int crypto_sign_keypair(unsigned char *pk,unsigned char *sk)
{
DSA *x;
int len;
x = DSA_new();
if (!x) return -1;
memset(sk,0,SECRETKEY_BYTES);
memset(pk,0,PUBLICKEY_BYTES);
x->p = BN_new(); if (!x->p) goto error;
x->q = BN_new(); if (!x->q) goto error;
x->g = BN_new(); if (!x->g) goto error;
if (!BN_bin2bn(prime,sizeof prime,x->p)) goto error;
if (!BN_bin2bn(prime_q,sizeof prime_q,x->q)) goto error;
if (!BN_bin2bn(prime_g,sizeof prime_g,x->g)) goto error;
if (!DSA_generate_key(x)) goto error;
len = BN_num_bytes(x->pub_key); if (len > PUBLICKEY_BYTES) goto error;
BN_bn2bin(x->pub_key,pk + PUBLICKEY_BYTES - len);
BN_bn2bin(x->pub_key,sk + PUBLICKEY_BYTES - len);
len = BN_num_bytes(x->priv_key); if (len > SECRETKEY_BYTES - PUBLICKEY_BYTES) goto error;
BN_bn2bin(x->priv_key,sk + SECRETKEY_BYTES - len);
DSA_free(x);
return 0;
error:
DSA_free(x);
return -1;
}
void openssl_dsa_crypt()
{
DSA *d;
unsigned int size, len;
unsigned char inputs[COMM_LEN] = "dsa crypt";
unsigned char outputs[MAX1_LEN] = { 0 };
printf("\nDSA generate key:\n");
d = DSA_new();
DSA_generate_parameters_ex(d, LINE_LEN, NULL, 0, NULL, NULL, NULL);
DSA_generate_key(d);
DSA_print_fp(stdout, d, 0);
DSA_sign(NID_md5_sha1, inputs, 20, outputs, &len, d);
printf("DSA_sign(%s) = ", inputs);
for (size = 0; size < len; size++)
printf("%.02x", outputs[size]);
printf("\n");
DSA_verify(NID_md5_sha1, inputs, 20, outputs, len, d);
printf("DSA_verify(");
for (size = 0; size < len; size++)
printf("%.02x", outputs[size]);
printf(") = %s\n", inputs);
DSA_free(d);
}
//
// DSA構造体の複製
//
DSA *duplicate_DSA(DSA *src)
{
DSA *dsa = NULL;
dsa = DSA_new();
if (dsa == NULL)
goto error;
dsa->p = BN_new();
dsa->q = BN_new();
dsa->g = BN_new();
dsa->pub_key = BN_new();
if (dsa->p == NULL ||
dsa->q == NULL ||
dsa->g == NULL ||
dsa->pub_key == NULL) {
DSA_free(dsa);
goto error;
}
// 深いコピー(deep copy)を行う。浅いコピー(shallow copy)はNG。
BN_copy(dsa->p, src->p);
BN_copy(dsa->q, src->q);
BN_copy(dsa->g, src->g);
BN_copy(dsa->pub_key, src->pub_key);
error:
return (dsa);
}
static isc_result_t
openssldsa_generate(dst_key_t *key, int unused, void (*callback)(int)) {
DSA *dsa;
unsigned char rand_array[ISC_SHA1_DIGESTLENGTH];
isc_result_t result;
#if OPENSSL_VERSION_NUMBER > 0x00908000L
BN_GENCB cb;
union {
void *dptr;
void (*fptr)(int);
} u;
#else
UNUSED(callback);
#endif
UNUSED(unused);
result = dst__entropy_getdata(rand_array, sizeof(rand_array),
ISC_FALSE);
if (result != ISC_R_SUCCESS)
return (result);
#if OPENSSL_VERSION_NUMBER > 0x00908000L
dsa = DSA_new();
if (dsa == NULL)
return (dst__openssl_toresult(DST_R_OPENSSLFAILURE));
if (callback == NULL) {
BN_GENCB_set_old(&cb, NULL, NULL);
} else {
u.fptr = callback;
BN_GENCB_set(&cb, &progress_cb, u.dptr);
}
if (!DSA_generate_parameters_ex(dsa, key->key_size, rand_array,
ISC_SHA1_DIGESTLENGTH, NULL, NULL,
&cb))
{
DSA_free(dsa);
return (dst__openssl_toresult(DST_R_OPENSSLFAILURE));
}
#else
dsa = DSA_generate_parameters(key->key_size, rand_array,
ISC_SHA1_DIGESTLENGTH, NULL, NULL,
NULL, NULL);
if (dsa == NULL)
return (dst__openssl_toresult(DST_R_OPENSSLFAILURE));
#endif
if (DSA_generate_key(dsa) == 0) {
DSA_free(dsa);
return (dst__openssl_toresult(DST_R_OPENSSLFAILURE));
}
dsa->flags &= ~DSA_FLAG_CACHE_MONT_P;
key->keydata.dsa = dsa;
return (ISC_R_SUCCESS);
}
static int dsa_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from)
{
BIGNUM *a;
if (to->pkey.dsa == NULL) {
to->pkey.dsa = DSA_new();
if (to->pkey.dsa == NULL)
return 0;
}
if ((a = BN_dup(from->pkey.dsa->p)) == NULL)
return 0;
BN_free(to->pkey.dsa->p);
to->pkey.dsa->p = a;
if ((a = BN_dup(from->pkey.dsa->q)) == NULL)
return 0;
BN_free(to->pkey.dsa->q);
to->pkey.dsa->q = a;
if ((a = BN_dup(from->pkey.dsa->g)) == NULL)
return 0;
BN_free(to->pkey.dsa->g);
to->pkey.dsa->g = a;
return 1;
}
static int constructDSASigningKey(struct pgpDigKeyDSA_s *key)
{
int rc;
if (key->dsa_key) {
/* We've already constructed it, so just reuse it */
return 1;
}
/* Create the DSA key */
DSA *dsa = DSA_new();
if (!dsa) return 0;
if (!DSA_set0_pqg(dsa, key->p, key->q, key->g)) {
rc = 0;
goto done;
}
if (!DSA_set0_key(dsa, key->y, NULL)) {
rc = 0;
goto done;
}
key->dsa_key = dsa;
rc = 1;
done:
if (rc == 0) {
DSA_free(dsa);
}
return rc;
}
int
_libssh2_dsa_new(libssh2_dsa_ctx ** dsactx,
const unsigned char *p,
unsigned long p_len,
const unsigned char *q,
unsigned long q_len,
const unsigned char *g,
unsigned long g_len,
const unsigned char *y,
unsigned long y_len,
const unsigned char *x, unsigned long x_len)
{
*dsactx = DSA_new();
(*dsactx)->p = BN_new();
BN_bin2bn(p, p_len, (*dsactx)->p);
(*dsactx)->q = BN_new();
BN_bin2bn(q, q_len, (*dsactx)->q);
(*dsactx)->g = BN_new();
BN_bin2bn(g, g_len, (*dsactx)->g);
(*dsactx)->pub_key = BN_new();
BN_bin2bn(y, y_len, (*dsactx)->pub_key);
if (x_len) {
(*dsactx)->priv_key = BN_new();
BN_bin2bn(x, x_len, (*dsactx)->priv_key);
}
return 0;
}
static int gost_set_priv_key(EVP_PKEY *pkey,BIGNUM *priv)
{
switch (EVP_PKEY_base_id(pkey))
{
case NID_id_GostR3410_94:
{
DSA *dsa = EVP_PKEY_get0(pkey);
if (!dsa)
{
dsa = DSA_new();
EVP_PKEY_assign(pkey,EVP_PKEY_base_id(pkey),dsa);
}
dsa->priv_key = BN_dup(priv);
if (!EVP_PKEY_missing_parameters(pkey))
gost94_compute_public(dsa);
break;
}
case NID_id_GostR3410_2001:
{
EC_KEY *ec = EVP_PKEY_get0(pkey);
if (!ec)
{
ec = EC_KEY_new();
EVP_PKEY_assign(pkey,EVP_PKEY_base_id(pkey),ec);
}
if (!EC_KEY_set_private_key(ec,priv)) return 0;
if (!EVP_PKEY_missing_parameters(pkey))
gost2001_compute_public(ec);
break;
}
}
return 1;
}
// Create the OpenSSL representation of the key
void OSSLDSAPublicKey::createOSSLKey()
{
if (dsa != NULL) return;
dsa = DSA_new();
if (dsa == NULL)
{
ERROR_MSG("Could not create DSA object");
return;
}
// Use the OpenSSL implementation and not any engine
#if OPENSSL_VERSION_NUMBER < 0x10100000L
#ifdef WITH_FIPS
if (FIPS_mode())
DSA_set_method(dsa, FIPS_dsa_openssl());
else
DSA_set_method(dsa, DSA_OpenSSL());
#else
DSA_set_method(dsa, DSA_OpenSSL());
#endif
#else
DSA_set_method(dsa, DSA_OpenSSL());
#endif
BIGNUM* bn_p = OSSL::byteString2bn(p);
BIGNUM* bn_q = OSSL::byteString2bn(q);
BIGNUM* bn_g = OSSL::byteString2bn(g);
BIGNUM* bn_pub_key = OSSL::byteString2bn(y);
DSA_set0_pqg(dsa, bn_p, bn_q, bn_g);
DSA_set0_key(dsa, bn_pub_key, NULL);
}
/**
* private static native int EVP_PKEY_new_DSA(byte[] p, byte[] q, byte[] g, byte[] pub_key, byte[] priv_key);
*/
static EVP_PKEY* NativeCrypto_EVP_PKEY_new_DSA(JNIEnv* env, jclass clazz, jbyteArray p, jbyteArray q, jbyteArray g, jbyteArray pub_key, jbyteArray priv_key) {
// LOGD("Entering EVP_PKEY_new_DSA()");
DSA* dsa = DSA_new();
dsa->p = arrayToBignum(env, p);
dsa->q = arrayToBignum(env, q);
dsa->g = arrayToBignum(env, g);
dsa->pub_key = arrayToBignum(env, pub_key);
if (priv_key != NULL) {
dsa->priv_key = arrayToBignum(env, priv_key);
}
if (dsa->p == NULL || dsa->q == NULL || dsa->g == NULL || dsa->pub_key == NULL) {
DSA_free(dsa);
throwRuntimeException(env, "Unable to convert BigInteger to BIGNUM");
return NULL;
}
EVP_PKEY* pkey = EVP_PKEY_new();
EVP_PKEY_assign_DSA(pkey, dsa);
return pkey;
}
static int param_copy_gost94(EVP_PKEY *to, const EVP_PKEY *from)
{
const DSA *dfrom = EVP_PKEY_get0((EVP_PKEY *)from);
DSA *dto = EVP_PKEY_get0(to);
if (EVP_PKEY_base_id(from) != EVP_PKEY_base_id(to))
{
GOSTerr(GOST_F_PARAM_COPY_GOST94,
GOST_R_INCOMPATIBLE_ALGORITHMS);
return 0;
}
if (!dfrom)
{
GOSTerr(GOST_F_PARAM_COPY_GOST94,
GOST_R_KEY_PARAMETERS_MISSING);
return 0;
}
if (!dto)
{
dto = DSA_new();
EVP_PKEY_assign(to,EVP_PKEY_base_id(from),dto);
}
#define COPYBIGNUM(a,b,x) if (a->x) BN_free(a->x); a->x=BN_dup(b->x);
COPYBIGNUM(dto,dfrom,p)
COPYBIGNUM(dto,dfrom,q)
COPYBIGNUM(dto,dfrom,g)
if (dto->priv_key)
gost94_compute_public(dto);
return 1;
}
static int pkey_dsa_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
{
DSA *dsa = NULL;
DSA_PKEY_CTX *dctx = ctx->data;
BN_GENCB *pcb;
int ret;
if (ctx->pkey_gencb) {
pcb = BN_GENCB_new();
if (pcb == NULL)
return 0;
evp_pkey_set_cb_translate(pcb, ctx);
} else
pcb = NULL;
dsa = DSA_new();
if (dsa == NULL) {
BN_GENCB_free(pcb);
return 0;
}
ret = dsa_builtin_paramgen(dsa, dctx->nbits, dctx->qbits, dctx->pmd,
NULL, 0, NULL, NULL, NULL, pcb);
BN_GENCB_free(pcb);
if (ret)
EVP_PKEY_assign_DSA(pkey, dsa);
else
DSA_free(dsa);
return ret;
}
OpenSSLCryptoKeyDSA::OpenSSLCryptoKeyDSA() {
// Create a new key to be loaded as we go
mp_dsaKey = DSA_new();
};
DSA *DSA_parse_private_key(CBS *cbs) {
DSA *ret = DSA_new();
if (ret == NULL) {
return NULL;
}
CBS child;
uint64_t version;
if (!CBS_get_asn1(cbs, &child, CBS_ASN1_SEQUENCE) ||
!CBS_get_asn1_uint64(&child, &version)) {
OPENSSL_PUT_ERROR(DSA, DSA_R_DECODE_ERROR);
goto err;
}
if (version != 0) {
OPENSSL_PUT_ERROR(DSA, DSA_R_BAD_VERSION);
goto err;
}
if (!parse_integer(&child, &ret->p) ||
!parse_integer(&child, &ret->q) ||
!parse_integer(&child, &ret->g) ||
!parse_integer(&child, &ret->pub_key) ||
!parse_integer(&child, &ret->priv_key) ||
CBS_len(&child) != 0) {
OPENSSL_PUT_ERROR(DSA, DSA_R_DECODE_ERROR);
goto err;
}
return ret;
err:
DSA_free(ret);
return NULL;
}
void OpenSSLCryptoKeyDSA::loadJBase64BigNums(const char * b64, unsigned int len) {
if (mp_dsaKey == NULL)
mp_dsaKey = DSA_new();
// Do nothing
}
DSA *DSA_generate_parameters(int bits,
unsigned char *seed_in, int seed_len,
int *counter_ret, unsigned long *h_ret,
void (*callback) (int, int, void *),
void *cb_arg)
{
BN_GENCB *cb;
DSA *ret;
if ((ret = DSA_new()) == NULL)
return NULL;
cb = BN_GENCB_new();
if (cb == NULL)
goto err;
BN_GENCB_set_old(cb, callback, cb_arg);
if (DSA_generate_parameters_ex(ret, bits, seed_in, seed_len,
counter_ret, h_ret, cb)) {
BN_GENCB_free(cb);
return ret;
}
BN_GENCB_free(cb);
err:
DSA_free(ret);
return NULL;
}
/*
* Parses GOST algorithm parameters from X509_ALGOR and modifies pkey setting
* NID and parameters
*/
static int decode_gost_algor_params(EVP_PKEY *pkey, X509_ALGOR *palg)
{
ASN1_OBJECT *palg_obj = NULL;
int ptype = V_ASN1_UNDEF;
int pkey_nid = NID_undef, param_nid = NID_undef;
void *_pval;
ASN1_STRING *pval = NULL;
const unsigned char *p;
GOST_KEY_PARAMS *gkp = NULL;
X509_ALGOR_get0(&palg_obj, &ptype, &_pval, palg);
pval = _pval;
if (ptype != V_ASN1_SEQUENCE) {
GOSTerr(GOST_F_DECODE_GOST_ALGOR_PARAMS,
GOST_R_BAD_KEY_PARAMETERS_FORMAT);
return 0;
}
p = pval->data;
pkey_nid = OBJ_obj2nid(palg_obj);
gkp = d2i_GOST_KEY_PARAMS(NULL, &p, pval->length);
if (!gkp) {
GOSTerr(GOST_F_DECODE_GOST_ALGOR_PARAMS,
GOST_R_BAD_PKEY_PARAMETERS_FORMAT);
return 0;
}
param_nid = OBJ_obj2nid(gkp->key_params);
GOST_KEY_PARAMS_free(gkp);
if(!EVP_PKEY_set_type(pkey, pkey_nid)) {
GOSTerr(GOST_F_DECODE_GOST_ALGOR_PARAMS, ERR_R_INTERNAL_ERROR);
return 0;
}
switch (pkey_nid) {
case NID_id_GostR3410_94:
{
DSA *dsa = EVP_PKEY_get0(pkey);
if (!dsa) {
dsa = DSA_new();
if (!EVP_PKEY_assign(pkey, pkey_nid, dsa))
return 0;
}
if (!fill_GOST94_params(dsa, param_nid))
return 0;
break;
}
case NID_id_GostR3410_2001:
{
EC_KEY *ec = EVP_PKEY_get0(pkey);
if (!ec) {
ec = EC_KEY_new();
if (!EVP_PKEY_assign(pkey, pkey_nid, ec))
return 0;
}
if (!fill_GOST2001_params(ec, param_nid))
return 0;
}
}
return 1;
}
static EP_STAT
generate_dsa_key(EP_CRYPTO_KEY *key, int keylen)
{
DSA *dsakey;
// generate new parameter block
dsakey = DSA_new();
if (DSA_generate_parameters_ex(dsakey, keylen,
NULL, 0, NULL, NULL, NULL) != 1)
{
_ep_crypto_error("cannot initialize DSA parameters");
goto fail0;
}
if (DSA_generate_key(dsakey) != 1)
{
_ep_crypto_error("cannot generate DSA key");
goto fail0;
}
if (EVP_PKEY_assign_DSA(key, dsakey) != 1)
{
_ep_crypto_error("cannot save DSA key");
goto fail0;
}
return EP_STAT_OK;
fail0:
return EP_STAT_CRYPTO_KEYCREATE;
}
void OpenSSLCryptoKeyDSA::loadPBase64BigNums(const char * b64, unsigned int len) {
if (mp_dsaKey == NULL)
mp_dsaKey = DSA_new();
mp_dsaKey->p = OpenSSLCryptoBase64::b642BN((char *) b64, len);
}
static int dsa_pub_decode(EVP_PKEY *pkey, X509_PUBKEY *pubkey)
{
const unsigned char *p, *pm;
int pklen, pmlen;
int ptype;
void *pval;
ASN1_STRING *pstr;
X509_ALGOR *palg;
ASN1_INTEGER *public_key = NULL;
DSA *dsa = NULL;
if (!X509_PUBKEY_get0_param(NULL, &p, &pklen, &palg, pubkey))
return 0;
X509_ALGOR_get0(NULL, &ptype, &pval, palg);
if (ptype == V_ASN1_SEQUENCE) {
pstr = pval;
pm = pstr->data;
pmlen = pstr->length;
if (!(dsa = d2i_DSAparams(NULL, &pm, pmlen))) {
DSAerr(DSA_F_DSA_PUB_DECODE, DSA_R_DECODE_ERROR);
goto err;
}
} else if ((ptype == V_ASN1_NULL) || (ptype == V_ASN1_UNDEF)) {
if (!(dsa = DSA_new())) {
DSAerr(DSA_F_DSA_PUB_DECODE, ERR_R_MALLOC_FAILURE);
goto err;
}
} else {
DSAerr(DSA_F_DSA_PUB_DECODE, DSA_R_PARAMETER_ENCODING_ERROR);
goto err;
}
if (!(public_key = d2i_ASN1_INTEGER(NULL, &p, pklen))) {
DSAerr(DSA_F_DSA_PUB_DECODE, DSA_R_DECODE_ERROR);
goto err;
}
if (!(dsa->pub_key = ASN1_INTEGER_to_BN(public_key, NULL))) {
DSAerr(DSA_F_DSA_PUB_DECODE, DSA_R_BN_DECODE_ERROR);
goto err;
}
ASN1_INTEGER_free(public_key);
EVP_PKEY_assign_DSA(pkey, dsa);
return 1;
err:
if (public_key)
ASN1_INTEGER_free(public_key);
if (dsa)
DSA_free(dsa);
return 0;
}
static int dsa_pub_decode(EVP_PKEY *pkey, X509_PUBKEY *pubkey) {
const uint8_t *p, *pm;
int pklen, pmlen;
int ptype;
void *pval;
ASN1_STRING *pstr;
X509_ALGOR *palg;
ASN1_INTEGER *public_key = NULL;
DSA *dsa = NULL;
if (!X509_PUBKEY_get0_param(NULL, &p, &pklen, &palg, pubkey)) {
return 0;
}
X509_ALGOR_get0(NULL, &ptype, &pval, palg);
if (ptype == V_ASN1_SEQUENCE) {
pstr = pval;
pm = pstr->data;
pmlen = pstr->length;
dsa = d2i_DSAparams(NULL, &pm, pmlen);
if (dsa == NULL) {
OPENSSL_PUT_ERROR(EVP, EVP_R_DECODE_ERROR);
goto err;
}
} else if (ptype == V_ASN1_NULL || ptype == V_ASN1_UNDEF) {
dsa = DSA_new();
if (dsa == NULL) {
OPENSSL_PUT_ERROR(EVP, ERR_R_MALLOC_FAILURE);
goto err;
}
} else {
OPENSSL_PUT_ERROR(EVP, EVP_R_PARAMETER_ENCODING_ERROR);
goto err;
}
public_key = d2i_ASN1_INTEGER(NULL, &p, pklen);
if (public_key == NULL) {
OPENSSL_PUT_ERROR(EVP, EVP_R_DECODE_ERROR);
goto err;
}
dsa->pub_key = ASN1_INTEGER_to_BN(public_key, NULL);
if (dsa->pub_key == NULL) {
OPENSSL_PUT_ERROR(EVP, EVP_R_BN_DECODE_ERROR);
goto err;
}
ASN1_INTEGER_free(public_key);
EVP_PKEY_assign_DSA(pkey, dsa);
return 1;
err:
ASN1_INTEGER_free(public_key);
DSA_free(dsa);
return 0;
}
static isc_result_t
openssldsa_parse(dst_key_t *key, isc_lex_t *lexer, dst_key_t *pub) {
dst_private_t priv;
isc_result_t ret;
int i;
DSA *dsa = NULL;
isc_mem_t *mctx = key->mctx;
#define DST_RET(a) {ret = a; goto err;}
UNUSED(pub);
/* read private key file */
ret = dst__privstruct_parse(key, DST_ALG_DSA, lexer, mctx, &priv);
if (ret != ISC_R_SUCCESS)
return (ret);
dsa = DSA_new();
if (dsa == NULL)
DST_RET(ISC_R_NOMEMORY);
dsa->flags &= ~DSA_FLAG_CACHE_MONT_P;
key->keydata.dsa = dsa;
for (i=0; i < priv.nelements; i++) {
BIGNUM *bn;
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_DSA_PRIME:
dsa->p = bn;
break;
case TAG_DSA_SUBPRIME:
dsa->q = bn;
break;
case TAG_DSA_BASE:
dsa->g = bn;
break;
case TAG_DSA_PRIVATE:
dsa->priv_key = bn;
break;
case TAG_DSA_PUBLIC:
dsa->pub_key = bn;
break;
}
}
dst__privstruct_free(&priv, mctx);
key->key_size = BN_num_bits(dsa->p);
return (ISC_R_SUCCESS);
err:
openssldsa_destroy(key);
dst__privstruct_free(&priv, mctx);
memset(&priv, 0, sizeof(priv));
return (ret);
}
DSA *xDSA_generate_parameters(int bits) {
DSA *dsa = DSA_new();
if(xDSA_paramgen(dsa, bits) != 0) {
return dsa;
}
DSA_free(dsa);
return NULL;
}
void sigver()
{
DSA *dsa=NULL;
char buf[1024];
int nmod=0;
unsigned char hash[20];
DSA_SIG *sig=DSA_SIG_new();
while(fgets(buf,sizeof buf,stdin) != NULL)
{
if(!strncmp(buf,"[mod = ",7))
{
nmod=atoi(buf+7);
if(dsa)
DSA_free(dsa);
dsa=DSA_new();
}
else if(!strncmp(buf,"P = ",4))
dsa->p=hex2bn(buf+4);
else if(!strncmp(buf,"Q = ",4))
dsa->q=hex2bn(buf+4);
else if(!strncmp(buf,"G = ",4))
{
dsa->g=hex2bn(buf+4);
printf("[mod = %d]\n\n",nmod);
pbn("P",dsa->p);
pbn("Q",dsa->q);
pbn("G",dsa->g);
putc('\n',stdout);
}
else if(!strncmp(buf,"Msg = ",6))
{
unsigned char msg[1024];
int n;
n=hex2bin(buf+6,msg);
pv("Msg",msg,n);
SHA1(msg,n,hash);
}
else if(!strncmp(buf,"Y = ",4))
dsa->pub_key=hex2bn(buf+4);
else if(!strncmp(buf,"R = ",4))
sig->r=hex2bn(buf+4);
else if(!strncmp(buf,"S = ",4))
{
sig->s=hex2bn(buf+4);
pbn("Y",dsa->pub_key);
pbn("R",sig->r);
pbn("S",sig->s);
printf("Result = %c\n",DSA_do_verify(hash,sizeof hash,sig,dsa)
? 'P' : 'F');
putc('\n',stdout);
}
}
}
// Key factory
bool OSSLDSA::generateKeyPair(AsymmetricKeyPair** ppKeyPair, AsymmetricParameters* parameters, RNG* /*rng = NULL */)
{
// Check parameters
if ((ppKeyPair == NULL) ||
(parameters == NULL))
{
return false;
}
if (!parameters->areOfType(DSAParameters::type))
{
ERROR_MSG("Invalid parameters supplied for DSA key generation");
return false;
}
DSAParameters* params = (DSAParameters*) parameters;
// Generate the key-pair
DSA* dsa = DSA_new();
if (dsa == NULL)
{
ERROR_MSG("Failed to instantiate OpenSSL DSA object");
return false;
}
// Use the OpenSSL implementation and not any engine
DSA_set_method(dsa, DSA_get_default_method());
dsa->p = OSSL::byteString2bn(params->getP());
dsa->q = OSSL::byteString2bn(params->getQ());
dsa->g = OSSL::byteString2bn(params->getG());
if (DSA_generate_key(dsa) != 1)
{
ERROR_MSG("DSA key generation failed (0x%08X)", ERR_get_error());
DSA_free(dsa);
return false;
}
// Create an asymmetric key-pair object to return
OSSLDSAKeyPair* kp = new OSSLDSAKeyPair();
((OSSLDSAPublicKey*) kp->getPublicKey())->setFromOSSL(dsa);
((OSSLDSAPrivateKey*) kp->getPrivateKey())->setFromOSSL(dsa);
*ppKeyPair = kp;
// Release the key
DSA_free(dsa);
return true;
}
int32_t CryptoNative_DsaKeyCreateByExplicitParameters(
DSA** outDsa,
uint8_t* p,
int32_t pLength,
uint8_t* q,
int32_t qLength,
uint8_t* g,
int32_t gLength,
uint8_t* y,
int32_t yLength,
uint8_t* x,
int32_t xLength)
{
if (!outDsa)
{
assert(false);
return 0;
}
*outDsa = DSA_new();
if (!*outDsa)
{
return 0;
}
DSA* dsa = *outDsa;
BIGNUM* bnP = MakeBignum(p, pLength);
BIGNUM* bnQ = MakeBignum(q, qLength);
BIGNUM* bnG = MakeBignum(g, gLength);
if (!DSA_set0_pqg(dsa, bnP, bnQ, bnG))
{
// BN_free handles NULL input
BN_free(bnP);
BN_free(bnQ);
BN_free(bnG);
return 0;
}
// Control was transferred, do not free.
bnP = NULL;
bnQ = NULL;
bnG = NULL;
BIGNUM* bnY = MakeBignum(y, yLength);
BIGNUM* bnX = MakeBignum(x, xLength);
if (!DSA_set0_key(dsa, bnY, bnX))
{
BN_free(bnY);
BN_free(bnX);
return 0;
}
return 1;
}
ssh_key pki_publickey_from_privatekey(ssh_key privkey) {
ssh_key pubkey = NULL;
if (privkey == NULL || !ssh_key_is_private(privkey)) {
return NULL;
}
pubkey = ssh_key_new();
if (pubkey == NULL) {
return NULL;
}
pubkey->type = privkey->type;
switch (pubkey->type) {
case SSH_KEYTYPE_DSS:
pubkey->dsa = DSA_new();
if (pubkey->dsa == NULL) {
goto fail;
}
pubkey->dsa->p = BN_dup(privkey->dsa->p);
pubkey->dsa->q = BN_dup(privkey->dsa->q);
pubkey->dsa->g = BN_dup(privkey->dsa->g);
pubkey->dsa->pub_key = BN_dup(privkey->dsa->pub_key);
if (pubkey->dsa->p == NULL ||
pubkey->dsa->q == NULL ||
pubkey->dsa->g == NULL ||
pubkey->dsa->pub_key == NULL) {
goto fail;
}
break;
case SSH_KEYTYPE_RSA:
case SSH_KEYTYPE_RSA1:
pubkey->rsa = RSA_new();
if (pubkey->rsa == NULL) {
goto fail;
}
pubkey->rsa->e = BN_dup(privkey->rsa->e);
pubkey->rsa->n = BN_dup(privkey->rsa->n);
if (pubkey->rsa->e == NULL ||
pubkey->rsa->n == NULL) {
goto fail;
}
break;
case SSH_KEYTYPE_ECDSA:
case SSH_KEYTYPE_UNKNOWN:
ssh_key_free(pubkey);
return NULL;
}
pubkey->type_c = ssh_key_type_to_char(privkey->type);
return pubkey;
fail:
ssh_key_free(pubkey);
return NULL;
}
static DSA* createDSAKey2()
{
unsigned char p_data[] =
"\x8d\xf2\xa4\x94\x49\x22\x76\xaa\x3d\x25\x75\x9b\xb0\x68\x69\xcb"
"\xea\xc0\xd8\x3a\xfb\x8d\x0c\xf7\xcb\xb8\x32\x4f\x0d\x78\x82\xe5"
"\xd0\x76\x2f\xc5\xb7\x21\x0e\xaf\xc2\xe9\xad\xac\x32\xab\x7a\xac"
"\x49\x69\x3d\xfb\xf8\x37\x24\xc2\xec\x07\x36\xee\x31\xc8\x02\x91";
int p_data_len = 64;
unsigned char q_data[] =
"\xc7\x73\x21\x8c\x73\x7e\xc8\xee\x99\x3b\x4f\x2d\xed\x30\xf4\x8e"
"\xda\xce\x91\x5f";
int q_data_len = 20;
unsigned char g_data[] =
"\x62\x6d\x02\x78\x39\xea\x0a\x13\x41\x31\x63\xa5\x5b\x4c\xb5\x00"
"\x29\x9d\x55\x22\x95\x6c\xef\xcb\x3b\xff\x10\xf3\x99\xce\x2c\x2e"
"\x71\xcb\x9d\xe5\xfa\x24\xba\xbf\x58\xe5\xb7\x95\x21\x92\x5c\x9c"
"\xc4\x2e\x9f\x6f\x46\x4b\x08\x8c\xc5\x72\xaf\x53\xe6\xd7\x88\x02";
int g_data_len = 64;
unsigned char priv_key_data[] =
"\x0f\x36\x53\xf7\x51\xa7\x04\x6e\x0b\x52\x30\xfe\x15\x7c\xa3\x3e"
"\x03\xf0\x84\x73";
int priv_key_data_len = 20;
unsigned char pub_key_data[] =
"\x7f\x9a\xd6\x6d\x4d\xa9\xb0\x0e\x71\x76\x04\xc4\xdb\x3b\x96\x93"
"\x6b\x6c\xa6\x16\xa5\x6b\xb6\xe6\x23\x26\xc7\xf5\xd4\xd6\x5b\x06"
"\x6c\x10\x47\x0a\xc2\xf2\x1d\xc1\x7b\x39\x54\x6d\x84\x99\x40\xd1"
"\x7e\xb0\xb5\x17\xc1\x17\xcd\xa0\x78\x0c\xc1\x67\xf1\x57\x83\x2c";
int pub_key_data_len = 64;
DSA* key = DSA_new();
key->p = BN_new();
key->q = BN_new();
key->g = BN_new();
key->priv_key = BN_new();
key->pub_key = BN_new();
BN_bin2bn(p_data, p_data_len, key->p);
BN_bin2bn(q_data, q_data_len, key->q);
BN_bin2bn(g_data, g_data_len, key->g);
BN_bin2bn(pub_key_data, pub_key_data_len, key->pub_key);
BN_bin2bn(priv_key_data, priv_key_data_len, key->priv_key);
return key;
}
int
_libssh2_dsa_new(libssh2_dsa_ctx ** dsactx,
const unsigned char *p,
unsigned long p_len,
const unsigned char *q,
unsigned long q_len,
const unsigned char *g,
unsigned long g_len,
const unsigned char *y,
unsigned long y_len,
const unsigned char *x, unsigned long x_len)
{
BIGNUM * p_bn;
BIGNUM * q_bn;
BIGNUM * g_bn;
BIGNUM * pub_key;
BIGNUM * priv_key = NULL;
p_bn = BN_new();
BN_bin2bn(p, p_len, p_bn);
q_bn = BN_new();
BN_bin2bn(q, q_len, q_bn);
g_bn = BN_new();
BN_bin2bn(g, g_len, g_bn);
pub_key = BN_new();
BN_bin2bn(y, y_len, pub_key);
if(x_len) {
priv_key = BN_new();
BN_bin2bn(x, x_len, priv_key);
}
*dsactx = DSA_new();
#ifdef HAVE_OPAQUE_STRUCTS
DSA_set0_pqg(*dsactx, p_bn, q_bn, g_bn);
#else
(*dsactx)->p = p_bn;
(*dsactx)->g = g_bn;
(*dsactx)->q = q_bn;
#endif
#ifdef HAVE_OPAQUE_STRUCTS
DSA_set0_key(*dsactx, pub_key, priv_key);
#else
(*dsactx)->pub_key = pub_key;
(*dsactx)->priv_key = priv_key;
#endif
return 0;
}
static EVP_PKEY *b2i_dss(const unsigned char **in, unsigned int length,
unsigned int bitlen, int ispub)
{
const unsigned char *p = *in;
EVP_PKEY *ret = NULL;
DSA *dsa = NULL;
BN_CTX *ctx = NULL;
unsigned int nbyte;
nbyte = (bitlen + 7) >> 3;
dsa = DSA_new();
ret = EVP_PKEY_new();
if (!dsa || !ret)
goto memerr;
if (!read_lebn(&p, nbyte, &dsa->p))
goto memerr;
if (!read_lebn(&p, 20, &dsa->q))
goto memerr;
if (!read_lebn(&p, nbyte, &dsa->g))
goto memerr;
if (ispub)
{
if (!read_lebn(&p, nbyte, &dsa->pub_key))
goto memerr;
}
else
{
if (!read_lebn(&p, 20, &dsa->priv_key))
goto memerr;
/* Calculate public key */
if (!(dsa->pub_key = BN_new()))
goto memerr;
if (!(ctx = BN_CTX_new()))
goto memerr;
if (!BN_mod_exp(dsa->pub_key, dsa->g,
dsa->priv_key, dsa->p, ctx))
goto memerr;
BN_CTX_free(ctx);
}
EVP_PKEY_set1_DSA(ret, dsa);
DSA_free(dsa);
*in = p;
return ret;
memerr:
PEMerr(PEM_F_B2I_DSS, ERR_R_MALLOC_FAILURE);
if (dsa)
DSA_free(dsa);
if (ret)
EVP_PKEY_free(ret);
if (ctx)
BN_CTX_free(ctx);
return NULL;
}
