feedc0de/wolfssl
1
0
Fork 0
forked from wolfSSL/wolfssl
Code Pull Requests Activity

align return code, coding style (tab-> space, line with 80 char), curve_idx validity

Browse Source
This commit is contained in:
Ludovic FLAMENT
2015-07-05 20:10:43 +02:00
parent 88fa36e3c0
commit 702dbcf570
16 changed files with 2562 additions and 2314 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3336
src/ssl.c
View File

File diff suppressed because it is too large Load Diff

169
wolfcrypt/src/asn.c
View File

@ -529,7 +529,8 @@ WOLFSSL_LOCAL int GetSet(const byte* input, word32* inOutIdx, int* len,
/* winodws header clash for WinCE using GetVersion */ /* winodws header clash for WinCE using GetVersion */
WOLFSSL_LOCAL int GetMyVersion(const byte* input, word32* inOutIdx, int* version) WOLFSSL_LOCAL int GetMyVersion(const byte* input, word32* inOutIdx,
int* version)
{ {
word32 idx = *inOutIdx; word32 idx = *inOutIdx;
@ -939,12 +940,12 @@ static int DecryptKey(const char* password, int passwordSz, byte* salt,
#endif #endif
if (version == PKCS5v2) if (version == PKCS5v2)
ret = wc_PBKDF2(key, (byte*)password, passwordSz, salt, saltSz, iterations, ret = wc_PBKDF2(key, (byte*)password, passwordSz,
derivedLen, typeH); salt, saltSz, iterations, derivedLen, typeH);
#ifndef NO_SHA #ifndef NO_SHA
else if (version == PKCS5) else if (version == PKCS5)
ret = wc_PBKDF1(key, (byte*)password, passwordSz, salt, saltSz, iterations, ret = wc_PBKDF1(key, (byte*)password, passwordSz,
derivedLen, typeH); salt, saltSz, iterations, derivedLen, typeH);
#endif #endif
else if (version == PKCS12) { else if (version == PKCS12) {
int i, idx = 0; int i, idx = 0;
@ -1415,106 +1416,106 @@ int DsaPrivateKeyDecode(const byte* input, word32* inOutIdx, DsaKey* key,
static mp_int* GetDsaInt(DsaKey* key, int idx) static mp_int* GetDsaInt(DsaKey* key, int idx)
{ {
if (idx == 0) if (idx == 0)
return &key->p; return &key->p;
if (idx == 1) if (idx == 1)
return &key->q; return &key->q;
if (idx == 2) if (idx == 2)
return &key->g; return &key->g;
if (idx == 3) if (idx == 3)
return &key->x; return &key->x;
if (idx == 4) if (idx == 4)
return &key->y; return &key->y;
return NULL; return NULL;
} }
/* Release Tmp DSA resources */ /* Release Tmp DSA resources */
static INLINE void FreeTmpDsas(byte** tmps) static INLINE void FreeTmpDsas(byte** tmps)
{ {
int i; int i;
for (i = 0; i < DSA_INTS; i++) for (i = 0; i < DSA_INTS; i++)
XFREE(tmps[i], NULL, DYNAMIC_TYPE_DSA); XFREE(tmps[i], NULL, DYNAMIC_TYPE_DSA);
} }
/* Convert DsaKey key to DER format, write to output (inLen), return bytes /* Convert DsaKey key to DER format, write to output (inLen), return bytes
written */ written */
int wc_DsaKeyToDer(DsaKey* key, byte* output, word32 inLen) int wc_DsaKeyToDer(DsaKey* key, byte* output, word32 inLen)
{ {
word32 seqSz, verSz, rawLen, intTotalLen = 0; word32 seqSz, verSz, rawLen, intTotalLen = 0;
word32 sizes[DSA_INTS]; word32 sizes[DSA_INTS];
int i, j, outLen, ret = 0; int i, j, outLen, ret = 0;
byte seq[MAX_SEQ_SZ]; byte seq[MAX_SEQ_SZ];
byte ver[MAX_VERSION_SZ]; byte ver[MAX_VERSION_SZ];
byte* tmps[DSA_INTS]; byte* tmps[DSA_INTS];
if (!key || !output) if (!key || !output)
return BAD_FUNC_ARG; return BAD_FUNC_ARG;
if (key->type != DSA_PRIVATE) if (key->type != DSA_PRIVATE)
return BAD_FUNC_ARG; return BAD_FUNC_ARG;
for (i = 0; i < DSA_INTS; i++) for (i = 0; i < DSA_INTS; i++)
tmps[i] = NULL; tmps[i] = NULL;
/* write all big ints from key to DER tmps */ /* write all big ints from key to DER tmps */
for (i = 0; i < DSA_INTS; i++) { for (i = 0; i < DSA_INTS; i++) {
mp_int* keyInt = GetDsaInt(key, i); mp_int* keyInt = GetDsaInt(key, i);
rawLen = mp_unsigned_bin_size(keyInt); rawLen = mp_unsigned_bin_size(keyInt);
tmps[i] = (byte*)XMALLOC(rawLen + MAX_SEQ_SZ, NULL, DYNAMIC_TYPE_DSA); tmps[i] = (byte*)XMALLOC(rawLen + MAX_SEQ_SZ, NULL, DYNAMIC_TYPE_DSA);
if (tmps[i] == NULL) { if (tmps[i] == NULL) {
ret = MEMORY_E; ret = MEMORY_E;
break; break;
} }
tmps[i][0] = ASN_INTEGER; tmps[i][0] = ASN_INTEGER;
sizes[i] = SetLength(rawLen, tmps[i] + 1) + 1; /* int tag */ sizes[i] = SetLength(rawLen, tmps[i] + 1) + 1; /* int tag */
if (sizes[i] <= MAX_SEQ_SZ) { if (sizes[i] <= MAX_SEQ_SZ) {
int err = mp_to_unsigned_bin(keyInt, tmps[i] + sizes[i]); int err = mp_to_unsigned_bin(keyInt, tmps[i] + sizes[i]);
if (err == MP_OKAY) { if (err == MP_OKAY) {
sizes[i] += rawLen; sizes[i] += rawLen;
intTotalLen += sizes[i]; intTotalLen += sizes[i];
} }
else { else {
ret = err; ret = err;
break; break;
} }
} }
else { else {
ret = ASN_INPUT_E; ret = ASN_INPUT_E;
break; break;
} }
} }
if (ret != 0) { if (ret != 0) {
FreeTmpDsas(tmps); FreeTmpDsas(tmps);
return ret; return ret;
} }
/* make headers */ /* make headers */
verSz = SetMyVersion(0, ver, FALSE); verSz = SetMyVersion(0, ver, FALSE);
seqSz = SetSequence(verSz + intTotalLen, seq); seqSz = SetSequence(verSz + intTotalLen, seq);
outLen = seqSz + verSz + intTotalLen; outLen = seqSz + verSz + intTotalLen;
if (outLen > (int)inLen) if (outLen > (int)inLen)
return BAD_FUNC_ARG; return BAD_FUNC_ARG;
/* write to output */ /* write to output */
XMEMCPY(output, seq, seqSz); XMEMCPY(output, seq, seqSz);
j = seqSz; j = seqSz;
XMEMCPY(output + j, ver, verSz); XMEMCPY(output + j, ver, verSz);
j += verSz; j += verSz;
for (i = 0; i < DSA_INTS; i++) { for (i = 0; i < DSA_INTS; i++) {
XMEMCPY(output + j, tmps[i], sizes[i]); XMEMCPY(output + j, tmps[i], sizes[i]);
j += sizes[i]; j += sizes[i];
} }
FreeTmpDsas(tmps); FreeTmpDsas(tmps);
return outLen; return outLen;
} }
#endif /* NO_DSA */ #endif /* NO_DSA */
@ -1862,7 +1863,7 @@ static int GetKey(DecodedCert* cert)
#ifdef WOLFSSL_SMALL_STACK #ifdef WOLFSSL_SMALL_STACK
keyBlob = (byte*)XMALLOC(MAX_NTRU_KEY_SZ, NULL, keyBlob = (byte*)XMALLOC(MAX_NTRU_KEY_SZ, NULL,
DYNAMIC_TYPE_TMP_BUFFER); DYNAMIC_TYPE_TMP_BUFFER);
if (keyBlob == NULL) if (keyBlob == NULL)
return MEMORY_E; return MEMORY_E;
#endif #endif
@ -3354,7 +3355,7 @@ static int ConfirmSignature(const byte* buf, word32 bufSz,
#ifndef IGNORE_NAME_CONSTRAINTS #ifndef IGNORE_NAME_CONSTRAINTS
static int MatchBaseName(int type, const char* name, int nameSz, static int MatchBaseName(int type, const char* name, int nameSz,
const char* base, int baseSz) const char* base, int baseSz)
{ {
if (base == NULL || baseSz <= 0 || name == NULL || nameSz <= 0 || if (base == NULL || baseSz <= 0 || name == NULL || nameSz <= 0 ||
name[0] == '.' || nameSz < baseSz || name[0] == '.' || nameSz < baseSz ||
@ -6272,14 +6273,16 @@ int wc_SignCert(int requestSz, int sType, byte* buffer, word32 buffSz,
} }
int wc_MakeSelfCert(Cert* cert, byte* buffer, word32 buffSz, RsaKey* key, RNG* rng) int wc_MakeSelfCert(Cert* cert, byte* buffer, word32 buffSz,
RsaKey* key, RNG* rng)
{ {
int ret = wc_MakeCert(cert, buffer, buffSz, key, NULL, rng); int ret = wc_MakeCert(cert, buffer, buffSz, key, NULL, rng);
if (ret < 0) if (ret < 0)
return ret; return ret;
return wc_SignCert(cert->bodySz, cert->sigType, buffer, buffSz, key, NULL,rng); return wc_SignCert(cert->bodySz, cert->sigType,
buffer, buffSz, key, NULL, rng);
} }

622
wolfcrypt/src/ecc.c
View File

@ -87,7 +87,7 @@ const ecc_set_type ecc_sets[] = {
#ifdef ECC112 #ifdef ECC112
{ {
14, 14,
NID_secp111r1, NID_secp111r1,
"SECP112R1", "SECP112R1",
"DB7C2ABF62E35E668076BEAD208B", "DB7C2ABF62E35E668076BEAD208B",
"DB7C2ABF62E35E668076BEAD2088", "DB7C2ABF62E35E668076BEAD2088",
@ -100,7 +100,7 @@ const ecc_set_type ecc_sets[] = {
#ifdef ECC128 #ifdef ECC128
{ {
16, 16,
NID_secp128r1, NID_secp128r1,
"SECP128R1", "SECP128R1",
"FFFFFFFDFFFFFFFFFFFFFFFFFFFFFFFF", "FFFFFFFDFFFFFFFFFFFFFFFFFFFFFFFF",
"FFFFFFFDFFFFFFFFFFFFFFFFFFFFFFFC", "FFFFFFFDFFFFFFFFFFFFFFFFFFFFFFFC",
@ -113,7 +113,7 @@ const ecc_set_type ecc_sets[] = {
#ifdef ECC160 #ifdef ECC160
{ {
20, 20,
NID_secp160r1, NID_secp160r1,
"SECP160R1", "SECP160R1",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFF",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFC", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFC",
@ -126,7 +126,7 @@ const ecc_set_type ecc_sets[] = {
#ifdef ECC192 #ifdef ECC192
{ {
24, 24,
NID_cert192, NID_cert192,
"ECC-192", "ECC-192",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFF",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFC", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFC",
@ -139,7 +139,7 @@ const ecc_set_type ecc_sets[] = {
#ifdef ECC224 #ifdef ECC224
{ {
28, 28,
NID_cert224, NID_cert224,
"ECC-224", "ECC-224",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000001", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000001",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFE", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFE",
@ -152,7 +152,7 @@ const ecc_set_type ecc_sets[] = {
#ifdef ECC256 #ifdef ECC256
{ {
32, 32,
NID_X9_62_prime256v1, NID_X9_62_prime256v1,
"nistp256", "nistp256",
"FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF", "FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF",
"FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFC", "FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFC",
@ -165,7 +165,7 @@ const ecc_set_type ecc_sets[] = {
#ifdef ECC384 #ifdef ECC384
{ {
48, 48,
NID_secp384r1, NID_secp384r1,
"nistp384", "nistp384",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFF",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFC", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFC",
@ -178,7 +178,7 @@ const ecc_set_type ecc_sets[] = {
#ifdef ECC521 #ifdef ECC521
{ {
66, 66,
NID_secp521r1, NID_secp521r1,
"nistp521", "nistp521",
"1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", "1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
"1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC", "1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC",
@ -1437,59 +1437,55 @@ void ecc_del_point(ecc_point* p)
} }
/** Copy the value of a point to an other one /** Copy the value of a point to an other one
p The point to copy p The point to copy
r The created point r The created point
*/ */
int ecc_copy_point(ecc_point* p, ecc_point *r) int ecc_copy_point(ecc_point* p, ecc_point *r)
{ {
/* prevents null arguments */ int ret;
if (p == NULL || r == NULL)
return 0;
if (mp_copy(p->x, r->x) != MP_OKAY) /* prevents null arguments */
return 0; if (p == NULL || r == NULL)
if (mp_copy(p->y, r->y) != MP_OKAY) return ECC_BAD_ARG_E;
return 0;
if (mp_copy(p->z, r->z) != MP_OKAY)
return 0;
return 1; ret = mp_copy(p->x, r->x);
if (ret != MP_OKAY)
return ret;
ret = mp_copy(p->y, r->y);
if (ret != MP_OKAY)
return ret;
ret = mp_copy(p->z, r->z);
if (ret != MP_OKAY)
return ret;
return MP_OKAY;
} }
/** Compare the value of a point with an other one /** Compare the value of a point with an other one
a The point to compare a The point to compare
b The othe point to compare b The othe point to compare
return 0 if equal, 1 if not, -1 in case of error return MP_EQ if equal, MP_LT/MP_GT if not, < 0 in case of error
*/ */
int ecc_cmp_point(ecc_point* a, ecc_point *b) int ecc_cmp_point(ecc_point* a, ecc_point *b)
{ {
int ret; int ret;
/* prevents null arguments */ /* prevents null arguments */
if (a == NULL || b == NULL) if (a == NULL || b == NULL)
return -1; return BAD_FUNC_ARG;
ret = mp_cmp(a->x, b->x); ret = mp_cmp(a->x, b->x);
if (ret != MP_EQ) { if (ret != MP_EQ)
if (ret != MP_LT && ret != MP_GT) return ret;
return -1; ret = mp_cmp(a->y, b->y);
return 1; if (ret != MP_EQ)
} return ret;
ret = mp_cmp(a->y, b->y); ret = mp_cmp(a->z, b->z);
if (ret != MP_EQ) { if (ret != MP_EQ)
if (ret != MP_LT && ret != MP_GT) return ret;
return -1;
return 1;
}
ret = mp_cmp(a->z, b->z);
if (ret != MP_EQ) {
if (ret != MP_LT && ret != MP_GT)
return -1;
return 1;
}
return 0; return MP_EQ;
} }
/** Returns whether an ECC idx is valid or not /** Returns whether an ECC idx is valid or not
@ -1582,62 +1578,64 @@ int wc_ecc_shared_secret(ecc_key* private_key, ecc_key* public_key, byte* out,
/** /**
Create an ECC shared secret between two keys Create an ECC shared secret between two keys
private_key The private ECC key private_key The private ECC key
point The point to use (public key) point The point to use (public key)
out [out] Destination of the shared secret out [out] Destination of the shared secret
Conforms to EC-DH from ANSI X9.63 Conforms to EC-DH from ANSI X9.63
outlen [in/out] The max size and resulting size of the shared secret outlen [in/out] The max size and resulting size of the shared secret
return MP_OKAY if successful return MP_OKAY if successful
*/ */
int wc_ecc_shared_secret_ssh(ecc_key* private_key, ecc_point* point, byte* out, word32 *outlen) int wc_ecc_shared_secret_ssh(ecc_key* private_key, ecc_point* point,
byte* out, word32 *outlen)
{ {
word32 x = 0; word32 x = 0;
ecc_point* result; ecc_point* result;
mp_int prime; mp_int prime;
int err; int err;
if (private_key == NULL || point == NULL || out == NULL || outlen == NULL) if (private_key == NULL || point == NULL || out == NULL || outlen == NULL)
return BAD_FUNC_ARG; return BAD_FUNC_ARG;
/* type valid? */ /* type valid? */
if (private_key->type != ECC_PRIVATEKEY) { if (private_key->type != ECC_PRIVATEKEY) {
return ECC_BAD_ARG_E; return ECC_BAD_ARG_E;
} }
if (ecc_is_valid_idx(private_key->idx) == 0) if (ecc_is_valid_idx(private_key->idx) == 0)
return ECC_BAD_ARG_E; return ECC_BAD_ARG_E;
/* make new point */ /* make new point */
result = ecc_new_point(); result = ecc_new_point();
if (result == NULL) { if (result == NULL) {
return MEMORY_E; return MEMORY_E;
} }
if ((err = mp_init(&prime)) != MP_OKAY) { if ((err = mp_init(&prime)) != MP_OKAY) {
ecc_del_point(result); ecc_del_point(result);
return err; return err;
} }
err = mp_read_radix(&prime, (char *)private_key->dp->prime, 16); err = mp_read_radix(&prime, (char *)private_key->dp->prime, 16);
if (err == MP_OKAY) if (err == MP_OKAY)
err = ecc_mulmod(&private_key->k, point, result, &prime, 1); err = ecc_mulmod(&private_key->k, point, result, &prime, 1);
if (err == MP_OKAY) { if (err == MP_OKAY) {
x = mp_unsigned_bin_size(&prime); x = mp_unsigned_bin_size(&prime);
if (*outlen < x) if (*outlen < x)
err = BUFFER_E; err = BUFFER_E;
} }
if (err == MP_OKAY) { if (err == MP_OKAY) {
XMEMSET(out, 0, x); XMEMSET(out, 0, x);
err = mp_to_unsigned_bin(result->x,out + (x - mp_unsigned_bin_size(result->x))); err = mp_to_unsigned_bin(result->x,out +
*outlen = x; (x - mp_unsigned_bin_size(result->x)));
} *outlen = x;
}
mp_clear(&prime); mp_clear(&prime);
ecc_del_point(result); ecc_del_point(result);
return err; return err;
} }
@ -1779,23 +1777,23 @@ static int wc_ecc_make_key_ex(RNG* rng, ecc_key* key, const ecc_set_type* dp)
*/ */
int wc_ecc_make_key(RNG* rng, int keysize, ecc_key* key) int wc_ecc_make_key(RNG* rng, int keysize, ecc_key* key)
{ {
int x, err; int x, err;
if (key == NULL || rng == NULL) if (key == NULL || rng == NULL)
return ECC_BAD_ARG_E; return ECC_BAD_ARG_E;
/* find key size */ /* find key size */
for (x = 0; (keysize > ecc_sets[x].size) && (ecc_sets[x].size != 0); x++) for (x = 0; (keysize > ecc_sets[x].size) && (ecc_sets[x].size != 0); x++)
; ;
keysize = ecc_sets[x].size; keysize = ecc_sets[x].size;
if (keysize > ECC_MAXSIZE || ecc_sets[x].size == 0) { if (keysize > ECC_MAXSIZE || ecc_sets[x].size == 0) {
return BAD_FUNC_ARG; return BAD_FUNC_ARG;
} }
err = wc_ecc_make_key_ex(rng, key, &ecc_sets[x]); err = wc_ecc_make_key_ex(rng, key, &ecc_sets[x]);
key->idx = x; key->idx = x;
return err; return err;
} }
/* Setup dynamic pointers is using normal math for proper freeing */ /* Setup dynamic pointers is using normal math for proper freeing */
@ -1823,7 +1821,7 @@ int wc_ecc_init(ecc_key* key)
alt_fp_init(key->pubkey.z); alt_fp_init(key->pubkey.z);
#endif #endif
return 0; return MP_OKAY;
} }
@ -1837,27 +1835,28 @@ int wc_ecc_init(ecc_key* key)
return MP_OKAY if successful return MP_OKAY if successful
*/ */
int wc_ecc_sign_hash(const byte* in, word32 inlen, byte* out, word32 *outlen, int wc_ecc_sign_hash(const byte* in, word32 inlen, byte* out, word32 *outlen,
RNG* rng, ecc_key* key) RNG* rng, ecc_key* key)
{ {
mp_int r; mp_int r;
mp_int s; mp_int s;
int err; int err;
if (in == NULL || out == NULL || outlen == NULL || key == NULL || rng == NULL) if (in == NULL || out == NULL || outlen == NULL ||
return ECC_BAD_ARG_E; key == NULL || rng == NULL)
return ECC_BAD_ARG_E;
if ((err = mp_init_multi(&r, &s, NULL, NULL, NULL, NULL)) != MP_OKAY) { if ((err = mp_init_multi(&r, &s, NULL, NULL, NULL, NULL)) != MP_OKAY) {
return err; return err;
} }
err = wc_ecc_sign_hash_ex(in, inlen, rng, key, &r, &s); err = wc_ecc_sign_hash_ex(in, inlen, rng, key, &r, &s);
if (err == MP_OKAY) if (err == MP_OKAY)
err = StoreECC_DSA_Sig(out, outlen, &r, &s); err = StoreECC_DSA_Sig(out, outlen, &r, &s);
mp_clear(&r); mp_clear(&r);
mp_clear(&s); mp_clear(&s);
return err; return err;
} }
/** /**
@ -1868,11 +1867,11 @@ int wc_ecc_sign_hash(const byte* in, word32 inlen, byte* out, word32 *outlen,
outlen [in/out] The max size and resulting size of the signature outlen [in/out] The max size and resulting size of the signature
key A private ECC key key A private ECC key
r [out] The destination for r component of the signature r [out] The destination for r component of the signature
s [out] The destination for s component of the signature s [out] The destination for s component of the signature
return MP_OKAY if successful return MP_OKAY if successful
*/ */
int wc_ecc_sign_hash_ex(const byte* in, word32 inlen, RNG* rng, int wc_ecc_sign_hash_ex(const byte* in, word32 inlen, RNG* rng,
ecc_key* key, mp_int *r, mp_int *s) ecc_key* key, mp_int *r, mp_int *s)
{ {
mp_int e; mp_int e;
mp_int p; mp_int p;
@ -1916,47 +1915,48 @@ int wc_ecc_sign_hash_ex(const byte* in, word32 inlen, RNG* rng,
if (err == MP_OKAY) { if (err == MP_OKAY) {
int loop_check = 0; int loop_check = 0;
ecc_key pubkey; ecc_key pubkey;
wc_ecc_init(&pubkey); if (wc_ecc_init(&pubkey) == MP_OKAY) {
for (;;) { for (;;) {
if (++loop_check > 64) { if (++loop_check > 64) {
err = RNG_FAILURE_E; err = RNG_FAILURE_E;
break; break;
}
err = wc_ecc_make_key_ex(rng, &pubkey, key->dp);
if (err != MP_OKAY) break;
/* find r = x1 mod n */
err = mp_mod(pubkey.pubkey.x, &p, r);
if (err != MP_OKAY) break;
if (mp_iszero(r) == MP_YES) {
mp_clear(pubkey.pubkey.x);
mp_clear(pubkey.pubkey.y);
mp_clear(pubkey.pubkey.z);
mp_clear(&pubkey.k);
}
else {
/* find s = (e + xr)/k */
err = mp_invmod(&pubkey.k, &p, &pubkey.k);
if (err != MP_OKAY) break;
err = mp_mulmod(&key->k, r, &p, s); /* s = xr */
if (err != MP_OKAY) break;
err = mp_add(&e, s, s); /* s = e + xr */
if (err != MP_OKAY) break;
err = mp_mod(s, &p, s); /* s = e + xr */
if (err != MP_OKAY) break;
err = mp_mulmod(s, &pubkey.k, &p, s); /* s = (e + xr)/k */
if (err != MP_OKAY) break;
if (mp_iszero(s) == MP_NO)
break;
}
} }
err = wc_ecc_make_key_ex(rng, &pubkey, key->dp); wc_ecc_free(&pubkey);
if (err != MP_OKAY) break;
/* find r = x1 mod n */
err = mp_mod(pubkey.pubkey.x, &p, r);
if (err != MP_OKAY) break;
if (mp_iszero(r) == MP_YES) {
mp_clear(pubkey.pubkey.x);
mp_clear(pubkey.pubkey.y);
mp_clear(pubkey.pubkey.z);
mp_clear(&pubkey.k);
}
else {
/* find s = (e + xr)/k */
err = mp_invmod(&pubkey.k, &p, &pubkey.k);
if (err != MP_OKAY) break;
err = mp_mulmod(&key->k, r, &p, s); /* s = xr */
if (err != MP_OKAY) break;
err = mp_add(&e, s, s); /* s = e + xr */
if (err != MP_OKAY) break;
err = mp_mod(s, &p, s); /* s = e + xr */
if (err != MP_OKAY) break;
err = mp_mulmod(s, &pubkey.k, &p, s); /* s = (e + xr)/k */
if (err != MP_OKAY) break;
if (mp_iszero(s) == MP_NO)
break;
}
} }
wc_ecc_free(&pubkey);
} }
mp_clear(&p); mp_clear(&p);
@ -2240,34 +2240,34 @@ static int ecc_mul2add(ecc_point* A, mp_int* kA,
return MP_OKAY if successful (even if the signature is not valid) return MP_OKAY if successful (even if the signature is not valid)
*/ */
int wc_ecc_verify_hash(const byte* sig, word32 siglen, const byte* hash, int wc_ecc_verify_hash(const byte* sig, word32 siglen, const byte* hash,
word32 hashlen, int* stat, ecc_key* key) word32 hashlen, int* stat, ecc_key* key)
{ {
mp_int r; mp_int r;
mp_int s; mp_int s;
int err; int err;
if (sig == NULL || hash == NULL || stat == NULL || key == NULL) if (sig == NULL || hash == NULL || stat == NULL || key == NULL)
return ECC_BAD_ARG_E; return ECC_BAD_ARG_E;
/* default to invalid signature */ /* default to invalid signature */
*stat = 0; *stat = 0;
/* Note, DecodeECC_DSA_Sig() calls mp_init() on r and s. /* Note, DecodeECC_DSA_Sig() calls mp_init() on r and s.
* If either of those don't allocate correctly, none of * If either of those don't allocate correctly, none of
* the rest of this function will execute, and everything * the rest of this function will execute, and everything
* gets cleaned up at the end. */ * gets cleaned up at the end. */
XMEMSET(&r, 0, sizeof(r)); XMEMSET(&r, 0, sizeof(r));
XMEMSET(&s, 0, sizeof(s)); XMEMSET(&s, 0, sizeof(s));
err = DecodeECC_DSA_Sig(sig, siglen, &r, &s); err = DecodeECC_DSA_Sig(sig, siglen, &r, &s);
if (err == MP_OKAY) if (err == MP_OKAY)
err = wc_ecc_verify_hash_ex(&r, &s, hash, hashlen, stat, key); err = wc_ecc_verify_hash_ex(&r, &s, hash, hashlen, stat, key);
mp_clear(&r); mp_clear(&r);
mp_clear(&s); mp_clear(&s);
return err; return err;
} }
/** /**
@ -2335,7 +2335,8 @@ int wc_ecc_verify_hash_ex(mp_int *r, mp_int *s, const byte* hash,
/* check for zero */ /* check for zero */
if (err == MP_OKAY) { if (err == MP_OKAY) {
if (mp_iszero(r) || mp_iszero(s) || mp_cmp(r, &p) != MP_LT || mp_cmp(s, &p) != MP_LT) if (mp_iszero(r) || mp_iszero(s) || mp_cmp(r, &p) != MP_LT ||
mp_cmp(s, &p) != MP_LT)
err = MP_ZERO_E; err = MP_ZERO_E;
} }
/* read hash */ /* read hash */
@ -2434,189 +2435,193 @@ int wc_ecc_verify_hash_ex(mp_int *r, mp_int *s, const byte* hash,
} }
/* import point from der */ /* import point from der */
int wc_ecc_import_point_der(byte* in, word32 inLen, const int curve_idx, ecc_point* point) int wc_ecc_import_point_der(byte* in, word32 inLen, const int curve_idx,
ecc_point* point)
{ {
int err = 0; int err = 0;
int compressed = 0; int compressed = 0;
if (in == NULL || point == NULL || (ecc_is_valid_idx(curve_idx) == 0)) if (in == NULL || point == NULL || (curve_idx < 0) ||
return ECC_BAD_ARG_E; (ecc_is_valid_idx(curve_idx) == 0))
return ECC_BAD_ARG_E;
/* must be odd */ /* must be odd */
if ((inLen & 1) == 0) { if ((inLen & 1) == 0) {
return ECC_BAD_ARG_E; return ECC_BAD_ARG_E;
} }
/* init point */ /* init point */
#ifdef ALT_ECC_SIZE #ifdef ALT_ECC_SIZE
point->x = (mp_int*)&point->xyz[0]; point->x = (mp_int*)&point->xyz[0];
point->y = (mp_int*)&point->xyz[1]; point->y = (mp_int*)&point->xyz[1];
point->z = (mp_int*)&point->xyz[2]; point->z = (mp_int*)&point->xyz[2];
alt_fp_init(point->x); alt_fp_init(point->x);
alt_fp_init(point->y); alt_fp_init(point->y);
alt_fp_init(point->z); alt_fp_init(point->z);
#else #else
err = mp_init_multi(point->x, point->y, point->z, NULL, NULL, NULL); err = mp_init_multi(point->x, point->y, point->z, NULL, NULL, NULL);
#endif #endif
if (err != MP_OKAY) if (err != MP_OKAY)
return MEMORY_E; return MEMORY_E;
/* check for 4, 2, or 3 */ /* check for 4, 2, or 3 */
if (in[0] != 0x04 && in[0] != 0x02 && in[0] != 0x03) { if (in[0] != 0x04 && in[0] != 0x02 && in[0] != 0x03) {
err = ASN_PARSE_E; err = ASN_PARSE_E;
} }
if (in[0] == 0x02 || in[0] == 0x03) { if (in[0] == 0x02 || in[0] == 0x03) {
#ifdef HAVE_COMP_KEY #ifdef HAVE_COMP_KEY
compressed = 1; compressed = 1;
#else #else
err = NOT_COMPILED_IN; err = NOT_COMPILED_IN;
#endif #endif
} }
/* read data */ /* read data */
if (err == MP_OKAY) if (err == MP_OKAY)
err = mp_read_unsigned_bin(point->x, (byte*)in+1, (inLen-1)>>1); err = mp_read_unsigned_bin(point->x, (byte*)in+1, (inLen-1)>>1);
#ifdef HAVE_COMP_KEY #ifdef HAVE_COMP_KEY
if (err == MP_OKAY && compressed == 1) { /* build y */ if (err == MP_OKAY && compressed == 1) { /* build y */
mp_int t1, t2, prime, a, b; mp_int t1, t2, prime, a, b;
if (mp_init_multi(&t1, &t2, &prime, &a, &b, NULL) != MP_OKAY) if (mp_init_multi(&t1, &t2, &prime, &a, &b, NULL) != MP_OKAY)
err = MEMORY_E; err = MEMORY_E;
/* load prime */ /* load prime */
if (err == MP_OKAY) if (err == MP_OKAY)
err = mp_read_radix(&prime, (char *)ecc_sets[curve_idx].prime, 16); err = mp_read_radix(&prime, (char *)ecc_sets[curve_idx].prime, 16);
/* load a */ /* load a */
if (err == MP_OKAY) if (err == MP_OKAY)
err = mp_read_radix(&a, (char *)ecc_sets[curve_idx].Af, 16); err = mp_read_radix(&a, (char *)ecc_sets[curve_idx].Af, 16);
/* load b */ /* load b */
if (err == MP_OKAY) if (err == MP_OKAY)
err = mp_read_radix(&b, (char *)ecc_sets[curve_idx].Bf, 16); err = mp_read_radix(&b, (char *)ecc_sets[curve_idx].Bf, 16);
/* compute x^3 */ /* compute x^3 */
if (err == MP_OKAY) if (err == MP_OKAY)
err = mp_sqr(point->x, &t1); err = mp_sqr(point->x, &t1);
if (err == MP_OKAY) if (err == MP_OKAY)
err = mp_mulmod(&t1, point->x, &prime, &t1); err = mp_mulmod(&t1, point->x, &prime, &t1);
/* compute x^3 + a*x */ /* compute x^3 + a*x */
if (err == MP_OKAY) if (err == MP_OKAY)
err = mp_mulmod(&a, point->x, &prime, &t2); err = mp_mulmod(&a, point->x, &prime, &t2);
if (err == MP_OKAY) if (err == MP_OKAY)
err = mp_add(&t1, &t2, &t1); err = mp_add(&t1, &t2, &t1);
/* compute x^3 + a*x + b */ /* compute x^3 + a*x + b */
if (err == MP_OKAY) if (err == MP_OKAY)
err = mp_add(&t1, &b, &t1); err = mp_add(&t1, &b, &t1);
/* compute sqrt(x^3 + a*x + b) */ /* compute sqrt(x^3 + a*x + b) */
if (err == MP_OKAY) if (err == MP_OKAY)
err = mp_sqrtmod_prime(&t1, &prime, &t2); err = mp_sqrtmod_prime(&t1, &prime, &t2);
/* adjust y */ /* adjust y */
if (err == MP_OKAY) { if (err == MP_OKAY) {
if ((mp_isodd(&t2) && in[0] == 0x03) || if ((mp_isodd(&t2) && in[0] == 0x03) ||
(!mp_isodd(&t2) && in[0] == 0x02)) { (!mp_isodd(&t2) && in[0] == 0x02)) {
err = mp_mod(&t2, &prime, point->y); err = mp_mod(&t2, &prime, point->y);
} }
else { else {
err = mp_submod(&prime, &t2, &prime, point->y); err = mp_submod(&prime, &t2, &prime, point->y);
} }
} }
mp_clear(&a); mp_clear(&a);
mp_clear(&b); mp_clear(&b);
mp_clear(&prime); mp_clear(&prime);
mp_clear(&t2); mp_clear(&t2);
mp_clear(&t1); mp_clear(&t1);
} }
#endif #endif
if (err == MP_OKAY && compressed == 0) if (err == MP_OKAY && compressed == 0)
err = mp_read_unsigned_bin(point->y, (byte*)in+1+((inLen-1)>>1), (inLen-1)>>1); err = mp_read_unsigned_bin(point->y,
if (err == MP_OKAY) (byte*)in+1+((inLen-1)>>1), (inLen-1)>>1);
mp_set(point->z, 1); if (err == MP_OKAY)
mp_set(point->z, 1);
if (err != MP_OKAY) { if (err != MP_OKAY) {
mp_clear(point->x); mp_clear(point->x);
mp_clear(point->y); mp_clear(point->y);
mp_clear(point->z); mp_clear(point->z);
} }
return err; return err;
} }
/* export point to der */ /* export point to der */
int wc_ecc_export_point_der(const int curve_idx, ecc_point* point, byte* out, word32* outLen) int wc_ecc_export_point_der(const int curve_idx, ecc_point* point, byte* out,
word32* outLen)
{ {
#ifdef WOLFSSL_SMALL_STACK #ifdef WOLFSSL_SMALL_STACK
byte* buf; byte* buf;
#else #else
byte buf[ECC_BUFSIZE]; byte buf[ECC_BUFSIZE];
#endif #endif
word32 numlen; word32 numlen;
int ret = MP_OKAY; int ret = MP_OKAY;
if (curve_idx < 0) if ((curve_idx < 0) || (ecc_is_valid_idx(curve_idx) == 0))
return ECC_BAD_ARG_E; return ECC_BAD_ARG_E;
/* return length needed only */ /* return length needed only */
if (point != NULL && out == NULL && outLen != NULL) { if (point != NULL && out == NULL && outLen != NULL) {
numlen = ecc_sets[curve_idx].size; numlen = ecc_sets[curve_idx].size;
*outLen = 1 + 2*numlen; *outLen = 1 + 2*numlen;
return LENGTH_ONLY_E; return LENGTH_ONLY_E;
} }
if (point == NULL || out == NULL || outLen == NULL) if (point == NULL || out == NULL || outLen == NULL)
return ECC_BAD_ARG_E; return ECC_BAD_ARG_E;
numlen = ecc_sets[curve_idx].size; numlen = ecc_sets[curve_idx].size;
if (*outLen < (1 + 2*numlen)) { if (*outLen < (1 + 2*numlen)) {
*outLen = 1 + 2*numlen; *outLen = 1 + 2*numlen;
return BUFFER_E; return BUFFER_E;
} }
/* store byte 0x04 */ /* store byte 0x04 */
out[0] = 0x04; out[0] = 0x04;
#ifdef WOLFSSL_SMALL_STACK #ifdef WOLFSSL_SMALL_STACK
buf = (byte*)XMALLOC(ECC_BUFSIZE, NULL, DYNAMIC_TYPE_TMP_BUFFER); buf = (byte*)XMALLOC(ECC_BUFSIZE, NULL, DYNAMIC_TYPE_TMP_BUFFER);
if (buf == NULL) if (buf == NULL)
return MEMORY_E; return MEMORY_E;
#endif #endif
do { do {
/* pad and store x */ /* pad and store x */
XMEMSET(buf, 0, ECC_BUFSIZE); XMEMSET(buf, 0, ECC_BUFSIZE);
ret = mp_to_unsigned_bin(point->x, ret = mp_to_unsigned_bin(point->x, buf +
buf + (numlen - mp_unsigned_bin_size(point->x))); (numlen - mp_unsigned_bin_size(point->x)));
if (ret != MP_OKAY) if (ret != MP_OKAY)
break; break;
XMEMCPY(out+1, buf, numlen); XMEMCPY(out+1, buf, numlen);
/* pad and store y */ /* pad and store y */
XMEMSET(buf, 0, ECC_BUFSIZE); XMEMSET(buf, 0, ECC_BUFSIZE);
ret = mp_to_unsigned_bin(point->y, ret = mp_to_unsigned_bin(point->y, buf +
buf + (numlen - mp_unsigned_bin_size(point->y))); (numlen - mp_unsigned_bin_size(point->y)));
if (ret != MP_OKAY) if (ret != MP_OKAY)
break; break;
XMEMCPY(out+1+numlen, buf, numlen); XMEMCPY(out+1+numlen, buf, numlen);
*outLen = 1 + 2*numlen; *outLen = 1 + 2*numlen;
} while (0); } while (0);
#ifdef WOLFSSL_SMALL_STACK #ifdef WOLFSSL_SMALL_STACK
XFREE(buf, NULL, DYNAMIC_TYPE_TMP_BUFFER); XFREE(buf, NULL, DYNAMIC_TYPE_TMP_BUFFER);
#endif #endif
return ret; return ret;
} }
@ -2690,7 +2695,8 @@ int wc_ecc_export_x963(ecc_key* key, byte* out, word32* outLen)
/* export public ECC key in ANSI X9.63 format, extended with /* export public ECC key in ANSI X9.63 format, extended with
* compression option */ * compression option */
int wc_ecc_export_x963_ex(ecc_key* key, byte* out, word32* outLen, int compressed) int wc_ecc_export_x963_ex(ecc_key* key, byte* out, word32* outLen,
int compressed)
{ {
if (compressed == 0) if (compressed == 0)
return wc_ecc_export_x963(key, out, outLen); return wc_ecc_export_x963(key, out, outLen);
@ -3235,8 +3241,8 @@ int wc_ecc_size(ecc_key* key)
} }
/* worst case estimate, check actual return from wc_ecc_sign_hash for actual value /* worst case estimate, check actual return from wc_ecc_sign_hash for actual
of signature size in octets */ value of signature size in octets */
int wc_ecc_sig_size(ecc_key* key) int wc_ecc_sig_size(ecc_key* key)
{ {
int sz = wc_ecc_size(key); int sz = wc_ecc_size(key);

227
wolfcrypt/src/integer.c
View File

@ -49,18 +49,18 @@
static void static void
bn_reverse (unsigned char *s, int len) bn_reverse (unsigned char *s, int len)
{ {
int ix, iy; int ix, iy;
unsigned char t; unsigned char t;
ix = 0; ix = 0;
iy = len - 1; iy = len - 1;
while (ix < iy) { while (ix < iy) {
t = s[ix]; t = s[ix];
s[ix] = s[iy]; s[ix] = s[iy];
s[iy] = t; s[iy] = t;
++ix; ++ix;
--iy; --iy;
} }
} }
/* math settings check */ /* math settings check */
@ -1251,10 +1251,10 @@ void mp_set (mp_int * a, mp_digit b)
/* chek if a bit is set */ /* chek if a bit is set */
int mp_is_bit_set (mp_int *a, mp_digit b) int mp_is_bit_set (mp_int *a, mp_digit b)
{ {
if ((mp_digit)a->used < b/DIGIT_BIT) if ((mp_digit)a->used < b/DIGIT_BIT)
return 0; return 0;
return (int)((a->dp[b/DIGIT_BIT] >> b%DIGIT_BIT) & (mp_digit)1); return (int)((a->dp[b/DIGIT_BIT] >> b%DIGIT_BIT) & (mp_digit)1);
} }
/* c = a mod b, 0 <= c < b */ /* c = a mod b, 0 <= c < b */
@ -1888,7 +1888,8 @@ int mp_exptmod_fast (mp_int * G, mp_int * X, mp_int * P, mp_int * Y,
} }
for (x = 0; x < (winsize - 1); x++) { for (x = 0; x < (winsize - 1); x++) {
if ((err = mp_sqr (&M[(mp_digit)(1 << (winsize - 1))], &M[(mp_digit)(1 << (winsize - 1))])) != MP_OKAY) { if ((err = mp_sqr (&M[(mp_digit)(1 << (winsize - 1))],
&M[(mp_digit)(1 << (winsize - 1))])) != MP_OKAY) {
goto LBL_RES; goto LBL_RES;
} }
if ((err = redux (&M[(mp_digit)(1 << (winsize - 1))], P, mp)) != MP_OKAY) { if ((err = redux (&M[(mp_digit)(1 << (winsize - 1))], P, mp)) != MP_OKAY) {
@ -2523,20 +2524,20 @@ mp_2expt (mp_int * a, int b)
int int
mp_set_bit (mp_int * a, int b) mp_set_bit (mp_int * a, int b)
{ {
int i = b / DIGIT_BIT, res; int i = b / DIGIT_BIT, res;
/* grow a to accomodate the single bit */ /* grow a to accomodate the single bit */
if ((res = mp_grow (a, i + 1)) != MP_OKAY) { if ((res = mp_grow (a, i + 1)) != MP_OKAY) {
return res; return res;
} }
/* set the used count of where the bit will go */ /* set the used count of where the bit will go */
a->used = i + 1; a->used = i + 1;
/* put the single bit in its place */ /* put the single bit in its place */
a->dp[i] |= ((mp_digit)1) << (b % DIGIT_BIT); a->dp[i] |= ((mp_digit)1) << (b % DIGIT_BIT);
return MP_OKAY; return MP_OKAY;
} }
/* multiply by a digit */ /* multiply by a digit */
@ -3192,7 +3193,8 @@ int mp_montgomery_calc_normalization (mp_int * a, mp_int * b)
bits = mp_count_bits (b) % DIGIT_BIT; bits = mp_count_bits (b) % DIGIT_BIT;
if (b->used > 1) { if (b->used > 1) {
if ((res = mp_2expt (a, (b->used - 1) * DIGIT_BIT + bits - 1)) != MP_OKAY) { if ((res = mp_2expt (a, (b->used - 1) * DIGIT_BIT + bits - 1))
!= MP_OKAY) {
return res; return res;
} }
} else { } else {
@ -3624,7 +3626,8 @@ s_mp_mul_high_digs (mp_int * a, mp_int * b, mp_int * c, int digs)
/* can we use the fast multiplier? */ /* can we use the fast multiplier? */
#ifdef BN_FAST_S_MP_MUL_HIGH_DIGS_C #ifdef BN_FAST_S_MP_MUL_HIGH_DIGS_C
if (((a->used + b->used + 1) < MP_WARRAY) if (((a->used + b->used + 1) < MP_WARRAY)
&& MIN (a->used, b->used) < (1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) { && MIN (a->used, b->used) <
(1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) {
return fast_s_mp_mul_high_digs (a, b, c, digs); return fast_s_mp_mul_high_digs (a, b, c, digs);
} }
#endif #endif
@ -3818,7 +3821,8 @@ int mp_sqrmod (mp_int * a, mp_int * b, mp_int * c)
#endif #endif
#if defined(HAVE_ECC) || !defined(NO_PWDBASED) || defined(WOLFSSL_SNIFFER) || defined(WOLFSSL_HAVE_WOLFSCEP) || defined(WOLFSSL_KEY_GEN) #if defined(HAVE_ECC) || !defined(NO_PWDBASED) || defined(WOLFSSL_SNIFFER) || \
defined(WOLFSSL_HAVE_WOLFSCEP) || defined(WOLFSSL_KEY_GEN)
/* single digit addition */ /* single digit addition */
int mp_add_d (mp_int* a, mp_digit b, mp_int* c) int mp_add_d (mp_int* a, mp_digit b, mp_int* c)
@ -4120,7 +4124,7 @@ int mp_mod_d (mp_int * a, mp_digit b, mp_digit * c)
return mp_div_d(a, b, NULL, c); return mp_div_d(a, b, NULL, c);
} }
#endif /* defined(WOLFSSL_KEY_GEN) || defined(HAVE_COMP_KEY) || defined(HAVE_ECC) */ #endif /* defined(WOLFSSL_KEY_GEN)||defined(HAVE_COMP_KEY)||defined(HAVE_ECC) */
#ifdef WOLFSSL_KEY_GEN #ifdef WOLFSSL_KEY_GEN
@ -4472,7 +4476,8 @@ LBL_U:mp_clear (&v);
#ifdef HAVE_ECC #ifdef HAVE_ECC
/* chars used in radix conversions */ /* chars used in radix conversions */
const char *mp_s_rmap = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/"; const char *mp_s_rmap = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ\
abcdefghijklmnopqrstuvwxyz+/";
/* read a string [ASCII] in a given radix */ /* read a string [ASCII] in a given radix */
int mp_read_radix (mp_int * a, const char *str, int radix) int mp_read_radix (mp_int * a, const char *str, int radix)
@ -4541,110 +4546,110 @@ int mp_read_radix (mp_int * a, const char *str, int radix)
/* returns size of ASCII representation */ /* returns size of ASCII representation */
int mp_radix_size (mp_int *a, int radix, int *size) int mp_radix_size (mp_int *a, int radix, int *size)
{ {
int res, digs; int res, digs;
mp_int t; mp_int t;
mp_digit d; mp_digit d;
*size = 0; *size = 0;
/* special case for binary */ /* special case for binary */
if (radix == 2) { if (radix == 2) {
*size = mp_count_bits (a) + (a->sign == MP_NEG ? 1 : 0) + 1; *size = mp_count_bits (a) + (a->sign == MP_NEG ? 1 : 0) + 1;
return MP_OKAY; return MP_OKAY;
} }
/* make sure the radix is in range */ /* make sure the radix is in range */
if (radix < 2 || radix > 64) { if (radix < 2 || radix > 64) {
return MP_VAL; return MP_VAL;
} }
if (mp_iszero(a) == MP_YES) { if (mp_iszero(a) == MP_YES) {
*size = 2; *size = 2;
return MP_OKAY; return MP_OKAY;
} }
/* digs is the digit count */ /* digs is the digit count */
digs = 0; digs = 0;
/* if it's negative add one for the sign */ /* if it's negative add one for the sign */
if (a->sign == MP_NEG) { if (a->sign == MP_NEG) {
++digs; ++digs;
} }
/* init a copy of the input */ /* init a copy of the input */
if ((res = mp_init_copy (&t, a)) != MP_OKAY) { if ((res = mp_init_copy (&t, a)) != MP_OKAY) {
return res; return res;
} }
/* force temp to positive */ /* force temp to positive */
t.sign = MP_ZPOS; t.sign = MP_ZPOS;
/* fetch out all of the digits */ /* fetch out all of the digits */
while (mp_iszero (&t) == MP_NO) { while (mp_iszero (&t) == MP_NO) {
if ((res = mp_div_d (&t, (mp_digit) radix, &t, &d)) != MP_OKAY) { if ((res = mp_div_d (&t, (mp_digit) radix, &t, &d)) != MP_OKAY) {
mp_clear (&t); mp_clear (&t);
return res; return res;
} }
++digs; ++digs;
} }
mp_clear (&t); mp_clear (&t);
/* return digs + 1, the 1 is for the NULL byte that would be required. */ /* return digs + 1, the 1 is for the NULL byte that would be required. */
*size = digs + 1; *size = digs + 1;
return MP_OKAY; return MP_OKAY;
} }
/* stores a bignum as a ASCII string in a given radix (2..64) */ /* stores a bignum as a ASCII string in a given radix (2..64) */
int mp_toradix (mp_int *a, char *str, int radix) int mp_toradix (mp_int *a, char *str, int radix)
{ {
int res, digs; int res, digs;
mp_int t; mp_int t;
mp_digit d; mp_digit d;
char *_s = str; char *_s = str;
/* check range of the radix */ /* check range of the radix */
if (radix < 2 || radix > 64) { if (radix < 2 || radix > 64) {
return MP_VAL; return MP_VAL;
} }
/* quick out if its zero */ /* quick out if its zero */
if (mp_iszero(a) == 1) { if (mp_iszero(a) == 1) {
*str++ = '0'; *str++ = '0';
*str = '\0'; *str = '\0';
return MP_OKAY; return MP_OKAY;
} }
if ((res = mp_init_copy (&t, a)) != MP_OKAY) { if ((res = mp_init_copy (&t, a)) != MP_OKAY) {
return res; return res;
} }
/* if it is negative output a - */ /* if it is negative output a - */
if (t.sign == MP_NEG) { if (t.sign == MP_NEG) {
++_s; ++_s;
*str++ = '-'; *str++ = '-';
t.sign = MP_ZPOS; t.sign = MP_ZPOS;
} }
digs = 0; digs = 0;
while (mp_iszero (&t) == 0) { while (mp_iszero (&t) == 0) {
if ((res = mp_div_d (&t, (mp_digit) radix, &t, &d)) != MP_OKAY) { if ((res = mp_div_d (&t, (mp_digit) radix, &t, &d)) != MP_OKAY) {
mp_clear (&t); mp_clear (&t);
return res; return res;
} }
*str++ = mp_s_rmap[d]; *str++ = mp_s_rmap[d];
++digs; ++digs;
} }
/* reverse the digits of the string. In this case _s points /* reverse the digits of the string. In this case _s points
* to the first digit [exluding the sign] of the number] * to the first digit [exluding the sign] of the number]
*/ */
bn_reverse ((unsigned char *)_s, digs); bn_reverse ((unsigned char *)_s, digs);
/* append a NULL so the string is properly terminated */ /* append a NULL so the string is properly terminated */
*str = '\0'; *str = '\0';
mp_clear (&t); mp_clear (&t);
return MP_OKAY; return MP_OKAY;
} }
#endif /* HAVE_ECC */ #endif /* HAVE_ECC */

194
wolfcrypt/src/tfm.c
View File

@ -538,7 +538,7 @@ int fp_div(fp_int *a, fp_int *b, fp_int *c, fp_int *d)
t = y.used - 1; t = y.used - 1;
/* while (x >= y*b**n-t) do { q[n-t] += 1; x -= y*b**{n-t} } */ /* while (x >= y*b**n-t) do { q[n-t] += 1; x -= y*b**{n-t} } */
fp_lshd (&y, n - t); /* y = y*b**{n-t} */ fp_lshd (&y, n - t); /* y = y*b**{n-t} */
while (fp_cmp (&x, &y) != FP_LT) { while (fp_cmp (&x, &y) != FP_LT) {
++(q.dp[n - t]); ++(q.dp[n - t]);
@ -966,8 +966,8 @@ int fp_mulmod(fp_int *a, fp_int *b, fp_int *c, fp_int *d)
#ifdef TFM_TIMING_RESISTANT #ifdef TFM_TIMING_RESISTANT
/* timing resistant montgomery ladder based exptmod /* timing resistant montgomery ladder based exptmod
Based on work by Marc Joye, Sung-Ming Yen, "The Montgomery Powering Ladder",
Based on work by Marc Joye, Sung-Ming Yen, "The Montgomery Powering Ladder", Cryptographic Hardware and Embedded Systems, CHES 2002 Cryptographic Hardware and Embedded Systems, CHES 2002
*/ */
static int _fp_exptmod(fp_int * G, fp_int * X, fp_int * P, fp_int * Y) static int _fp_exptmod(fp_int * G, fp_int * X, fp_int * P, fp_int * Y)
{ {
@ -1085,7 +1085,8 @@ static int _fp_exptmod(fp_int * G, fp_int * X, fp_int * P, fp_int * Y)
} }
fp_mulmod (&M[1], &res, P, &M[1]); fp_mulmod (&M[1], &res, P, &M[1]);
/* compute the value at M[1<<(winsize-1)] by squaring M[1] (winsize-1) times */ /* compute the value at M[1<<(winsize-1)] by
* squaring M[1] (winsize-1) times */
fp_copy (&M[1], &M[1 << (winsize - 1)]); fp_copy (&M[1], &M[1 << (winsize - 1)]);
for (x = 0; x < (winsize - 1); x++) { for (x = 0; x < (winsize - 1); x++) {
fp_sqr (&M[1 << (winsize - 1)], &M[1 << (winsize - 1)]); fp_sqr (&M[1 << (winsize - 1)], &M[1 << (winsize - 1)]);
@ -1737,7 +1738,8 @@ void fp_read_unsigned_bin(fp_int *a, unsigned char *b, int c)
/* If we know the endianness of this architecture, and we're using /* If we know the endianness of this architecture, and we're using
32-bit fp_digits, we can optimize this */ 32-bit fp_digits, we can optimize this */
#if (defined(LITTLE_ENDIAN_ORDER) || defined(BIG_ENDIAN_ORDER)) && defined(FP_32BIT) #if (defined(LITTLE_ENDIAN_ORDER) || defined(BIG_ENDIAN_ORDER)) && \
defined(FP_32BIT)
/* But not for both simultaneously */ /* But not for both simultaneously */
#if defined(LITTLE_ENDIAN_ORDER) && defined(BIG_ENDIAN_ORDER) #if defined(LITTLE_ENDIAN_ORDER) && defined(BIG_ENDIAN_ORDER)
#error Both LITTLE_ENDIAN_ORDER and BIG_ENDIAN_ORDER defined. #error Both LITTLE_ENDIAN_ORDER and BIG_ENDIAN_ORDER defined.
@ -1757,12 +1759,12 @@ void fp_read_unsigned_bin(fp_int *a, unsigned char *b, int c)
/* Use Duff's device to unroll the loop. */ /* Use Duff's device to unroll the loop. */
int idx = (c - 1) & ~3; int idx = (c - 1) & ~3;
switch (c % 4) { switch (c % 4) {
case 0: do { pd[idx+0] = *b++; case 0: do { pd[idx+0] = *b++;
case 3: pd[idx+1] = *b++; case 3: pd[idx+1] = *b++;
case 2: pd[idx+2] = *b++; case 2: pd[idx+2] = *b++;
case 1: pd[idx+3] = *b++; case 1: pd[idx+3] = *b++;
idx -= 4; idx -= 4;
} while ((c -= 4) > 0); } while ((c -= 4) > 0);
} }
} }
#else #else
@ -1813,10 +1815,10 @@ void fp_set(fp_int *a, fp_digit b)
/* chek if a bit is set */ /* chek if a bit is set */
int fp_is_bit_set (fp_int *a, fp_digit b) int fp_is_bit_set (fp_int *a, fp_digit b)
{ {
if ((fp_digit)a->used < b/DIGIT_BIT) if ((fp_digit)a->used < b/DIGIT_BIT)
return 0; return 0;
return (int)((a->dp[b/DIGIT_BIT] >> b%DIGIT_BIT) & (fp_digit)1); return (int)((a->dp[b/DIGIT_BIT] >> b%DIGIT_BIT) & (fp_digit)1);
} }
int fp_count_bits (fp_int * a) int fp_count_bits (fp_int * a)
@ -2003,7 +2005,8 @@ void mp_clear (mp_int * a)
} }
/* handle up to 6 inits */ /* handle up to 6 inits */
int mp_init_multi(mp_int* a, mp_int* b, mp_int* c, mp_int* d, mp_int* e, mp_int* f) int mp_init_multi(mp_int* a, mp_int* b, mp_int* c, mp_int* d,
mp_int* e, mp_int* f)
{ {
if (a) if (a)
fp_init(a); fp_init(a);
@ -2111,7 +2114,7 @@ int mp_sub_d(fp_int *a, fp_digit b, fp_int *c)
int mp_mul_2d(fp_int *a, int b, fp_int *c) int mp_mul_2d(fp_int *a, int b, fp_int *c)
{ {
fp_mul_2d(a, b, c); fp_mul_2d(a, b, c);
return MP_OKAY; return MP_OKAY;
} }
@ -2191,7 +2194,7 @@ int mp_set_int(fp_int *a, fp_digit b)
int mp_is_bit_set (fp_int *a, fp_digit b) int mp_is_bit_set (fp_int *a, fp_digit b)
{ {
return fp_is_bit_set(a, b); return fp_is_bit_set(a, b);
} }
#if defined(WOLFSSL_KEY_GEN) || defined (HAVE_ECC) #if defined(WOLFSSL_KEY_GEN) || defined (HAVE_ECC)
@ -2597,7 +2600,8 @@ int mp_add_d(fp_int *a, fp_digit b, fp_int *c)
#ifdef HAVE_ECC #ifdef HAVE_ECC
/* chars used in radix conversions */ /* chars used in radix conversions */
static const char *fp_s_rmap = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/"; static const char *fp_s_rmap = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ\
abcdefghijklmnopqrstuvwxyz+/";
static int fp_read_radix(fp_int *a, const char *str, int radix) static int fp_read_radix(fp_int *a, const char *str, int radix)
{ {
@ -2717,107 +2721,107 @@ int mp_cnt_lsb(fp_int* a)
/* returns size of ASCII reprensentation */ /* returns size of ASCII reprensentation */
int mp_radix_size (mp_int *a, int radix, int *size) int mp_radix_size (mp_int *a, int radix, int *size)
{ {
int res, digs; int res, digs;
fp_int t; fp_int t;
fp_digit d; fp_digit d;
*size = 0; *size = 0;
/* special case for binary */ /* special case for binary */
if (radix == 2) { if (radix == 2) {
*size = fp_count_bits (a) + (a->sign == FP_NEG ? 1 : 0) + 1; *size = fp_count_bits (a) + (a->sign == FP_NEG ? 1 : 0) + 1;
return FP_YES; return FP_YES;
} }
/* make sure the radix is in range */ /* make sure the radix is in range */
if (radix < 2 || radix > 64) { if (radix < 2 || radix > 64) {
return FP_VAL; return FP_VAL;
} }
if (fp_iszero(a) == MP_YES) { if (fp_iszero(a) == MP_YES) {
*size = 2; *size = 2;
return FP_YES; return FP_YES;
} }
/* digs is the digit count */ /* digs is the digit count */
digs = 0; digs = 0;
/* if it's negative add one for the sign */ /* if it's negative add one for the sign */
if (a->sign == FP_NEG) { if (a->sign == FP_NEG) {
++digs; ++digs;
} }
/* init a copy of the input */ /* init a copy of the input */
fp_init_copy (&t, a); fp_init_copy (&t, a);
/* force temp to positive */ /* force temp to positive */
t.sign = FP_ZPOS; t.sign = FP_ZPOS;
/* fetch out all of the digits */ /* fetch out all of the digits */
while (fp_iszero (&t) == FP_NO) { while (fp_iszero (&t) == FP_NO) {
if ((res = fp_div_d (&t, (mp_digit) radix, &t, &d)) != FP_OKAY) { if ((res = fp_div_d (&t, (mp_digit) radix, &t, &d)) != FP_OKAY) {
fp_zero (&t); fp_zero (&t);
return res; return res;
} }
++digs; ++digs;
} }
fp_zero (&t); fp_zero (&t);
/* return digs + 1, the 1 is for the NULL byte that would be required. */ /* return digs + 1, the 1 is for the NULL byte that would be required. */
*size = digs + 1; *size = digs + 1;
return FP_OKAY; return FP_OKAY;
} }
/* stores a bignum as a ASCII string in a given radix (2..64) */ /* stores a bignum as a ASCII string in a given radix (2..64) */
int mp_toradix (mp_int *a, char *str, int radix) int mp_toradix (mp_int *a, char *str, int radix)
{ {
int res, digs; int res, digs;
fp_int t; fp_int t;
fp_digit d; fp_digit d;
char *_s = str; char *_s = str;
/* check range of the radix */ /* check range of the radix */
if (radix < 2 || radix > 64) { if (radix < 2 || radix > 64) {
return FP_VAL; return FP_VAL;
} }
/* quick out if its zero */ /* quick out if its zero */
if (fp_iszero(a) == 1) { if (fp_iszero(a) == 1) {
*str++ = '0'; *str++ = '0';
*str = '\0'; *str = '\0';
return FP_YES; return FP_YES;
} }
/* init a copy of the input */ /* init a copy of the input */
fp_init_copy (&t, a); fp_init_copy (&t, a);
/* if it is negative output a - */ /* if it is negative output a - */
if (t.sign == FP_NEG) { if (t.sign == FP_NEG) {
++_s; ++_s;
*str++ = '-'; *str++ = '-';
t.sign = FP_ZPOS; t.sign = FP_ZPOS;
} }
digs = 0; digs = 0;
while (fp_iszero (&t) == 0) { while (fp_iszero (&t) == 0) {
if ((res = fp_div_d (&t, (fp_digit) radix, &t, &d)) != FP_OKAY) { if ((res = fp_div_d (&t, (fp_digit) radix, &t, &d)) != FP_OKAY) {
fp_zero (&t); fp_zero (&t);
return res; return res;
} }
*str++ = fp_s_rmap[d]; *str++ = fp_s_rmap[d];
++digs; ++digs;
} }
/* reverse the digits of the string. In this case _s points /* reverse the digits of the string. In this case _s points
* to the first digit [exluding the sign] of the number] * to the first digit [exluding the sign] of the number]
*/ */
fp_reverse ((unsigned char *)_s, digs); fp_reverse ((unsigned char *)_s, digs);
/* append a NULL so the string is properly terminated */ /* append a NULL so the string is properly terminated */
*str = '\0'; *str = '\0';
fp_zero (&t); fp_zero (&t);
return FP_OKAY; return FP_OKAY;
} }
#endif /* defined(WOLFSSL_KEY_GEN) || defined(HAVE_COMP_KEY) */ #endif /* defined(WOLFSSL_KEY_GEN) || defined(HAVE_COMP_KEY) */

20
wolfssl/openssl/bn.h
View File

@ -32,9 +32,9 @@ WOLFSSL_API void wolfSSL_BN_clear_free(WOLFSSL_BIGNUM*);
WOLFSSL_API int wolfSSL_BN_sub(WOLFSSL_BIGNUM*, const WOLFSSL_BIGNUM*, WOLFSSL_API int wolfSSL_BN_sub(WOLFSSL_BIGNUM*, const WOLFSSL_BIGNUM*,
const WOLFSSL_BIGNUM*); const WOLFSSL_BIGNUM*);
WOLFSSL_API int wolfSSL_BN_mod(WOLFSSL_BIGNUM*, const WOLFSSL_BIGNUM*, WOLFSSL_API int wolfSSL_BN_mod(WOLFSSL_BIGNUM*, const WOLFSSL_BIGNUM*,
const WOLFSSL_BIGNUM*, const WOLFSSL_BN_CTX*); const WOLFSSL_BIGNUM*, const WOLFSSL_BN_CTX*);
WOLFSSL_API const WOLFSSL_BIGNUM* wolfSSL_BN_value_one(void); WOLFSSL_API const WOLFSSL_BIGNUM* wolfSSL_BN_value_one(void);
@ -50,7 +50,7 @@ WOLFSSL_API int wolfSSL_BN_cmp(const WOLFSSL_BIGNUM*, const WOLFSSL_BIGNUM*);
WOLFSSL_API int wolfSSL_BN_bn2bin(const WOLFSSL_BIGNUM*, unsigned char*); WOLFSSL_API int wolfSSL_BN_bn2bin(const WOLFSSL_BIGNUM*, unsigned char*);
WOLFSSL_API WOLFSSL_BIGNUM* wolfSSL_BN_bin2bn(const unsigned char*, int len, WOLFSSL_API WOLFSSL_BIGNUM* wolfSSL_BN_bin2bn(const unsigned char*, int len,
WOLFSSL_BIGNUM* ret); WOLFSSL_BIGNUM* ret);
WOLFSSL_API int wolfSSL_mask_bits(WOLFSSL_BIGNUM*, int n); WOLFSSL_API int wolfSSL_mask_bits(WOLFSSL_BIGNUM*, int n);
@ -59,7 +59,8 @@ WOLFSSL_API int wolfSSL_BN_is_bit_set(const WOLFSSL_BIGNUM*, int n);
WOLFSSL_API int wolfSSL_BN_hex2bn(WOLFSSL_BIGNUM**, const char* str); WOLFSSL_API int wolfSSL_BN_hex2bn(WOLFSSL_BIGNUM**, const char* str);
WOLFSSL_API WOLFSSL_BIGNUM* wolfSSL_BN_dup(const WOLFSSL_BIGNUM*); WOLFSSL_API WOLFSSL_BIGNUM* wolfSSL_BN_dup(const WOLFSSL_BIGNUM*);
WOLFSSL_API WOLFSSL_BIGNUM* wolfSSL_BN_copy(WOLFSSL_BIGNUM*, const WOLFSSL_BIGNUM*); WOLFSSL_API WOLFSSL_BIGNUM* wolfSSL_BN_copy(WOLFSSL_BIGNUM*,
const WOLFSSL_BIGNUM*);
WOLFSSL_API int wolfSSL_BN_dec2bn(WOLFSSL_BIGNUM**, const char* str); WOLFSSL_API int wolfSSL_BN_dec2bn(WOLFSSL_BIGNUM**, const char* str);
WOLFSSL_API char* wolfSSL_BN_bn2dec(const WOLFSSL_BIGNUM*); WOLFSSL_API char* wolfSSL_BN_bn2dec(const WOLFSSL_BIGNUM*);
@ -69,12 +70,13 @@ WOLFSSL_API int wolfSSL_BN_add_word(WOLFSSL_BIGNUM*, WOLFSSL_BN_ULONG);
WOLFSSL_API int wolfSSL_BN_set_bit(WOLFSSL_BIGNUM*, int); WOLFSSL_API int wolfSSL_BN_set_bit(WOLFSSL_BIGNUM*, int);
WOLFSSL_API int wolfSSL_BN_set_word(WOLFSSL_BIGNUM*, WOLFSSL_BN_ULONG); WOLFSSL_API int wolfSSL_BN_set_word(WOLFSSL_BIGNUM*, WOLFSSL_BN_ULONG);
WOLFSSL_API int wolfSSL_BN_add(WOLFSSL_BIGNUM*, WOLFSSL_BIGNUM*,
/* 2/6 */ WOLFSSL_BIGNUM*);
WOLFSSL_API int wolfSSL_BN_add(WOLFSSL_BIGNUM*, WOLFSSL_BIGNUM*, WOLFSSL_BIGNUM*);
WOLFSSL_API char *wolfSSL_BN_bn2hex(const WOLFSSL_BIGNUM*); WOLFSSL_API char *wolfSSL_BN_bn2hex(const WOLFSSL_BIGNUM*);
WOLFSSL_API int wolfSSL_BN_is_prime_ex(const WOLFSSL_BIGNUM*, int, WOLFSSL_BN_CTX*, WOLFSSL_BN_GENCB*); WOLFSSL_API int wolfSSL_BN_is_prime_ex(const WOLFSSL_BIGNUM*, int,
WOLFSSL_API WOLFSSL_BN_ULONG wolfSSL_BN_mod_word(const WOLFSSL_BIGNUM*, WOLFSSL_BN_ULONG); WOLFSSL_BN_CTX*, WOLFSSL_BN_GENCB*);
WOLFSSL_API WOLFSSL_BN_ULONG wolfSSL_BN_mod_word(const WOLFSSL_BIGNUM*,
WOLFSSL_BN_ULONG);
WOLFSSL_API int wolfSSL_BN_print_fp(FILE*, const WOLFSSL_BIGNUM*); WOLFSSL_API int wolfSSL_BN_print_fp(FILE*, const WOLFSSL_BIGNUM*);
WOLFSSL_API int wolfSSL_BN_rshift(WOLFSSL_BIGNUM*, const WOLFSSL_BIGNUM*, int); WOLFSSL_API int wolfSSL_BN_rshift(WOLFSSL_BIGNUM*, const WOLFSSL_BIGNUM*, int);
WOLFSSL_API WOLFSSL_BIGNUM *wolfSSL_BN_CTX_get(WOLFSSL_BN_CTX *ctx); WOLFSSL_API WOLFSSL_BIGNUM *wolfSSL_BN_CTX_get(WOLFSSL_BN_CTX *ctx);

9
wolfssl/openssl/dh.h
View File

@ -4,21 +4,16 @@
#ifndef WOLFSSL_DH_H_ #ifndef WOLFSSL_DH_H_
#define WOLFSSL_DH_H_ #define WOLFSSL_DH_H_
#include <wolfssl/openssl/ssl.h> #include <wolfssl/openssl/ssl.h>
#include <wolfssl/openssl/bn.h> #include <wolfssl/openssl/bn.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
typedef struct WOLFSSL_DH { typedef struct WOLFSSL_DH {
WOLFSSL_BIGNUM* p; WOLFSSL_BIGNUM* p;
WOLFSSL_BIGNUM* g; WOLFSSL_BIGNUM* g;
WOLFSSL_BIGNUM* pub_key; /* openssh deference g^x */ WOLFSSL_BIGNUM* pub_key; /* openssh deference g^x */
WOLFSSL_BIGNUM* priv_key; /* openssh deference x */ WOLFSSL_BIGNUM* priv_key; /* openssh deference x */
void* internal; /* our DH */ void* internal; /* our DH */

25
wolfssl/openssl/dsa.h
View File

@ -4,23 +4,19 @@
#ifndef WOLFSSL_DSA_H_ #ifndef WOLFSSL_DSA_H_
#define WOLFSSL_DSA_H_ #define WOLFSSL_DSA_H_
#include <wolfssl/openssl/ssl.h> #include <wolfssl/openssl/ssl.h>
#include <wolfssl/openssl/bn.h> #include <wolfssl/openssl/bn.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
struct WOLFSSL_DSA { struct WOLFSSL_DSA {
WOLFSSL_BIGNUM* p; WOLFSSL_BIGNUM* p;
WOLFSSL_BIGNUM* q; WOLFSSL_BIGNUM* q;
WOLFSSL_BIGNUM* g; WOLFSSL_BIGNUM* g;
WOLFSSL_BIGNUM* pub_key; /* our y */ WOLFSSL_BIGNUM* pub_key; /* our y */
WOLFSSL_BIGNUM* priv_key; /* our x */ WOLFSSL_BIGNUM* priv_key; /* our x */
void* internal; /* our Dsa Key */ void* internal; /* our Dsa Key */
char inSet; /* internal set from external ? */ char inSet; /* internal set from external ? */
char exSet; /* external set from internal ? */ char exSet; /* external set from internal ? */
@ -36,10 +32,13 @@ WOLFSSL_API int wolfSSL_DSA_generate_parameters_ex(WOLFSSL_DSA*, int bits,
unsigned long* hRet, void* cb); unsigned long* hRet, void* cb);
WOLFSSL_API int wolfSSL_DSA_LoadDer(WOLFSSL_DSA*, const unsigned char*, int sz); WOLFSSL_API int wolfSSL_DSA_LoadDer(WOLFSSL_DSA*, const unsigned char*, int sz);
WOLFSSL_API int wolfSSL_DSA_do_sign(const unsigned char* d, unsigned char* sigRet,
WOLFSSL_DSA* dsa); WOLFSSL_API int wolfSSL_DSA_do_sign(const unsigned char* d,
WOLFSSL_API int wolfSSL_DSA_do_verify(const unsigned char* d, unsigned char* sig, unsigned char* sigRet, WOLFSSL_DSA* dsa);
WOLFSSL_DSA* dsa, int *dsacheck);
WOLFSSL_API int wolfSSL_DSA_do_verify(const unsigned char* d,
unsigned char* sig,
WOLFSSL_DSA* dsa, int *dsacheck);
#define DSA_new wolfSSL_DSA_new #define DSA_new wolfSSL_DSA_new
#define DSA_free wolfSSL_DSA_free #define DSA_free wolfSSL_DSA_free

170
wolfssl/openssl/ec.h
View File

@ -6,96 +6,135 @@
#include <wolfssl/openssl/ssl.h> #include <wolfssl/openssl/ssl.h>
#include <wolfssl/openssl/bn.h> #include <wolfssl/openssl/bn.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/* Map OpenSSL NID value */ /* Map OpenSSL NID value */
enum { enum {
POINT_CONVERSION_UNCOMPRESSED = 4, POINT_CONVERSION_UNCOMPRESSED = 4,
NID_secp111r1 = 0, NID_secp111r1 = 0,
NID_secp128r1 = 1, NID_secp128r1 = 1,
NID_secp160r1 = 2, NID_secp160r1 = 2,
NID_cert192 = 3, NID_cert192 = 3,
NID_cert224 = 4, NID_cert224 = 4,
NID_X9_62_prime256v1 = 5, NID_X9_62_prime256v1 = 5,
NID_secp384r1 = 6, NID_secp384r1 = 6,
NID_secp521r1 = 7, NID_secp521r1 = 7,
NID_X9_62_prime_field = 100, NID_X9_62_prime_field = 100,
OPENSSL_EC_NAMED_CURVE = 0x001 OPENSSL_EC_NAMED_CURVE = 0x001
}; };
struct WOLFSSL_EC_POINT { struct WOLFSSL_EC_POINT {
WOLFSSL_BIGNUM *X; WOLFSSL_BIGNUM *X;
WOLFSSL_BIGNUM *Y; WOLFSSL_BIGNUM *Y;
WOLFSSL_BIGNUM *Z; WOLFSSL_BIGNUM *Z;
void* internal; /* our ECC point */ void* internal; /* our ECC point */
char inSet; /* internal set from external ? */ char inSet; /* internal set from external ? */
char exSet; /* external set from internal ? */ char exSet; /* external set from internal ? */
}; };
struct WOLFSSL_EC_GROUP { struct WOLFSSL_EC_GROUP {
int curve_idx; /* index of curve, used by WolfSSL as a curve reference */ int curve_idx; /* index of curve, used by WolfSSL as reference */
int curve_nid; /* NID of curve, used by OpenSSL/OpenSSH as a curve reference */ int curve_nid; /* NID of curve, used by OpenSSL/OpenSSH as reference */
}; };
struct WOLFSSL_EC_KEY { struct WOLFSSL_EC_KEY {
WOLFSSL_EC_GROUP *group; WOLFSSL_EC_GROUP *group;
WOLFSSL_EC_POINT *pub_key; WOLFSSL_EC_POINT *pub_key;
WOLFSSL_BIGNUM *priv_key; WOLFSSL_BIGNUM *priv_key;
void* internal; /* our ECC Key */ void* internal; /* our ECC Key */
char inSet; /* internal set from external ? */ char inSet; /* internal set from external ? */
char exSet; /* external set from internal ? */ char exSet; /* external set from internal ? */
}; };
WOLFSSL_API int wolfSSL_ECPoint_i2d(const WOLFSSL_EC_GROUP *curve, const WOLFSSL_EC_POINT *p, unsigned char *out, unsigned int *len); WOLFSSL_API
WOLFSSL_API int wolfSSL_ECPoint_d2i(unsigned char *in, unsigned int len, const WOLFSSL_EC_GROUP *curve, WOLFSSL_EC_POINT *p); int wolfSSL_ECPoint_i2d(const WOLFSSL_EC_GROUP *curve,
WOLFSSL_API int wolfSSL_EC_KEY_LoadDer(WOLFSSL_EC_KEY* key, const unsigned char* der, int derSz); const WOLFSSL_EC_POINT *p,
unsigned char *out, unsigned int *len);
WOLFSSL_API void wolfSSL_EC_KEY_free(WOLFSSL_EC_KEY *key); WOLFSSL_API
WOLFSSL_API WOLFSSL_EC_POINT *wolfSSL_EC_KEY_get0_public_key(const WOLFSSL_EC_KEY *key); int wolfSSL_ECPoint_d2i(unsigned char *in, unsigned int len,
WOLFSSL_API const WOLFSSL_EC_GROUP *wolfSSL_EC_KEY_get0_group(const WOLFSSL_EC_KEY *key); const WOLFSSL_EC_GROUP *curve, WOLFSSL_EC_POINT *p);
WOLFSSL_API int wolfSSL_EC_KEY_set_private_key(WOLFSSL_EC_KEY *key, const WOLFSSL_BIGNUM *priv_key); WOLFSSL_API
WOLFSSL_API WOLFSSL_BIGNUM *wolfSSL_EC_KEY_get0_private_key(const WOLFSSL_EC_KEY *key); int wolfSSL_EC_KEY_LoadDer(WOLFSSL_EC_KEY* key,
WOLFSSL_API WOLFSSL_EC_KEY *wolfSSL_EC_KEY_new_by_curve_name(int nid); const unsigned char* der, int derSz);
WOLFSSL_API WOLFSSL_EC_KEY *wolfSSL_EC_KEY_new(void); WOLFSSL_API
WOLFSSL_API int wolfSSL_EC_KEY_set_group(WOLFSSL_EC_KEY *key, WOLFSSL_EC_GROUP *group); void wolfSSL_EC_KEY_free(WOLFSSL_EC_KEY *key);
WOLFSSL_API int wolfSSL_EC_KEY_generate_key(WOLFSSL_EC_KEY *key); WOLFSSL_API
WOLFSSL_API void wolfSSL_EC_KEY_set_asn1_flag(WOLFSSL_EC_KEY *key, int asn1_flag); WOLFSSL_EC_POINT *wolfSSL_EC_KEY_get0_public_key(const WOLFSSL_EC_KEY *key);
WOLFSSL_API int wolfSSL_EC_KEY_set_public_key(WOLFSSL_EC_KEY *key, const WOLFSSL_EC_POINT *pub); WOLFSSL_API
const WOLFSSL_EC_GROUP *wolfSSL_EC_KEY_get0_group(const WOLFSSL_EC_KEY *key);
WOLFSSL_API
WOLFSSL_API void wolfSSL_EC_GROUP_set_asn1_flag(WOLFSSL_EC_GROUP *group, int flag); int wolfSSL_EC_KEY_set_private_key(WOLFSSL_EC_KEY *key,
WOLFSSL_API WOLFSSL_EC_GROUP *wolfSSL_EC_GROUP_new_by_curve_name(int nid); const WOLFSSL_BIGNUM *priv_key);
WOLFSSL_API int wolfSSL_EC_GROUP_cmp(const WOLFSSL_EC_GROUP *a, const WOLFSSL_EC_GROUP *b, WOLFSSL_BN_CTX *ctx); WOLFSSL_API
WOLFSSL_API int wolfSSL_EC_GROUP_get_curve_name(const WOLFSSL_EC_GROUP *group); WOLFSSL_BIGNUM *wolfSSL_EC_KEY_get0_private_key(const WOLFSSL_EC_KEY *key);
WOLFSSL_API int wolfSSL_EC_GROUP_get_degree(const WOLFSSL_EC_GROUP *group); WOLFSSL_API
WOLFSSL_API int wolfSSL_EC_GROUP_get_order(const WOLFSSL_EC_GROUP *group, WOLFSSL_BIGNUM *order, WOLFSSL_BN_CTX *ctx); WOLFSSL_EC_KEY *wolfSSL_EC_KEY_new_by_curve_name(int nid);
WOLFSSL_API void wolfSSL_EC_GROUP_free(WOLFSSL_EC_GROUP *group); WOLFSSL_API
WOLFSSL_EC_KEY *wolfSSL_EC_KEY_new(void);
WOLFSSL_API void wolfssl_EC_POINT_dump(const char *msg, const WOLFSSL_EC_POINT *p); WOLFSSL_API
WOLFSSL_API WOLFSSL_EC_POINT *wolfSSL_EC_POINT_new(const WOLFSSL_EC_GROUP *group); int wolfSSL_EC_KEY_set_group(WOLFSSL_EC_KEY *key, WOLFSSL_EC_GROUP *group);
WOLFSSL_API int wolfSSL_EC_POINT_get_affine_coordinates_GFp(const WOLFSSL_EC_GROUP *group, const WOLFSSL_EC_POINT *p, WOLFSSL_API
WOLFSSL_BIGNUM *x, WOLFSSL_BIGNUM *y, WOLFSSL_BN_CTX *ctx); int wolfSSL_EC_KEY_generate_key(WOLFSSL_EC_KEY *key);
WOLFSSL_API int wolfSSL_EC_POINT_mul(const WOLFSSL_EC_GROUP *group, WOLFSSL_EC_POINT *r, const WOLFSSL_BIGNUM *n, WOLFSSL_API
const WOLFSSL_EC_POINT *q, const WOLFSSL_BIGNUM *m, WOLFSSL_BN_CTX *ctx); void wolfSSL_EC_KEY_set_asn1_flag(WOLFSSL_EC_KEY *key, int asn1_flag);
WOLFSSL_API void wolfSSL_EC_POINT_clear_free(WOLFSSL_EC_POINT *point); WOLFSSL_API
WOLFSSL_API int wolfSSL_EC_POINT_cmp(const WOLFSSL_EC_GROUP *group, const WOLFSSL_EC_POINT *a, int wolfSSL_EC_KEY_set_public_key(WOLFSSL_EC_KEY *key,
const WOLFSSL_EC_POINT *b, WOLFSSL_BN_CTX *ctx); const WOLFSSL_EC_POINT *pub);
WOLFSSL_API void wolfSSL_EC_POINT_free(WOLFSSL_EC_POINT *point); WOLFSSL_API
WOLFSSL_API int wolfSSL_EC_POINT_is_at_infinity(const WOLFSSL_EC_GROUP *group, const WOLFSSL_EC_POINT *a); void wolfSSL_EC_GROUP_set_asn1_flag(WOLFSSL_EC_GROUP *group, int flag);
WOLFSSL_API
WOLFSSL_EC_GROUP *wolfSSL_EC_GROUP_new_by_curve_name(int nid);
WOLFSSL_API
int wolfSSL_EC_GROUP_cmp(const WOLFSSL_EC_GROUP *a, const WOLFSSL_EC_GROUP *b,
WOLFSSL_BN_CTX *ctx);
WOLFSSL_API
int wolfSSL_EC_GROUP_get_curve_name(const WOLFSSL_EC_GROUP *group);
WOLFSSL_API
int wolfSSL_EC_GROUP_get_degree(const WOLFSSL_EC_GROUP *group);
WOLFSSL_API
int wolfSSL_EC_GROUP_get_order(const WOLFSSL_EC_GROUP *group,
WOLFSSL_BIGNUM *order, WOLFSSL_BN_CTX *ctx);
WOLFSSL_API
void wolfSSL_EC_GROUP_free(WOLFSSL_EC_GROUP *group);
WOLFSSL_API
void wolfssl_EC_POINT_dump(const char *msg, const WOLFSSL_EC_POINT *p);
WOLFSSL_API
WOLFSSL_EC_POINT *wolfSSL_EC_POINT_new(const WOLFSSL_EC_GROUP *group);
WOLFSSL_API
int wolfSSL_EC_POINT_get_affine_coordinates_GFp(const WOLFSSL_EC_GROUP *group,
const WOLFSSL_EC_POINT *p,
WOLFSSL_BIGNUM *x,
WOLFSSL_BIGNUM *y,
WOLFSSL_BN_CTX *ctx);
WOLFSSL_API
int wolfSSL_EC_POINT_mul(const WOLFSSL_EC_GROUP *group, WOLFSSL_EC_POINT *r,
const WOLFSSL_BIGNUM *n,
const WOLFSSL_EC_POINT *q, const WOLFSSL_BIGNUM *m,
WOLFSSL_BN_CTX *ctx);
WOLFSSL_API
void wolfSSL_EC_POINT_clear_free(WOLFSSL_EC_POINT *point);
WOLFSSL_API
int wolfSSL_EC_POINT_cmp(const WOLFSSL_EC_GROUP *group,
const WOLFSSL_EC_POINT *a, const WOLFSSL_EC_POINT *b,
WOLFSSL_BN_CTX *ctx);
WOLFSSL_API
void wolfSSL_EC_POINT_free(WOLFSSL_EC_POINT *point);
WOLFSSL_API
int wolfSSL_EC_POINT_is_at_infinity(const WOLFSSL_EC_GROUP *group,
const WOLFSSL_EC_POINT *a);
#define EC_KEY_free wolfSSL_EC_KEY_free #define EC_KEY_free wolfSSL_EC_KEY_free
#define EC_KEY_get0_public_key wolfSSL_EC_KEY_get0_public_key #define EC_KEY_get0_public_key wolfSSL_EC_KEY_get0_public_key
#define EC_KEY_get0_group wolfSSL_EC_KEY_get0_group #define EC_KEY_get0_group wolfSSL_EC_KEY_get0_group
#define EC_KEY_set_private_key wolfSSL_EC_KEY_set_private_key #define EC_KEY_set_private_key wolfSSL_EC_KEY_set_private_key
#define EC_KEY_get0_private_key wolfSSL_EC_KEY_get0_private_key #define EC_KEY_get0_private_key wolfSSL_EC_KEY_get0_private_key
#define EC_KEY_new_by_curve_name wolfSSL_EC_KEY_new_by_curve_name #define EC_KEY_new_by_curve_name wolfSSL_EC_KEY_new_by_curve_name
#define EC_KEY_set_group wolfSSL_EC_KEY_set_group #define EC_KEY_set_group wolfSSL_EC_KEY_set_group
#define EC_KEY_generate_key wolfSSL_EC_KEY_generate_key #define EC_KEY_generate_key wolfSSL_EC_KEY_generate_key
#define EC_KEY_set_asn1_flag wolfSSL_EC_KEY_set_asn1_flag #define EC_KEY_set_asn1_flag wolfSSL_EC_KEY_set_asn1_flag
#define EC_KEY_set_public_key wolfSSL_EC_KEY_set_public_key #define EC_KEY_set_public_key wolfSSL_EC_KEY_set_public_key
#define EC_KEY_new wolfSSL_EC_KEY_new #define EC_KEY_new wolfSSL_EC_KEY_new
@ -109,7 +148,8 @@ WOLFSSL_API int wolfSSL_EC_POINT_is_at_infinity(const WOLFSSL_EC_GROUP *group, c
#define EC_GROUP_free wolfSSL_EC_GROUP_free #define EC_GROUP_free wolfSSL_EC_GROUP_free
#define EC_POINT_new wolfSSL_EC_POINT_new #define EC_POINT_new wolfSSL_EC_POINT_new
#define EC_POINT_get_affine_coordinates_GFp wolfSSL_EC_POINT_get_affine_coordinates_GFp #define EC_POINT_get_affine_coordinates_GFp \
wolfSSL_EC_POINT_get_affine_coordinates_GFp
#define EC_POINT_mul wolfSSL_EC_POINT_mul #define EC_POINT_mul wolfSSL_EC_POINT_mul
#define EC_POINT_clear_free wolfSSL_EC_POINT_clear_free #define EC_POINT_clear_free wolfSSL_EC_POINT_clear_free
#define EC_POINT_cmp wolfSSL_EC_POINT_cmp #define EC_POINT_cmp wolfSSL_EC_POINT_cmp

9
wolfssl/openssl/ecdh.h
View File

@ -11,8 +11,13 @@ extern C {
#endif #endif
WOLFSSL_API int wolfSSL_ECDH_compute_key(void *out, size_t outlen, const WOLFSSL_EC_POINT *pub_key, WOLFSSL_API int wolfSSL_ECDH_compute_key(void *out, size_t outlen,
WOLFSSL_EC_KEY *ecdh, void *(*KDF) (const void *in, size_t inlen, void *out, size_t *outlen)); const WOLFSSL_EC_POINT *pub_key,
WOLFSSL_EC_KEY *ecdh,
void *(*KDF) (const void *in,
size_t inlen,
void *out,
size_t *outlen));
#define ECDH_compute_key wolfSSL_ECDH_compute_key #define ECDH_compute_key wolfSSL_ECDH_compute_key

26
wolfssl/openssl/ecdsa.h
View File

@ -12,24 +12,24 @@ extern "C" {
#endif #endif
struct WOLFSSL_ECDSA_SIG { struct WOLFSSL_ECDSA_SIG {
WOLFSSL_BIGNUM *r; WOLFSSL_BIGNUM *r;
WOLFSSL_BIGNUM *s; WOLFSSL_BIGNUM *s;
#if 0
void* internal; /* our EC DSA */
char inSet; /* internal set from external ? */
char exSet; /* external set from internal ? */
#endif
}; };
WOLFSSL_API void wolfSSL_ECDSA_SIG_free(WOLFSSL_ECDSA_SIG *sig); WOLFSSL_API void wolfSSL_ECDSA_SIG_free(WOLFSSL_ECDSA_SIG *sig);
WOLFSSL_API WOLFSSL_ECDSA_SIG *wolfSSL_ECDSA_SIG_new(void); WOLFSSL_API WOLFSSL_ECDSA_SIG *wolfSSL_ECDSA_SIG_new(void);
WOLFSSL_API WOLFSSL_ECDSA_SIG *wolfSSL_ECDSA_do_sign(const unsigned char *dgst, int dgst_len, WOLFSSL_EC_KEY *eckey); WOLFSSL_API WOLFSSL_ECDSA_SIG *wolfSSL_ECDSA_do_sign(const unsigned char *dgst,
WOLFSSL_API int wolfSSL_ECDSA_do_verify(const unsigned char *dgst, int dgst_len, const WOLFSSL_ECDSA_SIG *sig, WOLFSSL_EC_KEY *eckey); int dgst_len,
WOLFSSL_EC_KEY *eckey);
WOLFSSL_API int wolfSSL_ECDSA_do_verify(const unsigned char *dgst,
int dgst_len,
const WOLFSSL_ECDSA_SIG *sig,
WOLFSSL_EC_KEY *eckey);
#define ECDSA_SIG_free wolfSSL_ECDSA_SIG_free #define ECDSA_SIG_free wolfSSL_ECDSA_SIG_free
#define ECDSA_SIG_new wolfSSL_ECDSA_SIG_new #define ECDSA_SIG_new wolfSSL_ECDSA_SIG_new
#define ECDSA_do_sign wolfSSL_ECDSA_do_sign #define ECDSA_do_sign wolfSSL_ECDSA_do_sign
#define ECDSA_do_verify wolfSSL_ECDSA_do_verify #define ECDSA_do_verify wolfSSL_ECDSA_do_verify
#ifdef __cplusplus #ifdef __cplusplus
} /* extern "C" */ } /* extern "C" */

2
wolfssl/ssl.h
View File

@ -1199,7 +1199,7 @@ WOLFSSL_API void* wolfSSL_GetRsaDecCtx(WOLFSSL* ssl);
#ifndef NO_CERTS #ifndef NO_CERTS
WOLFSSL_API void wolfSSL_CTX_SetCACb(WOLFSSL_CTX*, CallbackCACache); WOLFSSL_API void wolfSSL_CTX_SetCACb(WOLFSSL_CTX*, CallbackCACache);
WOLFSSL_API WOLFSSL_CERT_MANAGER* wolfSSL_CertManagerNew(void); WOLFSSL_API WOLFSSL_CERT_MANAGER* wolfSSL_CertManagerNew(void);
WOLFSSL_API void wolfSSL_CertManagerFree(WOLFSSL_CERT_MANAGER*); WOLFSSL_API void wolfSSL_CertManagerFree(WOLFSSL_CERT_MANAGER*);

14
wolfssl/wolfcrypt/asn.h
View File

@ -145,7 +145,7 @@ enum Misc_ASN {
KEYID_SIZE = SHA_DIGEST_SIZE, KEYID_SIZE = SHA_DIGEST_SIZE,
#endif #endif
RSA_INTS = 8, /* RSA ints in private key */ RSA_INTS = 8, /* RSA ints in private key */
DSA_INTS = 5, /* DSA ints in private key */ DSA_INTS = 5, /* DSA ints in private key */
MIN_DATE_SIZE = 13, MIN_DATE_SIZE = 13,
MAX_DATE_SIZE = 32, MAX_DATE_SIZE = 32,
ASN_GEN_TIME_SZ = 15, /* 7 numbers * 2 + Zulu tag */ ASN_GEN_TIME_SZ = 15, /* 7 numbers * 2 + Zulu tag */
@ -521,7 +521,7 @@ WOLFSSL_TEST_API void InitDecodedCert(DecodedCert*, byte*, word32, void*);
WOLFSSL_TEST_API void FreeDecodedCert(DecodedCert*); WOLFSSL_TEST_API void FreeDecodedCert(DecodedCert*);
WOLFSSL_TEST_API int ParseCert(DecodedCert*, int type, int verify, void* cm); WOLFSSL_TEST_API int ParseCert(DecodedCert*, int type, int verify, void* cm);
WOLFSSL_LOCAL int ParseCertRelative(DecodedCert*, int type, int verify,void* cm); WOLFSSL_LOCAL int ParseCertRelative(DecodedCert*,int type,int verify,void* cm);
WOLFSSL_LOCAL int DecodeToKey(DecodedCert*, int verify); WOLFSSL_LOCAL int DecodeToKey(DecodedCert*, int verify);
WOLFSSL_LOCAL Signer* MakeSigner(void*); WOLFSSL_LOCAL Signer* MakeSigner(void*);
@ -530,7 +530,7 @@ WOLFSSL_LOCAL void FreeSignerTable(Signer**, int, void*);
WOLFSSL_LOCAL int ToTraditional(byte* buffer, word32 length); WOLFSSL_LOCAL int ToTraditional(byte* buffer, word32 length);
WOLFSSL_LOCAL int ToTraditionalEnc(byte* buffer, word32 length,const char*, int); WOLFSSL_LOCAL int ToTraditionalEnc(byte* buffer, word32 length,const char*,int);
WOLFSSL_LOCAL int ValidateDate(const byte* date, byte format, int dateType); WOLFSSL_LOCAL int ValidateDate(const byte* date, byte format, int dateType);
@ -550,10 +550,10 @@ WOLFSSL_LOCAL int GetAlgoId(const byte* input, word32* inOutIdx, word32* oid,
WOLFSSL_LOCAL word32 SetLength(word32 length, byte* output); WOLFSSL_LOCAL word32 SetLength(word32 length, byte* output);
WOLFSSL_LOCAL word32 SetSequence(word32 len, byte* output); WOLFSSL_LOCAL word32 SetSequence(word32 len, byte* output);
WOLFSSL_LOCAL word32 SetOctetString(word32 len, byte* output); WOLFSSL_LOCAL word32 SetOctetString(word32 len, byte* output);
WOLFSSL_LOCAL word32 SetImplicit(byte tag, byte number, word32 len,byte* output); WOLFSSL_LOCAL word32 SetImplicit(byte tag,byte number,word32 len,byte* output);
WOLFSSL_LOCAL word32 SetExplicit(byte number, word32 len, byte* output); WOLFSSL_LOCAL word32 SetExplicit(byte number, word32 len, byte* output);
WOLFSSL_LOCAL word32 SetSet(word32 len, byte* output); WOLFSSL_LOCAL word32 SetSet(word32 len, byte* output);
WOLFSSL_LOCAL word32 SetAlgoID(int algoOID, byte* output, int type, int curveSz); WOLFSSL_LOCAL word32 SetAlgoID(int algoOID,byte* output,int type,int curveSz);
WOLFSSL_LOCAL int SetMyVersion(word32 version, byte* output, int header); WOLFSSL_LOCAL int SetMyVersion(word32 version, byte* output, int header);
WOLFSSL_LOCAL int SetSerialNumber(const byte* sn, word32 snSz, byte* output); WOLFSSL_LOCAL int SetSerialNumber(const byte* sn, word32 snSz, byte* output);
WOLFSSL_LOCAL int GetNameHash(const byte* source, word32* idx, byte* hash, WOLFSSL_LOCAL int GetNameHash(const byte* source, word32* idx, byte* hash,
@ -582,7 +582,7 @@ enum cert_enums {
#ifndef NO_FILESYSTEM #ifndef NO_FILESYSTEM
/* forward from wolfSSL */ /* forward from wolfSSL */
WOLFSSL_API WOLFSSL_API
int wolfSSL_PemCertToDer(const char* fileName, unsigned char* derBuf, int derSz); int wolfSSL_PemCertToDer(const char* fileName,unsigned char* derBuf,int derSz);
#define WOLFSSL_PEMCERT_TODER_DEFINED #define WOLFSSL_PEMCERT_TODER_DEFINED
#endif #endif
#endif #endif
@ -645,7 +645,7 @@ struct OcspResponse {
word32 responseSz; /* length of the OCSP Response */ word32 responseSz; /* length of the OCSP Response */
byte producedDate[MAX_DATE_SIZE]; byte producedDate[MAX_DATE_SIZE];
/* Date at which this response was signed */ /* Date at which this response was signed */
byte producedDateFormat; /* format of the producedDate */ byte producedDateFormat; /* format of the producedDate */
byte* issuerHash; byte* issuerHash;
byte* issuerKeyHash; byte* issuerKeyHash;

14
wolfssl/wolfcrypt/asn_public.h
View File

@ -44,9 +44,9 @@ enum CertType {
CA_TYPE, CA_TYPE,
ECC_PRIVATEKEY_TYPE, ECC_PRIVATEKEY_TYPE,
CERTREQ_TYPE, CERTREQ_TYPE,
DSA_TYPE, DSA_TYPE,
ECC_TYPE, ECC_TYPE,
RSA_TYPE RSA_TYPE
}; };
@ -150,8 +150,8 @@ WOLFSSL_API void wc_InitCert(Cert*);
WOLFSSL_API int wc_MakeCert(Cert*, byte* derBuffer, word32 derSz, RsaKey*, WOLFSSL_API int wc_MakeCert(Cert*, byte* derBuffer, word32 derSz, RsaKey*,
ecc_key*, RNG*); ecc_key*, RNG*);
#ifdef WOLFSSL_CERT_REQ #ifdef WOLFSSL_CERT_REQ
WOLFSSL_API int wc_MakeCertReq(Cert*, byte* derBuffer, word32 derSz, RsaKey*, WOLFSSL_API int wc_MakeCertReq(Cert*, byte* derBuffer, word32 derSz,
ecc_key*); RsaKey*, ecc_key*);
#endif #endif
WOLFSSL_API int wc_SignCert(int requestSz, int sigType, byte* derBuffer, WOLFSSL_API int wc_SignCert(int requestSz, int sigType, byte* derBuffer,
word32 derSz, RsaKey*, ecc_key*, RNG*); word32 derSz, RsaKey*, ecc_key*, RNG*);
@ -188,8 +188,8 @@ WOLFSSL_API int wc_SetDatesBuffer(Cert*, const byte*, int);
#endif #endif
/* DER encode signature */ /* DER encode signature */
WOLFSSL_API word32 wc_EncodeSignature(byte* out, const byte* digest, word32 digSz, WOLFSSL_API word32 wc_EncodeSignature(byte* out, const byte* digest,
int hashOID); word32 digSz, int hashOID);
WOLFSSL_API int wc_GetCTC_HashOID(int type); WOLFSSL_API int wc_GetCTC_HashOID(int type);
#ifdef __cplusplus #ifdef __cplusplus

19
wolfssl/wolfcrypt/dsa.h
View File

@ -54,19 +54,16 @@ typedef struct DsaKey {
int type; /* public or private */ int type; /* public or private */
} DsaKey; } DsaKey;
WOLFSSL_API void wc_InitDsaKey(DsaKey* key); WOLFSSL_API void wc_InitDsaKey(DsaKey* key);
WOLFSSL_API void wc_FreeDsaKey(DsaKey* key); WOLFSSL_API void wc_FreeDsaKey(DsaKey* key);
WOLFSSL_API int wc_DsaSign(const byte* digest, byte* out,
WOLFSSL_API int wc_DsaSign(const byte* digest, byte* out, DsaKey* key, RNG* rng); DsaKey* key, RNG* rng);
WOLFSSL_API int wc_DsaVerify(const byte* digest, const byte* sig, DsaKey* key, WOLFSSL_API int wc_DsaVerify(const byte* digest, const byte* sig,
int* answer); DsaKey* key, int* answer);
WOLFSSL_API int wc_DsaPublicKeyDecode(const byte* input, word32* inOutIdx,
WOLFSSL_API int wc_DsaPublicKeyDecode(const byte* input, word32* inOutIdx, DsaKey*, DsaKey*, word32);
word32); WOLFSSL_API int wc_DsaPrivateKeyDecode(const byte* input, word32* inOutIdx,
WOLFSSL_API int wc_DsaPrivateKeyDecode(const byte* input, word32* inOutIdx, DsaKey*, DsaKey*, word32);
word32);
WOLFSSL_API int wc_DsaKeyToDer(DsaKey* key, byte* output, word32 inLen); WOLFSSL_API int wc_DsaKeyToDer(DsaKey* key, byte* output, word32 inLen);
#ifdef __cplusplus #ifdef __cplusplus

20
wolfssl/wolfcrypt/ecc.h
View File

@ -47,7 +47,7 @@ enum {
/* ECC set type defined a NIST GF(p) curve */ /* ECC set type defined a NIST GF(p) curve */
typedef struct { typedef struct {
int size; /* The size of the curve in octets */ int size; /* The size of the curve in octets */
int nid; /* id of this curve */ int nid; /* id of this curve */
const char* name; /* name of this curve */ const char* name; /* name of this curve */
const char* prime; /* prime that defines the field, curve is in (hex) */ const char* prime; /* prime that defines the field, curve is in (hex) */
const char* Af; /* fields A param (hex) */ const char* Af; /* fields A param (hex) */
@ -141,19 +141,20 @@ WOLFSSL_API
int wc_ecc_shared_secret(ecc_key* private_key, ecc_key* public_key, byte* out, int wc_ecc_shared_secret(ecc_key* private_key, ecc_key* public_key, byte* out,
word32* outlen); word32* outlen);
WOLFSSL_API WOLFSSL_API
int wc_ecc_shared_secret_ssh(ecc_key* private_key, ecc_point* point, byte* out, word32 *outlen); int wc_ecc_shared_secret_ssh(ecc_key* private_key, ecc_point* point,
byte* out, word32 *outlen);
WOLFSSL_API WOLFSSL_API
int wc_ecc_sign_hash(const byte* in, word32 inlen, byte* out, word32 *outlen, int wc_ecc_sign_hash(const byte* in, word32 inlen, byte* out, word32 *outlen,
RNG* rng, ecc_key* key); RNG* rng, ecc_key* key);
WOLFSSL_API WOLFSSL_API
int wc_ecc_sign_hash_ex(const byte* in, word32 inlen, RNG* rng, int wc_ecc_sign_hash_ex(const byte* in, word32 inlen, RNG* rng,
ecc_key* key, mp_int *r, mp_int *s); ecc_key* key, mp_int *r, mp_int *s);
WOLFSSL_API WOLFSSL_API
int wc_ecc_verify_hash(const byte* sig, word32 siglen, const byte* hash, int wc_ecc_verify_hash(const byte* sig, word32 siglen, const byte* hash,
word32 hashlen, int* stat, ecc_key* key); word32 hashlen, int* stat, ecc_key* key);
WOLFSSL_API WOLFSSL_API
int wc_ecc_verify_hash_ex(mp_int *r, mp_int *s, const byte* hash, int wc_ecc_verify_hash_ex(mp_int *r, mp_int *s, const byte* hash,
word32 hashlen, int* stat, ecc_key* key); word32 hashlen, int* stat, ecc_key* key);
WOLFSSL_API WOLFSSL_API
int wc_ecc_init(ecc_key* key); int wc_ecc_init(ecc_key* key);
WOLFSSL_API WOLFSSL_API
@ -195,8 +196,11 @@ WOLFSSL_API
int wc_ecc_export_private_only(ecc_key* key, byte* out, word32* outLen); int wc_ecc_export_private_only(ecc_key* key, byte* out, word32* outLen);
WOLFSSL_API WOLFSSL_API
int wc_ecc_export_point_der(const int curve_idx, ecc_point* point, byte* out, word32* outLen); int wc_ecc_export_point_der(const int curve_idx, ecc_point* point,
int wc_ecc_import_point_der(byte* in, word32 inLen, const int curve_idx, ecc_point* point); byte* out, word32* outLen);
WOLFSSL_API
int wc_ecc_import_point_der(byte* in, word32 inLen, const int curve_idx,
ecc_point* point);
/* size helper */ /* size helper */
WOLFSSL_API WOLFSSL_API
@ -244,7 +248,7 @@ ecEncCtx* wc_ecc_ctx_new(int flags, RNG* rng);
WOLFSSL_API WOLFSSL_API
void wc_ecc_ctx_free(ecEncCtx*); void wc_ecc_ctx_free(ecEncCtx*);
WOLFSSL_API WOLFSSL_API
int wc_ecc_ctx_reset(ecEncCtx*, RNG*); /* reset for use again w/o alloc/free */ int wc_ecc_ctx_reset(ecEncCtx*, RNG*); /* reset for use again w/o alloc/free */
WOLFSSL_API WOLFSSL_API
const byte* wc_ecc_ctx_get_own_salt(ecEncCtx*); const byte* wc_ecc_ctx_get_own_salt(ecEncCtx*);