What changed, and why it matters
This commit changes how a secure-handshake library (used to set up encrypted connections) stores sensitive keys. Previously, the long-term private key, public key, and pre-shared key were copied into a handshake state structure at initialization and kept there for the whole handshake. Now they are passed only to the specific functions that actually need them. This reduces the window during which those secrets sit in memory inside the handshake object, which is a defensive hardening improvement rather than a fix for an active bug. There is no claim by the vendor that this resolves a reported security vulnerability.
Treat as a benign API refactor with defensive hardening benefits. Verify that all production callers of noise_xxpsk3_initiator_init, noise_xxpsk3_responder_init, noise_xxpsk3_responder_create_response1, noise_xxpsk3_responder_handle_request2, and noise_xxpsk3_initiator_create_request2 are updated to match the new signatures and that secrets are zeroed after use by callers. No urgent security patch is indicated by the commit itself.
Security signals we found
Reduction of secret material lifetime in memory (defensive hardening)
Removal of long-term private key and PSK fields from persistent handshake state structure
API change that may require updates in all production callers to avoid compile/runtime failures
No input validation, bounds-checking, or cryptographic algorithm changes visible in the diff
Evidence from the diff
The patch refactors the Noise_XXpsk3 implementation in crypto/noise_xxpsk3.c/.h. It removes static_private, static_public, and psk fields from noise_xxpsk3_handshake_state_t and from the init functions (noise_xxpsk3_initiator_init, noise_xxpsk3_responder_init). Instead, static_private_key/static_public_key are passed to create_response1/create_request2, and psk is passed to handle_request2/create_request2. The init functions now only set up the symmetric state and clear the structure. This shortens the lifetime of secret material in the handshake state and removes unnecessary copies, but the commit message labels it as a ‘chore’ and explicitly says ‘[no changelog]’. The change is API-breaking for callers, but the diff only shows test updates, not production callers. No vulnerability, CVE, or advisory is referenced.
Changed components
crypto/noise_xxpsk3.ccrypto/noise_xxpsk3.hcrypto/tests/test_check.cInspect captured patch +86 / −116
### crypto/noise_xxpsk3.c
@@ -367,12 +367,9 @@ static bool ss_decrypt_and_hash(noise_xxpsk3_symmetric_state_t *ss,
return true;
}
-static bool noise_xxpsk3_init_state(
- noise_xxpsk3_handshake_state_t *state,
- const uint8_t psk[NOISE_XXPSK3_DHLEN],
- const uint8_t static_private_key[NOISE_XXPSK3_DHLEN],
- const uint8_t static_public_key[NOISE_XXPSK3_DHLEN],
- const uint8_t *prologue, size_t prologue_len) {
+static bool noise_xxpsk3_init_state(noise_xxpsk3_handshake_state_t *state,
+ const uint8_t *prologue,
+ size_t prologue_len) {
static const uint8_t XX_PROTOCOL_NAME[] = "Noise_XXpsk3_25519_AESGCM_SHA256";
if (prologue == NULL && prologue_len != 0) {
@@ -382,38 +379,28 @@ static bool noise_xxpsk3_init_state(
ss_init(&state->symmetric_state, XX_PROTOCOL_NAME,
sizeof(XX_PROTOCOL_NAME) - 1); // -1 substract the string terminator
- memcpy(state->static_private, static_private_key, NOISE_XXPSK3_DHLEN);
- memcpy(state->static_public, static_public_key, NOISE_XXPSK3_DHLEN);
-
ss_mix_hash(&state->symmetric_state, prologue, prologue_len);
- memcpy(state->psk, psk, NOISE_XXPSK3_DHLEN);
-
state->has_ephemeral_private = false;
state->has_remote_ephemeral_public = false;
return true;
}
#ifdef USE_NOISE_XXPSK3_RESPONDER
-bool noise_xxpsk3_responder_init(
- noise_xxpsk3_responder_t *rspn, const uint8_t psk[NOISE_XXPSK3_DHLEN],
- const uint8_t static_private_key[NOISE_XXPSK3_DHLEN],
- const uint8_t static_public_key[NOISE_XXPSK3_DHLEN]) {
+bool noise_xxpsk3_responder_init(noise_xxpsk3_responder_t *rspn) {
if (rspn == NULL) {
return false;
}
- if (rspn->initialized || psk == NULL || static_private_key == NULL ||
- static_public_key == NULL) {
+ if (rspn->initialized) {
goto cleanup;
}
// Clear the responder structure
memset(rspn, 0, sizeof(noise_xxpsk3_responder_t));
- if (!noise_xxpsk3_init_state(&rspn->handshake_state, psk, static_private_key,
- static_public_key, NULL, 0)) {
+ if (!noise_xxpsk3_init_state(&rspn->handshake_state, NULL, 0)) {
goto cleanup;
}
@@ -489,15 +476,19 @@ bool noise_xxpsk3_responder_handle_request1(
}
bool noise_xxpsk3_responder_create_response1(
- noise_xxpsk3_responder_t *rspn, const uint8_t *payload, size_t payload_size,
- uint8_t *response, size_t max_response_size, size_t *response_size) {
+ noise_xxpsk3_responder_t *rspn,
+ const uint8_t static_private_key[NOISE_XXPSK3_DHLEN],
+ const uint8_t static_public_key[NOISE_XXPSK3_DHLEN], const uint8_t *payload,
+ size_t payload_size, uint8_t *response, size_t max_response_size,
+ size_t *response_size) {
if (rspn == NULL) {
return false;
}
noise_xxpsk3_handshake_state_t *state = &rspn->handshake_state;
- if (!rspn->initialized || response == NULL || response_size == NULL ||
+ if (!rspn->initialized || static_private_key == NULL ||
+ static_public_key == NULL || response == NULL || response_size == NULL ||
rspn->handshake_stage != NOISE_XXPSK3_RSPN_READY_FOR_RESPONSE1 ||
!state->has_remote_ephemeral_public ||
(payload == NULL && payload_size != 0)) {
@@ -531,13 +522,13 @@ bool noise_xxpsk3_responder_create_response1(
memzero(input_key_material, sizeof(input_key_material));
// Encrypt static public key
- if (!ss_encrypt_and_hash(&state->symmetric_state, state->static_public,
+ if (!ss_encrypt_and_hash(&state->symmetric_state, static_public_key,
NOISE_XXPSK3_DHLEN, response + NOISE_XXPSK3_DHLEN)) {
goto cleanup;
}
- dh(&state->static_private, &state->remote_ephemeral_public,
- &input_key_material);
+ dh((const uint8_t (*)[NOISE_XXPSK3_DHLEN])static_private_key,
+ &state->remote_ephemeral_public, &input_key_material);
ss_mix_key(&state->symmetric_state, &input_key_material);
memzero(input_key_material, sizeof(input_key_material));
@@ -560,7 +551,8 @@ bool noise_xxpsk3_responder_create_response1(
}
bool noise_xxpsk3_responder_handle_request2(
- noise_xxpsk3_responder_t *rspn, const uint8_t *request, size_t request_len,
+ noise_xxpsk3_responder_t *rspn, const uint8_t psk[NOISE_XXPSK3_DHLEN],
+ const uint8_t *request, size_t request_len,
uint8_t remote_static_public_key[NOISE_XXPSK3_DHLEN], uint8_t *payload,
size_t max_payload_size, size_t *payload_size) {
if (rspn == NULL) {
@@ -569,7 +561,7 @@ bool noise_xxpsk3_responder_handle_request2(
noise_xxpsk3_handshake_state_t *state = &rspn->handshake_state;
- if (!rspn->initialized || request == NULL ||
+ if (!rspn->initialized || psk == NULL || request == NULL ||
remote_static_public_key == NULL ||
rspn->handshake_stage != NOISE_XXPSK3_RSPN_WAITING_FOR_REQUEST2 ||
!state->has_ephemeral_private ||
@@ -596,7 +588,8 @@ bool noise_xxpsk3_responder_handle_request2(
ss_mix_key(&state->symmetric_state, &input_key_material);
memzero(input_key_material, sizeof(input_key_material));
- ss_mix_key_and_hash(&state->symmetric_state, &state->psk);
+ ss_mix_key_and_hash(&state->symmetric_state,
+ (const uint8_t (*)[NOISE_XXPSK3_HASHLEN])psk);
size_t ciphertext_len =
request_len - (NOISE_XXPSK3_DHLEN + NOISE_XXPSK3_TAG_SIZE);
@@ -636,24 +629,19 @@ bool noise_xxpsk3_responder_handle_request2(
#ifdef USE_NOISE_XXPSK3_INITIATOR
-bool noise_xxpsk3_initiator_init(
- noise_xxpsk3_initiator_t *intr, const uint8_t psk[NOISE_XXPSK3_DHLEN],
- const uint8_t static_private_key[NOISE_XXPSK3_DHLEN],
- const uint8_t static_public_key[NOISE_XXPSK3_DHLEN]) {
+bool noise_xxpsk3_initiator_init(noise_xxpsk3_initiator_t *intr) {
if (intr == NULL) {
return false;
}
- if (intr->initialized || psk == NULL || static_private_key == NULL ||
- static_public_key == NULL) {
+ if (intr->initialized) {
goto cleanup;
}
// Clear the initiator structure
memset(intr, 0, sizeof(noise_xxpsk3_initiator_t));
- if (!noise_xxpsk3_init_state(&intr->handshake_state, psk, static_private_key,
- static_public_key, NULL, 0)) {
+ if (!noise_xxpsk3_init_state(&intr->handshake_state, NULL, 0)) {
goto cleanup;
}
@@ -801,13 +789,18 @@ bool noise_xxpsk3_initiator_handle_response1(
}
bool noise_xxpsk3_initiator_create_request2(
- noise_xxpsk3_initiator_t *intr, const uint8_t *payload, size_t payload_size,
- uint8_t *request, size_t max_request_size, size_t *request_size) {
+ noise_xxpsk3_initiator_t *intr,
+ const uint8_t static_private_key[NOISE_XXPSK3_DHLEN],
+ const uint8_t static_public_key[NOISE_XXPSK3_DHLEN],
+ const uint8_t psk[NOISE_XXPSK3_DHLEN], const uint8_t *payload,
+ size_t payload_size, uint8_t *request, size_t max_request_size,
+ size_t *request_size) {
if (intr == NULL) {
return false;
}
- if (!intr->initialized ||
+ if (!intr->initialized || static_private_key == NULL ||
+ static_public_key == NULL || psk == NULL ||
intr->handshake_stage != NOISE_XXPSK3_INTR_READY_FOR_REQUEST2 ||
(payload == NULL && payload_size != 0) || request == NULL ||
request_size == NULL) {
@@ -826,18 +819,19 @@ bool noise_xxpsk3_initiator_create_request2(
noise_xxpsk3_handshake_state_t *state = &intr->handshake_state;
- if (!ss_encrypt_and_hash(&state->symmetric_state, state->static_public,
+ if (!ss_encrypt_and_hash(&state->symmetric_state, static_public_key,
NOISE_XXPSK3_DHLEN, request)) {
goto cleanup;
}
uint8_t input_key_material[NOISE_XXPSK3_DHLEN] = {0};
- dh(&state->static_private, &state->remote_ephemeral_public,
- &input_key_material);
+ dh((const uint8_t (*)[NOISE_XXPSK3_DHLEN])static_private_key,
+ &state->remote_ephemeral_public, &input_key_material);
ss_mix_key(&state->symmetric_state, &input_key_material);
memzero(input_key_material, sizeof(input_key_material));
- ss_mix_key_and_hash(&state->symmetric_state, &state->psk);
+ ss_mix_key_and_hash(&state->symmetric_state,
+ (const uint8_t (*)[NOISE_XXPSK3_HASHLEN])psk);
if (!ss_encrypt_and_hash(
&state->symmetric_state, payload, payload_size,
### crypto/noise_xxpsk3.h
@@ -61,9 +61,6 @@ typedef struct {
typedef struct {
noise_xxpsk3_symmetric_state_t symmetric_state;
- uint8_t static_private[NOISE_XXPSK3_DHLEN];
- uint8_t static_public[NOISE_XXPSK3_DHLEN];
- uint8_t psk[NOISE_XXPSK3_DHLEN];
bool has_ephemeral_private;
uint8_t ephemeral_private[NOISE_XXPSK3_DHLEN];
@@ -116,8 +113,7 @@ typedef struct {
* Noise_XXpsk3_25519_AESGCM_SHA256 protocol and has to be used in the following
* order:
*
- * 1. noise_xxpsk3_initiator_init() - to initialize the initiator structure with
- * the pre-shared key and static key pair
+ * 1. noise_xxpsk3_initiator_init() - to initialize the initiator structure
* 2. noise_xxpsk3_initiator_create_request1() - to create the first message,
* which includes the initiator's ephemeral public key and an encrypted payload
* 3. noise_xxpsk3_initiator_handle_response1() - to handle the response from
@@ -134,20 +130,12 @@ typedef struct {
*/
/**
- * @brief Initialize the initiator structure with the pre-shared key and static
- * key pair.
+ * @brief Initialize the initiator structure.
*
* @param intr Pointer to the initiator structure to initialize
- * @param psk Pre-shared key for the Noise protocol (32 bytes)
- * @param static_private_key Static private key for the initiator (32 bytes)
- * @param static_public_key Static public key corresponding to
- * `static_private_key` (32 bytes)
* @return true if the initiator was initialized correctly, false otherwise
*/
-bool noise_xxpsk3_initiator_init(
- noise_xxpsk3_initiator_t *intr, const uint8_t psk[NOISE_XXPSK3_DHLEN],
- const uint8_t static_private_key[NOISE_XXPSK3_DHLEN],
- const uint8_t static_public_key[NOISE_XXPSK3_DHLEN]);
+bool noise_xxpsk3_initiator_init(noise_xxpsk3_initiator_t *intr);
/**
* @brief Deinitialize the initiator structure and clear any sensitive data.
@@ -218,6 +206,10 @@ bool noise_xxpsk3_initiator_handle_response1(
* <encrypted_static_public_key[48B]><encrypted_payload[payload_size + 16B]>
*
* @param intr Pointer to the initiator structure
+ * @param static_private_key Static private key of the initiator (32 bytes)
+ * @param static_public_key Static public key corresponding to
+ * `static_private_key` (32 bytes)
+ * @param psk Pre-shared key for the Noise protocol (32 bytes)
* @param payload Plain payload to send (may be empty)
* @param payload_size Length of the payload in bytes
* @param request Output buffer for the request message
@@ -226,8 +218,12 @@ bool noise_xxpsk3_initiator_handle_response1(
* @return true if the request was created correctly, false otherwise
*/
bool noise_xxpsk3_initiator_create_request2(
- noise_xxpsk3_initiator_t *intr, const uint8_t *payload, size_t payload_size,
- uint8_t *request, size_t max_request_size, size_t *request_size);
+ noise_xxpsk3_initiator_t *intr,
+ const uint8_t static_private_key[NOISE_XXPSK3_DHLEN],
+ const uint8_t static_public_key[NOISE_XXPSK3_DHLEN],
+ const uint8_t psk[NOISE_XXPSK3_DHLEN], const uint8_t *payload,
+ size_t payload_size, uint8_t *request, size_t max_request_size,
+ size_t *request_size);
#endif /* USE_NOISE_XXPSK3_INITIATOR */
@@ -238,8 +234,7 @@ bool noise_xxpsk3_initiator_create_request2(
* Noise_XXpsk3_25519_AESGCM_SHA256 protocol and has to be used in the following
* order:
*
- * 1. noise_xxpsk3_responder_init() - to initialize the responder structure with
- * the pre-shared key and static key pair
+ * 1. noise_xxpsk3_responder_init() - to initialize the responder structure
* 2. noise_xxpsk3_responder_handle_request1() - to handle the first message
* from the initiator and extract the initiator's ephemeral public key
* 3. noise_xxpsk3_responder_create_response1() - to create the response to the
@@ -256,20 +251,12 @@ bool noise_xxpsk3_initiator_create_request2(
*/
/**
- * @brief Initialize the responder structure with the pre-shared key and static
- * key pair.
+ * @brief Initialize the responder structure.
*
* @param rspn Pointer to the responder structure to initialize
- * @param psk Pre-shared key for the Noise protocol (32 bytes)
- * @param static_private_key Static private key for the responder (32 bytes)
- * @param static_public_key Static public key corresponding to
- * `static_private_key` (32 bytes)
* @return true if the responder was initialized correctly, false otherwise
*/
-bool noise_xxpsk3_responder_init(
- noise_xxpsk3_responder_t *rspn, const uint8_t psk[NOISE_XXPSK3_DHLEN],
- const uint8_t static_private_key[NOISE_XXPSK3_DHLEN],
- const uint8_t static_public_key[NOISE_XXPSK3_DHLEN]);
+bool noise_xxpsk3_responder_init(noise_xxpsk3_responder_t *rspn);
/**
* @brief Deinitialize the responder structure and clear any sensitive data.
@@ -310,6 +297,9 @@ bool noise_xxpsk3_responder_handle_request1(
* + 16B]>
*
* @param rspn Pointer to the responder structure
+ * @param static_private_key Static private key of the responder (32 bytes)
+ * @param static_public_key Static public key corresponding to
+ * `static_private_key` (32 bytes)
* @param payload Plain payload to send (may be empty)
* @param payload_size Length of the payload in bytes
* @param response Output buffer for the response message
@@ -319,8 +309,11 @@ bool noise_xxpsk3_responder_handle_request1(
* @return true if the response was created correctly, false otherwise
*/
bool noise_xxpsk3_responder_create_response1(
- noise_xxpsk3_responder_t *rspn, const uint8_t *payload, size_t payload_size,
- uint8_t *response, size_t max_response_size, size_t *response_size);
+ noise_xxpsk3_responder_t *rspn,
+ const uint8_t static_private_key[NOISE_XXPSK3_DHLEN],
+ const uint8_t static_public_key[NOISE_XXPSK3_DHLEN], const uint8_t *payload,
+ size_t payload_size, uint8_t *response, size_t max_response_size,
+ size_t *response_size);
/**
* @brief Handle the second handshake message.
@@ -334,6 +327,7 @@ bool noise_xxpsk3_responder_create_response1(
* Out: Decrypted payload
*
* @param rspn Pointer to the responder structure
+ * @param psk Pre-shared key for the Noise protocol (32 bytes)
* @param request Incoming request buffer
* @param request_len Length of the incoming request buffer
* @param remote_static_public_key Output buffer for the initiator's static
@@ -344,7 +338,8 @@ bool noise_xxpsk3_responder_create_response1(
* @return true if the request was handled correctly, false otherwise
*/
bool noise_xxpsk3_responder_handle_request2(
- noise_xxpsk3_responder_t *rspn, const uint8_t *request, size_t request_len,
+ noise_xxpsk3_responder_t *rspn, const uint8_t psk[NOISE_XXPSK3_DHLEN],
+ const uint8_t *request, size_t request_len,
uint8_t remote_static_public_key[NOISE_XXPSK3_DHLEN], uint8_t *payload,
size_t max_payload_size, size_t *payload_size);
### crypto/tests/test_check.c
@@ -12139,14 +12139,8 @@ static void test_noise_xxpsk3_handshake(uint32_t seed,
curve25519_scalarmult_basepoint(initiator_public_key, initiator_private_key);
curve25519_scalarmult_basepoint(responder_public_key, responder_private_key);
- ck_assert_int_eq(
- noise_xxpsk3_initiator_init(initiator, psk, initiator_private_key,
- initiator_public_key),
- true);
- ck_assert_int_eq(
- noise_xxpsk3_responder_init(responder, psk, responder_private_key,
- responder_public_key),
- true);
+ ck_assert_int_eq(noise_xxpsk3_initiator_init(initiator), true);
+ ck_assert_int_eq(noise_xxpsk3_responder_init(responder), true);
uint8_t request1[256] = {0}, response1[256] = {0}, request2[256] = {0};
size_t request1_size = 0, response1_size = 0, request2_size = 0;
@@ -12165,10 +12159,10 @@ static void test_noise_xxpsk3_handshake(uint32_t seed,
// response1 = ephemeral_public_key[32] + encrypted_static_public_key[48] +
// encrypted_payload[0 + 16]
- ck_assert_int_eq(
- noise_xxpsk3_responder_create_response1(
- responder, NULL, 0, response1, sizeof(response1), &response1_size),
- true);
+ ck_assert_int_eq(noise_xxpsk3_responder_create_response1(
+ responder, responder_private_key, responder_public_key,
+ NULL, 0, response1, sizeof(response1), &response1_size),
+ true);
ck_assert_int_eq(response1_size, 32 + 48 + 16);
ck_assert_int_eq(noise_xxpsk3_initiator_handle_response1(
initiator, response1, response1_size,
@@ -12179,12 +12173,13 @@ static void test_noise_xxpsk3_handshake(uint32_t seed,
// request2 = encrypted_static_public_key[48] + encrypted_payload[0 + 16]
ck_assert_int_eq(
- noise_xxpsk3_initiator_create_request2(initiator, NULL, 0, request2,
- sizeof(request2), &request2_size),
+ noise_xxpsk3_initiator_create_request2(
+ initiator, initiator_private_key, initiator_public_key, psk, NULL, 0,
+ request2, sizeof(request2), &request2_size),
true);
ck_assert_int_eq(request2_size, 48 + 16);
ck_assert_int_eq(noise_xxpsk3_responder_handle_request2(
- responder, request2, request2_size,
+ responder, psk, request2, request2_size,
received_initiator_public_key, NULL, 0, NULL),
true);
ck_assert_mem_eq(received_initiator_public_key, initiator_public_key,
@@ -12284,15 +12279,10 @@ START_TEST(test_noise_xxpsk3) {
NOISE_XXPSK3_HASHLEN);
// --- Double-init should fail ---
- // The arguments are irrelevant, an already initialized structure is rejected
- // before they are looked at
- uint8_t unused_key[32] = {0};
- ret = noise_xxpsk3_initiator_init(&initiator, unused_key, unused_key,
- unused_key);
+ ret = noise_xxpsk3_initiator_init(&initiator);
ck_assert_int_eq(ret, false);
- ret = noise_xxpsk3_responder_init(&responder, unused_key, unused_key,
- unused_key);
+ ret = noise_xxpsk3_responder_init(&responder);
ck_assert_int_eq(ret, false);
// Cleanup
@@ -12319,18 +12309,10 @@ START_TEST(test_noise_xxpsk3_limits) {
bool ret = false;
// --- Handshake message size limit ---
- // Any static key pair will do, the calls below are rejected on the length
- // before any key is used
random_reseed(2748932008);
- uint8_t psk[32] = "this_is_a_32byte_preshared_key!!";
- uint8_t static_private_key[32] = {0};
- uint8_t static_public_key[32] = {0};
- random_buffer(static_private_key, sizeof(static_private_key));
- curve25519_scalarmult_basepoint(static_public_key, static_private_key);
// request1 = ephemeral_public_key[32] + encrypted_payload[payload + 16]
- ret = noise_xxpsk3_initiator_init(&initiator, psk, static_private_key,
- static_public_key);
+ ret = noise_xxpsk3_initiator_init(&initiator);
ck_assert_int_eq(ret, true);
ret = noise_xxpsk3_initiator_create_request1(
&initiator, payload_buf, NOISE_XXPSK3_MAX_MESSAGE_SIZE - (32 + 16) + 1,
@@ -12339,8 +12321,7 @@ START_TEST(test_noise_xxpsk3_limits) {
// A rejected call deinitializes the initiator
ck_assert_int_eq(initiator.initialized, false);
- ret = noise_xxpsk3_responder_init(&responder, psk, static_private_key,
- static_public_key);
+ ret = noise_xxpsk3_responder_init(&responder);
ck_assert_int_eq(ret, true);
// The sentinel shows that the message was rejected for its size before it was
// decrypted, a failed tag verification would have wiped the output buffer
@@ -12547,11 +12528,9 @@ START_TEST(test_noise_xxpsk3_vectors) {
noise_xxpsk3_responder_t responder = {0};
bool ret;
- ret = noise_xxpsk3_initiator_init(&initiator, psk, initiator_private_key,
- initiator_public_key);
+ ret = noise_xxpsk3_initiator_init(&initiator);
ck_assert_int_eq(ret, true);
- ret = noise_xxpsk3_responder_init(&responder, psk, responder_private_key,
- responder_public_key);
+ ret = noise_xxpsk3_responder_init(&responder);
ck_assert_int_eq(ret, true);
uint8_t req1[512] = {0};
@@ -12573,7 +12552,8 @@ START_TEST(test_noise_xxpsk3_vectors) {
uint8_t rsp1[512] = {0};
size_t rsp1_size = 0;
ret = noise_xxpsk3_responder_create_response1(
- &responder, rsp1_payload, rsp1_plen, rsp1, sizeof(rsp1), &rsp1_size);
+ &responder, responder_private_key, responder_public_key, rsp1_payload,
+ rsp1_plen, rsp1, sizeof(rsp1), &rsp1_size);
ck_assert_int_eq(ret, true);
ck_assert_mem_eq(rsp1, fromhex(vectors[v].expected_response1), rsp1_size);
@@ -12592,16 +12572,17 @@ START_TEST(test_noise_xxpsk3_vectors) {
uint8_t req2[512] = {0};
size_t req2_size = 0;
ret = noise_xxpsk3_initiator_create_request2(
- &initiator, req2_payload, req2_plen, req2, sizeof(req2), &req2_size);
+ &initiator, initiator_private_key, initiator_public_key, psk,
+ req2_payload, req2_plen, req2, sizeof(req2), &req2_size);
ck_assert_int_eq(ret, true);
ck_assert_mem_eq(req2, fromhex(vectors[v].expected_request2), req2_size);
uint8_t req2_dec[512] = {0};
size_t req2_dec_size = 0;
uint8_t received_initiator_public_key[32] = {0};
ret = noise_xxpsk3_responder_handle_request2(
- &responder, req2, req2_size, received_initiator_public_key, req2_dec,
- sizeof(req2_dec), &req2_dec_size);
+ &responder, psk, req2, req2_size, received_initiator_public_key,
+ req2_dec, sizeof(req2_dec), &req2_dec_size);
ck_assert_int_eq(ret, true);
ck_assert_mem_eq(received_initiator_public_key, initiator_public_key,
sizeof(initiator_public_key));Why this scored 29/100
Community notes
Notes can correct, qualify, or add evidence to the AI analysis. Every note shown here has been validated by a human moderator.
The AI analysis stands alone for now. Submit a note if you can add evidence or important context.