mirror of
https://github.com/libtom/libtomcrypt
synced 2026-08-25 20:26:07 -04:00
2463 lines
136 KiB
C
2463 lines
136 KiB
C
/* LibTomCrypt, modular cryptographic library -- Tom St Denis */
|
|
/* SPDX-License-Identifier: Unlicense */
|
|
#include <tomcrypt_test.h>
|
|
|
|
#if defined(LTC_MECC)
|
|
|
|
const unsigned char ltc_ecc_long_pri_test_key[] = { /* private + long public, explicit curve params */
|
|
0x30, 0x82, 0x01, 0x13, 0x02, 0x01, 0x01, 0x04, 0x20, 0x0c, 0xf1, 0xad, 0x2f, 0x03, 0xf7, 0x91,
|
|
0x1b, 0xba, 0x03, 0xcf, 0x23, 0x37, 0xc8, 0xf2, 0xf7, 0x36, 0xce, 0x65, 0xf1, 0x84, 0x2d, 0x7d,
|
|
0x9f, 0x5f, 0x9e, 0x21, 0xd9, 0x5e, 0x49, 0xbd, 0x23, 0xa0, 0x81, 0xa5, 0x30, 0x81, 0xa2, 0x02,
|
|
0x01, 0x01, 0x30, 0x2c, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x01, 0x01, 0x02, 0x21, 0x00,
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x2f,
|
|
0x30, 0x06, 0x04, 0x01, 0x00, 0x04, 0x01, 0x07, 0x04, 0x41, 0x04, 0x79, 0xbe, 0x66, 0x7e, 0xf9,
|
|
0xdc, 0xbb, 0xac, 0x55, 0xa0, 0x62, 0x95, 0xce, 0x87, 0x0b, 0x07, 0x02, 0x9b, 0xfc, 0xdb, 0x2d,
|
|
0xce, 0x28, 0xd9, 0x59, 0xf2, 0x81, 0x5b, 0x16, 0xf8, 0x17, 0x98, 0x48, 0x3a, 0xda, 0x77, 0x26,
|
|
0xa3, 0xc4, 0x65, 0x5d, 0xa4, 0xfb, 0xfc, 0x0e, 0x11, 0x08, 0xa8, 0xfd, 0x17, 0xb4, 0x48, 0xa6,
|
|
0x85, 0x54, 0x19, 0x9c, 0x47, 0xd0, 0x8f, 0xfb, 0x10, 0xd4, 0xb8, 0x02, 0x21, 0x00, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xba, 0xae,
|
|
0xdc, 0xe6, 0xaf, 0x48, 0xa0, 0x3b, 0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41, 0x41, 0x02, 0x01,
|
|
0x01, 0xa1, 0x44, 0x03, 0x42, 0x00, 0x04, 0x2a, 0xf9, 0x0b, 0xda, 0xbe, 0x71, 0x66, 0x9e, 0xd1,
|
|
0xcf, 0x12, 0xd0, 0x24, 0xaf, 0xba, 0xb6, 0x7f, 0xfb, 0x96, 0x27, 0x3e, 0x2f, 0xbd, 0x1e, 0xd5,
|
|
0xf9, 0x8d, 0x6c, 0x73, 0x9d, 0xc5, 0x16, 0x91, 0xbd, 0xb2, 0xb9, 0x1b, 0x40, 0x10, 0x5a, 0xb7,
|
|
0x6c, 0x6e, 0x32, 0x5b, 0xf7, 0x63, 0x62, 0x94, 0x24, 0x24, 0xdb, 0xec, 0x3f, 0x8b, 0xe5, 0x6e,
|
|
0x4b, 0x64, 0x37, 0x31, 0x24, 0x79, 0x4d
|
|
};
|
|
const unsigned long ltc_ecc_long_pri_test_key_sz = sizeof(ltc_ecc_long_pri_test_key);
|
|
|
|
static unsigned int sizes[] = {
|
|
#ifdef LTC_ECC_SECP112R1
|
|
14,
|
|
#endif
|
|
#ifdef LTC_ECC_SECP128R1
|
|
16,
|
|
#endif
|
|
#ifdef LTC_ECC_SECP160R1
|
|
20,
|
|
#endif
|
|
#ifdef LTC_ECC_SECP192R1
|
|
24,
|
|
#endif
|
|
#ifdef LTC_ECC_SECP224R1
|
|
28,
|
|
#endif
|
|
#ifdef LTC_ECC_SECP256R1
|
|
32,
|
|
#endif
|
|
#ifdef LTC_ECC_SECP384R1
|
|
48,
|
|
#endif
|
|
#ifdef LTC_ECC_SECP512R1
|
|
66
|
|
#endif
|
|
};
|
|
|
|
static const char* curvenames[] = {
|
|
#ifdef LTC_ECC_SECP112R1
|
|
"SECP112R1", "ECC-112",
|
|
"secp112r1", /* name is case-insensitive */
|
|
"S E C-P-1_1_2r1", /* should pass fuzzy matching */
|
|
#endif
|
|
#ifdef LTC_ECC_SECP112R2
|
|
"SECP112R2",
|
|
#endif
|
|
#ifdef LTC_ECC_SECP128R1
|
|
"SECP128R1", "ECC-128",
|
|
#endif
|
|
#ifdef LTC_ECC_SECP128R2
|
|
"SECP128R2",
|
|
#endif
|
|
#ifdef LTC_ECC_SECP160R1
|
|
"SECP160R1", "ECC-160",
|
|
#endif
|
|
#ifdef LTC_ECC_SECP160R2
|
|
"SECP160R2",
|
|
#endif
|
|
#ifdef LTC_ECC_SECP160K1
|
|
"SECP160K1",
|
|
#endif
|
|
#ifdef LTC_ECC_BRAINPOOLP160R1
|
|
"BRAINPOOLP160R1",
|
|
#endif
|
|
#ifdef LTC_ECC_SECP192R1
|
|
"SECP192R1", "NISTP192", "PRIME192V1", "ECC-192", "P-192",
|
|
#endif
|
|
#ifdef LTC_ECC_PRIME192V2
|
|
"PRIME192V2",
|
|
#endif
|
|
#ifdef LTC_ECC_PRIME192V3
|
|
"PRIME192V3",
|
|
#endif
|
|
#ifdef LTC_ECC_SECP192K1
|
|
"SECP192K1",
|
|
#endif
|
|
#ifdef LTC_ECC_BRAINPOOLP192R1
|
|
"BRAINPOOLP192R1",
|
|
#endif
|
|
#ifdef LTC_ECC_SECP224R1
|
|
"SECP224R1", "NISTP224", "ECC-224", "P-224",
|
|
#endif
|
|
#ifdef LTC_ECC_SECP224K1
|
|
"SECP224K1",
|
|
#endif
|
|
#ifdef LTC_ECC_BRAINPOOLP224R1
|
|
"BRAINPOOLP224R1",
|
|
#endif
|
|
#ifdef LTC_ECC_PRIME239V1
|
|
"PRIME239V1",
|
|
#endif
|
|
#ifdef LTC_ECC_PRIME239V2
|
|
"PRIME239V2",
|
|
#endif
|
|
#ifdef LTC_ECC_PRIME239V3
|
|
"PRIME239V3",
|
|
#endif
|
|
#ifdef LTC_ECC_SECP256R1
|
|
"SECP256R1", "NISTP256", "PRIME256V1", "ECC-256", "P-256",
|
|
#endif
|
|
#ifdef LTC_ECC_SECP256K1
|
|
"SECP256K1",
|
|
#endif
|
|
#ifdef LTC_ECC_BRAINPOOLP256R1
|
|
"BRAINPOOLP256R1",
|
|
#endif
|
|
#ifdef LTC_ECC_BRAINPOOLP320R1
|
|
"BRAINPOOLP320R1",
|
|
#endif
|
|
#ifdef LTC_ECC_SECP384R1
|
|
"SECP384R1", "NISTP384", "ECC-384", "P-384",
|
|
#endif
|
|
#ifdef LTC_ECC_BRAINPOOLP384R1
|
|
"BRAINPOOLP384R1",
|
|
#endif
|
|
#ifdef LTC_ECC_BRAINPOOLP512R1
|
|
"BRAINPOOLP512R1",
|
|
#endif
|
|
#ifdef LTC_ECC_SECP521R1
|
|
"SECP521R1", "NISTP521", "ECC-521", "P-521",
|
|
#endif
|
|
};
|
|
|
|
|
|
#ifdef LTC_ECC_SHAMIR
|
|
static int s_ecc_test_shamir(void)
|
|
{
|
|
void *a, *modulus, *mp, *kA, *kB, *rA, *rB;
|
|
void *mu, *ma;
|
|
ecc_point *G, *A, *B, *C1, *C2;
|
|
int x, y, z;
|
|
unsigned char buf[ECC_BUF_SIZE];
|
|
|
|
DO(ltc_mp_init_multi(&kA, &kB, &rA, &rB, &modulus, &a, &mu, &ma, LTC_NULL));
|
|
LTC_ARGCHK((G = ltc_ecc_new_point()) != NULL);
|
|
LTC_ARGCHK((A = ltc_ecc_new_point()) != NULL);
|
|
LTC_ARGCHK((B = ltc_ecc_new_point()) != NULL);
|
|
LTC_ARGCHK((C1 = ltc_ecc_new_point()) != NULL);
|
|
LTC_ARGCHK((C2 = ltc_ecc_new_point()) != NULL);
|
|
|
|
for (x = 0; x < (int)LTC_ARRAY_SIZE(sizes); x++) {
|
|
/* get the base point */
|
|
for (z = 0; ltc_ecc_curves[z].prime != NULL; z++) {
|
|
DO(ltc_mp_read_radix(modulus, ltc_ecc_curves[z].prime, 16));
|
|
if (sizes[x] <= ltc_mp_unsigned_bin_size(modulus)) break;
|
|
}
|
|
LTC_ARGCHK(ltc_ecc_curves[z].prime != NULL);
|
|
|
|
/* load it */
|
|
DO(ltc_mp_read_radix(G->x, ltc_ecc_curves[z].Gx, 16));
|
|
DO(ltc_mp_read_radix(G->y, ltc_ecc_curves[z].Gy, 16));
|
|
DO(ltc_mp_set(G->z, 1));
|
|
DO(ltc_mp_read_radix(a, ltc_ecc_curves[z].A, 16));
|
|
DO(ltc_mp_montgomery_setup(modulus, &mp));
|
|
DO(ltc_mp_montgomery_normalization(mu, modulus));
|
|
DO(ltc_mp_mulmod(a, mu, modulus, ma));
|
|
|
|
/* do 100 random tests */
|
|
for (y = 0; y < 100; y++) {
|
|
/* pick a random r1, r2 */
|
|
ENSURE(yarrow_read(buf, sizes[x], &yarrow_prng) == sizes[x]);
|
|
DO(ltc_mp_read_unsigned_bin(rA, buf, sizes[x]));
|
|
ENSURE(yarrow_read(buf, sizes[x], &yarrow_prng) == sizes[x]);
|
|
DO(ltc_mp_read_unsigned_bin(rB, buf, sizes[x]));
|
|
|
|
/* compute rA * G = A */
|
|
DO(ltc_mp.ecc_ptmul(rA, G, A, a, modulus, 1));
|
|
|
|
/* compute rB * G = B */
|
|
DO(ltc_mp.ecc_ptmul(rB, G, B, a, modulus, 1));
|
|
|
|
/* pick a random kA, kB */
|
|
ENSURE(yarrow_read(buf, sizes[x], &yarrow_prng) == sizes[x]);
|
|
DO(ltc_mp_read_unsigned_bin(kA, buf, sizes[x]));
|
|
ENSURE(yarrow_read(buf, sizes[x], &yarrow_prng) == sizes[x]);
|
|
DO(ltc_mp_read_unsigned_bin(kB, buf, sizes[x]));
|
|
|
|
/* now, compute kA*A + kB*B = C1 using the older method */
|
|
DO(ltc_mp.ecc_ptmul(kA, A, C1, a, modulus, 0));
|
|
DO(ltc_mp.ecc_ptmul(kB, B, C2, a, modulus, 0));
|
|
DO(ltc_mp.ecc_ptadd(C1, C2, C1, a, modulus, mp));
|
|
DO(ltc_mp.ecc_map(C1, modulus, mp));
|
|
|
|
/* now compute using mul2add */
|
|
DO(ltc_mp.ecc_mul2add(A, kA, B, kB, C2, ma, modulus));
|
|
|
|
/* is they the sames? */
|
|
if ((ltc_mp_cmp(C1->x, C2->x) != LTC_MP_EQ) || (ltc_mp_cmp(C1->y, C2->y) != LTC_MP_EQ) || (ltc_mp_cmp(C1->z, C2->z) != LTC_MP_EQ)) {
|
|
fprintf(stderr, "ECC failed shamir test: size=%d, testno=%d\n", sizes[x], y);
|
|
return 1;
|
|
}
|
|
}
|
|
ltc_mp_montgomery_free(mp);
|
|
}
|
|
ltc_ecc_del_point(C2);
|
|
ltc_ecc_del_point(C1);
|
|
ltc_ecc_del_point(B);
|
|
ltc_ecc_del_point(A);
|
|
ltc_ecc_del_point(G);
|
|
ltc_mp_deinit_multi(kA, kB, rA, rB, modulus, a, mu, ma, LTC_NULL);
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
/* https://github.com/libtom/libtomcrypt/issues/630 */
|
|
static int s_ecc_issue630(void)
|
|
{
|
|
unsigned char protected_buffer[30], protected_buffer_copy[30];
|
|
unsigned long keylen = 0;
|
|
ecc_key key;
|
|
int low, high;
|
|
|
|
ecc_sizes(&low, &high);
|
|
|
|
DO(ecc_make_key (&yarrow_prng, find_prng ("yarrow"), high, &key));
|
|
if (yarrow_read(protected_buffer, sizeof(protected_buffer), &yarrow_prng) != sizeof(protected_buffer)) {
|
|
return CRYPT_ERROR_READPRNG;
|
|
}
|
|
XMEMCPY(protected_buffer_copy, protected_buffer, sizeof(protected_buffer));
|
|
COMPARE_TESTVECTOR(protected_buffer, sizeof(protected_buffer), protected_buffer_copy, sizeof(protected_buffer), "Ensure copy is equal", 0);
|
|
|
|
keylen = 10;
|
|
SHOULD_FAIL(ecc_get_key(&protected_buffer[10], &keylen, PK_PRIVATE, &key));
|
|
COMPARE_TESTVECTOR(protected_buffer, 10, protected_buffer_copy, 10, "Start canary", 1);
|
|
COMPARE_TESTVECTOR(&protected_buffer[20], 10, &protected_buffer[20], 10, "End canary", 2);
|
|
ecc_free(&key);
|
|
return 0;
|
|
}
|
|
|
|
/* https://github.com/libtom/libtomcrypt/issues/116
|
|
verifies that ECDSA verification succeeds for an all-zero hash when the non-Shamir fallback is used
|
|
i.e. when u1 == 0 and the code path computes 0 * G + u2 * Q via two separate point multiplications
|
|
*/
|
|
static int s_ecc_issue116(void)
|
|
{
|
|
const ltc_ecc_curve *dp;
|
|
ecc_key key;
|
|
int err, stat;
|
|
unsigned long siglen;
|
|
unsigned char hash[20];
|
|
unsigned char sig[128];
|
|
ltc_ecc_sig_opts sig_opts = { .type = LTC_ECCSIG_RFC7518, .prng = &yarrow_prng, .wprng = find_prng("yarrow") };
|
|
int (*saved_mul2add)(const ecc_point *A, void *kA, const ecc_point *B, void *kB, ecc_point *C, const void *ma, const void *modulus);
|
|
|
|
XMEMSET(hash, 0, sizeof(hash));
|
|
|
|
DO(ecc_find_curve("SECP256R1", &dp));
|
|
DO(ecc_make_key_ex(&yarrow_prng, find_prng("yarrow"), &key, dp));
|
|
|
|
siglen = sizeof(sig);
|
|
DO(ecc_sign_hash_v2(hash, sizeof(hash), sig, &siglen, &sig_opts, &key));
|
|
|
|
saved_mul2add = ltc_mp.ecc_mul2add;
|
|
ltc_mp.ecc_mul2add = NULL;
|
|
stat = 0;
|
|
err = ecc_verify_hash_v2(sig, siglen, hash, sizeof(hash), &(ltc_ecc_sig_opts){ .type = LTC_ECCSIG_RFC7518 }, &stat, &key);
|
|
ltc_mp.ecc_mul2add = saved_mul2add;
|
|
ecc_free(&key);
|
|
|
|
if (err != CRYPT_OK) return err;
|
|
if (stat != 1) return CRYPT_FAIL_TESTVECTOR;
|
|
return CRYPT_OK;
|
|
}
|
|
|
|
/* Wycheproof ecdh_secp256r1_test.json tcId=202 */
|
|
static int s_ecc_wycheproof_p256_edgecase_dbl(void)
|
|
{
|
|
const char *priv_hex = "809c461d8b39163537ff8f5ef5b977e4cdb980e70e38a7ee0b37cc876729e9ff";
|
|
const char *pub_hex = "04dbfa466f12013255f9d57a6496c158ee7dd202a1ce4a5a53005b3564d509a0bbf2578007e857bdd082751ef2f3b4b9c38a0b87bab413d55ccb26a574f2b4be9d";
|
|
const char *exp_hex = "e2d57eeec983756c9124f885a4d118ed5b8de7d2895fd91264cf291496949a12";
|
|
const ltc_ecc_curve *cu;
|
|
ecc_key priv, pub;
|
|
unsigned char sk[32], pk[65], expected[32], out[64];
|
|
unsigned long len, olen;
|
|
|
|
DO(ecc_find_curve("SECP256R1", &cu));
|
|
len = sizeof(sk); DO(base16_decode(priv_hex, XSTRLEN(priv_hex), sk, &len));
|
|
len = sizeof(pk); DO(base16_decode(pub_hex, XSTRLEN(pub_hex), pk, &len));
|
|
len = sizeof(expected); DO(base16_decode(exp_hex, XSTRLEN(exp_hex), expected, &len));
|
|
|
|
DO(ecc_set_curve(cu, &priv));
|
|
DO(ecc_set_key(sk, sizeof(sk), PK_PRIVATE, &priv));
|
|
DO(ecc_set_curve(cu, &pub));
|
|
DO(ecc_set_key(pk, sizeof(pk), PK_PUBLIC, &pub));
|
|
|
|
olen = sizeof(out);
|
|
DO(ecc_shared_secret(&priv, &pub, out, &olen));
|
|
COMPARE_TESTVECTOR(out, olen, expected, sizeof(expected), "Wycheproof ecdh_secp256r1 EdgeCaseDoubling", 202);
|
|
ecc_free(&priv);
|
|
ecc_free(&pub);
|
|
return CRYPT_OK;
|
|
}
|
|
|
|
#if defined(LTC_PEM) && defined(LTC_DER)
|
|
/* Wycheproof ecdh_secp256r1_pem_test.json tcId=202 */
|
|
static int s_ecc_wycheproof_p256_pem_edgecase_dbl(void)
|
|
{
|
|
static const char priv_pem[] =
|
|
"-----BEGIN PRIVATE KEY-----\n"
|
|
"MEECAQAwEwYHKoZIzj0CAQYIKoZIzj0DAQcEJzAlAgEBBCCAnEYdizkWNTf/j171\n"
|
|
"uXfkzbmA5w44p+4LN8yHZynp/w==\n"
|
|
"-----END PRIVATE KEY-----\n";
|
|
static const char pub_pem[] =
|
|
"-----BEGIN PUBLIC KEY-----\n"
|
|
"MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2/pGbxIBMlX51XpklsFY7n3SAqHO\n"
|
|
"SlpTAFs1ZNUJoLvyV4AH6Fe90IJ1HvLztLnDiguHurQT1VzLJqV08rS+nQ==\n"
|
|
"-----END PUBLIC KEY-----\n";
|
|
const char *exp_hex = "e2d57eeec983756c9124f885a4d118ed5b8de7d2895fd91264cf291496949a12";
|
|
ltc_pka_key priv = {0}, pub = {0};
|
|
unsigned char expected[32], out[64];
|
|
unsigned long len, olen;
|
|
|
|
DO(pem_decode(priv_pem, sizeof(priv_pem) - 1, &priv, NULL));
|
|
ENSURE(priv.id == LTC_PKA_EC);
|
|
DO(pem_decode(pub_pem, sizeof(pub_pem) - 1, &pub, NULL));
|
|
ENSURE(pub.id == LTC_PKA_EC);
|
|
|
|
len = sizeof(expected);
|
|
DO(base16_decode(exp_hex, XSTRLEN(exp_hex), expected, &len));
|
|
|
|
olen = sizeof(out);
|
|
DO(ecc_shared_secret(&priv.u.ecc, &pub.u.ecc, out, &olen));
|
|
COMPARE_TESTVECTOR(out, olen, expected, sizeof(expected), "Wycheproof ecdh_secp256r1_pem EdgeCaseDoubling", 202);
|
|
|
|
pka_key_free(&priv);
|
|
pka_key_free(&pub);
|
|
return CRYPT_OK;
|
|
}
|
|
|
|
/* Wycheproof ecdh_secp256r1_pem_test.json tcId=352 (WrongOrder), tcId=359 (NoCofactor) and tcId=363 (ModifiedPrime) */
|
|
static int s_ecc_wycheproof_p256_pem_invalid_explicit(void)
|
|
{
|
|
static const char priv_pem[] =
|
|
"-----BEGIN PRIVATE KEY-----\n"
|
|
"MEECAQAwEwYHKoZIzj0CAQYIKoZIzj0DAQcEJzAlAgEBBCBPNBTRWJtJ9xctQ5y7\n"
|
|
"545bU1Dchd6kDNLWJ0dAxuAjnA==\n"
|
|
"-----END PRIVATE KEY-----\n";
|
|
/* tcId=352 WrongOrder (order = -secp256r1.order) */
|
|
static const char pub_pem[] =
|
|
"-----BEGIN PUBLIC KEY-----\n"
|
|
"MIIBMzCB7AYHKoZIzj0CATCB4AIBATAsBgcqhkjOPQEBAiEA/////wAAAAEAAAAA\n"
|
|
"AAAAAAAAAAD///////////////8wRAQg/////wAAAAEAAAAAAAAAAAAAAAD/////\n"
|
|
"//////////wEIFrGNdiqOpPns+u9VXaYhrxlHQawzFOw9jvOPD4n0mBLBEEEaxfR\n"
|
|
"8uEsQkf4vOblY6RA8ncDfYEt6zOg9KE5RdiYwpZP40Li/hp/m47n60p8D54WK84z\n"
|
|
"V2sxXs7LtkBoN79R9QIh/wAAAAD/////AAAAAAAAAABDGQVSWOhhewxGNT0DnNqv\n"
|
|
"AgEBA0IABBUQJkwYnD1SP/mRar1wae+mlo2Nx922RX14abU+pgzc+vt+1HhtoV0p\n"
|
|
"7lklb1Nto1daSIjBuwqVslb0p+n9dko=\n"
|
|
"-----END PUBLIC KEY-----\n";
|
|
const char *bad_secret_hex = "d003f5cc83852584061f7a8a28bcb5671ecbda096e16e7accfa8f8d311a3db7a";
|
|
ltc_pka_key priv = {0}, pub = {0};
|
|
unsigned char bad_secret[32], out[64];
|
|
unsigned long len, olen;
|
|
int err;
|
|
|
|
len = sizeof(bad_secret);
|
|
DO(base16_decode(bad_secret_hex, XSTRLEN(bad_secret_hex), bad_secret, &len));
|
|
|
|
/* private import must succeed (it's well-formed) */
|
|
DO(pem_decode(priv_pem, sizeof(priv_pem) - 1, &priv, NULL));
|
|
ENSURE(priv.id == LTC_PKA_EC);
|
|
|
|
/* acceptable: pem_decode rejects the explicit-parameter SPKI */
|
|
err = pem_decode(pub_pem, sizeof(pub_pem) - 1, &pub, NULL);
|
|
if (err != CRYPT_OK) {
|
|
pka_key_free(&priv);
|
|
return CRYPT_OK;
|
|
}
|
|
ENSURE(pub.id == LTC_PKA_EC);
|
|
|
|
/* if import did succeed, ecc_shared_secret must either fail outright or produce a value that is *not* the documented bad secret */
|
|
olen = sizeof(out);
|
|
err = ecc_shared_secret(&priv.u.ecc, &pub.u.ecc, out, &olen);
|
|
if (err == CRYPT_OK && olen == sizeof(bad_secret) && XMEMCMP(out, bad_secret, sizeof(bad_secret)) == 0) {
|
|
fprintf(stderr, "Wycheproof ecdh_secp256r1_pem invalid tcId=352\n");
|
|
pka_key_free(&priv);
|
|
pka_key_free(&pub);
|
|
return CRYPT_FAIL_TESTVECTOR;
|
|
}
|
|
|
|
pka_key_free(&priv);
|
|
pka_key_free(&pub);
|
|
return CRYPT_OK;
|
|
}
|
|
#endif /* LTC_PEM && LTC_DER */
|
|
|
|
#if defined(LTC_DER) && defined(LTC_ECC_BRAINPOOLP224R1) && defined(LTC_ECC_BRAINPOOLP224T1)
|
|
/* Wycheproof ecdh_brainpoolP224r1_test.json tcId=517 (WrongCurve) */
|
|
static int s_ecc_wycheproof_bp224_wrong_curve(void)
|
|
{
|
|
const char *priv_hex = "55a6601d488398ee537d8e745a461cfb8e60eeb7cb09088698faa6e9";
|
|
const char *pub_spki_hex = "3052301406072a8648ce3d020106092b2403030208010106033a00040ad954137b533120d3344cc8b991"
|
|
"3491791ebf145bab44f200a507d3027e41442fabed87e7a30783fd1618790511098b0d004c60b5086b1a";
|
|
const ltc_ecc_curve *bp_r1;
|
|
ecc_key priv, pub;
|
|
unsigned char sk[28], spki[256], out[64];
|
|
unsigned long len, slen, olen;
|
|
int err;
|
|
|
|
DO(ecc_find_curve("BRAINPOOLP224R1", &bp_r1));
|
|
|
|
slen = sizeof(spki);
|
|
DO(base16_decode(pub_spki_hex, XSTRLEN(pub_spki_hex), spki, &slen));
|
|
|
|
/* import public key from its own SPKI; the named-curve OID binds pub to bp224t1, but the point also lies on bp224r1 per the Wycheproof vector */
|
|
DO(ecc_import_openssl(spki, slen, &pub));
|
|
|
|
/* set up the private key on bp224r1 with the listed scalar */
|
|
len = sizeof(sk);
|
|
DO(base16_decode(priv_hex, XSTRLEN(priv_hex), sk, &len));
|
|
DO(ecc_set_curve(bp_r1, &priv));
|
|
DO(ecc_set_key(sk, len, PK_PRIVATE, &priv));
|
|
|
|
olen = sizeof(out);
|
|
err = ecc_shared_secret(&priv, &pub, out, &olen);
|
|
ecc_free(&priv);
|
|
ecc_free(&pub);
|
|
|
|
if (err == CRYPT_OK) {
|
|
fprintf(stderr, "Wycheproof ecdh_brainpoolP224r1 tcId=517\n");
|
|
return CRYPT_FAIL_TESTVECTOR;
|
|
}
|
|
return CRYPT_OK;
|
|
}
|
|
#endif
|
|
|
|
/* https://github.com/libtom/libtomcrypt/issues/108 */
|
|
static int s_ecc_issue108(void)
|
|
{
|
|
void *a, *modulus, *order;
|
|
ecc_point *Q, *Result;
|
|
int err;
|
|
const ltc_ecc_curve* dp;
|
|
|
|
/* init */
|
|
if ((err = ltc_mp_init_multi(&modulus, &order, &a, LTC_NULL)) != CRYPT_OK) { return err; }
|
|
Q = ltc_ecc_new_point();
|
|
Result = ltc_ecc_new_point();
|
|
|
|
/* ECC-224 AKA SECP224R1 */
|
|
if ((err = ecc_find_curve("SECP224R1", &dp)) != CRYPT_OK) { goto done; }
|
|
/* read A */
|
|
if ((err = ltc_mp_read_radix(a, dp->A, 16)) != CRYPT_OK) { goto done; }
|
|
/* read modulus */
|
|
if ((err = ltc_mp_read_radix(modulus, dp->prime, 16)) != CRYPT_OK) { goto done; }
|
|
/* read order */
|
|
if ((err = ltc_mp_read_radix(order, dp->order, 16)) != CRYPT_OK) { goto done; }
|
|
/* read Q */
|
|
if ((err = ltc_mp_read_radix(Q->x, "EA3745501BBC6A70BBFDD8AEEDB18CF5073C6DC9AA7CBB5915170D60", 16)) != CRYPT_OK) { goto done; }
|
|
if ((err = ltc_mp_read_radix(Q->y, "6C9CB8E68AABFEC989CAC5E2326E0448B7E69C3E56039BA21A44FDAC", 16)) != CRYPT_OK) { goto done; }
|
|
ltc_mp_set(Q->z, 1);
|
|
/* calculate nQ */
|
|
if ((err = ltc_mp.ecc_ptmul(order, Q, Result, a, modulus, 1)) != CRYPT_OK) { goto done; }
|
|
|
|
done:
|
|
ltc_ecc_del_point(Result);
|
|
ltc_ecc_del_point(Q);
|
|
ltc_mp_deinit_multi(modulus, order, a, LTC_NULL);
|
|
return err;
|
|
}
|
|
|
|
/* https://github.com/libtom/libtomcrypt/issues/443 */
|
|
/* https://github.com/libtom/libtomcrypt/issues/447 */
|
|
static int s_ecc_issue443_447(void)
|
|
{
|
|
const ltc_ecc_curve* cu;
|
|
ecc_key key;
|
|
int err, stat = 0;
|
|
unsigned char hash[64];
|
|
unsigned long hashlen;
|
|
const unsigned char msg[] = { 0x54,0x65,0x73,0x74 };
|
|
/* msg+pub1+sig1 test vector is from wycheproof - ecdsa_webcrypto_test (incorrect size of signature) */
|
|
const unsigned char pub1[] = {
|
|
0x04,
|
|
0x4a,0x03,0xef,0x9f,0x92,0xeb,0x26,0x8c,0xaf,0xa6,0x01,0x07,0x24,0x89,0xa5,0x63,
|
|
0x80,0xfa,0x0d,0xc4,0x31,0x71,0xd7,0x71,0x28,0x13,0xb3,0xa1,0x9a,0x1e,0xb5,0xe5,
|
|
0x3e,0x21,0x3e,0x28,0xa6,0x08,0xce,0x9a,0x2f,0x4a,0x17,0xfd,0x83,0x0c,0x66,0x54,
|
|
0x01,0x8a,0x79,0xb3,0xe0,0x26,0x3d,0x91,0xa8,0xba,0x90,0x62,0x2d,0xf6,0xf2,0xf0
|
|
};
|
|
const unsigned char sig1[] = { 0x05, 0x01 };
|
|
/* msg+pub2+sig2 test vector is from wycheproof - ecdsa_webcrypto_test (incorrect size of signature) */
|
|
const unsigned char pub2[] = {
|
|
0x04,
|
|
0x00,0x5f,0x50,0x59,0x30,0x83,0x49,0xf9,0xeb,0xbb,0x4d,0x1c,0x55,0xc0,0xaf,0xcc,0xf6,0x21,0x62,0xec,0x1d,0xd1,
|
|
0x2e,0xf3,0xed,0x90,0x66,0x56,0x92,0x4f,0xfd,0x99,0xca,0xb9,0xf0,0x6b,0x0e,0xb2,0x18,0xcf,0xf0,0x78,0xa4,0x67,
|
|
0x7a,0x5c,0xe1,0xcc,0x07,0x65,0x2b,0xc9,0x76,0xae,0xfc,0x73,0x2c,0x28,0xf6,0x7e,0xf0,0x78,0xa4,0x34,0xe9,0x99,
|
|
0x00,0xa5,0xd1,0x4d,0xf3,0x10,0x63,0x0d,0x76,0xec,0x03,0xcb,0x6f,0x9b,0x95,0xbf,0x1a,0x22,0x43,0x81,0x05,0xc8,
|
|
0x8c,0xd9,0xfd,0x3d,0xac,0x80,0xf8,0x57,0xad,0xd3,0x82,0x71,0xd8,0xba,0x90,0x16,0x84,0xb2,0x6d,0x43,0x6d,0x4a,
|
|
0x85,0x9a,0xd4,0xcd,0xa5,0xe9,0x67,0x7b,0x73,0xca,0xb3,0xf3,0xe5,0xe4,0x1a,0x3d,0x79,0x96,0x60,0x72,0x79,0xab
|
|
};
|
|
const unsigned char sig2[] = { 0x01, 0x01 };
|
|
|
|
hashlen = sizeof(hash);
|
|
DO(hash_memory(find_hash("sha256"), msg, sizeof(msg), hash, &hashlen));
|
|
DO(ecc_find_curve("secp256r1", &cu));
|
|
DO(ecc_set_curve(cu, &key));
|
|
DO(ecc_set_key(pub1, sizeof(pub1), PK_PUBLIC, &key));
|
|
err = ecc_verify_hash_rfc7518_internal(sig1, sizeof(sig1), hash, hashlen, &stat, &key); /* should fail */
|
|
ecc_free(&key);
|
|
if (err != CRYPT_INVALID_PACKET) return CRYPT_FAIL_TESTVECTOR;
|
|
|
|
hashlen = sizeof(hash);
|
|
DO(hash_memory(find_hash("sha512"), msg, sizeof(msg), hash, &hashlen));
|
|
DO(ecc_find_curve("secp521r1", &cu));
|
|
DO(ecc_set_curve(cu, &key));
|
|
DO(ecc_set_key(pub2, sizeof(pub2), PK_PUBLIC, &key));
|
|
err = ecc_verify_hash_rfc7518_internal(sig2, sizeof(sig2), hash, hashlen, &stat, &key); /* should fail */
|
|
ecc_free(&key);
|
|
if (err != CRYPT_INVALID_PACKET) return CRYPT_FAIL_TESTVECTOR;
|
|
|
|
return CRYPT_OK;
|
|
}
|
|
|
|
/* https://github.com/libtom/libtomcrypt/issues/446 */
|
|
static int s_ecc_issue446(void)
|
|
{
|
|
const ltc_ecc_curve* cu;
|
|
ecc_key key1, key2, key3, key4;
|
|
int stat = 0;
|
|
ltc_ecc_sig_opts sig_opts = { .type = LTC_ECCSIG_ANSIX962 };
|
|
unsigned char hash[64];
|
|
unsigned long hashlen;
|
|
const unsigned char msg1[] = { 0x31,0x32,0x33,0x34,0x30,0x30 };
|
|
const unsigned char msg2[] = { 0x36,0x39,0x38,0x31,0x39 };
|
|
const unsigned char msg3[] = { 0x4d,0x73,0x67 };
|
|
const unsigned char msg4[] = { 0x54,0x65,0x73,0x74 };
|
|
const unsigned char pub1[] = {
|
|
0x04, /* secp256r1 */
|
|
0x29,0x27,0xb1,0x05,0x12,0xba,0xe3,0xed,0xdc,0xfe,0x46,0x78,0x28,0x12,0x8b,0xad,
|
|
0x29,0x03,0x26,0x99,0x19,0xf7,0x08,0x60,0x69,0xc8,0xc4,0xdf,0x6c,0x73,0x28,0x38,
|
|
0xc7,0x78,0x79,0x64,0xea,0xac,0x00,0xe5,0x92,0x1f,0xb1,0x49,0x8a,0x60,0xf4,0x60,
|
|
0x67,0x66,0xb3,0xd9,0x68,0x50,0x01,0x55,0x8d,0x1a,0x97,0x4e,0x73,0x41,0x51,0x3e
|
|
};
|
|
const unsigned char pub2[] = {
|
|
0x04, /* secp224r1 */
|
|
0x53,0x88,0x35,0x38,0xd8,0x66,0x09,0x21,0x7a,0x4d,0x9c,0x27,0x99,0x2e,
|
|
0x2b,0xd7,0x04,0xa4,0xbb,0x12,0xfb,0x91,0x25,0x3c,0xd4,0xf4,0x96,0xfa,
|
|
0x00,0xb3,0x2f,0x3a,0x2d,0x15,0x3a,0x52,0xbb,0x57,0x76,0x50,0xcd,0xf1,
|
|
0xb7,0x3a,0x34,0x05,0x35,0xc7,0xe7,0x3d,0xeb,0x59,0x9a,0xa9,0x50,0x88
|
|
};
|
|
const unsigned char pub3[] = {
|
|
0x04, /* brainpoolP256r1 */
|
|
0x30,0x29,0x1b,0xca,0x4e,0xb9,0x3c,0x41,0x99,0x1d,0xae,0xc0,0xfd,0x2e,0x87,0xc2,
|
|
0x77,0x8d,0x95,0x8d,0x9a,0x8e,0x2f,0xa4,0xe6,0xd3,0x83,0x5d,0x48,0x5b,0xc2,0x3e,
|
|
0x42,0x17,0xf6,0x84,0xcf,0xdd,0x83,0x6d,0x7c,0xf6,0x09,0x9a,0x34,0xc6,0x82,0x61,
|
|
0xe5,0xa0,0x94,0xad,0xb5,0xb3,0xe4,0xa9,0x26,0x2f,0xf5,0x95,0x7c,0x1b,0x1b,0xa8
|
|
};
|
|
const unsigned char pub4[] = {
|
|
0x04, /* brainpoolP256t1 */
|
|
0x44,0x24,0xf0,0x9e,0x4f,0x86,0x92,0x31,0xe4,0x7b,0x1e,0x34,0x26,0xec,0x26,0x9e,
|
|
0x5b,0xef,0x19,0xec,0x64,0xcc,0x96,0xda,0x5b,0x2e,0xfd,0xd2,0x11,0x6b,0x83,0xf0,
|
|
0x7a,0x86,0x3d,0x25,0x74,0x3b,0xb2,0x60,0xa6,0x38,0xde,0x64,0x97,0x96,0xc6,0x76,
|
|
0xe1,0x38,0x05,0x86,0x5c,0x8b,0xb9,0xda,0xc3,0x8e,0x16,0xfa,0xe5,0x4b,0x0c,0xef
|
|
};
|
|
/* msg1+pub1+sig1 test vector is from wycheproof/ecdsa_test VALID */
|
|
const unsigned char sig1[] = {
|
|
0x30,0x45,0x02,0x20,0x2b,0xa3,0xa8,0xbe,0x6b,0x94,0xd5,0xec,0x80,0xa6,0xd9,0xd1,0x19,0x0a,
|
|
0x43,0x6e,0xff,0xe5,0x0d,0x85,0xa1,0xee,0xe8,0x59,0xb8,0xcc,0x6a,0xf9,0xbd,0x5c,0x2e,0x18,
|
|
0x02,0x21,0x00,0xb3,0x29,0xf4,0x79,0xa2,0xbb,0xd0,0xa5,0xc3,0x84,0xee,0x14,0x93,0xb1,0xf5,
|
|
0x18,0x6a,0x87,0x13,0x9c,0xac,0x5d,0xf4,0x08,0x7c,0x13,0x4b,0x49,0x15,0x68,0x47,0xdb
|
|
};
|
|
/* msg1+pub1+sig2 test vector is from wycheproof/ecdsa_test INVALID (changing tag value of sequence) */
|
|
const unsigned char sig2[] = {
|
|
0x31,0x45,0x02,0x20,0x2b,0xa3,0xa8,0xbe,0x6b,0x94,0xd5,0xec,0x80,0xa6,0xd9,0xd1,0x19,0x0a,
|
|
0x43,0x6e,0xff,0xe5,0x0d,0x85,0xa1,0xee,0xe8,0x59,0xb8,0xcc,0x6a,0xf9,0xbd,0x5c,0x2e,0x18,
|
|
0x02,0x21,0x00,0xb3,0x29,0xf4,0x79,0xa2,0xbb,0xd0,0xa5,0xc3,0x84,0xee,0x14,0x93,0xb1,0xf5,
|
|
0x18,0x6a,0x87,0x13,0x9c,0xac,0x5d,0xf4,0x08,0x7c,0x13,0x4b,0x49,0x15,0x68,0x47,0xdb
|
|
};
|
|
/* msg2+pub1+sig3 test vector is from wycheproof/ecdsa_test VALID (Edge case for Shamir multiplication) */
|
|
const unsigned char sig3[] = {
|
|
0x30,0x44,0x02,0x20,0x64,0xa1,0xaa,0xb5,0x00,0x0d,0x0e,0x80,0x4f,0x3e,0x2f,0xc0,0x2b,0xde,
|
|
0xe9,0xbe,0x8f,0xf3,0x12,0x33,0x4e,0x2b,0xa1,0x6d,0x11,0x54,0x7c,0x97,0x71,0x1c,0x89,0x8e,
|
|
0x02,0x20,0x6a,0xf0,0x15,0x97,0x1c,0xc3,0x0b,0xe6,0xd1,0xa2,0x06,0xd4,0xe0,0x13,0xe0,0x99,
|
|
0x77,0x72,0xa2,0xf9,0x1d,0x73,0x28,0x6f,0xfd,0x68,0x3b,0x9b,0xb2,0xcf,0x4f,0x1b
|
|
};
|
|
/* msg1+pub1+sig4 test vector is from wycheproof/ecdsa_test INVALID (long form encoding of length) */
|
|
const unsigned char sig4[] = {
|
|
0x30,0x81,0x45,0x02,0x20,0x2b,0xa3,0xa8,0xbe,0x6b,0x94,0xd5,0xec,0x80,0xa6,0xd9,0xd1,0x19,
|
|
0x0a,0x43,0x6e,0xff,0xe5,0x0d,0x85,0xa1,0xee,0xe8,0x59,0xb8,0xcc,0x6a,0xf9,0xbd,0x5c,0x2e,
|
|
0x18,0x02,0x21,0x00,0xb3,0x29,0xf4,0x79,0xa2,0xbb,0xd0,0xa5,0xc3,0x84,0xee,0x14,0x93,0xb1,
|
|
0xf5,0x18,0x6a,0x87,0x13,0x9c,0xac,0x5d,0xf4,0x08,0x7c,0x13,0x4b,0x49,0x15,0x68,0x47,0xdb
|
|
};
|
|
/* msg1+pub1+sig5 test vector is from wycheproof/ecdsa_test INVALID (length contains leading 0) */
|
|
const unsigned char sig5[] = {
|
|
0x30,0x82,0x00,0x45,0x02,0x20,0x2b,0xa3,0xa8,0xbe,0x6b,0x94,0xd5,0xec,0x80,0xa6,0xd9,0xd1,
|
|
0x19,0x0a,0x43,0x6e,0xff,0xe5,0x0d,0x85,0xa1,0xee,0xe8,0x59,0xb8,0xcc,0x6a,0xf9,0xbd,0x5c,
|
|
0x2e,0x18,0x02,0x21,0x00,0xb3,0x29,0xf4,0x79,0xa2,0xbb,0xd0,0xa5,0xc3,0x84,0xee,0x14,0x93,
|
|
0xb1,0xf5,0x18,0x6a,0x87,0x13,0x9c,0xac,0x5d,0xf4,0x08,0x7c,0x13,0x4b,0x49,0x15,0x68,0x47,0xdb
|
|
};
|
|
/* msg3+pub2+sig6 test vector is from wycheproof/ecdsa_test VALID (extreme value for k and edgecase s) */
|
|
const unsigned char sig6[] = {
|
|
0x30,0x3c,0x02,0x1c,0x70,0x6a,0x46,0xdc,0x76,0xdc,0xb7,0x67,0x98,0xe6,0x0e,0x6d,0x89,0x47,0x47,0x88,0xd1,
|
|
0x6d,0xc1,0x80,0x32,0xd2,0x68,0xfd,0x1a,0x70,0x4f,0xa6,0x02,0x1c,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
|
|
0x55,0x55,0x55,0x55,0x55,0x55,0x07,0x8b,0xa0,0x3d,0xa5,0x6a,0x06,0x9f,0x0d,0xc1,0xc9,0x74,0x0e,0x14
|
|
};
|
|
/* msg4+pub3+sig7 test vector is from wycheproof/ecdsa_test VALID (extreme value for k) */
|
|
const unsigned char sig7[] = {
|
|
0x30,0x44,0x02,0x20,0x74,0x3c,0xf1,0xb8,0xb5,0xcd,0x4f,0x2e,0xb5,0x5f,0x8a,0xa3,0x69,0x59,
|
|
0x3a,0xc4,0x36,0xef,0x04,0x41,0x66,0x69,0x9e,0x37,0xd5,0x1a,0x14,0xc2,0xce,0x13,0xea,0x0e,
|
|
0x02,0x20,0x77,0x47,0x2d,0x9a,0x28,0xb4,0xec,0xe7,0x1c,0xf4,0x13,0xa6,0x8e,0xac,0x0e,0xb4,
|
|
0x23,0xa1,0x6f,0xb4,0x62,0xb1,0xf4,0x87,0x06,0xfe,0xd4,0x8c,0xa4,0x37,0xbd,0x2d
|
|
};
|
|
/* msg4+pub4+sig8 test vector is from wycheproof/ecdsa_test VALID (extreme value for k and s^-1) */
|
|
const unsigned char sig8[] = {
|
|
0x30,0x45,0x02,0x21,0x00,0x83,0x38,0x42,0x7c,0x7c,0xf4,0xd1,0x1c,0xb9,0x81,0xd9,0xb1,0x87,
|
|
0x93,0xe3,0x77,0x9c,0x49,0x4c,0x50,0x2c,0x75,0xbd,0x73,0x9e,0x57,0x8d,0xe2,0xa7,0x00,0x57,
|
|
0x8d,0x02,0x20,0x30,0x90,0xf4,0x87,0xe5,0x1f,0x9e,0x35,0xc8,0xaf,0x70,0xbb,0x9a,0xb7,0xdf,
|
|
0x45,0x03,0x7e,0x23,0x0a,0x33,0xd2,0xc1,0xfd,0x96,0xe4,0x04,0x25,0x4f,0xcb,0x86,0x79
|
|
};
|
|
|
|
DO(ecc_find_curve("secp256r1", &cu));
|
|
DO(ecc_set_curve(cu, &key1));
|
|
DO(ecc_set_key(pub1, sizeof(pub1), PK_PUBLIC, &key1));
|
|
|
|
DO(ecc_find_curve("secp224r1", &cu));
|
|
DO(ecc_set_curve(cu, &key2));
|
|
DO(ecc_set_key(pub2, sizeof(pub2), PK_PUBLIC, &key2));
|
|
|
|
DO(ecc_find_curve("brainpoolP256r1", &cu));
|
|
DO(ecc_set_curve(cu, &key3));
|
|
DO(ecc_set_key(pub3, sizeof(pub3), PK_PUBLIC, &key3));
|
|
|
|
DO(ecc_find_curve("brainpoolP256t1", &cu));
|
|
DO(ecc_set_curve(cu, &key4));
|
|
DO(ecc_set_key(pub4, sizeof(pub4), PK_PUBLIC, &key4));
|
|
|
|
hashlen = sizeof(hash);
|
|
DO(hash_memory(find_hash("sha256"), msg1, sizeof(msg1), hash, &hashlen));
|
|
|
|
DO(ecc_verify_hash_v2(sig1, sizeof(sig1), hash, hashlen, &sig_opts, &stat, &key1));
|
|
ENSUREX(stat == 1, "sig1 - wycheproof / Valid");
|
|
|
|
SHOULD_FAIL(ecc_verify_hash_v2(sig2, sizeof(sig2), hash, hashlen, &sig_opts, &stat, &key1));
|
|
ENSUREX(stat == 0, "sig2 - wycheproof / changing tag value of sequence");
|
|
|
|
SHOULD_FAIL(ecc_verify_hash_v2(sig4, sizeof(sig4), hash, hashlen, &sig_opts, &stat, &key1));
|
|
ENSUREX(stat == 0, "sig4 - wycheproof / long form encoding of length");
|
|
|
|
SHOULD_FAIL(ecc_verify_hash_v2(sig5, sizeof(sig5), hash, hashlen, &sig_opts, &stat, &key1));
|
|
ENSUREX(stat == 0, "sig5 - wycheproof / length contains leading 0");
|
|
|
|
hashlen = sizeof(hash);
|
|
DO(hash_memory(find_hash("sha256"), msg2, sizeof(msg2), hash, &hashlen));
|
|
|
|
DO(ecc_verify_hash_v2(sig3, sizeof(sig3), hash, hashlen, &sig_opts, &stat, &key1));
|
|
ENSUREX(stat == 1, "wycheproof / Edge case for Shamir multiplication");
|
|
|
|
hashlen = sizeof(hash);
|
|
DO(hash_memory(find_hash("sha224"), msg3, sizeof(msg3), hash, &hashlen));
|
|
DO(ecc_verify_hash_v2(sig6, sizeof(sig6), hash, hashlen, &sig_opts, &stat, &key2));
|
|
ENSUREX(stat == 1, "wycheproof / extreme value for k and edgecase s");
|
|
|
|
hashlen = sizeof(hash);
|
|
DO(hash_memory(find_hash("sha256"), msg4, sizeof(msg4), hash, &hashlen));
|
|
DO(ecc_verify_hash_v2(sig7, sizeof(sig7), hash, hashlen, &sig_opts, &stat, &key3));
|
|
ENSUREX(stat == 1, "wycheproof / extreme value for k");
|
|
|
|
DO(ecc_verify_hash_v2(sig8, sizeof(sig8), hash, hashlen, &sig_opts, &stat, &key4));
|
|
ENSUREX(stat == 1, "wycheproof / extreme value for k and s^-1");
|
|
|
|
ecc_free(&key1);
|
|
ecc_free(&key2);
|
|
ecc_free(&key3);
|
|
ecc_free(&key4);
|
|
return CRYPT_OK;
|
|
}
|
|
|
|
static int s_ecc_test_mp(void)
|
|
{
|
|
void *a, *modulus, *order;
|
|
ecc_point *G, *GG;
|
|
int i, err, primality;
|
|
char buf[4096];
|
|
|
|
DO(ltc_mp_init_multi(&modulus, &order, &a, LTC_NULL));
|
|
|
|
G = ltc_ecc_new_point();
|
|
GG = ltc_ecc_new_point();
|
|
if (G == NULL || GG == NULL) {
|
|
ltc_mp_deinit_multi(modulus, order, LTC_NULL);
|
|
ltc_ecc_del_point(G);
|
|
ltc_ecc_del_point(GG);
|
|
return CRYPT_MEM;
|
|
}
|
|
|
|
err = CRYPT_OK;
|
|
|
|
for (i = 0; ltc_ecc_curves[i].prime != NULL; i++) {
|
|
DO(ltc_mp_read_radix(a, ltc_ecc_curves[i].A, 16));
|
|
DO(ltc_mp_read_radix(modulus, ltc_ecc_curves[i].prime, 16));
|
|
DO(ltc_mp_read_radix(order, ltc_ecc_curves[i].order, 16));
|
|
|
|
/* is prime actually prime? */
|
|
DO(ltc_mp_prime_is_prime(modulus, 8, &primality));
|
|
if (primality == 0) {
|
|
err = CRYPT_FAIL_TESTVECTOR;
|
|
ltc_mp_tohex(modulus, buf);
|
|
printf("Modulus failed prime check: %s\n", buf);
|
|
}
|
|
|
|
/* is order prime ? */
|
|
DO(ltc_mp_prime_is_prime(order, 8, &primality));
|
|
if (primality == 0) {
|
|
err = CRYPT_FAIL_TESTVECTOR;
|
|
ltc_mp_tohex(order, buf);
|
|
printf("Order failed prime check: %s\n", buf);
|
|
}
|
|
|
|
DO(ltc_mp_read_radix(G->x, ltc_ecc_curves[i].Gx, 16));
|
|
DO(ltc_mp_read_radix(G->y, ltc_ecc_curves[i].Gy, 16));
|
|
ltc_mp_set(G->z, 1);
|
|
|
|
/* then we should have G == (order + 1)G */
|
|
DO(ltc_mp_add_d(order, 1, order));
|
|
DO(ltc_mp.ecc_ptmul(order, G, GG, a, modulus, 1));
|
|
if (ltc_mp_cmp(G->x, GG->x) != LTC_MP_EQ || ltc_mp_cmp(G->y, GG->y) != LTC_MP_EQ) {
|
|
err = CRYPT_FAIL_TESTVECTOR;
|
|
}
|
|
if (err != CRYPT_OK) {
|
|
goto done;
|
|
}
|
|
}
|
|
err = CRYPT_OK;
|
|
done:
|
|
ltc_ecc_del_point(GG);
|
|
ltc_ecc_del_point(G);
|
|
ltc_mp_deinit_multi(order, modulus, a, LTC_NULL);
|
|
return err;
|
|
}
|
|
|
|
static int s_ecc_old_api(void)
|
|
{
|
|
unsigned char buf[4][4096], ch;
|
|
unsigned long x, y, z, s;
|
|
int stat, stat2;
|
|
ecc_key usera, userb, pubKey, privKey;
|
|
ltc_ecc_sig_opts sig_opts = {
|
|
.prng = &yarrow_prng,
|
|
.wprng = find_prng ("yarrow")
|
|
};
|
|
int low, high;
|
|
|
|
ecc_sizes(&low, &high);
|
|
if (low < 14 || high < 14 || low > 100 || high > 100 || high < low) return CRYPT_FAIL_TESTVECTOR;
|
|
|
|
for (s = 0; s < LTC_ARRAY_SIZE(sizes); s++) {
|
|
/* make up two keys */
|
|
DO(ecc_make_key (&yarrow_prng, find_prng ("yarrow"), sizes[s], &usera));
|
|
DO(ecc_make_key (&yarrow_prng, find_prng ("yarrow"), sizes[s], &userb));
|
|
if (ecc_get_size(&usera) != (int)sizes[s]) return CRYPT_FAIL_TESTVECTOR;
|
|
if (ecc_get_size(&userb) != (int)sizes[s]) return CRYPT_FAIL_TESTVECTOR;
|
|
|
|
/* make the shared secret */
|
|
x = sizeof(buf[0]);
|
|
DO(ecc_shared_secret (&usera, &userb, buf[0], &x));
|
|
|
|
y = sizeof(buf[1]);
|
|
DO(ecc_shared_secret (&userb, &usera, buf[1], &y));
|
|
|
|
COMPARE_TESTVECTOR(buf[0], x, buf[1], y, "ecc Shared keys", s);
|
|
|
|
/* now export userb */
|
|
y = sizeof(buf[0]);
|
|
DO(ecc_export (buf[1], &y, PK_PUBLIC, &userb));
|
|
ecc_free (&userb);
|
|
|
|
/* import and make the shared secret again */
|
|
DO(ecc_import (buf[1], y, &userb));
|
|
|
|
z = sizeof(buf[0]);
|
|
DO(ecc_shared_secret (&usera, &userb, buf[2], &z));
|
|
|
|
if (z != x) {
|
|
fprintf(stderr, "failed. Size don't match?");
|
|
return 1;
|
|
}
|
|
if (memcmp (buf[0], buf[2], x)) {
|
|
fprintf(stderr, "Failed. Contents didn't match.");
|
|
return 1;
|
|
}
|
|
|
|
/* export with ANSI X9.63 */
|
|
y = sizeof(buf[1]);
|
|
DO(ecc_ansi_x963_export(&userb, buf[1], &y));
|
|
ecc_free (&userb);
|
|
|
|
/* now import the ANSI key */
|
|
DO(ecc_ansi_x963_import(buf[1], y, &userb));
|
|
|
|
/* shared secret */
|
|
z = sizeof(buf[0]);
|
|
DO(ecc_shared_secret (&usera, &userb, buf[2], &z));
|
|
|
|
if (z != x) {
|
|
fprintf(stderr, "failed. Size don't match?");
|
|
return 1;
|
|
}
|
|
if (memcmp (buf[0], buf[2], x)) {
|
|
fprintf(stderr, "Failed. Contents didn't match.");
|
|
return 1;
|
|
}
|
|
|
|
ecc_free (&usera);
|
|
ecc_free (&userb);
|
|
|
|
/* test encrypt_key */
|
|
DO(ecc_make_key (&yarrow_prng, find_prng ("yarrow"), sizes[s], &usera));
|
|
|
|
/* export key */
|
|
x = sizeof(buf[0]);
|
|
DO(ecc_export(buf[0], &x, PK_PUBLIC, &usera));
|
|
DO(ecc_import(buf[0], x, &pubKey));
|
|
x = sizeof(buf[0]);
|
|
DO(ecc_export(buf[0], &x, PK_PRIVATE, &usera));
|
|
DO(ecc_import(buf[0], x, &privKey));
|
|
|
|
for (ch = 0; ch < 32; ch++) {
|
|
buf[0][ch] = ch;
|
|
}
|
|
y = sizeof (buf[1]);
|
|
DO(ecc_encrypt_key (buf[0], 32, buf[1], &y, &yarrow_prng, find_prng ("yarrow"), find_hash ("sha256"), &pubKey));
|
|
zeromem (buf[0], sizeof (buf[0]));
|
|
x = sizeof (buf[0]);
|
|
DO(ecc_decrypt_key (buf[1], y, buf[0], &x, &privKey));
|
|
if (x != 32) {
|
|
fprintf(stderr, "Failed (length)");
|
|
return 1;
|
|
}
|
|
for (ch = 0; ch < 32; ch++) {
|
|
if (buf[0][ch] != ch) {
|
|
fprintf(stderr, "Failed (contents)");
|
|
return 1;
|
|
}
|
|
}
|
|
/* test sign_hash */
|
|
for (ch = 0; ch < 16; ch++) {
|
|
buf[0][ch] = ch;
|
|
}
|
|
x = sizeof (buf[1]);
|
|
DO(ecc_sign_hash_v2(buf[0], 16, buf[1], &x, &sig_opts, &privKey));
|
|
DO(ecc_verify_hash_v2(buf[1], x, buf[0], 16, &sig_opts, &stat, &pubKey));
|
|
buf[0][0] ^= 1;
|
|
DO(ecc_verify_hash_v2(buf[1], x, buf[0], 16, &sig_opts, &stat2, &privKey));
|
|
if (!(stat == 1 && stat2 == 0)) {
|
|
fprintf(stderr, "ecc_verify_hash failed %d, %d, ", stat, stat2);
|
|
return 1;
|
|
}
|
|
/* test sign_hash_rfc7518 */
|
|
for (ch = 0; ch < 16; ch++) {
|
|
buf[0][ch] = ch;
|
|
}
|
|
x = sizeof (buf[1]);
|
|
DO(ecc_sign_hash_v2(buf[0], 16, buf[1], &x, &sig_opts, &privKey));
|
|
DO(ecc_verify_hash_v2(buf[1], x, buf[0], 16, &sig_opts, &stat, &pubKey));
|
|
buf[0][0] ^= 1;
|
|
DO(ecc_verify_hash_v2(buf[1], x, buf[0], 16, &sig_opts, &stat2, &privKey));
|
|
if (!(stat == 1 && stat2 == 0)) {
|
|
fprintf(stderr, "ecc_verify_hash_rfc7518 failed %d, %d, ", stat, stat2);
|
|
return 1;
|
|
}
|
|
ecc_free (&usera);
|
|
ecc_free (&pubKey);
|
|
ecc_free (&privKey);
|
|
}
|
|
return CRYPT_OK;
|
|
}
|
|
|
|
int ecc_key_cmp(const int should_type, const ecc_key *should, const ecc_key *is)
|
|
{
|
|
if (should_type != is->type) return CRYPT_ERROR;
|
|
if (should_type == PK_PRIVATE) {
|
|
if (ltc_mp_cmp(should->k, is->k) != LTC_MP_EQ) return CRYPT_ERROR;
|
|
}
|
|
if (ltc_mp_cmp(should->dp.prime, is->dp.prime) != LTC_MP_EQ) return CRYPT_ERROR;
|
|
if (ltc_mp_cmp(should->dp.A, is->dp.A) != LTC_MP_EQ) return CRYPT_ERROR;
|
|
if (ltc_mp_cmp(should->dp.B, is->dp.B) != LTC_MP_EQ) return CRYPT_ERROR;
|
|
if (ltc_mp_cmp(should->dp.order, is->dp.order) != LTC_MP_EQ) return CRYPT_ERROR;
|
|
if (ltc_mp_cmp(should->dp.base.x, is->dp.base.x) != LTC_MP_EQ) return CRYPT_ERROR;
|
|
if (ltc_mp_cmp(should->dp.base.y, is->dp.base.y) != LTC_MP_EQ) return CRYPT_ERROR;
|
|
if (ltc_mp_cmp(should->pubkey.x, is->pubkey.x) != LTC_MP_EQ) return CRYPT_ERROR;
|
|
if (ltc_mp_cmp(should->pubkey.y, is->pubkey.y) != LTC_MP_EQ) return CRYPT_ERROR;
|
|
if (should->dp.size != is->dp.size) return CRYPT_ERROR;
|
|
if (should->dp.cofactor != is->dp.cofactor) return CRYPT_ERROR;
|
|
return CRYPT_OK;
|
|
}
|
|
|
|
static int s_ecc_new_api(void)
|
|
{
|
|
int i, stat;
|
|
const ltc_ecc_curve* dp;
|
|
ecc_key key, privkey, pubkey;
|
|
unsigned char buf[1000];
|
|
unsigned long len, j;
|
|
#ifdef LTC_ECC_SHAMIR
|
|
unsigned long k;
|
|
#endif
|
|
unsigned char data16[MAXBLOCKSIZE];
|
|
unsigned long len16;
|
|
const ecc_signature_type sig_algs[] = {
|
|
#ifdef LTC_DER
|
|
LTC_ECCSIG_ANSIX962,
|
|
#endif
|
|
LTC_ECCSIG_RFC7518,
|
|
LTC_ECCSIG_ETH27,
|
|
#ifdef LTC_SSH
|
|
LTC_ECCSIG_RFC5656,
|
|
#endif
|
|
};
|
|
ltc_ecc_sig_opts sig_opts = {
|
|
.type = LTC_ECCSIG_ANSIX962,
|
|
.prng = &yarrow_prng,
|
|
.wprng = find_prng ("yarrow")
|
|
};
|
|
XMEMSET(data16, 0xd1, sizeof(data16));
|
|
|
|
for (i = 0; i < (int)LTC_ARRAY_SIZE(curvenames); i++) {
|
|
DO(ecc_find_curve(curvenames[i], &dp));
|
|
/* make new key */
|
|
DO(ecc_make_key_ex(&yarrow_prng, find_prng ("yarrow"), &key, dp));
|
|
len = sizeof(buf);
|
|
DO(ecc_export(buf, &len, PK_PRIVATE, &key));
|
|
DO(ecc_import_ex(buf, len, &privkey, dp));
|
|
ecc_free(&privkey);
|
|
len = sizeof(buf);
|
|
DO(ecc_export(buf, &len, PK_PUBLIC, &key));
|
|
DO(ecc_import_ex(buf, len, &pubkey, dp));
|
|
ecc_free(&pubkey);
|
|
len = sizeof(buf);
|
|
DO(ecc_ansi_x963_export(&key, buf, &len));
|
|
ecc_free(&key);
|
|
DO(ecc_ansi_x963_import_ex(buf, len, &pubkey, dp));
|
|
ecc_free(&pubkey);
|
|
|
|
/* generate new key */
|
|
DO(ecc_set_curve(dp, &key));
|
|
DO(ecc_generate_key(&yarrow_prng, find_prng ("yarrow"), &key));
|
|
len = sizeof(buf);
|
|
DO(ecc_get_key(buf, &len, PK_PRIVATE, &key));
|
|
ecc_free(&key);
|
|
|
|
/* load exported private key */
|
|
DO(ecc_set_curve(dp, &privkey));
|
|
DO(ecc_set_key(buf, len, PK_PRIVATE, &privkey));
|
|
|
|
if (strcmp(ltc_mp.name, "TomsFastMath") != 0) {
|
|
/* XXX-FIXME: TFM does not support sqrtmod_prime */
|
|
/* export compressed public key */
|
|
len = sizeof(buf);
|
|
DO(ecc_get_key(buf, &len, PK_PUBLIC|PK_COMPRESSED, &privkey));
|
|
if (len != 1 + (unsigned)ecc_get_size(&privkey)) return CRYPT_FAIL_TESTVECTOR;
|
|
/* load exported public+compressed key */
|
|
DO(ecc_set_curve(dp, &pubkey));
|
|
DO(ecc_set_key(buf, len, PK_PUBLIC, &pubkey));
|
|
ecc_free(&pubkey);
|
|
}
|
|
|
|
/* export long public key */
|
|
len = sizeof(buf);
|
|
DO(ecc_get_key(buf, &len, PK_PUBLIC, &privkey));
|
|
if (len != 1 + 2 * (unsigned)ecc_get_size(&privkey)) return CRYPT_FAIL_TESTVECTOR;
|
|
/* load exported public key */
|
|
DO(ecc_set_curve(dp, &pubkey));
|
|
DO(ecc_set_key(buf, len, PK_PUBLIC, &pubkey));
|
|
|
|
for (j = 0; j < LTC_ARRAY_SIZE(sig_algs); ++j) {
|
|
/* test signature */
|
|
if (sig_algs[j] == LTC_ECCSIG_ETH27 && XSTRCMP(dp->OID, "1.3.132.0.10"))
|
|
continue;
|
|
len = sizeof(buf);
|
|
sig_opts.type = sig_algs[j];
|
|
DO(ecc_sign_hash_v2(data16, privkey.dp.size, buf, &len, &sig_opts, &privkey));
|
|
stat = 0;
|
|
DO(ecc_verify_hash_v2(buf, len, data16, privkey.dp.size, &sig_opts, &stat, &pubkey));
|
|
if (stat != 1) return CRYPT_FAIL_TESTVECTOR;
|
|
|
|
#ifdef LTC_ECC_SHAMIR
|
|
if (strcmp(ltc_mp.name, "TomsFastMath") != 0) {
|
|
/* XXX-FIXME: TFM does not support sqrtmod_prime */
|
|
int found = 0;
|
|
ecc_key reckey;
|
|
/* test recovery */
|
|
sig_opts.enable_recovery_id = 1;
|
|
len = sizeof(buf);
|
|
DO(ecc_sign_hash_v2(data16, privkey.dp.size, buf, &len, &sig_opts, &privkey));
|
|
DO(ecc_set_curve(dp, &reckey));
|
|
for (k = 0; k < 2*(1+privkey.dp.cofactor); k++) {
|
|
sig_opts.recovery_id = k;
|
|
stat = ecc_recover_key(buf, len, data16, privkey.dp.size, &sig_opts, &reckey);
|
|
if (stat != CRYPT_OK) continue; /* last two will almost always fail, only possible if x<(prime mod order) */
|
|
stat = ecc_key_cmp(PK_PUBLIC, &pubkey, &reckey);
|
|
if (stat == CRYPT_OK) found++;
|
|
}
|
|
sig_opts.enable_recovery_id = 0;
|
|
if (found != 1) return CRYPT_FAIL_TESTVECTOR; /* unique match */
|
|
ecc_free(&reckey);
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
/* test encryption */
|
|
len = sizeof(buf);
|
|
DO(ecc_encrypt_key(data16, 16, buf, &len, &yarrow_prng, find_prng("yarrow"), find_hash("sha256"), &pubkey));
|
|
zeromem(data16, 16);
|
|
len16 = 16;
|
|
DO(ecc_decrypt_key(buf, len, data16, &len16, &privkey));
|
|
if ((int)len16 != 16) return CRYPT_FAIL_TESTVECTOR;
|
|
for (j = 0; (int)j < 16; j++) if (data16[j] != 0xd1) return CRYPT_FAIL_TESTVECTOR;
|
|
|
|
/* cleanup */
|
|
ecc_free(&privkey);
|
|
ecc_free(&pubkey);
|
|
}
|
|
return CRYPT_OK;
|
|
}
|
|
|
|
static int s_ecc_rfc6979(void)
|
|
{
|
|
const struct {
|
|
const char *curve, *x, *Ux, *Uy;
|
|
struct {
|
|
const char *k, *r, *s;
|
|
} signatures[11];
|
|
} tests[] = {
|
|
{
|
|
"P-192",
|
|
"6FAB034934E4C0FC9AE67F5B5659A9D7D1FEFD187EE09FD4",
|
|
"AC2C77F529F91689FEA0EA5EFEC7F210D8EEA0B9E047ED56",
|
|
"3BC723E57670BD4887EBC732C523063D0A7C957BC97C1C43",
|
|
{
|
|
{
|
|
"37D7CA00D2C7B0E5E412AC03BD44BA837FDD5B28CD3B0021",
|
|
"98C6BD12B23EAF5E2A2045132086BE3EB8EBD62ABF6698FF",
|
|
"57A22B07DEA9530F8DE9471B1DC6624472E8E2844BC25B64",
|
|
},
|
|
{
|
|
"4381526B3FC1E7128F202E194505592F01D5FF4C5AF015D8",
|
|
"A1F00DAD97AEEC91C95585F36200C65F3C01812AA60378F5",
|
|
"E07EC1304C7C6C9DEBBE980B9692668F81D4DE7922A0F97A",
|
|
},
|
|
{
|
|
"32B1B6D7D42A05CB449065727A84804FB1A3E34D8F261496",
|
|
"4B0B8CE98A92866A2820E20AA6B75B56382E0F9BFD5ECB55",
|
|
"CCDB006926EA9565CBADC840829D8C384E06DE1F1E381B85",
|
|
},
|
|
{
|
|
"4730005C4FCB01834C063A7B6760096DBE284B8252EF4311",
|
|
"DA63BF0B9ABCF948FBB1E9167F136145F7A20426DCC287D5",
|
|
"C3AA2C960972BD7A2003A57E1C4C77F0578F8AE95E31EC5E",
|
|
},
|
|
{
|
|
"A2AC7AB055E4F20692D49209544C203A7D1F2C0BFBC75DB1",
|
|
"4D60C5AB1996BD848343B31C00850205E2EA6922DAC2E4B8",
|
|
"3F6E837448F027A1BF4B34E796E32A811CBB4050908D8F67",
|
|
},
|
|
{
|
|
"D9CF9C3D3297D3260773A1DA7418DB5537AB8DD93DE7FA25",
|
|
"0F2141A0EBBC44D2E1AF90A50EBCFCE5E197B3B7D4DE036D",
|
|
"EB18BC9E1F3D7387500CB99CF5F7C157070A8961E38700B7",
|
|
},
|
|
{
|
|
"F5DC805F76EF851800700CCE82E7B98D8911B7D510059FBE",
|
|
"6945A1C1D1B2206B8145548F633BB61CEF04891BAF26ED34",
|
|
"B7FB7FDFC339C0B9BD61A9F5A8EAF9BE58FC5CBA2CB15293",
|
|
},
|
|
{
|
|
"5C4CE89CF56D9E7C77C8585339B006B97B5F0680B4306C6C",
|
|
"3A718BD8B4926C3B52EE6BBE67EF79B18CB6EB62B1AD97AE",
|
|
"5662E6848A4A19B1F1AE2F72ACD4B8BBE50F1EAC65D9124F",
|
|
},
|
|
{
|
|
"5AFEFB5D3393261B828DB6C91FBC68C230727B030C975693",
|
|
"B234B60B4DB75A733E19280A7A6034BD6B1EE88AF5332367",
|
|
"7994090B2D59BB782BE57E74A44C9A1C700413F8ABEFE77A",
|
|
},
|
|
{
|
|
"0758753A5254759C7CFBAD2E2D9B0792EEE44136C9480527",
|
|
"FE4F4AE86A58B6507946715934FE2D8FF9D95B6B098FE739",
|
|
"74CF5605C98FBA0E1EF34D4B5A1577A7DCF59457CAE52290",
|
|
},
|
|
{
|
|
NULL, NULL, NULL
|
|
}
|
|
}
|
|
},
|
|
{
|
|
"P-224",
|
|
"F220266E1105BFE3083E03EC7A3A654651F45E37167E88600BF257C1",
|
|
"CF08DA5AD719E42707FA431292DEA11244D64FC51610D94B130D6C",
|
|
"EEAB6F3DEBE455E3DBF85416F7030CBD94F34F2D6F232C69F3C1385A",
|
|
{
|
|
{
|
|
"7EEFADD91110D8DE6C2C470831387C50D3357F7F4D477054B8B426BC",
|
|
"22226F9D40A96E19C4A301CE5B74B115303C0F3A4FD30FC257FB57AC",
|
|
"66D1CDD83E3AF75605DD6E2FEFF196D30AA7ED7A2EDF7AF475403D69",
|
|
},
|
|
{
|
|
"C1D1F2F10881088301880506805FEB4825FE09ACB6816C36991AA06D",
|
|
"1CDFE6662DDE1E4A1EC4CDEDF6A1F5A2FB7FBD9145C12113E6ABFD3E",
|
|
"A6694FD7718A21053F225D3F46197CA699D45006C06F871808F43EBC",
|
|
},
|
|
{
|
|
"AD3029E0278F80643DE33917CE6908C70A8FF50A411F06E41DEDFCDC",
|
|
"61AA3DA010E8E8406C656BC477A7A7189895E7E840CDFE8FF42307BA",
|
|
"BC814050DAB5D23770879494F9E0A680DC1AF7161991BDE692B10101",
|
|
},
|
|
{
|
|
"52B40F5A9D3D13040F494E83D3906C6079F29981035C7BD51E5CAC40",
|
|
"0B115E5E36F0F9EC81F1325A5952878D745E19D7BB3EABFABA77E953",
|
|
"830F34CCDFE826CCFDC81EB4129772E20E122348A2BBD889A1B1AF1D",
|
|
},
|
|
{
|
|
"9DB103FFEDEDF9CFDBA05184F925400C1653B8501BAB89CEA0FBEC14",
|
|
"074BD1D979D5F32BF958DDC61E4FB4872ADCAFEB2256497CDAC30397",
|
|
"A4CECA196C3D5A1FF31027B33185DC8EE43F288B21AB342E5D8EB084",
|
|
},
|
|
{
|
|
"2519178F82C3F0E4F87ED5883A4E114E5B7A6E374043D8EFD329C253",
|
|
"DEAA646EC2AF2EA8AD53ED66B2E2DDAA49A12EFD8356561451F3E21C",
|
|
"95987796F6CF2062AB8135271DE56AE55366C045F6D9593F53787BD2",
|
|
},
|
|
{
|
|
"DF8B38D40DCA3E077D0AC520BF56B6D565134D9B5F2EAE0D34900524",
|
|
"C441CE8E261DED634E4CF84910E4C5D1D22C5CF3B732BB204DBEF019",
|
|
"902F42847A63BDC5F6046ADA114953120F99442D76510150F372A3F4",
|
|
},
|
|
{
|
|
"FF86F57924DA248D6E44E8154EB69F0AE2AEBAEE9931D0B5A969F904",
|
|
"AD04DDE87B84747A243A631EA47A1BA6D1FAA059149AD2440DE6FBA6",
|
|
"178D49B1AE90E3D8B629BE3DB5683915F4E8C99FDF6E666CF37ADCFD",
|
|
},
|
|
{
|
|
"7046742B839478C1B5BD31DB2E862AD868E1A45C863585B5F22BDC2D",
|
|
"389B92682E399B26518A95506B52C03BC9379A9DADF3391A21FB0EA4",
|
|
"414A718ED3249FF6DBC5B50C27F71F01F070944DA22AB1F78F559AAB",
|
|
},
|
|
{
|
|
"E39C2AA4EA6BE2306C72126D40ED77BF9739BB4D6EF2BBB1DCB6169D",
|
|
"049F050477C5ADD858CAC56208394B5A55BAEBBE887FDF765047C17C",
|
|
"077EB13E7005929CEFA3CD0403C7CDCC077ADF4E44F3C41B2F60ECFF",
|
|
},
|
|
{
|
|
NULL, NULL, NULL
|
|
}
|
|
}
|
|
},
|
|
{
|
|
"P-256",
|
|
"C9AFA9D845BA75166B5C215767B1D6934E50C3DB36E89B127B8A622B120F6721",
|
|
"60FED4BA255A9D31C961EB74C6356D68C049B8923B61FA6CE669622E60F29FB6",
|
|
"7903FE1008B8BC99A41AE9E95628BC64F2F1B20C2D7E9F5177A3C294D4462299",
|
|
{
|
|
{
|
|
"882905F1227FD620FBF2ABF21244F0BA83D0DC3A9103DBBEE43A1FB858109DB4",
|
|
"61340C88C3AAEBEB4F6D667F672CA9759A6CCAA9FA8811313039EE4A35471D32",
|
|
"6D7F147DAC089441BB2E2FE8F7A3FA264B9C475098FDCF6E00D7C996E1B8B7EB",
|
|
},
|
|
{
|
|
"103F90EE9DC52E5E7FB5132B7033C63066D194321491862059967C715985D473",
|
|
"53B2FFF5D1752B2C689DF257C04C40A587FABABB3F6FC2702F1343AF7CA9AA3F",
|
|
"B9AFB64FDC03DC1A131C7D2386D11E349F070AA432A4ACC918BEA988BF75C74C",
|
|
},
|
|
{
|
|
"A6E3C57DD01ABE90086538398355DD4C3B17AA873382B0F24D6129493D8AAD60",
|
|
"EFD48B2AACB6A8FD1140DD9CD45E81D69D2C877B56AAF991C34D0EA84EAF3716",
|
|
"F7CB1C942D657C41D436C7A1B6E29F65F3E900DBB9AFF4064DC4AB2F843ACDA8",
|
|
},
|
|
{
|
|
"09F634B188CEFD98E7EC88B1AA9852D734D0BC272F7D2A47DECC6EBEB375AAD4",
|
|
"0EAFEA039B20E9B42309FB1D89E213057CBF973DC0CFC8F129EDDDC800EF7719",
|
|
"4861F0491E6998B9455193E34E7B0D284DDD7149A74B95B9261F13ABDE940954",
|
|
},
|
|
{
|
|
"5FA81C63109BADB88C1F367B47DA606DA28CAD69AA22C4FE6AD7DF73A7173AA5",
|
|
"8496A60B5E9B47C825488827E0495B0E3FA109EC4568FD3F8D1097678EB97F00",
|
|
"2362AB1ADBE2B8ADF9CB9EDAB740EA6049C028114F2460F96554F61FAE3302FE",
|
|
},
|
|
{
|
|
"8C9520267C55D6B980DF741E56B4ADEE114D84FBFA2E62137954164028632A2E",
|
|
"0CBCC86FD6ABD1D99E703E1EC50069EE5C0B4BA4B9AC60E409E8EC5910D81A89",
|
|
"01B9D7B73DFAA60D5651EC4591A0136F87653E0FD780C3B1BC872FFDEAE479B1",
|
|
},
|
|
{
|
|
"669F4426F2688B8BE0DB3A6BD1989BDAEFFF84B649EEB84F3DD26080F667FAA7",
|
|
"C37EDB6F0AE79D47C3C27E962FA269BB4F441770357E114EE511F662EC34A692",
|
|
"C820053A05791E521FCAAD6042D40AEA1D6B1A540138558F47D0719800E18F2D",
|
|
},
|
|
{
|
|
"D16B6AE827F17175E040871A1C7EC3500192C4C92677336EC2537ACAEE0008E0",
|
|
"F1ABB023518351CD71D881567B1EA663ED3EFCF6C5132B354F28D3B0B7D38367",
|
|
"019F4113742A2B14BD25926B49C649155F267E60D3814B4C0CC84250E46F0083",
|
|
},
|
|
{
|
|
"16AEFFA357260B04B1DD199693960740066C1A8F3E8EDD79070AA914D361B3B8",
|
|
"83910E8B48BB0C74244EBDF7F07A1C5413D61472BD941EF3920E623FBCCEBEB6",
|
|
"8DDBEC54CF8CD5874883841D712142A56A8D0F218F5003CB0296B6B509619F2C",
|
|
},
|
|
{
|
|
"6915D11632ACA3C40D5D51C08DAF9C555933819548784480E93499000D9F0B7F",
|
|
"461D93F31B6540894788FD206C07CFA0CC35F46FA3C91816FFF1040AD1581A04",
|
|
"39AF9F15DE0DB8D97E72719C74820D304CE5226E32DEDAE67519E840D1194E55",
|
|
},
|
|
{
|
|
NULL, NULL, NULL
|
|
}
|
|
}
|
|
},
|
|
{
|
|
"P-384",
|
|
"6B9D3DAD2E1B8C1C05B19875B6659F4DE23C3B667BF297BA9AA47740787137D896D5724E4C70A825F872C9EA60D2EDF5",
|
|
"EC3A4E415B4E19A4568618029F427FA5DA9A8BC4AE92E02E06AAE5286B300C64DEF8F0EA9055866064A254515480BC13",
|
|
"8015D9B72D7D57244EA8EF9AC0C621896708A59367F9DFB9F54CA84B3F1C9DB1288B231C3AE0D4FE7344FD2533264720",
|
|
{
|
|
{
|
|
"4471EF7518BB2C7C20F62EAE1C387AD0C5E8E470995DB4ACF694466E6AB096630F29E5938D25106C3C340045A2DB01A7",
|
|
"EC748D839243D6FBEF4FC5C4859A7DFFD7F3ABDDF72014540C16D73309834FA37B9BA002899F6FDA3A4A9386790D4EB2",
|
|
"A3BCFA947BEEF4732BF247AC17F71676CB31A847B9FF0CBC9C9ED4C1A5B3FACF26F49CA031D4857570CCB5CA4424A443",
|
|
},
|
|
{
|
|
"A4E4D2F0E729EB786B31FC20AD5D849E304450E0AE8E3E341134A5C1AFA03CAB8083EE4E3C45B06A5899EA56C51B5879",
|
|
"42356E76B55A6D9B4631C865445DBE54E056D3B3431766D0509244793C3F9366450F76EE3DE43F5A125333A6BE060122",
|
|
"9DA0C81787064021E78DF658F2FBB0B042BF304665DB721F077A4298B095E4834C082C03D83028EFBF93A3C23940CA8D",
|
|
},
|
|
{
|
|
"180AE9F9AEC5438A44BC159A1FCB277C7BE54FA20E7CF404B490650A8ACC414E375572342863C899F9F2EDF9747A9B60",
|
|
"21B13D1E013C7FA1392D03C5F99AF8B30C570C6F98D4EA8E354B63A21D3DAA33BDE1E888E63355D92FA2B3C36D8FB2CD",
|
|
"F3AA443FB107745BF4BD77CB3891674632068A10CA67E3D45DB2266FA7D1FEEBEFDC63ECCD1AC42EC0CB8668A4FA0AB0",
|
|
},
|
|
{
|
|
"94ED910D1A099DAD3254E9242AE85ABDE4BA15168EAF0CA87A555FD56D10FBCA2907E3E83BA95368623B8C4686915CF9",
|
|
"94EDBB92A5ECB8AAD4736E56C691916B3F88140666CE9FA73D64C4EA95AD133C81A648152E44ACF96E36DD1E80FABE46",
|
|
"99EF4AEB15F178CEA1FE40DB2603138F130E740A19624526203B6351D0A3A94FA329C145786E679E7B82C71A38628AC8",
|
|
},
|
|
{
|
|
"92FC3C7183A883E24216D1141F1A8976C5B0DD797DFA597E3D7B32198BD35331A4E966532593A52980D0E3AAA5E10EC3",
|
|
"ED0959D5880AB2D869AE7F6C2915C6D60F96507F9CB3E047C0046861DA4A799CFE30F35CC900056D7C99CD7882433709",
|
|
"512C8CCEEE3890A84058CE1E22DBC2198F42323CE8ACA9135329F03C068E5112DC7CC3EF3446DEFCEB01A45C2667FDD5",
|
|
},
|
|
{
|
|
"66CC2C8F4D303FC962E5FF6A27BD79F84EC812DDAE58CF5243B64A4AD8094D47EC3727F3A3C186C15054492E30698497",
|
|
"4BC35D3A50EF4E30576F58CD96CE6BF638025EE624004A1F7789A8B8E43D0678ACD9D29876DAF46638645F7F404B11C7",
|
|
"D5A6326C494ED3FF614703878961C0FDE7B2C278F9A65FD8C4B7186201A2991695BA1C84541327E966FA7B50F7382282",
|
|
},
|
|
{
|
|
"18FA39DB95AA5F561F30FA3591DC59C0FA3653A80DAFFA0B48D1A4C6DFCBFF6E3D33BE4DC5EB8886A8ECD093F2935726",
|
|
"E8C9D0B6EA72A0E7837FEA1D14A1A9557F29FAA45D3E7EE888FC5BF954B5E62464A9A817C47FF78B8C11066B24080E72",
|
|
"07041D4A7A0379AC7232FF72E6F77B6DDB8F09B16CCE0EC3286B2BD43FA8C6141C53EA5ABEF0D8231077A04540A96B66",
|
|
},
|
|
{
|
|
"0CFAC37587532347DC3389FDC98286BBA8C73807285B184C83E62E26C401C0FAA48DD070BA79921A3457ABFF2D630AD7",
|
|
"6D6DEFAC9AB64DABAFE36C6BF510352A4CC27001263638E5B16D9BB51D451559F918EEDAF2293BE5B475CC8F0188636B",
|
|
"2D46F3BECBCC523D5F1A1256BF0C9B024D879BA9E838144C8BA6BAEB4B53B47D51AB373F9845C0514EEFB14024787265",
|
|
},
|
|
{
|
|
"015EE46A5BF88773ED9123A5AB0807962D193719503C527B031B4C2D225092ADA71F4A459BC0DA98ADB95837DB8312EA",
|
|
"8203B63D3C853E8D77227FB377BCF7B7B772E97892A80F36AB775D509D7A5FEB0542A7F0812998DA8F1DD3CA3CF023DB",
|
|
"DDD0760448D42D8A43AF45AF836FCE4DE8BE06B485E9B61B827C2F13173923E06A739F040649A667BF3B828246BAA5A5",
|
|
},
|
|
{
|
|
"3780C4F67CB15518B6ACAE34C9F83568D2E12E47DEAB6C50A4E4EE5319D1E8CE0E2CC8A136036DC4B9C00E6888F66B6C",
|
|
"A0D5D090C9980FAF3C2CE57B7AE951D31977DD11C775D314AF55F76C676447D06FB6495CD21B4B6E340FC236584FB277",
|
|
"976984E59B4C77B0E8E4460DCA3D9F20E07B9BB1F63BEEFAF576F6B2E8B224634A2092CD3792E0159AD9CEE37659C736",
|
|
},
|
|
{
|
|
NULL, NULL, NULL
|
|
}
|
|
}
|
|
},
|
|
{
|
|
"P-521",
|
|
"00FAD06DAA62BA3B25D2FB40133DA757205DE67F5BB0018FEE8C86E1B68C7E75CAA896EB32F1F47C70855836A6D16FCC1466F6D8FBEC67DB89EC0C08B0E996B83538",
|
|
"1894550D0785932E00EAA23B694F213F8C3121F86DC97A04E5A7167DB4E5BCD371123D46E45DB6B5D5370A7F20FB633155D38FFA16D2BD761DCAC474B9A2F5023A4",
|
|
"493101C962CD4D2FDDF782285E64584139C2F91B47F87FF82354D6630F746A28A0DB25741B5B34A828008B22ACC23F924FAAFBD4D33F81EA66956DFEAA2BFDFCF5",
|
|
{
|
|
{
|
|
"89C071B419E1C2820962321787258469511958E80582E95D8378E0C2CCDB3CB42BEDE42F50E3FA3C71F5A76724281D31D9C89F0F91FC1BE4918DB1C03A5838D0F9",
|
|
"00343B6EC45728975EA5CBA6659BBB6062A5FF89EEA58BE3C80B619F322C87910FE092F7D45BB0F8EEE01ED3F20BABEC079D202AE677B243AB40B5431D497C55D75D",
|
|
"00E7B0E675A9B24413D448B8CC119D2BF7B2D2DF032741C096634D6D65D0DBE3D5694625FB9E8104D3B842C1B0E2D0B98BEA19341E8676AEF66AE4EBA3D5475D5D16",
|
|
},
|
|
{
|
|
"0121415EC2CD7726330A61F7F3FA5DE14BE9436019C4DB8CB4041F3B54CF31BE0493EE3F427FB906393D895A19C9523F3A1D54BB8702BD4AA9C99DAB2597B92113F3",
|
|
"01776331CFCDF927D666E032E00CF776187BC9FDD8E69D0DABB4109FFE1B5E2A30715F4CC923A4A5E94D2503E9ACFED92857B7F31D7152E0F8C00C15FF3D87E2ED2E",
|
|
"0050CB5265417FE2320BBB5A122B8E1A32BD699089851128E360E620A30C7E17BA41A666AF126CE100E5799B153B60528D5300D08489CA9178FB610A2006C254B41F",
|
|
},
|
|
{
|
|
"EDF38AFCAAECAB4383358B34D67C9F2216C8382AAEA44A3DAD5FDC9C32575761793FEF24EB0FC276DFC4F6E3EC476752F043CF01415387470BCBD8678ED2C7E1A0",
|
|
"01511BB4D675114FE266FC4372B87682BAECC01D3CC62CF2303C92B3526012659D16876E25C7C1E57648F23B73564D67F61C6F14D527D54972810421E7D87589E1A7",
|
|
"004A171143A83163D6DF460AAF61522695F207A58B95C0644D87E52AA1A347916E4F7A72930B1BC06DBE22CE3F58264AFD23704CBB63B29B931F7DE6C9D949A7ECFC",
|
|
},
|
|
{
|
|
"01546A108BC23A15D6F21872F7DED661FA8431DDBD922D0DCDB77CC878C8553FFAD064C95A920A750AC9137E527390D2D92F153E66196966EA554D9ADFCB109C4211",
|
|
"01EA842A0E17D2DE4F92C15315C63DDF72685C18195C2BB95E572B9C5136CA4B4B576AD712A52BE9730627D16054BA40CC0B8D3FF035B12AE75168397F5D50C67451",
|
|
"01F21A3CEE066E1961025FB048BD5FE2B7924D0CD797BABE0A83B66F1E35EEAF5FDE143FA85DC394A7DEE766523393784484BDF3E00114A1C857CDE1AA203DB65D61",
|
|
},
|
|
{
|
|
"01DAE2EA071F8110DC26882D4D5EAE0621A3256FC8847FB9022E2B7D28E6F10198B1574FDD03A9053C08A1854A168AA5A57470EC97DD5CE090124EF52A2F7ECBFFD3",
|
|
"00C328FAFCBD79DD77850370C46325D987CB525569FB63C5D3BC53950E6D4C5F174E25A1EE9017B5D450606ADD152B534931D7D4E8455CC91F9B15BF05EC36E377FA",
|
|
"00617CCE7CF5064806C467F678D3B4080D6F1CC50AF26CA209417308281B68AF282623EAA63E5B5C0723D8B8C37FF0777B1A20F8CCB1DCCC43997F1EE0E44DA4A67A",
|
|
},
|
|
{
|
|
"00BB9F2BF4FE1038CCF4DABD7139A56F6FD8BB1386561BD3C6A4FC818B20DF5DDBA80795A947107A1AB9D12DAA615B1ADE4F7A9DC05E8E6311150F47F5C57CE8B222",
|
|
"013BAD9F29ABE20DE37EBEB823C252CA0F63361284015A3BF430A46AAA80B87B0693F0694BD88AFE4E661FC33B094CD3B7963BED5A727ED8BD6A3A202ABE009D0367",
|
|
"01E9BB81FF7944CA409AD138DBBEE228E1AFCC0C890FC78EC8604639CB0DBDC90F717A99EAD9D272855D00162EE9527567DD6A92CBD629805C0445282BBC916797FF",
|
|
},
|
|
{
|
|
"0040D09FCF3C8A5F62CF4FB223CBBB2B9937F6B0577C27020A99602C25A01136987E452988781484EDBBCF1C47E554E7FC901BC3085E5206D9F619CFF07E73D6F706",
|
|
"01C7ED902E123E6815546065A2C4AF977B22AA8EADDB68B2C1110E7EA44D42086BFE4A34B67DDC0E17E96536E358219B23A706C6A6E16BA77B65E1C595D43CAE17FB",
|
|
"0177336676304FCB343CE028B38E7B4FBA76C1C1B277DA18CAD2A8478B2A9A9F5BEC0F3BA04F35DB3E4263569EC6AADE8C92746E4C82F8299AE1B8F1739F8FD519A4",
|
|
},
|
|
{
|
|
"001DE74955EFAABC4C4F17F8E84D881D1310B5392D7700275F82F145C61E843841AF09035BF7A6210F5A431A6A9E81C9323354A9E69135D44EBD2FCAA7731B909258",
|
|
"000E871C4A14F993C6C7369501900C4BC1E9C7B0B4BA44E04868B30B41D8071042EB28C4C250411D0CE08CD197E4188EA4876F279F90B3D8D74A3C76E6F1E4656AA8",
|
|
"00CD52DBAA33B063C3A6CD8058A1FB0A46A4754B034FCC644766CA14DA8CA5CA9FDE00E88C1AD60CCBA759025299079D7A427EC3CC5B619BFBC828E7769BCD694E86",
|
|
},
|
|
{
|
|
"01F1FC4A349A7DA9A9E116BFDD055DC08E78252FF8E23AC276AC88B1770AE0B5DCEB1ED14A4916B769A523CE1E90BA22846AF11DF8B300C38818F713DADD85DE0C88",
|
|
"014BEE21A18B6D8B3C93FAB08D43E739707953244FDBE924FA926D76669E7AC8C89DF62ED8975C2D8397A65A49DCC09F6B0AC62272741924D479354D74FF6075578C",
|
|
"0133330865C067A0EAF72362A65E2D7BC4E461E8C8995C3B6226A21BD1AA78F0ED94FE536A0DCA35534F0CD1510C41525D163FE9D74D134881E35141ED5E8E95B979",
|
|
},
|
|
{
|
|
"016200813020EC986863BEDFC1B121F605C1215645018AEA1A7B215A564DE9EB1B38A67AA1128B80CE391C4FB71187654AAA3431027BFC7F395766CA988C964DC56D",
|
|
"013E99020ABF5CEE7525D16B69B229652AB6BDF2AFFCAEF38773B4B7D08725F10CDB93482FDCC54EDCEE91ECA4166B2A7C6265EF0CE2BD7051B7CEF945BABD47EE6D",
|
|
"01FBD0013C674AA79CB39849527916CE301C66EA7CE8B80682786AD60F98F7E78A19CA69EFF5C57400E3B3A0AD66CE0978214D13BAF4E9AC60752F7B155E2DE4DCE3",
|
|
},
|
|
{
|
|
NULL, NULL, NULL
|
|
}
|
|
}
|
|
},
|
|
{
|
|
0
|
|
}
|
|
};
|
|
|
|
const void *inputs[] = {
|
|
"sample",
|
|
"test"
|
|
};
|
|
const char hashes[][7] = {
|
|
"sha1",
|
|
"sha224",
|
|
"sha256",
|
|
"sha384",
|
|
"sha512"
|
|
};
|
|
const ltc_ecc_curve* dp;
|
|
ecc_key key;
|
|
unsigned char pk[MAXBLOCKSIZE], hash[MAXBLOCKSIZE], sig[512], should[512];
|
|
char name[128], tmp[MAXBLOCKSIZE];
|
|
unsigned int t, s, i, h;
|
|
unsigned long pklen, hashlen, curvelen, inputlen, siglen, shouldlen, shouldlen2;
|
|
ltc_ecc_sig_opts sig_opts = {
|
|
.type = LTC_ECCSIG_RFC7518,
|
|
.prng = &yarrow_prng,
|
|
.wprng = find_prng ("yarrow")
|
|
};
|
|
for (t = 0; tests[t].curve; ++t) {
|
|
curvelen = XSTRLEN(tests[t].curve);
|
|
XMEMCPY(name, tests[t].curve, curvelen);
|
|
name[curvelen++] = '-';
|
|
DOX(ecc_find_curve(tests[t].curve, &dp), tests[t].curve);
|
|
pklen = sizeof(pk);
|
|
DOX(base16_decode(tests[t].x, XSTRLEN(tests[t].x), pk, &pklen), tests[t].curve);
|
|
DOX(ecc_set_curve(dp, &key), tests[t].curve);
|
|
DOX(ecc_set_key(pk, pklen, PK_PRIVATE, &key), tests[t].curve);
|
|
name[curvelen] = 'U';
|
|
name[curvelen + 1] = 'x';
|
|
name[curvelen + 2] = '\0';
|
|
ltc_mp.write_radix(key.pubkey.x, tmp, 16);
|
|
COMPARE_TESTVECTOR(tmp, XSTRLEN(tmp), tests[t].Ux, XSTRLEN(tests[t].Ux), name, t * 1000);
|
|
name[curvelen + 1] = 'y';
|
|
ltc_mp.write_radix(key.pubkey.y, tmp, 16);
|
|
COMPARE_TESTVECTOR(tmp, XSTRLEN(tmp), tests[t].Uy, XSTRLEN(tests[t].Uy), name, t * 1000);
|
|
i = h = 0;
|
|
for (s = 0; tests[t].signatures[s].k; ++s) {
|
|
if (h == 0) {
|
|
inputlen = XSTRLEN(inputs[i]);
|
|
XMEMCPY(&name[curvelen], inputs[i], inputlen);
|
|
name[curvelen + inputlen++] = '-';
|
|
}
|
|
XMEMCPY(&name[curvelen + inputlen], hashes[h], 7);
|
|
hashlen = sizeof(hash);
|
|
DOX(hash_memory(find_hash(hashes[h]), inputs[i], XSTRLEN(inputs[i]), hash, &hashlen), name);
|
|
sig_opts.rfc6979_hash_alg = hashes[h];
|
|
siglen = sizeof(sig);
|
|
DOX(ecc_sign_hash_v2(hash, hashlen, sig, &siglen, &sig_opts, &key), name);
|
|
XMEMSET(should, 0, sizeof(should));
|
|
shouldlen = sizeof(should);
|
|
DOX(base16_decode(tests[t].signatures[s].r, XSTRLEN(tests[t].signatures[s].r), should, &shouldlen), name);
|
|
shouldlen2 = sizeof(should) - shouldlen;
|
|
DOX(base16_decode(tests[t].signatures[s].s, XSTRLEN(tests[t].signatures[s].s), should + shouldlen, &shouldlen2), name);
|
|
COMPARE_TESTVECTOR(sig, siglen, should, shouldlen + shouldlen2, name, (t * 1000 | s * 100 | i * 10 | h));
|
|
h++;
|
|
if (h == 5) {
|
|
h = 0;
|
|
i++;
|
|
}
|
|
}
|
|
ecc_free(&key);
|
|
}
|
|
return CRYPT_OK;
|
|
}
|
|
|
|
|
|
static int password_get(void **p, unsigned long *l, void *u)
|
|
{
|
|
LTC_UNUSED_PARAM(u);
|
|
*p = strdup("secret");
|
|
*l = 6;
|
|
return 0;
|
|
}
|
|
|
|
static int s_ecc_import_export(void) {
|
|
const ltc_ecc_curve *cu;
|
|
ecc_key key, pri, pub;
|
|
unsigned char out[300];
|
|
unsigned long outlen;
|
|
|
|
/* the following test keys were generated by:
|
|
# no password
|
|
openssl ecparam -name secp256k1 -genkey -out main-key.pem
|
|
openssl ec -in main-key.pem -param_enc explicit -out long_pri.der -outform DER
|
|
openssl ec -in main-key.pem -param_enc explicit -conv_form compressed -out long_pric.der -outform DER
|
|
openssl ec -in main-key.pem -param_enc explicit -pubout -out long_pub.der -outform DER
|
|
openssl ec -in main-key.pem -param_enc explicit -pubout -conv_form compressed -out long_pubc.der -outform DER
|
|
openssl ec -in main-key.pem -param_enc named_curve -out short_pri.der -outform DER
|
|
openssl ec -in main-key.pem -param_enc named_curve -conv_form compressed -out short_pric.der -outform DER
|
|
openssl ec -in main-key.pem -param_enc named_curve -pubout -out short_pub.der -outform DER
|
|
openssl ec -in main-key.pem -param_enc named_curve -pubout -conv_form compressed -out short_pubc.der -outform DER
|
|
# X.509 EC certificates
|
|
openssl req -new -x509 -keyform der -key long_pri.der -sha512 -subj '/CN=Test Cert EC' -out x509_cert_long.der -outform der -days 365000
|
|
openssl req -new -x509 -keyform der -key long_pric.der -sha512 -subj '/CN=Test Cert EC' -out x509_cert_longc.der -outform der -days 365000
|
|
openssl req -new -x509 -keyform der -key short_pri.der -sha512 -subj '/CN=Test Cert EC' -out x509_cert_short.der -outform der -days 365000
|
|
openssl req -new -x509 -keyform der -key short_pric.der -sha512 -subj '/CN=Test Cert EC' -out x509_cert_shortc.der -outform der -days 365000
|
|
# pkcs8 without password
|
|
openssl pkcs8 -topk8 -inform DER -outform DER -nocrypt -in long_pri.der -out long_pri_pkcs8.der
|
|
openssl pkcs8 -topk8 -inform DER -outform DER -nocrypt -in long_pric.der -out long_pric_pkcs8.der
|
|
openssl pkcs8 -topk8 -inform DER -outform DER -nocrypt -in short_pri.der -out short_pri_pkcs8.der
|
|
openssl pkcs8 -topk8 -inform DER -outform DER -nocrypt -in short_pric.der -out short_pric_pkcs8.der
|
|
# password protected - PBES1
|
|
openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in long_pri.der -v1 PBE-MD2-DES -out long_pri_pkcs8_pbe_md2_des.der
|
|
openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in long_pri.der -v1 PBE-MD2-RC2-64 -out long_pri_pkcs8_pbe_md2_rc2_64.der
|
|
openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in ltc_ecc_long_pri_test_key.der -v1 PBE-MD5-DES -out long_pri_pkcs8_pbe_md5_des.der
|
|
openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in ltc_ecc_long_pri_test_key.der -v1 PBE-SHA1-RC2-64 -out long_pri_pkcs8_pbe_sha1_rc2_64.der
|
|
openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in ltc_ecc_long_pri_test_key.der -v1 PBE-MD5-RC2-64 -out long_pri_pkcs8_pbe_md5_rc2_64.der
|
|
openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in ltc_ecc_long_pri_test_key.der -v1 PBE-SHA1-DES -out long_pri_pkcs8_pbe_sha1_des.der
|
|
# password protected - PBES2
|
|
openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in ltc_ecc_long_pri_test_key.der -v2 rc2 -out long_pri_pkcs8_pbkdf2_rc2_cbc.der
|
|
openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in ltc_ecc_long_pri_test_key.der -v2 des -out long_pri_pkcs8_pbkdf2_des_cbc.der
|
|
openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in ltc_ecc_long_pri_test_key.der -v2 des3 -out long_pri_pkcs8_pbkdf2_des_ede3_cbc.der
|
|
openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in ltc_ecc_long_pri_test_key.der -v2 des3 -v2prf hmacWithSHA224 -out long_pri_pkcs8_pbkdf2_sha224_des_ede3_cbc.der
|
|
openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in ltc_ecc_long_pri_test_key.der -v2 des3 -v2prf hmacWithSHA256 -out long_pri_pkcs8_pbkdf2_sha256_des_ede3_cbc.der
|
|
openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in ltc_ecc_long_pri_test_key.der -v2 des3 -v2prf hmacWithSHA384 -out long_pri_pkcs8_pbkdf2_sha384_des_ede3_cbc.der
|
|
openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in ltc_ecc_long_pri_test_key.der -v2 des3 -v2prf hmacWithSHA512 -out long_pri_pkcs8_pbkdf2_sha512_des_ede3_cbc.der
|
|
*/
|
|
/* static const unsigned char ltc_ecc_long_pri_test_key[] defined globally */
|
|
static const unsigned char long_pri_pkcs8[] = { /* private + long public, explicit curve params, PKCS8 */
|
|
0x30, 0x82, 0x01, 0x23, 0x02, 0x01, 0x00, 0x30, 0x81, 0xae, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce,
|
|
0x3d, 0x02, 0x01, 0x30, 0x81, 0xa2, 0x02, 0x01, 0x01, 0x30, 0x2c, 0x06, 0x07, 0x2a, 0x86, 0x48,
|
|
0xce, 0x3d, 0x01, 0x01, 0x02, 0x21, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x2f, 0x30, 0x06, 0x04, 0x01, 0x00, 0x04, 0x01, 0x07, 0x04,
|
|
0x41, 0x04, 0x79, 0xbe, 0x66, 0x7e, 0xf9, 0xdc, 0xbb, 0xac, 0x55, 0xa0, 0x62, 0x95, 0xce, 0x87,
|
|
0x0b, 0x07, 0x02, 0x9b, 0xfc, 0xdb, 0x2d, 0xce, 0x28, 0xd9, 0x59, 0xf2, 0x81, 0x5b, 0x16, 0xf8,
|
|
0x17, 0x98, 0x48, 0x3a, 0xda, 0x77, 0x26, 0xa3, 0xc4, 0x65, 0x5d, 0xa4, 0xfb, 0xfc, 0x0e, 0x11,
|
|
0x08, 0xa8, 0xfd, 0x17, 0xb4, 0x48, 0xa6, 0x85, 0x54, 0x19, 0x9c, 0x47, 0xd0, 0x8f, 0xfb, 0x10,
|
|
0xd4, 0xb8, 0x02, 0x21, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff, 0xfe, 0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0, 0x3b, 0xbf, 0xd2, 0x5e,
|
|
0x8c, 0xd0, 0x36, 0x41, 0x41, 0x02, 0x01, 0x01, 0x04, 0x6d, 0x30, 0x6b, 0x02, 0x01, 0x01, 0x04,
|
|
0x20, 0x0c, 0xf1, 0xad, 0x2f, 0x03, 0xf7, 0x91, 0x1b, 0xba, 0x03, 0xcf, 0x23, 0x37, 0xc8, 0xf2,
|
|
0xf7, 0x36, 0xce, 0x65, 0xf1, 0x84, 0x2d, 0x7d, 0x9f, 0x5f, 0x9e, 0x21, 0xd9, 0x5e, 0x49, 0xbd,
|
|
0x23, 0xa1, 0x44, 0x03, 0x42, 0x00, 0x04, 0x2a, 0xf9, 0x0b, 0xda, 0xbe, 0x71, 0x66, 0x9e, 0xd1,
|
|
0xcf, 0x12, 0xd0, 0x24, 0xaf, 0xba, 0xb6, 0x7f, 0xfb, 0x96, 0x27, 0x3e, 0x2f, 0xbd, 0x1e, 0xd5,
|
|
0xf9, 0x8d, 0x6c, 0x73, 0x9d, 0xc5, 0x16, 0x91, 0xbd, 0xb2, 0xb9, 0x1b, 0x40, 0x10, 0x5a, 0xb7,
|
|
0x6c, 0x6e, 0x32, 0x5b, 0xf7, 0x63, 0x62, 0x94, 0x24, 0x24, 0xdb, 0xec, 0x3f, 0x8b, 0xe5, 0x6e,
|
|
0x4b, 0x64, 0x37, 0x31, 0x24, 0x79, 0x4d
|
|
};
|
|
#if defined(LTC_MD2) && defined(LTC_DES)
|
|
static const unsigned char long_pri_pkcs8_pbe_md2_des[] = {
|
|
0x30, 0x82, 0x01, 0x49, 0x30, 0x1b, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x05,
|
|
0x01, 0x30, 0x0e, 0x04, 0x08, 0xd8, 0x1c, 0x80, 0xac, 0xd9, 0xfa, 0x9d, 0xbc, 0x02, 0x02, 0x08,
|
|
0x00, 0x04, 0x82, 0x01, 0x28, 0xe1, 0xd5, 0xa8, 0x9a, 0xa8, 0x23, 0x85, 0x53, 0x18, 0xb3, 0x96,
|
|
0x67, 0x8d, 0x45, 0x72, 0xf8, 0x69, 0xc4, 0xb1, 0x01, 0x3e, 0x04, 0xf7, 0xf7, 0x5d, 0x07, 0xad,
|
|
0xec, 0x8e, 0xd6, 0x23, 0x00, 0xe7, 0x59, 0xb0, 0x98, 0xbb, 0xdb, 0x85, 0xdb, 0x59, 0x4d, 0xb5,
|
|
0x53, 0xb3, 0x32, 0x50, 0x66, 0x75, 0xc4, 0x69, 0x05, 0x07, 0xee, 0xd4, 0xd8, 0x33, 0xcd, 0x4c,
|
|
0x94, 0xad, 0x82, 0xc7, 0x89, 0x53, 0x65, 0x9f, 0x55, 0x44, 0x95, 0x20, 0xe8, 0x4a, 0xc2, 0xef,
|
|
0x41, 0xf2, 0x9d, 0xf8, 0x3d, 0x16, 0x8a, 0x6a, 0x4e, 0x85, 0x90, 0xa7, 0xf9, 0xf8, 0xac, 0x16,
|
|
0x76, 0xf2, 0x29, 0x4b, 0x93, 0xec, 0xd8, 0x17, 0x3f, 0x89, 0x84, 0x79, 0x75, 0x90, 0x5f, 0xc3,
|
|
0xf2, 0xb8, 0x1a, 0x0a, 0x25, 0xf4, 0xe2, 0x59, 0xe0, 0xea, 0xa6, 0x57, 0xc4, 0x9c, 0xce, 0xfd,
|
|
0xa8, 0xbc, 0xf6, 0x0d, 0x3a, 0x47, 0x14, 0x9d, 0x6a, 0x92, 0x77, 0xe4, 0xcb, 0x88, 0x6e, 0xfa,
|
|
0x19, 0xa4, 0x3d, 0x58, 0xdb, 0x5f, 0xc7, 0xad, 0x91, 0x64, 0xb0, 0x1f, 0xe2, 0x66, 0xc5, 0x5a,
|
|
0x28, 0x21, 0xb0, 0xc1, 0xc8, 0x73, 0x55, 0xd8, 0x43, 0x66, 0x6a, 0x5c, 0xcd, 0xb0, 0x89, 0x60,
|
|
0x59, 0x31, 0xe0, 0x2f, 0x20, 0x3b, 0x83, 0xdf, 0x27, 0xcf, 0x33, 0xcc, 0xb9, 0xb6, 0xe0, 0xec,
|
|
0x8b, 0x94, 0x4b, 0xc4, 0x1c, 0x25, 0xba, 0x97, 0x6c, 0x83, 0x22, 0x8c, 0xca, 0x9d, 0xc6, 0xaa,
|
|
0x74, 0x3f, 0x46, 0xdc, 0xba, 0x7a, 0x36, 0x04, 0xa7, 0xc8, 0x65, 0xb4, 0xf7, 0x14, 0x53, 0x8c,
|
|
0xff, 0x4d, 0x19, 0xc1, 0xdb, 0xa4, 0xcc, 0x52, 0xc2, 0xd9, 0x38, 0x16, 0x8f, 0xd8, 0x6e, 0x55,
|
|
0x41, 0xa8, 0xe0, 0x15, 0xd6, 0x2d, 0xa4, 0x37, 0x9f, 0xcc, 0x42, 0x3c, 0xcb, 0xcc, 0x92, 0x04,
|
|
0xc8, 0xcf, 0xbc, 0x60, 0xfb, 0x45, 0xff, 0x62, 0x74, 0xa1, 0xe9, 0xba, 0x1e, 0x5d, 0x44, 0x6f,
|
|
0x0e, 0xac, 0xdf, 0xde, 0xb1, 0xbb, 0x47, 0x5e, 0x0c, 0x88, 0x0a, 0x85, 0x0b, 0xa8, 0x9e, 0xcb,
|
|
0x32, 0x99, 0x8d, 0xb1, 0xdd, 0x12, 0x08, 0xeb, 0x7e, 0x45, 0x70, 0x12, 0xe3
|
|
};
|
|
#endif
|
|
#if defined(LTC_MD2) && defined(LTC_RC2)
|
|
static const unsigned char long_pri_pkcs8_pbe_md2_rc2_64[] = {
|
|
0x30, 0x82, 0x01, 0x49, 0x30, 0x1b, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x05,
|
|
0x04, 0x30, 0x0e, 0x04, 0x08, 0xa2, 0x28, 0xb7, 0x2a, 0x08, 0x1c, 0x4a, 0xc4, 0x02, 0x02, 0x08,
|
|
0x00, 0x04, 0x82, 0x01, 0x28, 0x78, 0x12, 0x02, 0x58, 0x9b, 0xea, 0x77, 0xba, 0x84, 0x20, 0x96,
|
|
0x63, 0xf0, 0xf3, 0x38, 0x0b, 0x98, 0x53, 0x63, 0x8d, 0xa4, 0x5a, 0xa0, 0xa9, 0x21, 0x93, 0xd0,
|
|
0x56, 0xc9, 0xd2, 0x67, 0xb2, 0x5e, 0xb5, 0x9f, 0x15, 0x8c, 0x3c, 0x9a, 0xaf, 0x9c, 0xe5, 0x8b,
|
|
0xe6, 0x61, 0xac, 0xa4, 0x26, 0x75, 0x96, 0xea, 0x73, 0xaf, 0xd6, 0xb7, 0x4c, 0x66, 0x33, 0x98,
|
|
0x9e, 0x0b, 0xf8, 0xe6, 0x9c, 0xfd, 0x83, 0x0f, 0x55, 0x86, 0x9f, 0xa9, 0xf0, 0x23, 0xcb, 0x80,
|
|
0xe5, 0x32, 0x50, 0xea, 0x5b, 0x7d, 0xe2, 0x69, 0xc4, 0x6b, 0x61, 0xb2, 0xb8, 0x81, 0xe9, 0x05,
|
|
0xcb, 0x76, 0xae, 0xa5, 0x37, 0x0f, 0x3c, 0xe6, 0xde, 0x24, 0x6a, 0x9c, 0xf2, 0x0a, 0x28, 0x6a,
|
|
0xc9, 0xec, 0xef, 0xd7, 0xda, 0xcc, 0xf4, 0x3b, 0x74, 0x36, 0xc5, 0xaf, 0x53, 0xd8, 0xf4, 0x30,
|
|
0x0b, 0xd4, 0xb6, 0x36, 0xdc, 0x90, 0x4f, 0x83, 0x44, 0x79, 0xea, 0xc9, 0xb7, 0xb2, 0xd0, 0x03,
|
|
0xa6, 0x63, 0x7e, 0x1d, 0xa8, 0x4e, 0x93, 0x16, 0x7a, 0x4f, 0xd2, 0x8b, 0xd6, 0x78, 0x7d, 0x48,
|
|
0x41, 0x7c, 0xba, 0xc3, 0x64, 0x6f, 0x11, 0x22, 0x6d, 0x40, 0xb8, 0xc9, 0x03, 0x7a, 0x2c, 0xdf,
|
|
0x76, 0x78, 0x4f, 0x5f, 0x50, 0x03, 0x7a, 0xaf, 0x78, 0x91, 0xbb, 0x2a, 0xe6, 0x5e, 0x0f, 0xf5,
|
|
0x60, 0x9e, 0x8a, 0x2f, 0xdb, 0x9e, 0x57, 0xbe, 0xf6, 0x0f, 0x76, 0x6e, 0x44, 0x91, 0x7b, 0x36,
|
|
0x88, 0x9c, 0xf9, 0xbe, 0x13, 0x3e, 0x6b, 0x85, 0x62, 0xda, 0x1f, 0xf9, 0x73, 0x98, 0x8a, 0x0d,
|
|
0xdf, 0x11, 0x74, 0x18, 0xe1, 0x1c, 0xd1, 0x3f, 0x02, 0x43, 0xd4, 0x46, 0xe3, 0x8a, 0x3b, 0x6c,
|
|
0x7f, 0x81, 0xb4, 0xc3, 0x85, 0x4f, 0x89, 0x67, 0x26, 0x5a, 0x08, 0x35, 0x31, 0xd3, 0x15, 0xbb,
|
|
0xcc, 0x7d, 0x7b, 0x99, 0x41, 0xdb, 0x43, 0xa0, 0x83, 0x84, 0x74, 0x6c, 0x0a, 0x80, 0x46, 0xdc,
|
|
0xc8, 0x88, 0x87, 0x01, 0x21, 0x19, 0xd4, 0x1e, 0xf4, 0x09, 0x0e, 0x18, 0x31, 0x91, 0x37, 0x35,
|
|
0x1d, 0x07, 0xaf, 0x87, 0x92, 0x3d, 0xf8, 0xee, 0x6f, 0x87, 0x7b, 0x52, 0x3d
|
|
};
|
|
#endif
|
|
#if defined(LTC_MD5) && defined(LTC_DES)
|
|
static const unsigned char long_pri_pkcs8_pbe_md5_des[] = {
|
|
0x30, 0x82, 0x01, 0x49, 0x30, 0x1b, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x05,
|
|
0x03, 0x30, 0x0e, 0x04, 0x08, 0x33, 0xe7, 0xd9, 0xf1, 0x35, 0xd9, 0x74, 0x83, 0x02, 0x02, 0x08,
|
|
0x00, 0x04, 0x82, 0x01, 0x28, 0x2f, 0x77, 0x7c, 0x48, 0xc9, 0x43, 0x6d, 0xdb, 0xd0, 0x1a, 0xef,
|
|
0xfb, 0x29, 0x5e, 0x53, 0xa3, 0x52, 0x28, 0x27, 0x76, 0xc2, 0x01, 0x76, 0x5a, 0xea, 0x98, 0xe6,
|
|
0x72, 0xdf, 0x06, 0xa2, 0xf5, 0xd0, 0x7b, 0x74, 0xe4, 0x6b, 0x98, 0xa6, 0xb5, 0xe1, 0x02, 0xf7,
|
|
0xab, 0x2c, 0xf1, 0xeb, 0xf4, 0xec, 0xa6, 0xba, 0xd3, 0xd5, 0xb2, 0x26, 0x83, 0xeb, 0xff, 0xc9,
|
|
0xf8, 0x7b, 0xbf, 0xab, 0xdc, 0xe5, 0xe4, 0x91, 0xd5, 0x48, 0xba, 0x49, 0xcb, 0xc5, 0xf1, 0x71,
|
|
0x48, 0x1e, 0x96, 0x7c, 0x10, 0xe4, 0xa9, 0x35, 0xa7, 0xe6, 0x82, 0x97, 0x6f, 0xe4, 0x64, 0xd4,
|
|
0x53, 0xa9, 0xf1, 0x1b, 0x6c, 0x31, 0xa1, 0xc7, 0x12, 0x46, 0x45, 0x6f, 0x45, 0xb2, 0x09, 0x3a,
|
|
0xfe, 0x35, 0x4e, 0xbf, 0x7d, 0xf8, 0xcf, 0x94, 0x78, 0x0c, 0x78, 0xfb, 0xce, 0xc1, 0x30, 0xcd,
|
|
0x6d, 0x6b, 0x08, 0x5e, 0xf6, 0xf5, 0x97, 0xff, 0x5e, 0x63, 0x44, 0x36, 0xa5, 0x71, 0x04, 0xe5,
|
|
0x2d, 0xd9, 0xe3, 0x41, 0x91, 0x09, 0x1e, 0xa3, 0x30, 0xff, 0x12, 0x2a, 0x7a, 0xe1, 0x8f, 0x9c,
|
|
0x38, 0x13, 0x3d, 0xc3, 0xbb, 0x68, 0xfa, 0xc0, 0xc6, 0x35, 0x77, 0xed, 0xe8, 0x73, 0xca, 0xc3,
|
|
0x87, 0x62, 0xa9, 0x0e, 0xef, 0xcf, 0x73, 0x3c, 0xb3, 0xa0, 0x1b, 0xb5, 0x5d, 0x72, 0x89, 0x82,
|
|
0xd4, 0xf6, 0x37, 0x0b, 0x57, 0x8f, 0x48, 0xd4, 0xf1, 0x10, 0xa1, 0xe5, 0x25, 0x90, 0xeb, 0xde,
|
|
0x8d, 0x2a, 0x9d, 0xfb, 0x7c, 0x0d, 0xdc, 0x38, 0x45, 0x9e, 0xa0, 0x05, 0x98, 0x4e, 0x72, 0x9f,
|
|
0x3d, 0xde, 0xc7, 0x00, 0xf9, 0xaf, 0xdc, 0x67, 0x47, 0x73, 0xf7, 0xcf, 0x63, 0x80, 0xe3, 0x05,
|
|
0xb3, 0xda, 0x9f, 0x4b, 0x27, 0xd3, 0x14, 0xc9, 0x62, 0xd5, 0x09, 0xde, 0x4d, 0xe7, 0x21, 0x67,
|
|
0xfa, 0x10, 0x34, 0x18, 0xbf, 0xde, 0xf7, 0x95, 0x25, 0x6d, 0xba, 0xe4, 0x10, 0xf0, 0x9d, 0x05,
|
|
0x7b, 0xe4, 0xb5, 0xc0, 0x21, 0xb3, 0x7d, 0xcd, 0x1d, 0x80, 0xd0, 0x10, 0xd4, 0xdb, 0x9f, 0x06,
|
|
0xd5, 0x86, 0xea, 0x62, 0x96, 0xb7, 0x31, 0x73, 0xde, 0x25, 0xd0, 0xbb, 0xb2
|
|
};
|
|
#endif
|
|
#if defined(LTC_MD5) && defined(LTC_RC2)
|
|
static const unsigned char long_pri_pkcs8_pbe_md5_rc2_64[] = {
|
|
0x30, 0x82, 0x01, 0x49, 0x30, 0x1b, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x05,
|
|
0x06, 0x30, 0x0e, 0x04, 0x08, 0x95, 0x82, 0x6d, 0x08, 0xe4, 0x7e, 0xae, 0x5f, 0x02, 0x02, 0x08,
|
|
0x00, 0x04, 0x82, 0x01, 0x28, 0x93, 0x2c, 0xd8, 0x27, 0xed, 0x13, 0xe1, 0x31, 0xef, 0x7c, 0x44,
|
|
0x9c, 0xce, 0x85, 0x17, 0x38, 0x5a, 0xe3, 0xd8, 0xe9, 0xfd, 0x1e, 0x81, 0xae, 0x9c, 0xd7, 0x8b,
|
|
0x11, 0x4e, 0x92, 0x08, 0x3a, 0x97, 0x2c, 0x4f, 0x9a, 0xb7, 0x10, 0xda, 0x6a, 0x06, 0x9e, 0xe2,
|
|
0xb6, 0x41, 0xf8, 0xb3, 0xd4, 0x42, 0xcc, 0x67, 0xe8, 0x25, 0x76, 0x9a, 0xc2, 0x66, 0x1a, 0x94,
|
|
0x19, 0x0c, 0xe1, 0x43, 0x27, 0x27, 0x1e, 0xad, 0xfb, 0xce, 0xb7, 0x96, 0xfb, 0x5d, 0x6d, 0xf3,
|
|
0xe1, 0x73, 0xc5, 0x1c, 0xa0, 0xbe, 0x94, 0x2c, 0xe7, 0x1c, 0x04, 0xa9, 0xfe, 0xdf, 0x15, 0x79,
|
|
0x0c, 0x5e, 0xf8, 0xe2, 0xb9, 0x4a, 0xa0, 0xc5, 0x89, 0x2c, 0xf8, 0x1d, 0x5f, 0xcc, 0xf0, 0xb6,
|
|
0xe8, 0x31, 0xeb, 0xe5, 0xb4, 0x9d, 0x2a, 0xa8, 0x8d, 0xff, 0x69, 0xf7, 0x83, 0x65, 0xbb, 0xa2,
|
|
0xdd, 0xcd, 0x97, 0x41, 0x6e, 0xfa, 0xb6, 0xe1, 0x76, 0x7e, 0xa3, 0x24, 0x9b, 0x23, 0x58, 0x0e,
|
|
0xeb, 0x08, 0x00, 0x96, 0x53, 0xae, 0x6c, 0xb9, 0xaa, 0x5c, 0x9a, 0xf8, 0xee, 0xcd, 0xfd, 0xe5,
|
|
0xc5, 0x40, 0x62, 0x58, 0x6d, 0xf0, 0x10, 0xd5, 0x85, 0xeb, 0xed, 0x8a, 0x75, 0xe9, 0x8c, 0x2b,
|
|
0xe7, 0x39, 0xaf, 0xb1, 0x15, 0xdb, 0x4f, 0xe3, 0xa5, 0x24, 0x1d, 0xd2, 0xae, 0x82, 0x88, 0x1a,
|
|
0x37, 0x4c, 0x6b, 0x30, 0x9d, 0x6f, 0x93, 0x9c, 0x87, 0x99, 0xd1, 0x1c, 0x93, 0x0c, 0xbb, 0xf9,
|
|
0x70, 0x36, 0x28, 0x56, 0x68, 0x27, 0x2f, 0x1e, 0xf1, 0x86, 0x0a, 0x23, 0x04, 0xe6, 0x72, 0x1f,
|
|
0x1b, 0x71, 0x45, 0x0b, 0xe7, 0x74, 0x45, 0x8e, 0x7f, 0x94, 0xbc, 0xcd, 0x6c, 0xf8, 0xf3, 0xed,
|
|
0x44, 0x02, 0x4d, 0x0a, 0xdd, 0xe9, 0xe4, 0x46, 0x31, 0x94, 0x28, 0x9b, 0x5f, 0x05, 0x37, 0xf4,
|
|
0x05, 0x9c, 0xa3, 0x9c, 0xdf, 0xb7, 0xfb, 0xab, 0xe0, 0x07, 0x26, 0x40, 0x79, 0x12, 0x9a, 0x78,
|
|
0xf6, 0xb6, 0x30, 0x3d, 0x4e, 0x16, 0x2e, 0x39, 0x96, 0x98, 0x2a, 0x8c, 0xa7, 0xdb, 0xa0, 0x4a,
|
|
0x3f, 0x42, 0x30, 0xd3, 0x5d, 0xd0, 0x26, 0xd0, 0xc5, 0xd5, 0xa4, 0x10, 0x10
|
|
};
|
|
#endif
|
|
#if defined(LTC_SHA1) && defined(LTC_DES)
|
|
static const unsigned char long_pri_pkcs8_pbe_sha1_des[] = {
|
|
0x30, 0x82, 0x01, 0x49, 0x30, 0x1b, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x05,
|
|
0x0a, 0x30, 0x0e, 0x04, 0x08, 0x7c, 0x01, 0xae, 0xc9, 0x05, 0x43, 0x40, 0x70, 0x02, 0x02, 0x08,
|
|
0x00, 0x04, 0x82, 0x01, 0x28, 0xff, 0x96, 0x47, 0x56, 0x02, 0xd5, 0xd3, 0x2a, 0xf0, 0x44, 0x47,
|
|
0x7e, 0x74, 0x28, 0x62, 0x3f, 0x2b, 0xd4, 0xa9, 0xcc, 0x2c, 0xb7, 0x03, 0xc7, 0xa6, 0x39, 0xde,
|
|
0xc1, 0x46, 0xf1, 0xcd, 0x53, 0xb8, 0x76, 0xcd, 0xb8, 0xfd, 0xe8, 0x96, 0x1d, 0x52, 0xc5, 0xc2,
|
|
0x33, 0x2c, 0x2e, 0x4a, 0xe1, 0x83, 0x2e, 0x8a, 0x3a, 0x73, 0xfe, 0x50, 0x70, 0xcf, 0x2a, 0x29,
|
|
0xd5, 0x8a, 0x77, 0x96, 0xa3, 0x29, 0x7e, 0xfa, 0x74, 0xde, 0x78, 0x31, 0xd6, 0x78, 0x0a, 0x4f,
|
|
0x67, 0x8e, 0x26, 0xc9, 0x64, 0xf3, 0xde, 0xda, 0x5d, 0x15, 0xc2, 0x6b, 0x22, 0x25, 0x9e, 0x98,
|
|
0x41, 0x71, 0x4c, 0x09, 0x56, 0x90, 0x44, 0x7d, 0x16, 0xab, 0x7e, 0xd3, 0x75, 0x54, 0xbd, 0x88,
|
|
0x85, 0x4a, 0x01, 0xf4, 0x17, 0x19, 0xe2, 0x43, 0x5f, 0x31, 0xf9, 0x0b, 0x78, 0xd3, 0xb6, 0xc8,
|
|
0xa0, 0x29, 0x65, 0x86, 0xbc, 0x4b, 0xcb, 0xe2, 0xe8, 0xe7, 0x06, 0xe2, 0x27, 0xa3, 0x6a, 0xdc,
|
|
0x9f, 0x42, 0x40, 0xc4, 0x38, 0x49, 0x3b, 0x15, 0x28, 0x82, 0x9f, 0xa0, 0x2d, 0x42, 0x30, 0xa9,
|
|
0x28, 0x84, 0x41, 0x2b, 0xa3, 0xfb, 0xf1, 0x74, 0xa1, 0xfa, 0xff, 0x9d, 0xb6, 0x7e, 0x9b, 0x9f,
|
|
0xfa, 0xbd, 0x00, 0x17, 0x17, 0xa6, 0xb5, 0x2a, 0x1f, 0x6b, 0x55, 0x6c, 0xd4, 0x4b, 0xbe, 0xbb,
|
|
0xa5, 0xa7, 0x9f, 0x0c, 0x90, 0x04, 0x91, 0x09, 0x4d, 0x82, 0xe1, 0x67, 0x21, 0x96, 0x3a, 0x3b,
|
|
0xcf, 0x7f, 0xe9, 0xb9, 0xcc, 0x56, 0xd8, 0xc7, 0xe4, 0x98, 0x30, 0x11, 0x8f, 0xfd, 0xe5, 0xbc,
|
|
0x5e, 0xc4, 0x60, 0xe9, 0xd4, 0xc6, 0xf2, 0x60, 0xf3, 0xcd, 0x36, 0xa4, 0xe4, 0x6c, 0xfe, 0xbf,
|
|
0xab, 0xd5, 0x2f, 0x12, 0xf4, 0xa2, 0xf0, 0xeb, 0x10, 0xd9, 0x74, 0xef, 0x7c, 0x37, 0x8d, 0xdd,
|
|
0xc1, 0xaa, 0x84, 0xf6, 0xf1, 0xb6, 0x5b, 0x43, 0x51, 0x06, 0x78, 0xae, 0x8e, 0x9d, 0xc5, 0xc9,
|
|
0x26, 0xdc, 0x05, 0xa3, 0x00, 0xfa, 0x4a, 0x27, 0x5f, 0x19, 0xf3, 0x88, 0x2e, 0x01, 0xb8, 0xe7,
|
|
0x23, 0x37, 0x77, 0xa1, 0xbb, 0xb0, 0x66, 0xe2, 0xba, 0x10, 0x50, 0x06, 0x65
|
|
};
|
|
#endif
|
|
#if defined(LTC_SHA1) && defined(LTC_RC2)
|
|
static const unsigned char long_pri_pkcs8_pbe_sha1_rc2_64[] = {
|
|
0x30, 0x82, 0x01, 0x49, 0x30, 0x1b, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x05,
|
|
0x0b, 0x30, 0x0e, 0x04, 0x08, 0x64, 0x3c, 0xdb, 0x86, 0xd9, 0xa0, 0xae, 0x3e, 0x02, 0x02, 0x08,
|
|
0x00, 0x04, 0x82, 0x01, 0x28, 0x78, 0x85, 0x55, 0x7f, 0x37, 0xb8, 0xf7, 0xff, 0x94, 0x94, 0xf3,
|
|
0xf2, 0x21, 0x05, 0x6d, 0x75, 0xca, 0x03, 0x1c, 0xa3, 0x9f, 0x47, 0x41, 0x14, 0x57, 0xdd, 0x63,
|
|
0x71, 0x6c, 0xc2, 0x51, 0x14, 0x4a, 0x0d, 0x63, 0x12, 0xa8, 0x27, 0xf6, 0x3c, 0xb7, 0x47, 0x6d,
|
|
0xa0, 0x72, 0xfe, 0x60, 0x9f, 0x1c, 0xc8, 0xe4, 0xe5, 0xfe, 0x68, 0x9d, 0x85, 0x0f, 0x8e, 0x52,
|
|
0x2e, 0x30, 0xd5, 0x81, 0xd8, 0xc9, 0x05, 0x14, 0x1b, 0x1b, 0xf3, 0xbc, 0x95, 0x6d, 0x5d, 0x94,
|
|
0x71, 0xff, 0xa8, 0xfe, 0xa7, 0x34, 0xff, 0x30, 0xbe, 0x8e, 0xe4, 0x65, 0x6b, 0xd0, 0xa2, 0x43,
|
|
0x42, 0x14, 0x63, 0x36, 0x6f, 0x5d, 0x79, 0x56, 0x1b, 0x23, 0xd6, 0xdf, 0x39, 0x75, 0x48, 0x07,
|
|
0xa2, 0x5f, 0x8d, 0x11, 0x7c, 0x95, 0x48, 0x18, 0x2d, 0xdd, 0x92, 0x14, 0x4f, 0xfd, 0x45, 0x7e,
|
|
0x60, 0x68, 0xde, 0x47, 0x04, 0x0d, 0x0a, 0xa6, 0x3a, 0x30, 0xcb, 0x29, 0xc7, 0x9e, 0x27, 0xc3,
|
|
0x2d, 0x49, 0xbd, 0x1e, 0xc5, 0xc9, 0xd8, 0xd2, 0x22, 0x72, 0xe2, 0xd0, 0x8e, 0x03, 0xe8, 0x84,
|
|
0xfd, 0x7e, 0xb8, 0x8a, 0xd7, 0x70, 0x6d, 0x0b, 0xec, 0x67, 0xd0, 0xb3, 0x08, 0x9a, 0x31, 0x32,
|
|
0x43, 0x1f, 0xa3, 0xd1, 0x6b, 0x3a, 0x63, 0xbc, 0xca, 0x25, 0x1e, 0x55, 0xd7, 0x21, 0x68, 0x77,
|
|
0xfa, 0x41, 0x70, 0xdc, 0x3a, 0xfb, 0x05, 0x19, 0xd8, 0x8a, 0xe3, 0xe7, 0xfc, 0xf1, 0xc1, 0x0d,
|
|
0xd4, 0x9e, 0x64, 0xd0, 0x91, 0xa5, 0x4d, 0x7b, 0x8b, 0xd9, 0xee, 0xa7, 0x6b, 0x2b, 0x0f, 0xd9,
|
|
0xcf, 0xb3, 0xb4, 0x5b, 0x4e, 0xcc, 0xac, 0x53, 0xe5, 0xd3, 0xdd, 0x73, 0x40, 0xa5, 0x35, 0x71,
|
|
0xeb, 0xca, 0xa7, 0xc0, 0xae, 0x70, 0xdf, 0x14, 0x83, 0xbe, 0xd8, 0x37, 0xfa, 0x8b, 0x14, 0xdb,
|
|
0x0c, 0x4e, 0x98, 0xc7, 0xe6, 0x40, 0x38, 0x94, 0x69, 0xd4, 0xd4, 0xa9, 0xb5, 0x3f, 0xec, 0xac,
|
|
0x14, 0x59, 0x46, 0xb5, 0x98, 0xb0, 0x99, 0x89, 0xea, 0xf5, 0x43, 0xb4, 0x47, 0xa9, 0xb1, 0xf2,
|
|
0x03, 0x2a, 0xaf, 0xd5, 0x5d, 0x81, 0xae, 0x3b, 0xb4, 0x52, 0x11, 0x85, 0xcb
|
|
};
|
|
#endif
|
|
#if defined(LTC_DES)
|
|
static const unsigned char long_pri_pkcs8_pbkdf2_des_cbc[] = {
|
|
0x30, 0x82, 0x01, 0x6b, 0x30, 0x3d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x05,
|
|
0x0d, 0x30, 0x30, 0x30, 0x1b, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x05, 0x0c,
|
|
0x30, 0x0e, 0x04, 0x08, 0xda, 0x6b, 0x0a, 0x58, 0x7e, 0xd2, 0x9d, 0x38, 0x02, 0x02, 0x08, 0x00,
|
|
0x30, 0x11, 0x06, 0x05, 0x2b, 0x0e, 0x03, 0x02, 0x07, 0x04, 0x08, 0xcc, 0x5c, 0x19, 0x7c, 0xa6,
|
|
0x0d, 0x01, 0x4b, 0x04, 0x82, 0x01, 0x28, 0x02, 0x9d, 0xec, 0xa4, 0xe1, 0x42, 0xc4, 0xdb, 0x18,
|
|
0x32, 0x26, 0x96, 0x8b, 0x87, 0x1a, 0xb7, 0x66, 0x8e, 0xfd, 0x23, 0x1e, 0x1e, 0x20, 0x18, 0xcd,
|
|
0x81, 0x1b, 0x67, 0x86, 0x78, 0xae, 0xb3, 0x70, 0x81, 0xf9, 0x6a, 0x26, 0x4e, 0x31, 0x64, 0xf8,
|
|
0x7e, 0xbf, 0xf3, 0xd3, 0xea, 0x7c, 0xda, 0x5d, 0x4d, 0xb7, 0xe2, 0xda, 0x9a, 0x80, 0x94, 0xd1,
|
|
0x65, 0x5f, 0x57, 0x17, 0xbc, 0xac, 0xd3, 0xb4, 0x94, 0xdc, 0xd0, 0x34, 0xe9, 0xed, 0x57, 0x97,
|
|
0x53, 0xe9, 0x24, 0x21, 0xac, 0x2b, 0xd1, 0xd9, 0x35, 0x7f, 0xf0, 0x79, 0x14, 0xce, 0x96, 0xe2,
|
|
0x55, 0xfb, 0xb9, 0x6e, 0xeb, 0xbf, 0xc8, 0xf2, 0x66, 0xc1, 0x42, 0xee, 0x94, 0x22, 0xac, 0x6a,
|
|
0xe2, 0xf6, 0xba, 0xfc, 0xeb, 0xc1, 0xd0, 0xec, 0x3c, 0x16, 0xa4, 0x36, 0x7a, 0xbf, 0xe9, 0x9d,
|
|
0x39, 0xd6, 0x32, 0x54, 0x3e, 0x86, 0xcf, 0xe4, 0x32, 0x1c, 0xc5, 0x54, 0x3f, 0x8d, 0x6e, 0xb9,
|
|
0x6c, 0x3d, 0xd7, 0x68, 0xd7, 0x67, 0xdd, 0x04, 0x0e, 0x8c, 0xfd, 0x62, 0x1a, 0x21, 0xa8, 0xcc,
|
|
0x67, 0xbd, 0x4f, 0x9b, 0x3c, 0x99, 0xd5, 0xa5, 0x98, 0x12, 0x33, 0x04, 0xcf, 0x1b, 0x58, 0x3f,
|
|
0xb2, 0x70, 0xfe, 0x92, 0xff, 0x7a, 0x73, 0xf9, 0x37, 0xd5, 0x20, 0x0e, 0x49, 0xed, 0xb3, 0x77,
|
|
0x73, 0x0f, 0x3e, 0xf8, 0x15, 0xc1, 0xfc, 0x28, 0x47, 0x10, 0xe8, 0x30, 0xee, 0xa9, 0x96, 0xcf,
|
|
0x39, 0xb6, 0x83, 0xe2, 0x84, 0x1d, 0x0e, 0x65, 0xb7, 0x02, 0x08, 0xf7, 0x8d, 0xe7, 0xf2, 0xcc,
|
|
0x52, 0xc2, 0xe6, 0x1d, 0xf6, 0x96, 0x17, 0x3e, 0x3f, 0xd8, 0x70, 0x8d, 0x2c, 0x62, 0x00, 0xf3,
|
|
0x32, 0xbd, 0x1c, 0x6b, 0x4a, 0x0c, 0xc6, 0x46, 0x61, 0x92, 0x1c, 0x01, 0x11, 0xbc, 0x55, 0xdd,
|
|
0x82, 0xd1, 0xbf, 0x2e, 0x1e, 0x97, 0xbe, 0xa7, 0x6e, 0x5a, 0xcd, 0xc6, 0x8f, 0x38, 0x24, 0x8f,
|
|
0xb8, 0x36, 0x3d, 0x06, 0x82, 0x14, 0x5b, 0x1a, 0x84, 0x1e, 0x47, 0x53, 0x3a, 0x12, 0x21, 0x23,
|
|
0xbe, 0xe4, 0xf4, 0x57, 0xc7, 0x31, 0x45, 0x24, 0x46, 0x94, 0x53, 0x0b, 0x1d, 0xcd, 0x57
|
|
};
|
|
#endif
|
|
#if defined(LTC_DES)
|
|
static const unsigned char long_pri_pkcs8_pbkdf2_des_ede3_cbc[] = {
|
|
0x30, 0x82, 0x01, 0x6e, 0x30, 0x40, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x05,
|
|
0x0d, 0x30, 0x33, 0x30, 0x1b, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x05, 0x0c,
|
|
0x30, 0x0e, 0x04, 0x08, 0x6a, 0x99, 0x55, 0x06, 0x40, 0xd5, 0xe6, 0xc9, 0x02, 0x02, 0x08, 0x00,
|
|
0x30, 0x14, 0x06, 0x08, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x03, 0x07, 0x04, 0x08, 0x7f, 0xf2,
|
|
0xa7, 0xa3, 0x2c, 0xbb, 0x8e, 0x78, 0x04, 0x82, 0x01, 0x28, 0x55, 0x4d, 0xcb, 0xab, 0xb8, 0x6e,
|
|
0xcf, 0x00, 0xd2, 0xe8, 0x1e, 0x0e, 0xe1, 0x8f, 0x51, 0x8e, 0x32, 0x68, 0xaf, 0x44, 0xa6, 0xf2,
|
|
0x9e, 0x11, 0xd7, 0x0f, 0xa7, 0xd5, 0x74, 0x77, 0xbc, 0x6b, 0x53, 0x40, 0x70, 0xb6, 0x02, 0xdb,
|
|
0xa6, 0x2e, 0xc7, 0x20, 0x15, 0x78, 0x91, 0xcc, 0x5b, 0xa7, 0x15, 0x58, 0x65, 0xeb, 0xc7, 0x6f,
|
|
0xb8, 0x14, 0xc9, 0x5f, 0x89, 0x58, 0xe2, 0xab, 0x69, 0x17, 0xe2, 0xe7, 0xe0, 0xa4, 0x59, 0xb7,
|
|
0x6a, 0xc2, 0xe5, 0xba, 0x03, 0x0e, 0xcc, 0x0a, 0xb1, 0xf0, 0x69, 0xb2, 0x90, 0xac, 0x30, 0x79,
|
|
0xd4, 0xa3, 0x90, 0xa2, 0x60, 0x37, 0x7d, 0xf8, 0xd9, 0x49, 0xa3, 0x0b, 0x6d, 0xd9, 0x98, 0x9e,
|
|
0xb0, 0x6a, 0xad, 0x97, 0x08, 0xf1, 0xfd, 0xec, 0xf8, 0xa7, 0x3c, 0xf6, 0x48, 0x81, 0x5b, 0x6d,
|
|
0x19, 0xcc, 0xed, 0x49, 0x94, 0x05, 0x6e, 0xa4, 0x9b, 0x58, 0xdd, 0xaf, 0xd7, 0x3d, 0x12, 0xe6,
|
|
0xf4, 0x12, 0x46, 0xd9, 0x82, 0xde, 0xb7, 0xc4, 0xeb, 0x1c, 0x3a, 0xef, 0x93, 0x82, 0x3d, 0xf8,
|
|
0x55, 0x88, 0xe5, 0x54, 0xd6, 0x74, 0x1c, 0x20, 0xbd, 0x40, 0x65, 0x99, 0x19, 0x5f, 0x25, 0x62,
|
|
0x35, 0x6d, 0x32, 0x64, 0xd7, 0xa1, 0x45, 0xa8, 0xc4, 0x8d, 0xe0, 0x6d, 0x14, 0x85, 0x84, 0x75,
|
|
0x62, 0x0f, 0xb0, 0xe9, 0xb1, 0xca, 0x31, 0x97, 0x22, 0x41, 0xb3, 0xf5, 0xdf, 0x5c, 0xbf, 0x3f,
|
|
0x4f, 0x01, 0xf8, 0xe7, 0xbc, 0xdc, 0xb2, 0x9a, 0x7d, 0x0c, 0x96, 0x38, 0x48, 0x7a, 0x1b, 0x89,
|
|
0x2b, 0xab, 0xa6, 0xbd, 0xee, 0x7a, 0xf8, 0x85, 0x82, 0x80, 0x8c, 0x3b, 0x05, 0x3c, 0x40, 0x69,
|
|
0x97, 0x0a, 0x4c, 0x45, 0xae, 0x38, 0x22, 0xc5, 0x95, 0xf2, 0x4f, 0x0c, 0xd5, 0x54, 0x23, 0x92,
|
|
0x9b, 0x06, 0x81, 0xca, 0xa5, 0x1e, 0x91, 0x7e, 0x2b, 0x85, 0xb4, 0xd4, 0xeb, 0xb6, 0xee, 0x22,
|
|
0x10, 0x72, 0xaf, 0x9e, 0x6d, 0xcc, 0x16, 0x24, 0x01, 0x44, 0x48, 0xaa, 0xc9, 0xf8, 0x38, 0x72,
|
|
0x7a, 0x35, 0x94, 0x20, 0x58, 0xa2, 0x1c, 0x81, 0xaf, 0x47, 0x3b, 0xb8, 0x23, 0xbb, 0x71, 0x09,
|
|
0xbf, 0x93
|
|
};
|
|
#endif
|
|
#if defined(LTC_RC2)
|
|
static const unsigned char long_pri_pkcs8_pbkdf2_rc2_cbc[] = {
|
|
0x30, 0x82, 0x01, 0x76, 0x30, 0x48, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x05,
|
|
0x0d, 0x30, 0x3b, 0x30, 0x1e, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x05, 0x0c,
|
|
0x30, 0x11, 0x04, 0x08, 0xbf, 0xef, 0x1a, 0x42, 0x5d, 0xc3, 0x6b, 0x0f, 0x02, 0x02, 0x08, 0x00,
|
|
0x02, 0x01, 0x10, 0x30, 0x19, 0x06, 0x08, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x03, 0x02, 0x30,
|
|
0x0d, 0x02, 0x01, 0x3a, 0x04, 0x08, 0xfe, 0xf2, 0x09, 0x0c, 0xa4, 0xd0, 0xe6, 0x83, 0x04, 0x82,
|
|
0x01, 0x28, 0x61, 0x18, 0x73, 0xb7, 0x9d, 0x58, 0xc8, 0x4a, 0xf4, 0x24, 0xec, 0xb4, 0xe6, 0x24,
|
|
0xa7, 0xf0, 0x1e, 0xea, 0xc3, 0x57, 0x44, 0xb7, 0x5a, 0x77, 0xe5, 0x3c, 0x1c, 0x6a, 0x6b, 0x70,
|
|
0x6e, 0x64, 0x35, 0xa5, 0x5d, 0x32, 0xe3, 0xce, 0xe8, 0x79, 0xa4, 0x7f, 0x2b, 0xfc, 0xcb, 0x07,
|
|
0x62, 0xcd, 0xc9, 0x15, 0x30, 0xdf, 0x69, 0xae, 0xe8, 0xb4, 0x83, 0xec, 0x2a, 0xaf, 0xb3, 0x29,
|
|
0x92, 0x77, 0xf3, 0x31, 0x4d, 0x5f, 0xcb, 0xea, 0xa2, 0x4d, 0xfb, 0xa1, 0x68, 0xbe, 0x00, 0x01,
|
|
0x6d, 0x3f, 0xc6, 0xc1, 0x13, 0xee, 0xb0, 0x5a, 0x52, 0xce, 0xdc, 0x12, 0xf8, 0x42, 0x22, 0x2f,
|
|
0x57, 0x2e, 0x54, 0xac, 0x48, 0x31, 0x4d, 0x3c, 0xa1, 0x97, 0x5e, 0x17, 0x74, 0x88, 0x9b, 0x31,
|
|
0x91, 0x69, 0x00, 0x00, 0x15, 0x2c, 0xc2, 0xac, 0x70, 0x84, 0x9c, 0x7e, 0x5d, 0xc9, 0xee, 0x06,
|
|
0xcc, 0x38, 0x9d, 0x7d, 0xea, 0x71, 0xc3, 0x4f, 0x99, 0x08, 0xde, 0xb0, 0x1b, 0x3b, 0x2a, 0xbd,
|
|
0x7e, 0x01, 0x3b, 0x5e, 0xe5, 0xc2, 0x54, 0xf2, 0x30, 0xe5, 0xa0, 0xf3, 0x69, 0x87, 0x77, 0xed,
|
|
0xa1, 0x37, 0x76, 0x6a, 0xec, 0xe2, 0x9c, 0x8d, 0x4c, 0xe9, 0xf4, 0xd0, 0xca, 0xb5, 0x8f, 0xd0,
|
|
0x63, 0x17, 0x41, 0xcb, 0x29, 0x58, 0x4f, 0x2a, 0xd1, 0xe1, 0x03, 0x73, 0x09, 0xcc, 0x93, 0xc6,
|
|
0xde, 0x1e, 0x34, 0x0f, 0xb3, 0x67, 0xfd, 0x5e, 0x49, 0x16, 0x84, 0x84, 0x6a, 0x8f, 0x55, 0x22,
|
|
0x0b, 0xe4, 0xd8, 0xee, 0x2e, 0x9f, 0x25, 0x19, 0x89, 0x19, 0xe6, 0x8d, 0x64, 0x31, 0x38, 0x68,
|
|
0xfa, 0x40, 0x84, 0xca, 0x39, 0xef, 0x1a, 0x4a, 0xe9, 0x04, 0xee, 0xcc, 0x4a, 0xea, 0x19, 0x96,
|
|
0xa4, 0xcd, 0x62, 0x76, 0xb3, 0xc4, 0x2c, 0x23, 0x75, 0x24, 0xcd, 0x49, 0xe2, 0x17, 0x81, 0x45,
|
|
0x24, 0x55, 0xeb, 0xe1, 0xb4, 0xeb, 0xda, 0xc5, 0x56, 0xac, 0xfa, 0x30, 0xbd, 0x05, 0xbb, 0x03,
|
|
0x65, 0x50, 0xdc, 0xbf, 0xdf, 0xff, 0x2a, 0x80, 0x85, 0x6d, 0x6a, 0x5c, 0x93, 0xb8, 0x81, 0xc4,
|
|
0xca, 0x91, 0x08, 0x7b, 0x8a, 0x9d, 0xe9, 0x2d, 0xfc, 0x3b
|
|
};
|
|
#endif
|
|
#if defined(LTC_SHA224) && defined(LTC_DES)
|
|
static const unsigned char long_pri_pkcs8_pbkdf2_sha224_des_ede3_cbc[] = {
|
|
0x30, 0x82, 0x01, 0x7c, 0x30, 0x4e, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x05,
|
|
0x0d, 0x30, 0x41, 0x30, 0x29, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x05, 0x0c,
|
|
0x30, 0x1c, 0x04, 0x08, 0xb2, 0x82, 0x71, 0xc5, 0xd6, 0x3c, 0x2b, 0x92, 0x02, 0x02, 0x08, 0x00,
|
|
0x30, 0x0c, 0x06, 0x08, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x02, 0x08, 0x05, 0x00, 0x30, 0x14,
|
|
0x06, 0x08, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x03, 0x07, 0x04, 0x08, 0x4a, 0x46, 0x2a, 0xa9,
|
|
0xd5, 0x9f, 0x79, 0xea, 0x04, 0x82, 0x01, 0x28, 0xc4, 0x27, 0x05, 0xa8, 0x01, 0xa7, 0xc9, 0x0d,
|
|
0x0e, 0x74, 0x06, 0x4a, 0xb8, 0x07, 0x9f, 0x7b, 0x0f, 0x82, 0xfd, 0x2c, 0xb5, 0x4f, 0x63, 0xed,
|
|
0xed, 0x86, 0x96, 0x79, 0x08, 0x2d, 0x5f, 0x6d, 0x8c, 0x83, 0xc9, 0xcc, 0xd4, 0x9b, 0x0a, 0x81,
|
|
0x60, 0x22, 0x09, 0xb9, 0x12, 0xca, 0xf1, 0xad, 0x61, 0x22, 0xf0, 0x6b, 0xdb, 0x52, 0x99, 0xae,
|
|
0x70, 0x2b, 0x61, 0x63, 0xdc, 0x2f, 0xc1, 0xd3, 0xb5, 0x28, 0xbb, 0xa1, 0xd2, 0xb7, 0xaf, 0xbb,
|
|
0x86, 0xa1, 0x1b, 0x46, 0x0a, 0xc9, 0xab, 0x44, 0xd2, 0x9c, 0x16, 0x18, 0x8b, 0x4a, 0x92, 0x56,
|
|
0x5b, 0x50, 0x39, 0x1b, 0x88, 0x50, 0x92, 0x35, 0xb8, 0x85, 0xc3, 0xaa, 0x56, 0x76, 0xde, 0xbf,
|
|
0x68, 0x91, 0x2e, 0xc8, 0x28, 0x29, 0xd8, 0x71, 0x60, 0xe3, 0xf0, 0x5a, 0x66, 0x85, 0xdd, 0x6b,
|
|
0x5c, 0xaf, 0xf1, 0x28, 0xf8, 0xdc, 0xa7, 0x8d, 0xc4, 0x9b, 0xcb, 0xb2, 0x99, 0x34, 0x4d, 0x76,
|
|
0xa0, 0x8b, 0xf2, 0x18, 0x8e, 0x42, 0xe0, 0x79, 0xc3, 0xeb, 0x0f, 0x00, 0xe7, 0xbe, 0x83, 0xdf,
|
|
0xba, 0xa5, 0xf1, 0x81, 0x05, 0x1c, 0xc9, 0xda, 0xea, 0xe1, 0xc4, 0x38, 0x24, 0x1e, 0xcf, 0xea,
|
|
0x22, 0x05, 0x75, 0x43, 0xfe, 0xfe, 0x14, 0xf7, 0x6d, 0x41, 0x67, 0xcf, 0xfd, 0x57, 0xa7, 0xfc,
|
|
0x22, 0x03, 0x14, 0xc1, 0xf6, 0x4d, 0x40, 0x4e, 0xf1, 0xec, 0x72, 0xec, 0x3c, 0xb1, 0x87, 0x44,
|
|
0xe9, 0x72, 0xc5, 0x8b, 0x48, 0xd9, 0x98, 0x08, 0x55, 0xc5, 0x40, 0x26, 0xf5, 0x8d, 0x73, 0x5e,
|
|
0x35, 0x98, 0x71, 0x09, 0x98, 0xfa, 0xb7, 0x1c, 0x35, 0xcd, 0xd4, 0xf1, 0x65, 0xb4, 0x59, 0xdb,
|
|
0x9e, 0x79, 0xe7, 0x21, 0x99, 0xd7, 0x9e, 0x8c, 0x13, 0x77, 0x0c, 0x5e, 0xae, 0x43, 0x82, 0xf1,
|
|
0x83, 0x79, 0x7d, 0x37, 0x51, 0xde, 0x65, 0x26, 0x1f, 0x8f, 0x81, 0x1c, 0x55, 0x40, 0xec, 0xaf,
|
|
0x3f, 0x0a, 0x68, 0xd2, 0xc7, 0x59, 0x47, 0xda, 0x78, 0x0c, 0x0e, 0x59, 0x6a, 0x93, 0xcd, 0x05,
|
|
0x09, 0x51, 0x47, 0xb1, 0x45, 0x3f, 0x67, 0xf8, 0x76, 0x50, 0x76, 0xa3, 0x2d, 0x31, 0x17, 0x73
|
|
};
|
|
#endif
|
|
#if defined(LTC_SHA256) && defined(LTC_DES)
|
|
static const unsigned char long_pri_pkcs8_pbkdf2_sha256_des_ede3_cbc[] = {
|
|
0x30, 0x82, 0x01, 0x7c, 0x30, 0x4e, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x05,
|
|
0x0d, 0x30, 0x41, 0x30, 0x29, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x05, 0x0c,
|
|
0x30, 0x1c, 0x04, 0x08, 0x93, 0x6e, 0x0a, 0x02, 0x8e, 0x72, 0xac, 0x98, 0x02, 0x02, 0x08, 0x00,
|
|
0x30, 0x0c, 0x06, 0x08, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x02, 0x09, 0x05, 0x00, 0x30, 0x14,
|
|
0x06, 0x08, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x03, 0x07, 0x04, 0x08, 0x89, 0xa4, 0xc9, 0xd9,
|
|
0x82, 0xfa, 0x02, 0x76, 0x04, 0x82, 0x01, 0x28, 0xec, 0xd9, 0xee, 0xbf, 0xfa, 0xe6, 0x51, 0xdb,
|
|
0x02, 0xcb, 0xf3, 0x2c, 0x55, 0xdb, 0x83, 0x90, 0x5d, 0x9e, 0xf6, 0xbe, 0x10, 0xae, 0x35, 0x8c,
|
|
0x22, 0x39, 0xfc, 0xf9, 0xd1, 0x23, 0x27, 0x68, 0xd3, 0x15, 0x46, 0xed, 0x5d, 0x15, 0xfb, 0xdf,
|
|
0x6f, 0xe1, 0x01, 0x1c, 0xed, 0x4c, 0xfc, 0x78, 0x94, 0x47, 0x71, 0x92, 0xbc, 0xa1, 0xa6, 0x06,
|
|
0x74, 0x22, 0xcc, 0xbb, 0x49, 0x98, 0x43, 0xf1, 0xc2, 0xde, 0x4e, 0xeb, 0x56, 0x0e, 0x03, 0xc1,
|
|
0xf1, 0xc1, 0x80, 0x4b, 0x70, 0xd0, 0x8f, 0xf3, 0xd8, 0x18, 0x08, 0x41, 0x7a, 0xf9, 0x8b, 0x74,
|
|
0xe5, 0x28, 0x61, 0x77, 0x2f, 0x84, 0xb3, 0xb3, 0x68, 0xce, 0x19, 0xf0, 0xc6, 0xa9, 0xc1, 0x29,
|
|
0x96, 0xca, 0x3b, 0xdb, 0x13, 0x99, 0x86, 0xbe, 0x21, 0x0d, 0x00, 0xd7, 0x30, 0x15, 0x74, 0xfb,
|
|
0x43, 0xf7, 0x14, 0x97, 0x6d, 0xed, 0xeb, 0xe3, 0x4d, 0x67, 0x80, 0x35, 0x03, 0x69, 0x0d, 0xbe,
|
|
0xf1, 0x99, 0x6b, 0x53, 0xb7, 0xa3, 0xdf, 0xf4, 0xc3, 0xda, 0x20, 0x9b, 0xbf, 0xf9, 0x3f, 0x19,
|
|
0xae, 0xd5, 0x37, 0x91, 0x36, 0x42, 0xf3, 0x7d, 0xad, 0x40, 0x3c, 0x2a, 0x7f, 0x2d, 0xf1, 0x79,
|
|
0xee, 0x4c, 0x08, 0x3a, 0xd6, 0x35, 0x9b, 0xc9, 0xff, 0xd8, 0x41, 0x41, 0xd1, 0xc6, 0xa1, 0xba,
|
|
0x4d, 0xc6, 0xb7, 0x85, 0x05, 0xa1, 0x8e, 0xeb, 0xd1, 0xd2, 0x3a, 0x13, 0xd7, 0xbd, 0xb0, 0x02,
|
|
0xfe, 0x54, 0xfe, 0xf4, 0xfd, 0x31, 0x0c, 0x42, 0x78, 0xb9, 0x17, 0x90, 0x36, 0x17, 0xb8, 0x1a,
|
|
0x08, 0xe8, 0x7e, 0x5f, 0xbb, 0x30, 0xc2, 0xec, 0xd5, 0x08, 0xbc, 0xae, 0x2f, 0xe0, 0xca, 0xf2,
|
|
0x44, 0x2c, 0xa4, 0xb5, 0xec, 0xb9, 0xc2, 0xa3, 0x4a, 0x1a, 0x49, 0xfb, 0x3e, 0x5c, 0xb5, 0xd8,
|
|
0xb6, 0xf0, 0xbc, 0xa2, 0xda, 0xaa, 0x7a, 0x05, 0x4d, 0x06, 0xc0, 0x4b, 0x8f, 0x59, 0xce, 0x56,
|
|
0x02, 0x26, 0xb2, 0xa0, 0x5f, 0x74, 0xbb, 0x0b, 0x01, 0x1c, 0xb2, 0x0b, 0x8a, 0x80, 0xa4, 0x5d,
|
|
0x6e, 0x52, 0x24, 0xd0, 0xbe, 0xf5, 0x8e, 0x9e, 0x9e, 0x02, 0x40, 0x08, 0x99, 0xe0, 0x2c, 0xf9
|
|
};
|
|
#endif
|
|
#if defined(LTC_SHA384) && defined(LTC_DES)
|
|
static const unsigned char long_pri_pkcs8_pbkdf2_sha384_des_ede3_cbc[] = {
|
|
0x30, 0x82, 0x01, 0x7c, 0x30, 0x4e, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x05,
|
|
0x0d, 0x30, 0x41, 0x30, 0x29, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x05, 0x0c,
|
|
0x30, 0x1c, 0x04, 0x08, 0xfd, 0x6c, 0xdf, 0x0b, 0x23, 0xed, 0x71, 0xf7, 0x02, 0x02, 0x08, 0x00,
|
|
0x30, 0x0c, 0x06, 0x08, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x02, 0x0a, 0x05, 0x00, 0x30, 0x14,
|
|
0x06, 0x08, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x03, 0x07, 0x04, 0x08, 0x99, 0xd0, 0x84, 0x7d,
|
|
0x6d, 0x4e, 0x82, 0xe1, 0x04, 0x82, 0x01, 0x28, 0xac, 0x9a, 0x2c, 0x71, 0xdf, 0x1a, 0x19, 0x38,
|
|
0xee, 0xc4, 0x9d, 0x7a, 0x27, 0xe0, 0xb9, 0x69, 0x32, 0xed, 0xe7, 0xa1, 0x77, 0x16, 0x60, 0x18,
|
|
0x7a, 0xf1, 0x47, 0xc1, 0x98, 0x48, 0xa4, 0xff, 0xab, 0x83, 0x1a, 0x7d, 0xe3, 0xdb, 0xcc, 0xf0,
|
|
0x40, 0x94, 0x3a, 0x6a, 0x3f, 0xf7, 0x88, 0x19, 0x59, 0xf4, 0xd8, 0x1b, 0x87, 0x14, 0x5b, 0x9c,
|
|
0x1f, 0xc5, 0xaf, 0x80, 0xe8, 0x06, 0xdb, 0xfa, 0x2c, 0xac, 0x61, 0x1c, 0xec, 0xec, 0x99, 0x5e,
|
|
0x06, 0x6e, 0x68, 0x4c, 0xb0, 0xc8, 0x6f, 0x74, 0x2c, 0x1e, 0x58, 0x2f, 0x49, 0x82, 0xa4, 0x2b,
|
|
0xb4, 0x4a, 0x2d, 0x77, 0x13, 0x87, 0xed, 0xbd, 0x71, 0x5a, 0x29, 0x29, 0x0c, 0x88, 0x4a, 0xf3,
|
|
0x76, 0x37, 0x7e, 0x04, 0x3c, 0x45, 0x76, 0x98, 0x22, 0x20, 0x97, 0xef, 0xae, 0x4a, 0xa9, 0x08,
|
|
0x54, 0xef, 0x43, 0xe0, 0x86, 0x54, 0x72, 0x44, 0xd1, 0x25, 0x9c, 0xb6, 0x7d, 0x88, 0xbd, 0x8f,
|
|
0xbe, 0xcb, 0xa8, 0x63, 0xfe, 0x66, 0x54, 0xa2, 0xce, 0x77, 0x19, 0x7e, 0xdd, 0xf7, 0x4d, 0xdc,
|
|
0xb1, 0xf7, 0xbf, 0x3c, 0xb5, 0xd2, 0x30, 0x9d, 0x3c, 0x35, 0x09, 0x37, 0xae, 0xae, 0x0f, 0x0b,
|
|
0x9d, 0xf5, 0x10, 0xae, 0x56, 0x83, 0x4f, 0xd8, 0xcd, 0xfe, 0xb7, 0xa9, 0x54, 0xf9, 0xb3, 0x89,
|
|
0xf6, 0x9a, 0x11, 0x60, 0x04, 0x4d, 0x80, 0xaf, 0x74, 0x73, 0x2d, 0xc4, 0x24, 0x23, 0xaa, 0x50,
|
|
0x4c, 0xf1, 0xd6, 0x2d, 0xc6, 0x74, 0xeb, 0x62, 0x02, 0xda, 0x81, 0x68, 0xc8, 0x68, 0xf0, 0x82,
|
|
0x71, 0xb2, 0xa5, 0x8e, 0x45, 0x93, 0x29, 0x94, 0x8f, 0xec, 0x11, 0x65, 0xcc, 0xd6, 0x4c, 0x2e,
|
|
0x0d, 0x4e, 0x45, 0xb4, 0x4e, 0x97, 0x38, 0xd0, 0xc2, 0x61, 0x43, 0x78, 0xa4, 0x08, 0x0a, 0x58,
|
|
0x3f, 0x66, 0xdb, 0x34, 0x42, 0x17, 0x42, 0x92, 0x04, 0x9a, 0x2d, 0x73, 0xaf, 0x58, 0x38, 0xc8,
|
|
0x3f, 0x5b, 0x83, 0x95, 0x3d, 0xae, 0xae, 0x60, 0x2b, 0x6d, 0xd9, 0xb4, 0xe3, 0x97, 0x6b, 0x49,
|
|
0xef, 0xd9, 0x68, 0xbb, 0x8d, 0x3a, 0x7e, 0xcb, 0x57, 0x33, 0xf5, 0x1a, 0x8d, 0xb4, 0x6d, 0xfb
|
|
};
|
|
#endif
|
|
#if defined(LTC_SHA512) && defined(LTC_DES)
|
|
static const unsigned char long_pri_pkcs8_pbkdf2_sha512_des_ede3_cbc[] = {
|
|
0x30, 0x82, 0x01, 0x7c, 0x30, 0x4e, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x05,
|
|
0x0d, 0x30, 0x41, 0x30, 0x29, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x05, 0x0c,
|
|
0x30, 0x1c, 0x04, 0x08, 0xad, 0xb1, 0xe1, 0x21, 0xdc, 0xe5, 0x09, 0xee, 0x02, 0x02, 0x08, 0x00,
|
|
0x30, 0x0c, 0x06, 0x08, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x02, 0x0b, 0x05, 0x00, 0x30, 0x14,
|
|
0x06, 0x08, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x03, 0x07, 0x04, 0x08, 0x1a, 0x8b, 0x81, 0x3b,
|
|
0x97, 0x7d, 0xfa, 0x51, 0x04, 0x82, 0x01, 0x28, 0x6d, 0x6f, 0x93, 0x77, 0xcb, 0x52, 0x2d, 0x3b,
|
|
0x82, 0x12, 0x80, 0xce, 0x9e, 0x69, 0x03, 0xe4, 0x64, 0xa1, 0x4b, 0x8e, 0x60, 0x51, 0x4d, 0x08,
|
|
0xe1, 0x25, 0x5d, 0xe6, 0xed, 0x20, 0x23, 0x4c, 0x4e, 0xa3, 0xe8, 0xab, 0x7a, 0xf8, 0x54, 0x65,
|
|
0x22, 0x92, 0x0c, 0x45, 0xab, 0x1c, 0xe2, 0x68, 0x4e, 0xf3, 0xa9, 0x61, 0xd6, 0x44, 0x9d, 0x55,
|
|
0x19, 0xc6, 0xd9, 0x2a, 0x0d, 0x45, 0x7d, 0xca, 0xa4, 0x41, 0xb5, 0x6d, 0xd5, 0x09, 0xf2, 0xb6,
|
|
0x81, 0x95, 0x64, 0xdb, 0x2b, 0xed, 0x83, 0x6b, 0x44, 0xa6, 0xce, 0x36, 0x8d, 0x23, 0x89, 0xb6,
|
|
0xf3, 0xb0, 0xe0, 0xcf, 0x57, 0x72, 0xc7, 0x61, 0x3f, 0x29, 0xb9, 0xea, 0xe8, 0x7a, 0xca, 0x43,
|
|
0x90, 0x79, 0x81, 0x8a, 0xe2, 0x3c, 0xd1, 0xa6, 0xd9, 0x09, 0xd8, 0x7d, 0xd0, 0x90, 0x69, 0x7e,
|
|
0xdd, 0x40, 0xde, 0xba, 0x11, 0xc6, 0x6f, 0x75, 0xfc, 0xc3, 0x99, 0x43, 0xd2, 0xa4, 0x16, 0x2e,
|
|
0x95, 0x99, 0x12, 0x77, 0xe8, 0x86, 0x9a, 0xf9, 0x97, 0xf4, 0x43, 0x99, 0x1d, 0x7b, 0xe0, 0x69,
|
|
0xb0, 0xe9, 0x45, 0xd0, 0x0b, 0xaa, 0xd0, 0xa9, 0x90, 0x85, 0x39, 0xd9, 0xe0, 0xe4, 0xe5, 0xf3,
|
|
0xcf, 0xb6, 0x60, 0x63, 0x51, 0x0b, 0xd8, 0x3d, 0xa2, 0x0f, 0xf6, 0x53, 0x09, 0x2e, 0x11, 0xc4,
|
|
0xe6, 0xe3, 0xfa, 0xfb, 0x9f, 0x4d, 0xf4, 0xef, 0xb2, 0xf6, 0x9b, 0xc6, 0xb3, 0x75, 0x66, 0xfd,
|
|
0x1b, 0x44, 0xba, 0x3c, 0xa8, 0x51, 0xbe, 0x97, 0xf1, 0x54, 0xb5, 0xcc, 0x6f, 0x5f, 0x1d, 0x9b,
|
|
0xee, 0xed, 0x7a, 0x82, 0xfa, 0x40, 0x39, 0xa7, 0xf5, 0x8e, 0x5e, 0x42, 0xfa, 0x37, 0xcc, 0xe8,
|
|
0x99, 0x38, 0xc1, 0xab, 0x83, 0xb8, 0x3c, 0x25, 0x17, 0x5f, 0xb7, 0x45, 0x0f, 0xcd, 0xec, 0x2a,
|
|
0x47, 0x07, 0x02, 0xba, 0x92, 0xc1, 0x79, 0xf1, 0x95, 0xc7, 0x83, 0x46, 0xd7, 0x9e, 0x04, 0x96,
|
|
0x3c, 0x5d, 0x7e, 0x70, 0xe6, 0x2b, 0x72, 0x70, 0x42, 0x66, 0x17, 0x0e, 0xc3, 0xcf, 0x32, 0x28,
|
|
0x0c, 0xf9, 0x46, 0x38, 0xb7, 0x64, 0xd6, 0x51, 0xf9, 0xbd, 0x57, 0xf2, 0x7a, 0xcc, 0x02, 0xe3
|
|
};
|
|
#endif
|
|
static const unsigned char long_pric[] = { /* private + compressed public, explicit curve params */
|
|
0x30, 0x81, 0xd3, 0x02, 0x01, 0x01, 0x04, 0x20, 0x0c, 0xf1, 0xad, 0x2f, 0x03, 0xf7, 0x91, 0x1b,
|
|
0xba, 0x03, 0xcf, 0x23, 0x37, 0xc8, 0xf2, 0xf7, 0x36, 0xce, 0x65, 0xf1, 0x84, 0x2d, 0x7d, 0x9f,
|
|
0x5f, 0x9e, 0x21, 0xd9, 0x5e, 0x49, 0xbd, 0x23, 0xa0, 0x81, 0x85, 0x30, 0x81, 0x82, 0x02, 0x01,
|
|
0x01, 0x30, 0x2c, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x01, 0x01, 0x02, 0x21, 0x00, 0xff,
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x2f, 0x30,
|
|
0x06, 0x04, 0x01, 0x00, 0x04, 0x01, 0x07, 0x04, 0x21, 0x02, 0x79, 0xbe, 0x66, 0x7e, 0xf9, 0xdc,
|
|
0xbb, 0xac, 0x55, 0xa0, 0x62, 0x95, 0xce, 0x87, 0x0b, 0x07, 0x02, 0x9b, 0xfc, 0xdb, 0x2d, 0xce,
|
|
0x28, 0xd9, 0x59, 0xf2, 0x81, 0x5b, 0x16, 0xf8, 0x17, 0x98, 0x02, 0x21, 0x00, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xba, 0xae, 0xdc,
|
|
0xe6, 0xaf, 0x48, 0xa0, 0x3b, 0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41, 0x41, 0x02, 0x01, 0x01,
|
|
0xa1, 0x24, 0x03, 0x22, 0x00, 0x03, 0x2a, 0xf9, 0x0b, 0xda, 0xbe, 0x71, 0x66, 0x9e, 0xd1, 0xcf,
|
|
0x12, 0xd0, 0x24, 0xaf, 0xba, 0xb6, 0x7f, 0xfb, 0x96, 0x27, 0x3e, 0x2f, 0xbd, 0x1e, 0xd5, 0xf9,
|
|
0x8d, 0x6c, 0x73, 0x9d, 0xc5, 0x16
|
|
};
|
|
static const unsigned char long_pric_pkcs8[] = { /* private + compressed public, explicit curve params, PKCS8 */
|
|
0x30, 0x81, 0xe3, 0x02, 0x01, 0x00, 0x30, 0x81, 0x8e, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d,
|
|
0x02, 0x01, 0x30, 0x81, 0x82, 0x02, 0x01, 0x01, 0x30, 0x2c, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce,
|
|
0x3d, 0x01, 0x01, 0x02, 0x21, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xfe, 0xff, 0xff, 0xfc, 0x2f, 0x30, 0x06, 0x04, 0x01, 0x00, 0x04, 0x01, 0x07, 0x04, 0x21,
|
|
0x02, 0x79, 0xbe, 0x66, 0x7e, 0xf9, 0xdc, 0xbb, 0xac, 0x55, 0xa0, 0x62, 0x95, 0xce, 0x87, 0x0b,
|
|
0x07, 0x02, 0x9b, 0xfc, 0xdb, 0x2d, 0xce, 0x28, 0xd9, 0x59, 0xf2, 0x81, 0x5b, 0x16, 0xf8, 0x17,
|
|
0x98, 0x02, 0x21, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xfe, 0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0, 0x3b, 0xbf, 0xd2, 0x5e, 0x8c,
|
|
0xd0, 0x36, 0x41, 0x41, 0x02, 0x01, 0x01, 0x04, 0x4d, 0x30, 0x4b, 0x02, 0x01, 0x01, 0x04, 0x20,
|
|
0x0c, 0xf1, 0xad, 0x2f, 0x03, 0xf7, 0x91, 0x1b, 0xba, 0x03, 0xcf, 0x23, 0x37, 0xc8, 0xf2, 0xf7,
|
|
0x36, 0xce, 0x65, 0xf1, 0x84, 0x2d, 0x7d, 0x9f, 0x5f, 0x9e, 0x21, 0xd9, 0x5e, 0x49, 0xbd, 0x23,
|
|
0xa1, 0x24, 0x03, 0x22, 0x00, 0x03, 0x2a, 0xf9, 0x0b, 0xda, 0xbe, 0x71, 0x66, 0x9e, 0xd1, 0xcf,
|
|
0x12, 0xd0, 0x24, 0xaf, 0xba, 0xb6, 0x7f, 0xfb, 0x96, 0x27, 0x3e, 0x2f, 0xbd, 0x1e, 0xd5, 0xf9,
|
|
0x8d, 0x6c, 0x73, 0x9d, 0xc5, 0x16
|
|
};
|
|
static const unsigned char long_pub[] = { /* long public, explicit curve params */
|
|
0x30, 0x81, 0xf5, 0x30, 0x81, 0xae, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01, 0x30,
|
|
0x81, 0xa2, 0x02, 0x01, 0x01, 0x30, 0x2c, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x01, 0x01,
|
|
0x02, 0x21, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff,
|
|
0xff, 0xfc, 0x2f, 0x30, 0x06, 0x04, 0x01, 0x00, 0x04, 0x01, 0x07, 0x04, 0x41, 0x04, 0x79, 0xbe,
|
|
0x66, 0x7e, 0xf9, 0xdc, 0xbb, 0xac, 0x55, 0xa0, 0x62, 0x95, 0xce, 0x87, 0x0b, 0x07, 0x02, 0x9b,
|
|
0xfc, 0xdb, 0x2d, 0xce, 0x28, 0xd9, 0x59, 0xf2, 0x81, 0x5b, 0x16, 0xf8, 0x17, 0x98, 0x48, 0x3a,
|
|
0xda, 0x77, 0x26, 0xa3, 0xc4, 0x65, 0x5d, 0xa4, 0xfb, 0xfc, 0x0e, 0x11, 0x08, 0xa8, 0xfd, 0x17,
|
|
0xb4, 0x48, 0xa6, 0x85, 0x54, 0x19, 0x9c, 0x47, 0xd0, 0x8f, 0xfb, 0x10, 0xd4, 0xb8, 0x02, 0x21,
|
|
0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
0xfe, 0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0, 0x3b, 0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41,
|
|
0x41, 0x02, 0x01, 0x01, 0x03, 0x42, 0x00, 0x04, 0x2a, 0xf9, 0x0b, 0xda, 0xbe, 0x71, 0x66, 0x9e,
|
|
0xd1, 0xcf, 0x12, 0xd0, 0x24, 0xaf, 0xba, 0xb6, 0x7f, 0xfb, 0x96, 0x27, 0x3e, 0x2f, 0xbd, 0x1e,
|
|
0xd5, 0xf9, 0x8d, 0x6c, 0x73, 0x9d, 0xc5, 0x16, 0x91, 0xbd, 0xb2, 0xb9, 0x1b, 0x40, 0x10, 0x5a,
|
|
0xb7, 0x6c, 0x6e, 0x32, 0x5b, 0xf7, 0x63, 0x62, 0x94, 0x24, 0x24, 0xdb, 0xec, 0x3f, 0x8b, 0xe5,
|
|
0x6e, 0x4b, 0x64, 0x37, 0x31, 0x24, 0x79, 0x4d
|
|
};
|
|
static const unsigned char long_pubc[] = { /* compressed public, explicit curve params */
|
|
0x30, 0x81, 0xb5, 0x30, 0x81, 0x8e, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01, 0x30,
|
|
0x81, 0x82, 0x02, 0x01, 0x01, 0x30, 0x2c, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x01, 0x01,
|
|
0x02, 0x21, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff,
|
|
0xff, 0xfc, 0x2f, 0x30, 0x06, 0x04, 0x01, 0x00, 0x04, 0x01, 0x07, 0x04, 0x21, 0x02, 0x79, 0xbe,
|
|
0x66, 0x7e, 0xf9, 0xdc, 0xbb, 0xac, 0x55, 0xa0, 0x62, 0x95, 0xce, 0x87, 0x0b, 0x07, 0x02, 0x9b,
|
|
0xfc, 0xdb, 0x2d, 0xce, 0x28, 0xd9, 0x59, 0xf2, 0x81, 0x5b, 0x16, 0xf8, 0x17, 0x98, 0x02, 0x21,
|
|
0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
0xfe, 0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0, 0x3b, 0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41,
|
|
0x41, 0x02, 0x01, 0x01, 0x03, 0x22, 0x00, 0x03, 0x2a, 0xf9, 0x0b, 0xda, 0xbe, 0x71, 0x66, 0x9e,
|
|
0xd1, 0xcf, 0x12, 0xd0, 0x24, 0xaf, 0xba, 0xb6, 0x7f, 0xfb, 0x96, 0x27, 0x3e, 0x2f, 0xbd, 0x1e,
|
|
0xd5, 0xf9, 0x8d, 0x6c, 0x73, 0x9d, 0xc5, 0x16
|
|
};
|
|
static const unsigned char short_pri[] = { /* private + long public, curve by OID */
|
|
0x30, 0x74, 0x02, 0x01, 0x01, 0x04, 0x20, 0x0c, 0xf1, 0xad, 0x2f, 0x03, 0xf7, 0x91, 0x1b, 0xba,
|
|
0x03, 0xcf, 0x23, 0x37, 0xc8, 0xf2, 0xf7, 0x36, 0xce, 0x65, 0xf1, 0x84, 0x2d, 0x7d, 0x9f, 0x5f,
|
|
0x9e, 0x21, 0xd9, 0x5e, 0x49, 0xbd, 0x23, 0xa0, 0x07, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x0a,
|
|
0xa1, 0x44, 0x03, 0x42, 0x00, 0x04, 0x2a, 0xf9, 0x0b, 0xda, 0xbe, 0x71, 0x66, 0x9e, 0xd1, 0xcf,
|
|
0x12, 0xd0, 0x24, 0xaf, 0xba, 0xb6, 0x7f, 0xfb, 0x96, 0x27, 0x3e, 0x2f, 0xbd, 0x1e, 0xd5, 0xf9,
|
|
0x8d, 0x6c, 0x73, 0x9d, 0xc5, 0x16, 0x91, 0xbd, 0xb2, 0xb9, 0x1b, 0x40, 0x10, 0x5a, 0xb7, 0x6c,
|
|
0x6e, 0x32, 0x5b, 0xf7, 0x63, 0x62, 0x94, 0x24, 0x24, 0xdb, 0xec, 0x3f, 0x8b, 0xe5, 0x6e, 0x4b,
|
|
0x64, 0x37, 0x31, 0x24, 0x79, 0x4d
|
|
};
|
|
static const unsigned char short_pri_pkcs8[] = { /* private + long public, curve by OID, PKCS8 */
|
|
0x30, 0x81, 0x84, 0x02, 0x01, 0x00, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
|
|
0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x0a, 0x04, 0x6d, 0x30, 0x6b, 0x02, 0x01, 0x01, 0x04,
|
|
0x20, 0x0c, 0xf1, 0xad, 0x2f, 0x03, 0xf7, 0x91, 0x1b, 0xba, 0x03, 0xcf, 0x23, 0x37, 0xc8, 0xf2,
|
|
0xf7, 0x36, 0xce, 0x65, 0xf1, 0x84, 0x2d, 0x7d, 0x9f, 0x5f, 0x9e, 0x21, 0xd9, 0x5e, 0x49, 0xbd,
|
|
0x23, 0xa1, 0x44, 0x03, 0x42, 0x00, 0x04, 0x2a, 0xf9, 0x0b, 0xda, 0xbe, 0x71, 0x66, 0x9e, 0xd1,
|
|
0xcf, 0x12, 0xd0, 0x24, 0xaf, 0xba, 0xb6, 0x7f, 0xfb, 0x96, 0x27, 0x3e, 0x2f, 0xbd, 0x1e, 0xd5,
|
|
0xf9, 0x8d, 0x6c, 0x73, 0x9d, 0xc5, 0x16, 0x91, 0xbd, 0xb2, 0xb9, 0x1b, 0x40, 0x10, 0x5a, 0xb7,
|
|
0x6c, 0x6e, 0x32, 0x5b, 0xf7, 0x63, 0x62, 0x94, 0x24, 0x24, 0xdb, 0xec, 0x3f, 0x8b, 0xe5, 0x6e,
|
|
0x4b, 0x64, 0x37, 0x31, 0x24, 0x79, 0x4d
|
|
};
|
|
static const unsigned char short_pric[] = { /* private + compressed public, curve by OID */
|
|
0x30, 0x54, 0x02, 0x01, 0x01, 0x04, 0x20, 0x0c, 0xf1, 0xad, 0x2f, 0x03, 0xf7, 0x91, 0x1b, 0xba,
|
|
0x03, 0xcf, 0x23, 0x37, 0xc8, 0xf2, 0xf7, 0x36, 0xce, 0x65, 0xf1, 0x84, 0x2d, 0x7d, 0x9f, 0x5f,
|
|
0x9e, 0x21, 0xd9, 0x5e, 0x49, 0xbd, 0x23, 0xa0, 0x07, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x0a,
|
|
0xa1, 0x24, 0x03, 0x22, 0x00, 0x03, 0x2a, 0xf9, 0x0b, 0xda, 0xbe, 0x71, 0x66, 0x9e, 0xd1, 0xcf,
|
|
0x12, 0xd0, 0x24, 0xaf, 0xba, 0xb6, 0x7f, 0xfb, 0x96, 0x27, 0x3e, 0x2f, 0xbd, 0x1e, 0xd5, 0xf9,
|
|
0x8d, 0x6c, 0x73, 0x9d, 0xc5, 0x16
|
|
};
|
|
static const unsigned char short_pric_pkcs8[] = { /* private + compressed public, curve by OID, PKCS8 */
|
|
0x30, 0x64, 0x02, 0x01, 0x00, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01,
|
|
0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x0a, 0x04, 0x4d, 0x30, 0x4b, 0x02, 0x01, 0x01, 0x04, 0x20,
|
|
0x0c, 0xf1, 0xad, 0x2f, 0x03, 0xf7, 0x91, 0x1b, 0xba, 0x03, 0xcf, 0x23, 0x37, 0xc8, 0xf2, 0xf7,
|
|
0x36, 0xce, 0x65, 0xf1, 0x84, 0x2d, 0x7d, 0x9f, 0x5f, 0x9e, 0x21, 0xd9, 0x5e, 0x49, 0xbd, 0x23,
|
|
0xa1, 0x24, 0x03, 0x22, 0x00, 0x03, 0x2a, 0xf9, 0x0b, 0xda, 0xbe, 0x71, 0x66, 0x9e, 0xd1, 0xcf,
|
|
0x12, 0xd0, 0x24, 0xaf, 0xba, 0xb6, 0x7f, 0xfb, 0x96, 0x27, 0x3e, 0x2f, 0xbd, 0x1e, 0xd5, 0xf9,
|
|
0x8d, 0x6c, 0x73, 0x9d, 0xc5, 0x16
|
|
};
|
|
static const unsigned char short_pub[] = { /* long public, curve by OID */
|
|
0x30, 0x56, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01, 0x06, 0x05, 0x2b,
|
|
0x81, 0x04, 0x00, 0x0a, 0x03, 0x42, 0x00, 0x04, 0x2a, 0xf9, 0x0b, 0xda, 0xbe, 0x71, 0x66, 0x9e,
|
|
0xd1, 0xcf, 0x12, 0xd0, 0x24, 0xaf, 0xba, 0xb6, 0x7f, 0xfb, 0x96, 0x27, 0x3e, 0x2f, 0xbd, 0x1e,
|
|
0xd5, 0xf9, 0x8d, 0x6c, 0x73, 0x9d, 0xc5, 0x16, 0x91, 0xbd, 0xb2, 0xb9, 0x1b, 0x40, 0x10, 0x5a,
|
|
0xb7, 0x6c, 0x6e, 0x32, 0x5b, 0xf7, 0x63, 0x62, 0x94, 0x24, 0x24, 0xdb, 0xec, 0x3f, 0x8b, 0xe5,
|
|
0x6e, 0x4b, 0x64, 0x37, 0x31, 0x24, 0x79, 0x4d
|
|
};
|
|
static const unsigned char short_pubc[] = { /* compressed public, curve by OID */
|
|
0x30, 0x36, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01, 0x06, 0x05, 0x2b,
|
|
0x81, 0x04, 0x00, 0x0a, 0x03, 0x22, 0x00, 0x03, 0x2a, 0xf9, 0x0b, 0xda, 0xbe, 0x71, 0x66, 0x9e,
|
|
0xd1, 0xcf, 0x12, 0xd0, 0x24, 0xaf, 0xba, 0xb6, 0x7f, 0xfb, 0x96, 0x27, 0x3e, 0x2f, 0xbd, 0x1e,
|
|
0xd5, 0xf9, 0x8d, 0x6c, 0x73, 0x9d, 0xc5, 0x16
|
|
};
|
|
static const unsigned char raw_pri[] = { /* raw private key */
|
|
0x0c, 0xf1, 0xad, 0x2f, 0x03, 0xf7, 0x91, 0x1b, 0xba, 0x03, 0xcf, 0x23, 0x37, 0xc8, 0xf2, 0xf7,
|
|
0x36, 0xce, 0x65, 0xf1, 0x84, 0x2d, 0x7d, 0x9f, 0x5f, 0x9e, 0x21, 0xd9, 0x5e, 0x49, 0xbd, 0x23
|
|
};
|
|
static const unsigned char raw_pub[] = { /* raw public key - long form */
|
|
0x04, 0x2a, 0xf9, 0x0b, 0xda, 0xbe, 0x71, 0x66, 0x9e, 0xd1, 0xcf, 0x12, 0xd0, 0x24, 0xaf, 0xba,
|
|
0xb6, 0x7f, 0xfb, 0x96, 0x27, 0x3e, 0x2f, 0xbd, 0x1e, 0xd5, 0xf9, 0x8d, 0x6c, 0x73, 0x9d, 0xc5,
|
|
0x16, 0x91, 0xbd, 0xb2, 0xb9, 0x1b, 0x40, 0x10, 0x5a, 0xb7, 0x6c, 0x6e, 0x32, 0x5b, 0xf7, 0x63,
|
|
0x62, 0x94, 0x24, 0x24, 0xdb, 0xec, 0x3f, 0x8b, 0xe5, 0x6e, 0x4b, 0x64, 0x37, 0x31, 0x24, 0x79,
|
|
0x4d
|
|
};
|
|
static const unsigned char raw_pubc[] = { /* raw public key - compressed form */
|
|
0x03, 0x2a, 0xf9, 0x0b, 0xda, 0xbe, 0x71, 0x66, 0x9e, 0xd1, 0xcf, 0x12, 0xd0, 0x24, 0xaf, 0xba,
|
|
0xb6, 0x7f, 0xfb, 0x96, 0x27, 0x3e, 0x2f, 0xbd, 0x1e, 0xd5, 0xf9, 0x8d, 0x6c, 0x73, 0x9d, 0xc5,
|
|
0x16
|
|
};
|
|
static const unsigned char x509_cert_long[] = { /* X.509 cert, long pubkey, explicit curve params */
|
|
0x30, 0x82, 0x02, 0x13, 0x30, 0x82, 0x01, 0xba, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x09, 0x00,
|
|
0xaf, 0x14, 0xe3, 0x53, 0x36, 0x06, 0x79, 0x34, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce,
|
|
0x3d, 0x04, 0x03, 0x04, 0x30, 0x17, 0x31, 0x15, 0x30, 0x13, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c,
|
|
0x0c, 0x54, 0x65, 0x73, 0x74, 0x20, 0x43, 0x65, 0x72, 0x74, 0x20, 0x45, 0x43, 0x30, 0x20, 0x17,
|
|
0x0d, 0x31, 0x37, 0x31, 0x32, 0x33, 0x30, 0x32, 0x30, 0x33, 0x33, 0x34, 0x31, 0x5a, 0x18, 0x0f,
|
|
0x33, 0x30, 0x31, 0x37, 0x30, 0x35, 0x30, 0x32, 0x32, 0x30, 0x33, 0x33, 0x34, 0x31, 0x5a, 0x30,
|
|
0x17, 0x31, 0x15, 0x30, 0x13, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x0c, 0x54, 0x65, 0x73, 0x74,
|
|
0x20, 0x43, 0x65, 0x72, 0x74, 0x20, 0x45, 0x43, 0x30, 0x81, 0xf5, 0x30, 0x81, 0xae, 0x06, 0x07,
|
|
0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01, 0x30, 0x81, 0xa2, 0x02, 0x01, 0x01, 0x30, 0x2c, 0x06,
|
|
0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x01, 0x01, 0x02, 0x21, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x2f, 0x30, 0x06, 0x04, 0x01, 0x00,
|
|
0x04, 0x01, 0x07, 0x04, 0x41, 0x04, 0x79, 0xbe, 0x66, 0x7e, 0xf9, 0xdc, 0xbb, 0xac, 0x55, 0xa0,
|
|
0x62, 0x95, 0xce, 0x87, 0x0b, 0x07, 0x02, 0x9b, 0xfc, 0xdb, 0x2d, 0xce, 0x28, 0xd9, 0x59, 0xf2,
|
|
0x81, 0x5b, 0x16, 0xf8, 0x17, 0x98, 0x48, 0x3a, 0xda, 0x77, 0x26, 0xa3, 0xc4, 0x65, 0x5d, 0xa4,
|
|
0xfb, 0xfc, 0x0e, 0x11, 0x08, 0xa8, 0xfd, 0x17, 0xb4, 0x48, 0xa6, 0x85, 0x54, 0x19, 0x9c, 0x47,
|
|
0xd0, 0x8f, 0xfb, 0x10, 0xd4, 0xb8, 0x02, 0x21, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0,
|
|
0x3b, 0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41, 0x41, 0x02, 0x01, 0x01, 0x03, 0x42, 0x00, 0x04,
|
|
0x2a, 0xf9, 0x0b, 0xda, 0xbe, 0x71, 0x66, 0x9e, 0xd1, 0xcf, 0x12, 0xd0, 0x24, 0xaf, 0xba, 0xb6,
|
|
0x7f, 0xfb, 0x96, 0x27, 0x3e, 0x2f, 0xbd, 0x1e, 0xd5, 0xf9, 0x8d, 0x6c, 0x73, 0x9d, 0xc5, 0x16,
|
|
0x91, 0xbd, 0xb2, 0xb9, 0x1b, 0x40, 0x10, 0x5a, 0xb7, 0x6c, 0x6e, 0x32, 0x5b, 0xf7, 0x63, 0x62,
|
|
0x94, 0x24, 0x24, 0xdb, 0xec, 0x3f, 0x8b, 0xe5, 0x6e, 0x4b, 0x64, 0x37, 0x31, 0x24, 0x79, 0x4d,
|
|
0xa3, 0x50, 0x30, 0x4e, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0x66,
|
|
0xc9, 0x90, 0x3c, 0x8a, 0x81, 0xa3, 0x1c, 0x20, 0x61, 0xd2, 0xf3, 0xf5, 0xae, 0xa8, 0x85, 0x70,
|
|
0xf9, 0x1f, 0x2c, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14,
|
|
0x66, 0xc9, 0x90, 0x3c, 0x8a, 0x81, 0xa3, 0x1c, 0x20, 0x61, 0xd2, 0xf3, 0xf5, 0xae, 0xa8, 0x85,
|
|
0x70, 0xf9, 0x1f, 0x2c, 0x30, 0x0c, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x04, 0x05, 0x30, 0x03, 0x01,
|
|
0x01, 0xff, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x04, 0x03, 0x47,
|
|
0x00, 0x30, 0x44, 0x02, 0x1f, 0x2a, 0x62, 0x64, 0x05, 0x67, 0xb0, 0x2c, 0xa0, 0xa3, 0xb8, 0x61,
|
|
0x4e, 0x87, 0x06, 0x69, 0xf2, 0xda, 0x78, 0xd6, 0x0e, 0x8d, 0x9b, 0xf1, 0x43, 0x5f, 0xf6, 0x40,
|
|
0x9d, 0x9d, 0xbd, 0xce, 0x02, 0x21, 0x00, 0xe9, 0x6f, 0x79, 0xb4, 0x4a, 0x00, 0xf7, 0xfa, 0x81,
|
|
0x25, 0x29, 0xec, 0x79, 0xb2, 0xfa, 0x86, 0xf8, 0x84, 0xd1, 0x78, 0xe7, 0xf8, 0xfd, 0x76, 0x2d,
|
|
0x4f, 0xfe, 0x02, 0x72, 0xba, 0x6c, 0xca
|
|
};
|
|
static const unsigned char x509_cert_longc[] = { /* X.509 cert, compressed pubkey, explicit curve params */
|
|
0x30, 0x82, 0x01, 0xd3, 0x30, 0x82, 0x01, 0x7a, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x09, 0x00,
|
|
0x90, 0x5b, 0x48, 0x32, 0x37, 0x4b, 0x72, 0x54, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce,
|
|
0x3d, 0x04, 0x03, 0x04, 0x30, 0x17, 0x31, 0x15, 0x30, 0x13, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c,
|
|
0x0c, 0x54, 0x65, 0x73, 0x74, 0x20, 0x43, 0x65, 0x72, 0x74, 0x20, 0x45, 0x43, 0x30, 0x20, 0x17,
|
|
0x0d, 0x31, 0x37, 0x31, 0x32, 0x33, 0x30, 0x32, 0x30, 0x33, 0x33, 0x34, 0x31, 0x5a, 0x18, 0x0f,
|
|
0x33, 0x30, 0x31, 0x37, 0x30, 0x35, 0x30, 0x32, 0x32, 0x30, 0x33, 0x33, 0x34, 0x31, 0x5a, 0x30,
|
|
0x17, 0x31, 0x15, 0x30, 0x13, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x0c, 0x54, 0x65, 0x73, 0x74,
|
|
0x20, 0x43, 0x65, 0x72, 0x74, 0x20, 0x45, 0x43, 0x30, 0x81, 0xb5, 0x30, 0x81, 0x8e, 0x06, 0x07,
|
|
0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01, 0x30, 0x81, 0x82, 0x02, 0x01, 0x01, 0x30, 0x2c, 0x06,
|
|
0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x01, 0x01, 0x02, 0x21, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x2f, 0x30, 0x06, 0x04, 0x01, 0x00,
|
|
0x04, 0x01, 0x07, 0x04, 0x21, 0x02, 0x79, 0xbe, 0x66, 0x7e, 0xf9, 0xdc, 0xbb, 0xac, 0x55, 0xa0,
|
|
0x62, 0x95, 0xce, 0x87, 0x0b, 0x07, 0x02, 0x9b, 0xfc, 0xdb, 0x2d, 0xce, 0x28, 0xd9, 0x59, 0xf2,
|
|
0x81, 0x5b, 0x16, 0xf8, 0x17, 0x98, 0x02, 0x21, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0,
|
|
0x3b, 0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41, 0x41, 0x02, 0x01, 0x01, 0x03, 0x22, 0x00, 0x03,
|
|
0x2a, 0xf9, 0x0b, 0xda, 0xbe, 0x71, 0x66, 0x9e, 0xd1, 0xcf, 0x12, 0xd0, 0x24, 0xaf, 0xba, 0xb6,
|
|
0x7f, 0xfb, 0x96, 0x27, 0x3e, 0x2f, 0xbd, 0x1e, 0xd5, 0xf9, 0x8d, 0x6c, 0x73, 0x9d, 0xc5, 0x16,
|
|
0xa3, 0x50, 0x30, 0x4e, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0xca,
|
|
0x2a, 0xa1, 0x12, 0x97, 0x96, 0x2c, 0x85, 0xd3, 0x1f, 0xb1, 0x34, 0x7c, 0x26, 0xe9, 0xd6, 0x49,
|
|
0x9f, 0x98, 0xcf, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14,
|
|
0xca, 0x2a, 0xa1, 0x12, 0x97, 0x96, 0x2c, 0x85, 0xd3, 0x1f, 0xb1, 0x34, 0x7c, 0x26, 0xe9, 0xd6,
|
|
0x49, 0x9f, 0x98, 0xcf, 0x30, 0x0c, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x04, 0x05, 0x30, 0x03, 0x01,
|
|
0x01, 0xff, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x04, 0x03, 0x47,
|
|
0x00, 0x30, 0x44, 0x02, 0x20, 0x24, 0x7a, 0xc1, 0xb4, 0x7d, 0x1c, 0x3c, 0x23, 0xc6, 0xad, 0xea,
|
|
0x04, 0x27, 0x27, 0x65, 0xb8, 0x72, 0x93, 0x46, 0xc9, 0xe9, 0x60, 0x8f, 0xca, 0x96, 0x30, 0x60,
|
|
0xb3, 0x22, 0xf7, 0x3b, 0x01, 0x02, 0x20, 0x48, 0x30, 0x2a, 0x58, 0x18, 0x46, 0xdb, 0x50, 0x3e,
|
|
0xad, 0xc3, 0xca, 0xcd, 0x6d, 0x83, 0xd4, 0xc3, 0xc4, 0xa4, 0x8f, 0x37, 0xc3, 0x1d, 0x83, 0x3c,
|
|
0xd3, 0x1f, 0x8f, 0x38, 0x29, 0x75, 0x2c
|
|
};
|
|
static const unsigned char x509_cert_short[] = { /* X.509 cert, long pubkey, curve by OID */
|
|
0x30, 0x82, 0x01, 0x74, 0x30, 0x82, 0x01, 0x1a, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x09, 0x00,
|
|
0xbd, 0x81, 0x04, 0x29, 0x43, 0x12, 0x79, 0xce, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce,
|
|
0x3d, 0x04, 0x03, 0x04, 0x30, 0x17, 0x31, 0x15, 0x30, 0x13, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c,
|
|
0x0c, 0x54, 0x65, 0x73, 0x74, 0x20, 0x43, 0x65, 0x72, 0x74, 0x20, 0x45, 0x43, 0x30, 0x20, 0x17,
|
|
0x0d, 0x31, 0x37, 0x31, 0x32, 0x33, 0x30, 0x32, 0x30, 0x33, 0x33, 0x34, 0x31, 0x5a, 0x18, 0x0f,
|
|
0x33, 0x30, 0x31, 0x37, 0x30, 0x35, 0x30, 0x32, 0x32, 0x30, 0x33, 0x33, 0x34, 0x31, 0x5a, 0x30,
|
|
0x17, 0x31, 0x15, 0x30, 0x13, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x0c, 0x54, 0x65, 0x73, 0x74,
|
|
0x20, 0x43, 0x65, 0x72, 0x74, 0x20, 0x45, 0x43, 0x30, 0x56, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86,
|
|
0x48, 0xce, 0x3d, 0x02, 0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x0a, 0x03, 0x42, 0x00, 0x04,
|
|
0x2a, 0xf9, 0x0b, 0xda, 0xbe, 0x71, 0x66, 0x9e, 0xd1, 0xcf, 0x12, 0xd0, 0x24, 0xaf, 0xba, 0xb6,
|
|
0x7f, 0xfb, 0x96, 0x27, 0x3e, 0x2f, 0xbd, 0x1e, 0xd5, 0xf9, 0x8d, 0x6c, 0x73, 0x9d, 0xc5, 0x16,
|
|
0x91, 0xbd, 0xb2, 0xb9, 0x1b, 0x40, 0x10, 0x5a, 0xb7, 0x6c, 0x6e, 0x32, 0x5b, 0xf7, 0x63, 0x62,
|
|
0x94, 0x24, 0x24, 0xdb, 0xec, 0x3f, 0x8b, 0xe5, 0x6e, 0x4b, 0x64, 0x37, 0x31, 0x24, 0x79, 0x4d,
|
|
0xa3, 0x50, 0x30, 0x4e, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0x66,
|
|
0xc9, 0x90, 0x3c, 0x8a, 0x81, 0xa3, 0x1c, 0x20, 0x61, 0xd2, 0xf3, 0xf5, 0xae, 0xa8, 0x85, 0x70,
|
|
0xf9, 0x1f, 0x2c, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14,
|
|
0x66, 0xc9, 0x90, 0x3c, 0x8a, 0x81, 0xa3, 0x1c, 0x20, 0x61, 0xd2, 0xf3, 0xf5, 0xae, 0xa8, 0x85,
|
|
0x70, 0xf9, 0x1f, 0x2c, 0x30, 0x0c, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x04, 0x05, 0x30, 0x03, 0x01,
|
|
0x01, 0xff, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x04, 0x03, 0x48,
|
|
0x00, 0x30, 0x45, 0x02, 0x21, 0x00, 0x9b, 0x4e, 0xb2, 0x6a, 0xcc, 0xfa, 0x02, 0x69, 0x22, 0x6a,
|
|
0x32, 0x9c, 0x0c, 0xaa, 0x4c, 0xdf, 0xbb, 0x9b, 0x22, 0xfb, 0xd6, 0xec, 0x5d, 0xf9, 0x87, 0x82,
|
|
0xeb, 0x37, 0xb8, 0x32, 0x7c, 0xd6, 0x02, 0x20, 0x50, 0x8b, 0x9f, 0xc1, 0xa8, 0x4a, 0xff, 0x49,
|
|
0x0d, 0x7e, 0x04, 0x2d, 0x93, 0x3e, 0xdb, 0x30, 0xbc, 0x93, 0xd1, 0x16, 0x1d, 0x99, 0xbd, 0x3f,
|
|
0xfa, 0x2a, 0x6d, 0xe0, 0x2a, 0x83, 0x55, 0x5d
|
|
};
|
|
static const unsigned char x509_cert_shortc[] = { /* X.509 cert, compressed pubkey, curve by OID */
|
|
0x30, 0x82, 0x01, 0x54, 0x30, 0x81, 0xfa, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x09, 0x00, 0x85,
|
|
0x45, 0x77, 0x75, 0x02, 0x95, 0xf7, 0x06, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d,
|
|
0x04, 0x03, 0x04, 0x30, 0x17, 0x31, 0x15, 0x30, 0x13, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x0c,
|
|
0x54, 0x65, 0x73, 0x74, 0x20, 0x43, 0x65, 0x72, 0x74, 0x20, 0x45, 0x43, 0x30, 0x20, 0x17, 0x0d,
|
|
0x31, 0x37, 0x31, 0x32, 0x33, 0x30, 0x32, 0x30, 0x33, 0x33, 0x34, 0x31, 0x5a, 0x18, 0x0f, 0x33,
|
|
0x30, 0x31, 0x37, 0x30, 0x35, 0x30, 0x32, 0x32, 0x30, 0x33, 0x33, 0x34, 0x31, 0x5a, 0x30, 0x17,
|
|
0x31, 0x15, 0x30, 0x13, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x0c, 0x54, 0x65, 0x73, 0x74, 0x20,
|
|
0x43, 0x65, 0x72, 0x74, 0x20, 0x45, 0x43, 0x30, 0x36, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48,
|
|
0xce, 0x3d, 0x02, 0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x0a, 0x03, 0x22, 0x00, 0x03, 0x2a,
|
|
0xf9, 0x0b, 0xda, 0xbe, 0x71, 0x66, 0x9e, 0xd1, 0xcf, 0x12, 0xd0, 0x24, 0xaf, 0xba, 0xb6, 0x7f,
|
|
0xfb, 0x96, 0x27, 0x3e, 0x2f, 0xbd, 0x1e, 0xd5, 0xf9, 0x8d, 0x6c, 0x73, 0x9d, 0xc5, 0x16, 0xa3,
|
|
0x50, 0x30, 0x4e, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0xca, 0x2a,
|
|
0xa1, 0x12, 0x97, 0x96, 0x2c, 0x85, 0xd3, 0x1f, 0xb1, 0x34, 0x7c, 0x26, 0xe9, 0xd6, 0x49, 0x9f,
|
|
0x98, 0xcf, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0xca,
|
|
0x2a, 0xa1, 0x12, 0x97, 0x96, 0x2c, 0x85, 0xd3, 0x1f, 0xb1, 0x34, 0x7c, 0x26, 0xe9, 0xd6, 0x49,
|
|
0x9f, 0x98, 0xcf, 0x30, 0x0c, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x04, 0x05, 0x30, 0x03, 0x01, 0x01,
|
|
0xff, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x04, 0x03, 0x49, 0x00,
|
|
0x30, 0x46, 0x02, 0x21, 0x00, 0xa4, 0xf9, 0x41, 0x2b, 0x4b, 0x56, 0xa5, 0xd4, 0x8c, 0xdf, 0xb0,
|
|
0x14, 0xe3, 0xe7, 0xed, 0xcc, 0xc4, 0x46, 0x42, 0x04, 0xec, 0x15, 0x9f, 0xe1, 0xb2, 0x00, 0x07,
|
|
0x8c, 0xc1, 0xf9, 0x25, 0xed, 0x02, 0x21, 0x00, 0x81, 0xd8, 0xc4, 0x3a, 0x9f, 0xdf, 0xc1, 0x70,
|
|
0x9d, 0x7b, 0x70, 0x3e, 0xf5, 0x7d, 0xa4, 0xfd, 0x3c, 0xc6, 0x49, 0x93, 0xd3, 0x5b, 0xef, 0xc9,
|
|
0xae, 0x97, 0xaf, 0x64, 0x64, 0xf9, 0x69, 0xd8
|
|
};
|
|
password_ctx pw_ctx = { .callback = password_get };
|
|
|
|
if (ltc_mp.sqrtmod_prime == NULL) return CRYPT_NOP; /* we need compressed points which requires sqrtmod_prime */
|
|
|
|
DO(ecc_import_openssl(short_pub, sizeof(short_pub), &pub));
|
|
DO(ecc_import_openssl(short_pri, sizeof(short_pri), &pri));
|
|
DO(ecc_find_curve("SECP256K1", &cu));
|
|
|
|
/* import - raw keys */
|
|
DO(ecc_set_curve(cu, &key));
|
|
DO(ecc_set_key(raw_pri, sizeof(raw_pri), PK_PRIVATE, &key));
|
|
DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
|
|
ecc_free(&key);
|
|
DO(ecc_set_curve(cu, &key));
|
|
DO(ecc_set_key(raw_pub, sizeof(raw_pub), PK_PUBLIC, &key));
|
|
DO(ecc_key_cmp(PK_PUBLIC, &pub, &key));
|
|
ecc_free(&key);
|
|
DO(ecc_set_curve(cu, &key));
|
|
DO(ecc_set_key(raw_pubc, sizeof(raw_pubc), PK_PUBLIC, &key));
|
|
DO(ecc_key_cmp(PK_PUBLIC, &pub, &key));
|
|
ecc_free(&key);
|
|
|
|
/* import - openssl compatible DER format */
|
|
DO(ecc_import_openssl(ltc_ecc_long_pri_test_key, sizeof(ltc_ecc_long_pri_test_key), &key));
|
|
DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
|
|
ecc_free(&key);
|
|
DO(ecc_import_openssl(long_pric, sizeof(long_pric), &key));
|
|
DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
|
|
ecc_free(&key);
|
|
DO(ecc_import_openssl(long_pub, sizeof(long_pub), &key));
|
|
DO(ecc_key_cmp(PK_PUBLIC, &pub, &key));
|
|
ecc_free(&key);
|
|
DO(ecc_import_openssl(long_pubc, sizeof(long_pubc), &key));
|
|
DO(ecc_key_cmp(PK_PUBLIC, &pub, &key));
|
|
ecc_free(&key);
|
|
DO(ecc_import_openssl(short_pri, sizeof(short_pri), &key));
|
|
DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
|
|
ecc_free(&key);
|
|
DO(ecc_import_openssl(short_pric, sizeof(short_pric), &key));
|
|
DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
|
|
ecc_free(&key);
|
|
DO(ecc_import_openssl(short_pub, sizeof(short_pub), &key));
|
|
DO(ecc_key_cmp(PK_PUBLIC, &pub, &key));
|
|
ecc_free(&key);
|
|
DO(ecc_import_openssl(short_pubc, sizeof(short_pubc), &key));
|
|
DO(ecc_key_cmp(PK_PUBLIC, &pub, &key));
|
|
ecc_free(&key);
|
|
|
|
/* import - private PKCS8 format - no password */
|
|
DO(ecc_import_pkcs8(long_pri_pkcs8, sizeof(long_pri_pkcs8), NULL, &key));
|
|
DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
|
|
ecc_free(&key);
|
|
DO(ecc_import_pkcs8(long_pric_pkcs8, sizeof(long_pric_pkcs8), NULL, &key));
|
|
DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
|
|
ecc_free(&key);
|
|
DO(ecc_import_pkcs8(short_pri_pkcs8, sizeof(short_pri_pkcs8), NULL, &key));
|
|
DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
|
|
ecc_free(&key);
|
|
DO(ecc_import_pkcs8(short_pric_pkcs8, sizeof(short_pric_pkcs8), NULL, &key));
|
|
DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
|
|
ecc_free(&key);
|
|
|
|
/* import - private PKCS8 format - password protected (PBES1 algorithms) */
|
|
#ifdef LTC_MD2
|
|
DO(ecc_import_pkcs8(long_pri_pkcs8_pbe_md2_des, sizeof(long_pri_pkcs8_pbe_md2_des), &pw_ctx, &key));
|
|
DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
|
|
ecc_free(&key);
|
|
#endif
|
|
#ifdef LTC_MD5
|
|
DO(ecc_import_pkcs8(long_pri_pkcs8_pbe_md5_des, sizeof(long_pri_pkcs8_pbe_md5_des), &pw_ctx, &key));
|
|
DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
|
|
ecc_free(&key);
|
|
#endif
|
|
#ifdef LTC_SHA1
|
|
DO(ecc_import_pkcs8(long_pri_pkcs8_pbe_sha1_des, sizeof(long_pri_pkcs8_pbe_sha1_des), &pw_ctx, &key));
|
|
DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
|
|
ecc_free(&key);
|
|
#endif
|
|
#if defined(LTC_RC2) && defined(LTC_MD2)
|
|
DO(ecc_import_pkcs8(long_pri_pkcs8_pbe_md2_rc2_64, sizeof(long_pri_pkcs8_pbe_md2_rc2_64), &pw_ctx, &key));
|
|
DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
|
|
ecc_free(&key);
|
|
#endif
|
|
#if defined(LTC_RC2) && defined(LTC_MD5)
|
|
DO(ecc_import_pkcs8(long_pri_pkcs8_pbe_md5_rc2_64, sizeof(long_pri_pkcs8_pbe_md5_rc2_64), &pw_ctx, &key));
|
|
DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
|
|
ecc_free(&key);
|
|
#endif
|
|
#if defined(LTC_RC2) && defined(LTC_SHA1)
|
|
DO(ecc_import_pkcs8(long_pri_pkcs8_pbe_sha1_rc2_64, sizeof(long_pri_pkcs8_pbe_sha1_rc2_64), &pw_ctx, &key));
|
|
DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
|
|
ecc_free(&key);
|
|
#endif
|
|
|
|
/* import - private PKCS8 format - password protected (PBES2 algorithms) */
|
|
#if defined(LTC_RC2)
|
|
DO(ecc_import_pkcs8(long_pri_pkcs8_pbkdf2_rc2_cbc, sizeof(long_pri_pkcs8_pbkdf2_rc2_cbc), &pw_ctx, &key));
|
|
DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
|
|
ecc_free(&key);
|
|
#endif
|
|
#if defined(LTC_DES)
|
|
DO(ecc_import_pkcs8(long_pri_pkcs8_pbkdf2_des_cbc, sizeof(long_pri_pkcs8_pbkdf2_des_cbc), &pw_ctx, &key));
|
|
DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
|
|
ecc_free(&key);
|
|
#endif
|
|
#if defined(LTC_DES)
|
|
DO(ecc_import_pkcs8(long_pri_pkcs8_pbkdf2_des_ede3_cbc, sizeof(long_pri_pkcs8_pbkdf2_des_ede3_cbc), &pw_ctx, &key));
|
|
DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
|
|
ecc_free(&key);
|
|
#endif
|
|
#if defined(LTC_SHA224) && defined(LTC_DES)
|
|
DO(ecc_import_pkcs8(long_pri_pkcs8_pbkdf2_sha224_des_ede3_cbc, sizeof(long_pri_pkcs8_pbkdf2_sha224_des_ede3_cbc), &pw_ctx, &key));
|
|
DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
|
|
ecc_free(&key);
|
|
#endif
|
|
#if defined(LTC_SHA256) && defined(LTC_DES)
|
|
DO(ecc_import_pkcs8(long_pri_pkcs8_pbkdf2_sha256_des_ede3_cbc, sizeof(long_pri_pkcs8_pbkdf2_sha256_des_ede3_cbc), &pw_ctx, &key));
|
|
DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
|
|
ecc_free(&key);
|
|
#endif
|
|
#if defined(LTC_SHA384) && defined(LTC_DES)
|
|
DO(ecc_import_pkcs8(long_pri_pkcs8_pbkdf2_sha384_des_ede3_cbc, sizeof(long_pri_pkcs8_pbkdf2_sha384_des_ede3_cbc), &pw_ctx, &key));
|
|
DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
|
|
ecc_free(&key);
|
|
#endif
|
|
#if defined(LTC_SHA512) && defined(LTC_DES)
|
|
DO(ecc_import_pkcs8(long_pri_pkcs8_pbkdf2_sha512_des_ede3_cbc, sizeof(long_pri_pkcs8_pbkdf2_sha512_des_ede3_cbc), &pw_ctx, &key));
|
|
DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
|
|
ecc_free(&key);
|
|
#endif
|
|
|
|
/* import - X.509 EC certificates */
|
|
DO(ecc_import_x509(x509_cert_long, sizeof(x509_cert_long), &key));
|
|
DO(ecc_key_cmp(PK_PUBLIC, &pub, &key));
|
|
ecc_free(&key);
|
|
DO(ecc_import_x509(x509_cert_longc, sizeof(x509_cert_longc), &key));
|
|
DO(ecc_key_cmp(PK_PUBLIC, &pub, &key));
|
|
ecc_free(&key);
|
|
DO(ecc_import_x509(x509_cert_short, sizeof(x509_cert_short), &key));
|
|
DO(ecc_key_cmp(PK_PUBLIC, &pub, &key));
|
|
ecc_free(&key);
|
|
DO(ecc_import_x509(x509_cert_shortc, sizeof(x509_cert_shortc), &key));
|
|
DO(ecc_key_cmp(PK_PUBLIC, &pub, &key));
|
|
ecc_free(&key);
|
|
|
|
/* export - openssl compatible DER format */
|
|
outlen = sizeof(out);
|
|
DO(ecc_export_openssl(out, &outlen, PK_PRIVATE, &pri));
|
|
COMPARE_TESTVECTOR(out, outlen, ltc_ecc_long_pri_test_key, sizeof(ltc_ecc_long_pri_test_key), "e-ltc_ecc_long_pri_test_key", 0);
|
|
outlen = sizeof(out);
|
|
DO(ecc_export_openssl(out, &outlen, PK_PRIVATE|PK_COMPRESSED, &pri));
|
|
COMPARE_TESTVECTOR(out, outlen, long_pric, sizeof(long_pric), "e-long_pric", 0);
|
|
outlen = sizeof(out);
|
|
DO(ecc_export_openssl(out, &outlen, PK_PUBLIC, &pub));
|
|
COMPARE_TESTVECTOR(out, outlen, long_pub, sizeof(long_pub), "e-long_pub", 0);
|
|
outlen = sizeof(out);
|
|
DO(ecc_export_openssl(out, &outlen, PK_PUBLIC|PK_COMPRESSED, &pub));
|
|
COMPARE_TESTVECTOR(out, outlen, long_pubc, sizeof(long_pubc), "e-long_pubc", 0);
|
|
outlen = sizeof(out);
|
|
DO(ecc_export_openssl(out, &outlen, PK_PRIVATE|PK_CURVEOID, &pri));
|
|
COMPARE_TESTVECTOR(out, outlen, short_pri, sizeof(short_pri), "e-short_pri", 0);
|
|
outlen = sizeof(out);
|
|
DO(ecc_export_openssl(out, &outlen, PK_PRIVATE|PK_CURVEOID|PK_COMPRESSED, &pri));
|
|
COMPARE_TESTVECTOR(out, outlen, short_pric, sizeof(short_pric), "e-short_pric", 0);
|
|
outlen = sizeof(out);
|
|
DO(ecc_export_openssl(out, &outlen, PK_PUBLIC|PK_CURVEOID, &pub));
|
|
COMPARE_TESTVECTOR(out, outlen, short_pub, sizeof(short_pub), "e-short_pub", 0);
|
|
outlen = sizeof(out);
|
|
DO(ecc_export_openssl(out, &outlen, PK_PUBLIC|PK_CURVEOID|PK_COMPRESSED, &pub));
|
|
COMPARE_TESTVECTOR(out, outlen, short_pubc, sizeof(short_pubc), "e-short_pubc", 0);
|
|
|
|
/* export - raw keys */
|
|
outlen = sizeof(out);
|
|
DO(ecc_get_key(out, &outlen, PK_PRIVATE, &pri));
|
|
COMPARE_TESTVECTOR(out, outlen, raw_pri, sizeof(raw_pri), "e-raw_pri", 0);
|
|
outlen = sizeof(out);
|
|
DO(ecc_get_key(out, &outlen, PK_PUBLIC, &pub));
|
|
COMPARE_TESTVECTOR(out, outlen, raw_pub, sizeof(raw_pub), "e-raw_pub", 0);
|
|
outlen = sizeof(out);
|
|
DO(ecc_get_key(out, &outlen, PK_PUBLIC|PK_COMPRESSED, &pub));
|
|
COMPARE_TESTVECTOR(out, outlen, raw_pubc, sizeof(raw_pubc), "e-raw_pubc", 0);
|
|
|
|
ecc_free(&pri);
|
|
ecc_free(&pub);
|
|
return CRYPT_OK;
|
|
}
|
|
|
|
#ifdef LTC_ECC_SHAMIR
|
|
static int s_ecc_test_ethereum(void)
|
|
{
|
|
#ifdef LTC_ECC_SECP256K1
|
|
int stat;
|
|
const ltc_ecc_curve* dp;
|
|
ecc_key key, reckey;
|
|
unsigned char buf[128];
|
|
unsigned long len;
|
|
unsigned char data16[16] = { 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1 };
|
|
ltc_ecc_sig_opts sig_opts = {
|
|
.type = LTC_ECCSIG_ETH27,
|
|
.prng = &yarrow_prng,
|
|
.wprng = find_prng ("yarrow"),
|
|
};
|
|
|
|
DO(ecc_find_curve("SECP256K1", &dp));
|
|
|
|
DO(ecc_make_key_ex(&yarrow_prng, find_prng ("yarrow"), &key, dp));
|
|
|
|
/* test Ethereum signature */
|
|
len = sizeof(buf);
|
|
DO(ecc_sign_hash_v2(data16, 16, buf, &len, &sig_opts, &key));
|
|
stat = 0;
|
|
DO(ecc_verify_hash_v2(buf, len, data16, 16, &sig_opts, &stat, &key));
|
|
if (stat != 1) return CRYPT_FAIL_TESTVECTOR;
|
|
|
|
/* XXX-FIXME: TFM does not support sqrtmod_prime */
|
|
if (strcmp(ltc_mp.name, "TomsFastMath") != 0) {
|
|
DO(ecc_set_curve(dp, &reckey));
|
|
DO(ecc_recover_key(buf, len, data16, 16, &sig_opts, &reckey));
|
|
DO(ecc_key_cmp(PK_PUBLIC, &key, &reckey));
|
|
|
|
/* cleanup */
|
|
ecc_free(&reckey);
|
|
}
|
|
/* cleanup */
|
|
ecc_free(&key);
|
|
return CRYPT_OK;
|
|
#else
|
|
return CRYPT_NOP;
|
|
#endif
|
|
}
|
|
|
|
static int s_ecc_test_recovery(void)
|
|
{
|
|
int i, stat;
|
|
const ltc_ecc_curve* dp;
|
|
ecc_key key, privkey, pubkey, reckey;
|
|
unsigned char buf[1000];
|
|
unsigned long len;
|
|
unsigned char data16[16] = { 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1 };
|
|
unsigned char eth_hash[] = { /* Keccak-256 hash of "Hello World" */
|
|
0x59, 0x2f, 0xa7, 0x43, 0x88, 0x9f, 0xc7, 0xf9, 0x2a, 0xc2, 0xa3, 0x7b, 0xb1, 0xf5, 0xba, 0x1d,
|
|
0xaf, 0x2a, 0x5c, 0x84, 0x74, 0x1c, 0xa0, 0xe0, 0x06, 0x1d, 0x24, 0x3a, 0x2e, 0x67, 0x07, 0xba
|
|
};
|
|
unsigned char eth_pubkey[] = { /* Public part of randomly-generated key pair */
|
|
0x04,
|
|
0xc6, 0x99, 0x5f, 0xdc, 0xf4, 0xf2, 0xda, 0x6e, 0x79, 0xe0, 0x47, 0x12, 0xd3, 0xbe, 0x22, 0xe7,
|
|
0x65, 0xc6, 0xa3, 0x32, 0x89, 0x1b, 0x34, 0xba, 0xc1, 0xb7, 0x01, 0x83, 0xed, 0xdd, 0xf1, 0xcc,
|
|
0xbf, 0x20, 0xdd, 0xcd, 0x05, 0x4e, 0x49, 0xc8, 0xcb, 0x66, 0x6c, 0xb7, 0x71, 0x2f, 0x7e, 0xc1,
|
|
0xd6, 0x1a, 0x4a, 0x42, 0x3d, 0xe5, 0xc2, 0x8d, 0x74, 0x03, 0x81, 0xe7, 0xea, 0xc5, 0x3c, 0x10
|
|
};
|
|
unsigned char eth_sig[] = { /* Signature of eth_hash to be verified against eth_pubkey */
|
|
0xbd, 0x6d, 0xbb, 0xbe, 0x2d, 0xe7, 0x1d, 0x00, 0xae, 0x18, 0x57, 0x12, 0x1d, 0x63, 0xa5, 0x1b,
|
|
0x0b, 0x42, 0x71, 0xa2, 0x80, 0x49, 0xe0, 0x5c, 0xfa, 0xc8, 0x1a, 0x0d, 0x8a, 0x88, 0x67, 0x56,
|
|
0xf6, 0x67, 0x1b, 0x41, 0x46, 0x09, 0x4e, 0xd0, 0x44, 0x25, 0x18, 0xfd, 0xf4, 0xcd, 0x62, 0xa3,
|
|
0xb7, 0x3c, 0x97, 0x55, 0xfa, 0x69, 0xf8, 0xef, 0xe9, 0xcf, 0x12, 0xaf, 0x48, 0x25, 0xe3, 0xe0,
|
|
0x1b
|
|
};
|
|
ltc_ecc_sig_opts sig_opts = {
|
|
.prng = &yarrow_prng,
|
|
.wprng = find_prng ("yarrow"),
|
|
.enable_recovery_id = 1,
|
|
};
|
|
|
|
/* XXX-FIXME: TFM does not support sqrtmod_prime */
|
|
if (strcmp(ltc_mp.name, "TomsFastMath") == 0) return CRYPT_NOP;
|
|
|
|
#ifdef LTC_ECC_SECP256K1
|
|
DO(ecc_find_curve("SECP256K1", &dp));
|
|
|
|
DO(ecc_set_curve(dp, &pubkey));
|
|
DO(ecc_set_key(eth_pubkey, sizeof(eth_pubkey), PK_PUBLIC, &pubkey));
|
|
|
|
DO(ecc_set_curve(dp, &reckey));
|
|
sig_opts.recovery_id = 0;
|
|
sig_opts.type = LTC_ECCSIG_RFC7518;
|
|
DO(ecc_recover_key(eth_sig, sizeof(eth_sig)-1, eth_hash, sizeof(eth_hash), &sig_opts, &reckey));
|
|
DO(ecc_key_cmp(PK_PUBLIC, &pubkey, &reckey));
|
|
ecc_free(&reckey);
|
|
|
|
DO(ecc_set_curve(dp, &reckey));
|
|
sig_opts.recovery_id = -1;
|
|
sig_opts.type = LTC_ECCSIG_ETH27;
|
|
DO(ecc_recover_key(eth_sig, sizeof(eth_sig), eth_hash, sizeof(eth_hash), &sig_opts, &reckey));
|
|
DO(ecc_key_cmp(PK_PUBLIC, &pubkey, &reckey));
|
|
ecc_free(&reckey);
|
|
|
|
ecc_free(&pubkey);
|
|
#endif
|
|
|
|
sig_opts.type = LTC_ECCSIG_RFC7518;
|
|
for (i = 0; i < (int)LTC_ARRAY_SIZE(curvenames); i++) {
|
|
DO(ecc_find_curve(curvenames[i], &dp));
|
|
|
|
/* generate new key */
|
|
DO(ecc_set_curve(dp, &key));
|
|
DO(ecc_generate_key(&yarrow_prng, find_prng ("yarrow"), &key));
|
|
|
|
/* export private key */
|
|
len = sizeof(buf);
|
|
DO(ecc_get_key(buf, &len, PK_PRIVATE, &key));
|
|
ecc_free(&key);
|
|
|
|
/* load exported private key */
|
|
DO(ecc_set_curve(dp, &privkey));
|
|
DO(ecc_set_key(buf, len, PK_PRIVATE, &privkey));
|
|
|
|
/* export long public key */
|
|
len = sizeof(buf);
|
|
DO(ecc_get_key(buf, &len, PK_PUBLIC, &privkey));
|
|
if (len != 1 + 2 * (unsigned)ecc_get_size(&privkey)) return CRYPT_FAIL_TESTVECTOR;
|
|
|
|
/* load exported public key */
|
|
DO(ecc_set_curve(dp, &pubkey));
|
|
DO(ecc_set_key(buf, len, PK_PUBLIC, &pubkey));
|
|
|
|
/* test signature */
|
|
len = sizeof(buf);
|
|
sig_opts.recovery_id = 0;
|
|
DO(ecc_sign_hash_v2(data16, 16, buf, &len, &sig_opts, &privkey));
|
|
|
|
/* test verification */
|
|
stat = 0;
|
|
DO(ecc_verify_hash_v2(buf, len, data16, 16, &sig_opts, &stat, &pubkey));
|
|
if (stat != 1) return CRYPT_FAIL_TESTVECTOR;
|
|
|
|
/* test recovery */
|
|
DO(ecc_set_curve(dp, &reckey));
|
|
stat = ecc_recover_key(buf, len, data16, 16, &sig_opts, &reckey);
|
|
if (stat != CRYPT_OK) return CRYPT_FAIL_TESTVECTOR;
|
|
DO(ecc_key_cmp(PK_PUBLIC, &pubkey, &reckey));
|
|
|
|
/* cleanup */
|
|
ecc_free(&reckey);
|
|
ecc_free(&privkey);
|
|
ecc_free(&pubkey);
|
|
}
|
|
|
|
return CRYPT_OK;
|
|
}
|
|
#endif
|
|
|
|
int ecc_test(void)
|
|
{
|
|
if (ltc_mp.name == NULL) return CRYPT_NOP;
|
|
|
|
DO(s_ecc_wycheproof_p256_edgecase_dbl());
|
|
#if defined(LTC_PEM) && defined(LTC_DER)
|
|
DO(s_ecc_wycheproof_p256_pem_edgecase_dbl());
|
|
DO(s_ecc_wycheproof_p256_pem_invalid_explicit());
|
|
#endif
|
|
#if defined(LTC_DER) && defined(LTC_ECC_BRAINPOOLP224R1) && defined(LTC_ECC_BRAINPOOLP224T1)
|
|
DO(s_ecc_wycheproof_bp224_wrong_curve());
|
|
#endif
|
|
DO(s_ecc_issue446());
|
|
DO(s_ecc_rfc6979());
|
|
DO(s_ecc_old_api()); /* up to 1.18 */
|
|
DO(s_ecc_new_api());
|
|
DO(s_ecc_import_export());
|
|
DO(s_ecc_test_mp());
|
|
DO(s_ecc_issue108());
|
|
DO(s_ecc_issue443_447());
|
|
DO(s_ecc_issue630());
|
|
DO(s_ecc_issue116());
|
|
#ifdef LTC_ECC_SHAMIR
|
|
DO(s_ecc_test_shamir());
|
|
DO(s_ecc_test_recovery());
|
|
DO(s_ecc_test_ethereum());
|
|
#endif
|
|
return CRYPT_OK;
|
|
}
|
|
#else
|
|
LTC_NOP_TEST(ecc_test)
|
|
#endif
|