laantungir/n_signer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 40 Wiki Activity
Files
master
n_signer/tests/test_algorithm_api.c

789 lines
37 KiB
C
Raw Permalink Blame History

/* test_algorithm_api.c — Tests for the algorithm-based API.
*
* Tests the new verbs: sign, verify, encapsulate, decapsulate,
* derive_shared_secret, and the algorithm-based get_public_key.
* Also tests old verb aliases and enforcement.
*/
/* NSIGNER_HEADERLESS_DECLS_BEGIN */
#include <stddef.h>
#include <stdint.h>
#include <sys/types.h>
#include <cJSON.h>
/* from secure_mem.h */
typedef struct {
void *data;
size_t size;
int locked;
} secure_buf_t;
int secure_buf_alloc(secure_buf_t *buf, size_t size);
void secure_buf_free(secure_buf_t *buf);
void secure_memzero(void *ptr, size_t len);
/* from mnemonic.h */
#define MNEMONIC_MAX_LEN 256
typedef struct {
secure_buf_t buf;
int loaded;
int word_count;
} mnemonic_state_t;
void mnemonic_init(mnemonic_state_t *state);
int mnemonic_load(mnemonic_state_t *state, const char *phrase);
void mnemonic_unload(mnemonic_state_t *state);
int mnemonic_is_loaded(const mnemonic_state_t *state);
const char *mnemonic_get_phrase(const mnemonic_state_t *state);
/* from role_table.h */
#define ROLE_NAME_MAX 64
#define ROLE_PATH_MAX 128
#define ROLE_PURPOSE_MAX 32
#define ROLE_CURVE_MAX 16
#define ROLE_PUBKEY_HEX_MAX 66
#define ROLE_TABLE_MAX_ENTRIES 256
typedef enum { PURPOSE_NOSTR=0, PURPOSE_BITCOIN, PURPOSE_SSH, PURPOSE_AGE, PURPOSE_FIPS, PURPOSE_PQ_SIG, PURPOSE_PQ_KEM, PURPOSE_UNKNOWN } role_purpose_t;
typedef enum { CURVE_SECP256K1=0, CURVE_ED25519, CURVE_X25519, CURVE_ML_DSA_65, CURVE_SLH_DSA_128S, CURVE_ML_KEM_768, CURVE_UNKNOWN } role_curve_t;
typedef enum { SELECTOR_NOSTR_INDEX, SELECTOR_ROLE_PATH } role_selector_type_t;
typedef struct {
char name[ROLE_NAME_MAX];
char purpose_str[ROLE_PURPOSE_MAX];
char curve_str[ROLE_CURVE_MAX];
role_purpose_t purpose;
role_curve_t curve;
role_selector_type_t selector_type;
int nostr_index;
char role_path[ROLE_PATH_MAX];
char pubkey_hex[ROLE_PUBKEY_HEX_MAX];
int derived;
} role_entry_t;
typedef struct { role_entry_t entries[ROLE_TABLE_MAX_ENTRIES]; int count; } role_table_t;
void role_table_init(role_table_t *table);
int role_table_add(role_table_t *table, const role_entry_t *entry);
role_entry_t *role_table_find_by_name(role_table_t *table, const char *name);
role_purpose_t role_purpose_from_str(const char *s);
role_curve_t role_curve_from_str(const char *s);
/* from enforcement.h */
#define ENFORCE_OK 0
#define ENFORCE_ERR_PURPOSE -1
#define ENFORCE_ERR_CURVE -2
#define ENFORCE_ERR_UNKNOWN_VERB -3
#define ENFORCE_ERR_ALGORITHM -4
#define VERB_SIGN "sign"
#define VERB_VERIFY "verify"
#define VERB_ENCAPSULATE "encapsulate"
#define VERB_DECAPSULATE "decapsulate"
#define VERB_DERIVE_SHARED "derive_shared_secret"
#define VERB_DERIVE "derive"
#define VERB_GET_PUBLIC_KEY "get_public_key"
#define VERB_NOSTR_GET_PUBLIC_KEY "nostr_get_public_key"
#define VERB_NOSTR_SIGN_EVENT "nostr_sign_event"
#define VERB_NOSTR_MINE_EVENT "nostr_mine_event"
#define VERB_NOSTR_NIP44_ENCRYPT "nostr_nip44_encrypt"
#define VERB_NOSTR_NIP44_DECRYPT "nostr_nip44_decrypt"
#define VERB_NOSTR_NIP04_ENCRYPT "nostr_nip04_encrypt"
#define VERB_NOSTR_NIP04_DECRYPT "nostr_nip04_decrypt"
int enforce_verb_role(const char *verb, const role_entry_t *role);
const char *enforce_strerror(int err);
/* from policy.h */
#define POLICY_MAX_ENTRIES 32
#define POLICY_MAX_VERBS 16
#define POLICY_MAX_ROLES 16
#define POLICY_MAX_PURPOSES 8
#define POLICY_VERB_MAX_LEN 32
#define POLICY_CALLER_MAX_LEN 160
#define POLICY_MAX_ALGS 16
typedef enum { PROMPT_NEVER=0, PROMPT_FIRST_PER_BOOT, PROMPT_EVERY_REQUEST, PROMPT_DENY } prompt_mode_t;
typedef enum { POLICY_SOURCE_DEFAULT=0, POLICY_SOURCE_PREAPPROVE, POLICY_SOURCE_SESSION_GRANT } policy_source_t;
typedef struct {
char caller[POLICY_CALLER_MAX_LEN];
char verbs[POLICY_MAX_VERBS][POLICY_VERB_MAX_LEN];
int verb_count;
char roles[POLICY_MAX_ROLES][ROLE_NAME_MAX];
int role_count;
char purposes[POLICY_MAX_PURPOSES][ROLE_PURPOSE_MAX];
int purpose_count;
char algorithms[16][32];
int alg_count;
int index_min;
int index_max;
prompt_mode_t prompt;
policy_source_t source;
} policy_entry_t;
typedef struct { policy_entry_t entries[POLICY_MAX_ENTRIES]; int count; } policy_table_t;
#define POLICY_ALLOW 0
#define POLICY_DENY -1
#define POLICY_PROMPT -2
#define POLICY_NO_MATCH -3
void policy_table_init(policy_table_t *table);
void policy_init_default(policy_table_t *table, uid_t owner_uid);
int policy_table_add(policy_table_t *table, const policy_entry_t *entry);
int policy_check(const policy_table_t *table, const char *caller_id,
const char *verb, const char *role_name, const char *purpose,
policy_source_t *out_source);
int policy_check_algorithm(const policy_table_t *table, const char *caller_id,
const char *verb, const char *algorithm, int index,
policy_source_t *out_source);
/* from pq_crypto.h */
typedef enum { CRYPTO_ALG_SECP256K1=0, CRYPTO_ALG_ED25519, CRYPTO_ALG_X25519, CRYPTO_ALG_ML_DSA_65, CRYPTO_ALG_SLH_DSA_128S, CRYPTO_ALG_ML_KEM_768, CRYPTO_ALG_UNKNOWN } crypto_alg_t;
typedef struct { size_t priv_key_len; size_t pub_key_len; size_t sig_len; size_t ciphertext_len; size_t shared_secret_len; } crypto_alg_sizes_t;
const crypto_alg_sizes_t *crypto_alg_get_sizes(crypto_alg_t alg);
crypto_alg_t crypto_alg_from_role(role_curve_t curve, role_purpose_t purpose);
const char *crypto_alg_to_str(crypto_alg_t alg);
crypto_alg_t crypto_alg_from_str(const char *s);
int crypto_ed25519_keygen_from_seed(const unsigned char *seed, size_t seed_len, unsigned char *priv_out, unsigned char *pub_out);
int crypto_ed25519_sign(const unsigned char *priv, size_t priv_len, const unsigned char *msg, size_t msg_len, unsigned char *sig_out, size_t *sig_out_len);
int crypto_ed25519_verify(const unsigned char *pub, size_t pub_len, const unsigned char *msg, size_t msg_len, const unsigned char *sig, size_t sig_len);
int crypto_x25519_keygen_from_seed(const unsigned char *seed, size_t seed_len, unsigned char *priv_out, unsigned char *pub_out);
int crypto_x25519_ecdh(const unsigned char *our_priv, size_t priv_len, const unsigned char *peer_pub, size_t pub_len, unsigned char *shared_out, size_t *shared_out_len);
int crypto_derive_seed_from_mnemonic(const char *mnemonic, const char *path, unsigned char *seed_out, size_t seed_out_len);
int crypto_ml_dsa_65_keygen_from_seed(const unsigned char *seed, size_t seed_len, unsigned char *priv_out, unsigned char *pub_out);
int crypto_ml_dsa_65_sign(const unsigned char *priv, size_t priv_len, const unsigned char *msg, size_t msg_len, unsigned char *sig_out, size_t *sig_out_len);
int crypto_ml_dsa_65_verify(const unsigned char *pub, size_t pub_len, const unsigned char *msg, size_t msg_len, const unsigned char *sig, size_t sig_len);
int crypto_slh_dsa_128s_keygen_from_seed(const unsigned char *seed, size_t seed_len, unsigned char *priv_out, unsigned char *pub_out);
int crypto_slh_dsa_128s_sign(const unsigned char *priv, size_t priv_len, const unsigned char *msg, size_t msg_len, unsigned char *sig_out, size_t *sig_out_len);
int crypto_slh_dsa_128s_verify(const unsigned char *pub, size_t pub_len, const unsigned char *msg, size_t msg_len, const unsigned char *sig, size_t sig_len);
int crypto_ml_kem_768_keygen_from_seed(const unsigned char *seed, size_t seed_len, unsigned char *priv_out, unsigned char *pub_out);
int crypto_ml_kem_768_encaps(const unsigned char *pub, size_t pub_len, unsigned char *ct_out, unsigned char *ss_out);
int crypto_ml_kem_768_decaps(const unsigned char *priv, size_t priv_len, const unsigned char *ct, size_t ct_len, unsigned char *ss_out);
void pq_drbg_init(const unsigned char *seed, size_t seed_len);
int pq_drbg_randombytes(unsigned char *buf, size_t len);
void pq_drbg_zeroize(void);
/* from alg_api.h */
int enforce_verb_algorithm(const char *verb, crypto_alg_t alg);
int crypto_secp256k1_schnorr_sign(const unsigned char *priv, size_t priv_len, const unsigned char *msg, size_t msg_len, unsigned char *sig_out, size_t *sig_out_len);
int crypto_secp256k1_schnorr_verify(const unsigned char *pub, size_t pub_len, const unsigned char *msg, size_t msg_len, const unsigned char *sig, size_t sig_len);
int crypto_secp256k1_ecdsa_sign(const unsigned char *priv, size_t priv_len, const unsigned char *msg, size_t msg_len, unsigned char *sig_out, size_t *sig_out_len);
int crypto_secp256k1_ecdsa_verify(const unsigned char *pub, size_t pub_len, const unsigned char *msg, size_t msg_len, const unsigned char *sig, size_t sig_len);
#define ALG_KEY_CACHE_MAX 32
typedef struct {
crypto_alg_t alg;
int index;
secure_buf_t private_key;
secure_buf_t public_key;
char pubkey_hex[8192];
char key_id[17];
int valid;
} alg_key_entry_t;
typedef struct { alg_key_entry_t entries[ALG_KEY_CACHE_MAX]; int count; } algorithm_key_cache_t;
void alg_key_cache_init(algorithm_key_cache_t *cache);
void alg_key_cache_wipe(algorithm_key_cache_t *cache);
const alg_key_entry_t *alg_key_cache_get(algorithm_key_cache_t *cache, crypto_alg_t alg, int index);
int alg_key_cache_derive(algorithm_key_cache_t *cache, const mnemonic_state_t *mnemonic, crypto_alg_t alg, int index);
/* from crypto.h */
typedef struct {
secure_buf_t private_key;
secure_buf_t public_key;
char pubkey_hex[8192];
char npub[128];
crypto_alg_t alg;
int valid;
} derived_key_t;
typedef struct { derived_key_t keys[ROLE_TABLE_MAX_ENTRIES]; int count; } key_store_t;
int crypto_derive_all(key_store_t *store, role_table_t *table, const mnemonic_state_t *mnemonic);
const unsigned char *crypto_get_private_key(const key_store_t *store, int role_index);
const char *crypto_get_pubkey_hex(const key_store_t *store, int role_index);
char *crypto_sign_event(const key_store_t *store, int role_index, const char *event_json);
void crypto_wipe(key_store_t *store);
/* from dispatcher.h */
typedef struct {
role_table_t *role_table;
mnemonic_state_t *mnemonic;
key_store_t *key_store;
algorithm_key_cache_t *alg_key_cache;
} dispatcher_ctx_t;
void dispatcher_init(dispatcher_ctx_t *ctx, role_table_t *table, mnemonic_state_t *mnemonic, key_store_t *key_store, algorithm_key_cache_t *alg_key_cache);
char *dispatcher_handle_request(dispatcher_ctx_t *ctx, const char *json_request);
/* from main.h */
#define NSIGNER_VERSION "v0.0.2"
/* NSIGNER_HEADERLESS_DECLS_END */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <nostr_core/utils.h>
#include <nostr_core/nostr_common.h>
static int g_passes = 0;
static int g_total = 0;
static void check(const char *name, int condition) {
g_total++;
if (condition) {
printf("PASS: %s\n", name);
g_passes++;
} else {
printf("FAIL: %s\n", name);
}
}
static int resp_has(const char *resp, const char *needle) {
return (resp != NULL && needle != NULL && strstr(resp, needle) != NULL);
}
/* Extract a string field from a JSON result object embedded in a response.
* The response format is {"id":"...","result":"{...}"} where the result
* value is a JSON string. This extracts the result string, parses it,
* and returns the value of the given field. Caller must free. */
static char *extract_result_field(const char *response, const char *field) {
cJSON *root, *result_item, *result_obj, *field_item;
char *out = NULL;
if (response == NULL || field == NULL) return NULL;
root = cJSON_Parse(response);
if (root == NULL) return NULL;
result_item = cJSON_GetObjectItemCaseSensitive(root, "result");
if (!cJSON_IsString(result_item) || result_item->valuestring == NULL) {
cJSON_Delete(root);
return NULL;
}
result_obj = cJSON_Parse(result_item->valuestring);
if (result_obj == NULL) {
cJSON_Delete(root);
return NULL;
}
field_item = cJSON_GetObjectItemCaseSensitive(result_obj, field);
if (cJSON_IsString(field_item) && field_item->valuestring != NULL) {
out = strdup(field_item->valuestring);
}
cJSON_Delete(result_obj);
cJSON_Delete(root);
return out;
}
static int extract_result_bool(const char *response, const char *field) {
cJSON *root, *result_item, *result_obj, *field_item;
int val = -1;
if (response == NULL || field == NULL) return -1;
root = cJSON_Parse(response);
if (root == NULL) return -1;
result_item = cJSON_GetObjectItemCaseSensitive(root, "result");
if (!cJSON_IsString(result_item) || result_item->valuestring == NULL) {
cJSON_Delete(root);
return -1;
}
result_obj = cJSON_Parse(result_item->valuestring);
if (result_obj == NULL) {
cJSON_Delete(root);
return -1;
}
field_item = cJSON_GetObjectItemCaseSensitive(result_obj, field);
if (cJSON_IsBool(field_item)) {
val = cJSON_IsTrue(field_item) ? 1 : 0;
}
cJSON_Delete(result_obj);
cJSON_Delete(root);
return val;
}
/* File-level statics to avoid stack overflow (key_store_t is ~2.1MB) */
static key_store_t g_key_store;
static algorithm_key_cache_t g_alg_key_cache;
static mnemonic_state_t g_mnemonic;
static role_table_t g_role_table;
static dispatcher_ctx_t g_dispatcher;
int main(void) {
const char *valid_12 = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
char *resp;
char *sig_hex;
char *pub_hex;
char *ct_hex;
char *ss_hex1;
char *ss_hex2;
char *shared_hex;
char request[32768];
int rc;
/* ---- Setup ---- */
role_table_init(&g_role_table);
{
role_entry_t main_role;
memset(&main_role, 0, sizeof(main_role));
strncpy(main_role.name, "main", sizeof(main_role.name) - 1);
strncpy(main_role.purpose_str, "nostr", sizeof(main_role.purpose_str) - 1);
strncpy(main_role.curve_str, "secp256k1", sizeof(main_role.curve_str) - 1);
main_role.purpose = role_purpose_from_str("nostr");
main_role.curve = role_curve_from_str("secp256k1");
main_role.selector_type = SELECTOR_NOSTR_INDEX;
main_role.nostr_index = 0;
role_table_add(&g_role_table, &main_role);
}
mnemonic_init(&g_mnemonic);
rc = mnemonic_load(&g_mnemonic, valid_12);
check("mnemonic_load succeeds", rc == 0);
memset(&g_key_store, 0, sizeof(g_key_store));
alg_key_cache_init(&g_alg_key_cache);
rc = nostr_init();
check("nostr_init succeeds", rc == 0);
crypto_derive_all(&g_key_store, &g_role_table, &g_mnemonic);
dispatcher_init(&g_dispatcher, &g_role_table, &g_mnemonic, &g_key_store, &g_alg_key_cache);
/* ---- Enforcement tests ---- */
check("enforce sign + ed25519 -> OK",
enforce_verb_algorithm(VERB_SIGN, CRYPTO_ALG_ED25519) == ENFORCE_OK);
check("enforce sign + secp256k1 -> OK",
enforce_verb_algorithm(VERB_SIGN, CRYPTO_ALG_SECP256K1) == ENFORCE_OK);
check("enforce sign + ml-dsa-65 -> OK",
enforce_verb_algorithm(VERB_SIGN, CRYPTO_ALG_ML_DSA_65) == ENFORCE_OK);
check("enforce sign + slh-dsa-128s -> OK",
enforce_verb_algorithm(VERB_SIGN, CRYPTO_ALG_SLH_DSA_128S) == ENFORCE_OK);
check("enforce sign + x25519 -> ALGORITHM err",
enforce_verb_algorithm(VERB_SIGN, CRYPTO_ALG_X25519) == ENFORCE_ERR_ALGORITHM);
check("enforce sign + ml-kem-768 -> ALGORITHM err",
enforce_verb_algorithm(VERB_SIGN, CRYPTO_ALG_ML_KEM_768) == ENFORCE_ERR_ALGORITHM);
check("enforce encapsulate + ml-kem-768 -> OK",
enforce_verb_algorithm(VERB_ENCAPSULATE, CRYPTO_ALG_ML_KEM_768) == ENFORCE_OK);
check("enforce encapsulate + ed25519 -> ALGORITHM err",
enforce_verb_algorithm(VERB_ENCAPSULATE, CRYPTO_ALG_ED25519) == ENFORCE_ERR_ALGORITHM);
check("enforce decapsulate + ml-kem-768 -> OK",
enforce_verb_algorithm(VERB_DECAPSULATE, CRYPTO_ALG_ML_KEM_768) == ENFORCE_OK);
check("enforce derive_shared_secret + x25519 -> OK",
enforce_verb_algorithm(VERB_DERIVE_SHARED, CRYPTO_ALG_X25519) == ENFORCE_OK);
check("enforce derive_shared_secret + ed25519 -> ALGORITHM err",
enforce_verb_algorithm(VERB_DERIVE_SHARED, CRYPTO_ALG_ED25519) == ENFORCE_ERR_ALGORITHM);
check("enforce derive + secp256k1 -> OK",
enforce_verb_algorithm(VERB_DERIVE, CRYPTO_ALG_SECP256K1) == ENFORCE_OK);
check("enforce derive + ed25519 -> ALGORITHM err",
enforce_verb_algorithm(VERB_DERIVE, CRYPTO_ALG_ED25519) == ENFORCE_ERR_ALGORITHM);
check("enforce derive + x25519 -> ALGORITHM err",
enforce_verb_algorithm(VERB_DERIVE, CRYPTO_ALG_X25519) == ENFORCE_ERR_ALGORITHM);
check("enforce derive + ml-kem-768 -> ALGORITHM err",
enforce_verb_algorithm(VERB_DERIVE, CRYPTO_ALG_ML_KEM_768) == ENFORCE_ERR_ALGORITHM);
check("enforce get_public_key + any alg -> OK",
enforce_verb_algorithm(VERB_GET_PUBLIC_KEY, CRYPTO_ALG_ED25519) == ENFORCE_OK);
check("enforce nostr_sign_event + secp256k1 -> OK",
enforce_verb_algorithm(VERB_NOSTR_SIGN_EVENT, CRYPTO_ALG_SECP256K1) == ENFORCE_OK);
check("enforce nostr_sign_event + ed25519 -> ALGORITHM err",
enforce_verb_algorithm(VERB_NOSTR_SIGN_EVENT, CRYPTO_ALG_ED25519) == ENFORCE_ERR_ALGORITHM);
/* ---- get_public_key with algorithm parameter ---- */
resp = dispatcher_handle_request(&g_dispatcher,
"{\"id\":\"gpk1\",\"method\":\"get_public_key\",\"params\":[{\"algorithm\":\"ed25519\",\"index\":0}]}");
check("get_public_key algorithm=ed25519 returns result",
resp_has(resp, "\"result\""));
check("get_public_key algorithm=ed25519 has algorithm field",
resp_has(resp, "ed25519"));
check("get_public_key algorithm=ed25519 has public_key field",
resp_has(resp, "public_key"));
check("get_public_key algorithm=ed25519 has key_id field",
resp_has(resp, "key_id"));
free(resp);
resp = dispatcher_handle_request(&g_dispatcher,
"{\"id\":\"gpk2\",\"method\":\"get_public_key\",\"params\":[{\"algorithm\":\"ml-dsa-65\",\"index\":0}]}");
check("get_public_key algorithm=ml-dsa-65 returns result",
resp_has(resp, "\"result\""));
check("get_public_key algorithm=ml-dsa-65 has algorithm field",
resp_has(resp, "ml-dsa-65"));
free(resp);
/* ---- sign + verify roundtrip: ed25519 ---- */
resp = dispatcher_handle_request(&g_dispatcher,
"{\"id\":\"s1\",\"method\":\"sign\",\"params\":[\"68656c6c6f\",{\"algorithm\":\"ed25519\",\"index\":0}]}");
check("sign ed25519 returns result",
resp_has(resp, "\"result\""));
check("sign ed25519 has signature field",
resp_has(resp, "signature"));
check("sign ed25519 has algorithm ed25519",
resp_has(resp, "ed25519"));
check("sign ed25519 has key_id",
resp_has(resp, "key_id"));
sig_hex = extract_result_field(resp, "signature");
free(resp);
check("sign ed25519 extracted signature", sig_hex != NULL && strlen(sig_hex) > 0);
if (sig_hex) {
snprintf(request, sizeof(request),
"{\"id\":\"v1\",\"method\":\"verify\",\"params\":[\"68656c6c6f\",\"%s\",{\"algorithm\":\"ed25519\",\"index\":0}]}",
sig_hex);
resp = dispatcher_handle_request(&g_dispatcher, request);
check("verify ed25519 returns result", resp_has(resp, "\"result\""));
check("verify ed25519 valid:true", extract_result_bool(resp, "valid") == 1);
free(resp);
/* verify with wrong message */
snprintf(request, sizeof(request),
"{\"id\":\"v2\",\"method\":\"verify\",\"params\":[\"776f726c64\",\"%s\",{\"algorithm\":\"ed25519\",\"index\":0}]}",
sig_hex);
resp = dispatcher_handle_request(&g_dispatcher, request);
check("verify ed25519 wrong msg valid:false", extract_result_bool(resp, "valid") == 0);
free(resp);
free(sig_hex);
}
/* ---- sign + verify roundtrip: ml-dsa-65 ---- */
resp = dispatcher_handle_request(&g_dispatcher,
"{\"id\":\"s2\",\"method\":\"sign\",\"params\":[\"68656c6c6f\",{\"algorithm\":\"ml-dsa-65\",\"index\":0}]}");
check("sign ml-dsa-65 returns result", resp_has(resp, "\"result\""));
check("sign ml-dsa-65 has signature", resp_has(resp, "signature"));
sig_hex = extract_result_field(resp, "signature");
free(resp);
check("sign ml-dsa-65 extracted signature", sig_hex != NULL && strlen(sig_hex) > 0);
if (sig_hex) {
snprintf(request, sizeof(request),
"{\"id\":\"v3\",\"method\":\"verify\",\"params\":[\"68656c6c6f\",\"%s\",{\"algorithm\":\"ml-dsa-65\",\"index\":0}]}",
sig_hex);
resp = dispatcher_handle_request(&g_dispatcher, request);
check("verify ml-dsa-65 valid:true", extract_result_bool(resp, "valid") == 1);
free(resp);
free(sig_hex);
}
/* ---- sign + verify roundtrip: slh-dsa-128s ---- */
resp = dispatcher_handle_request(&g_dispatcher,
"{\"id\":\"s3\",\"method\":\"sign\",\"params\":[\"68656c6c6f\",{\"algorithm\":\"slh-dsa-128s\",\"index\":0}]}");
check("sign slh-dsa-128s returns result", resp_has(resp, "\"result\""));
sig_hex = extract_result_field(resp, "signature");
free(resp);
check("sign slh-dsa-128s extracted signature", sig_hex != NULL && strlen(sig_hex) > 0);
if (sig_hex) {
snprintf(request, sizeof(request),
"{\"id\":\"v4\",\"method\":\"verify\",\"params\":[\"68656c6c6f\",\"%s\",{\"algorithm\":\"slh-dsa-128s\",\"index\":0}]}",
sig_hex);
resp = dispatcher_handle_request(&g_dispatcher, request);
check("verify slh-dsa-128s valid:true", extract_result_bool(resp, "valid") == 1);
free(resp);
free(sig_hex);
}
/* ---- sign + verify roundtrip: secp256k1 schnorr ---- */
resp = dispatcher_handle_request(&g_dispatcher,
"{\"id\":\"s4\",\"method\":\"sign\",\"params\":[\"68656c6c6f\",{\"algorithm\":\"secp256k1\",\"index\":0,\"scheme\":\"schnorr\"}]}");
check("sign secp256k1 schnorr returns result", resp_has(resp, "\"result\""));
sig_hex = extract_result_field(resp, "signature");
free(resp);
check("sign secp256k1 schnorr extracted signature", sig_hex != NULL && strlen(sig_hex) == 128);
if (sig_hex) {
snprintf(request, sizeof(request),
"{\"id\":\"v5\",\"method\":\"verify\",\"params\":[\"68656c6c6f\",\"%s\",{\"algorithm\":\"secp256k1\",\"index\":0,\"scheme\":\"schnorr\"}]}",
sig_hex);
resp = dispatcher_handle_request(&g_dispatcher, request);
check("verify secp256k1 schnorr valid:true", extract_result_bool(resp, "valid") == 1);
free(resp);
free(sig_hex);
}
/* ---- sign + verify roundtrip: secp256k1 ecdsa ---- */
resp = dispatcher_handle_request(&g_dispatcher,
"{\"id\":\"s5\",\"method\":\"sign\",\"params\":[\"68656c6c6f\",{\"algorithm\":\"secp256k1\",\"index\":0,\"scheme\":\"ecdsa\"}]}");
check("sign secp256k1 ecdsa returns result", resp_has(resp, "\"result\""));
sig_hex = extract_result_field(resp, "signature");
free(resp);
check("sign secp256k1 ecdsa extracted signature", sig_hex != NULL && strlen(sig_hex) == 128);
if (sig_hex) {
snprintf(request, sizeof(request),
"{\"id\":\"v6\",\"method\":\"verify\",\"params\":[\"68656c6c6f\",\"%s\",{\"algorithm\":\"secp256k1\",\"index\":0,\"scheme\":\"ecdsa\"}]}",
sig_hex);
resp = dispatcher_handle_request(&g_dispatcher, request);
check("verify secp256k1 ecdsa valid:true", extract_result_bool(resp, "valid") == 1);
free(resp);
free(sig_hex);
}
/* ---- encapsulate + decapsulate: ml-kem-768 ---- */
/* First get our ML-KEM public key */
resp = dispatcher_handle_request(&g_dispatcher,
"{\"id\":\"gpk3\",\"method\":\"get_public_key\",\"params\":[{\"algorithm\":\"ml-kem-768\",\"index\":0}]}");
pub_hex = extract_result_field(resp, "public_key");
check("get_public_key ml-kem-768 returns public_key", pub_hex != NULL && strlen(pub_hex) > 0);
free(resp);
if (pub_hex) {
/* Encapsulate with our own public key (for testing) */
snprintf(request, sizeof(request),
"{\"id\":\"e1\",\"method\":\"encapsulate\",\"params\":[\"%s\",{\"algorithm\":\"ml-kem-768\"}]}",
pub_hex);
resp = dispatcher_handle_request(&g_dispatcher, request);
check("encapsulate ml-kem-768 returns result", resp_has(resp, "\"result\""));
check("encapsulate ml-kem-768 has ciphertext", resp_has(resp, "ciphertext"));
check("encapsulate ml-kem-768 has shared_secret", resp_has(resp, "shared_secret"));
ct_hex = extract_result_field(resp, "ciphertext");
ss_hex1 = extract_result_field(resp, "shared_secret");
free(resp);
check("encapsulate extracted ciphertext", ct_hex != NULL && strlen(ct_hex) > 0);
check("encapsulate extracted shared_secret", ss_hex1 != NULL && strlen(ss_hex1) > 0);
if (ct_hex) {
/* Decapsulate with our private key */
snprintf(request, sizeof(request),
"{\"id\":\"d1\",\"method\":\"decapsulate\",\"params\":[\"%s\",{\"algorithm\":\"ml-kem-768\",\"index\":0}]}",
ct_hex);
resp = dispatcher_handle_request(&g_dispatcher, request);
check("decapsulate ml-kem-768 returns result", resp_has(resp, "\"result\""));
check("decapsulate ml-kem-768 has shared_secret", resp_has(resp, "shared_secret"));
ss_hex2 = extract_result_field(resp, "shared_secret");
free(resp);
check("decapsulate extracted shared_secret", ss_hex2 != NULL);
/* Verify the shared secrets match */
if (ss_hex1 && ss_hex2) {
check("encapsulate/decapsulate shared secrets match",
strcmp(ss_hex1, ss_hex2) == 0);
}
free(ss_hex2);
}
free(ct_hex);
free(ss_hex1);
free(pub_hex);
}
/* ---- derive_shared_secret: x25519 ---- */
/* Get our x25519 public key */
resp = dispatcher_handle_request(&g_dispatcher,
"{\"id\":\"gpk4\",\"method\":\"get_public_key\",\"params\":[{\"algorithm\":\"x25519\",\"index\":0}]}");
pub_hex = extract_result_field(resp, "public_key");
check("get_public_key x25519 returns public_key", pub_hex != NULL && strlen(pub_hex) > 0);
free(resp);
if (pub_hex) {
/* Derive shared secret with our own public key (for testing) */
snprintf(request, sizeof(request),
"{\"id\":\"dss1\",\"method\":\"derive_shared_secret\",\"params\":[\"%s\",{\"algorithm\":\"x25519\",\"index\":0}]}",
pub_hex);
resp = dispatcher_handle_request(&g_dispatcher, request);
check("derive_shared_secret x25519 returns result", resp_has(resp, "\"result\""));
check("derive_shared_secret x25519 has shared_secret", resp_has(resp, "shared_secret"));
check("derive_shared_secret x25519 has algorithm x25519", resp_has(resp, "x25519"));
shared_hex = extract_result_field(resp, "shared_secret");
free(resp);
check("derive_shared_secret extracted shared_secret", shared_hex != NULL && strlen(shared_hex) == 64);
free(shared_hex);
free(pub_hex);
}
/* ---- Enforcement via dispatcher: sign with x25519 fails ---- */
resp = dispatcher_handle_request(&g_dispatcher,
"{\"id\":\"err1\",\"method\":\"sign\",\"params\":[\"68656c6c6f\",{\"algorithm\":\"x25519\",\"index\":0}]}");
check("sign x25519 returns algorithm error",
resp_has(resp, "algorithm_not_supported_for_verb") || resp_has(resp, "\"code\":1010"));
free(resp);
/* ---- Enforcement via dispatcher: encapsulate with ed25519 fails ---- */
resp = dispatcher_handle_request(&g_dispatcher,
"{\"id\":\"err2\",\"method\":\"encapsulate\",\"params\":[\"abcd\",{\"algorithm\":\"ed25519\"}]}");
check("encapsulate ed25519 returns algorithm error",
resp_has(resp, "algorithm_not_supported_for_verb") || resp_has(resp, "\"code\":1010"));
free(resp);
/* ---- Verb: sign with algorithm=ed25519 ---- */
resp = dispatcher_handle_request(&g_dispatcher,
"{\"id\":\"alias1\",\"method\":\"sign\",\"params\":[\"68656c6c6f\",{\"algorithm\":\"ed25519\",\"index\":0}]}");
check("sign with algorithm=ed25519 returns result",
resp_has(resp, "\"result\""));
check("sign has signature",
resp_has(resp, "signature"));
free(resp);
/* ---- Verb: sign (ssh) with algorithm=ed25519 ---- */
resp = dispatcher_handle_request(&g_dispatcher,
"{\"id\":\"alias2\",\"method\":\"sign\",\"params\":[\"68656c6c6f\",{\"algorithm\":\"ed25519\",\"index\":0}]}");
check("sign with algorithm=ed25519 returns result",
resp_has(resp, "\"result\""));
free(resp);
/* ---- Verb: encapsulate with algorithm=ml-kem-768 ---- */
resp = dispatcher_handle_request(&g_dispatcher,
"{\"id\":\"gpk5\",\"method\":\"get_public_key\",\"params\":[{\"algorithm\":\"ml-kem-768\",\"index\":1}]}");
pub_hex = extract_result_field(resp, "public_key");
free(resp);
if (pub_hex) {
snprintf(request, sizeof(request),
"{\"id\":\"alias3\",\"method\":\"encapsulate\",\"params\":[\"%s\",{\"algorithm\":\"ml-kem-768\"}]}",
pub_hex);
resp = dispatcher_handle_request(&g_dispatcher, request);
check("encapsulate with algorithm=ml-kem-768 returns result",
resp_has(resp, "\"result\""));
check("encapsulate has ciphertext",
resp_has(resp, "ciphertext"));
free(resp);
free(pub_hex);
}
/* ---- nostr_sign_event with role still works ---- */
resp = dispatcher_handle_request(&g_dispatcher,
"{\"id\":\"bc1\",\"method\":\"nostr_sign_event\",\"params\":[\"{\\\"kind\\\":1,\\\"content\\\":\\\"hello\\\",\\\"tags\\\":[]}\",{\"role\":\"main\"}]}");
check("nostr_sign_event with role=main returns signed event",
resp_has(resp, "pubkey") && resp_has(resp, "sig"));
free(resp);
/* ---- nostr_get_public_key with role still works ---- */
resp = dispatcher_handle_request(&g_dispatcher,
"{\"id\":\"bc2\",\"method\":\"nostr_get_public_key\",\"params\":[{\"role\":\"main\"}]}");
check("nostr_get_public_key with role=main returns hex",
resp_has(resp, "\"result\""));
free(resp);
/* ---- Policy: algorithm-based preapprove ---- */
{
policy_table_t policy;
policy_entry_t entry;
policy_source_t src;
policy_init_default(&policy, 1000);
/* Add algorithm-based preapprove entry */
memset(&entry, 0, sizeof(entry));
strncpy(entry.caller, "uid:1000", sizeof(entry.caller) - 1);
strncpy(entry.algorithms[0], "ed25519", sizeof(entry.algorithms[0]) - 1);
entry.alg_count = 1;
entry.index_min = 0;
entry.index_max = 4;
strncpy(entry.verbs[0], "sign", sizeof(entry.verbs[0]) - 1);
strncpy(entry.verbs[1], "verify", sizeof(entry.verbs[1]) - 1);
entry.verb_count = 2;
entry.prompt = PROMPT_NEVER;
entry.source = POLICY_SOURCE_PREAPPROVE;
policy_table_add(&policy, &entry);
/* Check: allowed */
rc = policy_check_algorithm(&policy, "uid:1000", "sign", "ed25519", 0, &src);
check("policy_check_algorithm: sign ed25519 idx=0 -> ALLOW", rc == POLICY_ALLOW);
rc = policy_check_algorithm(&policy, "uid:1000", "sign", "ed25519", 3, &src);
check("policy_check_algorithm: sign ed25519 idx=3 -> ALLOW", rc == POLICY_ALLOW);
/* Check: index out of range */
rc = policy_check_algorithm(&policy, "uid:1000", "sign", "ed25519", 5, &src);
check("policy_check_algorithm: sign ed25519 idx=5 -> NO_MATCH", rc == POLICY_NO_MATCH);
/* Check: wrong algorithm */
rc = policy_check_algorithm(&policy, "uid:1000", "sign", "ml-dsa-65", 0, &src);
check("policy_check_algorithm: sign ml-dsa-65 -> NO_MATCH", rc == POLICY_NO_MATCH);
/* Check: wrong verb */
rc = policy_check_algorithm(&policy, "uid:1000", "encapsulate", "ed25519", 0, &src);
check("policy_check_algorithm: encapsulate ed25519 -> NO_MATCH", rc == POLICY_NO_MATCH);
/* Check: wrong caller */
rc = policy_check_algorithm(&policy, "uid:2000", "sign", "ed25519", 0, &src);
check("policy_check_algorithm: wrong caller -> NO_MATCH", rc == POLICY_NO_MATCH);
}
/* ---- derive: HMAC-SHA256(privkey, data) — secp256k1 ---- */
/* Successful call returns a 64-hex digest. */
resp = dispatcher_handle_request(&g_dispatcher,
"{\"id\":\"dv1\",\"method\":\"derive\",\"params\":[\"test-data\",{\"algorithm\":\"secp256k1\",\"index\":0}]}");
check("derive secp256k1 returns result", resp_has(resp, "\"result\""));
check("derive secp256k1 has digest field", resp_has(resp, "digest"));
check("derive secp256k1 has algorithm secp256k1", resp_has(resp, "secp256k1"));
{
char *digest_hex = extract_result_field(resp, "digest");
check("derive secp256k1 digest is 64 hex chars",
digest_hex != NULL && strlen(digest_hex) == 64);
free(digest_hex);
}
free(resp);
/* Determinism: same input -> same digest. */
resp = dispatcher_handle_request(&g_dispatcher,
"{\"id\":\"dv2\",\"method\":\"derive\",\"params\":[\"test-data\",{\"algorithm\":\"secp256k1\",\"index\":0}]}");
{
char *digest2 = extract_result_field(resp, "digest");
/* Re-run first call to compare (deterministic). */
char *resp_a = dispatcher_handle_request(&g_dispatcher,
"{\"id\":\"dv1b\",\"method\":\"derive\",\"params\":[\"test-data\",{\"algorithm\":\"secp256k1\",\"index\":0}]}");
char *digest_a = extract_result_field(resp_a, "digest");
check("derive determinism: same input -> same digest",
digest2 != NULL && digest_a != NULL && strcmp(digest2, digest_a) == 0);
free(digest2); free(digest_a); free(resp_a);
}
free(resp);
/* Opaqueness: different inputs -> different digests. */
{
char *resp_b = dispatcher_handle_request(&g_dispatcher,
"{\"id\":\"dv3\",\"method\":\"derive\",\"params\":[\"other-data\",{\"algorithm\":\"secp256k1\",\"index\":0}]}");
char *resp_c = dispatcher_handle_request(&g_dispatcher,
"{\"id\":\"dv1c\",\"method\":\"derive\",\"params\":[\"test-data\",{\"algorithm\":\"secp256k1\",\"index\":0}]}");
char *dig_b = extract_result_field(resp_b, "digest");
char *dig_c = extract_result_field(resp_c, "digest");
check("derive opaqueness: different inputs -> different digests",
dig_b != NULL && dig_c != NULL && strcmp(dig_b, dig_c) != 0);
free(dig_b); free(dig_c); free(resp_b); free(resp_c);
}
/* Cross-check against nostr_hmac_sha256 with the derived private key. */
{
const unsigned char *priv = crypto_get_private_key(&g_key_store, 0);
unsigned char ref_mac[32];
char ref_hex[65];
char *resp_ref = dispatcher_handle_request(&g_dispatcher,
"{\"id\":\"dvref\",\"method\":\"derive\",\"params\":[\"test-data\",{\"algorithm\":\"secp256k1\",\"index\":0}]}");
char *got_hex = extract_result_field(resp_ref, "digest");
if (priv != NULL && nostr_hmac_sha256(priv, 32,
(const unsigned char *)"test-data", strlen("test-data"),
ref_mac) == 0) {
nostr_bytes_to_hex(ref_mac, 32, ref_hex);
check("derive matches reference HMAC-SHA256(privkey, data)",
got_hex != NULL && strcmp(got_hex, ref_hex) == 0);
} else {
check("derive reference HMAC computation available", 0);
}
free(got_hex); free(resp_ref);
}
/* index is required: omitting it returns missing_index. */
resp = dispatcher_handle_request(&g_dispatcher,
"{\"id\":\"dv4\",\"method\":\"derive\",\"params\":[\"test-data\",{\"algorithm\":\"secp256k1\"}]}");
check("derive without index returns missing_index",
resp_has(resp, "missing_index"));
free(resp);
/* Non-secp256k1 algorithm is rejected. */
resp = dispatcher_handle_request(&g_dispatcher,
"{\"id\":\"dv5\",\"method\":\"derive\",\"params\":[\"test-data\",{\"algorithm\":\"ed25519\",\"index\":0}]}");
check("derive ed25519 returns algorithm error",
resp_has(resp, "algorithm_not_supported_for_verb") || resp_has(resp, "\"code\":1010"));
free(resp);
/* Different index -> different digest (different privkey). */
{
char *r0 = dispatcher_handle_request(&g_dispatcher,
"{\"id\":\"dvi0\",\"method\":\"derive\",\"params\":[\"test-data\",{\"algorithm\":\"secp256k1\",\"index\":0}]}");
char *r1 = dispatcher_handle_request(&g_dispatcher,
"{\"id\":\"dvi1\",\"method\":\"derive\",\"params\":[\"test-data\",{\"algorithm\":\"secp256k1\",\"index\":1}]}");
char *d0 = extract_result_field(r0, "digest");
char *d1 = extract_result_field(r1, "digest");
check("derive different index -> different digest",
d0 != NULL && d1 != NULL && strcmp(d0, d1) != 0);
free(d0); free(d1); free(r0); free(r1);
}
/* ---- Cleanup ---- */
crypto_wipe(&g_key_store);
alg_key_cache_wipe(&g_alg_key_cache);
nostr_cleanup();
mnemonic_unload(&g_mnemonic);
printf("%d/%d tests passed\n", g_passes, g_total);
return (g_passes == g_total) ? 0 : 1;
}
Reference in New Issue View Git Blame Copy Permalink