diff --git a/rustwallet.h b/rustwallet.h
index 8fdd151..8dfba10 100644
--- a/rustwallet.h
+++ b/rustwallet.h
@@ -57,3 +57,5 @@ char *rsa_key_pair(void);
 char *rsa_encrypt(const char *content, const char *p_key);
 
 char *rsa_decrypt(const char *content, const char *s_key);
+
+void free_cstr(char *s);
diff --git a/src/lib.rs b/src/lib.rs
index e3d7f6c..64d94cc 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -25,16 +25,22 @@ use utils::str_utils::{base64_to_hex, hex_to_base64};
 // mod android;
 macro_rules! cchar_to_str {
     ($p1:expr) => {{
-        let s = CStr::from_ptr($p1);
-        let ps = s.to_str().unwrap();
+        let s = unsafe {CStr::from_ptr($p1)};
+        let ps = match s.to_str(){
+            Err(err) => panic!("Problem convert c_char to string: {:?}", err),
+            Ok(string) => string,
+        };
         ps
     }};
 }
 
 macro_rules! cchar_to_string {
     ($p1:expr) => {{
-        let s = CStr::from_ptr($p1);
-        let ps = s.to_str().unwrap();
+        let s = unsafe {CStr::from_ptr($p1)};
+        let ps = match s.to_str() {
+            Err(err) => panic!("Problem convert c_char to string: {:?}", err),
+            Ok(string) => string,
+        };
         ps.to_string()
     }};
 }
