int i2d_PublicKey(EVP_PKEY *key, uint8_t **outp) { switch (key->type) { case EVP_PKEY_RSA: return i2d_RSAPublicKey(key->pkey.rsa, outp); case EVP_PKEY_DSA: return i2d_DSAPublicKey(key->pkey.dsa, outp); case EVP_PKEY_EC: return i2o_ECPublicKey(key->pkey.ec, outp); default: OPENSSL_PUT_ERROR(EVP, EVP_R_UNSUPPORTED_PUBLIC_KEY_TYPE); return -1; } }
static int dsa_pub_encode(X509_PUBKEY *pk, const EVP_PKEY *pkey) { DSA *dsa; void *pval = NULL; int ptype; unsigned char *penc = NULL; int penclen; dsa = pkey->pkey.dsa; if (pkey->save_parameters && dsa->p && dsa->q && dsa->g) { ASN1_STRING *str; str = ASN1_STRING_new(); if (str == NULL) { DSAerror(ERR_R_MALLOC_FAILURE); goto err; } str->length = i2d_DSAparams(dsa, &str->data); if (str->length <= 0) { DSAerror(ERR_R_MALLOC_FAILURE); ASN1_STRING_free(str); goto err; } pval = str; ptype = V_ASN1_SEQUENCE; } else ptype = V_ASN1_UNDEF; dsa->write_params = 0; penclen = i2d_DSAPublicKey(dsa, &penc); if (penclen <= 0) { DSAerror(ERR_R_MALLOC_FAILURE); goto err; } if (X509_PUBKEY_set0_param(pk, OBJ_nid2obj(EVP_PKEY_DSA), ptype, pval, penc, penclen)) return 1; err: free(penc); ASN1_STRING_free(pval); return 0; }
static int dsa_pub_encode(X509_PUBKEY *pk, const EVP_PKEY *pkey) { DSA *dsa; ASN1_STRING *pval = NULL; uint8_t *penc = NULL; int penclen; dsa = pkey->pkey.dsa; dsa->write_params = 0; int ptype; if (dsa->p && dsa->q && dsa->g) { pval = ASN1_STRING_new(); if (!pval) { OPENSSL_PUT_ERROR(EVP, ERR_R_MALLOC_FAILURE); goto err; } pval->length = i2d_DSAparams(dsa, &pval->data); if (pval->length <= 0) { OPENSSL_PUT_ERROR(EVP, ERR_R_MALLOC_FAILURE); goto err; } ptype = V_ASN1_SEQUENCE; } else { ptype = V_ASN1_UNDEF; } penclen = i2d_DSAPublicKey(dsa, &penc); if (penclen <= 0) { OPENSSL_PUT_ERROR(EVP, ERR_R_MALLOC_FAILURE); goto err; } if (X509_PUBKEY_set0_param(pk, OBJ_nid2obj(EVP_PKEY_DSA), ptype, pval, penc, penclen)) { return 1; } err: OPENSSL_free(penc); ASN1_STRING_free(pval); return 0; }
int i2d_PublicKey(const EVP_PKEY *a, unsigned char **pp) { switch (EVP_PKEY_id(a)) { #ifndef OPENSSL_NO_RSA case EVP_PKEY_RSA: return i2d_RSAPublicKey(EVP_PKEY_get0_RSA(a), pp); #endif #ifndef OPENSSL_NO_DSA case EVP_PKEY_DSA: return i2d_DSAPublicKey(EVP_PKEY_get0_DSA(a), pp); #endif #ifndef OPENSSL_NO_EC case EVP_PKEY_EC: return i2o_ECPublicKey(EVP_PKEY_get0_EC_KEY(a), pp); #endif default: ASN1err(ASN1_F_I2D_PUBLICKEY, ASN1_R_UNSUPPORTED_PUBLIC_KEY_TYPE); return -1; } }
int i2d_PublicKey(EVP_PKEY *a, unsigned char **pp) { switch (a->type) { #ifndef OPENSSL_NO_RSA case EVP_PKEY_RSA: return (i2d_RSAPublicKey(a->pkey.rsa, pp)); #endif #ifndef OPENSSL_NO_DSA case EVP_PKEY_DSA: return (i2d_DSAPublicKey(a->pkey.dsa, pp)); #endif #ifndef OPENSSL_NO_EC case EVP_PKEY_EC: return (i2o_ECPublicKey(a->pkey.ec, pp)); #endif default: ASN1err(ASN1_F_I2D_PUBLICKEY, ASN1_R_UNSUPPORTED_PUBLIC_KEY_TYPE); return (-1); } }
QSslKey SafetPKCS12::keyFromEVP( EVP_PKEY * evp ) { EVP_PKEY *key = (EVP_PKEY*)evp; unsigned char *data = NULL; int len = 0; QSsl::KeyAlgorithm alg; QSsl::KeyType type; switch( EVP_PKEY_type( key->type ) ) { case EVP_PKEY_RSA: { RSA *rsa = EVP_PKEY_get1_RSA( key ); alg = QSsl::Rsa; type = rsa->d ? QSsl::PrivateKey : QSsl::PublicKey; len = rsa->d ? i2d_RSAPrivateKey( rsa, &data ) : i2d_RSAPublicKey( rsa, &data ); RSA_free( rsa ); break; } case EVP_PKEY_DSA: { DSA *dsa = EVP_PKEY_get1_DSA( key ); alg = QSsl::Dsa; type = dsa->priv_key ? QSsl::PrivateKey : QSsl::PublicKey; len = dsa->priv_key ? i2d_DSAPrivateKey( dsa, &data ) : i2d_DSAPublicKey( dsa, &data ); DSA_free( dsa ); break; } default: break; } QSslKey k; if( len > 0 ) k = QSslKey( QByteArray( (char*)data, len ), alg, QSsl::Der, type ); OPENSSL_free( data ); return k; }
/* * ASCII-encode a key. */ char * kn_encode_key(struct keynote_deckey *dc, int iencoding, int encoding, int keytype) { char *foo, *ptr; DSA *dsa; RSA *rsa; int i; struct keynote_binary *bn; char *s; keynote_errno = 0; if (dc == NULL || dc->dec_key == NULL) { keynote_errno = ERROR_NOTFOUND; return NULL; } /* DSA keys */ if ((dc->dec_algorithm == KEYNOTE_ALGORITHM_DSA) && (iencoding == INTERNAL_ENC_ASN1) && ((encoding == ENCODING_HEX) || (encoding == ENCODING_BASE64))) { dsa = (DSA *) dc->dec_key; if (keytype == KEYNOTE_PUBLIC_KEY) i = i2d_DSAPublicKey(dsa, NULL); else i = i2d_DSAPrivateKey(dsa, NULL); if (i <= 0) { keynote_errno = ERROR_SYNTAX; return NULL; } ptr = foo = calloc(i, sizeof(char)); if (foo == NULL) { keynote_errno = ERROR_MEMORY; return NULL; } dsa->write_params = 1; if (keytype == KEYNOTE_PUBLIC_KEY) i2d_DSAPublicKey(dsa, (unsigned char **) &foo); else i2d_DSAPrivateKey(dsa, (unsigned char **) &foo); if (encoding == ENCODING_HEX) { if (kn_encode_hex(ptr, &s, i) != 0) { free(ptr); return NULL; } free(ptr); return s; } else if (encoding == ENCODING_BASE64) { s = calloc(2 * i, sizeof(char)); if (s == NULL) { free(ptr); keynote_errno = ERROR_MEMORY; return NULL; } if (kn_encode_base64(ptr, i, s, 2 * i) == -1) { free(s); free(ptr); return NULL; } free(ptr); return s; } } /* RSA keys */ if ((dc->dec_algorithm == KEYNOTE_ALGORITHM_RSA) && (iencoding == INTERNAL_ENC_PKCS1) && ((encoding == ENCODING_HEX) || (encoding == ENCODING_BASE64))) { rsa = (RSA *) dc->dec_key; if (keytype == KEYNOTE_PUBLIC_KEY) i = i2d_RSAPublicKey(rsa, NULL); else i = i2d_RSAPrivateKey(rsa, NULL); if (i <= 0) { keynote_errno = ERROR_SYNTAX; return NULL; } ptr = foo = calloc(i, sizeof(char)); if (foo == NULL) { keynote_errno = ERROR_MEMORY; return NULL; } if (keytype == KEYNOTE_PUBLIC_KEY) i2d_RSAPublicKey(rsa, (unsigned char **) &foo); else i2d_RSAPrivateKey(rsa, (unsigned char **) &foo); if (encoding == ENCODING_HEX) { if (kn_encode_hex(ptr, &s, i) != 0) { free(ptr); return NULL; } free(ptr); return s; } else if (encoding == ENCODING_BASE64) { s = calloc(2 * i, sizeof(char)); if (s == NULL) { free(ptr); keynote_errno = ERROR_MEMORY; return NULL; } if (kn_encode_base64(ptr, i, s, 2 * i) == -1) { free(s); free(ptr); return NULL; } free(ptr); return s; } } /* BINARY keys */ if ((dc->dec_algorithm == KEYNOTE_ALGORITHM_BINARY) && (iencoding == INTERNAL_ENC_NONE) && ((encoding == ENCODING_HEX) || (encoding == ENCODING_BASE64))) { bn = (struct keynote_binary *) dc->dec_key; if (encoding == ENCODING_HEX) { if (kn_encode_hex(bn->bn_key, &s, bn->bn_len) != 0) return NULL; return s; } else if (encoding == ENCODING_BASE64) { s = calloc(2 * bn->bn_len, sizeof(char)); if (s == NULL) { keynote_errno = ERROR_MEMORY; return NULL; } if (kn_encode_base64(bn->bn_key, bn->bn_len, s, 2 * bn->bn_len) == -1) { free(s); return NULL; } return s; } } keynote_errno = ERROR_NOTFOUND; return NULL; }