Skip to content

Commit 8e26329

Browse files
lealem47lealem47
committed
Address Copilot feedback
1 parent c01c434 commit 8e26329

2 files changed

Lines changed: 74 additions & 47 deletions

File tree

‎tests/api/test_evp_pkey.c‎

Lines changed: 36 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -2364,19 +2364,25 @@ int test_wolfSSL_EVP_PKEY_ed25519(void)
23642364
WOLFSSL_EVP_PKEY* pkey = NULL;
23652365
const unsigned char* p;
23662366

2367+
/* Known-valid Ed25519 public key matching server_ed25519_key. The bytes
2368+
* are the raw 32-byte BIT STRING contents from
2369+
* ./certs/ed25519/server-ed25519-key.der so the import succeeds even
2370+
* under strict point-validation. */
23672371
static const unsigned char rawPub[32] = {
2368-
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
2369-
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
2370-
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
2371-
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f
2372+
0x23, 0xaa, 0x4d, 0x60, 0x50, 0xe0, 0x13, 0xd3,
2373+
0x3a, 0xed, 0xab, 0xf6, 0xa9, 0xcc, 0x4a, 0xfe,
2374+
0xd7, 0x4d, 0x2f, 0xd2, 0x5b, 0x1a, 0x10, 0x05,
2375+
0xef, 0x5a, 0x41, 0x25, 0xce, 0x1b, 0x53, 0x78
23722376
};
23732377

2378+
/* SPKI wrapper around the same known-valid public key (the full
2379+
* contents of ./certs/ed25519/server-ed25519-key.der). */
23742380
static const unsigned char spkiPub[] = {
23752381
0x30, 0x2a, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70, 0x03, 0x21, 0x00,
2376-
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
2377-
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
2378-
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
2379-
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f
2382+
0x23, 0xaa, 0x4d, 0x60, 0x50, 0xe0, 0x13, 0xd3,
2383+
0x3a, 0xed, 0xab, 0xf6, 0xa9, 0xcc, 0x4a, 0xfe,
2384+
0xd7, 0x4d, 0x2f, 0xd2, 0x5b, 0x1a, 0x10, 0x05,
2385+
0xef, 0x5a, 0x41, 0x25, 0xce, 0x1b, 0x53, 0x78
23802386
};
23812387

23822388
/* Exercise the WC_EVP_PKEY_ED25519 case in d2i_evp_pkey()
@@ -2448,28 +2454,33 @@ int test_wolfSSL_EVP_PKEY_ed448(void)
24482454
#if defined(OPENSSL_EXTRA) && defined(HAVE_ED448)
24492455
WOLFSSL_EVP_PKEY* pkey = NULL;
24502456
const unsigned char* p;
2451-
/* 57 arbitrary bytes used as a "raw Ed448 public key". */
2457+
2458+
/* Known-valid Ed448 public key: the raw 57-byte BIT STRING contents
2459+
* from ./certs/ed448/server-ed448-key.der so the import succeeds even
2460+
* under strict point-validation. */
24522461
static const unsigned char rawPub[57] = {
2453-
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
2454-
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
2455-
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
2456-
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
2457-
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
2458-
0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
2459-
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
2460-
0x38
2462+
0x54, 0x81, 0x39, 0x01, 0xeb, 0x37, 0xd9, 0xa9,
2463+
0x07, 0xcd, 0x01, 0xbc, 0x9d, 0x70, 0x16, 0xc2,
2464+
0x2c, 0x2b, 0x75, 0x5b, 0x63, 0xdb, 0xee, 0x3a,
2465+
0x2d, 0x44, 0x92, 0x46, 0xb4, 0x7b, 0x07, 0x03,
2466+
0x4f, 0xa2, 0xae, 0x86, 0x86, 0xdc, 0x8b, 0x4b,
2467+
0x2c, 0x7f, 0xe8, 0x6b, 0x14, 0x8d, 0x58, 0xdd,
2468+
0x6d, 0xe7, 0x6f, 0x3a, 0x05, 0x95, 0xa8, 0xef,
2469+
0x00
24612470
};
24622471

2472+
/* SPKI wrapper around the same known-valid public key (the full
2473+
* contents of ./certs/ed448/server-ed448-key.der). */
24632474
static const unsigned char spkiPub[] = {
24642475
0x30, 0x43, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x71, 0x03, 0x3a, 0x00,
2465-
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
2466-
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
2467-
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
2468-
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
2469-
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
2470-
0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
2471-
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
2472-
0x38
2476+
0x54, 0x81, 0x39, 0x01, 0xeb, 0x37, 0xd9, 0xa9,
2477+
0x07, 0xcd, 0x01, 0xbc, 0x9d, 0x70, 0x16, 0xc2,
2478+
0x2c, 0x2b, 0x75, 0x5b, 0x63, 0xdb, 0xee, 0x3a,
2479+
0x2d, 0x44, 0x92, 0x46, 0xb4, 0x7b, 0x07, 0x03,
2480+
0x4f, 0xa2, 0xae, 0x86, 0x86, 0xdc, 0x8b, 0x4b,
2481+
0x2c, 0x7f, 0xe8, 0x6b, 0x14, 0x8d, 0x58, 0xdd,
2482+
0x6d, 0xe7, 0x6f, 0x3a, 0x05, 0x95, 0xa8, 0xef,
2483+
0x00
24732484
};
24742485