@@ -42,13 +48,12 @@ macro_rules! cchar_to_string {
 macro_rules! str_to_cchar {
     ($p1:expr) => {{
         let msgkey = CString::new($p1).unwrap();
-        let c_msgkey: *mut c_char = msgkey.into_raw();
-        c_msgkey
+        msgkey.into_raw()
     }};
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn get_address(
+pub extern "C" fn get_address(
     msg_key: *const c_char,
     master_key: *const c_char,
     second_key: *const c_char,
@@ -61,7 +66,7 @@ pub unsafe extern "C" fn get_address(
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn get_public_key(
+pub extern "C" fn get_public_key(
     msg_key: *const c_char,
     master_key: *const c_char,
     second_key: *const c_char,
@@ -73,7 +78,7 @@ pub unsafe extern "C" fn get_public_key(
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn generate_sec_key(
+pub extern "C" fn generate_sec_key(
     msg_key: *const c_char,
     master_key: *const c_char,
     second_key: *const c_char,
@@ -85,7 +90,7 @@ pub unsafe extern "C" fn generate_sec_key(
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn sign(
+pub extern "C" fn sign(
     msg_key: *const c_char,
     master_key: *const c_char,
     second_key: *const c_char,
@@ -102,7 +107,7 @@ pub unsafe extern "C" fn sign(
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn sign_for_tran(
+pub extern "C" fn sign_for_tran(
     msg_key: *const c_char,
     master_key: *const c_char,
     second_key: *const c_char,
@@ -121,7 +126,7 @@ pub unsafe extern "C" fn sign_for_tran(
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn rencrypt(pk: *const c_char, msg: *const c_char) -> *mut c_char {
+pub extern "C" fn rencrypt(pk: *const c_char, msg: *const c_char) -> *mut c_char {
     let msg_str = cchar_to_str!(msg);
     let pk_str = cchar_to_str!(pk);
     let public_key = match PublicKey::from_str(pk_str) {
@@ -136,7 +141,7 @@ pub unsafe extern "C" fn rencrypt(pk: *const c_char, msg: *const c_char) -> *mut
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn rdecrypt(sk: *const c_char, msg: *const c_char) -> *mut c_char {
+pub extern "C" fn rdecrypt(sk: *const c_char, msg: *const c_char) -> *mut c_char {
     let msg_str = cchar_to_str!(msg);
     let sk_str = cchar_to_str!(sk);
     let private_key = match SecretKey::from_str(sk_str) {
@@ -151,7 +156,7 @@ pub unsafe extern "C" fn rdecrypt(sk: *const c_char, msg: *const c_char) -> *mut
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn wallet_encrypt(
+pub extern "C" fn wallet_encrypt(
     msg_key: *const c_char,
     master_key: *const c_char,
     second_key: *const c_char,
@@ -168,7 +173,7 @@ pub unsafe extern "C" fn wallet_encrypt(
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn wallet_decrypt(
+pub extern "C" fn wallet_decrypt(
     msg_key: *const c_char,
     master_key: *const c_char,
     second_key: *const c_char,
@@ -185,34 +190,34 @@ pub unsafe extern "C" fn wallet_decrypt(
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn hex_deflate(content: *const c_char) -> *mut c_char {
+pub extern "C" fn hex_deflate(content: *const c_char) -> *mut c_char {
     let content_str = cchar_to_str!(content);
     let msg_base64 = hex_to_base64(&content_str);
     str_to_cchar!(msg_base64)
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn hex_inflate(content: *const c_char) -> *mut c_char {
+pub extern "C" fn hex_inflate(content: *const c_char) -> *mut c_char {
     let content_str = cchar_to_str!(content);
     let msg_hex = base64_to_hex(&content_str);
     str_to_cchar!(msg_hex)
 }
 // hash pasword of email register
 #[no_mangle]
-pub unsafe extern "C" fn hash_pass_svr(content: *const c_char) -> *mut c_char {
+pub extern "C" fn hash_pass_svr(content: *const c_char) -> *mut c_char {
     let content_str = cchar_to_str!(content);
     let msg_hex = utils::crypto_utils::hash_pass_svr(&content_str);
     str_to_cchar!(msg_hex)
 }
 #[no_mangle]
-pub unsafe extern "C" fn keccak256_hash(content: *const c_char) -> *mut c_char {
+pub extern "C" fn keccak256_hash(content: *const c_char) -> *mut c_char {
     let content_str = cchar_to_str!(content);
     let msg_hex = utils::crypto_utils::keccak256_hash(&content_str);
     str_to_cchar!(msg_hex)
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn aes_encrypt(content: *const c_char, key: *const c_char) -> *mut c_char {
+pub extern "C" fn aes_encrypt(content: *const c_char, key: *const c_char) -> *mut c_char {
     let content_str = cchar_to_str!(content);
     let pass = cchar_to_str!(key);
     let pass = utils::crypto_utils::keccak256_hash(pass);
@@ -221,7 +226,7 @@ pub unsafe extern "C" fn aes_encrypt(content: *const c_char, key: *const c_char)
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn aes_decrypt(content: *const c_char, key: *const c_char) -> *mut c_char {
+pub extern "C" fn aes_decrypt(content: *const c_char, key: *const c_char) -> *mut c_char {
     let content_str = cchar_to_str!(content);
     let pass = cchar_to_str!(key);
     let pass = utils::crypto_utils::keccak256_hash(pass);
@@ -230,13 +235,13 @@ pub unsafe extern "C" fn aes_decrypt(content: *const c_char, key: *const c_char)
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn local_pass_hasher(password: *const c_char) -> *mut c_char {
+pub extern "C" fn local_pass_hasher(password: *const c_char) -> *mut c_char {
     let result = wallet_impl::local_pass_hasher(cchar_to_str!(password));
     str_to_cchar!(result)
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn verify_local_pass(
+pub extern "C" fn verify_local_pass(
     password: *const c_char,
     pass_hash: *const c_char,
 ) -> bool {
@@ -244,7 +249,7 @@ pub unsafe extern "C" fn verify_local_pass(
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn generate_client_key(
+pub extern "C" fn generate_client_key(
     password: *const c_char,
     openid: *const c_char,
     salt: *const c_char,
@@ -258,7 +263,7 @@ pub unsafe extern "C" fn generate_client_key(
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn simple_sign(content: *const c_char, key: *const c_char) -> *mut c_char {
+pub extern "C" fn simple_sign(content: *const c_char, key: *const c_char) -> *mut c_char {
     let result = wallet_impl::simple_sign(cchar_to_str!(content), cchar_to_str!(key));
     let r = match result {
         Ok(v) => v,
@@ -268,7 +273,7 @@ pub unsafe extern "C" fn simple_sign(content: *const c_char, key: *const c_char)
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn ramdonKey() -> *mut c_char {
+pub extern "C" fn ramdonKey() -> *mut c_char {
     let (s_key, _p_key) = wallet_impl::generate_keypair();
     let s_key = hex::encode(&s_key.secret_bytes());
     let cs_key = CString::new(s_key).unwrap();
@@ -276,13 +281,13 @@ pub unsafe extern "C" fn ramdonKey() -> *mut c_char {
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn rsa_key_pair() -> *mut c_char {
+pub extern "C" fn rsa_key_pair() -> *mut c_char {
     let key_str = general_rsa_keystr();
     return str_to_cchar!(key_str);
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn rsa_encrypt(content: *const c_char, p_key: *const c_char) -> *mut c_char {
+pub extern "C" fn rsa_encrypt(content: *const c_char, p_key: *const c_char) -> *mut c_char {
     let content_str = cchar_to_str!(content);
     let p_key_str = cchar_to_str!(p_key);
     let msg_encrypt = utils::crypto_utils::rsa_encrypt(content_str, p_key_str);
@@ -290,14 +295,22 @@ pub unsafe extern "C" fn rsa_encrypt(content: *const c_char, p_key: *const c_cha
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn rsa_decrypt(content: *const c_char, s_key: *const c_char) -> *mut c_char {
+pub extern "C" fn rsa_decrypt(content: *const c_char, s_key: *const c_char) -> *mut c_char {
     let content_str = cchar_to_str!(content);
     let s_key_str = cchar_to_str!(s_key);
     let msg_decrypt = utils::crypto_utils::rsa_decrypt(content_str, s_key_str);
     str_to_cchar!(msg_decrypt)
 }
 
-unsafe fn generate_rwallet(
+#[no_mangle]
+pub extern fn free_cstr(s: *mut c_char) {
+    unsafe {
+        if s.is_null() { return }
+        CString::from_raw(s)
+    };
+}
+
+fn generate_rwallet(
     msg_key: *const c_char,
     master_key: *const c_char,
     second_key: *const c_char,