bool hostupdate_h(connection_t *c) { /* FIXME: Whoah! Even more!! */ char rawfile[MAX_STRING_SIZE]; char rawhost[MAX_STRING_SIZE], b64host[MAX_STRING_SIZE]; char rawdgst[MAX_STRING_SIZE], b64dgst[MAX_STRING_SIZE]; char updname[MAX_STRING_SIZE], hosttoupd[MAX_STRING_SIZE]; char *fname; FILE *fp; size_t slen, dlen, rlen; RSA *updkey; /* We ignore host files updates, maybe for reason */ if (ignorenetupdates() || ignorehostsupdates()) return true; /* handle received host data, check sign, (over)write on disk */ if (sscanf(c->buffer, "%*d " MAX_STRING " " MAX_STRING " " MAX_STRING " %zd %zd " MAX_STRING, updname, hosttoupd, b64host, &slen, &dlen, b64dgst) != 6) { logger(LOG_ERR, "Got bad %s from %s (%s)", "HOSTUPDATE", c->name, c->hostname); return false; } /* verify the originating node is permitted to send updates */ if (dontverifyupdatepermission()) goto _next; if(!getconf_bool_node_offline(updname, "HostsFilesMaster")) { ifdebug(PROTOCOL) logger(LOG_WARNING, "Ignoring hosts update request originating from %s [which came from %s (%s)]", updname, c->name, c->hostname); return true; } /* some other sanity checks */ _next: if (!isvalidfname(updname)) { logger(LOG_ERR, "Got bogus updater name \"%s\" from %s (%s) (from: %s)", updname, c->name, c->hostname, updname); return false; } if (!isvalidfname(hosttoupd)) { logger(LOG_ERR, "Got bogus update name \"%s\" from %s (%s) (from: %s)", hosttoupd, c->name, c->hostname, updname); return false; } if (slen >= MAX_STRING_SIZE || dlen >= MAX_STRING_SIZE) { logger(LOG_ERR, "HOSTUPDATE string sizes for %s are bigger than buffer can fit (%zd, %zd)", hosttoupd, slen, dlen); return false; } /* verify it */ if (dontverifyupdatesignature()) goto _out; if (!read_rsa_public_key_offline(updname, &updkey)) { logger(LOG_ERR, "Could not find public key for %s", updname); return true; } base64_decode(b64dgst, rawdgst, sizeof(rawdgst)-1); snprintf(rawhost, sizeof(rawhost), "%s %s %s %zd %zd", updname, hosttoupd, b64host, slen, dlen); rlen = strlen(rawhost); if (!EVP_verify(updkey, rawdgst, dlen, rawhost, rlen)) { logger(LOG_WARNING, "Ignoring hosts update request with bad signature from %s for %s" " [which came from %s (%s)]", updname, hosttoupd, c->name, c->hostname); RSA_free(updkey); return true; } RSA_free(updkey); /* neighbours return us our own packets */ _out: if (!strcmp(updname, myself->name)) return true; /* All right, let's start updating */ xasprintf(&fname, "%s/hosts/%s", confbase, hosttoupd); /* Tell others if needed */ if (!dontforwardhostsupdates()) { exceptmasters = true; forward_request(c); } /* Check if it's a START marker */ if (!strcmp(updname, hosttoupd) && !strcmp(b64host, "START")) { /* Run pre-update script (embedded devices do remount,rw fs for example) We really need to run this once, so that's why there are START and END markers */ run_script("hostsupdate-before"); /* That's it folks! Waiting for files to arrive */ free(fname); return true; } /* Check if it's a END marker */ else if (!strcmp(updname, hosttoupd) && !strcmp(b64host, "END")) { /* Run post-update script (embedded devices do remount,ro fs for example) */ run_script("hostsupdate-after"); /* Schedule config/host reload */ schedulereload(); /* That's it folks! */ free(fname); return true; } /* Remove unneeded hosts */ else if (!strcmp(b64host, "DEAD")) { unlink(fname); /* That's it, waiting for other next request */ free(fname); return true; } /* We need this early for next test */ base64_decode(b64host, rawhost, sizeof(rawhost)-1); /* * Via broadcasting host files one hosts file master can become config file master. * Reject such a claims even if they're authentic. */ if (dontverifyupdatepermission()) goto _write; if(!getconf_bool_node_offline(updname, "ConfFileMaster") && strcasestr_local(rawhost, "ConfFileMaster")) { logger(LOG_WARNING, "Ignoring %s which tried to raise privileges for %s to ConfFileMaster!", updname, hosttoupd); goto _end; } /* Finally write it to disk */ _write: fp = fopen(fname, "w"); if (!fp) { logger(LOG_ERR, "Unable to write new host file: %s (%s)", fname, strerror(errno)); free(fname); return true; } #ifdef HAVE_FCHMOD fchmod(fileno(fp), 0640); #endif fwrite(rawhost, slen, 1, fp); fclose(fp); _end: free(fname); return true; }
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) { 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 = strlen(plain_text); // calculate the number of chunks int num_of_chunks = (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) { // take out chunk of plain text unsigned char *plain_chunk = malloc(chunk_length + 1); memcpy(&plain_chunk[0], &plain_text[i], chunk_length); printf("Plain chunk: %s\n", plain_chunk); unsigned char *result_chunk = malloc(rsa_public_len + 1); int result_length = RSA_public_encrypt(chunk_length, plain_chunk, result_chunk, rsa_publicKey, RSA_PKCS1_PADDING); printf("Encrypted Result chunk: %s\nEncrypted Chunk length: %d\n", result_chunk, result_length); 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; } 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); return encrypted; }
RSA_Helper::~RSA_Helper(){ if(key){ RSA_free(key); CRYPTO_cleanup_all_ex_data(); } }
static void int_rsa_free(EVP_PKEY *pkey) { RSA_free(pkey->pkey.rsa); }
/* * Generate key */ static int westcos_pkcs15init_generate_key(sc_profile_t *profile, sc_pkcs15_card_t *p15card, sc_pkcs15_object_t *obj, sc_pkcs15_pubkey_t *pubkey) { #ifndef ENABLE_OPENSSL return SC_ERROR_NOT_SUPPORTED; #else int r = SC_ERROR_UNKNOWN; long lg; u8 *p; sc_pkcs15_prkey_info_t *key_info = (sc_pkcs15_prkey_info_t *) obj->data; RSA *rsa = NULL; BIGNUM *bn = NULL; BIO *mem = NULL; sc_file_t *prkf = NULL; if (obj->type != SC_PKCS15_TYPE_PRKEY_RSA) { return SC_ERROR_NOT_SUPPORTED; } #if OPENSSL_VERSION_NUMBER>=0x00908000L rsa = RSA_new(); bn = BN_new(); mem = BIO_new(BIO_s_mem()); if(rsa == NULL || bn == NULL || mem == NULL) { r = SC_ERROR_OUT_OF_MEMORY; goto out; } if(!BN_set_word(bn, RSA_F4) || !RSA_generate_key_ex(rsa, key_info->modulus_length, bn, NULL)) #else mem = BIO_new(BIO_s_mem()); if(mem == NULL) { r = SC_ERROR_OUT_OF_MEMORY; goto out; } rsa = RSA_generate_key(key_info->modulus_length, RSA_F4, NULL, NULL); if (!rsa) #endif { r = SC_ERROR_UNKNOWN; goto out; } RSA_set_method(rsa, RSA_PKCS1_OpenSSL()); if(pubkey != NULL) { if(!i2d_RSAPublicKey_bio(mem, rsa)) { r = SC_ERROR_UNKNOWN; goto out; } lg = BIO_get_mem_data(mem, &p); pubkey->algorithm = SC_ALGORITHM_RSA; r = sc_pkcs15_decode_pubkey(p15card->card->ctx, pubkey, p, lg); if (r < 0) goto out; } (void) BIO_reset(mem); if(!i2d_RSAPrivateKey_bio(mem, rsa)) { r = SC_ERROR_UNKNOWN; goto out; } lg = BIO_get_mem_data(mem, &p); /* Get the private key file */ r = sc_profile_get_file_by_path(profile, &key_info->path, &prkf); if (r < 0) { char pbuf[SC_MAX_PATH_STRING_SIZE]; r = sc_path_print(pbuf, sizeof(pbuf), &key_info->path); if (r != SC_SUCCESS) pbuf[0] = '\0'; goto out; } prkf->size = lg; r = sc_pkcs15init_create_file(profile, p15card, prkf); if(r) goto out; r = sc_pkcs15init_update_file(profile, p15card, prkf, p, lg); if(r) goto out; out: if(mem) BIO_free(mem); if(bn) BN_free(bn); if(rsa) RSA_free(rsa); sc_file_free(prkf); return r; #endif }
static isc_result_t opensslrsa_todns(const dst_key_t *key, isc_buffer_t *data) { isc_region_t r; unsigned int e_bytes; unsigned int mod_bytes; isc_result_t ret; RSA *rsa; #if USE_EVP EVP_PKEY *pkey; #endif #if USE_EVP REQUIRE(key->keydata.pkey != NULL); #else REQUIRE(key->keydata.rsa != NULL); #endif #if USE_EVP pkey = key->keydata.pkey; rsa = EVP_PKEY_get1_RSA(pkey); if (rsa == NULL) return (dst__openssl_toresult(DST_R_OPENSSLFAILURE)); #else rsa = key->keydata.rsa; #endif isc_buffer_availableregion(data, &r); e_bytes = BN_num_bytes(rsa->e); mod_bytes = BN_num_bytes(rsa->n); if (e_bytes < 256) { /*%< key exponent is <= 2040 bits */ if (r.length < 1) DST_RET(ISC_R_NOSPACE); isc_buffer_putuint8(data, (isc_uint8_t) e_bytes); isc_region_consume(&r, 1); } else { if (r.length < 3) DST_RET(ISC_R_NOSPACE); isc_buffer_putuint8(data, 0); isc_buffer_putuint16(data, (isc_uint16_t) e_bytes); isc_region_consume(&r, 3); } if (r.length < e_bytes + mod_bytes) DST_RET(ISC_R_NOSPACE); BN_bn2bin(rsa->e, r.base); isc_region_consume(&r, e_bytes); BN_bn2bin(rsa->n, r.base); isc_buffer_add(data, e_bytes + mod_bytes); ret = ISC_R_SUCCESS; err: #if USE_EVP if (rsa != NULL) RSA_free(rsa); #endif return (ret); }
static isc_result_t opensslrsa_tofile(const dst_key_t *key, const char *directory) { int i; RSA *rsa; dst_private_t priv; unsigned char *bufs[8]; isc_result_t result; #if USE_EVP if (key->keydata.pkey == NULL) return (DST_R_NULLKEY); rsa = EVP_PKEY_get1_RSA(key->keydata.pkey); if (rsa == NULL) return (dst__openssl_toresult(DST_R_OPENSSLFAILURE)); #else if (key->keydata.rsa == NULL) return (DST_R_NULLKEY); rsa = key->keydata.rsa; #endif for (i = 0; i < 8; i++) { bufs[i] = isc_mem_get(key->mctx, BN_num_bytes(rsa->n)); if (bufs[i] == NULL) { result = ISC_R_NOMEMORY; goto fail; } } i = 0; priv.elements[i].tag = TAG_RSA_MODULUS; priv.elements[i].length = BN_num_bytes(rsa->n); BN_bn2bin(rsa->n, bufs[i]); priv.elements[i].data = bufs[i]; i++; priv.elements[i].tag = TAG_RSA_PUBLICEXPONENT; priv.elements[i].length = BN_num_bytes(rsa->e); BN_bn2bin(rsa->e, bufs[i]); priv.elements[i].data = bufs[i]; i++; if (rsa->d != NULL) { priv.elements[i].tag = TAG_RSA_PRIVATEEXPONENT; priv.elements[i].length = BN_num_bytes(rsa->d); BN_bn2bin(rsa->d, bufs[i]); priv.elements[i].data = bufs[i]; i++; } if (rsa->p != NULL) { priv.elements[i].tag = TAG_RSA_PRIME1; priv.elements[i].length = BN_num_bytes(rsa->p); BN_bn2bin(rsa->p, bufs[i]); priv.elements[i].data = bufs[i]; i++; } if (rsa->q != NULL) { priv.elements[i].tag = TAG_RSA_PRIME2; priv.elements[i].length = BN_num_bytes(rsa->q); BN_bn2bin(rsa->q, bufs[i]); priv.elements[i].data = bufs[i]; i++; } if (rsa->dmp1 != NULL) { priv.elements[i].tag = TAG_RSA_EXPONENT1; priv.elements[i].length = BN_num_bytes(rsa->dmp1); BN_bn2bin(rsa->dmp1, bufs[i]); priv.elements[i].data = bufs[i]; i++; } if (rsa->dmq1 != NULL) { priv.elements[i].tag = TAG_RSA_EXPONENT2; priv.elements[i].length = BN_num_bytes(rsa->dmq1); BN_bn2bin(rsa->dmq1, bufs[i]); priv.elements[i].data = bufs[i]; i++; } if (rsa->iqmp != NULL) { priv.elements[i].tag = TAG_RSA_COEFFICIENT; priv.elements[i].length = BN_num_bytes(rsa->iqmp); BN_bn2bin(rsa->iqmp, bufs[i]); priv.elements[i].data = bufs[i]; i++; } if (key->engine != NULL) { priv.elements[i].tag = TAG_RSA_ENGINE; priv.elements[i].length = strlen(key->engine) + 1; priv.elements[i].data = (unsigned char *)key->engine; i++; } if (key->label != NULL) { priv.elements[i].tag = TAG_RSA_LABEL; priv.elements[i].length = strlen(key->label) + 1; priv.elements[i].data = (unsigned char *)key->label; i++; } priv.nelements = i; result = dst__privstruct_writefile(key, &priv, directory); fail: #if USE_EVP RSA_free(rsa); #endif for (i = 0; i < 8; i++) { if (bufs[i] == NULL) break; isc_mem_put(key->mctx, bufs[i], BN_num_bytes(rsa->n)); } return (result); }
void ca_imsg(struct mproc *p, struct imsg *imsg) { RSA *rsa; const void *from = NULL; unsigned char *to = NULL; struct msg m; const char *pkiname; size_t flen, tlen, padding; struct pki *pki; int ret = 0; uint64_t id; int v; if (p->proc == PROC_PARENT) { switch (imsg->hdr.type) { case IMSG_CONF_START: return; case IMSG_CONF_END: ca_init(); /* Start fulfilling requests */ mproc_enable(p_pony); return; } } if (p->proc == PROC_CONTROL) { switch (imsg->hdr.type) { case IMSG_CTL_VERBOSE: m_msg(&m, imsg); m_get_int(&m, &v); m_end(&m); log_verbose(v); return; case IMSG_CTL_PROFILE: m_msg(&m, imsg); m_get_int(&m, &v); m_end(&m); profiling = v; return; } } if (p->proc == PROC_PONY) { switch (imsg->hdr.type) { case IMSG_CA_PRIVENC: case IMSG_CA_PRIVDEC: m_msg(&m, imsg); m_get_id(&m, &id); m_get_string(&m, &pkiname); m_get_data(&m, &from, &flen); m_get_size(&m, &tlen); m_get_size(&m, &padding); m_end(&m); pki = dict_get(env->sc_pki_dict, pkiname); if (pki == NULL || pki->pki_pkey == NULL || (rsa = EVP_PKEY_get1_RSA(pki->pki_pkey)) == NULL) fatalx("ca_imsg: invalid pki"); if ((to = calloc(1, tlen)) == NULL) fatalx("ca_imsg: calloc"); switch (imsg->hdr.type) { case IMSG_CA_PRIVENC: ret = RSA_private_encrypt(flen, from, to, rsa, padding); break; case IMSG_CA_PRIVDEC: ret = RSA_private_decrypt(flen, from, to, rsa, padding); break; } m_create(p, imsg->hdr.type, 0, 0, -1); m_add_id(p, id); m_add_int(p, ret); if (ret > 0) m_add_data(p, to, (size_t)ret); m_close(p); free(to); RSA_free(rsa); return; } } errx(1, "ca_imsg: unexpected %s imsg", imsg_to_str(imsg->hdr.type)); }
/* * Decode a string to a key. Return 0 on success. */ int kn_decode_key(struct keynote_deckey *dc, char *key, int keytype) { void *kk = (void *) NULL; X509 *px509Cert; EVP_PKEY *pPublicKey; unsigned char *ptr = (char *) NULL, *decoded = (char *) NULL; int encoding, internalencoding, len = 0; keynote_errno = 0; if (keytype == KEYNOTE_PRIVATE_KEY) dc->dec_algorithm = keynote_get_private_key_algorithm(key, &encoding, &internalencoding); else dc->dec_algorithm = keynote_get_key_algorithm(key, &encoding, &internalencoding); if (dc->dec_algorithm == KEYNOTE_ALGORITHM_NONE) { dc->dec_key = (void *) strdup(key); if (dc->dec_key == (void *) NULL) { keynote_errno = ERROR_MEMORY; return -1; } return 0; } key = strchr(key, ':'); /* Move forward, to the Encoding. We're guaranteed * to have a ':' character, since this is a key */ key++; /* Remove ASCII encoding */ switch (encoding) { case ENCODING_NONE: break; case ENCODING_HEX: len = strlen(key) / 2; if (kn_decode_hex(key, (char **) &decoded) != 0) return -1; ptr = decoded; break; case ENCODING_BASE64: len = strlen(key); if (len % 4) /* Base64 encoding must be a multiple of 4 */ { keynote_errno = ERROR_SYNTAX; return -1; } len = 3 * (len / 4); decoded = (unsigned char *) calloc(len, sizeof(unsigned char)); ptr = decoded; if (decoded == (unsigned char *) NULL) { keynote_errno = ERROR_MEMORY; return -1; } if ((len = kn_decode_base64(key, decoded, len)) == -1) return -1; break; case ENCODING_NATIVE: decoded = strdup(key); if (decoded == (unsigned char *) NULL) { keynote_errno = ERROR_MEMORY; return -1; } len = strlen(key); ptr = decoded; break; default: keynote_errno = ERROR_SYNTAX; return -1; } /* DSA-HEX */ if ((dc->dec_algorithm == KEYNOTE_ALGORITHM_DSA) && (internalencoding == INTERNAL_ENC_ASN1)) { dc->dec_key = DSA_new(); if (dc->dec_key == (DSA *) NULL) { keynote_errno = ERROR_MEMORY; return -1; } kk = dc->dec_key; if (keytype == KEYNOTE_PRIVATE_KEY) { if (d2i_DSAPrivateKey((DSA **) &kk,(const unsigned char **) &decoded, len) == (DSA *) NULL) { if (ptr != (unsigned char *) NULL) free(ptr); DSA_free(kk); keynote_errno = ERROR_SYNTAX; /* Could be a memory error */ return -1; } } else { if (d2i_DSAPublicKey((DSA **) &kk, (const unsigned char **) &decoded, len) == (DSA *) NULL) { if (ptr != (unsigned char *) NULL) free(ptr); DSA_free(kk); keynote_errno = ERROR_SYNTAX; /* Could be a memory error */ return -1; } } if (ptr != (unsigned char *) NULL) free(ptr); return 0; } /* RSA-PKCS1-HEX */ if ((dc->dec_algorithm == KEYNOTE_ALGORITHM_RSA) && (internalencoding == INTERNAL_ENC_PKCS1)) { dc->dec_key = RSA_new(); if (dc->dec_key == (RSA *) NULL) { keynote_errno = ERROR_MEMORY; return -1; } kk = dc->dec_key; if (keytype == KEYNOTE_PRIVATE_KEY) { if (d2i_RSAPrivateKey((RSA **) &kk, (const unsigned char **) &decoded, len) == (RSA *) NULL) { if (ptr != (unsigned char *) NULL) free(ptr); RSA_free(kk); keynote_errno = ERROR_SYNTAX; /* Could be a memory error */ return -1; } if (RSA_blinding_on ((RSA *) kk, NULL) != 1) { if (ptr != (unsigned char *) NULL) free(ptr); RSA_free(kk); keynote_errno = ERROR_MEMORY; return -1; } } else { if (d2i_RSAPublicKey((RSA **) &kk, (const unsigned char **) &decoded, len) == (RSA *) NULL) { if (ptr != (unsigned char *) NULL) free(ptr); RSA_free(kk); keynote_errno = ERROR_SYNTAX; /* Could be a memory error */ return -1; } } if (ptr != (unsigned char *) NULL) free(ptr); return 0; } /* X509 Cert */ if ((dc->dec_algorithm == KEYNOTE_ALGORITHM_X509) && (internalencoding == INTERNAL_ENC_ASN1) && (keytype == KEYNOTE_PUBLIC_KEY)) { if ((px509Cert = X509_new()) == (X509 *) NULL) { if (ptr) free(ptr); keynote_errno = ERROR_MEMORY; return -1; } if(d2i_X509(&px509Cert, &decoded, len) == NULL) { if (ptr) free(ptr); X509_free(px509Cert); keynote_errno = ERROR_SYNTAX; return -1; } if ((pPublicKey = X509_get_pubkey(px509Cert)) == (EVP_PKEY *) NULL) { if (ptr) free(ptr); X509_free(px509Cert); keynote_errno = ERROR_SYNTAX; return -1; } /* RSA-specific */ dc->dec_key = pPublicKey->pkey.rsa; if(ptr) free(ptr); return 0; } /* BINARY keys */ if ((dc->dec_algorithm == KEYNOTE_ALGORITHM_BINARY) && (internalencoding == INTERNAL_ENC_NONE)) { dc->dec_key = (void *) calloc(1, sizeof(struct keynote_binary)); if (dc->dec_key == (struct keynote_binary *) NULL) { keynote_errno = ERROR_MEMORY; return -1; } ((struct keynote_binary *) dc->dec_key)->bn_key = decoded; ((struct keynote_binary *) dc->dec_key)->bn_len = len; return RESULT_TRUE; } /* Add support for more algorithms here */ if (ptr != (unsigned char *) NULL) free(ptr); /* This shouldn't ever be reached really */ keynote_errno = ERROR_SYNTAX; return -1; }
static gchar* generate_response(const gchar *nouce, const gchar *userid, const gchar *password, const gchar *publickey, const gchar *aeskey_raw) { gchar *psdhex = hash_password_v4(userid, password); gchar modulus[257]; gchar exponent[7]; gint ret, flen; BIGNUM *bnn, *bne; guchar *out; guchar *nonce, *aeskey, *psd, *res; gint nonce_len, aeskey_len, psd_len; RSA *r = RSA_new(); memset(modulus, 0, sizeof(modulus)); memset(exponent, 0, sizeof(exponent)); memcpy(modulus, publickey, 256); memcpy(exponent, publickey + 256, 6); nonce = (guchar*)g_malloc0(strlen(nouce) + 1); memcpy(nonce, (guchar*)nouce, strlen(nouce)); nonce_len = strlen(nouce); psd = strtohex(psdhex, &psd_len); aeskey = strtohex(aeskey_raw, &aeskey_len); res = (guchar*)g_malloc0(nonce_len + aeskey_len + psd_len + 1); memcpy(res, nonce, nonce_len); memcpy(res + nonce_len, psd, psd_len); memcpy(res + nonce_len + psd_len, aeskey, aeskey_len); bnn = BN_new(); bne = BN_new(); BN_hex2bn(&bnn, modulus); BN_hex2bn(&bne, exponent); r->n = bnn; r->e = bne; r->d = NULL; RSA_print_fp(stdout, r, 5); flen = RSA_size(r); out = (guchar*)g_malloc0(flen); hybrid_debug_info("fetion", "start encrypting response"); ret = RSA_public_encrypt(nonce_len + aeskey_len + psd_len, res, out, r, RSA_PKCS1_PADDING); if (ret < 0) { hybrid_debug_info("fetion", "encrypt response failed!"); g_free(res); g_free(aeskey); g_free(psd); g_free(nonce); return NULL; } RSA_free(r); hybrid_debug_info("fetion", "encrypting reponse success"); g_free(res); g_free(aeskey); g_free(psd); g_free(nonce); return hextostr(out , ret); }
char *js_private_encrypt(const char *plain_text, const char *private_key_path) { RSA *rsa_privateKey = NULL; FILE *fp_privateKey; int rsa_private_len; if ((fp_privateKey = fopen(private_key_path, "r")) == NULL) { printf("Could not open %s\n", private_key_path); return '\0'; } if ((rsa_privateKey = PEM_read_RSAPrivateKey(fp_privateKey, NULL, NULL, NULL)) == NULL) { fclose(fp_privateKey); printf("Error loading RSA Private Key File."); return '\0'; } fclose(fp_privateKey); 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 (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_private_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_private_len + 1); int result_length = RSA_private_encrypt(len, plain_chunk, result_chunk, rsa_privateKey, 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); free(cipher_data); return encrypted; }
int MAIN(int argc, char **argv) { BN_GENCB cb; int ret=1; int i,num=DEFBITS; long l; int use_x931 = 0; const EVP_CIPHER *enc=NULL; unsigned long f4=RSA_F4; char *outfile=NULL; char *passargout = NULL, *passout = NULL; #ifndef OPENSSL_NO_ENGINE char *engine=NULL; #endif char *inrand=NULL; BIO *out=NULL; BIGNUM *bn = BN_new(); RSA *rsa = NULL; if(!bn) goto err; apps_startup(); BN_GENCB_set(&cb, genrsa_cb, bio_err); if (bio_err == NULL) if ((bio_err=BIO_new(BIO_s_file())) != NULL) BIO_set_fp(bio_err,stderr,BIO_NOCLOSE|BIO_FP_TEXT); if (!load_config(bio_err, NULL)) goto err; if ((out=BIO_new(BIO_s_file())) == NULL) { BIO_printf(bio_err,"unable to create BIO for output\n"); goto err; } argv++; argc--; for (;;) { if (argc <= 0) break; if (strcmp(*argv,"-out") == 0) { if (--argc < 1) goto bad; outfile= *(++argv); } else if (strcmp(*argv,"-3") == 0) f4=3; else if (strcmp(*argv,"-F4") == 0 || strcmp(*argv,"-f4") == 0) f4=RSA_F4; else if (strcmp(*argv,"-x931") == 0) use_x931 = 1; #ifndef OPENSSL_NO_ENGINE else if (strcmp(*argv,"-engine") == 0) { if (--argc < 1) goto bad; engine= *(++argv); } #endif else if (strcmp(*argv,"-rand") == 0) { if (--argc < 1) goto bad; inrand= *(++argv); } #ifndef OPENSSL_NO_DES else if (strcmp(*argv,"-des") == 0) enc=EVP_des_cbc(); else if (strcmp(*argv,"-des3") == 0) enc=EVP_des_ede3_cbc(); #endif #ifndef OPENSSL_NO_IDEA else if (strcmp(*argv,"-idea") == 0) enc=EVP_idea_cbc(); #endif #ifndef OPENSSL_NO_SEED else if (strcmp(*argv,"-seed") == 0) enc=EVP_seed_cbc(); #endif #ifndef OPENSSL_NO_AES else if (strcmp(*argv,"-aes128") == 0) enc=EVP_aes_128_cbc(); else if (strcmp(*argv,"-aes192") == 0) enc=EVP_aes_192_cbc(); else if (strcmp(*argv,"-aes256") == 0) enc=EVP_aes_256_cbc(); #endif #ifndef OPENSSL_NO_CAMELLIA else if (strcmp(*argv,"-camellia128") == 0) enc=EVP_camellia_128_cbc(); else if (strcmp(*argv,"-camellia192") == 0) enc=EVP_camellia_192_cbc(); else if (strcmp(*argv,"-camellia256") == 0) enc=EVP_camellia_256_cbc(); #endif else if (strcmp(*argv,"-passout") == 0) { if (--argc < 1) goto bad; passargout= *(++argv); } else break; argv++; argc--; } if ((argc >= 1) && ((sscanf(*argv,"%d",&num) == 0) || (num < 0))) { bad: BIO_printf(bio_err,"usage: genrsa [args] [numbits]\n"); BIO_printf(bio_err," -des encrypt the generated key with DES in cbc mode\n"); BIO_printf(bio_err," -des3 encrypt the generated key with DES in ede cbc mode (168 bit key)\n"); #ifndef OPENSSL_NO_IDEA BIO_printf(bio_err," -idea encrypt the generated key with IDEA in cbc mode\n"); #endif #ifndef OPENSSL_NO_SEED BIO_printf(bio_err," -seed\n"); BIO_printf(bio_err," encrypt PEM output with cbc seed\n"); #endif #ifndef OPENSSL_NO_AES BIO_printf(bio_err," -aes128, -aes192, -aes256\n"); BIO_printf(bio_err," encrypt PEM output with cbc aes\n"); #endif #ifndef OPENSSL_NO_CAMELLIA BIO_printf(bio_err," -camellia128, -camellia192, -camellia256\n"); BIO_printf(bio_err," encrypt PEM output with cbc camellia\n"); #endif BIO_printf(bio_err," -out file output the key to 'file\n"); BIO_printf(bio_err," -passout arg output file pass phrase source\n"); BIO_printf(bio_err," -f4 use F4 (0x10001) for the E value\n"); BIO_printf(bio_err," -3 use 3 for the E value\n"); #ifndef OPENSSL_NO_ENGINE BIO_printf(bio_err," -engine e use engine e, possibly a hardware device.\n"); #endif BIO_printf(bio_err," -rand file%cfile%c...\n", LIST_SEPARATOR_CHAR, LIST_SEPARATOR_CHAR); BIO_printf(bio_err," load the file (or the files in the directory) into\n"); BIO_printf(bio_err," the random number generator\n"); goto err; } ERR_load_crypto_strings(); if(!app_passwd(bio_err, NULL, passargout, NULL, &passout)) { BIO_printf(bio_err, "Error getting password\n"); goto err; } #ifndef OPENSSL_NO_ENGINE setup_engine(bio_err, engine, 0); #endif if (outfile == NULL) { BIO_set_fp(out,stdout,BIO_NOCLOSE); #ifdef OPENSSL_SYS_VMS { BIO *tmpbio = BIO_new(BIO_f_linebuffer()); out = BIO_push(tmpbio, out); } #endif } else { if (BIO_write_filename(out,outfile) <= 0) { perror(outfile); goto err; } } if (!app_RAND_load_file(NULL, bio_err, 1) && inrand == NULL && !RAND_status()) { BIO_printf(bio_err,"warning, not much extra random data, consider using the -rand option\n"); } if (inrand != NULL) BIO_printf(bio_err,"%ld semi-random bytes loaded\n", app_RAND_load_files(inrand)); BIO_printf(bio_err,"Generating RSA private key, %d bit long modulus\n", num); rsa = RSA_new(); if (!rsa) goto err; if (use_x931) { BIGNUM *pubexp; pubexp = BN_new(); if (!BN_set_word(pubexp, f4)) goto err; if (!RSA_X931_generate_key_ex(rsa, num, pubexp, &cb)) goto err; BN_free(pubexp); } else if(!BN_set_word(bn, f4) || !RSA_generate_key_ex(rsa, num, bn, &cb)) goto err; app_RAND_write_file(NULL, bio_err); /* We need to do the following for when the base number size is < * long, esp windows 3.1 :-(. */ l=0L; for (i=0; i<rsa->e->top; i++) { #ifndef SIXTY_FOUR_BIT l<<=BN_BITS4; l<<=BN_BITS4; #endif l+=rsa->e->d[i]; } BIO_printf(bio_err,"e is %ld (0x%lX)\n",l,l); { PW_CB_DATA cb_data; cb_data.password = passout; cb_data.prompt_info = outfile; if (!PEM_write_bio_RSAPrivateKey(out,rsa,enc,NULL,0, (pem_password_cb *)password_callback,&cb_data)) goto err; } ret=0; err: if (bn) BN_free(bn); if (rsa) RSA_free(rsa); if (out) BIO_free_all(out); if(passout) OPENSSL_free(passout); if (ret != 0) ERR_print_errors(bio_err); apps_shutdown(); OPENSSL_EXIT(ret); }
int gen_cert (X509 ** cert, EVP_PKEY ** key) { RSA *rsa; X509_NAME *subj; X509_EXTENSION *ext; X509V3_CTX ctx; const char *commonName = "localhost"; char dNSName[128]; int rc; *cert = NULL; *key = NULL; /* Generate a private key. */ *key = EVP_PKEY_new (); if (*key == NULL) { #ifdef DEBUG fprintf (stderr, "Error generating key.\n"); #endif exit (1); } do { rsa = RSA_generate_key (DEFAULT_KEY_BITS, RSA_F4, NULL, NULL); if (rsa == NULL) { #ifdef DEBUG fprintf (stderr, "Error generating RSA key.\n"); #endif exit (1); } rc = RSA_check_key (rsa); } while (rc == 0); if (rc == -1) { #ifdef DEBUG fprintf (stderr, "Error generating RSA key.\n"); #endif exit (1); } if (EVP_PKEY_assign_RSA (*key, rsa) == 0) { RSA_free (rsa); #ifdef DEBUG fprintf (stderr, "Error with EVP and PKEY.\n"); #endif exit (1); } /* Generate a certificate. */ *cert = X509_new (); if (*cert == NULL) { #ifdef DEBUG fprintf (stderr, "Couldn't generate 509 cert.\n"); #endif exit (1); } if (X509_set_version (*cert, 2) == 0) { /* Version 3. */ #ifdef DEBUG fprintf (stderr, "Couldn't set x509 version.\n"); #endif exit (1); } /* Set the commonName. */ subj = X509_get_subject_name (*cert); if (X509_NAME_add_entry_by_txt (subj, "commonName", MBSTRING_ASC, (unsigned char *) commonName, -1, -1, 0) == 0) { #ifdef DEBUG fprintf (stderr, "Couldn't set common name.\n"); #endif exit (1); } /* Set the dNSName. */ rc = snprintf (dNSName, sizeof (dNSName), "DNS:%s", commonName); if (rc < 0 || rc >= sizeof (dNSName)) { #ifdef DEBUG fprintf (stderr, "Unable to set dns name.\n"); #endif exit (1); } X509V3_set_ctx (&ctx, *cert, *cert, NULL, NULL, 0); ext = X509V3_EXT_conf (NULL, &ctx, "subjectAltName", dNSName); if (ext == NULL) { #ifdef DEBUG fprintf (stderr, "Unable to get subjectaltname.\n"); #endif exit (1); } if (X509_add_ext (*cert, ext, -1) == 0) { #ifdef DEBUG fprintf (stderr, "x509_add_ext error.\n"); #endif exit (1); } /* Set a comment. */ ext = X509V3_EXT_conf (NULL, &ctx, "nsComment", CERTIFICATE_COMMENT); if (ext == NULL) { #ifdef DEBUG fprintf (stderr, "x509v3_ext_conf error.\n"); #endif exit (1); } if (X509_add_ext (*cert, ext, -1) == 0) { #ifdef DEBUG fprintf (stderr, "x509_add_ext error.\n"); #endif exit (1); } X509_set_issuer_name (*cert, X509_get_subject_name (*cert)); X509_gmtime_adj (X509_get_notBefore (*cert), 0); X509_gmtime_adj (X509_get_notAfter (*cert), DEFAULT_CERT_DURATION); X509_set_pubkey (*cert, *key); /* Sign it. */ if (X509_sign (*cert, *key, EVP_sha1 ()) == 0) { #ifdef DEBUG fprintf (stderr, "x509_sign error.\n"); #endif exit (1); } return 1; }
bool confupdate_h(connection_t *c) { char updname[MAX_STRING_SIZE]; char rawconf[MAX_STRING_SIZE], b64conf[MAX_STRING_SIZE]; char rawdgst[MAX_STRING_SIZE], b64dgst[MAX_STRING_SIZE]; node_t *n; char *fname, *tname; FILE *fp; int x; size_t slen, dlen, rlen; RSA *updkey; /* Guard ourselves against updates */ if (ignorenetupdates() || ignoreconfupdates()) return true; if (sscanf(c->buffer, "%*d " MAX_STRING " " MAX_STRING " %zd %zd " MAX_STRING, updname, b64conf, &slen, &dlen, b64dgst) != 5) { logger(LOG_ERR, "Got bad %s from %s (%s)", "CONFUPDATE", c->name, c->hostname); return false; } if (dontverifyupdatepermission()) goto _next; if(!getconf_bool_node_offline(updname, "ConfFileMaster")) { ifdebug(PROTOCOL) logger(LOG_WARNING, "Ignoring config update request originating from %s [which came from %s (%s)]", updname, c->name, c->hostname); return true; } _next: if (!isvalidfname(updname)) { logger(LOG_ERR, "Got bogus updater name \"%s\" from %s (%s) (from: %s)", updname, c->name, c->hostname, updname); return false; } if (slen >= MAX_STRING_SIZE || dlen >= MAX_STRING_SIZE) { logger(LOG_ERR, "CONFUPDATE string sizes are bigger than buffer can fit (%zd, %zd)", slen, dlen); return false; } if (dontverifyupdatesignature()) goto _out; if (!read_rsa_public_key_offline(updname, &updkey)) { logger(LOG_ERR, "Could not find public key for %s", updname); return true; } base64_decode(b64dgst, rawdgst, sizeof(rawdgst)-1); snprintf(rawconf, sizeof(rawconf), "%s %s %zd %zd", updname, b64conf, slen, dlen); rlen = strlen(rawconf); if (!EVP_verify(updkey, rawdgst, dlen, rawconf, rlen)) { logger(LOG_WARNING, "Ignoring config update request with bad signature" " from %s [which came from %s (%s)]", updname, c->name, c->hostname); RSA_free(updkey); return true; } RSA_free(updkey); _out: if (!strcmp(updname, myself->name)) return true; if (!dontforwardconfupdates()) { exceptmasters = true; forward_request(c); } if (!strcmp(b64conf, "START")) { run_script("confupdate-before"); return true; } else if (!strcmp(b64conf, "END")) { run_script("confupdate-after"); schedulereload(); return true; } xasprintf(&fname, "%s/tinc.conf", confbase); fp = fopen(fname, "w"); if (!fp) { logger(LOG_ERR, "Could not update %s: %s", fname, strerror(errno)); free(fname); return true; } /* Save variables which are sensitive */ for (x = 0; confvarstopreserve[x]; x++) { if(get_config_string(lookup_config(config_tree, confvarstopreserve[x]), &tname)) { fprintf(fp, "%s = %s\n", confvarstopreserve[x], tname); free(tname); } } /* Decode and append our template */ base64_decode(b64conf, rawconf, sizeof(rawconf)-1); fwrite(rawconf, slen, 1, fp); fclose(fp); free(fname); return true; }
static isc_boolean_t opensslrsa_compare(const dst_key_t *key1, const dst_key_t *key2) { int status; RSA *rsa1 = NULL, *rsa2 = NULL; #if USE_EVP EVP_PKEY *pkey1, *pkey2; #endif #if USE_EVP pkey1 = key1->keydata.pkey; pkey2 = key2->keydata.pkey; /* * The pkey reference will keep these around after * the RSA_free() call. */ if (pkey1 != NULL) { rsa1 = EVP_PKEY_get1_RSA(pkey1); RSA_free(rsa1); } if (pkey2 != NULL) { rsa2 = EVP_PKEY_get1_RSA(pkey2); RSA_free(rsa2); } #else rsa1 = key1->keydata.rsa; rsa2 = key2->keydata.rsa; #endif if (rsa1 == NULL && rsa2 == NULL) return (ISC_TRUE); else if (rsa1 == NULL || rsa2 == NULL) return (ISC_FALSE); status = BN_cmp(rsa1->n, rsa2->n) || BN_cmp(rsa1->e, rsa2->e); if (status != 0) return (ISC_FALSE); #if USE_EVP if ((rsa1->flags & RSA_FLAG_EXT_PKEY) != 0 || (rsa2->flags & RSA_FLAG_EXT_PKEY) != 0) { if ((rsa1->flags & RSA_FLAG_EXT_PKEY) == 0 || (rsa2->flags & RSA_FLAG_EXT_PKEY) == 0) return (ISC_FALSE); /* * Can't compare private parameters, BTW does it make sense? */ return (ISC_TRUE); } #endif if (rsa1->d != NULL || rsa2->d != NULL) { if (rsa1->d == NULL || rsa2->d == NULL) return (ISC_FALSE); status = BN_cmp(rsa1->d, rsa2->d) || BN_cmp(rsa1->p, rsa2->p) || BN_cmp(rsa1->q, rsa2->q); if (status != 0) return (ISC_FALSE); } return (ISC_TRUE); }
/* * Sign an assertion. */ static char * keynote_sign_assertion(struct assertion *as, char *sigalg, void *key, int keyalg, int verifyflag) { int slen, i, hashlen = 0, hashtype, alg, encoding, internalenc; unsigned char *sig = (char *) NULL, *finalbuf = (char *) NULL; unsigned char res2[LARGEST_HASH_SIZE], *sbuf = (char *) NULL; BIO *biokey = (BIO *) NULL; DSA *dsa = (DSA *) NULL; RSA *rsa = (RSA *) NULL; SHA_CTX shscontext; MD5_CTX md5context; int len; if ((as->as_signature_string_s == (char *) NULL) || (as->as_startofsignature == (char *) NULL) || (as->as_allbutsignature == (char *) NULL) || (as->as_allbutsignature - as->as_startofsignature <= 0) || (as->as_authorizer == (void *) NULL) || (key == (void *) NULL) || (as->as_signeralgorithm == KEYNOTE_ALGORITHM_NONE)) { keynote_errno = ERROR_SYNTAX; return (char *) NULL; } alg = keynote_get_sig_algorithm(sigalg, &hashtype, &encoding, &internalenc); if (((alg != as->as_signeralgorithm) && !((alg == KEYNOTE_ALGORITHM_RSA) && (as->as_signeralgorithm == KEYNOTE_ALGORITHM_X509)) && !((alg == KEYNOTE_ALGORITHM_X509) && (as->as_signeralgorithm == KEYNOTE_ALGORITHM_RSA))) || ((alg != keyalg) && !((alg == KEYNOTE_ALGORITHM_RSA) && (keyalg == KEYNOTE_ALGORITHM_X509)) && !((alg == KEYNOTE_ALGORITHM_X509) && (keyalg == KEYNOTE_ALGORITHM_RSA)))) { keynote_errno = ERROR_SYNTAX; return (char *) NULL; } sig = strchr(sigalg, ':'); if (sig == (unsigned char *) NULL) { keynote_errno = ERROR_SYNTAX; return (char *) NULL; } sig++; switch (hashtype) { case KEYNOTE_HASH_SHA1: hashlen = 20; memset(res2, 0, hashlen); SHA1_Init(&shscontext); SHA1_Update(&shscontext, as->as_startofsignature, as->as_allbutsignature - as->as_startofsignature); SHA1_Update(&shscontext, sigalg, (char *) sig - sigalg); SHA1_Final(res2, &shscontext); break; case KEYNOTE_HASH_MD5: hashlen = 16; memset(res2, 0, hashlen); MD5_Init(&md5context); MD5_Update(&md5context, as->as_startofsignature, as->as_allbutsignature - as->as_startofsignature); MD5_Update(&md5context, sigalg, (char *) sig - sigalg); MD5_Final(res2, &md5context); break; case KEYNOTE_HASH_NONE: break; } if ((alg == KEYNOTE_ALGORITHM_DSA) && (hashtype == KEYNOTE_HASH_SHA1) && (internalenc == INTERNAL_ENC_ASN1) && ((encoding == ENCODING_HEX) || (encoding == ENCODING_BASE64))) { dsa = (DSA *) key; sbuf = (unsigned char *) calloc(DSA_size(dsa), sizeof(unsigned char)); if (sbuf == (unsigned char *) NULL) { keynote_errno = ERROR_MEMORY; return (char *) NULL; } if (DSA_sign(0, res2, hashlen, sbuf, &slen, dsa) <= 0) { free(sbuf); keynote_errno = ERROR_SYNTAX; return (char *) NULL; } } else if ((alg == KEYNOTE_ALGORITHM_RSA) && ((hashtype == KEYNOTE_HASH_SHA1) || (hashtype == KEYNOTE_HASH_MD5)) && (internalenc == INTERNAL_ENC_PKCS1) && ((encoding == ENCODING_HEX) || (encoding == ENCODING_BASE64))) { rsa = (RSA *) key; sbuf = (unsigned char *) calloc(RSA_size(rsa), sizeof(unsigned char)); if (sbuf == (unsigned char *) NULL) { keynote_errno = ERROR_MEMORY; return (char *) NULL; } if (RSA_sign_ASN1_OCTET_STRING(RSA_PKCS1_PADDING, res2, hashlen, sbuf, &slen, rsa) <= 0) { free(sbuf); keynote_errno = ERROR_SYNTAX; return (char *) NULL; } } else if ((alg == KEYNOTE_ALGORITHM_X509) && (hashtype == KEYNOTE_HASH_SHA1) && (internalenc == INTERNAL_ENC_ASN1)) { if ((biokey = BIO_new(BIO_s_mem())) == (BIO *) NULL) { keynote_errno = ERROR_SYNTAX; return (char *) NULL; } if (BIO_write(biokey, key, strlen(key) + 1) <= 0) { BIO_free(biokey); keynote_errno = ERROR_SYNTAX; return (char *) NULL; } /* RSA-specific */ rsa = (RSA *) PEM_read_bio_RSAPrivateKey(biokey, NULL, NULL, NULL); if (rsa == (RSA *) NULL) { BIO_free(biokey); keynote_errno = ERROR_SYNTAX; return (char *) NULL; } sbuf = calloc(RSA_size(rsa), sizeof(char)); if (sbuf == (unsigned char *) NULL) { BIO_free(biokey); RSA_free(rsa); keynote_errno = ERROR_MEMORY; return (char *) NULL; } if (RSA_sign(NID_shaWithRSAEncryption, res2, hashlen, sbuf, &slen, rsa) <= 0) { BIO_free(biokey); RSA_free(rsa); free(sbuf); keynote_errno = ERROR_SIGN_FAILURE; return NULL; } BIO_free(biokey); RSA_free(rsa); } else /* Other algorithms here */ { keynote_errno = ERROR_SYNTAX; return (char *) NULL; } /* ASCII encoding */ switch (encoding) { case ENCODING_HEX: i = kn_encode_hex(sbuf, (char **) &finalbuf, slen); free(sbuf); if (i != 0) return (char *) NULL; break; case ENCODING_BASE64: finalbuf = (unsigned char *) calloc(2 * slen, sizeof(unsigned char)); if (finalbuf == (unsigned char *) NULL) { keynote_errno = ERROR_MEMORY; free(sbuf); return (char *) NULL; } if ((slen = kn_encode_base64(sbuf, slen, finalbuf, 2 * slen)) == -1) { free(sbuf); return (char *) NULL; } break; default: free(sbuf); keynote_errno = ERROR_SYNTAX; return (char *) NULL; } /* Replace as->as_signature */ len = strlen(sigalg) + strlen(finalbuf) + 1; as->as_signature = (char *) calloc(len, sizeof(char)); if (as->as_signature == (char *) NULL) { free(finalbuf); keynote_errno = ERROR_MEMORY; return (char *) NULL; } /* Concatenate algorithm name and signature value */ snprintf(as->as_signature, len, "%s%s", sigalg, finalbuf); free(finalbuf); finalbuf = as->as_signature; /* Verify the newly-created signature if requested */ if (verifyflag) { /* Do the signature verification */ if (keynote_sigverify_assertion(as) != SIGRESULT_TRUE) { as->as_signature = (char *) NULL; free(finalbuf); if (keynote_errno == 0) keynote_errno = ERROR_SYNTAX; return (char *) NULL; } as->as_signature = (char *) NULL; } else as->as_signature = (char *) NULL; /* Everything ok */ return (char *) finalbuf; }
static isc_result_t opensslrsa_generate(dst_key_t *key, int exp, void (*callback)(int)) { #if OPENSSL_VERSION_NUMBER > 0x00908000L BN_GENCB cb; union { void *dptr; void (*fptr)(int); } u; RSA *rsa = RSA_new(); BIGNUM *e = BN_new(); #if USE_EVP EVP_PKEY *pkey = EVP_PKEY_new(); #endif if (rsa == NULL || e == NULL) goto err; #if USE_EVP if (pkey == NULL) goto err; if (!EVP_PKEY_set1_RSA(pkey, rsa)) goto err; #endif if (exp == 0) { /* RSA_F4 0x10001 */ BN_set_bit(e, 0); BN_set_bit(e, 16); } else { /* F5 0x100000001 */ BN_set_bit(e, 0); BN_set_bit(e, 32); } if (callback == NULL) { BN_GENCB_set_old(&cb, NULL, NULL); } else { u.fptr = callback; BN_GENCB_set(&cb, &progress_cb, u.dptr); } if (RSA_generate_key_ex(rsa, key->key_size, e, &cb)) { BN_free(e); SET_FLAGS(rsa); #if USE_EVP key->keydata.pkey = pkey; RSA_free(rsa); #else key->keydata.rsa = rsa; #endif return (ISC_R_SUCCESS); } err: #if USE_EVP if (pkey != NULL) EVP_PKEY_free(pkey); #endif if (e != NULL) BN_free(e); if (rsa != NULL) RSA_free(rsa); return (dst__openssl_toresult(DST_R_OPENSSLFAILURE)); #else RSA *rsa; unsigned long e; #if USE_EVP EVP_PKEY *pkey = EVP_PKEY_new(); UNUSED(callback); if (pkey == NULL) return (ISC_R_NOMEMORY); #else UNUSED(callback); #endif if (exp == 0) e = RSA_F4; else e = 0x40000003; rsa = RSA_generate_key(key->key_size, e, NULL, NULL); if (rsa == NULL) { #if USE_EVP EVP_PKEY_free(pkey); #endif return (dst__openssl_toresult(DST_R_OPENSSLFAILURE)); } SET_FLAGS(rsa); #if USE_EVP if (!EVP_PKEY_set1_RSA(pkey, rsa)) { EVP_PKEY_free(pkey); RSA_free(rsa); return (dst__openssl_toresult(DST_R_OPENSSLFAILURE)); } key->keydata.pkey = pkey; RSA_free(rsa); #else key->keydata.rsa = rsa; #endif return (ISC_R_SUCCESS); #endif }
int main(int argc, char *argv[]) { int err = 0; int v; RSA *key; unsigned char ptext[256]; unsigned char ctext[256]; static unsigned char ptext_ex[] = "\x54\x85\x9b\x34\x2c\x49\xea\x2a"; unsigned char ctext_ex[256]; int plen; int clen = 0; int num; int n; CRYPTO_malloc_debug_init(); CRYPTO_dbg_set_options(V_CRYPTO_MDEBUG_ALL); CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON); RAND_seed(rnd_seed, sizeof rnd_seed); /* or OAEP may fail */ plen = sizeof(ptext_ex) - 1; for (v = 0; v < 6; v++) { key = RSA_new(); switch (v % 3) { case 0: clen = key1(key, ctext_ex); break; case 1: clen = key2(key, ctext_ex); break; case 2: clen = key3(key, ctext_ex); break; } if (v / 3 >= 1) key->flags |= RSA_FLAG_NO_CONSTTIME; num = RSA_public_encrypt(plen, ptext_ex, ctext, key, RSA_PKCS1_PADDING); if (num != clen) { printf("PKCS#1 v1.5 encryption failed!\n"); err = 1; goto oaep; } num = RSA_private_decrypt(num, ctext, ptext, key, RSA_PKCS1_PADDING); if (num != plen || memcmp(ptext, ptext_ex, num) != 0) { printf("PKCS#1 v1.5 decryption failed!\n"); err = 1; } else printf("PKCS #1 v1.5 encryption/decryption ok\n"); oaep: ERR_clear_error(); num = RSA_public_encrypt(plen, ptext_ex, ctext, key, RSA_PKCS1_OAEP_PADDING); if (num == -1 && pad_unknown()) { printf("No OAEP support\n"); goto next; } if (num != clen) { printf("OAEP encryption failed!\n"); err = 1; goto next; } num = RSA_private_decrypt(num, ctext, ptext, key, RSA_PKCS1_OAEP_PADDING); if (num != plen || memcmp(ptext, ptext_ex, num) != 0) { printf("OAEP decryption (encrypted data) failed!\n"); err = 1; } else if (memcmp(ctext, ctext_ex, num) == 0) printf("OAEP test vector %d passed!\n", v); /* * Different ciphertexts (rsa_oaep.c without -DPKCS_TESTVECT). Try * decrypting ctext_ex */ num = RSA_private_decrypt(clen, ctext_ex, ptext, key, RSA_PKCS1_OAEP_PADDING); if (num != plen || memcmp(ptext, ptext_ex, num) != 0) { printf("OAEP decryption (test vector data) failed!\n"); err = 1; } else printf("OAEP encryption/decryption ok\n"); /* Try decrypting corrupted ciphertexts. */ for (n = 0; n < clen; ++n) { ctext[n] ^= 1; num = RSA_private_decrypt(clen, ctext, ptext, key, RSA_PKCS1_OAEP_PADDING); if (num > 0) { printf("Corrupt data decrypted!\n"); err = 1; break; } ctext[n] ^= 1; } /* Test truncated ciphertexts, as well as negative length. */ for (n = -1; n < clen; ++n) { num = RSA_private_decrypt(n, ctext, ptext, key, RSA_PKCS1_OAEP_PADDING); if (num > 0) { printf("Truncated data decrypted!\n"); err = 1; break; } } next: RSA_free(key); } CRYPTO_cleanup_all_ex_data(); ERR_remove_thread_state(NULL); CRYPTO_mem_leaks_fp(stderr); # ifdef OPENSSL_SYS_NETWARE if (err) printf("ERROR: %d\n", err); # endif return err; }
static isc_result_t opensslrsa_fromdns(dst_key_t *key, isc_buffer_t *data) { RSA *rsa; isc_region_t r; unsigned int e_bytes; #if USE_EVP EVP_PKEY *pkey; #endif isc_buffer_remainingregion(data, &r); if (r.length == 0) return (ISC_R_SUCCESS); rsa = RSA_new(); if (rsa == NULL) return (dst__openssl_toresult(ISC_R_NOMEMORY)); SET_FLAGS(rsa); if (r.length < 1) { RSA_free(rsa); return (DST_R_INVALIDPUBLICKEY); } e_bytes = *r.base++; r.length--; if (e_bytes == 0) { if (r.length < 2) { RSA_free(rsa); return (DST_R_INVALIDPUBLICKEY); } e_bytes = ((*r.base++) << 8); e_bytes += *r.base++; r.length -= 2; } if (r.length < e_bytes) { RSA_free(rsa); return (DST_R_INVALIDPUBLICKEY); } rsa->e = BN_bin2bn(r.base, e_bytes, NULL); r.base += e_bytes; r.length -= e_bytes; rsa->n = BN_bin2bn(r.base, r.length, NULL); key->key_size = BN_num_bits(rsa->n); isc_buffer_forward(data, r.length); #if USE_EVP pkey = EVP_PKEY_new(); if (pkey == NULL) { RSA_free(rsa); return (ISC_R_NOMEMORY); } if (!EVP_PKEY_set1_RSA(pkey, rsa)) { EVP_PKEY_free(pkey); RSA_free(rsa); return (dst__openssl_toresult(DST_R_OPENSSLFAILURE)); } key->keydata.pkey = pkey; RSA_free(rsa); #else key->keydata.rsa = rsa; #endif return (ISC_R_SUCCESS); }
void RSAKeyImpl::freeRSA() { if (_pRSA) RSA_free(_pRSA); _pRSA = 0; }
static void process_file(const char *filename) { FILE *keyfile; int i, count; unsigned char buffer[LINE_BUFFER_SIZE]; BIO *bp; char *nm = NULL, *header = NULL; unsigned char *data = NULL; EVP_CIPHER_INFO cipher; EVP_PKEY pk; long len; DSA *dsapkc = NULL; RSA *rsapkc = NULL; const char unsigned *dc; if (!(keyfile = fopen(filename, "rb"))) { fprintf(stderr, "! %s : %s\n", filename, strerror(errno)); return; } /* verify input files using OpenSSL */ bp = BIO_new(BIO_s_file()); if(!bp) { fprintf(stderr, "OpenSSL BIO allocation failure\n"); return; } if(!BIO_read_filename(bp, filename)) { fprintf(stderr, "OpenSSL BIO_read_filename failure\n"); ERR_print_errors_fp(stderr); return; } /* PEM_bytes_read_bio function in crypto/pem/pem_lib.c * check_pem function in crypto/pem/pem_lib.c */ for (;;) { if (!PEM_read_bio(bp, &nm, &header, &data, &len)) { if (ERR_GET_REASON(ERR_peek_error()) == PEM_R_NO_START_LINE) { /* ERR_print_errors_fp(stderr); */ fprintf(stderr, "! %s : %s\n", filename, "input keyfile validation failed"); goto out; } } if(!nm) { fprintf(stderr, "! %s : %s\n", filename, "input keyfile validation failed"); goto out; } /* only PEM encoded DSA and RSA private keys are supported. */ if (!strcmp(nm, PEM_STRING_DSA)) { pk.save_type = EVP_PKEY_DSA; break; } if (!strcmp(nm, PEM_STRING_RSA)) { pk.save_type = EVP_PKEY_RSA; break; } OPENSSL_free(nm); OPENSSL_free(header); OPENSSL_free(data); BIO_free(bp); } if (!PEM_get_EVP_CIPHER_INFO(header, &cipher)) { ERR_print_errors_fp(stderr); return; } /* check if key has no password */ dc = data; if (PEM_do_header(&cipher, data, &len, NULL, (char *) "")) { if (pk.save_type == EVP_PKEY_DSA) { if ((dsapkc = d2i_DSAPrivateKey(NULL, &dc, len)) != NULL) { fprintf(stderr, "%s has no password!\n", filename); DSA_free(dsapkc); goto out; } } else if (pk.save_type == EVP_PKEY_RSA) { if ((rsapkc = d2i_RSAPrivateKey(NULL, &dc, len)) != NULL) { fprintf(stderr, "%s has no password!\n", filename); RSA_free(rsapkc); goto out; } } } /* key has been verified */ count = fread(buffer, 1, LINE_BUFFER_SIZE, keyfile); printf("%s:$ssh2$", basename(filename)); for (i = 0; i < count; i++) { printf("%c%c", itoa16[ARCH_INDEX(buffer[i] >> 4)], itoa16[ARCH_INDEX(buffer[i] & 0x0f)]); } printf("*%d\n", count); out: fclose(keyfile); if(bp) BIO_free(bp); }
void rsa_pubkey_free(rsa_pubkey_t *pk) { OPENSSL_assert(pk); RSA_free(pk); }
idevice_error_t idevice_connection_enable_ssl(idevice_connection_t connection) { if (!connection || connection->ssl_data) return IDEVICE_E_INVALID_ARG; idevice_error_t ret = IDEVICE_E_SSL_ERROR; uint32_t return_me = 0; plist_t pair_record = NULL; userpref_read_pair_record(connection->udid, &pair_record); if (!pair_record) { debug_info("ERROR: Failed enabling SSL. Unable to read pair record for udid %s.", connection->udid); return ret; } #ifdef HAVE_OPENSSL key_data_t root_cert = { NULL, 0 }; key_data_t root_privkey = { NULL, 0 }; pair_record_import_crt_with_name(pair_record, USERPREF_ROOT_CERTIFICATE_KEY, &root_cert); pair_record_import_key_with_name(pair_record, USERPREF_ROOT_PRIVATE_KEY_KEY, &root_privkey); if (pair_record) plist_free(pair_record); BIO *ssl_bio = BIO_new(BIO_s_socket()); if (!ssl_bio) { debug_info("ERROR: Could not create SSL bio."); return ret; } BIO_set_fd(ssl_bio, (int)(long)connection->data, BIO_NOCLOSE); SSL_CTX *ssl_ctx = SSL_CTX_new(SSLv3_method()); if (ssl_ctx == NULL) { debug_info("ERROR: Could not create SSL context."); BIO_free(ssl_bio); return ret; } BIO* membp; X509* rootCert = NULL; membp = BIO_new_mem_buf(root_cert.data, root_cert.size); PEM_read_bio_X509(membp, &rootCert, NULL, NULL); BIO_free(membp); if (SSL_CTX_use_certificate(ssl_ctx, rootCert) != 1) { debug_info("WARNING: Could not load RootCertificate"); } X509_free(rootCert); free(root_cert.data); RSA* rootPrivKey = NULL; membp = BIO_new_mem_buf(root_privkey.data, root_privkey.size); PEM_read_bio_RSAPrivateKey(membp, &rootPrivKey, NULL, NULL); BIO_free(membp); if (SSL_CTX_use_RSAPrivateKey(ssl_ctx, rootPrivKey) != 1) { debug_info("WARNING: Could not load RootPrivateKey"); } RSA_free(rootPrivKey); free(root_privkey.data); SSL *ssl = SSL_new(ssl_ctx); if (!ssl) { debug_info("ERROR: Could not create SSL object"); BIO_free(ssl_bio); SSL_CTX_free(ssl_ctx); return ret; } SSL_set_connect_state(ssl); SSL_set_verify(ssl, 0, ssl_verify_callback); SSL_set_bio(ssl, ssl_bio, ssl_bio); return_me = SSL_do_handshake(ssl); if (return_me != 1) { debug_info("ERROR in SSL_do_handshake: %s", errorstring(SSL_get_error(ssl, return_me))); SSL_free(ssl); SSL_CTX_free(ssl_ctx); } else { ssl_data_t ssl_data_loc = (ssl_data_t)malloc(sizeof(struct ssl_data_private)); ssl_data_loc->session = ssl; ssl_data_loc->ctx = ssl_ctx; connection->ssl_data = ssl_data_loc; ret = IDEVICE_E_SUCCESS; debug_info("SSL mode enabled, cipher: %s", SSL_get_cipher(ssl)); } #else ssl_data_t ssl_data_loc = (ssl_data_t)malloc(sizeof(struct ssl_data_private)); /* Set up GnuTLS... */ debug_info("enabling SSL mode"); errno = 0; gnutls_certificate_allocate_credentials(&ssl_data_loc->certificate); gnutls_certificate_client_set_retrieve_function(ssl_data_loc->certificate, internal_cert_callback); gnutls_init(&ssl_data_loc->session, GNUTLS_CLIENT); gnutls_priority_set_direct(ssl_data_loc->session, "NONE:+VERS-SSL3.0:+ANON-DH:+RSA:+AES-128-CBC:+AES-256-CBC:+SHA1:+MD5:+COMP-NULL", NULL); gnutls_credentials_set(ssl_data_loc->session, GNUTLS_CRD_CERTIFICATE, ssl_data_loc->certificate); gnutls_session_set_ptr(ssl_data_loc->session, ssl_data_loc); gnutls_x509_crt_init(&ssl_data_loc->root_cert); gnutls_x509_crt_init(&ssl_data_loc->host_cert); gnutls_x509_privkey_init(&ssl_data_loc->root_privkey); gnutls_x509_privkey_init(&ssl_data_loc->host_privkey); pair_record_import_crt_with_name(pair_record, USERPREF_ROOT_CERTIFICATE_KEY, ssl_data_loc->root_cert); pair_record_import_crt_with_name(pair_record, USERPREF_HOST_CERTIFICATE_KEY, ssl_data_loc->host_cert); pair_record_import_key_with_name(pair_record, USERPREF_ROOT_PRIVATE_KEY_KEY, ssl_data_loc->root_privkey); pair_record_import_key_with_name(pair_record, USERPREF_HOST_PRIVATE_KEY_KEY, ssl_data_loc->host_privkey); if (pair_record) plist_free(pair_record); debug_info("GnuTLS step 1..."); gnutls_transport_set_ptr(ssl_data_loc->session, (gnutls_transport_ptr_t)connection); debug_info("GnuTLS step 2..."); gnutls_transport_set_push_function(ssl_data_loc->session, (gnutls_push_func) & internal_ssl_write); debug_info("GnuTLS step 3..."); gnutls_transport_set_pull_function(ssl_data_loc->session, (gnutls_pull_func) & internal_ssl_read); debug_info("GnuTLS step 4 -- now handshaking..."); if (errno) { debug_info("WARNING: errno says %s before handshake!", strerror(errno)); } return_me = gnutls_handshake(ssl_data_loc->session); debug_info("GnuTLS handshake done..."); if (return_me != GNUTLS_E_SUCCESS) { internal_ssl_cleanup(ssl_data_loc); free(ssl_data_loc); debug_info("GnuTLS reported something wrong."); gnutls_perror(return_me); debug_info("oh.. errno says %s", strerror(errno)); } else { connection->ssl_data = ssl_data_loc; ret = IDEVICE_E_SUCCESS; debug_info("SSL mode enabled"); } #endif return ret; }
void rsa_prvkey_free(rsa_prvkey_t *sk) { OPENSSL_assert(sk); RSA_free(sk); }
char *js_private_decrypt(const char *cipher_text, const char *private_key_path) { RSA *rsa_privateKey = NULL; FILE *fp_privateKey; int rsa_private_len; if ((fp_privateKey = fopen(private_key_path, "r")) == NULL) { printf("Could not open %s\n", private_key_path); return '\0'; } if ((rsa_privateKey = PEM_read_RSAPrivateKey(fp_privateKey, NULL, NULL, NULL)) == NULL) { printf("Error loading RSA Private Key File."); return '\0'; } fclose(fp_privateKey); printf("Cipher text: %s\n", cipher_text); rsa_private_len = RSA_size(rsa_privateKey); printf("RSA private length: %d\n", rsa_private_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_private_len) { unsigned char *crypt_chunk = malloc(rsa_private_len + 1); memcpy(&crypt_chunk[0], &crypt[i], rsa_private_len); printf("Crypt chunk: %s\n", crypt_chunk); unsigned char *result_chunk = malloc(crypt_len + 1); int result_length = RSA_private_decrypt(rsa_private_len, crypt_chunk, result_chunk, rsa_privateKey, RSA_PKCS1_PADDING); // chunk length should be the size of privatekey (in bytes) minus 11 (overhead during encryption) printf("Result chunk: %s\nChunk length: %d\n", result_chunk, result_length); // 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); 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_privateKey); printf("Final result: %s\n", plain_char); return plain_char; }
static isc_result_t opensslrsa_parse(dst_key_t *key, isc_lex_t *lexer, dst_key_t *pub) { dst_private_t priv; isc_result_t ret; int i; RSA *rsa = NULL, *pubrsa = NULL; #ifdef USE_ENGINE ENGINE *e = NULL; #endif isc_mem_t *mctx = key->mctx; const char *engine = NULL, *label = NULL; #if defined(USE_ENGINE) || USE_EVP EVP_PKEY *pkey = NULL; #endif #if USE_EVP if (pub != NULL && pub->keydata.pkey != NULL) pubrsa = EVP_PKEY_get1_RSA(pub->keydata.pkey); #else if (pub != NULL && pub->keydata.rsa != NULL) { pubrsa = pub->keydata.rsa; pub->keydata.rsa = NULL; } #endif /* read private key file */ ret = dst__privstruct_parse(key, DST_ALG_RSA, lexer, mctx, &priv); if (ret != ISC_R_SUCCESS) return (ret); for (i = 0; i < priv.nelements; i++) { switch (priv.elements[i].tag) { case TAG_RSA_ENGINE: engine = (char *)priv.elements[i].data; break; case TAG_RSA_LABEL: label = (char *)priv.elements[i].data; break; default: break; } } /* * Is this key is stored in a HSM? * See if we can fetch it. */ if (label != NULL) { #ifdef USE_ENGINE if (engine == NULL) DST_RET(DST_R_NOENGINE); e = dst__openssl_getengine(engine); if (e == NULL) DST_RET(DST_R_NOENGINE); pkey = ENGINE_load_private_key(e, label, NULL, NULL); if (pkey == NULL) { /* ERR_print_errors_fp(stderr); */ DST_RET(ISC_R_NOTFOUND); } key->engine = isc_mem_strdup(key->mctx, engine); if (key->engine == NULL) DST_RET(ISC_R_NOMEMORY); key->label = isc_mem_strdup(key->mctx, label); if (key->label == NULL) DST_RET(ISC_R_NOMEMORY); rsa = EVP_PKEY_get1_RSA(pkey); if (rsa == NULL) DST_RET(dst__openssl_toresult(DST_R_OPENSSLFAILURE)); if (rsa_check(rsa, pubrsa) != ISC_R_SUCCESS) DST_RET(DST_R_INVALIDPRIVATEKEY); if (pubrsa != NULL) RSA_free(pubrsa); key->key_size = EVP_PKEY_bits(pkey); #if USE_EVP key->keydata.pkey = pkey; RSA_free(rsa); #else key->keydata.rsa = rsa; EVP_PKEY_free(pkey); #endif dst__privstruct_free(&priv, mctx); memset(&priv, 0, sizeof(priv)); return (ISC_R_SUCCESS); #else DST_RET(DST_R_NOENGINE); #endif } rsa = RSA_new(); if (rsa == NULL) DST_RET(ISC_R_NOMEMORY); SET_FLAGS(rsa); #if USE_EVP pkey = EVP_PKEY_new(); if (pkey == NULL) DST_RET(ISC_R_NOMEMORY); if (!EVP_PKEY_set1_RSA(pkey, rsa)) DST_RET(ISC_R_FAILURE); key->keydata.pkey = pkey; #else key->keydata.rsa = rsa; #endif for (i = 0; i < priv.nelements; i++) { BIGNUM *bn; switch (priv.elements[i].tag) { case TAG_RSA_ENGINE: continue; case TAG_RSA_LABEL: continue; case TAG_RSA_PIN: continue; default: bn = BN_bin2bn(priv.elements[i].data, priv.elements[i].length, NULL); if (bn == NULL) DST_RET(ISC_R_NOMEMORY); } switch (priv.elements[i].tag) { case TAG_RSA_MODULUS: rsa->n = bn; break; case TAG_RSA_PUBLICEXPONENT: rsa->e = bn; break; case TAG_RSA_PRIVATEEXPONENT: rsa->d = bn; break; case TAG_RSA_PRIME1: rsa->p = bn; break; case TAG_RSA_PRIME2: rsa->q = bn; break; case TAG_RSA_EXPONENT1: rsa->dmp1 = bn; break; case TAG_RSA_EXPONENT2: rsa->dmq1 = bn; break; case TAG_RSA_COEFFICIENT: rsa->iqmp = bn; break; } } dst__privstruct_free(&priv, mctx); memset(&priv, 0, sizeof(priv)); if (rsa_check(rsa, pubrsa) != ISC_R_SUCCESS) DST_RET(DST_R_INVALIDPRIVATEKEY); key->key_size = BN_num_bits(rsa->n); if (pubrsa != NULL) RSA_free(pubrsa); #if USE_EVP RSA_free(rsa); #endif return (ISC_R_SUCCESS); err: #if USE_EVP if (pkey != NULL) EVP_PKEY_free(pkey); #endif if (rsa != NULL) RSA_free(rsa); if (pubrsa != NULL) RSA_free(pubrsa); opensslrsa_destroy(key); dst__privstruct_free(&priv, mctx); memset(&priv, 0, sizeof(priv)); return (ret); }
/* If no hash function was used, finish with RSA_public_decrypt(). * If a hash function was used, we can make a big shortcut by * finishing with EVP_VerifyFinal(). */ CK_RV sc_pkcs11_verify_data(const unsigned char *pubkey, int pubkey_len, const unsigned char *pubkey_params, int pubkey_params_len, CK_MECHANISM_TYPE mech, sc_pkcs11_operation_t *md, unsigned char *data, int data_len, unsigned char *signat, int signat_len) { int res; CK_RV rv = CKR_GENERAL_ERROR; EVP_PKEY *pkey; if (mech == CKM_GOSTR3410) { #if OPENSSL_VERSION_NUMBER >= 0x10000000L && !defined(OPENSSL_NO_EC) return gostr3410_verify_data(pubkey, pubkey_len, pubkey_params, pubkey_params_len, data, data_len, signat, signat_len); #else (void)pubkey_params, (void)pubkey_params_len; /* no warning */ return CKR_FUNCTION_NOT_SUPPORTED; #endif } pkey = d2i_PublicKey(EVP_PKEY_RSA, NULL, &pubkey, pubkey_len); if (pkey == NULL) return CKR_GENERAL_ERROR; if (md != NULL) { EVP_MD_CTX *md_ctx = DIGEST_CTX(md); res = EVP_VerifyFinal(md_ctx, signat, signat_len, pkey); EVP_PKEY_free(pkey); if (res == 1) return CKR_OK; else if (res == 0) return CKR_SIGNATURE_INVALID; else { sc_debug(context, SC_LOG_DEBUG_NORMAL, "EVP_VerifyFinal() returned %d\n", res); return CKR_GENERAL_ERROR; } } else { RSA *rsa; unsigned char *rsa_out = NULL, pad; int rsa_outlen = 0; switch(mech) { case CKM_RSA_PKCS: pad = RSA_PKCS1_PADDING; break; case CKM_RSA_X_509: pad = RSA_NO_PADDING; break; default: EVP_PKEY_free(pkey); return CKR_ARGUMENTS_BAD; } rsa = EVP_PKEY_get1_RSA(pkey); EVP_PKEY_free(pkey); if (rsa == NULL) return CKR_DEVICE_MEMORY; rsa_out = malloc(RSA_size(rsa)); if (rsa_out == NULL) { RSA_free(rsa); return CKR_DEVICE_MEMORY; } rsa_outlen = RSA_public_decrypt(signat_len, signat, rsa_out, rsa, pad); RSA_free(rsa); if(rsa_outlen <= 0) { free(rsa_out); sc_debug(context, SC_LOG_DEBUG_NORMAL, "RSA_public_decrypt() returned %d\n", rsa_outlen); return CKR_GENERAL_ERROR; } if (rsa_outlen == data_len && memcmp(rsa_out, data, data_len) == 0) rv = CKR_OK; else rv = CKR_SIGNATURE_INVALID; free(rsa_out); } return rv; }
static isc_result_t opensslrsa_fromlabel(dst_key_t *key, const char *engine, const char *label, const char *pin) { #ifdef USE_ENGINE ENGINE *e = NULL; isc_result_t ret; EVP_PKEY *pkey = NULL; RSA *rsa = NULL, *pubrsa = NULL; char *colon; UNUSED(pin); if (engine == NULL) DST_RET(DST_R_NOENGINE); e = dst__openssl_getengine(engine); if (e == NULL) DST_RET(DST_R_NOENGINE); pkey = ENGINE_load_public_key(e, label, NULL, NULL); if (pkey != NULL) { pubrsa = EVP_PKEY_get1_RSA(pkey); EVP_PKEY_free(pkey); if (pubrsa == NULL) DST_RET(dst__openssl_toresult(DST_R_OPENSSLFAILURE)); } pkey = ENGINE_load_private_key(e, label, NULL, NULL); if (pkey == NULL) DST_RET(ISC_R_NOTFOUND); if (engine != NULL) { key->engine = isc_mem_strdup(key->mctx, engine); if (key->engine == NULL) DST_RET(ISC_R_NOMEMORY); } else { key->engine = isc_mem_strdup(key->mctx, label); if (key->engine == NULL) DST_RET(ISC_R_NOMEMORY); colon = strchr(key->engine, ':'); if (colon != NULL) *colon = '\0'; } key->label = isc_mem_strdup(key->mctx, label); if (key->label == NULL) DST_RET(ISC_R_NOMEMORY); rsa = EVP_PKEY_get1_RSA(pkey); if (rsa == NULL) DST_RET(dst__openssl_toresult(DST_R_OPENSSLFAILURE)); if (rsa_check(rsa, pubrsa) != ISC_R_SUCCESS) DST_RET(DST_R_INVALIDPRIVATEKEY); if (pubrsa != NULL) RSA_free(pubrsa); key->key_size = EVP_PKEY_bits(pkey); #if USE_EVP key->keydata.pkey = pkey; RSA_free(rsa); #else key->keydata.rsa = rsa; EVP_PKEY_free(pkey); #endif return (ISC_R_SUCCESS); err: if (rsa != NULL) RSA_free(rsa); if (pubrsa != NULL) RSA_free(pubrsa); if (pkey != NULL) EVP_PKEY_free(pkey); return (ret); #else UNUSED(key); UNUSED(engine); UNUSED(label); UNUSED(pin); return(DST_R_NOENGINE); #endif }
static void init_generated (GstDtlsCertificate * self) { GstDtlsCertificatePrivate *priv = self->priv; RSA *rsa; X509_NAME *name = NULL; g_return_if_fail (!priv->x509); g_return_if_fail (!priv->private_key); priv->private_key = EVP_PKEY_new (); if (!priv->private_key) { GST_WARNING_OBJECT (self, "failed to create private key"); return; } priv->x509 = X509_new (); if (!priv->x509) { GST_WARNING_OBJECT (self, "failed to create certificate"); EVP_PKEY_free (priv->private_key); priv->private_key = NULL; return; } rsa = RSA_generate_key (2048, RSA_F4, NULL, NULL); if (!rsa) { GST_WARNING_OBJECT (self, "failed to generate RSA"); EVP_PKEY_free (priv->private_key); priv->private_key = NULL; X509_free (priv->x509); priv->x509 = NULL; return; } if (!EVP_PKEY_assign_RSA (priv->private_key, rsa)) { GST_WARNING_OBJECT (self, "failed to assign RSA"); RSA_free (rsa); rsa = NULL; EVP_PKEY_free (priv->private_key); priv->private_key = NULL; X509_free (priv->x509); priv->x509 = NULL; return; } rsa = NULL; X509_set_version (priv->x509, 2); ASN1_INTEGER_set (X509_get_serialNumber (priv->x509), 0); X509_gmtime_adj (X509_get_notBefore (priv->x509), 0); X509_gmtime_adj (X509_get_notAfter (priv->x509), 31536000L); /* A year */ X509_set_pubkey (priv->x509, priv->private_key); name = X509_get_subject_name (priv->x509); X509_NAME_add_entry_by_txt (name, "C", MBSTRING_ASC, (unsigned char *) "SE", -1, -1, 0); X509_NAME_add_entry_by_txt (name, "CN", MBSTRING_ASC, (unsigned char *) "OpenWebRTC", -1, -1, 0); X509_set_issuer_name (priv->x509, name); name = NULL; if (!X509_sign (priv->x509, priv->private_key, EVP_sha256 ())) { GST_WARNING_OBJECT (self, "failed to sign certificate"); EVP_PKEY_free (priv->private_key); priv->private_key = NULL; X509_free (priv->x509); priv->x509 = NULL; return; } self->priv->pem = _gst_dtls_x509_to_pem (priv->x509); }
int main(int argc, char **argv) { if(argc != 3) { exit(1); } FILE *input; RSA *key; if(strcmp(argv[1], "-s") == 0) { input = fopen(argv[2], "r"); key = RSA_new(); PEM_read_RSAPrivateKey(input, &key, NULL, NULL); gcry_sexp_t d_key; p2p_convert_private_key(key, &d_key); RSA_free(key); fclose(input); struct sockaddr_in serv_addr; serv_addr.sin_port = htons(4711); serv_addr.sin_family = AF_INET; serv_addr.sin_addr.s_addr = INADDR_ANY; int sock = socket(AF_INET, SOCK_STREAM, 0); bind(sock, (struct sockaddr *) &serv_addr, sizeof(serv_addr)); listen(sock, 5); struct sockaddr_in client_addr; socklen_t client_addrlen = sizeof(client_addr); int conn = accept(sock, (struct sockaddr *) &client_addr, &client_addrlen); unsigned char buf[1000]; int datalen = recv(conn, buf, 1000, 0); char msg[50]; int len = p2p_decrypt(buf, datalen, msg, 50, d_key); msg[len] = 0; printf("%s\n", msg); } else { input = fopen(argv[2], "r"); key = RSA_new(); PEM_read_RSA_PUBKEY(input, &key, NULL, NULL); gcry_sexp_t r_key; p2p_convert_public_key(key, &r_key); RSA_free(key); fclose(input); struct sockaddr_in serv_addr; serv_addr.sin_family = AF_INET; serv_addr.sin_port = htons(4711); serv_addr.sin_addr.s_addr = inet_addr("192.168.1.108"); int sock = socket(AF_INET, SOCK_STREAM, 0); int err = connect(sock, (struct sockaddr *) &serv_addr, sizeof(serv_addr)); if(err < 0) { perror("connect"); exit(1); } unsigned char buf[2000]; char msg[50]; printf("> "); fgets(msg, 50, stdin); size_t len = p2p_encrypt(msg, strlen(msg), buf, 2000, r_key); send(sock, buf, len, 0); } return 0; }