24752486
/* SPKI path. */

‎wolfcrypt/src/evp_pk.c‎

Lines changed: 38 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -241,7 +241,8 @@ static int d2iTryEccKey(WOLFSSL_EVP_PKEY** out, const unsigned char* mem,
241241
* @param [in] memSz Size of key data in bytes.
242242
* @param [in] priv 1 means private key, 0 means public key.
243243
* @return 1 on success.
244-
* @return 0 otherwise.
244+
* @return 0 on allocation/initialization failure
245+
* @return WOLFSSL_FATAL_ERROR if the input is not an Ed25519 key.
245246
*/
246247
static int d2iTryEd25519Key(WOLFSSL_EVP_PKEY** out, const unsigned char* mem,
247248
long memSz, int priv)
@@ -250,14 +251,19 @@ static int d2iTryEd25519Key(WOLFSSL_EVP_PKEY** out, const unsigned char* mem,
250251
word32 keyIdx = 0;
251252
int isEdKey;
252253
int ret = 1;
254+
void* heap = NULL;
255+
256+
if (*out != NULL) {
257+
heap = (*out)->heap;
258+
}
253259

254-
edKey = (ed25519_key*)XMALLOC(sizeof(ed25519_key), NULL,
260+
edKey = (ed25519_key*)XMALLOC(sizeof(ed25519_key), heap,
255261
DYNAMIC_TYPE_ED25519);
256262
if (edKey == NULL) {
257263
return 0;
258264
}
259-
if (wc_ed25519_init(edKey) != 0) {
260-
XFREE(edKey, NULL, DYNAMIC_TYPE_ED25519);
265+
if (wc_ed25519_init_ex(edKey, heap, INVALID_DEVID) != 0) {
266+
XFREE(edKey, heap, DYNAMIC_TYPE_ED25519);
261267
return 0;
262268
}
263269

@@ -288,19 +294,21 @@ static int d2iTryEd25519Key(WOLFSSL_EVP_PKEY** out, const unsigned char* mem,
288294

289295
if (!isEdKey) {
290296
wc_ed25519_free(edKey);
291-
XFREE(edKey, NULL, DYNAMIC_TYPE_ED25519);
297+
XFREE(edKey, heap, DYNAMIC_TYPE_ED25519);
292298
return WOLFSSL_FATAL_ERROR;
293299
}
294300

295-
/* Create an EVP PKEY object holding the DER bytes. */
301+
/* Create an EVP PKEY object holding the input bytes. These are the
302+
* SPKI / PKCS#8 DER on the structured path, or the raw 32-byte key
303+
* on the raw fallback path. */
296304
ret = d2i_make_pkey(out, mem, keyIdx, priv, WC_EVP_PKEY_ED25519);
297305
if (ret == 1) {
298306
(*out)->ownEd25519 = 1;
299307
(*out)->ed25519 = edKey;
300308
}
301309
else {
302310
wc_ed25519_free(edKey);
303-
XFREE(edKey, NULL, DYNAMIC_TYPE_ED25519);
311+
XFREE(edKey, heap, DYNAMIC_TYPE_ED25519);
304312
}
305313

306314
return ret;
@@ -317,7 +325,8 @@ static int d2iTryEd25519Key(WOLFSSL_EVP_PKEY** out, const unsigned char* mem,
317325
* @param [in] memSz Size of key data in bytes.
318326
* @param [in] priv 1 means private key, 0 means public key.
319327
* @return 1 on success.
320-
* @return 0 otherwise.
328+
* @return 0 on allocation/initialization failure.
329+
* @return WOLFSSL_FATAL_ERROR if the input is not an Ed448 key.
321330
*/
322331
static int d2iTryEd448Key(WOLFSSL_EVP_PKEY** out, const unsigned char* mem,
323332
long memSz, int priv)
@@ -326,13 +335,18 @@ static int d2iTryEd448Key(WOLFSSL_EVP_PKEY** out, const unsigned char* mem,
326335
word32 keyIdx = 0;
327336
int isEdKey;
328337
int ret = 1;
338+
void* heap = NULL;
339+
340+
if (*out != NULL) {
341+
heap = (*out)->heap;
342+
}
329343

330-
edKey = (ed448_key*)XMALLOC(sizeof(ed448_key), NULL, DYNAMIC_TYPE_ED448);
344+
edKey = (ed448_key*)XMALLOC(sizeof(ed448_key), heap, DYNAMIC_TYPE_ED448);
331345
if (edKey == NULL) {
332346
return 0;
333347
}
334-
if (wc_ed448_init(edKey) != 0) {
335-
XFREE(edKey, NULL, DYNAMIC_TYPE_ED448);
348+
if (wc_ed448_init_ex(edKey, heap, INVALID_DEVID) != 0) {
349+
XFREE(edKey, heap, DYNAMIC_TYPE_ED448);
336350
return 0;
337351
}
338352

@@ -363,19 +377,21 @@ static int d2iTryEd448Key(WOLFSSL_EVP_PKEY** out, const unsigned char* mem,
363377

364378
if (!isEdKey) {
365379
wc_ed448_free(edKey);
366-
XFREE(edKey, NULL, DYNAMIC_TYPE_ED448);
380+
XFREE(edKey, heap, DYNAMIC_TYPE_ED448);
367381
return WOLFSSL_FATAL_ERROR;
368382
}
369383

370-
/* Create an EVP PKEY object holding the DER bytes. */
384+
/* Create an EVP PKEY object holding the input bytes. These are the
385+
* SPKI / PKCS#8 DER on the structured path, or the raw 57-byte key
386+
* on the raw fallback path. */
371387
ret = d2i_make_pkey(out, mem, keyIdx, priv, WC_EVP_PKEY_ED448);
372388
if (ret == 1) {
373389
(*out)->ownEd448 = 1;
374390
(*out)->ed448 = edKey;
375391
}
376392
else {
377393
wc_ed448_free(edKey);
378-
XFREE(edKey, NULL, DYNAMIC_TYPE_ED448);
394+
XFREE(edKey, heap, DYNAMIC_TYPE_ED448);
379395
}
380396

381397
return ret;
@@ -1199,14 +1215,14 @@ static WOLFSSL_EVP_PKEY* d2i_evp_pkey(int type, WOLFSSL_EVP_PKEY** out,
11991215
word32 keyIdx = 0;
12001216
int isEdKey;
12011217

1202-
edKey = (ed25519_key*)XMALLOC(sizeof(ed25519_key), NULL,
1218+
edKey = (ed25519_key*)XMALLOC(sizeof(ed25519_key), local->heap,
12031219
DYNAMIC_TYPE_ED25519);
12041220
if (edKey == NULL) {
12051221
wolfSSL_EVP_PKEY_free(local);
12061222
return NULL;
12071223
}
1208-
if (wc_ed25519_init(edKey) != 0) {
1209-
XFREE(edKey, NULL, DYNAMIC_TYPE_ED25519);
1224+
if (wc_ed25519_init_ex(edKey, local->heap, INVALID_DEVID) != 0) {
1225+
XFREE(edKey, local->heap, DYNAMIC_TYPE_ED25519);
12101226
wolfSSL_EVP_PKEY_free(local);
12111227
return NULL;
12121228
}
@@ -1228,7 +1244,7 @@ static WOLFSSL_EVP_PKEY* d2i_evp_pkey(int type, WOLFSSL_EVP_PKEY** out,
12281244
}
12291245
if (!isEdKey) {
12301246
wc_ed25519_free(edKey);
1231-
XFREE(edKey, NULL, DYNAMIC_TYPE_ED25519);
1247+
XFREE(edKey, local->heap, DYNAMIC_TYPE_ED25519);
12321248
wolfSSL_EVP_PKEY_free(local);
12331249
return NULL;
12341250
}
@@ -1244,14 +1260,14 @@ static WOLFSSL_EVP_PKEY* d2i_evp_pkey(int type, WOLFSSL_EVP_PKEY** out,
12441260
word32 keyIdx = 0;
12451261
int isEdKey;
12461262

1247-
edKey = (ed448_key*)XMALLOC(sizeof(ed448_key), NULL,
1263+
edKey = (ed448_key*)XMALLOC(sizeof(ed448_key), local->heap,
12481264
DYNAMIC_TYPE_ED448);
12491265
if (edKey == NULL) {
12501266
wolfSSL_EVP_PKEY_free(local);
12511267
return NULL;
12521268
}
1253-
if (wc_ed448_init(edKey) != 0) {
1254-
XFREE(edKey, NULL, DYNAMIC_TYPE_ED448);
1269+
if (wc_ed448_init_ex(edKey, local->heap, INVALID_DEVID) != 0) {
1270+
XFREE(edKey, local->heap, DYNAMIC_TYPE_ED448);
12551271
wolfSSL_EVP_PKEY_free(local);
12561272
return NULL;
12571273
}
@@ -1273,7 +1289,7 @@ static WOLFSSL_EVP_PKEY* d2i_evp_pkey(int type, WOLFSSL_EVP_PKEY** out,
12731289
}
12741290
if (!isEdKey) {
12751291
wc_ed448_free(edKey);
1276-
XFREE(edKey, NULL, DYNAMIC_TYPE_ED448);
1292+
XFREE(edKey, local->heap, DYNAMIC_TYPE_ED448);
12771293
wolfSSL_EVP_PKEY_free(local);
12781294
return NULL;
12791295
}

0 commit comments

Comments
 (0)