int COsslKey::setPrivateKeyRaw( sqbind::CSqBinary *pBin ) {_STT(); Destroy(); if ( !pBin || !pBin->getUsed() ) return 0; m_pkey = EVP_PKEY_new(); if ( !m_pkey ) { oexERROR( 0, oexT( "EVP_PKEY_new() failed" ) ); Destroy(); return 0; } // end if const unsigned char *p = (const unsigned char*)pBin->Ptr(); RSA *rsa = d2i_RSAPrivateKey( oexNULL, &p, pBin->getUsed() ); if ( !rsa ) { oexERROR( 0, oexT( "d2i_RSAPrivateKey() failed" ) ); Destroy(); return 0; } // end if // Assign key if ( !EVP_PKEY_assign_RSA( m_pkey, rsa ) ) { oexERROR( 0, oexT( "EVP_PKEY_assign_RSA() failed" ) ); Destroy(); return 0; } // end if rsa = oexNULL; return GenPublicKey(); }
static void keystore_load_rsakey(GKeyFile *keyfile, gchar *key, struct keystore_t *keystore) { g_assert(NULL != keyfile); g_assert(NULL != key); g_assert(NULL != keystore); gsize length = 0; gchar **list = g_key_file_get_string_list(keyfile, "rsa", key, &length, NULL); if (length == 2) { int key_index = atoi(key); int keylen = atoi(list[0]); gsize keybits_len = 0; guchar *keybits = g_base64_decode(list[1], &keybits_len); const guchar *tmp = keybits; struct rsa_key_t *rsa_key = g_malloc(sizeof(struct rsa_key_t)); rsa_key->keylen = keylen; rsa_key->rsa = d2i_RSAPrivateKey(NULL, (const unsigned char **)&tmp, keybits_len); if (NULL != rsa_key->rsa) { keystore_key_replace(keystore->rsa, rsa_key, &key_index); } g_free(keybits); } g_strfreev(list); }
static RSA * read_key(ENGINE *engine, const char *rsa_key) { unsigned char buf[1024 * 4]; const unsigned char *p; size_t size; RSA *rsa; FILE *f; f = fopen(rsa_key, "rb"); if (f == NULL) err(1, "could not open file %s", rsa_key); rk_cloexec_file(f); size = fread(buf, 1, sizeof(buf), f); fclose(f); if (size == 0) err(1, "failed to read file %s", rsa_key); if (size == sizeof(buf)) err(1, "key too long in file %s!", rsa_key); p = buf; rsa = d2i_RSAPrivateKey(NULL, &p, size); if (rsa == NULL) err(1, "failed to parse key in file %s", rsa_key); RSA_set_method(rsa, ENGINE_get_RSA(engine)); if (!key_blinding) rsa->flags |= RSA_FLAG_NO_BLINDING; return rsa; }
VbPrivateKey* PrivateKeyRead(const char* filename) { VbPrivateKey *key; uint64_t filelen = 0; uint8_t *buffer; const unsigned char *start; buffer = ReadFile(filename, &filelen); if (!buffer) { VbExError("unable to read from file %s\n", filename); return 0; } key = (VbPrivateKey*)malloc(sizeof(VbPrivateKey)); if (!key) { VbExError("Unable to allocate VbPrivateKey\n"); free(buffer); return 0; } key->algorithm = *(typeof(key->algorithm) *)buffer; start = buffer + sizeof(key->algorithm); key->rsa_private_key = d2i_RSAPrivateKey(0, &start, filelen - sizeof(key->algorithm)); if (!key->rsa_private_key) { VbExError("Unable to parse RSA private key\n"); free(buffer); free(key); return 0; } free(buffer); return key; }
EVP_PKEY *d2i_PrivateKey(int type, EVP_PKEY **a, const unsigned char **pp, long length) { EVP_PKEY *ret; if ((a == NULL) || (*a == NULL)) { if ((ret=EVP_PKEY_new()) == NULL) { ASN1err(ASN1_F_D2I_PRIVATEKEY,ERR_R_EVP_LIB); return(NULL); } } else ret= *a; ret->save_type=type; ret->type=EVP_PKEY_type(type); switch (ret->type) { #ifndef OPENSSL_NO_RSA case EVP_PKEY_RSA: if ((ret->pkey.rsa=d2i_RSAPrivateKey(NULL, (const unsigned char **)pp,length)) == NULL) /* TMP UGLY CAST */ { ASN1err(ASN1_F_D2I_PRIVATEKEY,ERR_R_ASN1_LIB); goto err; } break; #endif #ifndef OPENSSL_NO_DSA case EVP_PKEY_DSA: if ((ret->pkey.dsa=d2i_DSAPrivateKey(NULL, (const unsigned char **)pp,length)) == NULL) /* TMP UGLY CAST */ { ASN1err(ASN1_F_D2I_PRIVATEKEY,ERR_R_ASN1_LIB); goto err; } break; #endif #ifndef OPENSSL_NO_EC case EVP_PKEY_EC: if ((ret->pkey.ec = d2i_ECPrivateKey(NULL, (const unsigned char **)pp, length)) == NULL) { ASN1err(ASN1_F_D2I_PRIVATEKEY, ERR_R_ASN1_LIB); goto err; } break; #endif default: ASN1err(ASN1_F_D2I_PRIVATEKEY,ASN1_R_UNKNOWN_PUBLIC_KEY_TYPE); goto err; /* break; */ } if (a != NULL) (*a)=ret; return(ret); err: if ((ret != NULL) && ((a == NULL) || (*a != ret))) EVP_PKEY_free(ret); return(NULL); }
static EVP_PKEY *load_example_rsa_key(void) { EVP_PKEY *ret = NULL; const unsigned char *derp = kExampleRSAKeyDER; EVP_PKEY *pkey = NULL; RSA *rsa = NULL; if (!d2i_RSAPrivateKey(&rsa, &derp, sizeof(kExampleRSAKeyDER))) { return NULL; } pkey = EVP_PKEY_new(); if (pkey == NULL || !EVP_PKEY_set1_RSA(pkey, rsa)) { goto out; } ret = pkey; pkey = NULL; out: EVP_PKEY_free(pkey); RSA_free(rsa); return ret; }
SEXP PKI_load_private_RSA(SEXP what, SEXP sPassword) { EVP_PKEY *key = 0; BIO *bio_mem; if (TYPEOF(sPassword) != STRSXP || LENGTH(sPassword) != 1) Rf_error("Password must be a string"); PKI_init(); if (TYPEOF(what) == RAWSXP) { /* assuming binary DER format */ RSA *rsa = 0; const unsigned char *ptr; ptr = (const unsigned char *) RAW(what); rsa = d2i_RSAPrivateKey(&rsa, &ptr, LENGTH(what)); if (!rsa) Rf_error("%s", ERR_error_string(ERR_get_error(), NULL)); key = EVP_PKEY_new(); EVP_PKEY_assign_RSA(key, rsa); } else if (TYPEOF(what) == STRSXP && LENGTH(what)) { SEXP b64Key = STRING_ELT(what, 0); bio_mem = BIO_new_mem_buf((void *) CHAR(b64Key), -1); key = PEM_read_bio_PrivateKey(bio_mem, 0, 0, (void*) CHAR(STRING_ELT(sPassword, 0))); BIO_free(bio_mem); if (!key) Rf_error("%s", ERR_error_string(ERR_get_error(), NULL)); } else Rf_error("Private key must be a character or raw vector"); return wrap_EVP_PKEY(key, PKI_KT_PRIVATE); }
main(){ unsigned char *pem_key_str = "MIGJAoGBAKz8scCXFg2O2r2sMsic40hSgHw1q52LUAvEHDH4S5pgflNjs8NfJKOjZmnkTpxI+eLmGKqPPWg7SF7YbUMmmTXvhuTWQF9OcXhIxzIUVFwQKZEWSgZyoaqwcy3XF6sIf7oFDRWfkIY5RCp03GdM0IjGK3lDIdfh0p6wSjTdfvvhAgMBAAEwggJcAgEAAoGBAKz8scCXFg2O2r2sMsic40hSgHw1q52LUAvEHDH4S5pgflNjs8NfJKOjZmnkTpxI+eLmGKqPPWg7SF7YbUMmmTXvhuTWQF9OcXhIxzIUVFwQKZEWSgZyoaqwcy3XF6sIf7oFDRWfkIY5RCp03GdM0IjGK3lDIdfh0p6wSjTdfvvhAgMBAAECgYBo1D1Xq3dWwgI2vPqNbd2h/zUTkGauczUP3EkF0yTlqaIEIMBYHfkTHTs74nns5aBg6vV5rpIU7w/9QgR8lBB1it3g6QU8RWdLG1cpckEL8LLPPWPIUOTSaId2BAeIU3Q0NOBc0sWO1pUTvYBGykQW9LYsP3254yIbc+5aQhwjAQJBANUh5TA45sMvpK+ZoRd3rWTQMU3Ted2/MCsGknPSPCk9ZxHTknU+q5O8L2kmWuc0b/IrVp4Zi9AUDx9AplRUvjECQQDPx7t6Iaim+jjO5y9FcKQPnFW4PRD2s2OffGisrIVAoLoQqNeHW5itltEs/CIT2AyTYRhg4uBIC37gt3kelDyxAkBhNv24Oiwf2apvok6VSrRfaIskqZJLr/pDldLVW46vbN+HhQ6nxfczAsJJXwJVtVheiKAQqyxXs96V7cIwcxrxAkEAihggRRK7yYaCXRkPtOIhV/K6kgGcFaqyapw/4Yuj4IkyQMJGxMKe3bhf+7rzVyb/bLBaiIIhOCDTybyHNkilcQJAHNSMtPgDVvYbzImMaNcpGHKJdkPoChO7W7EpRuCMlT7OMIc8cQIOiTBrHRDzF72NT0p+QfAXUAZxat7s1oqSDw=="; RSA *pub_rsa,*priv_rsa; unsigned char de_buf[2048],*p,*start; int de_len; p=de_buf; base64_decode(pem_key_str,strlen(pem_key_str),de_buf,&de_len); p = (unsigned char*)malloc(de_len); memcpy(p,de_buf,de_len); start = p; pub_rsa=d2i_RSAPublicKey(NULL,(const unsigned char**)&p,(long)de_len); de_len-=(p-start); priv_rsa=d2i_RSAPrivateKey(NULL,(const unsigned char**)&p,(long)de_len); if ((pub_rsa == NULL) || (priv_rsa == NULL)) ERR_print_errors_fp(stderr); RSA_print_fp(stdout,pub_rsa,11); RSA_print_fp(stdout,priv_rsa,11); RSA_free(pub_rsa); RSA_free(priv_rsa); }
RsaPrivateKey(const uint8_t *keyDer, size_t keyDerLength) { // Use a temporary pointer since d2i updates it. const uint8_t *derPointer = keyDer; privateKey_ = d2i_RSAPrivateKey(NULL, &derPointer, keyDerLength); if (!privateKey_) throw Error("RsaPrivateKey constructor: Error decoding private key DER"); }
int EdSSLContext::setSSLCertMem(void* crt, int crtlen, void* key, int keylen) { X509* xcert = d2i_X509(NULL, (const unsigned char**)&crt, crtlen); SSL_CTX_use_certificate(mCtx, xcert); RSA *pkey = d2i_RSAPrivateKey(NULL, (const unsigned char**)&key, keylen); SSL_CTX_use_RSAPrivateKey(mCtx, pkey); return 0; }
static int old_rsa_priv_decode(EVP_PKEY *pkey, const unsigned char **pder, int derlen) { RSA *rsa = d2i_RSAPrivateKey(NULL, pder, derlen); if (rsa == NULL) { OPENSSL_PUT_ERROR(EVP, old_rsa_priv_decode, ERR_R_RSA_LIB); return 0; } EVP_PKEY_assign_RSA(pkey, rsa); return 1; }
static int old_rsa_priv_decode(EVP_PKEY *pkey, const unsigned char **pder, int derlen) { RSA *rsa; if (!(rsa = d2i_RSAPrivateKey(NULL, pder, derlen))) { RSAerr(RSA_F_OLD_RSA_PRIV_DECODE, ERR_R_RSA_LIB); return 0; } EVP_PKEY_assign_RSA(pkey, rsa); return 1; }
SEXP R_rsa_decrypt(SEXP data, SEXP keydata){ static unsigned char* buf[8192]; RSA *rsa = RSA_new(); const unsigned char *ptr = RAW(keydata); bail(!!d2i_RSAPrivateKey(&rsa, &ptr, LENGTH(keydata))); int len = RSA_private_decrypt(LENGTH(data), RAW(data), (unsigned char*) buf, rsa, RSA_PKCS1_PADDING); bail(len > 0); SEXP res = allocVector(RAWSXP, len); memcpy(RAW(res), buf, len); return res; }
/** Parse an RSA private key from a PKCS#1 byte stream. @see ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-1/pkcs-1v2-1.pdf */ int32_t psRsaParsePkcs1PrivKey(psPool_t *pool, const unsigned char *p, psSize_t size, psRsaKey_t *key) { RSA *rsa; # ifndef USE_D2I const unsigned char *end, *seq; int32_t version; psSize_t seqlen; # endif # ifdef USE_D2I if ((rsa = d2i_RSAPrivateKey(NULL, &p, size)) == NULL) { return PS_PARSE_FAIL; } # else if ((rsa = RSA_new()) == NULL) { return PS_MEM_FAIL; } end = p + size; if (getAsnSequence(&p, size, &seqlen) < 0) { RSA_free(rsa); goto L_FAIL; } seq = p; if (getAsnInteger(&p, (uint16_t) (end - p), &version) < 0 || version != 0 || getBig(&p, (uint16_t) (end - p), &rsa->n) < 0 || getBig(&p, (uint16_t) (end - p), &rsa->e) < 0 || getBig(&p, (uint16_t) (end - p), &rsa->d) < 0 || getBig(&p, (uint16_t) (end - p), &rsa->p) < 0 || getBig(&p, (uint16_t) (end - p), &rsa->q) < 0 || getBig(&p, (uint16_t) (end - p), &rsa->dmp1) < 0 || getBig(&p, (uint16_t) (end - p), &rsa->dmq1) < 0 || getBig(&p, (uint16_t) (end - p), &rsa->iqmp) < 0 || (uint16_t) (p - seq) != seqlen) { RSA_free(rsa); goto L_FAIL; } rsa->version = version; # endif /* RSA_print_fp(stdout, rsa, 0); */ *key = rsa; return PS_SUCCESS; L_FAIL: psTraceIntCrypto("psRsaParsePkcs1PrivKey error on byte %d\n", p - (end - size)); return PS_PARSE_FAIL; }
main(){ char *source_filename = "/etc/shopex/skomart.com/sec.pem.en"; char *file_content = NULL; int file_content_len = 0; FILE *fp; char *output; int output_len; int de_len; int i = 0; RSA *priv_rsa; char *b64_decode; int b64_decode_len = 0; char *input = NULL; if((fp=fopen(source_filename,"rb"))==NULL) { printf("cant open the file"); exit(0); } fseek(fp, 0L, SEEK_END); file_content_len = ftell(fp); fseek(fp, 0L, SEEK_SET); file_content = (char *)malloc(file_content_len); fread(file_content, 1, file_content_len, fp ); file_content[file_content_len] = '\0'; //fclose(fp); shopex_conf_rsa_decrypt(file_content,file_content_len,&output,&output_len); output_len = output_len > strlen(output) ? strlen(output) : output_len; b64_decode = (char *)malloc(output_len); input = (char *)malloc(output_len); memcpy(input,output,output_len); base64_decode(input,output_len,b64_decode,&b64_decode_len); printf("%d\n",b64_decode_len); for(i=0;i<b64_decode_len;i++){ printf("%2x",b64_decode[i]); } priv_rsa=d2i_RSAPrivateKey(NULL,(const unsigned char**)&b64_decode,(long)b64_decode_len); RSA_print_fp(stdout,priv_rsa,11); RSA_free(priv_rsa); }
SEXP PKI_load_private_RSA(SEXP what) { EVP_PKEY *key; RSA *rsa = 0; const unsigned char *ptr; if (TYPEOF(what) != RAWSXP) Rf_error("key must be a raw vector"); ptr = (const unsigned char *) RAW(what); rsa = d2i_RSAPrivateKey(&rsa, &ptr, LENGTH(what)); if (!rsa) Rf_error("%s", ERR_error_string(ERR_get_error(), NULL)); key = EVP_PKEY_new(); EVP_PKEY_assign_RSA(key, rsa); return wrap_EVP_PKEY(key, PKI_KT_PRIVATE); }
void pki_evp::veryOldFromData(unsigned char *p, int size ) { unsigned char *sik, *pdec, *pdec1, *sik1; int outl, decsize; unsigned char iv[EVP_MAX_IV_LENGTH]; unsigned char ckey[EVP_MAX_KEY_LENGTH]; memset(iv, 0, EVP_MAX_IV_LENGTH); RSA *rsakey; EVP_CIPHER_CTX ctx; const EVP_CIPHER *cipher = EVP_des_ede3_cbc(); sik = (unsigned char *)OPENSSL_malloc(size); check_oom(sik); pki_openssl_error(); pdec = (unsigned char *)OPENSSL_malloc(size); if (pdec == NULL ) { OPENSSL_free(sik); check_oom(pdec); } pdec1=pdec; sik1=sik; memcpy(iv, p, 8); /* recover the iv */ /* generate the key */ EVP_BytesToKey(cipher, EVP_sha1(), iv, (unsigned char *)oldpasswd, strlen(oldpasswd), 1, ckey,NULL); /* we use sha1 as message digest, * because an md5 version of the password is * stored in the database... */ EVP_CIPHER_CTX_init (&ctx); EVP_DecryptInit( &ctx, cipher, ckey, iv); EVP_DecryptUpdate( &ctx, pdec , &outl, p + 8, size -8 ); decsize = outl; EVP_DecryptFinal( &ctx, pdec + decsize , &outl ); decsize += outl; pki_openssl_error(); memcpy(sik, pdec, decsize); if (key->type == EVP_PKEY_RSA) { rsakey=d2i_RSAPrivateKey(NULL,(const unsigned char **)&pdec, decsize); if (pki_ign_openssl_error()) { rsakey = d2i_RSA_PUBKEY(NULL, (const unsigned char **)&sik, decsize); } pki_openssl_error(); if (rsakey) EVP_PKEY_assign_RSA(key, rsakey); } OPENSSL_free(sik1); OPENSSL_free(pdec1); EVP_CIPHER_CTX_cleanup(&ctx); pki_openssl_error(); encryptKey(); }
ndn_Error ndn_RsaPrivateKey_decode (struct ndn_RsaPrivateKey *self, const uint8_t *privateKeyDer, size_t privateKeyDerLength) { if (self->privateKey) // Free a previous value. RSA_free(self->privateKey); self->privateKey = d2i_RSAPrivateKey(NULL, &privateKeyDer, privateKeyDerLength); if (!self->privateKey) return NDN_ERROR_Error_decoding_key; return NDN_ERROR_success; }
int s2n_asn1der_to_rsa_private_key(struct s2n_rsa_private_key *key, struct s2n_blob *asn1der) { uint8_t *original_ptr = asn1der->data; key->rsa = d2i_RSAPrivateKey(NULL, (const unsigned char **)(void *)&asn1der->data, asn1der->size); if (key->rsa == NULL) { S2N_ERROR(S2N_ERR_DECODE_PRIVATE_KEY); } if (asn1der->data - original_ptr != asn1der->size) { S2N_ERROR(S2N_ERR_DECODE_PRIVATE_KEY); } return 0; }
int put_key_der(int is_public_only, PyObject *py_key_der, PyObject **py_private_key_ccn, PyObject **py_public_key_ccn, PyObject **py_public_key_digest, int *public_key_digest_len) { RSA *key_rsa = NULL; const unsigned char *key_der; Py_ssize_t der_len; int r; unsigned long err; r = PyBytes_AsStringAndSize(py_key_der, (char **) &key_der, &der_len); JUMP_IF_NEG(r, error); if (is_public_only) key_rsa = d2i_RSA_PUBKEY(NULL, &key_der, der_len); else key_rsa = d2i_RSAPrivateKey(NULL, &key_der, der_len); //above changes the key_der, so we set it to NULL for safety to not use it key_der = NULL; JUMP_IF_NULL(key_rsa, openssl_error); r = ccn_keypair_from_rsa(is_public_only, key_rsa, py_private_key_ccn, py_public_key_ccn); JUMP_IF_NEG(r, error); r = create_public_key_digest(key_rsa, py_public_key_digest, public_key_digest_len); JUMP_IF_NEG(r, error); RSA_free(key_rsa); return 0; openssl_error: err = ERR_get_error(); { char buf[256]; ERR_error_string_n(err, buf, sizeof(buf)); PyErr_Format(g_PyExc_CCNKeyError, "Unable to read Private Key: %s", buf); } error: RSA_free(key_rsa); return -1; }
int SSL_CTX_use_RSAPrivateKey_ASN1(SSL_CTX *ctx, const unsigned char *d, long len) { int ret; RSA *rsa; if ((rsa = d2i_RSAPrivateKey(NULL, &d, (long)len)) == NULL) { SSLerrorx(ERR_R_ASN1_LIB); return (0); } ret = SSL_CTX_use_RSAPrivateKey(ctx, rsa); RSA_free(rsa); return (ret); }
int SSL_use_RSAPrivateKey_ASN1(SSL *ssl, const unsigned char *d, long len) { int ret; const unsigned char *p; RSA *rsa; p = d; if ((rsa = d2i_RSAPrivateKey(NULL, &p, (long)len)) == NULL) { SSLerr(SSL_F_SSL_USE_RSAPRIVATEKEY_ASN1, ERR_R_ASN1_LIB); return (0); } ret = SSL_use_RSAPrivateKey(ssl, rsa); RSA_free(rsa); return (ret); }
static LUA_FUNCTION(openssl_rsa_read) { size_t l; const char* data = luaL_checklstring(L, 1, &l); const unsigned char* in = (const unsigned char*)data; RSA *rsa = d2i_RSAPrivateKey(NULL, &in, l); if (rsa == NULL) { in = (const unsigned char*)data; rsa = d2i_RSA_PUBKEY(NULL, &in, l); } if (rsa) PUSH_OBJECT(rsa, "openssl.rsa"); else lua_pushnil(L); return 1; }
static void Init() { ctx = SSL_CTX_new(SSLv23_method()); const uint8_t *bufp = kRSAPrivateKeyDER; RSA *privkey = d2i_RSAPrivateKey(NULL, &bufp, sizeof(kRSAPrivateKeyDER)); OPENSSL_assert(privkey != NULL); EVP_PKEY *pkey = EVP_PKEY_new(); EVP_PKEY_assign_RSA(pkey, privkey); int ret = SSL_CTX_use_PrivateKey(ctx, pkey); OPENSSL_assert(ret == 1); EVP_PKEY_free(pkey); bufp = kCertificateDER; X509 *cert = d2i_X509(NULL, &bufp, sizeof(kCertificateDER)); OPENSSL_assert(cert != NULL); ret = SSL_CTX_use_certificate(ctx, cert); OPENSSL_assert(ret == 1); X509_free(cert); }
RSAKey RSAKey::createFromPrivateCompound(const std::vector<unsigned char>& data) { const unsigned char* buf = reinterpret_cast<const unsigned char*>(&data[0]); RSA* prsa = NULL; if (!d2i_RSAPrivateKey(&prsa, &buf, static_cast<long>(data.size()))) { THROW_EXCEPTION_WITH_LOG(OpenSSLException, "Unable to read private key compound from the specified buffer."); } else { std::shared_ptr<RSA> sprsa(prsa, RSA_free); return RSAKey(sprsa, true); } }
main4() { FILE *in; unsigned char buf[10240],buf2[10240],*p; int num,i; RSA *nx=NULL,*mx=NULL; in=fopen("rsa.der","r"); if (in == NULL) { perror("rsa.der"); exit(1); } num=fread(buf,1,10240,in); fclose(in); p=buf; if (d2i_RSAPrivateKey(&nx,&p,num) == NULL) goto err; printf("num=%d p-buf=%d\n",num,p-buf); p=buf2; num=i2d_RSAPrivateKey(nx,&p); printf("num=%d p-buf=%d\n",num,p-buf2); if (memcmp(buf,buf2,num) != 0) { fprintf(stderr,"data difference\n"); for (i=0; i<num; i++) fprintf(stderr,"%c%03d <%02X-%02X>\n", (buf[i] == buf2[i])?' ':'*',i, buf[i],buf2[i]); fprintf(stderr,"\n"); exit(1); } return(1); err: ERR_load_crypto_strings(); ERR_print_errors(stderr); return(0); }
static int rsa_priv_decode(EVP_PKEY *pkey, PKCS8_PRIV_KEY_INFO *p8) { const uint8_t *p; int pklen; RSA *rsa; if (!PKCS8_pkey_get0(NULL, &p, &pklen, NULL, p8)) { OPENSSL_PUT_ERROR(EVP, rsa_priv_decode, ERR_R_MALLOC_FAILURE); return 0; } rsa = d2i_RSAPrivateKey(NULL, &p, pklen); if (rsa == NULL) { OPENSSL_PUT_ERROR(EVP, rsa_priv_decode, ERR_R_RSA_LIB); return 0; } EVP_PKEY_assign_RSA(pkey, rsa); return 1; }
SEXP R_rsa_priv_decompose(SEXP bin){ RSA *rsa = RSA_new(); const unsigned char *ptr = RAW(bin); bail(!!d2i_RSAPrivateKey(&rsa, &ptr, LENGTH(bin))); const BIGNUM *e, *n, *p, *q, *d, *dmp1, *dmq1, *iqmp; MY_RSA_get0_key(rsa, &n, &e, &d); MY_RSA_get0_factors(rsa, &p, &q); MY_RSA_get0_crt_params(rsa, &dmp1, &dmq1, &iqmp); SEXP res = PROTECT(allocVector(VECSXP, 8)); SET_VECTOR_ELT(res, 0, bignum_to_r(e)); SET_VECTOR_ELT(res, 1, bignum_to_r(n)); SET_VECTOR_ELT(res, 2, bignum_to_r(p)); SET_VECTOR_ELT(res, 3, bignum_to_r(q)); SET_VECTOR_ELT(res, 4, bignum_to_r(d)); SET_VECTOR_ELT(res, 5, bignum_to_r(dmp1)); SET_VECTOR_ELT(res, 6, bignum_to_r(dmq1)); SET_VECTOR_ELT(res, 7, bignum_to_r(iqmp)); UNPROTECT(1); return res; }
static int rsa_priv_decode(EVP_PKEY *pkey, const PKCS8_PRIV_KEY_INFO *p8) { const unsigned char *p; RSA *rsa; int pklen; const X509_ALGOR *alg; if (!PKCS8_pkey_get0(NULL, &p, &pklen, &alg, p8)) return 0; rsa = d2i_RSAPrivateKey(NULL, &p, pklen); if (rsa == NULL) { RSAerr(RSA_F_RSA_PRIV_DECODE, ERR_R_RSA_LIB); return 0; } if (!rsa_param_decode(rsa, alg)) { RSA_free(rsa); return 0; } EVP_PKEY_assign(pkey, pkey->ameth->pkey_id, rsa); return 1; }
wi_rsa_t * wi_rsa_init_with_private_key(wi_rsa_t *rsa, wi_data_t *data) { const unsigned char *buffer; long length; buffer = wi_data_bytes(data); length = wi_data_length(data); rsa->rsa = d2i_RSAPrivateKey(NULL, &buffer, length); if(!rsa->rsa) { wi_error_set_openssl_error(); wi_release(rsa); return NULL; } rsa->private_key = wi_retain(data); return rsa; }