void ERR_load_crypto_strings(void) { #ifndef OPENSSL_NO_ERR ERR_load_ERR_strings(); /* include error strings for SYSerr */ ERR_load_BN_strings(); # ifndef OPENSSL_NO_RSA ERR_load_RSA_strings(); # endif # ifndef OPENSSL_NO_DH ERR_load_DH_strings(); # endif ERR_load_EVP_strings(); ERR_load_BUF_strings(); ERR_load_OBJ_strings(); ERR_load_PEM_strings(); # ifndef OPENSSL_NO_DSA ERR_load_DSA_strings(); # endif ERR_load_X509_strings(); ERR_load_ASN1_strings(); ERR_load_CONF_strings(); ERR_load_CRYPTO_strings(); # ifndef OPENSSL_NO_COMP ERR_load_COMP_strings(); # endif # ifndef OPENSSL_NO_EC ERR_load_EC_strings(); # endif # ifndef OPENSSL_NO_ECDSA ERR_load_ECDSA_strings(); # endif # ifndef OPENSSL_NO_ECDH ERR_load_ECDH_strings(); # endif /* skip ERR_load_SSL_strings() because it is not in this library */ ERR_load_BIO_strings(); ERR_load_PKCS7_strings(); ERR_load_X509V3_strings(); ERR_load_PKCS12_strings(); ERR_load_RAND_strings(); ERR_load_DSO_strings(); // ERR_load_TS_strings(); # ifndef OPENSSL_NO_ENGINE ERR_load_ENGINE_strings(); # endif ERR_load_OCSP_strings(); ERR_load_UI_strings(); # ifdef OPENSSL_FIPS ERR_load_FIPS_strings(); # endif /* # ifndef OPENSSL_NO_CMS ERR_load_CMS_strings(); # endif */ # ifndef OPENSSL_NO_JPAKE ERR_load_JPAKE_strings(); # endif #endif }
void err_load_crypto_strings_intern(void) { #ifdef OPENSSL_FIPS FIPS_set_error_callbacks(ERR_put_error, ERR_add_error_vdata); #endif #ifndef OPENSSL_NO_ERR ERR_load_ERR_strings(); /* include error strings for SYSerr */ ERR_load_BN_strings(); # ifndef OPENSSL_NO_RSA ERR_load_RSA_strings(); # endif # ifndef OPENSSL_NO_DH ERR_load_DH_strings(); # endif ERR_load_EVP_strings(); ERR_load_BUF_strings(); ERR_load_OBJ_strings(); ERR_load_PEM_strings(); # ifndef OPENSSL_NO_DSA ERR_load_DSA_strings(); # endif ERR_load_X509_strings(); ERR_load_ASN1_strings(); ERR_load_CONF_strings(); ERR_load_CRYPTO_strings(); # ifndef OPENSSL_NO_COMP ERR_load_COMP_strings(); # endif # ifndef OPENSSL_NO_EC ERR_load_EC_strings(); # endif /* skip ERR_load_SSL_strings() because it is not in this library */ ERR_load_BIO_strings(); ERR_load_PKCS7_strings(); ERR_load_X509V3_strings(); ERR_load_PKCS12_strings(); ERR_load_RAND_strings(); ERR_load_DSO_strings(); # ifndef OPENSSL_NO_TS ERR_load_TS_strings(); # endif # ifndef OPENSSL_NO_ENGINE ERR_load_ENGINE_strings(); # endif ERR_load_OCSP_strings(); ERR_load_UI_strings(); # ifdef OPENSSL_FIPS ERR_load_FIPS_strings(); # endif # ifndef OPENSSL_NO_CMS ERR_load_CMS_strings(); # endif # ifndef OPENSSL_NO_CT ERR_load_CT_strings(); # endif ERR_load_ASYNC_strings(); #endif ERR_load_KDF_strings(); }
// init bool CryptographyEngine::init( void ) { /* Initialise the library */ ERR_load_CRYPTO_strings(); OpenSSL_add_all_algorithms(); OPENSSL_config( NULL ); return true; }
Global::Global() { SSL_library_init(); ERR_load_CRYPTO_strings(); SSL_load_error_strings(); OpenSSL_add_all_algorithms(); RAND_poll(); event_base = event_base_new(); dns_base = evdns_base_new(event_base, 1); };
Global::Global() { SSL_library_init(); ERR_load_CRYPTO_strings(); SSL_load_error_strings(); OpenSSL_add_all_algorithms(); RAND_poll(); #ifndef _NO_LIBEVENT_THREADS evthread_use_pthreads(); #endif event_base = event_base_new(); dns_base = evdns_base_new(event_base, 1); };
void ERR_load_crypto_strings(void) { static int done=0; if (done) return; done=1; #ifndef OPENSSL_NO_ERR ERR_load_ERR_strings(); /* include error strings for SYSerr */ ERR_load_BN_strings(); #ifndef OPENSSL_NO_RSA ERR_load_RSA_strings(); #endif #ifndef OPENSSL_NO_DH ERR_load_DH_strings(); #endif ERR_load_EVP_strings(); ERR_load_BUF_strings(); ERR_load_OBJ_strings(); ERR_load_PEM_strings(); #ifndef OPENSSL_NO_DSA ERR_load_DSA_strings(); #endif ERR_load_X509_strings(); ERR_load_ASN1_strings(); ERR_load_CONF_strings(); ERR_load_CRYPTO_strings(); #ifndef OPENSSL_NO_EC ERR_load_EC_strings(); #endif #ifndef OPENSSL_NO_ECDSA ERR_load_ECDSA_strings(); #endif #ifndef OPENSSL_NO_ECDH ERR_load_ECDH_strings(); #endif /* skip ERR_load_SSL_strings() because it is not in this library */ ERR_load_BIO_strings(); ERR_load_PKCS7_strings(); ERR_load_X509V3_strings(); ERR_load_PKCS12_strings(); ERR_load_RAND_strings(); ERR_load_DSO_strings(); #ifndef OPENSSL_NO_ENGINE ERR_load_ENGINE_strings(); #endif ERR_load_OCSP_strings(); ERR_load_UI_strings(); #endif }
void capi_read_key_Engine(EVP_PKEY** key, char* id, ENGINE *e, char* storename) { if(!ENGINE_ctrl(e, CAPI_CMD_STORE_NAME, 0, (void*)storename, NULL)) { ERR_load_CRYPTO_strings(); fprintf(stderr, "Executing CAPI_CMD_STORE_NAME did not succeed: %s\n", ERR_error_string(ERR_peek_last_error(), NULL)); ERR_free_strings(); exit(SCEP_PKISTATUS_ERROR); } //loading the key *key = ENGINE_load_private_key(e, id, NULL, NULL); if(!key) { printf("%s: Could not load key %s from storename %s\n", pname, id, storename); exit(SCEP_PKISTATUS_FILE); } //ENGINE_ctrl(e, CAPI_CMD_STORE_NAME, 0, (void*)"MY", NULL); }
void SWU_CryptoInit_PEM(char *configuration_dir, char *pem_file) { OpenSSL_add_all_digests(); ERR_load_CRYPTO_strings(); char pem_file_name[1024] = ""; strcat(pem_file_name, configuration_dir); strcat(pem_file_name, "/"); strcat(pem_file_name, pem_file); FILE *pubKeyFile = fopen(pem_file_name, "r"); if (pubKeyFile == NULL) { printf("Error: Can't open PEM file %s\n", pem_file); exit(1); } EVP_PKEY *gpPubKey = PEM_read_PUBKEY(pubKeyFile, NULL, NULL, NULL); _gpPubKey = gpPubKey; if (_gpPubKey == NULL) { printf("Error: Can't read PEM signature from file %s\n", pem_file); fclose(pubKeyFile); exit(1); } fclose(pubKeyFile); ERR_clear_error(); }
bool BaseSSLProtocol::Initialize(Variant ¶meters) { //1. Initialize the SSL library if (!_libraryInitialized) { //3. This is the first time we use the library. So we have to //initialize it first SSL_library_init(); //init readable error messages SSL_load_error_strings(); ERR_load_SSL_strings(); ERR_load_CRYPTO_strings(); ERR_load_crypto_strings(); OpenSSL_add_all_algorithms(); OpenSSL_add_all_ciphers(); OpenSSL_add_all_digests(); //initialize the random numbers generator InitRandGenerator(); _libraryInitialized = true; } //2. Initialize the global context if (!InitGlobalContext(parameters)) { FATAL("Unable to initialize global context"); return false; } //3. create connection SSL context _pSSL = SSL_new(_pGlobalSSLContext); if (_pSSL == NULL) { FATAL("Unable to create SSL connection context"); return false; } //4. setup the I/O buffers SSL_set_bio(_pSSL, BIO_new(BIO_s_mem()), BIO_new(BIO_s_mem())); return DoHandshake(); }
char *js_public_encrypt(const char *plain_text, const char *public_key_path) { RSA *rsa_publicKey = NULL; FILE *fp_publicKey; int rsa_public_len; if ((fp_publicKey = fopen(public_key_path, "r")) == NULL) { printf("Could not open %s\n", public_key_path); return '\0'; } if ((rsa_publicKey = PEM_read_RSA_PUBKEY(fp_publicKey, NULL, NULL, NULL)) == NULL) { fclose(fp_publicKey); printf("Error loading RSA Public Key File."); return '\0'; } fclose(fp_publicKey); rsa_public_len = RSA_size(rsa_publicKey); printf("RSA public length: %d\n", rsa_public_len); // 11 bytes is overhead required for encryption int chunk_length = rsa_public_len - 11; // plain text length int plain_char_len = (int)strlen(plain_text); // calculate the number of chunks int num_of_chunks = (int)(strlen(plain_text) / chunk_length) + 1; int total_cipher_length = 0; // the output size is (total number of chunks) x (the key length) int encrypted_size = (num_of_chunks * rsa_public_len); unsigned char *cipher_data = malloc(encrypted_size + 1); char *err = NULL; for (int i = 0; i < plain_char_len; i += chunk_length) { // get the remaining character count from the plain text int remaining_char_count = plain_char_len - i; // this len is the number of characters to encrypt, thus take the minimum between the chunk count & the remaining characters // this must less than rsa_public_len - 11 int len = JSMIN(remaining_char_count, chunk_length); unsigned char *plain_chunk = malloc(len + 1); // take out chunk of plain text memcpy(&plain_chunk[0], &plain_text[i], len); printf("Plain chunk: %s\n", plain_chunk); unsigned char *result_chunk = malloc(rsa_public_len + 1); int result_length = RSA_public_encrypt(len, plain_chunk, result_chunk, rsa_publicKey, RSA_PKCS1_PADDING); printf("Plain char len: %d\n", i); printf("Encrypted Result chunk: %s\nEncrypted Chunk length: %d\n", result_chunk, result_length); free(plain_chunk); if (result_length == -1) { ERR_load_CRYPTO_strings(); fprintf(stderr, "Error %s\n", ERR_error_string(ERR_get_error(), err)); fprintf(stderr, "Error %s\n", err); } memcpy(&cipher_data[total_cipher_length], &result_chunk[0], result_length); total_cipher_length += result_length; free(result_chunk); } printf("Total cipher length: %d\n", total_cipher_length); RSA_free(rsa_publicKey); size_t total_len = 0; char *encrypted = base64_encode(cipher_data, encrypted_size, &total_len); printf("Final result: %s\n Final result length: %zu\n", encrypted, total_len); free(cipher_data); return encrypted; }
char *js_public_decrypt(const char *cipher_text, const char *public_key_path) { RSA *rsa_publicKey = NULL; FILE *fp_publicKey; int rsa_public_len; if ((fp_publicKey = fopen(public_key_path, "r")) == NULL) { printf("Could not open %s\n", public_key_path); return '\0'; } if ((rsa_publicKey = PEM_read_RSA_PUBKEY(fp_publicKey, NULL, NULL, NULL)) == NULL) { fclose(fp_publicKey); printf("Error loading RSA Public Key File."); return '\0'; } fclose(fp_publicKey); printf("Cipher text: %s\n", cipher_text); rsa_public_len = RSA_size(rsa_publicKey); printf("RSA public length: %d\n", rsa_public_len); size_t crypt_len = 0; unsigned char *crypt = base64_decode(cipher_text, strlen(cipher_text), &crypt_len); printf("Decoded cipher: %s\nCrypt length: %ld\n", crypt, crypt_len); // If no static, it will cause "address of stack memory associated with local variable ...", which mean the variable will released from memory after the end of this function char *plain_char = malloc(crypt_len); // initialize strcpy(plain_char, ""); char *err = NULL; for (int i = 0; i < crypt_len; i += rsa_public_len) { unsigned char *crypt_chunk = malloc(rsa_public_len + 1); memcpy(&crypt_chunk[0], &crypt[i], rsa_public_len); printf("Crypt chunk: %s\n", crypt_chunk); unsigned char *result_chunk = malloc(crypt_len + 1); int result_length = RSA_public_decrypt(rsa_public_len, crypt_chunk, result_chunk, rsa_publicKey, RSA_PKCS1_PADDING); // chunk length should be the size of publickey (in bytes) minus 11 (overhead during encryption) printf("Result chunk: %s\nChunk length: %d\n", result_chunk, result_length); free(crypt_chunk); // this is to omit the dummy character behind // i.e. Result chunk: ABC-1234567-201308101427371250-abcdefghijklmnopqrstuv\240Z // Chunk length: 53 // New chunk: ABC-1234567-201308101427371250-abcdefghijklmnopqrstuv // // by copying the chunk to a temporary variable with an extra length (i.e. in this case is 54) // and then set the last character of temporary variable to NULL char tmp_result[result_length + 1]; memcpy(tmp_result, result_chunk, result_length); tmp_result[result_length] = '\0'; printf("New chunk: %s\n", tmp_result); free(result_chunk); if (result_length == -1) { ERR_load_CRYPTO_strings(); fprintf(stderr, "Error %s\n", ERR_error_string(ERR_get_error(), err)); fprintf(stderr, "Error %s\n", err); } strcat(plain_char, tmp_result); } RSA_free(rsa_publicKey); free(crypt); printf("Final result: %s\n", plain_char); return plain_char; }
int err_load_crypto_strings_int(void) { if ( #ifndef OPENSSL_NO_ERR ERR_load_ERR_strings() == 0 || /* include error strings for SYSerr */ ERR_load_BN_strings() == 0 || # ifndef OPENSSL_NO_RSA ERR_load_RSA_strings() == 0 || # endif # ifndef OPENSSL_NO_DH ERR_load_DH_strings() == 0 || # endif ERR_load_EVP_strings() == 0 || ERR_load_BUF_strings() == 0 || ERR_load_OBJ_strings() == 0 || ERR_load_PEM_strings() == 0 || # ifndef OPENSSL_NO_DSA ERR_load_DSA_strings() == 0 || # endif ERR_load_X509_strings() == 0 || ERR_load_ASN1_strings() == 0 || ERR_load_CONF_strings() == 0 || ERR_load_CRYPTO_strings() == 0 || # ifndef OPENSSL_NO_COMP ERR_load_COMP_strings() == 0 || # endif # ifndef OPENSSL_NO_EC ERR_load_EC_strings() == 0 || # endif /* skip ERR_load_SSL_strings() because it is not in this library */ ERR_load_BIO_strings() == 0 || ERR_load_PKCS7_strings() == 0 || ERR_load_X509V3_strings() == 0 || ERR_load_PKCS12_strings() == 0 || ERR_load_RAND_strings() == 0 || ERR_load_DSO_strings() == 0 || # ifndef OPENSSL_NO_TS ERR_load_TS_strings() == 0 || # endif # ifndef OPENSSL_NO_ENGINE ERR_load_ENGINE_strings() == 0 || # endif # ifndef OPENSSL_NO_OCSP ERR_load_OCSP_strings() == 0 || # endif #ifndef OPENSSL_NO_UI ERR_load_UI_strings() == 0 || #endif # ifndef OPENSSL_NO_CMS ERR_load_CMS_strings() == 0 || # endif # ifndef OPENSSL_NO_CT ERR_load_CT_strings() == 0 || # endif ERR_load_ASYNC_strings() == 0 || #endif ERR_load_KDF_strings() == 0 || ERR_load_OSSL_STORE_strings() == 0) return 0; return 1; }
int main(void) { EVP_CIPHER_CTX *ctx = NULL; unsigned char key[16]; unsigned char iv[12]; unsigned char tag[16]; unsigned char data[128]; unsigned char ori_msg[128]; unsigned char enc_msg[128+16]; unsigned char dec_msg[128]; int r, len, enc_msg_len, dec_msg_len; const EVP_CIPHER* cipher = NULL; ERR_load_CRYPTO_strings(); OPENSSL_add_all_algorithms_noconf(); r = RAND_bytes(key, sizeof(key)); assert(r == 1); r = RAND_bytes(iv, sizeof(iv)); assert(r == 1); r = RAND_pseudo_bytes(data, sizeof(data)); assert(r == 1); r = RAND_pseudo_bytes(ori_msg, sizeof(ori_msg)); assert(r == 1); r = RAND_pseudo_bytes(enc_msg, sizeof(enc_msg)); assert(r == 1); cipher = EVP_aes_128_gcm(); ctx = EVP_CIPHER_CTX_new(); assert(ctx); EVP_CIPHER_CTX_init(ctx); len = EVP_CIPHER_key_length(cipher); assert(len == sizeof(key)); len = EVP_CIPHER_iv_length(cipher); assert(len == sizeof(iv)); r = EVP_EncryptInit_ex(ctx, cipher, NULL, key, iv); assert(r == 1); r = EVP_EncryptUpdate(ctx, NULL, &enc_msg_len, data, sizeof(data)); assert(r == 1); r = EVP_EncryptUpdate(ctx, enc_msg, &enc_msg_len, ori_msg, sizeof(ori_msg)); assert(r == 1); assert(enc_msg_len == sizeof(ori_msg)); r = EVP_EncryptFinal_ex(ctx, enc_msg + enc_msg_len, &len); assert(r == 1); assert(len == 0); r = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_GET_TAG, sizeof(tag), tag); assert(r == 1); r = EVP_DecryptInit_ex(ctx, cipher, NULL, key, iv); assert(r == 1); r = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_TAG, sizeof(tag), tag); assert(r == 1); r = EVP_DecryptUpdate(ctx, NULL, &dec_msg_len, data, sizeof(data)); assert(r == 1); r = EVP_DecryptUpdate(ctx, dec_msg, &dec_msg_len, enc_msg, enc_msg_len); assert(r == 1); assert(dec_msg_len == enc_msg_len); r = EVP_DecryptFinal_ex(ctx, dec_msg + dec_msg_len, &len); assert(r == 1); assert(len == 0); assert(memcmp(ori_msg, dec_msg, dec_msg_len) == 0); EVP_CIPHER_CTX_free(ctx); puts("OK!"); return 0; }
/* * js private key encrypt */ char * js_private_encrypt(const char *plain_text,int * encode_len ,char *private_key) { RSA *rsa_privateKey = NULL; int rsa_private_len; int i; // private_key = rsa_key_seliaze(private_key_str); //BIO* p_bio = BIO_new_mem_buf(PRIVATE_KEY, -1); BIO* p_bio = BIO_new_mem_buf(private_key, -1); rsa_privateKey = PEM_read_bio_RSAPrivateKey(p_bio, NULL, 0, NULL); // if ( rsa_privateKey == NULL ) { printf("RSA is NULL\n"); return NULL; } rsa_private_len = RSA_size(rsa_privateKey); // printf("RSA private length: %d\n", rsa_private_len); // 11 bytes is overhead required for encryption int chunk_length = rsa_private_len - 11; // plain text length int plain_char_len = (int)strlen(plain_text); // calculate the number of chunks int num_of_chunks = (int)(strlen(plain_text) / chunk_length) + 1; int total_cipher_length = 0; // the output size is (total number of chunks) x (the key length) int encrypted_size = (num_of_chunks * rsa_private_len); unsigned char *cipher_data = malloc(encrypted_size + 1); char *err = NULL; for ( i = 0; i < plain_char_len; i += chunk_length) { // get the remaining character count from the plain text int remaining_char_count = plain_char_len - i; // this len is the number of characters to encrypt, thus take the minimum between the chunk count & the remaining characters // this must less than rsa_private_len - 11 int len = JSMIN(remaining_char_count, chunk_length); unsigned char *plain_chunk = malloc(len + 1); memset(plain_chunk,0,len + 1); // take out chunk of plain text memcpy(&plain_chunk[0], &plain_text[i], len); // printf("Plain chunk: %s\n", plain_chunk); unsigned char *result_chunk = malloc(rsa_private_len + 1); memset(result_chunk,0,rsa_private_len + 1); int result_length = RSA_private_encrypt(len, plain_chunk, result_chunk, rsa_privateKey, RSA_PKCS1_PADDING); // RSA_NO_PADDING RSA_PKCS1_PADDING // printf("Encrypted Result chunk: %s\nEncrypted Chunk length: %d\n", result_chunk, result_length); free(plain_chunk); if (result_length == -1) { ERR_load_CRYPTO_strings(); fprintf(stderr, "Error %s\n", ERR_error_string(ERR_get_error(), err)); fprintf(stderr, "Error %s\n", err); } memcpy(&cipher_data[total_cipher_length], &result_chunk[0], result_length); total_cipher_length += result_length; free(result_chunk); } //printf("Total cipher length: %d\n", total_cipher_length); RSA_free(rsa_privateKey); // size_t total_len = 0; // char *encrypted = base64_encode(cipher_data, encrypted_size, &total_len); // printf("Final result: %s\n Final result length: %zu\n", encrypted, total_len); *encode_len = encrypted_size; //free(cipher_data); return cipher_data; }
/* * js public decrypt */ char * js_public_decrypt(const char *cipher_text, int encode_len, char *public_key) { RSA *rsa_publicKey = NULL; int rsa_public_len; int i; //printf("js_public_decrypt public_key is %s \n",public_key); BIO* p_bio = BIO_new_mem_buf(public_key, -1); //BIO* p_bio = BIO_new_mem_buf(public_key, strlen(public_key)); // printf("rsa_encrypt is %p \n",p_bio); //rsa_publicKey = PEM_read_bio_RSAPublicKey(p_bio, NULL, NULL, NULL); //PEM_read_bio_RSAPrivateKey PEM_read_RSA_PUBKEY() //PEM_read_bio_RSAPublicKey(p_bio, &rsa_publicKey, 0, NULL); //PEM_read_bio_RSAPrivateKey PEM_read_RSA_PUBKEY() //printf("111\n"); PEM_read_bio_RSA_PUBKEY(p_bio, &rsa_publicKey, NULL, NULL); if ( rsa_publicKey == NULL ) { printf("RSA is NULL\n"); return NULL; } //printf("222\n"); // printf("Cipher text: %s\n", cipher_text); rsa_public_len = RSA_size(rsa_publicKey); //printf("RSA public length: %d\n", rsa_public_len); size_t crypt_len = (size_t)encode_len; char *crypt =(char *) cipher_text; // unsigned char *crypt = base64_decode(cipher_text, strlen(cipher_text), &crypt_len); // printf("Decoded cipher: %s\nCrypt length: %ld\n", crypt, crypt_len); // If no static, it will cause "address of stack memory associated with local variable ...", which mean the variable will released from memory after the end of this function char *plain_char = malloc(crypt_len); //printf("plain_char is %p,crypt_len is %ld",plain_char,(int)crypt_len); // initialize //printf("333\n"); strcpy(plain_char, ""); char *err = NULL; for ( i = 0; i < crypt_len; i += rsa_public_len) { unsigned char *crypt_chunk = malloc(rsa_public_len + 1); // printf("444\n"); memcpy(&crypt_chunk[0], &crypt[i], rsa_public_len); //printf("Crypt chunk: %s\n", crypt_chunk); unsigned char *result_chunk = malloc(crypt_len + 1); // printf("555\n"); int result_length = RSA_public_decrypt(rsa_public_len, crypt_chunk, result_chunk, rsa_publicKey, RSA_PKCS1_PADDING);//RSA_NO_PADDING RSA_PKCS1_PADDING // chunk length should be the size of publickey (in bytes) minus 11 (overhead during encryption) // printf("Result chunk: %s\nChunk length: %d\n", result_chunk, result_length); free(crypt_chunk); // this is to omit the dummy character behind // i.e. Result chunk: ABC-1234567-201308101427371250-abcdefghijklmnopqrstuv\240Z // Chunk length: 53 // New chunk: ABC-1234567-201308101427371250-abcdefghijklmnopqrstuv // // by copying the chunk to a temporary variable with an extra length (i.e. in this case is 54) // and then set the last character of temporary variable to NULL char tmp_result[result_length + 1]; //printf("666\n"); memcpy(tmp_result, result_chunk, result_length); tmp_result[result_length] = '\0'; //printf("New chunk: %s\n", tmp_result); free(result_chunk); if (result_length == -1) { ERR_load_CRYPTO_strings(); fprintf(stderr, "Error %s\n", ERR_error_string(ERR_get_error(), err)); fprintf(stderr, "Error %s\n", err); } strcat(plain_char, tmp_result); } //printf("777\n"); RSA_free(rsa_publicKey); //free(crypt); // printf("Final result: %s\n", plain_char); return plain_char; }
/* * js pubilc key encrypt */ char * js_public_encrypt(const char *plain_text,int * length, char *public_key) { RSA *rsa_publicKey = NULL; int rsa_public_len; int i; //public_key = rsa_key_seliaze(public_key_str); BIO* p_bio = BIO_new_mem_buf(public_key, -1); // printf("rsa_encrypt is %p \n",p_bio); //rsa_publicKey = PEM_read_bio_RSAPublicKey(p_bio, NULL, NULL, NULL); //PEM_read_bio_RSAPrivateKey PEM_read_bio_RSA_PUBKEY(p_bio, &rsa_publicKey, NULL, NULL); if ( rsa_publicKey == NULL ) { printf("RSA is NULL\n"); return NULL; } rsa_public_len = RSA_size(rsa_publicKey); // printf("RSA public length: %d\n", rsa_public_len); // 11 bytes is overhead required for encryption int chunk_length = rsa_public_len - 11; // plain text length int plain_char_len = (int)strlen(plain_text); // calculate the number of chunks int num_of_chunks = (int)(strlen(plain_text) / chunk_length) + 1; int total_cipher_length = 0; // the output size is (total number of chunks) x (the key length) int encrypted_size = (num_of_chunks * rsa_public_len); char *cipher_data = malloc(encrypted_size + 1); if (cipher_data) { memset(cipher_data,0,encrypted_size + 1); }else{ return NULL; } char *err = NULL; for ( i = 0; i < plain_char_len; i += chunk_length) { // get the remaining character count from the plain text int remaining_char_count = plain_char_len - i; // this len is the number of characters to encrypt, thus take the minimum between the chunk count & the remaining characters // this must less than rsa_public_len - 11 int len = JSMIN(remaining_char_count, chunk_length); unsigned char *plain_chunk = calloc(len + 1,1); memset(plain_chunk,0,len+1); // take out chunk of plain text memcpy(&plain_chunk[0], &plain_text[i], len); // printf("Plain chunk: %s\n", plain_chunk); unsigned char *result_chunk = calloc(rsa_public_len + 1,1); memset(result_chunk,0,rsa_public_len + 1); int result_length = RSA_public_encrypt(len, plain_chunk,result_chunk, rsa_publicKey, RSA_PKCS1_PADDING); // printf("Plain char len: %d\n", i); // printf("\n\n%ld,鍔犲瘑鍓嶆暟鎹�s \n", strlen((char *)plain_chunk), plain_chunk); // printf("\鍔犲瘑缁撴灉闀垮害: %d\n", result_length); // printf("*********%d*****************\n", strlen(result_chunk)); free(plain_chunk); if (result_length == -1) { ERR_load_CRYPTO_strings(); fprintf(stderr, "Error %s\n", ERR_error_string(ERR_get_error(), err)); fprintf(stderr, "Error %s\n", err); break; } memcpy(&cipher_data[total_cipher_length], &result_chunk[0], result_length); // strcat(cipher_data, (const char *)result_chunk); total_cipher_length += result_length; free(result_chunk); } // printf("\n 鍔犲瘑鎬婚暱搴�d\n", total_cipher_length); cipher_data[total_cipher_length] = '\0'; *length = encrypted_size; //printf("\n鍔犲瘑杩斿洖缁撴灉闀垮害%d\n", strlen(cipher_data)); RSA_free(rsa_publicKey); return cipher_data; }