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;
}
