205 lines
7.1 KiB
C
205 lines
7.1 KiB
C
/*
|
|
* NIP-04 Encryption DEBUG Test
|
|
* This test shows intermediate values to compare with JavaScript implementation
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include "../nostr_core/nip004.h"
|
|
#include "../nostr_core/nostr_common.h"
|
|
#include "../nostr_core/crypto/nostr_secp256k1.h"
|
|
#include "../nostr_core/utils.h"
|
|
|
|
void print_hex_debug(const char* label, const unsigned char* data, size_t len) {
|
|
printf("%s (%zu bytes): ", label, len);
|
|
for (size_t i = 0; i < len; i++) {
|
|
printf("%02x", data[i]);
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
void hex_to_bytes(const char* hex_str, unsigned char* bytes) {
|
|
size_t len = strlen(hex_str);
|
|
for (size_t i = 0; i < len; i += 2) {
|
|
sscanf(hex_str + i, "%2hhx", &bytes[i / 2]);
|
|
}
|
|
}
|
|
|
|
int test_ecdh_debug(void) {
|
|
printf("\n=== ECDH DEBUG TEST ===\n");
|
|
|
|
// Test vector from JavaScript debug output
|
|
const char* sk1_hex = "91ba716fa9e7ea2fcbad360cf4f8e0d312f73984da63d90f524ad61a6a1e7dbe";
|
|
const char* pk2_hex = "dcb33a629560280a0ee3b6b99b68c044fe8914ad8a984001ebf6099a9b474dc3";
|
|
|
|
// Expected values from JavaScript:
|
|
// Shared Secret (33 bytes): 037ce22696eb0e303ddaa491bdf2a56b79d249f2d861b8e012a933e01dc4beba81
|
|
// Normalized Key (32 bytes): 7ce22696eb0e303ddaa491bdf2a56b79d249f2d861b8e012a933e01dc4beba81
|
|
|
|
unsigned char sk1[32], pk2[32];
|
|
hex_to_bytes(sk1_hex, sk1);
|
|
hex_to_bytes(pk2_hex, pk2);
|
|
|
|
printf("Private Key: %s\n", sk1_hex);
|
|
printf("Public Key: %s\n", pk2_hex);
|
|
|
|
print_hex_debug("SK1", sk1, 32);
|
|
print_hex_debug("PK2", pk2, 32);
|
|
|
|
// Test ECDH shared secret computation
|
|
unsigned char shared_secret[32];
|
|
printf("\nCalling ecdh_shared_secret...\n");
|
|
int result = ecdh_shared_secret(sk1, pk2, shared_secret);
|
|
printf("ecdh_shared_secret returned: %d\n", result);
|
|
|
|
if (result == 0) {
|
|
print_hex_debug("C Shared Secret", shared_secret, 32);
|
|
printf("Expected: 7ce22696eb0e303ddaa491bdf2a56b79d249f2d861b8e012a933e01dc4beba81\n");
|
|
|
|
// Check if it matches expected
|
|
const char* expected_hex = "7ce22696eb0e303ddaa491bdf2a56b79d249f2d861b8e012a933e01dc4beba81";
|
|
unsigned char expected[32];
|
|
hex_to_bytes(expected_hex, expected);
|
|
|
|
if (memcmp(shared_secret, expected, 32) == 0) {
|
|
printf("✅ ECDH matches expected value!\n");
|
|
return 1;
|
|
} else {
|
|
printf("❌ ECDH does NOT match expected value\n");
|
|
print_hex_debug("Expected", expected, 32);
|
|
return 0;
|
|
}
|
|
} else {
|
|
printf("❌ ECDH computation failed with error code: %d\n", result);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int test_encryption_step_by_step(void) {
|
|
printf("\n=== STEP-BY-STEP ENCRYPTION DEBUG ===\n");
|
|
|
|
// Test vector 1 data
|
|
const char* sk1_hex = "91ba716fa9e7ea2fcbad360cf4f8e0d312f73984da63d90f524ad61a6a1e7dbe";
|
|
const char* pk2_hex = "dcb33a629560280a0ee3b6b99b68c044fe8914ad8a984001ebf6099a9b474dc3";
|
|
const char* plaintext = "nanana";
|
|
|
|
// Known IV from JavaScript test (to get deterministic results)
|
|
const char* fixed_iv_hex = "115e5b52371ce0e5f62a6ff33e9e2775";
|
|
|
|
printf("Private Key: %s\n", sk1_hex);
|
|
printf("Public Key: %s\n", pk2_hex);
|
|
printf("Plaintext: \"%s\"\n", plaintext);
|
|
printf("Fixed IV: %s\n", fixed_iv_hex);
|
|
|
|
unsigned char sk1[32], pk2[32], fixed_iv[16];
|
|
hex_to_bytes(sk1_hex, sk1);
|
|
hex_to_bytes(pk2_hex, pk2);
|
|
hex_to_bytes(fixed_iv_hex, fixed_iv);
|
|
|
|
// Step 1: ECDH
|
|
printf("\n--- Step 1: ECDH Shared Secret ---\n");
|
|
unsigned char shared_secret[32];
|
|
if (ecdh_shared_secret(sk1, pk2, shared_secret) != 0) {
|
|
printf("❌ ECDH failed\n");
|
|
return 0;
|
|
}
|
|
print_hex_debug("Shared Secret", shared_secret, 32);
|
|
printf("Expected: 7ce22696eb0e303ddaa491bdf2a56b79d249f2d861b8e012a933e01dc4beba81\n");
|
|
|
|
// Step 2: Convert plaintext to bytes
|
|
printf("\n--- Step 2: Plaintext to UTF-8 bytes ---\n");
|
|
size_t plaintext_len = strlen(plaintext);
|
|
printf("UTF-8 Plaintext (%zu bytes): ", plaintext_len);
|
|
for (size_t i = 0; i < plaintext_len; i++) {
|
|
printf("%02x", (unsigned char)plaintext[i]);
|
|
}
|
|
printf("\n");
|
|
printf("Expected: 6e616e616e61\n");
|
|
|
|
// Step 3: PKCS#7 padding
|
|
printf("\n--- Step 3: PKCS#7 Padding ---\n");
|
|
size_t padded_len = ((plaintext_len / 16) + 1) * 16;
|
|
unsigned char* padded_data = malloc(padded_len);
|
|
if (!padded_data) {
|
|
printf("❌ Memory allocation failed\n");
|
|
return 0;
|
|
}
|
|
|
|
memcpy(padded_data, plaintext, plaintext_len);
|
|
|
|
// Manual PKCS#7 padding for debugging
|
|
size_t padding_needed = 16 - (plaintext_len % 16);
|
|
for (size_t i = 0; i < padding_needed; i++) {
|
|
padded_data[plaintext_len + i] = (unsigned char)padding_needed;
|
|
}
|
|
size_t actual_padded_len = plaintext_len + padding_needed;
|
|
|
|
print_hex_debug("Padded Data", padded_data, actual_padded_len);
|
|
printf("Padding bytes added: %zu (value: 0x%02x)\n", padding_needed, (unsigned char)padding_needed);
|
|
|
|
// Step 4: Try calling the full encryption function
|
|
printf("\n--- Step 4: Full Encryption Function ---\n");
|
|
char* encrypted = malloc(NOSTR_NIP04_MAX_ENCRYPTED_SIZE);
|
|
if (!encrypted) {
|
|
printf("❌ Memory allocation failed\n");
|
|
free(padded_data);
|
|
return 0;
|
|
}
|
|
|
|
printf("Calling nostr_nip04_encrypt...\n");
|
|
int result = nostr_nip04_encrypt(sk1, pk2, plaintext, encrypted, NOSTR_NIP04_MAX_ENCRYPTED_SIZE);
|
|
printf("nostr_nip04_encrypt returned: %d (%s)\n", result, nostr_strerror(result));
|
|
|
|
if (result == NOSTR_SUCCESS) {
|
|
printf("✅ Encryption succeeded!\n");
|
|
printf("Result: %s\n", encrypted);
|
|
printf("Expected: zJxfaJ32rN5Dg1ODjOlEew==?iv=EV5bUjcc4OX2Km/zPp4ndQ==\n");
|
|
} else {
|
|
printf("❌ Encryption failed with error: %s\n", nostr_strerror(result));
|
|
}
|
|
|
|
free(padded_data);
|
|
free(encrypted);
|
|
return result == NOSTR_SUCCESS ? 1 : 0;
|
|
}
|
|
|
|
int main(void) {
|
|
printf("=== NIP-04 DEBUG TEST ===\n");
|
|
printf("This test shows intermediate values for comparison with JavaScript implementation\n\n");
|
|
|
|
// Initialize secp256k1 context
|
|
printf("Initializing secp256k1 context...\n");
|
|
if (!nostr_secp256k1_context_create()) {
|
|
printf("❌ Failed to initialize secp256k1 context!\n");
|
|
return 1;
|
|
}
|
|
printf("✅ secp256k1 context initialized successfully\n\n");
|
|
|
|
int all_passed = 1;
|
|
|
|
// Test 1: ECDH computation
|
|
if (!test_ecdh_debug()) {
|
|
all_passed = 0;
|
|
printf("❌ ECDH test failed - this is likely the root cause!\n");
|
|
}
|
|
|
|
// Test 2: Step by step encryption
|
|
if (!test_encryption_step_by_step()) {
|
|
all_passed = 0;
|
|
}
|
|
|
|
// Summary
|
|
printf("\n=== SUMMARY ===\n");
|
|
if (all_passed) {
|
|
printf("✅ All debug tests passed!\n");
|
|
} else {
|
|
printf("❌ Some debug tests failed - compare values with JavaScript output\n");
|
|
}
|
|
|
|
// Clean up secp256k1 context
|
|
nostr_secp256k1_context_destroy();
|
|
|
|
return all_passed ? 0 : 1;
|
|
}
|