distinguish between RFC 4754 (concatenated) and RFC 3279 (DER encoded) ECDSA signatures
This commit is contained in:
Martin Willi
@@ -43,153 +43,129 @@ struct private_openssl_ec_private_key_t {
|
||||
/**
|
||||
* reference count
|
||||
*/
|
||||
refcount_t ref;
|
||||
refcount_t ref;
|
||||
};
|
||||
|
||||
/**
|
||||
* Mapping from the signature scheme defined in (RFC 4754) to the elliptic
|
||||
* curve and the hash algorithm
|
||||
*/
|
||||
typedef struct {
|
||||
/**
|
||||
* Scheme specified in RFC 4754
|
||||
*/
|
||||
int scheme;
|
||||
|
||||
/**
|
||||
* NID of the hash
|
||||
*/
|
||||
int hash;
|
||||
|
||||
/**
|
||||
* NID of the curve
|
||||
*/
|
||||
int curve;
|
||||
} openssl_ecdsa_scheme_t;
|
||||
|
||||
#define END_OF_LIST -1
|
||||
|
||||
/**
|
||||
* Signature schemes
|
||||
*/
|
||||
static openssl_ecdsa_scheme_t ecdsa_schemes[] = {
|
||||
{SIGN_ECDSA_WITH_SHA1, NID_sha1, -1},
|
||||
{SIGN_ECDSA_256, NID_sha256, NID_X9_62_prime256v1},
|
||||
{SIGN_ECDSA_384, NID_sha384, NID_secp384r1},
|
||||
{SIGN_ECDSA_521, NID_sha512, NID_secp521r1},
|
||||
{END_OF_LIST, 0, 0},
|
||||
};
|
||||
|
||||
/**
|
||||
* Look up the hash and curve of a signature scheme
|
||||
*/
|
||||
static bool lookup_scheme(int scheme, int *hash, int *curve)
|
||||
{
|
||||
openssl_ecdsa_scheme_t *ecdsa_scheme = ecdsa_schemes;
|
||||
while (ecdsa_scheme->scheme != END_OF_LIST)
|
||||
{
|
||||
if (scheme == ecdsa_scheme->scheme)
|
||||
{
|
||||
*hash = ecdsa_scheme->hash;
|
||||
*curve = ecdsa_scheme->curve;
|
||||
return TRUE;
|
||||
}
|
||||
ecdsa_scheme++;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/* from ec public key */
|
||||
bool openssl_ec_fingerprint(EC_KEY *ec, key_encoding_type_t type, chunk_t *fp);
|
||||
|
||||
/**
|
||||
* Convert an ECDSA_SIG to a chunk by concatenating r and s.
|
||||
* This function allocates memory for the chunk.
|
||||
*/
|
||||
static bool sig2chunk(const EC_GROUP *group, ECDSA_SIG *sig, chunk_t *chunk)
|
||||
{
|
||||
return openssl_bn_cat(EC_FIELD_ELEMENT_LEN(group), sig->r, sig->s, chunk);
|
||||
}
|
||||
|
||||
/**
|
||||
* Build the signature
|
||||
* Build a signature as in RFC 4754
|
||||
*/
|
||||
static bool build_signature(private_openssl_ec_private_key_t *this,
|
||||
chunk_t hash, chunk_t *signature)
|
||||
{
|
||||
bool built = FALSE;
|
||||
ECDSA_SIG *sig;
|
||||
bool success;
|
||||
|
||||
sig = ECDSA_do_sign(hash.ptr, hash.len, this->ec);
|
||||
if (!sig)
|
||||
if (sig)
|
||||
{
|
||||
return FALSE;
|
||||
/* concatenate BNs r/s to a signature chunk */
|
||||
built = openssl_bn_cat(EC_FIELD_ELEMENT_LEN(EC_KEY_get0_group(this->ec)),
|
||||
sig->r, sig->s, signature);
|
||||
ECDSA_SIG_free(sig);
|
||||
}
|
||||
success = sig2chunk(EC_KEY_get0_group(this->ec), sig, signature);
|
||||
ECDSA_SIG_free(sig);
|
||||
return success;
|
||||
return built;
|
||||
}
|
||||
|
||||
/**
|
||||
* Implementation of private_key_t.get_type.
|
||||
* Build a RFC 4754 signature for a specified curve and hash algorithm
|
||||
*/
|
||||
static key_type_t get_type(private_openssl_ec_private_key_t *this)
|
||||
static bool build_curve_signature(private_openssl_ec_private_key_t *this,
|
||||
signature_scheme_t scheme, int nid_hash,
|
||||
int nid_curve, chunk_t data, chunk_t *signature)
|
||||
{
|
||||
return KEY_ECDSA;
|
||||
const EC_GROUP *my_group;
|
||||
EC_GROUP *req_group;
|
||||
chunk_t hash;
|
||||
bool built;
|
||||
|
||||
req_group = EC_GROUP_new_by_curve_name(nid_curve);
|
||||
if (!req_group)
|
||||
{
|
||||
DBG1("signature scheme %N not supported in EC (required curve "
|
||||
"not supported)", signature_scheme_names, scheme);
|
||||
return FALSE;
|
||||
}
|
||||
my_group = EC_KEY_get0_group(this->ec);
|
||||
if (EC_GROUP_cmp(my_group, req_group, NULL) != 0)
|
||||
{
|
||||
DBG1("signature scheme %N not supported by private key",
|
||||
signature_scheme_names, scheme);
|
||||
return FALSE;
|
||||
}
|
||||
EC_GROUP_free(req_group);
|
||||
if (!openssl_hash_chunk(nid_hash, data, &hash))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
built = build_signature(this, data, signature);
|
||||
chunk_free(&hash);
|
||||
return built;
|
||||
}
|
||||
|
||||
/**
|
||||
* Build a DER encoded signature as in RFC 3279
|
||||
*/
|
||||
static bool build_der_signature(private_openssl_ec_private_key_t *this,
|
||||
int hash_nid, chunk_t data, chunk_t *signature)
|
||||
{
|
||||
chunk_t hash, sig;
|
||||
int siglen = 0;
|
||||
bool built;
|
||||
|
||||
if (!openssl_hash_chunk(hash_nid, data, &hash))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
sig = chunk_alloc(ECDSA_size(this->ec));
|
||||
built = ECDSA_sign(0, hash.ptr, hash.len, sig.ptr, &siglen, this->ec) == 1;
|
||||
sig.len = siglen;
|
||||
if (built)
|
||||
{
|
||||
*signature = sig;
|
||||
}
|
||||
else
|
||||
{
|
||||
free(sig.ptr);
|
||||
}
|
||||
free(hash.ptr);
|
||||
return built;
|
||||
}
|
||||
|
||||
/**
|
||||
* Implementation of private_key_t.sign.
|
||||
*/
|
||||
static bool sign(private_openssl_ec_private_key_t *this, signature_scheme_t scheme,
|
||||
chunk_t data, chunk_t *signature)
|
||||
static bool sign(private_openssl_ec_private_key_t *this,
|
||||
signature_scheme_t scheme, chunk_t data, chunk_t *signature)
|
||||
{
|
||||
bool success;
|
||||
|
||||
if (scheme == SIGN_ECDSA_WITH_NULL)
|
||||
switch (scheme)
|
||||
{
|
||||
success = build_signature(this, data, signature);
|
||||
case SIGN_ECDSA_WITH_NULL:
|
||||
return build_signature(this, data, signature);
|
||||
case SIGN_ECDSA_WITH_SHA1_DER:
|
||||
return build_der_signature(this, NID_sha1, data, signature);
|
||||
case SIGN_ECDSA_WITH_SHA256_DER:
|
||||
return build_der_signature(this, NID_sha256, data, signature);
|
||||
case SIGN_ECDSA_WITH_SHA384_DER:
|
||||
return build_der_signature(this, NID_sha384, data, signature);
|
||||
case SIGN_ECDSA_WITH_SHA512_DER:
|
||||
return build_der_signature(this, NID_sha512, data, signature);
|
||||
case SIGN_ECDSA_256:
|
||||
return build_curve_signature(this, scheme, NID_X9_62_prime256v1,
|
||||
NID_sha256, data, signature);
|
||||
case SIGN_ECDSA_384:
|
||||
return build_curve_signature(this, scheme, NID_secp384r1,
|
||||
NID_sha384, data, signature);
|
||||
case SIGN_ECDSA_521:
|
||||
return build_curve_signature(this, scheme, NID_secp521r1,
|
||||
NID_sha512, data, signature);
|
||||
default:
|
||||
DBG1("signature scheme %N not supported",
|
||||
signature_scheme_names, scheme);
|
||||
return FALSE;
|
||||
}
|
||||
else
|
||||
{
|
||||
EC_GROUP *req_group;
|
||||
const EC_GROUP *my_group;
|
||||
chunk_t hash = chunk_empty;
|
||||
int hash_type, curve;
|
||||
|
||||
if (!lookup_scheme(scheme, &hash_type, &curve))
|
||||
{
|
||||
DBG1("signature scheme %N not supported in EC",
|
||||
signature_scheme_names, scheme);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
if (curve != -1)
|
||||
{
|
||||
req_group = EC_GROUP_new_by_curve_name(curve);
|
||||
if (!req_group)
|
||||
{
|
||||
DBG1("signature scheme %N not supported in EC (required curve "
|
||||
"not supported)", signature_scheme_names, scheme);
|
||||
return FALSE;
|
||||
}
|
||||
my_group = EC_KEY_get0_group(this->ec);
|
||||
if (EC_GROUP_cmp(my_group, req_group, NULL) != 0)
|
||||
{
|
||||
DBG1("signature scheme %N not supported by private key",
|
||||
signature_scheme_names, scheme);
|
||||
return FALSE;
|
||||
}
|
||||
EC_GROUP_free(req_group);
|
||||
}
|
||||
if (!openssl_hash_chunk(hash_type, data, &hash))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
success = build_signature(this, hash, signature);
|
||||
chunk_free(&hash);
|
||||
}
|
||||
return success;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -210,6 +186,14 @@ static size_t get_keysize(private_openssl_ec_private_key_t *this)
|
||||
return EC_FIELD_ELEMENT_LEN(EC_KEY_get0_group(this->ec));
|
||||
}
|
||||
|
||||
/**
|
||||
* Implementation of private_key_t.get_type.
|
||||
*/
|
||||
static key_type_t get_type(private_openssl_ec_private_key_t *this)
|
||||
{
|
||||
return KEY_ECDSA;
|
||||
}
|
||||
|
||||
/**
|
||||
* Implementation of private_key_t.get_public_key.
|
||||
*/
|
||||
|
||||
Reference in New Issue
Block a user