修改：统一异常处理为try-catch

Author: IteratorGIT

devapi/abe/abe_crypto.cc

@@ -16,85 +16,75 @@ namespace mysqlx{
 MYSQLX_ABI_BEGIN(2,0)
 namespace abe{
 
-bool abe_crypto::encrypt(std::string pt, std::string policy, std::string &ct){
+void abe_crypto::encrypt(std::string pt, std::string policy, std::string &ct){
 
   oabe::InitializeOpenABE();
   oabe::OpenABECryptoContext cpabe("CP-ABE");
   cpabe.importPublicParams(mpk);
   cpabe.encrypt(policy.c_str(), pt, ct);
   oabe::ShutdownOpenABE();
-  
-//   std::cout<<"encrypt succefully!"<<std::endl;
-  return true;
 }
 
-bool abe_crypto::decrypt(const std::string ct, std::string &pt){
+void abe_crypto::decrypt(const std::string ct, std::string &pt){
 
   if(!check_abe_key()){
-    return false;
+    ABE_ERROR("no abe key!");
   }
 
   oabe::InitializeOpenABE();
   oabe::OpenABECryptoContext cpabe("CP-ABE");
   cpabe.importPublicParams(mpk);
   cpabe.importUserKey(user.user_id.c_str(), user.user_key);
   if(!cpabe.decrypt(user.user_id.c_str(), ct, pt)){
-    pt = "can't decrypt.";
+    oabe::ShutdownOpenABE();
+    ABE_ERROR("abe: can't decrypt.");
   }
-//   std::cout << "Recovered message: " << pt << std::endl;
   oabe::ShutdownOpenABE();
-  
-  return true;
 }
 
 bool abe_crypto::check_abe_key(){
     if(user.user_key == ""){
-        ABE_ERROR("there is no abe_key, please run:\n\tshow current_abe_key;\nto get from database");
         return false;
     }
     return true;
 }
 
 
-bool abe_crypto::init(std::string mpk_path, std::string key_path, 
+void abe_crypto::init(std::string mpk_path, std::string key_path, 
                         std::string kms_cert_path, std::string db_cert_path,
                         std::string rsa_sk_path){
-    if(!(import_mpk(mpk_path) 
-        && import_db_cert(db_cert_path) && import_kms_cert(kms_cert_path)
-        && import_sk(rsa_sk_path))){
-        return false;
-    }
+    import_mpk(mpk_path);
+    import_db_cert(db_cert_path);
+    import_kms_cert(kms_cert_path);
+    import_sk(rsa_sk_path);
     if(!import_user_key(key_path)){ //abe_user_key可以之后获取
         user.user_key = "";
     }
-    return true;
 }
 
-bool abe_crypto::import_mpk(std::string mpk_path){
+void abe_crypto::import_mpk(std::string mpk_path){
     //读入mpk
     std::ifstream ifs_mpk(mpk_path, std::ios::in);
     if(!ifs_mpk){
+        ifs_mpk.close();
         ABE_ERROR2("error opening security pameter (mpk) file.\nmpk_path=", mpk_path);
-        return false;
     }
     ifs_mpk>>mpk;
     ifs_mpk.close();
-    return true;
 }
 
 bool abe_crypto::import_user_key(std::string key_path){
     //读入abe_user_key
     std::ifstream ifs_key(key_path, std::ios::in);
     if(!ifs_key){
-        ABE_ERROR("there is no abe_key, please run:\n\tshow current_abe_key;\nto get from database");
         return false;
     }
     ifs_key>>user.user_key;
     ifs_key.close();
     return true;
 }
 
-bool abe_crypto::save_user_key(std::string key_path, std::string key_str_b64){
+void abe_crypto::save_user_key(std::string key_path, std::string key_str_b64){
     std::string pt;
 
     //key_str为base64编码
@@ -107,32 +97,25 @@ bool abe_crypto::save_user_key(std::string key_path, std::string key_str_b64){
     if(!rsa_decrypt(ct, pt)){
         free(key_str);
         ABE_ERROR("failed to decrypt abe user key");
-        return false;
     }
     free(key_str);
 
-    if(pt == ""){
-        return false;
-    }
     //写入abe_user_key
     std::ofstream ofs_key(key_path, std::ios::out);
     if(!ofs_key){
         ABE_ERROR2("error opening user key-file.\nkey_path=" , key_path);
-        return false;
     }
     ofs_key << pt;
     user.user_key = pt;
     ofs_key.close();
-    return true;
 }
 
-bool abe_crypto::import_sk(std::string rsa_sk_path){
+void abe_crypto::import_sk(std::string rsa_sk_path){
     // 导入rsa密钥文件并读取密钥
     FILE *hPriKeyFile = fopen(rsa_sk_path.c_str(), "rb");
     if (hPriKeyFile == NULL)
     {
-        // assert(false);
-        return false;
+        ABE_ERROR2("read file failed, file_path=", rsa_sk_path);
     }
     std::string strRet;
     RSA *pRSAPriKey = RSA_new();
@@ -141,11 +124,10 @@ bool abe_crypto::import_sk(std::string rsa_sk_path){
         // assert(false);
         RSA_free(pRSAPriKey);
         fclose(hPriKeyFile);
-        return false;
+        ABE_ERROR2("read rsa prikey failed, file_path=", rsa_sk_path);
     }
     sk = pRSAPriKey;
     fclose(hPriKeyFile);
-    return true;
 }
 
 RSA * abe_crypto::import_pk(const std::string cert_path, std::string &err_msg){
@@ -184,28 +166,24 @@ RSA * abe_crypto::import_pk(const std::string cert_path, std::string &err_msg){
     return pk;
 }
 
-bool abe_crypto::import_db_cert(std::string db_cert_path){
+void abe_crypto::import_db_cert(std::string db_cert_path){
     std::string err_msg;
     RSA *pk = import_pk(db_cert_path, err_msg);
     if(pk == NULL){
         err_msg += ":" + db_cert_path;
-        ABE_ERROR(err_msg);
-        return false;
+        ABE_ERROR(err_msg.c_str());
     }
     db_pk = pk;
-    return true;
 }
 
-bool abe_crypto::import_kms_cert(std::string kms_cert_path){
+void abe_crypto::import_kms_cert(std::string kms_cert_path){
     std::string err_msg;
     RSA *pk = import_pk(kms_cert_path, err_msg);
     if(pk == NULL){
         err_msg += ":" + kms_cert_path;
-        ABE_ERROR(err_msg);
-        return false;
+        ABE_ERROR(err_msg.c_str());
     }
     kms_pk = pk;
-    return true;
 }
 
 abe_crypto::~abe_crypto(){
@@ -214,43 +192,41 @@ abe_crypto::~abe_crypto(){
     if(sk != NULL)  RSA_free(sk);
 }
 
-bool abe_crypto::verify_sig(RSA *pk, unsigned char * msg, size_t msg_length, unsigned char * sig, size_t sig_length){
+void abe_crypto::verify_sig(RSA *pk, unsigned char * msg, size_t msg_length, unsigned char * sig, size_t sig_length){
     unsigned char digest[SHA512_DIGEST_LENGTH];
     // 对输入进行hash
     SHA512(msg, msg_length, digest);
 
     // 对签名进行认证
     int ret = RSA_verify(NID_sha512, digest, SHA512_DIGEST_LENGTH, sig, sig_length, pk);
     if (ret != 1){
-        ABE_ERROR("verify error");
         unsigned long ulErr = ERR_get_error();
         char szErrMsg[1024] = {0};
-        ABE_ERROR2("error number:" , ulErr);
         ERR_error_string(ulErr, szErrMsg); // 格式：error:errId:库:函数:原因
-        std::cout << szErrMsg << std::endl;
-        return false;
+        ABE_ERROR2("abe_key verify error: ", szErrMsg);
     }
-    return true;
 
 }
 
-bool abe_crypto::verify_db_sig(const std::string msg, const std::string sig_b64){
+void abe_crypto::verify_db_sig(const std::string msg, const std::string sig_b64){
     //sig是base64编码，需要先解码
     size_t sig_b64_length = sig_b64.length();
     unsigned char * sig = (unsigned char*)malloc(base64_utils::b64_dec_len(sig_b64_length));
     size_t sig_length = base64_utils::b64_decode(sig_b64.c_str(), sig_b64_length, (char*)sig);
 
-    if(!verify_sig(db_pk, (unsigned char *)msg.c_str(), msg.length(), sig, sig_length)){
+    try{
+        verify_sig(db_pk, (unsigned char *)msg.c_str(), msg.length(), sig, sig_length);
         free(sig);
-        ABE_ERROR("db_sig: verify failed");
-        return false;
+    }catch(const ::mysqlx::abe::Error& e){
+        free(sig);
+        ABE_ERROR2("db_sig:", e.what());
+    }catch(...){
+        free(sig);
+        ABE_ERROR("nknown exception");
     }
-    ABE_LOG("db_sig: verify success");
-    free(sig);
-    return true;
 }
 
-bool abe_crypto::verify_kms_sig(const std::string msg_b64, const std::string sig_b64){
+void abe_crypto::verify_kms_sig(const std::string msg_b64, const std::string sig_b64){
 
     //msg和sig都是base64编码，需要先解码
     size_t msg_b64_length = msg_b64.length();
@@ -261,17 +237,19 @@ bool abe_crypto::verify_kms_sig(const std::string msg_b64, const std::string sig
     unsigned char * sig = (unsigned char*)malloc(base64_utils::b64_dec_len(sig_b64_length));
     size_t sig_length = base64_utils::b64_decode(sig_b64.c_str(), sig_b64_length, (char*)sig);
 
-    if(!verify_sig(kms_pk, msg, msg_length, sig, sig_length)){
+    try{
+        verify_sig(kms_pk, msg, msg_length, sig, sig_length);
         free(msg);
         free(sig);
-        ABE_ERROR("kms_sig: verify failed");
-        return false;
+    }catch(const ::mysqlx::abe::Error& e){
+        free(msg);
+        free(sig);
+        ABE_ERROR2("kms_sig:", e.what());
+    }catch(...){
+        free(msg);
+        free(sig);
+        ABE_ERROR("nknown exception");
     }
-    
-    ABE_LOG("kms_sig: verify success");
-    free(msg);
-    free(sig);
-    return true;
 }
 
 //注意ct初始化时必须指定长度，否则ct.length会因为0x00而截断