v0.0.3 - Refactor key-store module and remove redundant crypto wrappers
This commit is contained in:
Laan Tungir
@@ -67,9 +67,8 @@ RUN gcc -static -O2 -Wall -Wextra -std=c99 \
|
||||
/build/src/dispatcher.c \
|
||||
/build/src/policy.c \
|
||||
/build/src/server.c \
|
||||
/build/src/crypto.c \
|
||||
/build/src/key_store.c \
|
||||
/build/src/socket_name.c \
|
||||
/build/src/bip39_english.c \
|
||||
/build/nostr_core_lib/libnostr_core_x64.a \
|
||||
-o /build/nsigner_static \
|
||||
$(pkg-config --static --libs libcurl openssl) \
|
||||
|
||||
40
Makefile
40
Makefile
@@ -1,5 +1,5 @@
|
||||
CC := gcc
|
||||
CFLAGS := -Wall -Wextra -std=c99 -O2 -Isrc -Isrc/cjson -Iresources/nostr_core_lib -Iresources/nostr_core_lib/nostr_core -Iresources/nostr_core_lib/cjson
|
||||
CFLAGS := -Wall -Wextra -std=c99 -O2 -Isrc -Iresources/nostr_core_lib -Iresources/nostr_core_lib/nostr_core -Iresources/nostr_core_lib/cjson
|
||||
LDFLAGS := resources/nostr_core_lib/libnostr_core_x64.a -lz -ldl -lpthread -lm -lssl -lcrypto -lcurl -lsecp256k1
|
||||
|
||||
SRC_DIR := src
|
||||
@@ -18,23 +18,11 @@ SOURCES := \
|
||||
$(SRC_DIR)/dispatcher.c \
|
||||
$(SRC_DIR)/policy.c \
|
||||
$(SRC_DIR)/server.c \
|
||||
$(SRC_DIR)/crypto.c \
|
||||
$(SRC_DIR)/socket_name.c \
|
||||
$(SRC_DIR)/bip39_english.c
|
||||
$(SRC_DIR)/key_store.c \
|
||||
$(SRC_DIR)/socket_name.c
|
||||
|
||||
HEADERS :=
|
||||
|
||||
HEADERS := \
|
||||
$(SRC_DIR)/main.h \
|
||||
$(SRC_DIR)/secure_mem.h \
|
||||
$(SRC_DIR)/mnemonic.h \
|
||||
$(SRC_DIR)/role_table.h \
|
||||
$(SRC_DIR)/selector.h \
|
||||
$(SRC_DIR)/enforcement.h \
|
||||
$(SRC_DIR)/dispatcher.h \
|
||||
$(SRC_DIR)/policy.h \
|
||||
$(SRC_DIR)/server.h \
|
||||
$(SRC_DIR)/crypto.h \
|
||||
$(SRC_DIR)/socket_name.h \
|
||||
$(SRC_DIR)/cjson/cJSON.h
|
||||
|
||||
TEST_MNEMONIC_TARGET := $(BUILD_DIR)/test_mnemonic
|
||||
TEST_ROLE_TARGET := $(BUILD_DIR)/test_role_table
|
||||
@@ -54,7 +42,7 @@ lib:
|
||||
|
||||
dev: lib $(TARGET_DEV)
|
||||
|
||||
$(TARGET_DEV): $(SOURCES) $(HEADERS)
|
||||
$(TARGET_DEV): $(SOURCES)
|
||||
@mkdir -p $(BUILD_DIR)
|
||||
$(CC) $(CFLAGS) $(SOURCES) -o $(TARGET_DEV) $(LDFLAGS)
|
||||
|
||||
@@ -96,27 +84,27 @@ test-policy: $(TEST_POLICY_TARGET)
|
||||
test-socket-name: $(TEST_SOCKET_NAME_TARGET)
|
||||
./$(TEST_SOCKET_NAME_TARGET)
|
||||
|
||||
$(TEST_MNEMONIC_TARGET): $(TEST_DIR)/test_mnemonic.c $(SRC_DIR)/mnemonic.c $(SRC_DIR)/secure_mem.c $(SRC_DIR)/mnemonic.h $(SRC_DIR)/secure_mem.h
|
||||
$(TEST_MNEMONIC_TARGET): $(TEST_DIR)/test_mnemonic.c $(SRC_DIR)/mnemonic.c $(SRC_DIR)/secure_mem.c
|
||||
@mkdir -p $(BUILD_DIR)
|
||||
$(CC) $(CFLAGS) $(TEST_DIR)/test_mnemonic.c $(SRC_DIR)/mnemonic.c $(SRC_DIR)/secure_mem.c -o $(TEST_MNEMONIC_TARGET) $(LDFLAGS)
|
||||
|
||||
$(TEST_ROLE_TARGET): $(TEST_DIR)/test_role_table.c $(SRC_DIR)/role_table.c $(SRC_DIR)/role_table.h
|
||||
$(TEST_ROLE_TARGET): $(TEST_DIR)/test_role_table.c $(SRC_DIR)/role_table.c
|
||||
@mkdir -p $(BUILD_DIR)
|
||||
$(CC) $(CFLAGS) $(TEST_DIR)/test_role_table.c $(SRC_DIR)/role_table.c -o $(TEST_ROLE_TARGET) $(LDFLAGS)
|
||||
|
||||
$(TEST_SELECTOR_TARGET): $(TEST_DIR)/test_selector.c $(SRC_DIR)/selector.c $(SRC_DIR)/role_table.c $(SRC_DIR)/selector.h $(SRC_DIR)/role_table.h
|
||||
$(TEST_SELECTOR_TARGET): $(TEST_DIR)/test_selector.c $(SRC_DIR)/selector.c $(SRC_DIR)/role_table.c
|
||||
@mkdir -p $(BUILD_DIR)
|
||||
$(CC) $(CFLAGS) $(TEST_DIR)/test_selector.c $(SRC_DIR)/selector.c $(SRC_DIR)/role_table.c -o $(TEST_SELECTOR_TARGET) $(LDFLAGS)
|
||||
|
||||
$(TEST_ENFORCEMENT_TARGET): $(TEST_DIR)/test_enforcement.c $(SRC_DIR)/enforcement.c $(SRC_DIR)/role_table.c $(SRC_DIR)/enforcement.h $(SRC_DIR)/role_table.h
|
||||
$(TEST_ENFORCEMENT_TARGET): $(TEST_DIR)/test_enforcement.c $(SRC_DIR)/enforcement.c $(SRC_DIR)/role_table.c
|
||||
@mkdir -p $(BUILD_DIR)
|
||||
$(CC) $(CFLAGS) $(TEST_DIR)/test_enforcement.c $(SRC_DIR)/enforcement.c $(SRC_DIR)/role_table.c -o $(TEST_ENFORCEMENT_TARGET) $(LDFLAGS)
|
||||
|
||||
$(TEST_DISPATCHER_TARGET): $(TEST_DIR)/test_dispatcher.c $(SRC_DIR)/dispatcher.c $(SRC_DIR)/crypto.c $(SRC_DIR)/selector.c $(SRC_DIR)/enforcement.c $(SRC_DIR)/role_table.c $(SRC_DIR)/mnemonic.c $(SRC_DIR)/secure_mem.c $(SRC_DIR)/dispatcher.h $(SRC_DIR)/crypto.h $(SRC_DIR)/selector.h $(SRC_DIR)/enforcement.h $(SRC_DIR)/role_table.h $(SRC_DIR)/mnemonic.h $(SRC_DIR)/secure_mem.h $(SRC_DIR)/cjson/cJSON.h
|
||||
$(TEST_DISPATCHER_TARGET): $(TEST_DIR)/test_dispatcher.c $(SRC_DIR)/dispatcher.c $(SRC_DIR)/key_store.c $(SRC_DIR)/selector.c $(SRC_DIR)/enforcement.c $(SRC_DIR)/role_table.c $(SRC_DIR)/mnemonic.c $(SRC_DIR)/secure_mem.c
|
||||
@mkdir -p $(BUILD_DIR)
|
||||
$(CC) $(CFLAGS) $(TEST_DIR)/test_dispatcher.c $(SRC_DIR)/dispatcher.c $(SRC_DIR)/crypto.c $(SRC_DIR)/selector.c $(SRC_DIR)/enforcement.c $(SRC_DIR)/role_table.c $(SRC_DIR)/mnemonic.c $(SRC_DIR)/secure_mem.c -o $(TEST_DISPATCHER_TARGET) $(LDFLAGS)
|
||||
$(CC) $(CFLAGS) $(TEST_DIR)/test_dispatcher.c $(SRC_DIR)/dispatcher.c $(SRC_DIR)/key_store.c $(SRC_DIR)/selector.c $(SRC_DIR)/enforcement.c $(SRC_DIR)/role_table.c $(SRC_DIR)/mnemonic.c $(SRC_DIR)/secure_mem.c -o $(TEST_DISPATCHER_TARGET) $(LDFLAGS)
|
||||
|
||||
$(TEST_POLICY_TARGET): $(TEST_DIR)/test_policy.c $(SRC_DIR)/policy.c $(SRC_DIR)/policy.h $(SRC_DIR)/role_table.h
|
||||
$(TEST_POLICY_TARGET): $(TEST_DIR)/test_policy.c $(SRC_DIR)/policy.c
|
||||
@mkdir -p $(BUILD_DIR)
|
||||
$(CC) $(CFLAGS) $(TEST_DIR)/test_policy.c $(SRC_DIR)/policy.c -o $(TEST_POLICY_TARGET) $(LDFLAGS)
|
||||
|
||||
@@ -124,7 +112,7 @@ $(TEST_INTEGRATION_TARGET): $(TEST_DIR)/test_integration.c
|
||||
@mkdir -p $(BUILD_DIR)
|
||||
$(CC) $(CFLAGS) $(TEST_DIR)/test_integration.c -o $(TEST_INTEGRATION_TARGET) $(LDFLAGS)
|
||||
|
||||
$(TEST_SOCKET_NAME_TARGET): $(TEST_DIR)/test_socket_name.c $(SRC_DIR)/socket_name.c $(SRC_DIR)/socket_name.h
|
||||
$(TEST_SOCKET_NAME_TARGET): $(TEST_DIR)/test_socket_name.c $(SRC_DIR)/socket_name.c
|
||||
@mkdir -p $(BUILD_DIR)
|
||||
$(CC) $(CFLAGS) $(TEST_DIR)/test_socket_name.c $(SRC_DIR)/socket_name.c -o $(TEST_SOCKET_NAME_TARGET) $(LDFLAGS)
|
||||
|
||||
|
||||
@@ -84,18 +84,23 @@ update_version_in_header() {
|
||||
local major="$2"
|
||||
local minor="$3"
|
||||
local patch="$4"
|
||||
local version_file=""
|
||||
|
||||
if [[ ! -f "src/main.h" ]]; then
|
||||
print_error "src/main.h not found"
|
||||
if [[ -f "src/main.h" ]]; then
|
||||
version_file="src/main.h"
|
||||
elif [[ -f "src/main.c" ]]; then
|
||||
version_file="src/main.c"
|
||||
else
|
||||
print_error "Neither src/main.h nor src/main.c found"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
sed -i "s/#define NSIGNER_VERSION \".*\"/#define NSIGNER_VERSION \"$new_version\"/" src/main.h
|
||||
sed -i "s/#define NSIGNER_VERSION_MAJOR [0-9]\+/#define NSIGNER_VERSION_MAJOR $major/" src/main.h
|
||||
sed -i "s/#define NSIGNER_VERSION_MINOR [0-9]\+/#define NSIGNER_VERSION_MINOR $minor/" src/main.h
|
||||
sed -i "s/#define NSIGNER_VERSION_PATCH [0-9]\+/#define NSIGNER_VERSION_PATCH $patch/" src/main.h
|
||||
sed -i "s/#define NSIGNER_VERSION \".*\"/#define NSIGNER_VERSION \"$new_version\"/" "$version_file"
|
||||
sed -i "s/#define NSIGNER_VERSION_MAJOR [0-9]\+/#define NSIGNER_VERSION_MAJOR $major/" "$version_file"
|
||||
sed -i "s/#define NSIGNER_VERSION_MINOR [0-9]\+/#define NSIGNER_VERSION_MINOR $minor/" "$version_file"
|
||||
sed -i "s/#define NSIGNER_VERSION_PATCH [0-9]\+/#define NSIGNER_VERSION_PATCH $patch/" "$version_file"
|
||||
|
||||
print_success "Updated src/main.h to $new_version"
|
||||
print_success "Updated $version_file to $new_version"
|
||||
}
|
||||
|
||||
increment_version() {
|
||||
|
||||
@@ -1,12 +0,0 @@
|
||||
/*
|
||||
* Placeholder translation unit for BIP-39 English wordlist ownership.
|
||||
*
|
||||
* Current implementation uses nostr_core_lib via:
|
||||
* nostr_bip39_mnemonic_from_bytes(...)
|
||||
* which already encapsulates the BIP-39 English wordlist.
|
||||
*
|
||||
* This file exists to satisfy build/plan structure and future portability work.
|
||||
*/
|
||||
int nsigner_bip39_english_placeholder(void) {
|
||||
return 0;
|
||||
}
|
||||
3191
src/cjson/cJSON.c
3191
src/cjson/cJSON.c
File diff suppressed because it is too large
Load Diff
@@ -1,306 +0,0 @@
|
||||
/*
|
||||
Copyright (c) 2009-2017 Dave Gamble and cJSON contributors
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#ifndef cJSON__h
|
||||
#define cJSON__h
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
#if !defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32))
|
||||
#define __WINDOWS__
|
||||
#endif
|
||||
|
||||
#ifdef __WINDOWS__
|
||||
|
||||
/* When compiling for windows, we specify a specific calling convention to avoid issues where we are being called from a project with a different default calling convention. For windows you have 3 define options:
|
||||
|
||||
CJSON_HIDE_SYMBOLS - Define this in the case where you don't want to ever dllexport symbols
|
||||
CJSON_EXPORT_SYMBOLS - Define this on library build when you want to dllexport symbols (default)
|
||||
CJSON_IMPORT_SYMBOLS - Define this if you want to dllimport symbol
|
||||
|
||||
For *nix builds that support visibility attribute, you can define similar behavior by
|
||||
|
||||
setting default visibility to hidden by adding
|
||||
-fvisibility=hidden (for gcc)
|
||||
or
|
||||
-xldscope=hidden (for sun cc)
|
||||
to CFLAGS
|
||||
|
||||
then using the CJSON_API_VISIBILITY flag to "export" the same symbols the way CJSON_EXPORT_SYMBOLS does
|
||||
|
||||
*/
|
||||
|
||||
#define CJSON_CDECL __cdecl
|
||||
#define CJSON_STDCALL __stdcall
|
||||
|
||||
/* export symbols by default, this is necessary for copy pasting the C and header file */
|
||||
#if !defined(CJSON_HIDE_SYMBOLS) && !defined(CJSON_IMPORT_SYMBOLS) && !defined(CJSON_EXPORT_SYMBOLS)
|
||||
#define CJSON_EXPORT_SYMBOLS
|
||||
#endif
|
||||
|
||||
#if defined(CJSON_HIDE_SYMBOLS)
|
||||
#define CJSON_PUBLIC(type) type CJSON_STDCALL
|
||||
#elif defined(CJSON_EXPORT_SYMBOLS)
|
||||
#define CJSON_PUBLIC(type) __declspec(dllexport) type CJSON_STDCALL
|
||||
#elif defined(CJSON_IMPORT_SYMBOLS)
|
||||
#define CJSON_PUBLIC(type) __declspec(dllimport) type CJSON_STDCALL
|
||||
#endif
|
||||
#else /* !__WINDOWS__ */
|
||||
#define CJSON_CDECL
|
||||
#define CJSON_STDCALL
|
||||
|
||||
#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(CJSON_API_VISIBILITY)
|
||||
#define CJSON_PUBLIC(type) __attribute__((visibility("default"))) type
|
||||
#else
|
||||
#define CJSON_PUBLIC(type) type
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* project version */
|
||||
#define CJSON_VERSION_MAJOR 1
|
||||
#define CJSON_VERSION_MINOR 7
|
||||
#define CJSON_VERSION_PATCH 18
|
||||
|
||||
#include <stddef.h>
|
||||
|
||||
/* cJSON Types: */
|
||||
#define cJSON_Invalid (0)
|
||||
#define cJSON_False (1 << 0)
|
||||
#define cJSON_True (1 << 1)
|
||||
#define cJSON_NULL (1 << 2)
|
||||
#define cJSON_Number (1 << 3)
|
||||
#define cJSON_String (1 << 4)
|
||||
#define cJSON_Array (1 << 5)
|
||||
#define cJSON_Object (1 << 6)
|
||||
#define cJSON_Raw (1 << 7) /* raw json */
|
||||
|
||||
#define cJSON_IsReference 256
|
||||
#define cJSON_StringIsConst 512
|
||||
|
||||
/* The cJSON structure: */
|
||||
typedef struct cJSON
|
||||
{
|
||||
/* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */
|
||||
struct cJSON *next;
|
||||
struct cJSON *prev;
|
||||
/* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */
|
||||
struct cJSON *child;
|
||||
|
||||
/* The type of the item, as above. */
|
||||
int type;
|
||||
|
||||
/* The item's string, if type==cJSON_String and type == cJSON_Raw */
|
||||
char *valuestring;
|
||||
/* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */
|
||||
int valueint;
|
||||
/* The item's number, if type==cJSON_Number */
|
||||
double valuedouble;
|
||||
|
||||
/* The item's name string, if this item is the child of, or is in the list of subitems of an object. */
|
||||
char *string;
|
||||
} cJSON;
|
||||
|
||||
typedef struct cJSON_Hooks
|
||||
{
|
||||
/* malloc/free are CDECL on Windows regardless of the default calling convention of the compiler, so ensure the hooks allow passing those functions directly. */
|
||||
void *(CJSON_CDECL *malloc_fn)(size_t sz);
|
||||
void (CJSON_CDECL *free_fn)(void *ptr);
|
||||
} cJSON_Hooks;
|
||||
|
||||
typedef int cJSON_bool;
|
||||
|
||||
/* Limits how deeply nested arrays/objects can be before cJSON rejects to parse them.
|
||||
* This is to prevent stack overflows. */
|
||||
#ifndef CJSON_NESTING_LIMIT
|
||||
#define CJSON_NESTING_LIMIT 1000
|
||||
#endif
|
||||
|
||||
/* Limits the length of circular references can be before cJSON rejects to parse them.
|
||||
* This is to prevent stack overflows. */
|
||||
#ifndef CJSON_CIRCULAR_LIMIT
|
||||
#define CJSON_CIRCULAR_LIMIT 10000
|
||||
#endif
|
||||
|
||||
/* returns the version of cJSON as a string */
|
||||
CJSON_PUBLIC(const char*) cJSON_Version(void);
|
||||
|
||||
/* Supply malloc, realloc and free functions to cJSON */
|
||||
CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks);
|
||||
|
||||
/* Memory Management: the caller is always responsible to free the results from all variants of cJSON_Parse (with cJSON_Delete) and cJSON_Print (with stdlib free, cJSON_Hooks.free_fn, or cJSON_free as appropriate). The exception is cJSON_PrintPreallocated, where the caller has full responsibility of the buffer. */
|
||||
/* Supply a block of JSON, and this returns a cJSON object you can interrogate. */
|
||||
CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value);
|
||||
CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length);
|
||||
/* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */
|
||||
/* If you supply a ptr in return_parse_end and parsing fails, then return_parse_end will contain a pointer to the error so will match cJSON_GetErrorPtr(). */
|
||||
CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated);
|
||||
CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated);
|
||||
|
||||
/* Render a cJSON entity to text for transfer/storage. */
|
||||
CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item);
|
||||
/* Render a cJSON entity to text for transfer/storage without any formatting. */
|
||||
CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item);
|
||||
/* Render a cJSON entity to text using a buffered strategy. prebuffer is a guess at the final size. guessing well reduces reallocation. fmt=0 gives unformatted, =1 gives formatted */
|
||||
CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt);
|
||||
/* Render a cJSON entity to text using a buffer already allocated in memory with given length. Returns 1 on success and 0 on failure. */
|
||||
/* NOTE: cJSON is not always 100% accurate in estimating how much memory it will use, so to be safe allocate 5 bytes more than you actually need */
|
||||
CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format);
|
||||
/* Delete a cJSON entity and all subentities. */
|
||||
CJSON_PUBLIC(void) cJSON_Delete(cJSON *item);
|
||||
|
||||
/* Returns the number of items in an array (or object). */
|
||||
CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array);
|
||||
/* Retrieve item number "index" from array "array". Returns NULL if unsuccessful. */
|
||||
CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index);
|
||||
/* Get item "string" from object. Case insensitive. */
|
||||
CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string);
|
||||
CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string);
|
||||
CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string);
|
||||
/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */
|
||||
CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void);
|
||||
|
||||
/* Check item type and return its value */
|
||||
CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON * const item);
|
||||
CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item);
|
||||
|
||||
/* These functions check the type of an item */
|
||||
CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item);
|
||||
CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item);
|
||||
CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item);
|
||||
CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item);
|
||||
CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item);
|
||||
CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item);
|
||||
CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item);
|
||||
CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item);
|
||||
CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item);
|
||||
CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item);
|
||||
|
||||
/* These calls create a cJSON item of the appropriate type. */
|
||||
CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void);
|
||||
CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void);
|
||||
CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void);
|
||||
CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean);
|
||||
CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num);
|
||||
CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string);
|
||||
/* raw json */
|
||||
CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw);
|
||||
CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void);
|
||||
CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void);
|
||||
|
||||
/* Create a string where valuestring references a string so
|
||||
* it will not be freed by cJSON_Delete */
|
||||
CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string);
|
||||
/* Create an object/array that only references it's elements so
|
||||
* they will not be freed by cJSON_Delete */
|
||||
CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child);
|
||||
CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child);
|
||||
|
||||
/* These utilities create an Array of count items.
|
||||
* The parameter count cannot be greater than the number of elements in the number array, otherwise array access will be out of bounds.*/
|
||||
CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count);
|
||||
CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count);
|
||||
CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count);
|
||||
CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count);
|
||||
|
||||
/* Append item to the specified array/object. */
|
||||
CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item);
|
||||
CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item);
|
||||
/* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object.
|
||||
* WARNING: When this function was used, make sure to always check that (item->type & cJSON_StringIsConst) is zero before
|
||||
* writing to `item->string` */
|
||||
CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item);
|
||||
/* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON. */
|
||||
CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item);
|
||||
CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item);
|
||||
|
||||
/* Remove/Detach items from Arrays/Objects. */
|
||||
CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item);
|
||||
CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which);
|
||||
CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which);
|
||||
CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string);
|
||||
CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string);
|
||||
CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string);
|
||||
CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string);
|
||||
|
||||
/* Update array items. */
|
||||
CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem); /* Shifts pre-existing items to the right. */
|
||||
CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement);
|
||||
CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem);
|
||||
CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem);
|
||||
CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object,const char *string,cJSON *newitem);
|
||||
|
||||
/* Duplicate a cJSON item */
|
||||
CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse);
|
||||
/* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will
|
||||
* need to be released. With recurse!=0, it will duplicate any children connected to the item.
|
||||
* The item->next and ->prev pointers are always zero on return from Duplicate. */
|
||||
/* Recursively compare two cJSON items for equality. If either a or b is NULL or invalid, they will be considered unequal.
|
||||
* case_sensitive determines if object keys are treated case sensitive (1) or case insensitive (0) */
|
||||
CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive);
|
||||
|
||||
/* Minify a strings, remove blank characters(such as ' ', '\t', '\r', '\n') from strings.
|
||||
* The input pointer json cannot point to a read-only address area, such as a string constant,
|
||||
* but should point to a readable and writable address area. */
|
||||
CJSON_PUBLIC(void) cJSON_Minify(char *json);
|
||||
|
||||
/* Helper functions for creating and adding items to an object at the same time.
|
||||
* They return the added item or NULL on failure. */
|
||||
CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name);
|
||||
CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name);
|
||||
CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name);
|
||||
CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean);
|
||||
CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number);
|
||||
CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string);
|
||||
CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw);
|
||||
CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name);
|
||||
CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name);
|
||||
|
||||
/* When assigning an integer value, it needs to be propagated to valuedouble too. */
|
||||
#define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number))
|
||||
/* helper for the cJSON_SetNumberValue macro */
|
||||
CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number);
|
||||
#define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number))
|
||||
/* Change the valuestring of a cJSON_String object, only takes effect when type of object is cJSON_String */
|
||||
CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring);
|
||||
|
||||
/* If the object is not a boolean type this does nothing and returns cJSON_Invalid else it returns the new type*/
|
||||
#define cJSON_SetBoolValue(object, boolValue) ( \
|
||||
(object != NULL && ((object)->type & (cJSON_False|cJSON_True))) ? \
|
||||
(object)->type=((object)->type &(~(cJSON_False|cJSON_True)))|((boolValue)?cJSON_True:cJSON_False) : \
|
||||
cJSON_Invalid\
|
||||
)
|
||||
|
||||
/* Macro for iterating over an array or object */
|
||||
#define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next)
|
||||
|
||||
/* malloc/free objects using the malloc/free functions that have been set with cJSON_InitHooks */
|
||||
CJSON_PUBLIC(void *) cJSON_malloc(size_t size);
|
||||
CJSON_PUBLIC(void) cJSON_free(void *object);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
232
src/crypto.c
232
src/crypto.c
@@ -1,232 +0,0 @@
|
||||
#define _GNU_SOURCE
|
||||
|
||||
#include "crypto.h"
|
||||
|
||||
#include <nostr_core/nostr_common.h>
|
||||
#include <nostr_core/nip001.h>
|
||||
#include <nostr_core/nip006.h>
|
||||
#include <nostr_core/nip019.h>
|
||||
#include <nostr_core/utils.h>
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
|
||||
#define NSIGNER_ENCRYPT_OUTPUT_MAX 65536
|
||||
|
||||
int crypto_init(void) {
|
||||
return nostr_init();
|
||||
}
|
||||
|
||||
void crypto_cleanup(void) {
|
||||
nostr_cleanup();
|
||||
}
|
||||
|
||||
int crypto_derive_all(key_store_t *store, role_table_t *table, const mnemonic_state_t *mnemonic) {
|
||||
int i;
|
||||
int derived_count;
|
||||
|
||||
if (store == NULL || table == NULL || mnemonic == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (!mnemonic_is_loaded(mnemonic)) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
crypto_wipe(store);
|
||||
derived_count = 0;
|
||||
|
||||
for (i = 0; i < table->count; ++i) {
|
||||
role_entry_t *role = &table->entries[i];
|
||||
unsigned char priv[32];
|
||||
unsigned char pub[32];
|
||||
derived_key_t *dst = &store->keys[i];
|
||||
|
||||
role->derived = 0;
|
||||
role->pubkey_hex[0] = '\0';
|
||||
|
||||
if (role->purpose != PURPOSE_NOSTR ||
|
||||
role->curve != CURVE_SECP256K1 ||
|
||||
role->selector_type != SELECTOR_NOSTR_INDEX) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (secure_buf_alloc(&dst->private_key, 32) != 0) {
|
||||
crypto_wipe(store);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (nostr_derive_keys_from_mnemonic(mnemonic_get_phrase(mnemonic), role->nostr_index, priv, pub) != 0) {
|
||||
secure_memzero(priv, sizeof(priv));
|
||||
secure_memzero(pub, sizeof(pub));
|
||||
crypto_wipe(store);
|
||||
return -1;
|
||||
}
|
||||
|
||||
memcpy(dst->private_key.data, priv, 32);
|
||||
memcpy(dst->public_key, pub, 32);
|
||||
|
||||
nostr_bytes_to_hex(pub, 32, dst->pubkey_hex);
|
||||
dst->npub[0] = '\0';
|
||||
(void)nostr_key_to_bech32(pub, "npub", dst->npub);
|
||||
|
||||
strncpy(role->pubkey_hex, dst->pubkey_hex, sizeof(role->pubkey_hex) - 1);
|
||||
role->pubkey_hex[sizeof(role->pubkey_hex) - 1] = '\0';
|
||||
role->derived = 1;
|
||||
|
||||
dst->valid = 1;
|
||||
derived_count++;
|
||||
|
||||
secure_memzero(priv, sizeof(priv));
|
||||
secure_memzero(pub, sizeof(pub));
|
||||
}
|
||||
|
||||
store->count = table->count;
|
||||
return derived_count;
|
||||
}
|
||||
|
||||
const unsigned char *crypto_get_private_key(const key_store_t *store, int role_index) {
|
||||
if (store == NULL || role_index < 0 || role_index >= ROLE_TABLE_MAX_ENTRIES) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (!store->keys[role_index].valid || store->keys[role_index].private_key.data == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return (const unsigned char *)store->keys[role_index].private_key.data;
|
||||
}
|
||||
|
||||
const char *crypto_get_pubkey_hex(const key_store_t *store, int role_index) {
|
||||
if (store == NULL || role_index < 0 || role_index >= ROLE_TABLE_MAX_ENTRIES) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (!store->keys[role_index].valid) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return store->keys[role_index].pubkey_hex;
|
||||
}
|
||||
|
||||
char *crypto_sign_event(const key_store_t *store, int role_index, const char *event_json) {
|
||||
const unsigned char *private_key;
|
||||
cJSON *parsed = NULL;
|
||||
cJSON *kind_item;
|
||||
cJSON *content_item;
|
||||
cJSON *tags_item;
|
||||
cJSON *created_at_item;
|
||||
cJSON *tags_for_sign = NULL;
|
||||
int kind;
|
||||
const char *content;
|
||||
time_t timestamp = 0;
|
||||
cJSON *signed_event = NULL;
|
||||
char *out = NULL;
|
||||
|
||||
if (event_json == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
private_key = crypto_get_private_key(store, role_index);
|
||||
if (private_key == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
parsed = cJSON_Parse(event_json);
|
||||
if (parsed == NULL || !cJSON_IsObject(parsed)) {
|
||||
cJSON_Delete(parsed);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
kind_item = cJSON_GetObjectItemCaseSensitive(parsed, "kind");
|
||||
content_item = cJSON_GetObjectItemCaseSensitive(parsed, "content");
|
||||
tags_item = cJSON_GetObjectItemCaseSensitive(parsed, "tags");
|
||||
created_at_item = cJSON_GetObjectItemCaseSensitive(parsed, "created_at");
|
||||
|
||||
if (!cJSON_IsNumber(kind_item) || !cJSON_IsString(content_item) || content_item->valuestring == NULL) {
|
||||
cJSON_Delete(parsed);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
kind = kind_item->valueint;
|
||||
content = content_item->valuestring;
|
||||
|
||||
if (cJSON_IsNumber(created_at_item)) {
|
||||
timestamp = (time_t)created_at_item->valuedouble;
|
||||
}
|
||||
|
||||
if (cJSON_IsArray(tags_item)) {
|
||||
tags_for_sign = cJSON_Duplicate(tags_item, 1);
|
||||
if (tags_for_sign == NULL) {
|
||||
cJSON_Delete(parsed);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
signed_event = nostr_create_and_sign_event(kind, content, tags_for_sign, private_key, timestamp);
|
||||
cJSON_Delete(tags_for_sign);
|
||||
cJSON_Delete(parsed);
|
||||
|
||||
if (signed_event == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
out = cJSON_PrintUnformatted(signed_event);
|
||||
cJSON_Delete(signed_event);
|
||||
return out;
|
||||
}
|
||||
|
||||
char *crypto_nip44_encrypt(const key_store_t *store, int role_index,
|
||||
const char *recipient_pubkey_hex, const char *plaintext) {
|
||||
(void)store;
|
||||
(void)role_index;
|
||||
(void)recipient_pubkey_hex;
|
||||
(void)plaintext;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
char *crypto_nip44_decrypt(const key_store_t *store, int role_index,
|
||||
const char *sender_pubkey_hex, const char *ciphertext) {
|
||||
(void)store;
|
||||
(void)role_index;
|
||||
(void)sender_pubkey_hex;
|
||||
(void)ciphertext;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
char *crypto_nip04_encrypt(const key_store_t *store, int role_index,
|
||||
const char *recipient_pubkey_hex, const char *plaintext) {
|
||||
(void)store;
|
||||
(void)role_index;
|
||||
(void)recipient_pubkey_hex;
|
||||
(void)plaintext;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
char *crypto_nip04_decrypt(const key_store_t *store, int role_index,
|
||||
const char *sender_pubkey_hex, const char *ciphertext) {
|
||||
(void)store;
|
||||
(void)role_index;
|
||||
(void)sender_pubkey_hex;
|
||||
(void)ciphertext;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void crypto_wipe(key_store_t *store) {
|
||||
int i;
|
||||
|
||||
if (store == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
for (i = 0; i < ROLE_TABLE_MAX_ENTRIES; ++i) {
|
||||
secure_buf_free(&store->keys[i].private_key);
|
||||
secure_memzero(store->keys[i].public_key, sizeof(store->keys[i].public_key));
|
||||
secure_memzero(store->keys[i].pubkey_hex, sizeof(store->keys[i].pubkey_hex));
|
||||
secure_memzero(store->keys[i].npub, sizeof(store->keys[i].npub));
|
||||
store->keys[i].valid = 0;
|
||||
}
|
||||
|
||||
store->count = 0;
|
||||
}
|
||||
66
src/crypto.h
66
src/crypto.h
@@ -1,66 +0,0 @@
|
||||
#ifndef NSIGNER_CRYPTO_H
|
||||
#define NSIGNER_CRYPTO_H
|
||||
|
||||
#include "role_table.h"
|
||||
#include "secure_mem.h"
|
||||
#include "mnemonic.h"
|
||||
#include <cJSON.h>
|
||||
|
||||
/* Per-role derived key material (stored in secure memory) */
|
||||
typedef struct {
|
||||
secure_buf_t private_key; /* 32 bytes, mlock'd */
|
||||
unsigned char public_key[32];
|
||||
char pubkey_hex[65]; /* 64 hex chars + null */
|
||||
char npub[128]; /* bech32 npub */
|
||||
int valid;
|
||||
} derived_key_t;
|
||||
|
||||
/* Key store — holds derived keys for all roles */
|
||||
typedef struct {
|
||||
derived_key_t keys[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} key_store_t;
|
||||
|
||||
/* Initialize crypto subsystem (calls nostr_init). Returns 0 on success. */
|
||||
int crypto_init(void);
|
||||
|
||||
/* Cleanup crypto subsystem (calls nostr_cleanup). */
|
||||
void crypto_cleanup(void);
|
||||
|
||||
/* Derive keys for all roles in the table using the loaded mnemonic.
|
||||
* Populates key_store and sets role->pubkey_hex and role->derived for each role.
|
||||
* Only derives for roles with purpose=nostr and curve=secp256k1 (for now).
|
||||
* Returns number of keys derived, or -1 on error. */
|
||||
int crypto_derive_all(key_store_t *store, role_table_t *table, const mnemonic_state_t *mnemonic);
|
||||
|
||||
/* Get the derived private key for a role (by table index). Returns NULL if not derived. */
|
||||
const unsigned char *crypto_get_private_key(const key_store_t *store, int role_index);
|
||||
|
||||
/* Get the derived public key hex for a role. Returns NULL if not derived. */
|
||||
const char *crypto_get_pubkey_hex(const key_store_t *store, int role_index);
|
||||
|
||||
/* Sign a Nostr event. event_json is the unsigned event JSON string.
|
||||
* Returns a newly-allocated string containing the signed event JSON, or NULL on error.
|
||||
* Caller must free() the returned string. */
|
||||
char *crypto_sign_event(const key_store_t *store, int role_index, const char *event_json);
|
||||
|
||||
/* NIP-44 encrypt. Returns newly-allocated ciphertext string, or NULL on error. Caller frees. */
|
||||
char *crypto_nip44_encrypt(const key_store_t *store, int role_index,
|
||||
const char *recipient_pubkey_hex, const char *plaintext);
|
||||
|
||||
/* NIP-44 decrypt. Returns newly-allocated plaintext string, or NULL on error. Caller frees. */
|
||||
char *crypto_nip44_decrypt(const key_store_t *store, int role_index,
|
||||
const char *sender_pubkey_hex, const char *ciphertext);
|
||||
|
||||
/* NIP-04 encrypt. Returns newly-allocated ciphertext string, or NULL on error. Caller frees. */
|
||||
char *crypto_nip04_encrypt(const key_store_t *store, int role_index,
|
||||
const char *recipient_pubkey_hex, const char *plaintext);
|
||||
|
||||
/* NIP-04 decrypt. Returns newly-allocated plaintext string, or NULL on error. Caller frees. */
|
||||
char *crypto_nip04_decrypt(const key_store_t *store, int role_index,
|
||||
const char *sender_pubkey_hex, const char *ciphertext);
|
||||
|
||||
/* Zeroize all derived keys in the store. */
|
||||
void crypto_wipe(key_store_t *store);
|
||||
|
||||
#endif /* NSIGNER_CRYPTO_H */
|
||||
444
src/dispatcher.c
444
src/dispatcher.c
@@ -1,8 +1,444 @@
|
||||
#include "dispatcher.h"
|
||||
/* NSIGNER_HEADERLESS_DECLS_BEGIN */
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
#include <cJSON.h>
|
||||
|
||||
#include "enforcement.h"
|
||||
#include "selector.h"
|
||||
#include "cjson/cJSON.h"
|
||||
/* from secure_mem.h */
|
||||
|
||||
|
||||
/*
|
||||
* Secure memory buffer — mlock'd, zeroized on free.
|
||||
* Used for mnemonic phrases, private keys, and any sensitive material.
|
||||
*/
|
||||
typedef struct {
|
||||
void *data; /* pointer to locked allocation */
|
||||
size_t size; /* usable size in bytes */
|
||||
int locked; /* 1 if mlock succeeded */
|
||||
} secure_buf_t;
|
||||
|
||||
/* Allocate a secure buffer of `size` bytes. Returns 0 on success, -1 on failure. */
|
||||
int secure_buf_alloc(secure_buf_t *buf, size_t size);
|
||||
|
||||
/* Zeroize and free a secure buffer. Always succeeds (idempotent). */
|
||||
void secure_buf_free(secure_buf_t *buf);
|
||||
|
||||
/* Zeroize `len` bytes at `ptr` in a way the compiler cannot optimize away. */
|
||||
void secure_memzero(void *ptr, size_t len);
|
||||
|
||||
|
||||
/* from mnemonic.h */
|
||||
|
||||
|
||||
/* Maximum mnemonic length: 24 words * 10 chars avg + spaces + null = 256 is safe */
|
||||
#define MNEMONIC_MAX_LEN 256
|
||||
|
||||
/*
|
||||
* Mnemonic state — holds the loaded mnemonic in secure memory.
|
||||
* Only one mnemonic is active at a time per process.
|
||||
*/
|
||||
typedef struct {
|
||||
secure_buf_t buf; /* secure storage for the mnemonic string */
|
||||
int loaded; /* 1 if a mnemonic is currently loaded */
|
||||
int word_count; /* 12, 15, 18, 21, or 24 */
|
||||
} mnemonic_state_t;
|
||||
|
||||
/* Initialize mnemonic state (must be called before use). */
|
||||
void mnemonic_init(mnemonic_state_t *state);
|
||||
|
||||
/* Load a mnemonic string into secure memory. Validates word count (12/15/18/21/24).
|
||||
* Returns 0 on success, -1 on invalid input, -2 on memory error. */
|
||||
int mnemonic_load(mnemonic_state_t *state, const char *phrase);
|
||||
|
||||
/* Zeroize and unload the mnemonic. Idempotent. */
|
||||
void mnemonic_unload(mnemonic_state_t *state);
|
||||
|
||||
/* Check if a mnemonic is currently loaded. */
|
||||
int mnemonic_is_loaded(const mnemonic_state_t *state);
|
||||
|
||||
/* Get the mnemonic string (only valid while loaded). Returns NULL if not loaded. */
|
||||
const char *mnemonic_get_phrase(const mnemonic_state_t *state);
|
||||
|
||||
/* Generate a new BIP-39 mnemonic phrase (12/15/18/21/24 words) into out.
|
||||
* Returns 0 on success, -1 on invalid arguments or generation failure. */
|
||||
int mnemonic_generate(int word_count, char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from role_table.h */
|
||||
|
||||
|
||||
/* Maximum limits */
|
||||
#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 /* 64 hex chars + null + pad */
|
||||
#define ROLE_TABLE_MAX_ENTRIES 64
|
||||
|
||||
/* Purpose enum for fast comparison (string form kept for config/display) */
|
||||
typedef enum {
|
||||
PURPOSE_NOSTR = 0,
|
||||
PURPOSE_BITCOIN,
|
||||
PURPOSE_SSH,
|
||||
PURPOSE_AGE,
|
||||
PURPOSE_FIPS,
|
||||
PURPOSE_UNKNOWN
|
||||
} role_purpose_t;
|
||||
|
||||
/* Curve enum */
|
||||
typedef enum {
|
||||
CURVE_SECP256K1 = 0,
|
||||
CURVE_ED25519,
|
||||
CURVE_X25519,
|
||||
CURVE_UNKNOWN
|
||||
} role_curve_t;
|
||||
|
||||
/* Selector type — how this role's key is addressed */
|
||||
typedef enum {
|
||||
SELECTOR_NOSTR_INDEX, /* uses nostr_index shorthand */
|
||||
SELECTOR_ROLE_PATH /* uses explicit full path */
|
||||
} role_selector_type_t;
|
||||
|
||||
/* A single role entry */
|
||||
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; /* valid if selector_type == SELECTOR_NOSTR_INDEX */
|
||||
char role_path[ROLE_PATH_MAX]; /* valid if selector_type == SELECTOR_ROLE_PATH */
|
||||
char pubkey_hex[ROLE_PUBKEY_HEX_MAX]; /* filled after derivation, empty until then */
|
||||
int derived; /* 1 if pubkey_hex has been populated */
|
||||
} role_entry_t;
|
||||
|
||||
/* The role table */
|
||||
typedef struct {
|
||||
role_entry_t entries[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} role_table_t;
|
||||
|
||||
/* Initialize an empty role table */
|
||||
void role_table_init(role_table_t *table);
|
||||
|
||||
/* Add a role entry. Returns 0 on success, -1 if table full, -2 if name duplicate. */
|
||||
int role_table_add(role_table_t *table, const role_entry_t *entry);
|
||||
|
||||
/* Find a role by name. Returns pointer to entry or NULL. */
|
||||
role_entry_t *role_table_find_by_name(role_table_t *table, const char *name);
|
||||
|
||||
/* Find a role by nostr_index. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_nostr_index(role_table_t *table, int index);
|
||||
|
||||
/* Find a role by role_path. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_path(role_table_t *table, const char *path);
|
||||
|
||||
/* Get the default role (named "main"). Returns pointer or NULL if no "main" role. */
|
||||
role_entry_t *role_table_get_default(role_table_t *table);
|
||||
|
||||
/* Parse purpose string to enum */
|
||||
role_purpose_t role_purpose_from_str(const char *s);
|
||||
|
||||
/* Parse curve string to enum */
|
||||
role_curve_t role_curve_from_str(const char *s);
|
||||
|
||||
/* Purpose enum to string */
|
||||
const char *role_purpose_to_str(role_purpose_t p);
|
||||
|
||||
/* Curve enum to string */
|
||||
const char *role_curve_to_str(role_curve_t c);
|
||||
|
||||
|
||||
/* from selector.h */
|
||||
|
||||
|
||||
/* Error codes for selector resolution */
|
||||
#define SELECTOR_OK 0
|
||||
#define SELECTOR_ERR_AMBIGUOUS -1 /* multiple selectors specified */
|
||||
#define SELECTOR_ERR_NOT_FOUND -2 /* no matching role in table */
|
||||
#define SELECTOR_ERR_NO_DEFAULT -3 /* no selector given and no "main" role exists */
|
||||
|
||||
/* Parsed selector from a request's options object */
|
||||
typedef struct {
|
||||
int has_role; /* 1 if "role" field was present */
|
||||
char role_name[ROLE_NAME_MAX];
|
||||
|
||||
int has_nostr_index; /* 1 if "nostr_index" field was present */
|
||||
int nostr_index;
|
||||
|
||||
int has_role_path; /* 1 if "role_path" field was present */
|
||||
char role_path[ROLE_PATH_MAX];
|
||||
} selector_request_t;
|
||||
|
||||
/* Initialize a selector request (all fields zeroed/unset) */
|
||||
void selector_request_init(selector_request_t *req);
|
||||
|
||||
/*
|
||||
* Resolve a selector request against the role table.
|
||||
* On success (returns SELECTOR_OK), *out points to the matched role_entry_t.
|
||||
* On failure, returns one of the SELECTOR_ERR_* codes and *out is NULL.
|
||||
*/
|
||||
int selector_resolve(const selector_request_t *req, role_table_t *table, role_entry_t **out);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for a selector error code.
|
||||
*/
|
||||
const char *selector_strerror(int err);
|
||||
|
||||
|
||||
/* from enforcement.h */
|
||||
|
||||
|
||||
/* Error codes */
|
||||
#define ENFORCE_OK 0
|
||||
#define ENFORCE_ERR_PURPOSE -1 /* purpose mismatch */
|
||||
#define ENFORCE_ERR_CURVE -2 /* curve mismatch */
|
||||
#define ENFORCE_ERR_UNKNOWN_VERB -3 /* verb not recognized */
|
||||
|
||||
/* Known verbs */
|
||||
#define VERB_SIGN_EVENT "sign_event"
|
||||
#define VERB_GET_PUBLIC_KEY "get_public_key"
|
||||
#define VERB_NIP44_ENCRYPT "nip44_encrypt"
|
||||
#define VERB_NIP44_DECRYPT "nip44_decrypt"
|
||||
#define VERB_NIP04_ENCRYPT "nip04_encrypt"
|
||||
#define VERB_NIP04_DECRYPT "nip04_decrypt"
|
||||
|
||||
/*
|
||||
* Check whether `verb` is allowed to execute against `role`.
|
||||
* Returns ENFORCE_OK if allowed, or an ENFORCE_ERR_* code.
|
||||
*
|
||||
* The enforcement rules are:
|
||||
* - All nostr verbs (sign_event, get_public_key, nip44_*, nip04_*) require:
|
||||
* purpose == PURPOSE_NOSTR and curve == CURVE_SECP256K1
|
||||
* - Unknown verbs return ENFORCE_ERR_UNKNOWN_VERB (fail-closed).
|
||||
*/
|
||||
int enforce_verb_role(const char *verb, const role_entry_t *role);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for an enforcement error code.
|
||||
*/
|
||||
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 64
|
||||
|
||||
/* Prompt behavior */
|
||||
typedef enum {
|
||||
PROMPT_NEVER = 0,
|
||||
PROMPT_FIRST_PER_BOOT,
|
||||
PROMPT_EVERY_REQUEST,
|
||||
PROMPT_DENY
|
||||
} prompt_mode_t;
|
||||
|
||||
/* A single policy entry */
|
||||
typedef struct {
|
||||
char caller[POLICY_CALLER_MAX_LEN]; /* e.g. "uid:1000" or "*" for any */
|
||||
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;
|
||||
prompt_mode_t prompt;
|
||||
} policy_entry_t;
|
||||
|
||||
/* Policy table */
|
||||
typedef struct {
|
||||
policy_entry_t entries[POLICY_MAX_ENTRIES];
|
||||
int count;
|
||||
} policy_table_t;
|
||||
|
||||
/* Policy check result */
|
||||
#define POLICY_ALLOW 0
|
||||
#define POLICY_DENY -1
|
||||
#define POLICY_PROMPT -2 /* would need user confirmation */
|
||||
#define POLICY_NO_MATCH -3 /* no policy entry matched (fail-closed = deny) */
|
||||
|
||||
/* Initialize policy table */
|
||||
void policy_table_init(policy_table_t *table);
|
||||
|
||||
/* Initialize default policy: allow same-uid, deny others */
|
||||
void policy_init_default(policy_table_t *table, uid_t owner_uid);
|
||||
|
||||
/* Add a policy entry. Returns 0 on success, -1 if full. */
|
||||
int policy_table_add(policy_table_t *table, const policy_entry_t *entry);
|
||||
|
||||
/*
|
||||
* Check whether caller_id is allowed to invoke `verb` on `role_name` with given `purpose`.
|
||||
* Returns POLICY_ALLOW, POLICY_DENY, POLICY_PROMPT, or POLICY_NO_MATCH.
|
||||
*/
|
||||
int policy_check(const policy_table_t *table, const char *caller_id,
|
||||
const char *verb, const char *role_name, const char *purpose);
|
||||
|
||||
/* Parse prompt mode from string */
|
||||
prompt_mode_t prompt_mode_from_str(const char *s);
|
||||
|
||||
/* Prompt mode to string */
|
||||
const char *prompt_mode_to_str(prompt_mode_t m);
|
||||
|
||||
|
||||
/* from crypto.h */
|
||||
|
||||
|
||||
/* Per-role derived key material (stored in secure memory) */
|
||||
typedef struct {
|
||||
secure_buf_t private_key; /* 32 bytes, mlock'd */
|
||||
unsigned char public_key[32];
|
||||
char pubkey_hex[65]; /* 64 hex chars + null */
|
||||
char npub[128]; /* bech32 npub */
|
||||
int valid;
|
||||
} derived_key_t;
|
||||
|
||||
/* Key store — holds derived keys for all roles */
|
||||
typedef struct {
|
||||
derived_key_t keys[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} key_store_t;
|
||||
|
||||
/* Derive keys for all roles in the table using the loaded mnemonic.
|
||||
* Populates key_store and sets role->pubkey_hex and role->derived for each role.
|
||||
* Only derives for roles with purpose=nostr and curve=secp256k1 (for now).
|
||||
* Returns number of keys derived, or -1 on error. */
|
||||
int crypto_derive_all(key_store_t *store, role_table_t *table, const mnemonic_state_t *mnemonic);
|
||||
|
||||
/* Get the derived private key for a role (by table index). Returns NULL if not derived. */
|
||||
const unsigned char *crypto_get_private_key(const key_store_t *store, int role_index);
|
||||
|
||||
/* Get the derived public key hex for a role. Returns NULL if not derived. */
|
||||
const char *crypto_get_pubkey_hex(const key_store_t *store, int role_index);
|
||||
|
||||
/* Sign a Nostr event. event_json is the unsigned event JSON string.
|
||||
* Returns a newly-allocated string containing the signed event JSON, or NULL on error.
|
||||
* Caller must free() the returned string. */
|
||||
char *crypto_sign_event(const key_store_t *store, int role_index, const char *event_json);
|
||||
|
||||
/* Zeroize all derived keys in the store. */
|
||||
void crypto_wipe(key_store_t *store);
|
||||
|
||||
|
||||
/* from dispatcher.h */
|
||||
|
||||
|
||||
/* Dispatcher context — holds references to shared state */
|
||||
typedef struct {
|
||||
role_table_t *role_table;
|
||||
mnemonic_state_t *mnemonic;
|
||||
key_store_t *key_store;
|
||||
} dispatcher_ctx_t;
|
||||
|
||||
/* Initialize dispatcher context */
|
||||
void dispatcher_init(dispatcher_ctx_t *ctx, role_table_t *table, mnemonic_state_t *mnemonic, key_store_t *key_store);
|
||||
|
||||
/*
|
||||
* Process a JSON-RPC request string and produce a JSON-RPC response string.
|
||||
*
|
||||
* The caller owns the returned string and must free() it.
|
||||
* Returns NULL only on catastrophic allocation failure.
|
||||
*
|
||||
* Response format on success:
|
||||
* { "id": "...", "result": "..." }
|
||||
*
|
||||
* Response format on error:
|
||||
* { "id": "...", "error": { "code": <int>, "message": "..." } }
|
||||
*
|
||||
* Error codes:
|
||||
* -32700 Parse error (invalid JSON)
|
||||
* -32600 Invalid request (missing id/method/params)
|
||||
* -32601 Method not found (unknown verb after enforcement)
|
||||
* -32602 Invalid params
|
||||
* 1001 ambiguous_role_selector
|
||||
* 1002 role_not_found
|
||||
* 1003 no_default_role
|
||||
* 1004 purpose_mismatch
|
||||
* 1005 curve_mismatch
|
||||
* 1006 mnemonic_not_loaded
|
||||
*/
|
||||
char *dispatcher_handle_request(dispatcher_ctx_t *ctx, const char *json_request);
|
||||
|
||||
|
||||
/* from server.h */
|
||||
|
||||
|
||||
#define SERVER_SOCKET_NAME_MAX 108
|
||||
#define SERVER_MAX_MSG_SIZE 65536
|
||||
|
||||
/* Caller identity */
|
||||
typedef struct {
|
||||
uid_t uid;
|
||||
gid_t gid;
|
||||
pid_t pid;
|
||||
char caller_id[64]; /* "uid:<n>" */
|
||||
} caller_identity_t;
|
||||
|
||||
/* Server context */
|
||||
typedef struct {
|
||||
char socket_name[SERVER_SOCKET_NAME_MAX]; /* abstract namespace name (without \0 prefix) */
|
||||
char last_error[256];
|
||||
int listen_fd;
|
||||
int running;
|
||||
dispatcher_ctx_t *dispatcher;
|
||||
policy_table_t *policy;
|
||||
int socket_name_explicit;
|
||||
} server_ctx_t;
|
||||
|
||||
/* Initialize server context. socket_name is the abstract namespace name (e.g. "nsigner").
|
||||
* socket_name_explicit should be non-zero when provided via --socket-name override. */
|
||||
void server_init(server_ctx_t *ctx, const char *socket_name, int socket_name_explicit,
|
||||
dispatcher_ctx_t *dispatcher, policy_table_t *policy);
|
||||
|
||||
/* Start listening. Returns 0 on success, -1 on error. */
|
||||
int server_start(server_ctx_t *ctx);
|
||||
|
||||
/* Get human-readable description of last server error. */
|
||||
const char *server_last_error(const server_ctx_t *ctx);
|
||||
|
||||
/* Handle one pending connection (non-blocking). Returns 1 if handled, 0 if nothing pending, -1 on error.
|
||||
* activity_cb is called with a description string for the TUI activity log. */
|
||||
typedef void (*server_activity_cb)(const char *message, void *user_data);
|
||||
int server_handle_one(server_ctx_t *ctx, server_activity_cb cb, void *cb_data);
|
||||
|
||||
/* Stop server and close socket */
|
||||
void server_stop(server_ctx_t *ctx);
|
||||
|
||||
/* Extract caller identity from connected fd */
|
||||
int server_get_caller(int fd, caller_identity_t *out);
|
||||
|
||||
|
||||
/* from socket_name.h */
|
||||
|
||||
|
||||
/*
|
||||
* Generate random socket name in format: nsigner_<word1>_<word2>
|
||||
* Returns 0 on success, -1 on error.
|
||||
*/
|
||||
int socket_name_random(char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from main.h */
|
||||
/*
|
||||
* nsigner main header - version information
|
||||
*
|
||||
* Version macros are auto-updated by increment_and_push.sh.
|
||||
*/
|
||||
|
||||
|
||||
/* Version information (auto-updated by build/version tooling) */
|
||||
#define NSIGNER_VERSION_MAJOR 0
|
||||
#define NSIGNER_VERSION_MINOR 0
|
||||
#define NSIGNER_VERSION_PATCH 2
|
||||
#define NSIGNER_VERSION "v0.0.2"
|
||||
|
||||
|
||||
/* NSIGNER_HEADERLESS_DECLS_END */
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
@@ -1,44 +0,0 @@
|
||||
#ifndef NSIGNER_DISPATCHER_H
|
||||
#define NSIGNER_DISPATCHER_H
|
||||
|
||||
#include "role_table.h"
|
||||
#include "mnemonic.h"
|
||||
#include "crypto.h"
|
||||
|
||||
/* Dispatcher context — holds references to shared state */
|
||||
typedef struct {
|
||||
role_table_t *role_table;
|
||||
mnemonic_state_t *mnemonic;
|
||||
key_store_t *key_store;
|
||||
} dispatcher_ctx_t;
|
||||
|
||||
/* Initialize dispatcher context */
|
||||
void dispatcher_init(dispatcher_ctx_t *ctx, role_table_t *table, mnemonic_state_t *mnemonic, key_store_t *key_store);
|
||||
|
||||
/*
|
||||
* Process a JSON-RPC request string and produce a JSON-RPC response string.
|
||||
*
|
||||
* The caller owns the returned string and must free() it.
|
||||
* Returns NULL only on catastrophic allocation failure.
|
||||
*
|
||||
* Response format on success:
|
||||
* { "id": "...", "result": "..." }
|
||||
*
|
||||
* Response format on error:
|
||||
* { "id": "...", "error": { "code": <int>, "message": "..." } }
|
||||
*
|
||||
* Error codes:
|
||||
* -32700 Parse error (invalid JSON)
|
||||
* -32600 Invalid request (missing id/method/params)
|
||||
* -32601 Method not found (unknown verb after enforcement)
|
||||
* -32602 Invalid params
|
||||
* 1001 ambiguous_role_selector
|
||||
* 1002 role_not_found
|
||||
* 1003 no_default_role
|
||||
* 1004 purpose_mismatch
|
||||
* 1005 curve_mismatch
|
||||
* 1006 mnemonic_not_loaded
|
||||
*/
|
||||
char *dispatcher_handle_request(dispatcher_ctx_t *ctx, const char *json_request);
|
||||
|
||||
#endif /* NSIGNER_DISPATCHER_H */
|
||||
@@ -1,4 +1,444 @@
|
||||
#include "enforcement.h"
|
||||
/* NSIGNER_HEADERLESS_DECLS_BEGIN */
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
#include <cJSON.h>
|
||||
|
||||
/* from secure_mem.h */
|
||||
|
||||
|
||||
/*
|
||||
* Secure memory buffer — mlock'd, zeroized on free.
|
||||
* Used for mnemonic phrases, private keys, and any sensitive material.
|
||||
*/
|
||||
typedef struct {
|
||||
void *data; /* pointer to locked allocation */
|
||||
size_t size; /* usable size in bytes */
|
||||
int locked; /* 1 if mlock succeeded */
|
||||
} secure_buf_t;
|
||||
|
||||
/* Allocate a secure buffer of `size` bytes. Returns 0 on success, -1 on failure. */
|
||||
int secure_buf_alloc(secure_buf_t *buf, size_t size);
|
||||
|
||||
/* Zeroize and free a secure buffer. Always succeeds (idempotent). */
|
||||
void secure_buf_free(secure_buf_t *buf);
|
||||
|
||||
/* Zeroize `len` bytes at `ptr` in a way the compiler cannot optimize away. */
|
||||
void secure_memzero(void *ptr, size_t len);
|
||||
|
||||
|
||||
/* from mnemonic.h */
|
||||
|
||||
|
||||
/* Maximum mnemonic length: 24 words * 10 chars avg + spaces + null = 256 is safe */
|
||||
#define MNEMONIC_MAX_LEN 256
|
||||
|
||||
/*
|
||||
* Mnemonic state — holds the loaded mnemonic in secure memory.
|
||||
* Only one mnemonic is active at a time per process.
|
||||
*/
|
||||
typedef struct {
|
||||
secure_buf_t buf; /* secure storage for the mnemonic string */
|
||||
int loaded; /* 1 if a mnemonic is currently loaded */
|
||||
int word_count; /* 12, 15, 18, 21, or 24 */
|
||||
} mnemonic_state_t;
|
||||
|
||||
/* Initialize mnemonic state (must be called before use). */
|
||||
void mnemonic_init(mnemonic_state_t *state);
|
||||
|
||||
/* Load a mnemonic string into secure memory. Validates word count (12/15/18/21/24).
|
||||
* Returns 0 on success, -1 on invalid input, -2 on memory error. */
|
||||
int mnemonic_load(mnemonic_state_t *state, const char *phrase);
|
||||
|
||||
/* Zeroize and unload the mnemonic. Idempotent. */
|
||||
void mnemonic_unload(mnemonic_state_t *state);
|
||||
|
||||
/* Check if a mnemonic is currently loaded. */
|
||||
int mnemonic_is_loaded(const mnemonic_state_t *state);
|
||||
|
||||
/* Get the mnemonic string (only valid while loaded). Returns NULL if not loaded. */
|
||||
const char *mnemonic_get_phrase(const mnemonic_state_t *state);
|
||||
|
||||
/* Generate a new BIP-39 mnemonic phrase (12/15/18/21/24 words) into out.
|
||||
* Returns 0 on success, -1 on invalid arguments or generation failure. */
|
||||
int mnemonic_generate(int word_count, char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from role_table.h */
|
||||
|
||||
|
||||
/* Maximum limits */
|
||||
#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 /* 64 hex chars + null + pad */
|
||||
#define ROLE_TABLE_MAX_ENTRIES 64
|
||||
|
||||
/* Purpose enum for fast comparison (string form kept for config/display) */
|
||||
typedef enum {
|
||||
PURPOSE_NOSTR = 0,
|
||||
PURPOSE_BITCOIN,
|
||||
PURPOSE_SSH,
|
||||
PURPOSE_AGE,
|
||||
PURPOSE_FIPS,
|
||||
PURPOSE_UNKNOWN
|
||||
} role_purpose_t;
|
||||
|
||||
/* Curve enum */
|
||||
typedef enum {
|
||||
CURVE_SECP256K1 = 0,
|
||||
CURVE_ED25519,
|
||||
CURVE_X25519,
|
||||
CURVE_UNKNOWN
|
||||
} role_curve_t;
|
||||
|
||||
/* Selector type — how this role's key is addressed */
|
||||
typedef enum {
|
||||
SELECTOR_NOSTR_INDEX, /* uses nostr_index shorthand */
|
||||
SELECTOR_ROLE_PATH /* uses explicit full path */
|
||||
} role_selector_type_t;
|
||||
|
||||
/* A single role entry */
|
||||
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; /* valid if selector_type == SELECTOR_NOSTR_INDEX */
|
||||
char role_path[ROLE_PATH_MAX]; /* valid if selector_type == SELECTOR_ROLE_PATH */
|
||||
char pubkey_hex[ROLE_PUBKEY_HEX_MAX]; /* filled after derivation, empty until then */
|
||||
int derived; /* 1 if pubkey_hex has been populated */
|
||||
} role_entry_t;
|
||||
|
||||
/* The role table */
|
||||
typedef struct {
|
||||
role_entry_t entries[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} role_table_t;
|
||||
|
||||
/* Initialize an empty role table */
|
||||
void role_table_init(role_table_t *table);
|
||||
|
||||
/* Add a role entry. Returns 0 on success, -1 if table full, -2 if name duplicate. */
|
||||
int role_table_add(role_table_t *table, const role_entry_t *entry);
|
||||
|
||||
/* Find a role by name. Returns pointer to entry or NULL. */
|
||||
role_entry_t *role_table_find_by_name(role_table_t *table, const char *name);
|
||||
|
||||
/* Find a role by nostr_index. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_nostr_index(role_table_t *table, int index);
|
||||
|
||||
/* Find a role by role_path. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_path(role_table_t *table, const char *path);
|
||||
|
||||
/* Get the default role (named "main"). Returns pointer or NULL if no "main" role. */
|
||||
role_entry_t *role_table_get_default(role_table_t *table);
|
||||
|
||||
/* Parse purpose string to enum */
|
||||
role_purpose_t role_purpose_from_str(const char *s);
|
||||
|
||||
/* Parse curve string to enum */
|
||||
role_curve_t role_curve_from_str(const char *s);
|
||||
|
||||
/* Purpose enum to string */
|
||||
const char *role_purpose_to_str(role_purpose_t p);
|
||||
|
||||
/* Curve enum to string */
|
||||
const char *role_curve_to_str(role_curve_t c);
|
||||
|
||||
|
||||
/* from selector.h */
|
||||
|
||||
|
||||
/* Error codes for selector resolution */
|
||||
#define SELECTOR_OK 0
|
||||
#define SELECTOR_ERR_AMBIGUOUS -1 /* multiple selectors specified */
|
||||
#define SELECTOR_ERR_NOT_FOUND -2 /* no matching role in table */
|
||||
#define SELECTOR_ERR_NO_DEFAULT -3 /* no selector given and no "main" role exists */
|
||||
|
||||
/* Parsed selector from a request's options object */
|
||||
typedef struct {
|
||||
int has_role; /* 1 if "role" field was present */
|
||||
char role_name[ROLE_NAME_MAX];
|
||||
|
||||
int has_nostr_index; /* 1 if "nostr_index" field was present */
|
||||
int nostr_index;
|
||||
|
||||
int has_role_path; /* 1 if "role_path" field was present */
|
||||
char role_path[ROLE_PATH_MAX];
|
||||
} selector_request_t;
|
||||
|
||||
/* Initialize a selector request (all fields zeroed/unset) */
|
||||
void selector_request_init(selector_request_t *req);
|
||||
|
||||
/*
|
||||
* Resolve a selector request against the role table.
|
||||
* On success (returns SELECTOR_OK), *out points to the matched role_entry_t.
|
||||
* On failure, returns one of the SELECTOR_ERR_* codes and *out is NULL.
|
||||
*/
|
||||
int selector_resolve(const selector_request_t *req, role_table_t *table, role_entry_t **out);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for a selector error code.
|
||||
*/
|
||||
const char *selector_strerror(int err);
|
||||
|
||||
|
||||
/* from enforcement.h */
|
||||
|
||||
|
||||
/* Error codes */
|
||||
#define ENFORCE_OK 0
|
||||
#define ENFORCE_ERR_PURPOSE -1 /* purpose mismatch */
|
||||
#define ENFORCE_ERR_CURVE -2 /* curve mismatch */
|
||||
#define ENFORCE_ERR_UNKNOWN_VERB -3 /* verb not recognized */
|
||||
|
||||
/* Known verbs */
|
||||
#define VERB_SIGN_EVENT "sign_event"
|
||||
#define VERB_GET_PUBLIC_KEY "get_public_key"
|
||||
#define VERB_NIP44_ENCRYPT "nip44_encrypt"
|
||||
#define VERB_NIP44_DECRYPT "nip44_decrypt"
|
||||
#define VERB_NIP04_ENCRYPT "nip04_encrypt"
|
||||
#define VERB_NIP04_DECRYPT "nip04_decrypt"
|
||||
|
||||
/*
|
||||
* Check whether `verb` is allowed to execute against `role`.
|
||||
* Returns ENFORCE_OK if allowed, or an ENFORCE_ERR_* code.
|
||||
*
|
||||
* The enforcement rules are:
|
||||
* - All nostr verbs (sign_event, get_public_key, nip44_*, nip04_*) require:
|
||||
* purpose == PURPOSE_NOSTR and curve == CURVE_SECP256K1
|
||||
* - Unknown verbs return ENFORCE_ERR_UNKNOWN_VERB (fail-closed).
|
||||
*/
|
||||
int enforce_verb_role(const char *verb, const role_entry_t *role);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for an enforcement error code.
|
||||
*/
|
||||
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 64
|
||||
|
||||
/* Prompt behavior */
|
||||
typedef enum {
|
||||
PROMPT_NEVER = 0,
|
||||
PROMPT_FIRST_PER_BOOT,
|
||||
PROMPT_EVERY_REQUEST,
|
||||
PROMPT_DENY
|
||||
} prompt_mode_t;
|
||||
|
||||
/* A single policy entry */
|
||||
typedef struct {
|
||||
char caller[POLICY_CALLER_MAX_LEN]; /* e.g. "uid:1000" or "*" for any */
|
||||
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;
|
||||
prompt_mode_t prompt;
|
||||
} policy_entry_t;
|
||||
|
||||
/* Policy table */
|
||||
typedef struct {
|
||||
policy_entry_t entries[POLICY_MAX_ENTRIES];
|
||||
int count;
|
||||
} policy_table_t;
|
||||
|
||||
/* Policy check result */
|
||||
#define POLICY_ALLOW 0
|
||||
#define POLICY_DENY -1
|
||||
#define POLICY_PROMPT -2 /* would need user confirmation */
|
||||
#define POLICY_NO_MATCH -3 /* no policy entry matched (fail-closed = deny) */
|
||||
|
||||
/* Initialize policy table */
|
||||
void policy_table_init(policy_table_t *table);
|
||||
|
||||
/* Initialize default policy: allow same-uid, deny others */
|
||||
void policy_init_default(policy_table_t *table, uid_t owner_uid);
|
||||
|
||||
/* Add a policy entry. Returns 0 on success, -1 if full. */
|
||||
int policy_table_add(policy_table_t *table, const policy_entry_t *entry);
|
||||
|
||||
/*
|
||||
* Check whether caller_id is allowed to invoke `verb` on `role_name` with given `purpose`.
|
||||
* Returns POLICY_ALLOW, POLICY_DENY, POLICY_PROMPT, or POLICY_NO_MATCH.
|
||||
*/
|
||||
int policy_check(const policy_table_t *table, const char *caller_id,
|
||||
const char *verb, const char *role_name, const char *purpose);
|
||||
|
||||
/* Parse prompt mode from string */
|
||||
prompt_mode_t prompt_mode_from_str(const char *s);
|
||||
|
||||
/* Prompt mode to string */
|
||||
const char *prompt_mode_to_str(prompt_mode_t m);
|
||||
|
||||
|
||||
/* from crypto.h */
|
||||
|
||||
|
||||
/* Per-role derived key material (stored in secure memory) */
|
||||
typedef struct {
|
||||
secure_buf_t private_key; /* 32 bytes, mlock'd */
|
||||
unsigned char public_key[32];
|
||||
char pubkey_hex[65]; /* 64 hex chars + null */
|
||||
char npub[128]; /* bech32 npub */
|
||||
int valid;
|
||||
} derived_key_t;
|
||||
|
||||
/* Key store — holds derived keys for all roles */
|
||||
typedef struct {
|
||||
derived_key_t keys[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} key_store_t;
|
||||
|
||||
/* Derive keys for all roles in the table using the loaded mnemonic.
|
||||
* Populates key_store and sets role->pubkey_hex and role->derived for each role.
|
||||
* Only derives for roles with purpose=nostr and curve=secp256k1 (for now).
|
||||
* Returns number of keys derived, or -1 on error. */
|
||||
int crypto_derive_all(key_store_t *store, role_table_t *table, const mnemonic_state_t *mnemonic);
|
||||
|
||||
/* Get the derived private key for a role (by table index). Returns NULL if not derived. */
|
||||
const unsigned char *crypto_get_private_key(const key_store_t *store, int role_index);
|
||||
|
||||
/* Get the derived public key hex for a role. Returns NULL if not derived. */
|
||||
const char *crypto_get_pubkey_hex(const key_store_t *store, int role_index);
|
||||
|
||||
/* Sign a Nostr event. event_json is the unsigned event JSON string.
|
||||
* Returns a newly-allocated string containing the signed event JSON, or NULL on error.
|
||||
* Caller must free() the returned string. */
|
||||
char *crypto_sign_event(const key_store_t *store, int role_index, const char *event_json);
|
||||
|
||||
/* Zeroize all derived keys in the store. */
|
||||
void crypto_wipe(key_store_t *store);
|
||||
|
||||
|
||||
/* from dispatcher.h */
|
||||
|
||||
|
||||
/* Dispatcher context — holds references to shared state */
|
||||
typedef struct {
|
||||
role_table_t *role_table;
|
||||
mnemonic_state_t *mnemonic;
|
||||
key_store_t *key_store;
|
||||
} dispatcher_ctx_t;
|
||||
|
||||
/* Initialize dispatcher context */
|
||||
void dispatcher_init(dispatcher_ctx_t *ctx, role_table_t *table, mnemonic_state_t *mnemonic, key_store_t *key_store);
|
||||
|
||||
/*
|
||||
* Process a JSON-RPC request string and produce a JSON-RPC response string.
|
||||
*
|
||||
* The caller owns the returned string and must free() it.
|
||||
* Returns NULL only on catastrophic allocation failure.
|
||||
*
|
||||
* Response format on success:
|
||||
* { "id": "...", "result": "..." }
|
||||
*
|
||||
* Response format on error:
|
||||
* { "id": "...", "error": { "code": <int>, "message": "..." } }
|
||||
*
|
||||
* Error codes:
|
||||
* -32700 Parse error (invalid JSON)
|
||||
* -32600 Invalid request (missing id/method/params)
|
||||
* -32601 Method not found (unknown verb after enforcement)
|
||||
* -32602 Invalid params
|
||||
* 1001 ambiguous_role_selector
|
||||
* 1002 role_not_found
|
||||
* 1003 no_default_role
|
||||
* 1004 purpose_mismatch
|
||||
* 1005 curve_mismatch
|
||||
* 1006 mnemonic_not_loaded
|
||||
*/
|
||||
char *dispatcher_handle_request(dispatcher_ctx_t *ctx, const char *json_request);
|
||||
|
||||
|
||||
/* from server.h */
|
||||
|
||||
|
||||
#define SERVER_SOCKET_NAME_MAX 108
|
||||
#define SERVER_MAX_MSG_SIZE 65536
|
||||
|
||||
/* Caller identity */
|
||||
typedef struct {
|
||||
uid_t uid;
|
||||
gid_t gid;
|
||||
pid_t pid;
|
||||
char caller_id[64]; /* "uid:<n>" */
|
||||
} caller_identity_t;
|
||||
|
||||
/* Server context */
|
||||
typedef struct {
|
||||
char socket_name[SERVER_SOCKET_NAME_MAX]; /* abstract namespace name (without \0 prefix) */
|
||||
char last_error[256];
|
||||
int listen_fd;
|
||||
int running;
|
||||
dispatcher_ctx_t *dispatcher;
|
||||
policy_table_t *policy;
|
||||
int socket_name_explicit;
|
||||
} server_ctx_t;
|
||||
|
||||
/* Initialize server context. socket_name is the abstract namespace name (e.g. "nsigner").
|
||||
* socket_name_explicit should be non-zero when provided via --socket-name override. */
|
||||
void server_init(server_ctx_t *ctx, const char *socket_name, int socket_name_explicit,
|
||||
dispatcher_ctx_t *dispatcher, policy_table_t *policy);
|
||||
|
||||
/* Start listening. Returns 0 on success, -1 on error. */
|
||||
int server_start(server_ctx_t *ctx);
|
||||
|
||||
/* Get human-readable description of last server error. */
|
||||
const char *server_last_error(const server_ctx_t *ctx);
|
||||
|
||||
/* Handle one pending connection (non-blocking). Returns 1 if handled, 0 if nothing pending, -1 on error.
|
||||
* activity_cb is called with a description string for the TUI activity log. */
|
||||
typedef void (*server_activity_cb)(const char *message, void *user_data);
|
||||
int server_handle_one(server_ctx_t *ctx, server_activity_cb cb, void *cb_data);
|
||||
|
||||
/* Stop server and close socket */
|
||||
void server_stop(server_ctx_t *ctx);
|
||||
|
||||
/* Extract caller identity from connected fd */
|
||||
int server_get_caller(int fd, caller_identity_t *out);
|
||||
|
||||
|
||||
/* from socket_name.h */
|
||||
|
||||
|
||||
/*
|
||||
* Generate random socket name in format: nsigner_<word1>_<word2>
|
||||
* Returns 0 on success, -1 on error.
|
||||
*/
|
||||
int socket_name_random(char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from main.h */
|
||||
/*
|
||||
* nsigner main header - version information
|
||||
*
|
||||
* Version macros are auto-updated by increment_and_push.sh.
|
||||
*/
|
||||
|
||||
|
||||
/* Version information (auto-updated by build/version tooling) */
|
||||
#define NSIGNER_VERSION_MAJOR 0
|
||||
#define NSIGNER_VERSION_MINOR 0
|
||||
#define NSIGNER_VERSION_PATCH 2
|
||||
#define NSIGNER_VERSION "v0.0.2"
|
||||
|
||||
|
||||
/* NSIGNER_HEADERLESS_DECLS_END */
|
||||
|
||||
#include <string.h>
|
||||
|
||||
|
||||
@@ -1,36 +0,0 @@
|
||||
#ifndef NSIGNER_ENFORCEMENT_H
|
||||
#define NSIGNER_ENFORCEMENT_H
|
||||
|
||||
#include "role_table.h"
|
||||
|
||||
/* Error codes */
|
||||
#define ENFORCE_OK 0
|
||||
#define ENFORCE_ERR_PURPOSE -1 /* purpose mismatch */
|
||||
#define ENFORCE_ERR_CURVE -2 /* curve mismatch */
|
||||
#define ENFORCE_ERR_UNKNOWN_VERB -3 /* verb not recognized */
|
||||
|
||||
/* Known verbs */
|
||||
#define VERB_SIGN_EVENT "sign_event"
|
||||
#define VERB_GET_PUBLIC_KEY "get_public_key"
|
||||
#define VERB_NIP44_ENCRYPT "nip44_encrypt"
|
||||
#define VERB_NIP44_DECRYPT "nip44_decrypt"
|
||||
#define VERB_NIP04_ENCRYPT "nip04_encrypt"
|
||||
#define VERB_NIP04_DECRYPT "nip04_decrypt"
|
||||
|
||||
/*
|
||||
* Check whether `verb` is allowed to execute against `role`.
|
||||
* Returns ENFORCE_OK if allowed, or an ENFORCE_ERR_* code.
|
||||
*
|
||||
* The enforcement rules are:
|
||||
* - All nostr verbs (sign_event, get_public_key, nip44_*, nip04_*) require:
|
||||
* purpose == PURPOSE_NOSTR and curve == CURVE_SECP256K1
|
||||
* - Unknown verbs return ENFORCE_ERR_UNKNOWN_VERB (fail-closed).
|
||||
*/
|
||||
int enforce_verb_role(const char *verb, const role_entry_t *role);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for an enforcement error code.
|
||||
*/
|
||||
const char *enforce_strerror(int err);
|
||||
|
||||
#endif /* NSIGNER_ENFORCEMENT_H */
|
||||
628
src/key_store.c
Normal file
628
src/key_store.c
Normal file
@@ -0,0 +1,628 @@
|
||||
#define _GNU_SOURCE
|
||||
|
||||
/* NSIGNER_HEADERLESS_DECLS_BEGIN */
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
#include <cJSON.h>
|
||||
|
||||
/* from secure_mem.h */
|
||||
|
||||
|
||||
/*
|
||||
* Secure memory buffer — mlock'd, zeroized on free.
|
||||
* Used for mnemonic phrases, private keys, and any sensitive material.
|
||||
*/
|
||||
typedef struct {
|
||||
void *data; /* pointer to locked allocation */
|
||||
size_t size; /* usable size in bytes */
|
||||
int locked; /* 1 if mlock succeeded */
|
||||
} secure_buf_t;
|
||||
|
||||
/* Allocate a secure buffer of `size` bytes. Returns 0 on success, -1 on failure. */
|
||||
int secure_buf_alloc(secure_buf_t *buf, size_t size);
|
||||
|
||||
/* Zeroize and free a secure buffer. Always succeeds (idempotent). */
|
||||
void secure_buf_free(secure_buf_t *buf);
|
||||
|
||||
/* Zeroize `len` bytes at `ptr` in a way the compiler cannot optimize away. */
|
||||
void secure_memzero(void *ptr, size_t len);
|
||||
|
||||
|
||||
/* from mnemonic.h */
|
||||
|
||||
|
||||
/* Maximum mnemonic length: 24 words * 10 chars avg + spaces + null = 256 is safe */
|
||||
#define MNEMONIC_MAX_LEN 256
|
||||
|
||||
/*
|
||||
* Mnemonic state — holds the loaded mnemonic in secure memory.
|
||||
* Only one mnemonic is active at a time per process.
|
||||
*/
|
||||
typedef struct {
|
||||
secure_buf_t buf; /* secure storage for the mnemonic string */
|
||||
int loaded; /* 1 if a mnemonic is currently loaded */
|
||||
int word_count; /* 12, 15, 18, 21, or 24 */
|
||||
} mnemonic_state_t;
|
||||
|
||||
/* Initialize mnemonic state (must be called before use). */
|
||||
void mnemonic_init(mnemonic_state_t *state);
|
||||
|
||||
/* Load a mnemonic string into secure memory. Validates word count (12/15/18/21/24).
|
||||
* Returns 0 on success, -1 on invalid input, -2 on memory error. */
|
||||
int mnemonic_load(mnemonic_state_t *state, const char *phrase);
|
||||
|
||||
/* Zeroize and unload the mnemonic. Idempotent. */
|
||||
void mnemonic_unload(mnemonic_state_t *state);
|
||||
|
||||
/* Check if a mnemonic is currently loaded. */
|
||||
int mnemonic_is_loaded(const mnemonic_state_t *state);
|
||||
|
||||
/* Get the mnemonic string (only valid while loaded). Returns NULL if not loaded. */
|
||||
const char *mnemonic_get_phrase(const mnemonic_state_t *state);
|
||||
|
||||
/* Generate a new BIP-39 mnemonic phrase (12/15/18/21/24 words) into out.
|
||||
* Returns 0 on success, -1 on invalid arguments or generation failure. */
|
||||
int mnemonic_generate(int word_count, char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from role_table.h */
|
||||
|
||||
|
||||
/* Maximum limits */
|
||||
#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 /* 64 hex chars + null + pad */
|
||||
#define ROLE_TABLE_MAX_ENTRIES 64
|
||||
|
||||
/* Purpose enum for fast comparison (string form kept for config/display) */
|
||||
typedef enum {
|
||||
PURPOSE_NOSTR = 0,
|
||||
PURPOSE_BITCOIN,
|
||||
PURPOSE_SSH,
|
||||
PURPOSE_AGE,
|
||||
PURPOSE_FIPS,
|
||||
PURPOSE_UNKNOWN
|
||||
} role_purpose_t;
|
||||
|
||||
/* Curve enum */
|
||||
typedef enum {
|
||||
CURVE_SECP256K1 = 0,
|
||||
CURVE_ED25519,
|
||||
CURVE_X25519,
|
||||
CURVE_UNKNOWN
|
||||
} role_curve_t;
|
||||
|
||||
/* Selector type — how this role's key is addressed */
|
||||
typedef enum {
|
||||
SELECTOR_NOSTR_INDEX, /* uses nostr_index shorthand */
|
||||
SELECTOR_ROLE_PATH /* uses explicit full path */
|
||||
} role_selector_type_t;
|
||||
|
||||
/* A single role entry */
|
||||
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; /* valid if selector_type == SELECTOR_NOSTR_INDEX */
|
||||
char role_path[ROLE_PATH_MAX]; /* valid if selector_type == SELECTOR_ROLE_PATH */
|
||||
char pubkey_hex[ROLE_PUBKEY_HEX_MAX]; /* filled after derivation, empty until then */
|
||||
int derived; /* 1 if pubkey_hex has been populated */
|
||||
} role_entry_t;
|
||||
|
||||
/* The role table */
|
||||
typedef struct {
|
||||
role_entry_t entries[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} role_table_t;
|
||||
|
||||
/* Initialize an empty role table */
|
||||
void role_table_init(role_table_t *table);
|
||||
|
||||
/* Add a role entry. Returns 0 on success, -1 if table full, -2 if name duplicate. */
|
||||
int role_table_add(role_table_t *table, const role_entry_t *entry);
|
||||
|
||||
/* Find a role by name. Returns pointer to entry or NULL. */
|
||||
role_entry_t *role_table_find_by_name(role_table_t *table, const char *name);
|
||||
|
||||
/* Find a role by nostr_index. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_nostr_index(role_table_t *table, int index);
|
||||
|
||||
/* Find a role by role_path. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_path(role_table_t *table, const char *path);
|
||||
|
||||
/* Get the default role (named "main"). Returns pointer or NULL if no "main" role. */
|
||||
role_entry_t *role_table_get_default(role_table_t *table);
|
||||
|
||||
/* Parse purpose string to enum */
|
||||
role_purpose_t role_purpose_from_str(const char *s);
|
||||
|
||||
/* Parse curve string to enum */
|
||||
role_curve_t role_curve_from_str(const char *s);
|
||||
|
||||
/* Purpose enum to string */
|
||||
const char *role_purpose_to_str(role_purpose_t p);
|
||||
|
||||
/* Curve enum to string */
|
||||
const char *role_curve_to_str(role_curve_t c);
|
||||
|
||||
|
||||
/* from selector.h */
|
||||
|
||||
|
||||
/* Error codes for selector resolution */
|
||||
#define SELECTOR_OK 0
|
||||
#define SELECTOR_ERR_AMBIGUOUS -1 /* multiple selectors specified */
|
||||
#define SELECTOR_ERR_NOT_FOUND -2 /* no matching role in table */
|
||||
#define SELECTOR_ERR_NO_DEFAULT -3 /* no selector given and no "main" role exists */
|
||||
|
||||
/* Parsed selector from a request's options object */
|
||||
typedef struct {
|
||||
int has_role; /* 1 if "role" field was present */
|
||||
char role_name[ROLE_NAME_MAX];
|
||||
|
||||
int has_nostr_index; /* 1 if "nostr_index" field was present */
|
||||
int nostr_index;
|
||||
|
||||
int has_role_path; /* 1 if "role_path" field was present */
|
||||
char role_path[ROLE_PATH_MAX];
|
||||
} selector_request_t;
|
||||
|
||||
/* Initialize a selector request (all fields zeroed/unset) */
|
||||
void selector_request_init(selector_request_t *req);
|
||||
|
||||
/*
|
||||
* Resolve a selector request against the role table.
|
||||
* On success (returns SELECTOR_OK), *out points to the matched role_entry_t.
|
||||
* On failure, returns one of the SELECTOR_ERR_* codes and *out is NULL.
|
||||
*/
|
||||
int selector_resolve(const selector_request_t *req, role_table_t *table, role_entry_t **out);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for a selector error code.
|
||||
*/
|
||||
const char *selector_strerror(int err);
|
||||
|
||||
|
||||
/* from enforcement.h */
|
||||
|
||||
|
||||
/* Error codes */
|
||||
#define ENFORCE_OK 0
|
||||
#define ENFORCE_ERR_PURPOSE -1 /* purpose mismatch */
|
||||
#define ENFORCE_ERR_CURVE -2 /* curve mismatch */
|
||||
#define ENFORCE_ERR_UNKNOWN_VERB -3 /* verb not recognized */
|
||||
|
||||
/* Known verbs */
|
||||
#define VERB_SIGN_EVENT "sign_event"
|
||||
#define VERB_GET_PUBLIC_KEY "get_public_key"
|
||||
#define VERB_NIP44_ENCRYPT "nip44_encrypt"
|
||||
#define VERB_NIP44_DECRYPT "nip44_decrypt"
|
||||
#define VERB_NIP04_ENCRYPT "nip04_encrypt"
|
||||
#define VERB_NIP04_DECRYPT "nip04_decrypt"
|
||||
|
||||
/*
|
||||
* Check whether `verb` is allowed to execute against `role`.
|
||||
* Returns ENFORCE_OK if allowed, or an ENFORCE_ERR_* code.
|
||||
*
|
||||
* The enforcement rules are:
|
||||
* - All nostr verbs (sign_event, get_public_key, nip44_*, nip04_*) require:
|
||||
* purpose == PURPOSE_NOSTR and curve == CURVE_SECP256K1
|
||||
* - Unknown verbs return ENFORCE_ERR_UNKNOWN_VERB (fail-closed).
|
||||
*/
|
||||
int enforce_verb_role(const char *verb, const role_entry_t *role);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for an enforcement error code.
|
||||
*/
|
||||
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 64
|
||||
|
||||
/* Prompt behavior */
|
||||
typedef enum {
|
||||
PROMPT_NEVER = 0,
|
||||
PROMPT_FIRST_PER_BOOT,
|
||||
PROMPT_EVERY_REQUEST,
|
||||
PROMPT_DENY
|
||||
} prompt_mode_t;
|
||||
|
||||
/* A single policy entry */
|
||||
typedef struct {
|
||||
char caller[POLICY_CALLER_MAX_LEN]; /* e.g. "uid:1000" or "*" for any */
|
||||
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;
|
||||
prompt_mode_t prompt;
|
||||
} policy_entry_t;
|
||||
|
||||
/* Policy table */
|
||||
typedef struct {
|
||||
policy_entry_t entries[POLICY_MAX_ENTRIES];
|
||||
int count;
|
||||
} policy_table_t;
|
||||
|
||||
/* Policy check result */
|
||||
#define POLICY_ALLOW 0
|
||||
#define POLICY_DENY -1
|
||||
#define POLICY_PROMPT -2 /* would need user confirmation */
|
||||
#define POLICY_NO_MATCH -3 /* no policy entry matched (fail-closed = deny) */
|
||||
|
||||
/* Initialize policy table */
|
||||
void policy_table_init(policy_table_t *table);
|
||||
|
||||
/* Initialize default policy: allow same-uid, deny others */
|
||||
void policy_init_default(policy_table_t *table, uid_t owner_uid);
|
||||
|
||||
/* Add a policy entry. Returns 0 on success, -1 if full. */
|
||||
int policy_table_add(policy_table_t *table, const policy_entry_t *entry);
|
||||
|
||||
/*
|
||||
* Check whether caller_id is allowed to invoke `verb` on `role_name` with given `purpose`.
|
||||
* Returns POLICY_ALLOW, POLICY_DENY, POLICY_PROMPT, or POLICY_NO_MATCH.
|
||||
*/
|
||||
int policy_check(const policy_table_t *table, const char *caller_id,
|
||||
const char *verb, const char *role_name, const char *purpose);
|
||||
|
||||
/* Parse prompt mode from string */
|
||||
prompt_mode_t prompt_mode_from_str(const char *s);
|
||||
|
||||
/* Prompt mode to string */
|
||||
const char *prompt_mode_to_str(prompt_mode_t m);
|
||||
|
||||
|
||||
/* from crypto.h */
|
||||
|
||||
|
||||
/* Per-role derived key material (stored in secure memory) */
|
||||
typedef struct {
|
||||
secure_buf_t private_key; /* 32 bytes, mlock'd */
|
||||
unsigned char public_key[32];
|
||||
char pubkey_hex[65]; /* 64 hex chars + null */
|
||||
char npub[128]; /* bech32 npub */
|
||||
int valid;
|
||||
} derived_key_t;
|
||||
|
||||
/* Key store — holds derived keys for all roles */
|
||||
typedef struct {
|
||||
derived_key_t keys[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} key_store_t;
|
||||
|
||||
/* Derive keys for all roles in the table using the loaded mnemonic.
|
||||
* Populates key_store and sets role->pubkey_hex and role->derived for each role.
|
||||
* Only derives for roles with purpose=nostr and curve=secp256k1 (for now).
|
||||
* Returns number of keys derived, or -1 on error. */
|
||||
int crypto_derive_all(key_store_t *store, role_table_t *table, const mnemonic_state_t *mnemonic);
|
||||
|
||||
/* Get the derived private key for a role (by table index). Returns NULL if not derived. */
|
||||
const unsigned char *crypto_get_private_key(const key_store_t *store, int role_index);
|
||||
|
||||
/* Get the derived public key hex for a role. Returns NULL if not derived. */
|
||||
const char *crypto_get_pubkey_hex(const key_store_t *store, int role_index);
|
||||
|
||||
/* Sign a Nostr event. event_json is the unsigned event JSON string.
|
||||
* Returns a newly-allocated string containing the signed event JSON, or NULL on error.
|
||||
* Caller must free() the returned string. */
|
||||
char *crypto_sign_event(const key_store_t *store, int role_index, const char *event_json);
|
||||
|
||||
/* Zeroize all derived keys in the store. */
|
||||
void crypto_wipe(key_store_t *store);
|
||||
|
||||
|
||||
/* from dispatcher.h */
|
||||
|
||||
|
||||
/* Dispatcher context — holds references to shared state */
|
||||
typedef struct {
|
||||
role_table_t *role_table;
|
||||
mnemonic_state_t *mnemonic;
|
||||
key_store_t *key_store;
|
||||
} dispatcher_ctx_t;
|
||||
|
||||
/* Initialize dispatcher context */
|
||||
void dispatcher_init(dispatcher_ctx_t *ctx, role_table_t *table, mnemonic_state_t *mnemonic, key_store_t *key_store);
|
||||
|
||||
/*
|
||||
* Process a JSON-RPC request string and produce a JSON-RPC response string.
|
||||
*
|
||||
* The caller owns the returned string and must free() it.
|
||||
* Returns NULL only on catastrophic allocation failure.
|
||||
*
|
||||
* Response format on success:
|
||||
* { "id": "...", "result": "..." }
|
||||
*
|
||||
* Response format on error:
|
||||
* { "id": "...", "error": { "code": <int>, "message": "..." } }
|
||||
*
|
||||
* Error codes:
|
||||
* -32700 Parse error (invalid JSON)
|
||||
* -32600 Invalid request (missing id/method/params)
|
||||
* -32601 Method not found (unknown verb after enforcement)
|
||||
* -32602 Invalid params
|
||||
* 1001 ambiguous_role_selector
|
||||
* 1002 role_not_found
|
||||
* 1003 no_default_role
|
||||
* 1004 purpose_mismatch
|
||||
* 1005 curve_mismatch
|
||||
* 1006 mnemonic_not_loaded
|
||||
*/
|
||||
char *dispatcher_handle_request(dispatcher_ctx_t *ctx, const char *json_request);
|
||||
|
||||
|
||||
/* from server.h */
|
||||
|
||||
|
||||
#define SERVER_SOCKET_NAME_MAX 108
|
||||
#define SERVER_MAX_MSG_SIZE 65536
|
||||
|
||||
/* Caller identity */
|
||||
typedef struct {
|
||||
uid_t uid;
|
||||
gid_t gid;
|
||||
pid_t pid;
|
||||
char caller_id[64]; /* "uid:<n>" */
|
||||
} caller_identity_t;
|
||||
|
||||
/* Server context */
|
||||
typedef struct {
|
||||
char socket_name[SERVER_SOCKET_NAME_MAX]; /* abstract namespace name (without \0 prefix) */
|
||||
char last_error[256];
|
||||
int listen_fd;
|
||||
int running;
|
||||
dispatcher_ctx_t *dispatcher;
|
||||
policy_table_t *policy;
|
||||
int socket_name_explicit;
|
||||
} server_ctx_t;
|
||||
|
||||
/* Initialize server context. socket_name is the abstract namespace name (e.g. "nsigner").
|
||||
* socket_name_explicit should be non-zero when provided via --socket-name override. */
|
||||
void server_init(server_ctx_t *ctx, const char *socket_name, int socket_name_explicit,
|
||||
dispatcher_ctx_t *dispatcher, policy_table_t *policy);
|
||||
|
||||
/* Start listening. Returns 0 on success, -1 on error. */
|
||||
int server_start(server_ctx_t *ctx);
|
||||
|
||||
/* Get human-readable description of last server error. */
|
||||
const char *server_last_error(const server_ctx_t *ctx);
|
||||
|
||||
/* Handle one pending connection (non-blocking). Returns 1 if handled, 0 if nothing pending, -1 on error.
|
||||
* activity_cb is called with a description string for the TUI activity log. */
|
||||
typedef void (*server_activity_cb)(const char *message, void *user_data);
|
||||
int server_handle_one(server_ctx_t *ctx, server_activity_cb cb, void *cb_data);
|
||||
|
||||
/* Stop server and close socket */
|
||||
void server_stop(server_ctx_t *ctx);
|
||||
|
||||
/* Extract caller identity from connected fd */
|
||||
int server_get_caller(int fd, caller_identity_t *out);
|
||||
|
||||
|
||||
/* from socket_name.h */
|
||||
|
||||
|
||||
/*
|
||||
* Generate random socket name in format: nsigner_<word1>_<word2>
|
||||
* Returns 0 on success, -1 on error.
|
||||
*/
|
||||
int socket_name_random(char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from main.h */
|
||||
/*
|
||||
* nsigner main header - version information
|
||||
*
|
||||
* Version macros are auto-updated by increment_and_push.sh.
|
||||
*/
|
||||
|
||||
|
||||
/* Version information (auto-updated by build/version tooling) */
|
||||
#define NSIGNER_VERSION_MAJOR 0
|
||||
#define NSIGNER_VERSION_MINOR 0
|
||||
#define NSIGNER_VERSION_PATCH 2
|
||||
#define NSIGNER_VERSION "v0.0.2"
|
||||
|
||||
|
||||
/* NSIGNER_HEADERLESS_DECLS_END */
|
||||
|
||||
#include <nostr_core/nostr_common.h>
|
||||
#include <nostr_core/nip001.h>
|
||||
#include <nostr_core/nip006.h>
|
||||
#include <nostr_core/nip019.h>
|
||||
#include <nostr_core/utils.h>
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
|
||||
#define NSIGNER_ENCRYPT_OUTPUT_MAX 65536
|
||||
|
||||
int crypto_derive_all(key_store_t *store, role_table_t *table, const mnemonic_state_t *mnemonic) {
|
||||
int i;
|
||||
int derived_count;
|
||||
|
||||
if (store == NULL || table == NULL || mnemonic == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (!mnemonic_is_loaded(mnemonic)) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
crypto_wipe(store);
|
||||
derived_count = 0;
|
||||
|
||||
for (i = 0; i < table->count; ++i) {
|
||||
role_entry_t *role = &table->entries[i];
|
||||
unsigned char priv[32];
|
||||
unsigned char pub[32];
|
||||
derived_key_t *dst = &store->keys[i];
|
||||
|
||||
role->derived = 0;
|
||||
role->pubkey_hex[0] = '\0';
|
||||
|
||||
if (role->purpose != PURPOSE_NOSTR ||
|
||||
role->curve != CURVE_SECP256K1 ||
|
||||
role->selector_type != SELECTOR_NOSTR_INDEX) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (secure_buf_alloc(&dst->private_key, 32) != 0) {
|
||||
crypto_wipe(store);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (nostr_derive_keys_from_mnemonic(mnemonic_get_phrase(mnemonic), role->nostr_index, priv, pub) != 0) {
|
||||
secure_memzero(priv, sizeof(priv));
|
||||
secure_memzero(pub, sizeof(pub));
|
||||
crypto_wipe(store);
|
||||
return -1;
|
||||
}
|
||||
|
||||
memcpy(dst->private_key.data, priv, 32);
|
||||
memcpy(dst->public_key, pub, 32);
|
||||
|
||||
nostr_bytes_to_hex(pub, 32, dst->pubkey_hex);
|
||||
dst->npub[0] = '\0';
|
||||
(void)nostr_key_to_bech32(pub, "npub", dst->npub);
|
||||
|
||||
strncpy(role->pubkey_hex, dst->pubkey_hex, sizeof(role->pubkey_hex) - 1);
|
||||
role->pubkey_hex[sizeof(role->pubkey_hex) - 1] = '\0';
|
||||
role->derived = 1;
|
||||
|
||||
dst->valid = 1;
|
||||
derived_count++;
|
||||
|
||||
secure_memzero(priv, sizeof(priv));
|
||||
secure_memzero(pub, sizeof(pub));
|
||||
}
|
||||
|
||||
store->count = table->count;
|
||||
return derived_count;
|
||||
}
|
||||
|
||||
const unsigned char *crypto_get_private_key(const key_store_t *store, int role_index) {
|
||||
if (store == NULL || role_index < 0 || role_index >= ROLE_TABLE_MAX_ENTRIES) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (!store->keys[role_index].valid || store->keys[role_index].private_key.data == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return (const unsigned char *)store->keys[role_index].private_key.data;
|
||||
}
|
||||
|
||||
const char *crypto_get_pubkey_hex(const key_store_t *store, int role_index) {
|
||||
if (store == NULL || role_index < 0 || role_index >= ROLE_TABLE_MAX_ENTRIES) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (!store->keys[role_index].valid) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return store->keys[role_index].pubkey_hex;
|
||||
}
|
||||
|
||||
char *crypto_sign_event(const key_store_t *store, int role_index, const char *event_json) {
|
||||
const unsigned char *private_key;
|
||||
cJSON *parsed = NULL;
|
||||
cJSON *kind_item;
|
||||
cJSON *content_item;
|
||||
cJSON *tags_item;
|
||||
cJSON *created_at_item;
|
||||
cJSON *tags_for_sign = NULL;
|
||||
int kind;
|
||||
const char *content;
|
||||
time_t timestamp = 0;
|
||||
cJSON *signed_event = NULL;
|
||||
char *out = NULL;
|
||||
|
||||
if (event_json == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
private_key = crypto_get_private_key(store, role_index);
|
||||
if (private_key == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
parsed = cJSON_Parse(event_json);
|
||||
if (parsed == NULL || !cJSON_IsObject(parsed)) {
|
||||
cJSON_Delete(parsed);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
kind_item = cJSON_GetObjectItemCaseSensitive(parsed, "kind");
|
||||
content_item = cJSON_GetObjectItemCaseSensitive(parsed, "content");
|
||||
tags_item = cJSON_GetObjectItemCaseSensitive(parsed, "tags");
|
||||
created_at_item = cJSON_GetObjectItemCaseSensitive(parsed, "created_at");
|
||||
|
||||
if (!cJSON_IsNumber(kind_item) || !cJSON_IsString(content_item) || content_item->valuestring == NULL) {
|
||||
cJSON_Delete(parsed);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
kind = kind_item->valueint;
|
||||
content = content_item->valuestring;
|
||||
|
||||
if (cJSON_IsNumber(created_at_item)) {
|
||||
timestamp = (time_t)created_at_item->valuedouble;
|
||||
}
|
||||
|
||||
if (cJSON_IsArray(tags_item)) {
|
||||
tags_for_sign = cJSON_Duplicate(tags_item, 1);
|
||||
if (tags_for_sign == NULL) {
|
||||
cJSON_Delete(parsed);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
signed_event = nostr_create_and_sign_event(kind, content, tags_for_sign, private_key, timestamp);
|
||||
cJSON_Delete(tags_for_sign);
|
||||
cJSON_Delete(parsed);
|
||||
|
||||
if (signed_event == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
out = cJSON_PrintUnformatted(signed_event);
|
||||
cJSON_Delete(signed_event);
|
||||
return out;
|
||||
}
|
||||
|
||||
void crypto_wipe(key_store_t *store) {
|
||||
int i;
|
||||
|
||||
if (store == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
for (i = 0; i < ROLE_TABLE_MAX_ENTRIES; ++i) {
|
||||
secure_buf_free(&store->keys[i].private_key);
|
||||
secure_memzero(store->keys[i].public_key, sizeof(store->keys[i].public_key));
|
||||
secure_memzero(store->keys[i].pubkey_hex, sizeof(store->keys[i].pubkey_hex));
|
||||
secure_memzero(store->keys[i].npub, sizeof(store->keys[i].npub));
|
||||
store->keys[i].valid = 0;
|
||||
}
|
||||
|
||||
store->count = 0;
|
||||
}
|
||||
461
src/main.c
461
src/main.c
@@ -1,13 +1,448 @@
|
||||
#define _GNU_SOURCE
|
||||
#include "main.h"
|
||||
|
||||
#include "dispatcher.h"
|
||||
#include "mnemonic.h"
|
||||
#include "policy.h"
|
||||
#include "role_table.h"
|
||||
#include "server.h"
|
||||
#include "crypto.h"
|
||||
#include "socket_name.h"
|
||||
/* NSIGNER_HEADERLESS_DECLS_BEGIN */
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
#include <cJSON.h>
|
||||
|
||||
/* from secure_mem.h */
|
||||
|
||||
|
||||
/*
|
||||
* Secure memory buffer — mlock'd, zeroized on free.
|
||||
* Used for mnemonic phrases, private keys, and any sensitive material.
|
||||
*/
|
||||
typedef struct {
|
||||
void *data; /* pointer to locked allocation */
|
||||
size_t size; /* usable size in bytes */
|
||||
int locked; /* 1 if mlock succeeded */
|
||||
} secure_buf_t;
|
||||
|
||||
/* Allocate a secure buffer of `size` bytes. Returns 0 on success, -1 on failure. */
|
||||
int secure_buf_alloc(secure_buf_t *buf, size_t size);
|
||||
|
||||
/* Zeroize and free a secure buffer. Always succeeds (idempotent). */
|
||||
void secure_buf_free(secure_buf_t *buf);
|
||||
|
||||
/* Zeroize `len` bytes at `ptr` in a way the compiler cannot optimize away. */
|
||||
void secure_memzero(void *ptr, size_t len);
|
||||
|
||||
|
||||
/* from mnemonic.h */
|
||||
|
||||
|
||||
/* Maximum mnemonic length: 24 words * 10 chars avg + spaces + null = 256 is safe */
|
||||
#define MNEMONIC_MAX_LEN 256
|
||||
|
||||
/*
|
||||
* Mnemonic state — holds the loaded mnemonic in secure memory.
|
||||
* Only one mnemonic is active at a time per process.
|
||||
*/
|
||||
typedef struct {
|
||||
secure_buf_t buf; /* secure storage for the mnemonic string */
|
||||
int loaded; /* 1 if a mnemonic is currently loaded */
|
||||
int word_count; /* 12, 15, 18, 21, or 24 */
|
||||
} mnemonic_state_t;
|
||||
|
||||
/* Initialize mnemonic state (must be called before use). */
|
||||
void mnemonic_init(mnemonic_state_t *state);
|
||||
|
||||
/* Load a mnemonic string into secure memory. Validates word count (12/15/18/21/24).
|
||||
* Returns 0 on success, -1 on invalid input, -2 on memory error. */
|
||||
int mnemonic_load(mnemonic_state_t *state, const char *phrase);
|
||||
|
||||
/* Zeroize and unload the mnemonic. Idempotent. */
|
||||
void mnemonic_unload(mnemonic_state_t *state);
|
||||
|
||||
/* Check if a mnemonic is currently loaded. */
|
||||
int mnemonic_is_loaded(const mnemonic_state_t *state);
|
||||
|
||||
/* Get the mnemonic string (only valid while loaded). Returns NULL if not loaded. */
|
||||
const char *mnemonic_get_phrase(const mnemonic_state_t *state);
|
||||
|
||||
/* Generate a new BIP-39 mnemonic phrase (12/15/18/21/24 words) into out.
|
||||
* Returns 0 on success, -1 on invalid arguments or generation failure. */
|
||||
int mnemonic_generate(int word_count, char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from role_table.h */
|
||||
|
||||
|
||||
/* Maximum limits */
|
||||
#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 /* 64 hex chars + null + pad */
|
||||
#define ROLE_TABLE_MAX_ENTRIES 64
|
||||
|
||||
/* Purpose enum for fast comparison (string form kept for config/display) */
|
||||
typedef enum {
|
||||
PURPOSE_NOSTR = 0,
|
||||
PURPOSE_BITCOIN,
|
||||
PURPOSE_SSH,
|
||||
PURPOSE_AGE,
|
||||
PURPOSE_FIPS,
|
||||
PURPOSE_UNKNOWN
|
||||
} role_purpose_t;
|
||||
|
||||
/* Curve enum */
|
||||
typedef enum {
|
||||
CURVE_SECP256K1 = 0,
|
||||
CURVE_ED25519,
|
||||
CURVE_X25519,
|
||||
CURVE_UNKNOWN
|
||||
} role_curve_t;
|
||||
|
||||
/* Selector type — how this role's key is addressed */
|
||||
typedef enum {
|
||||
SELECTOR_NOSTR_INDEX, /* uses nostr_index shorthand */
|
||||
SELECTOR_ROLE_PATH /* uses explicit full path */
|
||||
} role_selector_type_t;
|
||||
|
||||
/* A single role entry */
|
||||
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; /* valid if selector_type == SELECTOR_NOSTR_INDEX */
|
||||
char role_path[ROLE_PATH_MAX]; /* valid if selector_type == SELECTOR_ROLE_PATH */
|
||||
char pubkey_hex[ROLE_PUBKEY_HEX_MAX]; /* filled after derivation, empty until then */
|
||||
int derived; /* 1 if pubkey_hex has been populated */
|
||||
} role_entry_t;
|
||||
|
||||
/* The role table */
|
||||
typedef struct {
|
||||
role_entry_t entries[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} role_table_t;
|
||||
|
||||
/* Initialize an empty role table */
|
||||
void role_table_init(role_table_t *table);
|
||||
|
||||
/* Add a role entry. Returns 0 on success, -1 if table full, -2 if name duplicate. */
|
||||
int role_table_add(role_table_t *table, const role_entry_t *entry);
|
||||
|
||||
/* Find a role by name. Returns pointer to entry or NULL. */
|
||||
role_entry_t *role_table_find_by_name(role_table_t *table, const char *name);
|
||||
|
||||
/* Find a role by nostr_index. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_nostr_index(role_table_t *table, int index);
|
||||
|
||||
/* Find a role by role_path. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_path(role_table_t *table, const char *path);
|
||||
|
||||
/* Get the default role (named "main"). Returns pointer or NULL if no "main" role. */
|
||||
role_entry_t *role_table_get_default(role_table_t *table);
|
||||
|
||||
/* Parse purpose string to enum */
|
||||
role_purpose_t role_purpose_from_str(const char *s);
|
||||
|
||||
/* Parse curve string to enum */
|
||||
role_curve_t role_curve_from_str(const char *s);
|
||||
|
||||
/* Purpose enum to string */
|
||||
const char *role_purpose_to_str(role_purpose_t p);
|
||||
|
||||
/* Curve enum to string */
|
||||
const char *role_curve_to_str(role_curve_t c);
|
||||
|
||||
|
||||
/* from selector.h */
|
||||
|
||||
|
||||
/* Error codes for selector resolution */
|
||||
#define SELECTOR_OK 0
|
||||
#define SELECTOR_ERR_AMBIGUOUS -1 /* multiple selectors specified */
|
||||
#define SELECTOR_ERR_NOT_FOUND -2 /* no matching role in table */
|
||||
#define SELECTOR_ERR_NO_DEFAULT -3 /* no selector given and no "main" role exists */
|
||||
|
||||
/* Parsed selector from a request's options object */
|
||||
typedef struct {
|
||||
int has_role; /* 1 if "role" field was present */
|
||||
char role_name[ROLE_NAME_MAX];
|
||||
|
||||
int has_nostr_index; /* 1 if "nostr_index" field was present */
|
||||
int nostr_index;
|
||||
|
||||
int has_role_path; /* 1 if "role_path" field was present */
|
||||
char role_path[ROLE_PATH_MAX];
|
||||
} selector_request_t;
|
||||
|
||||
/* Initialize a selector request (all fields zeroed/unset) */
|
||||
void selector_request_init(selector_request_t *req);
|
||||
|
||||
/*
|
||||
* Resolve a selector request against the role table.
|
||||
* On success (returns SELECTOR_OK), *out points to the matched role_entry_t.
|
||||
* On failure, returns one of the SELECTOR_ERR_* codes and *out is NULL.
|
||||
*/
|
||||
int selector_resolve(const selector_request_t *req, role_table_t *table, role_entry_t **out);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for a selector error code.
|
||||
*/
|
||||
const char *selector_strerror(int err);
|
||||
|
||||
|
||||
/* from enforcement.h */
|
||||
|
||||
|
||||
/* Error codes */
|
||||
#define ENFORCE_OK 0
|
||||
#define ENFORCE_ERR_PURPOSE -1 /* purpose mismatch */
|
||||
#define ENFORCE_ERR_CURVE -2 /* curve mismatch */
|
||||
#define ENFORCE_ERR_UNKNOWN_VERB -3 /* verb not recognized */
|
||||
|
||||
/* Known verbs */
|
||||
#define VERB_SIGN_EVENT "sign_event"
|
||||
#define VERB_GET_PUBLIC_KEY "get_public_key"
|
||||
#define VERB_NIP44_ENCRYPT "nip44_encrypt"
|
||||
#define VERB_NIP44_DECRYPT "nip44_decrypt"
|
||||
#define VERB_NIP04_ENCRYPT "nip04_encrypt"
|
||||
#define VERB_NIP04_DECRYPT "nip04_decrypt"
|
||||
|
||||
/*
|
||||
* Check whether `verb` is allowed to execute against `role`.
|
||||
* Returns ENFORCE_OK if allowed, or an ENFORCE_ERR_* code.
|
||||
*
|
||||
* The enforcement rules are:
|
||||
* - All nostr verbs (sign_event, get_public_key, nip44_*, nip04_*) require:
|
||||
* purpose == PURPOSE_NOSTR and curve == CURVE_SECP256K1
|
||||
* - Unknown verbs return ENFORCE_ERR_UNKNOWN_VERB (fail-closed).
|
||||
*/
|
||||
int enforce_verb_role(const char *verb, const role_entry_t *role);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for an enforcement error code.
|
||||
*/
|
||||
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 64
|
||||
|
||||
/* Prompt behavior */
|
||||
typedef enum {
|
||||
PROMPT_NEVER = 0,
|
||||
PROMPT_FIRST_PER_BOOT,
|
||||
PROMPT_EVERY_REQUEST,
|
||||
PROMPT_DENY
|
||||
} prompt_mode_t;
|
||||
|
||||
/* A single policy entry */
|
||||
typedef struct {
|
||||
char caller[POLICY_CALLER_MAX_LEN]; /* e.g. "uid:1000" or "*" for any */
|
||||
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;
|
||||
prompt_mode_t prompt;
|
||||
} policy_entry_t;
|
||||
|
||||
/* Policy table */
|
||||
typedef struct {
|
||||
policy_entry_t entries[POLICY_MAX_ENTRIES];
|
||||
int count;
|
||||
} policy_table_t;
|
||||
|
||||
/* Policy check result */
|
||||
#define POLICY_ALLOW 0
|
||||
#define POLICY_DENY -1
|
||||
#define POLICY_PROMPT -2 /* would need user confirmation */
|
||||
#define POLICY_NO_MATCH -3 /* no policy entry matched (fail-closed = deny) */
|
||||
|
||||
/* Initialize policy table */
|
||||
void policy_table_init(policy_table_t *table);
|
||||
|
||||
/* Initialize default policy: allow same-uid, deny others */
|
||||
void policy_init_default(policy_table_t *table, uid_t owner_uid);
|
||||
|
||||
/* Add a policy entry. Returns 0 on success, -1 if full. */
|
||||
int policy_table_add(policy_table_t *table, const policy_entry_t *entry);
|
||||
|
||||
/*
|
||||
* Check whether caller_id is allowed to invoke `verb` on `role_name` with given `purpose`.
|
||||
* Returns POLICY_ALLOW, POLICY_DENY, POLICY_PROMPT, or POLICY_NO_MATCH.
|
||||
*/
|
||||
int policy_check(const policy_table_t *table, const char *caller_id,
|
||||
const char *verb, const char *role_name, const char *purpose);
|
||||
|
||||
/* Parse prompt mode from string */
|
||||
prompt_mode_t prompt_mode_from_str(const char *s);
|
||||
|
||||
/* Prompt mode to string */
|
||||
const char *prompt_mode_to_str(prompt_mode_t m);
|
||||
|
||||
|
||||
/* from crypto.h */
|
||||
|
||||
|
||||
/* Per-role derived key material (stored in secure memory) */
|
||||
typedef struct {
|
||||
secure_buf_t private_key; /* 32 bytes, mlock'd */
|
||||
unsigned char public_key[32];
|
||||
char pubkey_hex[65]; /* 64 hex chars + null */
|
||||
char npub[128]; /* bech32 npub */
|
||||
int valid;
|
||||
} derived_key_t;
|
||||
|
||||
/* Key store — holds derived keys for all roles */
|
||||
typedef struct {
|
||||
derived_key_t keys[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} key_store_t;
|
||||
|
||||
/* Derive keys for all roles in the table using the loaded mnemonic.
|
||||
* Populates key_store and sets role->pubkey_hex and role->derived for each role.
|
||||
* Only derives for roles with purpose=nostr and curve=secp256k1 (for now).
|
||||
* Returns number of keys derived, or -1 on error. */
|
||||
int crypto_derive_all(key_store_t *store, role_table_t *table, const mnemonic_state_t *mnemonic);
|
||||
|
||||
/* Get the derived private key for a role (by table index). Returns NULL if not derived. */
|
||||
const unsigned char *crypto_get_private_key(const key_store_t *store, int role_index);
|
||||
|
||||
/* Get the derived public key hex for a role. Returns NULL if not derived. */
|
||||
const char *crypto_get_pubkey_hex(const key_store_t *store, int role_index);
|
||||
|
||||
/* Sign a Nostr event. event_json is the unsigned event JSON string.
|
||||
* Returns a newly-allocated string containing the signed event JSON, or NULL on error.
|
||||
* Caller must free() the returned string. */
|
||||
char *crypto_sign_event(const key_store_t *store, int role_index, const char *event_json);
|
||||
|
||||
/* Zeroize all derived keys in the store. */
|
||||
void crypto_wipe(key_store_t *store);
|
||||
|
||||
|
||||
/* from dispatcher.h */
|
||||
|
||||
|
||||
/* Dispatcher context — holds references to shared state */
|
||||
typedef struct {
|
||||
role_table_t *role_table;
|
||||
mnemonic_state_t *mnemonic;
|
||||
key_store_t *key_store;
|
||||
} dispatcher_ctx_t;
|
||||
|
||||
/* Initialize dispatcher context */
|
||||
void dispatcher_init(dispatcher_ctx_t *ctx, role_table_t *table, mnemonic_state_t *mnemonic, key_store_t *key_store);
|
||||
|
||||
/*
|
||||
* Process a JSON-RPC request string and produce a JSON-RPC response string.
|
||||
*
|
||||
* The caller owns the returned string and must free() it.
|
||||
* Returns NULL only on catastrophic allocation failure.
|
||||
*
|
||||
* Response format on success:
|
||||
* { "id": "...", "result": "..." }
|
||||
*
|
||||
* Response format on error:
|
||||
* { "id": "...", "error": { "code": <int>, "message": "..." } }
|
||||
*
|
||||
* Error codes:
|
||||
* -32700 Parse error (invalid JSON)
|
||||
* -32600 Invalid request (missing id/method/params)
|
||||
* -32601 Method not found (unknown verb after enforcement)
|
||||
* -32602 Invalid params
|
||||
* 1001 ambiguous_role_selector
|
||||
* 1002 role_not_found
|
||||
* 1003 no_default_role
|
||||
* 1004 purpose_mismatch
|
||||
* 1005 curve_mismatch
|
||||
* 1006 mnemonic_not_loaded
|
||||
*/
|
||||
char *dispatcher_handle_request(dispatcher_ctx_t *ctx, const char *json_request);
|
||||
|
||||
|
||||
/* from server.h */
|
||||
|
||||
|
||||
#define SERVER_SOCKET_NAME_MAX 108
|
||||
#define SERVER_MAX_MSG_SIZE 65536
|
||||
|
||||
/* Caller identity */
|
||||
typedef struct {
|
||||
uid_t uid;
|
||||
gid_t gid;
|
||||
pid_t pid;
|
||||
char caller_id[64]; /* "uid:<n>" */
|
||||
} caller_identity_t;
|
||||
|
||||
/* Server context */
|
||||
typedef struct {
|
||||
char socket_name[SERVER_SOCKET_NAME_MAX]; /* abstract namespace name (without \0 prefix) */
|
||||
char last_error[256];
|
||||
int listen_fd;
|
||||
int running;
|
||||
dispatcher_ctx_t *dispatcher;
|
||||
policy_table_t *policy;
|
||||
int socket_name_explicit;
|
||||
} server_ctx_t;
|
||||
|
||||
/* Initialize server context. socket_name is the abstract namespace name (e.g. "nsigner").
|
||||
* socket_name_explicit should be non-zero when provided via --socket-name override. */
|
||||
void server_init(server_ctx_t *ctx, const char *socket_name, int socket_name_explicit,
|
||||
dispatcher_ctx_t *dispatcher, policy_table_t *policy);
|
||||
|
||||
/* Start listening. Returns 0 on success, -1 on error. */
|
||||
int server_start(server_ctx_t *ctx);
|
||||
|
||||
/* Get human-readable description of last server error. */
|
||||
const char *server_last_error(const server_ctx_t *ctx);
|
||||
|
||||
/* Handle one pending connection (non-blocking). Returns 1 if handled, 0 if nothing pending, -1 on error.
|
||||
* activity_cb is called with a description string for the TUI activity log. */
|
||||
typedef void (*server_activity_cb)(const char *message, void *user_data);
|
||||
int server_handle_one(server_ctx_t *ctx, server_activity_cb cb, void *cb_data);
|
||||
|
||||
/* Stop server and close socket */
|
||||
void server_stop(server_ctx_t *ctx);
|
||||
|
||||
/* Extract caller identity from connected fd */
|
||||
int server_get_caller(int fd, caller_identity_t *out);
|
||||
|
||||
|
||||
/* from socket_name.h */
|
||||
|
||||
|
||||
/*
|
||||
* Generate random socket name in format: nsigner_<word1>_<word2>
|
||||
* Returns 0 on success, -1 on error.
|
||||
*/
|
||||
int socket_name_random(char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from main.h */
|
||||
/*
|
||||
* nsigner main header - version information
|
||||
*
|
||||
* Version macros are auto-updated by increment_and_push.sh.
|
||||
*/
|
||||
|
||||
|
||||
/* Version information (auto-updated by build/version tooling) */
|
||||
#define NSIGNER_VERSION_MAJOR 0
|
||||
#define NSIGNER_VERSION_MINOR 0
|
||||
#define NSIGNER_VERSION_PATCH 3
|
||||
#define NSIGNER_VERSION "v0.0.3"
|
||||
|
||||
|
||||
/* NSIGNER_HEADERLESS_DECLS_END */
|
||||
|
||||
#include <nostr_core/nostr_common.h>
|
||||
|
||||
#include <arpa/inet.h>
|
||||
#include <errno.h>
|
||||
@@ -503,7 +938,7 @@ int main(int argc, char *argv[]) {
|
||||
|
||||
memset(&key_store, 0, sizeof(key_store));
|
||||
|
||||
if (crypto_init() != 0) {
|
||||
if (nostr_init() != 0) {
|
||||
fprintf(stderr, "Failed to initialize crypto subsystem\n");
|
||||
mnemonic_unload(&mnemonic);
|
||||
return 1;
|
||||
@@ -512,7 +947,7 @@ int main(int argc, char *argv[]) {
|
||||
derived_count = crypto_derive_all(&key_store, &role_table, &mnemonic);
|
||||
if (derived_count < 0) {
|
||||
fprintf(stderr, "Failed to derive keys from mnemonic\n");
|
||||
crypto_cleanup();
|
||||
nostr_cleanup();
|
||||
mnemonic_unload(&mnemonic);
|
||||
return 1;
|
||||
}
|
||||
@@ -526,7 +961,7 @@ int main(int argc, char *argv[]) {
|
||||
if (socket_name_random(generated_socket_name, sizeof(generated_socket_name)) != 0) {
|
||||
fprintf(stderr, "Failed to generate random socket name\n");
|
||||
crypto_wipe(&key_store);
|
||||
crypto_cleanup();
|
||||
nostr_cleanup();
|
||||
mnemonic_unload(&mnemonic);
|
||||
return 1;
|
||||
}
|
||||
@@ -537,7 +972,7 @@ int main(int argc, char *argv[]) {
|
||||
if (server_start(&server) != 0) {
|
||||
fprintf(stderr, "Failed to start server on @%s: %s\n", socket_name, server_last_error(&server));
|
||||
crypto_wipe(&key_store);
|
||||
crypto_cleanup();
|
||||
nostr_cleanup();
|
||||
mnemonic_unload(&mnemonic);
|
||||
return 1;
|
||||
}
|
||||
@@ -580,7 +1015,7 @@ int main(int argc, char *argv[]) {
|
||||
|
||||
server_stop(&server);
|
||||
crypto_wipe(&key_store);
|
||||
crypto_cleanup();
|
||||
nostr_cleanup();
|
||||
mnemonic_unload(&mnemonic);
|
||||
printf("Shutdown. All secrets wiped.\n");
|
||||
return 0;
|
||||
|
||||
16
src/main.h
16
src/main.h
@@ -1,16 +0,0 @@
|
||||
/*
|
||||
* nsigner main header - version information
|
||||
*
|
||||
* Version macros are auto-updated by increment_and_push.sh.
|
||||
*/
|
||||
|
||||
#ifndef NSIGNER_MAIN_H
|
||||
#define NSIGNER_MAIN_H
|
||||
|
||||
/* Version information (auto-updated by build/version tooling) */
|
||||
#define NSIGNER_VERSION_MAJOR 0
|
||||
#define NSIGNER_VERSION_MINOR 0
|
||||
#define NSIGNER_VERSION_PATCH 2
|
||||
#define NSIGNER_VERSION "v0.0.2"
|
||||
|
||||
#endif /* NSIGNER_MAIN_H */
|
||||
442
src/mnemonic.c
442
src/mnemonic.c
@@ -1,4 +1,444 @@
|
||||
#include "mnemonic.h"
|
||||
/* NSIGNER_HEADERLESS_DECLS_BEGIN */
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
#include <cJSON.h>
|
||||
|
||||
/* from secure_mem.h */
|
||||
|
||||
|
||||
/*
|
||||
* Secure memory buffer — mlock'd, zeroized on free.
|
||||
* Used for mnemonic phrases, private keys, and any sensitive material.
|
||||
*/
|
||||
typedef struct {
|
||||
void *data; /* pointer to locked allocation */
|
||||
size_t size; /* usable size in bytes */
|
||||
int locked; /* 1 if mlock succeeded */
|
||||
} secure_buf_t;
|
||||
|
||||
/* Allocate a secure buffer of `size` bytes. Returns 0 on success, -1 on failure. */
|
||||
int secure_buf_alloc(secure_buf_t *buf, size_t size);
|
||||
|
||||
/* Zeroize and free a secure buffer. Always succeeds (idempotent). */
|
||||
void secure_buf_free(secure_buf_t *buf);
|
||||
|
||||
/* Zeroize `len` bytes at `ptr` in a way the compiler cannot optimize away. */
|
||||
void secure_memzero(void *ptr, size_t len);
|
||||
|
||||
|
||||
/* from mnemonic.h */
|
||||
|
||||
|
||||
/* Maximum mnemonic length: 24 words * 10 chars avg + spaces + null = 256 is safe */
|
||||
#define MNEMONIC_MAX_LEN 256
|
||||
|
||||
/*
|
||||
* Mnemonic state — holds the loaded mnemonic in secure memory.
|
||||
* Only one mnemonic is active at a time per process.
|
||||
*/
|
||||
typedef struct {
|
||||
secure_buf_t buf; /* secure storage for the mnemonic string */
|
||||
int loaded; /* 1 if a mnemonic is currently loaded */
|
||||
int word_count; /* 12, 15, 18, 21, or 24 */
|
||||
} mnemonic_state_t;
|
||||
|
||||
/* Initialize mnemonic state (must be called before use). */
|
||||
void mnemonic_init(mnemonic_state_t *state);
|
||||
|
||||
/* Load a mnemonic string into secure memory. Validates word count (12/15/18/21/24).
|
||||
* Returns 0 on success, -1 on invalid input, -2 on memory error. */
|
||||
int mnemonic_load(mnemonic_state_t *state, const char *phrase);
|
||||
|
||||
/* Zeroize and unload the mnemonic. Idempotent. */
|
||||
void mnemonic_unload(mnemonic_state_t *state);
|
||||
|
||||
/* Check if a mnemonic is currently loaded. */
|
||||
int mnemonic_is_loaded(const mnemonic_state_t *state);
|
||||
|
||||
/* Get the mnemonic string (only valid while loaded). Returns NULL if not loaded. */
|
||||
const char *mnemonic_get_phrase(const mnemonic_state_t *state);
|
||||
|
||||
/* Generate a new BIP-39 mnemonic phrase (12/15/18/21/24 words) into out.
|
||||
* Returns 0 on success, -1 on invalid arguments or generation failure. */
|
||||
int mnemonic_generate(int word_count, char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from role_table.h */
|
||||
|
||||
|
||||
/* Maximum limits */
|
||||
#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 /* 64 hex chars + null + pad */
|
||||
#define ROLE_TABLE_MAX_ENTRIES 64
|
||||
|
||||
/* Purpose enum for fast comparison (string form kept for config/display) */
|
||||
typedef enum {
|
||||
PURPOSE_NOSTR = 0,
|
||||
PURPOSE_BITCOIN,
|
||||
PURPOSE_SSH,
|
||||
PURPOSE_AGE,
|
||||
PURPOSE_FIPS,
|
||||
PURPOSE_UNKNOWN
|
||||
} role_purpose_t;
|
||||
|
||||
/* Curve enum */
|
||||
typedef enum {
|
||||
CURVE_SECP256K1 = 0,
|
||||
CURVE_ED25519,
|
||||
CURVE_X25519,
|
||||
CURVE_UNKNOWN
|
||||
} role_curve_t;
|
||||
|
||||
/* Selector type — how this role's key is addressed */
|
||||
typedef enum {
|
||||
SELECTOR_NOSTR_INDEX, /* uses nostr_index shorthand */
|
||||
SELECTOR_ROLE_PATH /* uses explicit full path */
|
||||
} role_selector_type_t;
|
||||
|
||||
/* A single role entry */
|
||||
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; /* valid if selector_type == SELECTOR_NOSTR_INDEX */
|
||||
char role_path[ROLE_PATH_MAX]; /* valid if selector_type == SELECTOR_ROLE_PATH */
|
||||
char pubkey_hex[ROLE_PUBKEY_HEX_MAX]; /* filled after derivation, empty until then */
|
||||
int derived; /* 1 if pubkey_hex has been populated */
|
||||
} role_entry_t;
|
||||
|
||||
/* The role table */
|
||||
typedef struct {
|
||||
role_entry_t entries[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} role_table_t;
|
||||
|
||||
/* Initialize an empty role table */
|
||||
void role_table_init(role_table_t *table);
|
||||
|
||||
/* Add a role entry. Returns 0 on success, -1 if table full, -2 if name duplicate. */
|
||||
int role_table_add(role_table_t *table, const role_entry_t *entry);
|
||||
|
||||
/* Find a role by name. Returns pointer to entry or NULL. */
|
||||
role_entry_t *role_table_find_by_name(role_table_t *table, const char *name);
|
||||
|
||||
/* Find a role by nostr_index. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_nostr_index(role_table_t *table, int index);
|
||||
|
||||
/* Find a role by role_path. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_path(role_table_t *table, const char *path);
|
||||
|
||||
/* Get the default role (named "main"). Returns pointer or NULL if no "main" role. */
|
||||
role_entry_t *role_table_get_default(role_table_t *table);
|
||||
|
||||
/* Parse purpose string to enum */
|
||||
role_purpose_t role_purpose_from_str(const char *s);
|
||||
|
||||
/* Parse curve string to enum */
|
||||
role_curve_t role_curve_from_str(const char *s);
|
||||
|
||||
/* Purpose enum to string */
|
||||
const char *role_purpose_to_str(role_purpose_t p);
|
||||
|
||||
/* Curve enum to string */
|
||||
const char *role_curve_to_str(role_curve_t c);
|
||||
|
||||
|
||||
/* from selector.h */
|
||||
|
||||
|
||||
/* Error codes for selector resolution */
|
||||
#define SELECTOR_OK 0
|
||||
#define SELECTOR_ERR_AMBIGUOUS -1 /* multiple selectors specified */
|
||||
#define SELECTOR_ERR_NOT_FOUND -2 /* no matching role in table */
|
||||
#define SELECTOR_ERR_NO_DEFAULT -3 /* no selector given and no "main" role exists */
|
||||
|
||||
/* Parsed selector from a request's options object */
|
||||
typedef struct {
|
||||
int has_role; /* 1 if "role" field was present */
|
||||
char role_name[ROLE_NAME_MAX];
|
||||
|
||||
int has_nostr_index; /* 1 if "nostr_index" field was present */
|
||||
int nostr_index;
|
||||
|
||||
int has_role_path; /* 1 if "role_path" field was present */
|
||||
char role_path[ROLE_PATH_MAX];
|
||||
} selector_request_t;
|
||||
|
||||
/* Initialize a selector request (all fields zeroed/unset) */
|
||||
void selector_request_init(selector_request_t *req);
|
||||
|
||||
/*
|
||||
* Resolve a selector request against the role table.
|
||||
* On success (returns SELECTOR_OK), *out points to the matched role_entry_t.
|
||||
* On failure, returns one of the SELECTOR_ERR_* codes and *out is NULL.
|
||||
*/
|
||||
int selector_resolve(const selector_request_t *req, role_table_t *table, role_entry_t **out);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for a selector error code.
|
||||
*/
|
||||
const char *selector_strerror(int err);
|
||||
|
||||
|
||||
/* from enforcement.h */
|
||||
|
||||
|
||||
/* Error codes */
|
||||
#define ENFORCE_OK 0
|
||||
#define ENFORCE_ERR_PURPOSE -1 /* purpose mismatch */
|
||||
#define ENFORCE_ERR_CURVE -2 /* curve mismatch */
|
||||
#define ENFORCE_ERR_UNKNOWN_VERB -3 /* verb not recognized */
|
||||
|
||||
/* Known verbs */
|
||||
#define VERB_SIGN_EVENT "sign_event"
|
||||
#define VERB_GET_PUBLIC_KEY "get_public_key"
|
||||
#define VERB_NIP44_ENCRYPT "nip44_encrypt"
|
||||
#define VERB_NIP44_DECRYPT "nip44_decrypt"
|
||||
#define VERB_NIP04_ENCRYPT "nip04_encrypt"
|
||||
#define VERB_NIP04_DECRYPT "nip04_decrypt"
|
||||
|
||||
/*
|
||||
* Check whether `verb` is allowed to execute against `role`.
|
||||
* Returns ENFORCE_OK if allowed, or an ENFORCE_ERR_* code.
|
||||
*
|
||||
* The enforcement rules are:
|
||||
* - All nostr verbs (sign_event, get_public_key, nip44_*, nip04_*) require:
|
||||
* purpose == PURPOSE_NOSTR and curve == CURVE_SECP256K1
|
||||
* - Unknown verbs return ENFORCE_ERR_UNKNOWN_VERB (fail-closed).
|
||||
*/
|
||||
int enforce_verb_role(const char *verb, const role_entry_t *role);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for an enforcement error code.
|
||||
*/
|
||||
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 64
|
||||
|
||||
/* Prompt behavior */
|
||||
typedef enum {
|
||||
PROMPT_NEVER = 0,
|
||||
PROMPT_FIRST_PER_BOOT,
|
||||
PROMPT_EVERY_REQUEST,
|
||||
PROMPT_DENY
|
||||
} prompt_mode_t;
|
||||
|
||||
/* A single policy entry */
|
||||
typedef struct {
|
||||
char caller[POLICY_CALLER_MAX_LEN]; /* e.g. "uid:1000" or "*" for any */
|
||||
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;
|
||||
prompt_mode_t prompt;
|
||||
} policy_entry_t;
|
||||
|
||||
/* Policy table */
|
||||
typedef struct {
|
||||
policy_entry_t entries[POLICY_MAX_ENTRIES];
|
||||
int count;
|
||||
} policy_table_t;
|
||||
|
||||
/* Policy check result */
|
||||
#define POLICY_ALLOW 0
|
||||
#define POLICY_DENY -1
|
||||
#define POLICY_PROMPT -2 /* would need user confirmation */
|
||||
#define POLICY_NO_MATCH -3 /* no policy entry matched (fail-closed = deny) */
|
||||
|
||||
/* Initialize policy table */
|
||||
void policy_table_init(policy_table_t *table);
|
||||
|
||||
/* Initialize default policy: allow same-uid, deny others */
|
||||
void policy_init_default(policy_table_t *table, uid_t owner_uid);
|
||||
|
||||
/* Add a policy entry. Returns 0 on success, -1 if full. */
|
||||
int policy_table_add(policy_table_t *table, const policy_entry_t *entry);
|
||||
|
||||
/*
|
||||
* Check whether caller_id is allowed to invoke `verb` on `role_name` with given `purpose`.
|
||||
* Returns POLICY_ALLOW, POLICY_DENY, POLICY_PROMPT, or POLICY_NO_MATCH.
|
||||
*/
|
||||
int policy_check(const policy_table_t *table, const char *caller_id,
|
||||
const char *verb, const char *role_name, const char *purpose);
|
||||
|
||||
/* Parse prompt mode from string */
|
||||
prompt_mode_t prompt_mode_from_str(const char *s);
|
||||
|
||||
/* Prompt mode to string */
|
||||
const char *prompt_mode_to_str(prompt_mode_t m);
|
||||
|
||||
|
||||
/* from crypto.h */
|
||||
|
||||
|
||||
/* Per-role derived key material (stored in secure memory) */
|
||||
typedef struct {
|
||||
secure_buf_t private_key; /* 32 bytes, mlock'd */
|
||||
unsigned char public_key[32];
|
||||
char pubkey_hex[65]; /* 64 hex chars + null */
|
||||
char npub[128]; /* bech32 npub */
|
||||
int valid;
|
||||
} derived_key_t;
|
||||
|
||||
/* Key store — holds derived keys for all roles */
|
||||
typedef struct {
|
||||
derived_key_t keys[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} key_store_t;
|
||||
|
||||
/* Derive keys for all roles in the table using the loaded mnemonic.
|
||||
* Populates key_store and sets role->pubkey_hex and role->derived for each role.
|
||||
* Only derives for roles with purpose=nostr and curve=secp256k1 (for now).
|
||||
* Returns number of keys derived, or -1 on error. */
|
||||
int crypto_derive_all(key_store_t *store, role_table_t *table, const mnemonic_state_t *mnemonic);
|
||||
|
||||
/* Get the derived private key for a role (by table index). Returns NULL if not derived. */
|
||||
const unsigned char *crypto_get_private_key(const key_store_t *store, int role_index);
|
||||
|
||||
/* Get the derived public key hex for a role. Returns NULL if not derived. */
|
||||
const char *crypto_get_pubkey_hex(const key_store_t *store, int role_index);
|
||||
|
||||
/* Sign a Nostr event. event_json is the unsigned event JSON string.
|
||||
* Returns a newly-allocated string containing the signed event JSON, or NULL on error.
|
||||
* Caller must free() the returned string. */
|
||||
char *crypto_sign_event(const key_store_t *store, int role_index, const char *event_json);
|
||||
|
||||
/* Zeroize all derived keys in the store. */
|
||||
void crypto_wipe(key_store_t *store);
|
||||
|
||||
|
||||
/* from dispatcher.h */
|
||||
|
||||
|
||||
/* Dispatcher context — holds references to shared state */
|
||||
typedef struct {
|
||||
role_table_t *role_table;
|
||||
mnemonic_state_t *mnemonic;
|
||||
key_store_t *key_store;
|
||||
} dispatcher_ctx_t;
|
||||
|
||||
/* Initialize dispatcher context */
|
||||
void dispatcher_init(dispatcher_ctx_t *ctx, role_table_t *table, mnemonic_state_t *mnemonic, key_store_t *key_store);
|
||||
|
||||
/*
|
||||
* Process a JSON-RPC request string and produce a JSON-RPC response string.
|
||||
*
|
||||
* The caller owns the returned string and must free() it.
|
||||
* Returns NULL only on catastrophic allocation failure.
|
||||
*
|
||||
* Response format on success:
|
||||
* { "id": "...", "result": "..." }
|
||||
*
|
||||
* Response format on error:
|
||||
* { "id": "...", "error": { "code": <int>, "message": "..." } }
|
||||
*
|
||||
* Error codes:
|
||||
* -32700 Parse error (invalid JSON)
|
||||
* -32600 Invalid request (missing id/method/params)
|
||||
* -32601 Method not found (unknown verb after enforcement)
|
||||
* -32602 Invalid params
|
||||
* 1001 ambiguous_role_selector
|
||||
* 1002 role_not_found
|
||||
* 1003 no_default_role
|
||||
* 1004 purpose_mismatch
|
||||
* 1005 curve_mismatch
|
||||
* 1006 mnemonic_not_loaded
|
||||
*/
|
||||
char *dispatcher_handle_request(dispatcher_ctx_t *ctx, const char *json_request);
|
||||
|
||||
|
||||
/* from server.h */
|
||||
|
||||
|
||||
#define SERVER_SOCKET_NAME_MAX 108
|
||||
#define SERVER_MAX_MSG_SIZE 65536
|
||||
|
||||
/* Caller identity */
|
||||
typedef struct {
|
||||
uid_t uid;
|
||||
gid_t gid;
|
||||
pid_t pid;
|
||||
char caller_id[64]; /* "uid:<n>" */
|
||||
} caller_identity_t;
|
||||
|
||||
/* Server context */
|
||||
typedef struct {
|
||||
char socket_name[SERVER_SOCKET_NAME_MAX]; /* abstract namespace name (without \0 prefix) */
|
||||
char last_error[256];
|
||||
int listen_fd;
|
||||
int running;
|
||||
dispatcher_ctx_t *dispatcher;
|
||||
policy_table_t *policy;
|
||||
int socket_name_explicit;
|
||||
} server_ctx_t;
|
||||
|
||||
/* Initialize server context. socket_name is the abstract namespace name (e.g. "nsigner").
|
||||
* socket_name_explicit should be non-zero when provided via --socket-name override. */
|
||||
void server_init(server_ctx_t *ctx, const char *socket_name, int socket_name_explicit,
|
||||
dispatcher_ctx_t *dispatcher, policy_table_t *policy);
|
||||
|
||||
/* Start listening. Returns 0 on success, -1 on error. */
|
||||
int server_start(server_ctx_t *ctx);
|
||||
|
||||
/* Get human-readable description of last server error. */
|
||||
const char *server_last_error(const server_ctx_t *ctx);
|
||||
|
||||
/* Handle one pending connection (non-blocking). Returns 1 if handled, 0 if nothing pending, -1 on error.
|
||||
* activity_cb is called with a description string for the TUI activity log. */
|
||||
typedef void (*server_activity_cb)(const char *message, void *user_data);
|
||||
int server_handle_one(server_ctx_t *ctx, server_activity_cb cb, void *cb_data);
|
||||
|
||||
/* Stop server and close socket */
|
||||
void server_stop(server_ctx_t *ctx);
|
||||
|
||||
/* Extract caller identity from connected fd */
|
||||
int server_get_caller(int fd, caller_identity_t *out);
|
||||
|
||||
|
||||
/* from socket_name.h */
|
||||
|
||||
|
||||
/*
|
||||
* Generate random socket name in format: nsigner_<word1>_<word2>
|
||||
* Returns 0 on success, -1 on error.
|
||||
*/
|
||||
int socket_name_random(char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from main.h */
|
||||
/*
|
||||
* nsigner main header - version information
|
||||
*
|
||||
* Version macros are auto-updated by increment_and_push.sh.
|
||||
*/
|
||||
|
||||
|
||||
/* Version information (auto-updated by build/version tooling) */
|
||||
#define NSIGNER_VERSION_MAJOR 0
|
||||
#define NSIGNER_VERSION_MINOR 0
|
||||
#define NSIGNER_VERSION_PATCH 2
|
||||
#define NSIGNER_VERSION "v0.0.2"
|
||||
|
||||
|
||||
/* NSIGNER_HEADERLESS_DECLS_END */
|
||||
|
||||
#include <nostr_core/utils.h>
|
||||
|
||||
|
||||
@@ -1,39 +0,0 @@
|
||||
#ifndef NSIGNER_MNEMONIC_H
|
||||
#define NSIGNER_MNEMONIC_H
|
||||
|
||||
#include "secure_mem.h"
|
||||
|
||||
/* Maximum mnemonic length: 24 words * 10 chars avg + spaces + null = 256 is safe */
|
||||
#define MNEMONIC_MAX_LEN 256
|
||||
|
||||
/*
|
||||
* Mnemonic state — holds the loaded mnemonic in secure memory.
|
||||
* Only one mnemonic is active at a time per process.
|
||||
*/
|
||||
typedef struct {
|
||||
secure_buf_t buf; /* secure storage for the mnemonic string */
|
||||
int loaded; /* 1 if a mnemonic is currently loaded */
|
||||
int word_count; /* 12, 15, 18, 21, or 24 */
|
||||
} mnemonic_state_t;
|
||||
|
||||
/* Initialize mnemonic state (must be called before use). */
|
||||
void mnemonic_init(mnemonic_state_t *state);
|
||||
|
||||
/* Load a mnemonic string into secure memory. Validates word count (12/15/18/21/24).
|
||||
* Returns 0 on success, -1 on invalid input, -2 on memory error. */
|
||||
int mnemonic_load(mnemonic_state_t *state, const char *phrase);
|
||||
|
||||
/* Zeroize and unload the mnemonic. Idempotent. */
|
||||
void mnemonic_unload(mnemonic_state_t *state);
|
||||
|
||||
/* Check if a mnemonic is currently loaded. */
|
||||
int mnemonic_is_loaded(const mnemonic_state_t *state);
|
||||
|
||||
/* Get the mnemonic string (only valid while loaded). Returns NULL if not loaded. */
|
||||
const char *mnemonic_get_phrase(const mnemonic_state_t *state);
|
||||
|
||||
/* Generate a new BIP-39 mnemonic phrase (12/15/18/21/24 words) into out.
|
||||
* Returns 0 on success, -1 on invalid arguments or generation failure. */
|
||||
int mnemonic_generate(int word_count, char *out, size_t out_len);
|
||||
|
||||
#endif /* NSIGNER_MNEMONIC_H */
|
||||
442
src/policy.c
442
src/policy.c
@@ -1,4 +1,444 @@
|
||||
#include "policy.h"
|
||||
/* NSIGNER_HEADERLESS_DECLS_BEGIN */
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
#include <cJSON.h>
|
||||
|
||||
/* from secure_mem.h */
|
||||
|
||||
|
||||
/*
|
||||
* Secure memory buffer — mlock'd, zeroized on free.
|
||||
* Used for mnemonic phrases, private keys, and any sensitive material.
|
||||
*/
|
||||
typedef struct {
|
||||
void *data; /* pointer to locked allocation */
|
||||
size_t size; /* usable size in bytes */
|
||||
int locked; /* 1 if mlock succeeded */
|
||||
} secure_buf_t;
|
||||
|
||||
/* Allocate a secure buffer of `size` bytes. Returns 0 on success, -1 on failure. */
|
||||
int secure_buf_alloc(secure_buf_t *buf, size_t size);
|
||||
|
||||
/* Zeroize and free a secure buffer. Always succeeds (idempotent). */
|
||||
void secure_buf_free(secure_buf_t *buf);
|
||||
|
||||
/* Zeroize `len` bytes at `ptr` in a way the compiler cannot optimize away. */
|
||||
void secure_memzero(void *ptr, size_t len);
|
||||
|
||||
|
||||
/* from mnemonic.h */
|
||||
|
||||
|
||||
/* Maximum mnemonic length: 24 words * 10 chars avg + spaces + null = 256 is safe */
|
||||
#define MNEMONIC_MAX_LEN 256
|
||||
|
||||
/*
|
||||
* Mnemonic state — holds the loaded mnemonic in secure memory.
|
||||
* Only one mnemonic is active at a time per process.
|
||||
*/
|
||||
typedef struct {
|
||||
secure_buf_t buf; /* secure storage for the mnemonic string */
|
||||
int loaded; /* 1 if a mnemonic is currently loaded */
|
||||
int word_count; /* 12, 15, 18, 21, or 24 */
|
||||
} mnemonic_state_t;
|
||||
|
||||
/* Initialize mnemonic state (must be called before use). */
|
||||
void mnemonic_init(mnemonic_state_t *state);
|
||||
|
||||
/* Load a mnemonic string into secure memory. Validates word count (12/15/18/21/24).
|
||||
* Returns 0 on success, -1 on invalid input, -2 on memory error. */
|
||||
int mnemonic_load(mnemonic_state_t *state, const char *phrase);
|
||||
|
||||
/* Zeroize and unload the mnemonic. Idempotent. */
|
||||
void mnemonic_unload(mnemonic_state_t *state);
|
||||
|
||||
/* Check if a mnemonic is currently loaded. */
|
||||
int mnemonic_is_loaded(const mnemonic_state_t *state);
|
||||
|
||||
/* Get the mnemonic string (only valid while loaded). Returns NULL if not loaded. */
|
||||
const char *mnemonic_get_phrase(const mnemonic_state_t *state);
|
||||
|
||||
/* Generate a new BIP-39 mnemonic phrase (12/15/18/21/24 words) into out.
|
||||
* Returns 0 on success, -1 on invalid arguments or generation failure. */
|
||||
int mnemonic_generate(int word_count, char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from role_table.h */
|
||||
|
||||
|
||||
/* Maximum limits */
|
||||
#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 /* 64 hex chars + null + pad */
|
||||
#define ROLE_TABLE_MAX_ENTRIES 64
|
||||
|
||||
/* Purpose enum for fast comparison (string form kept for config/display) */
|
||||
typedef enum {
|
||||
PURPOSE_NOSTR = 0,
|
||||
PURPOSE_BITCOIN,
|
||||
PURPOSE_SSH,
|
||||
PURPOSE_AGE,
|
||||
PURPOSE_FIPS,
|
||||
PURPOSE_UNKNOWN
|
||||
} role_purpose_t;
|
||||
|
||||
/* Curve enum */
|
||||
typedef enum {
|
||||
CURVE_SECP256K1 = 0,
|
||||
CURVE_ED25519,
|
||||
CURVE_X25519,
|
||||
CURVE_UNKNOWN
|
||||
} role_curve_t;
|
||||
|
||||
/* Selector type — how this role's key is addressed */
|
||||
typedef enum {
|
||||
SELECTOR_NOSTR_INDEX, /* uses nostr_index shorthand */
|
||||
SELECTOR_ROLE_PATH /* uses explicit full path */
|
||||
} role_selector_type_t;
|
||||
|
||||
/* A single role entry */
|
||||
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; /* valid if selector_type == SELECTOR_NOSTR_INDEX */
|
||||
char role_path[ROLE_PATH_MAX]; /* valid if selector_type == SELECTOR_ROLE_PATH */
|
||||
char pubkey_hex[ROLE_PUBKEY_HEX_MAX]; /* filled after derivation, empty until then */
|
||||
int derived; /* 1 if pubkey_hex has been populated */
|
||||
} role_entry_t;
|
||||
|
||||
/* The role table */
|
||||
typedef struct {
|
||||
role_entry_t entries[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} role_table_t;
|
||||
|
||||
/* Initialize an empty role table */
|
||||
void role_table_init(role_table_t *table);
|
||||
|
||||
/* Add a role entry. Returns 0 on success, -1 if table full, -2 if name duplicate. */
|
||||
int role_table_add(role_table_t *table, const role_entry_t *entry);
|
||||
|
||||
/* Find a role by name. Returns pointer to entry or NULL. */
|
||||
role_entry_t *role_table_find_by_name(role_table_t *table, const char *name);
|
||||
|
||||
/* Find a role by nostr_index. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_nostr_index(role_table_t *table, int index);
|
||||
|
||||
/* Find a role by role_path. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_path(role_table_t *table, const char *path);
|
||||
|
||||
/* Get the default role (named "main"). Returns pointer or NULL if no "main" role. */
|
||||
role_entry_t *role_table_get_default(role_table_t *table);
|
||||
|
||||
/* Parse purpose string to enum */
|
||||
role_purpose_t role_purpose_from_str(const char *s);
|
||||
|
||||
/* Parse curve string to enum */
|
||||
role_curve_t role_curve_from_str(const char *s);
|
||||
|
||||
/* Purpose enum to string */
|
||||
const char *role_purpose_to_str(role_purpose_t p);
|
||||
|
||||
/* Curve enum to string */
|
||||
const char *role_curve_to_str(role_curve_t c);
|
||||
|
||||
|
||||
/* from selector.h */
|
||||
|
||||
|
||||
/* Error codes for selector resolution */
|
||||
#define SELECTOR_OK 0
|
||||
#define SELECTOR_ERR_AMBIGUOUS -1 /* multiple selectors specified */
|
||||
#define SELECTOR_ERR_NOT_FOUND -2 /* no matching role in table */
|
||||
#define SELECTOR_ERR_NO_DEFAULT -3 /* no selector given and no "main" role exists */
|
||||
|
||||
/* Parsed selector from a request's options object */
|
||||
typedef struct {
|
||||
int has_role; /* 1 if "role" field was present */
|
||||
char role_name[ROLE_NAME_MAX];
|
||||
|
||||
int has_nostr_index; /* 1 if "nostr_index" field was present */
|
||||
int nostr_index;
|
||||
|
||||
int has_role_path; /* 1 if "role_path" field was present */
|
||||
char role_path[ROLE_PATH_MAX];
|
||||
} selector_request_t;
|
||||
|
||||
/* Initialize a selector request (all fields zeroed/unset) */
|
||||
void selector_request_init(selector_request_t *req);
|
||||
|
||||
/*
|
||||
* Resolve a selector request against the role table.
|
||||
* On success (returns SELECTOR_OK), *out points to the matched role_entry_t.
|
||||
* On failure, returns one of the SELECTOR_ERR_* codes and *out is NULL.
|
||||
*/
|
||||
int selector_resolve(const selector_request_t *req, role_table_t *table, role_entry_t **out);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for a selector error code.
|
||||
*/
|
||||
const char *selector_strerror(int err);
|
||||
|
||||
|
||||
/* from enforcement.h */
|
||||
|
||||
|
||||
/* Error codes */
|
||||
#define ENFORCE_OK 0
|
||||
#define ENFORCE_ERR_PURPOSE -1 /* purpose mismatch */
|
||||
#define ENFORCE_ERR_CURVE -2 /* curve mismatch */
|
||||
#define ENFORCE_ERR_UNKNOWN_VERB -3 /* verb not recognized */
|
||||
|
||||
/* Known verbs */
|
||||
#define VERB_SIGN_EVENT "sign_event"
|
||||
#define VERB_GET_PUBLIC_KEY "get_public_key"
|
||||
#define VERB_NIP44_ENCRYPT "nip44_encrypt"
|
||||
#define VERB_NIP44_DECRYPT "nip44_decrypt"
|
||||
#define VERB_NIP04_ENCRYPT "nip04_encrypt"
|
||||
#define VERB_NIP04_DECRYPT "nip04_decrypt"
|
||||
|
||||
/*
|
||||
* Check whether `verb` is allowed to execute against `role`.
|
||||
* Returns ENFORCE_OK if allowed, or an ENFORCE_ERR_* code.
|
||||
*
|
||||
* The enforcement rules are:
|
||||
* - All nostr verbs (sign_event, get_public_key, nip44_*, nip04_*) require:
|
||||
* purpose == PURPOSE_NOSTR and curve == CURVE_SECP256K1
|
||||
* - Unknown verbs return ENFORCE_ERR_UNKNOWN_VERB (fail-closed).
|
||||
*/
|
||||
int enforce_verb_role(const char *verb, const role_entry_t *role);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for an enforcement error code.
|
||||
*/
|
||||
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 64
|
||||
|
||||
/* Prompt behavior */
|
||||
typedef enum {
|
||||
PROMPT_NEVER = 0,
|
||||
PROMPT_FIRST_PER_BOOT,
|
||||
PROMPT_EVERY_REQUEST,
|
||||
PROMPT_DENY
|
||||
} prompt_mode_t;
|
||||
|
||||
/* A single policy entry */
|
||||
typedef struct {
|
||||
char caller[POLICY_CALLER_MAX_LEN]; /* e.g. "uid:1000" or "*" for any */
|
||||
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;
|
||||
prompt_mode_t prompt;
|
||||
} policy_entry_t;
|
||||
|
||||
/* Policy table */
|
||||
typedef struct {
|
||||
policy_entry_t entries[POLICY_MAX_ENTRIES];
|
||||
int count;
|
||||
} policy_table_t;
|
||||
|
||||
/* Policy check result */
|
||||
#define POLICY_ALLOW 0
|
||||
#define POLICY_DENY -1
|
||||
#define POLICY_PROMPT -2 /* would need user confirmation */
|
||||
#define POLICY_NO_MATCH -3 /* no policy entry matched (fail-closed = deny) */
|
||||
|
||||
/* Initialize policy table */
|
||||
void policy_table_init(policy_table_t *table);
|
||||
|
||||
/* Initialize default policy: allow same-uid, deny others */
|
||||
void policy_init_default(policy_table_t *table, uid_t owner_uid);
|
||||
|
||||
/* Add a policy entry. Returns 0 on success, -1 if full. */
|
||||
int policy_table_add(policy_table_t *table, const policy_entry_t *entry);
|
||||
|
||||
/*
|
||||
* Check whether caller_id is allowed to invoke `verb` on `role_name` with given `purpose`.
|
||||
* Returns POLICY_ALLOW, POLICY_DENY, POLICY_PROMPT, or POLICY_NO_MATCH.
|
||||
*/
|
||||
int policy_check(const policy_table_t *table, const char *caller_id,
|
||||
const char *verb, const char *role_name, const char *purpose);
|
||||
|
||||
/* Parse prompt mode from string */
|
||||
prompt_mode_t prompt_mode_from_str(const char *s);
|
||||
|
||||
/* Prompt mode to string */
|
||||
const char *prompt_mode_to_str(prompt_mode_t m);
|
||||
|
||||
|
||||
/* from crypto.h */
|
||||
|
||||
|
||||
/* Per-role derived key material (stored in secure memory) */
|
||||
typedef struct {
|
||||
secure_buf_t private_key; /* 32 bytes, mlock'd */
|
||||
unsigned char public_key[32];
|
||||
char pubkey_hex[65]; /* 64 hex chars + null */
|
||||
char npub[128]; /* bech32 npub */
|
||||
int valid;
|
||||
} derived_key_t;
|
||||
|
||||
/* Key store — holds derived keys for all roles */
|
||||
typedef struct {
|
||||
derived_key_t keys[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} key_store_t;
|
||||
|
||||
/* Derive keys for all roles in the table using the loaded mnemonic.
|
||||
* Populates key_store and sets role->pubkey_hex and role->derived for each role.
|
||||
* Only derives for roles with purpose=nostr and curve=secp256k1 (for now).
|
||||
* Returns number of keys derived, or -1 on error. */
|
||||
int crypto_derive_all(key_store_t *store, role_table_t *table, const mnemonic_state_t *mnemonic);
|
||||
|
||||
/* Get the derived private key for a role (by table index). Returns NULL if not derived. */
|
||||
const unsigned char *crypto_get_private_key(const key_store_t *store, int role_index);
|
||||
|
||||
/* Get the derived public key hex for a role. Returns NULL if not derived. */
|
||||
const char *crypto_get_pubkey_hex(const key_store_t *store, int role_index);
|
||||
|
||||
/* Sign a Nostr event. event_json is the unsigned event JSON string.
|
||||
* Returns a newly-allocated string containing the signed event JSON, or NULL on error.
|
||||
* Caller must free() the returned string. */
|
||||
char *crypto_sign_event(const key_store_t *store, int role_index, const char *event_json);
|
||||
|
||||
/* Zeroize all derived keys in the store. */
|
||||
void crypto_wipe(key_store_t *store);
|
||||
|
||||
|
||||
/* from dispatcher.h */
|
||||
|
||||
|
||||
/* Dispatcher context — holds references to shared state */
|
||||
typedef struct {
|
||||
role_table_t *role_table;
|
||||
mnemonic_state_t *mnemonic;
|
||||
key_store_t *key_store;
|
||||
} dispatcher_ctx_t;
|
||||
|
||||
/* Initialize dispatcher context */
|
||||
void dispatcher_init(dispatcher_ctx_t *ctx, role_table_t *table, mnemonic_state_t *mnemonic, key_store_t *key_store);
|
||||
|
||||
/*
|
||||
* Process a JSON-RPC request string and produce a JSON-RPC response string.
|
||||
*
|
||||
* The caller owns the returned string and must free() it.
|
||||
* Returns NULL only on catastrophic allocation failure.
|
||||
*
|
||||
* Response format on success:
|
||||
* { "id": "...", "result": "..." }
|
||||
*
|
||||
* Response format on error:
|
||||
* { "id": "...", "error": { "code": <int>, "message": "..." } }
|
||||
*
|
||||
* Error codes:
|
||||
* -32700 Parse error (invalid JSON)
|
||||
* -32600 Invalid request (missing id/method/params)
|
||||
* -32601 Method not found (unknown verb after enforcement)
|
||||
* -32602 Invalid params
|
||||
* 1001 ambiguous_role_selector
|
||||
* 1002 role_not_found
|
||||
* 1003 no_default_role
|
||||
* 1004 purpose_mismatch
|
||||
* 1005 curve_mismatch
|
||||
* 1006 mnemonic_not_loaded
|
||||
*/
|
||||
char *dispatcher_handle_request(dispatcher_ctx_t *ctx, const char *json_request);
|
||||
|
||||
|
||||
/* from server.h */
|
||||
|
||||
|
||||
#define SERVER_SOCKET_NAME_MAX 108
|
||||
#define SERVER_MAX_MSG_SIZE 65536
|
||||
|
||||
/* Caller identity */
|
||||
typedef struct {
|
||||
uid_t uid;
|
||||
gid_t gid;
|
||||
pid_t pid;
|
||||
char caller_id[64]; /* "uid:<n>" */
|
||||
} caller_identity_t;
|
||||
|
||||
/* Server context */
|
||||
typedef struct {
|
||||
char socket_name[SERVER_SOCKET_NAME_MAX]; /* abstract namespace name (without \0 prefix) */
|
||||
char last_error[256];
|
||||
int listen_fd;
|
||||
int running;
|
||||
dispatcher_ctx_t *dispatcher;
|
||||
policy_table_t *policy;
|
||||
int socket_name_explicit;
|
||||
} server_ctx_t;
|
||||
|
||||
/* Initialize server context. socket_name is the abstract namespace name (e.g. "nsigner").
|
||||
* socket_name_explicit should be non-zero when provided via --socket-name override. */
|
||||
void server_init(server_ctx_t *ctx, const char *socket_name, int socket_name_explicit,
|
||||
dispatcher_ctx_t *dispatcher, policy_table_t *policy);
|
||||
|
||||
/* Start listening. Returns 0 on success, -1 on error. */
|
||||
int server_start(server_ctx_t *ctx);
|
||||
|
||||
/* Get human-readable description of last server error. */
|
||||
const char *server_last_error(const server_ctx_t *ctx);
|
||||
|
||||
/* Handle one pending connection (non-blocking). Returns 1 if handled, 0 if nothing pending, -1 on error.
|
||||
* activity_cb is called with a description string for the TUI activity log. */
|
||||
typedef void (*server_activity_cb)(const char *message, void *user_data);
|
||||
int server_handle_one(server_ctx_t *ctx, server_activity_cb cb, void *cb_data);
|
||||
|
||||
/* Stop server and close socket */
|
||||
void server_stop(server_ctx_t *ctx);
|
||||
|
||||
/* Extract caller identity from connected fd */
|
||||
int server_get_caller(int fd, caller_identity_t *out);
|
||||
|
||||
|
||||
/* from socket_name.h */
|
||||
|
||||
|
||||
/*
|
||||
* Generate random socket name in format: nsigner_<word1>_<word2>
|
||||
* Returns 0 on success, -1 on error.
|
||||
*/
|
||||
int socket_name_random(char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from main.h */
|
||||
/*
|
||||
* nsigner main header - version information
|
||||
*
|
||||
* Version macros are auto-updated by increment_and_push.sh.
|
||||
*/
|
||||
|
||||
|
||||
/* Version information (auto-updated by build/version tooling) */
|
||||
#define NSIGNER_VERSION_MAJOR 0
|
||||
#define NSIGNER_VERSION_MINOR 0
|
||||
#define NSIGNER_VERSION_PATCH 2
|
||||
#define NSIGNER_VERSION "v0.0.2"
|
||||
|
||||
|
||||
/* NSIGNER_HEADERLESS_DECLS_END */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
68
src/policy.h
68
src/policy.h
@@ -1,68 +0,0 @@
|
||||
#ifndef NSIGNER_POLICY_H
|
||||
#define NSIGNER_POLICY_H
|
||||
|
||||
#include "role_table.h"
|
||||
#include <sys/types.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 64
|
||||
|
||||
/* Prompt behavior */
|
||||
typedef enum {
|
||||
PROMPT_NEVER = 0,
|
||||
PROMPT_FIRST_PER_BOOT,
|
||||
PROMPT_EVERY_REQUEST,
|
||||
PROMPT_DENY
|
||||
} prompt_mode_t;
|
||||
|
||||
/* A single policy entry */
|
||||
typedef struct {
|
||||
char caller[POLICY_CALLER_MAX_LEN]; /* e.g. "uid:1000" or "*" for any */
|
||||
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;
|
||||
prompt_mode_t prompt;
|
||||
} policy_entry_t;
|
||||
|
||||
/* Policy table */
|
||||
typedef struct {
|
||||
policy_entry_t entries[POLICY_MAX_ENTRIES];
|
||||
int count;
|
||||
} policy_table_t;
|
||||
|
||||
/* Policy check result */
|
||||
#define POLICY_ALLOW 0
|
||||
#define POLICY_DENY -1
|
||||
#define POLICY_PROMPT -2 /* would need user confirmation */
|
||||
#define POLICY_NO_MATCH -3 /* no policy entry matched (fail-closed = deny) */
|
||||
|
||||
/* Initialize policy table */
|
||||
void policy_table_init(policy_table_t *table);
|
||||
|
||||
/* Initialize default policy: allow same-uid, deny others */
|
||||
void policy_init_default(policy_table_t *table, uid_t owner_uid);
|
||||
|
||||
/* Add a policy entry. Returns 0 on success, -1 if full. */
|
||||
int policy_table_add(policy_table_t *table, const policy_entry_t *entry);
|
||||
|
||||
/*
|
||||
* Check whether caller_id is allowed to invoke `verb` on `role_name` with given `purpose`.
|
||||
* Returns POLICY_ALLOW, POLICY_DENY, POLICY_PROMPT, or POLICY_NO_MATCH.
|
||||
*/
|
||||
int policy_check(const policy_table_t *table, const char *caller_id,
|
||||
const char *verb, const char *role_name, const char *purpose);
|
||||
|
||||
/* Parse prompt mode from string */
|
||||
prompt_mode_t prompt_mode_from_str(const char *s);
|
||||
|
||||
/* Prompt mode to string */
|
||||
const char *prompt_mode_to_str(prompt_mode_t m);
|
||||
|
||||
#endif /* NSIGNER_POLICY_H */
|
||||
442
src/role_table.c
442
src/role_table.c
@@ -1,4 +1,444 @@
|
||||
#include "role_table.h"
|
||||
/* NSIGNER_HEADERLESS_DECLS_BEGIN */
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
#include <cJSON.h>
|
||||
|
||||
/* from secure_mem.h */
|
||||
|
||||
|
||||
/*
|
||||
* Secure memory buffer — mlock'd, zeroized on free.
|
||||
* Used for mnemonic phrases, private keys, and any sensitive material.
|
||||
*/
|
||||
typedef struct {
|
||||
void *data; /* pointer to locked allocation */
|
||||
size_t size; /* usable size in bytes */
|
||||
int locked; /* 1 if mlock succeeded */
|
||||
} secure_buf_t;
|
||||
|
||||
/* Allocate a secure buffer of `size` bytes. Returns 0 on success, -1 on failure. */
|
||||
int secure_buf_alloc(secure_buf_t *buf, size_t size);
|
||||
|
||||
/* Zeroize and free a secure buffer. Always succeeds (idempotent). */
|
||||
void secure_buf_free(secure_buf_t *buf);
|
||||
|
||||
/* Zeroize `len` bytes at `ptr` in a way the compiler cannot optimize away. */
|
||||
void secure_memzero(void *ptr, size_t len);
|
||||
|
||||
|
||||
/* from mnemonic.h */
|
||||
|
||||
|
||||
/* Maximum mnemonic length: 24 words * 10 chars avg + spaces + null = 256 is safe */
|
||||
#define MNEMONIC_MAX_LEN 256
|
||||
|
||||
/*
|
||||
* Mnemonic state — holds the loaded mnemonic in secure memory.
|
||||
* Only one mnemonic is active at a time per process.
|
||||
*/
|
||||
typedef struct {
|
||||
secure_buf_t buf; /* secure storage for the mnemonic string */
|
||||
int loaded; /* 1 if a mnemonic is currently loaded */
|
||||
int word_count; /* 12, 15, 18, 21, or 24 */
|
||||
} mnemonic_state_t;
|
||||
|
||||
/* Initialize mnemonic state (must be called before use). */
|
||||
void mnemonic_init(mnemonic_state_t *state);
|
||||
|
||||
/* Load a mnemonic string into secure memory. Validates word count (12/15/18/21/24).
|
||||
* Returns 0 on success, -1 on invalid input, -2 on memory error. */
|
||||
int mnemonic_load(mnemonic_state_t *state, const char *phrase);
|
||||
|
||||
/* Zeroize and unload the mnemonic. Idempotent. */
|
||||
void mnemonic_unload(mnemonic_state_t *state);
|
||||
|
||||
/* Check if a mnemonic is currently loaded. */
|
||||
int mnemonic_is_loaded(const mnemonic_state_t *state);
|
||||
|
||||
/* Get the mnemonic string (only valid while loaded). Returns NULL if not loaded. */
|
||||
const char *mnemonic_get_phrase(const mnemonic_state_t *state);
|
||||
|
||||
/* Generate a new BIP-39 mnemonic phrase (12/15/18/21/24 words) into out.
|
||||
* Returns 0 on success, -1 on invalid arguments or generation failure. */
|
||||
int mnemonic_generate(int word_count, char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from role_table.h */
|
||||
|
||||
|
||||
/* Maximum limits */
|
||||
#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 /* 64 hex chars + null + pad */
|
||||
#define ROLE_TABLE_MAX_ENTRIES 64
|
||||
|
||||
/* Purpose enum for fast comparison (string form kept for config/display) */
|
||||
typedef enum {
|
||||
PURPOSE_NOSTR = 0,
|
||||
PURPOSE_BITCOIN,
|
||||
PURPOSE_SSH,
|
||||
PURPOSE_AGE,
|
||||
PURPOSE_FIPS,
|
||||
PURPOSE_UNKNOWN
|
||||
} role_purpose_t;
|
||||
|
||||
/* Curve enum */
|
||||
typedef enum {
|
||||
CURVE_SECP256K1 = 0,
|
||||
CURVE_ED25519,
|
||||
CURVE_X25519,
|
||||
CURVE_UNKNOWN
|
||||
} role_curve_t;
|
||||
|
||||
/* Selector type — how this role's key is addressed */
|
||||
typedef enum {
|
||||
SELECTOR_NOSTR_INDEX, /* uses nostr_index shorthand */
|
||||
SELECTOR_ROLE_PATH /* uses explicit full path */
|
||||
} role_selector_type_t;
|
||||
|
||||
/* A single role entry */
|
||||
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; /* valid if selector_type == SELECTOR_NOSTR_INDEX */
|
||||
char role_path[ROLE_PATH_MAX]; /* valid if selector_type == SELECTOR_ROLE_PATH */
|
||||
char pubkey_hex[ROLE_PUBKEY_HEX_MAX]; /* filled after derivation, empty until then */
|
||||
int derived; /* 1 if pubkey_hex has been populated */
|
||||
} role_entry_t;
|
||||
|
||||
/* The role table */
|
||||
typedef struct {
|
||||
role_entry_t entries[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} role_table_t;
|
||||
|
||||
/* Initialize an empty role table */
|
||||
void role_table_init(role_table_t *table);
|
||||
|
||||
/* Add a role entry. Returns 0 on success, -1 if table full, -2 if name duplicate. */
|
||||
int role_table_add(role_table_t *table, const role_entry_t *entry);
|
||||
|
||||
/* Find a role by name. Returns pointer to entry or NULL. */
|
||||
role_entry_t *role_table_find_by_name(role_table_t *table, const char *name);
|
||||
|
||||
/* Find a role by nostr_index. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_nostr_index(role_table_t *table, int index);
|
||||
|
||||
/* Find a role by role_path. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_path(role_table_t *table, const char *path);
|
||||
|
||||
/* Get the default role (named "main"). Returns pointer or NULL if no "main" role. */
|
||||
role_entry_t *role_table_get_default(role_table_t *table);
|
||||
|
||||
/* Parse purpose string to enum */
|
||||
role_purpose_t role_purpose_from_str(const char *s);
|
||||
|
||||
/* Parse curve string to enum */
|
||||
role_curve_t role_curve_from_str(const char *s);
|
||||
|
||||
/* Purpose enum to string */
|
||||
const char *role_purpose_to_str(role_purpose_t p);
|
||||
|
||||
/* Curve enum to string */
|
||||
const char *role_curve_to_str(role_curve_t c);
|
||||
|
||||
|
||||
/* from selector.h */
|
||||
|
||||
|
||||
/* Error codes for selector resolution */
|
||||
#define SELECTOR_OK 0
|
||||
#define SELECTOR_ERR_AMBIGUOUS -1 /* multiple selectors specified */
|
||||
#define SELECTOR_ERR_NOT_FOUND -2 /* no matching role in table */
|
||||
#define SELECTOR_ERR_NO_DEFAULT -3 /* no selector given and no "main" role exists */
|
||||
|
||||
/* Parsed selector from a request's options object */
|
||||
typedef struct {
|
||||
int has_role; /* 1 if "role" field was present */
|
||||
char role_name[ROLE_NAME_MAX];
|
||||
|
||||
int has_nostr_index; /* 1 if "nostr_index" field was present */
|
||||
int nostr_index;
|
||||
|
||||
int has_role_path; /* 1 if "role_path" field was present */
|
||||
char role_path[ROLE_PATH_MAX];
|
||||
} selector_request_t;
|
||||
|
||||
/* Initialize a selector request (all fields zeroed/unset) */
|
||||
void selector_request_init(selector_request_t *req);
|
||||
|
||||
/*
|
||||
* Resolve a selector request against the role table.
|
||||
* On success (returns SELECTOR_OK), *out points to the matched role_entry_t.
|
||||
* On failure, returns one of the SELECTOR_ERR_* codes and *out is NULL.
|
||||
*/
|
||||
int selector_resolve(const selector_request_t *req, role_table_t *table, role_entry_t **out);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for a selector error code.
|
||||
*/
|
||||
const char *selector_strerror(int err);
|
||||
|
||||
|
||||
/* from enforcement.h */
|
||||
|
||||
|
||||
/* Error codes */
|
||||
#define ENFORCE_OK 0
|
||||
#define ENFORCE_ERR_PURPOSE -1 /* purpose mismatch */
|
||||
#define ENFORCE_ERR_CURVE -2 /* curve mismatch */
|
||||
#define ENFORCE_ERR_UNKNOWN_VERB -3 /* verb not recognized */
|
||||
|
||||
/* Known verbs */
|
||||
#define VERB_SIGN_EVENT "sign_event"
|
||||
#define VERB_GET_PUBLIC_KEY "get_public_key"
|
||||
#define VERB_NIP44_ENCRYPT "nip44_encrypt"
|
||||
#define VERB_NIP44_DECRYPT "nip44_decrypt"
|
||||
#define VERB_NIP04_ENCRYPT "nip04_encrypt"
|
||||
#define VERB_NIP04_DECRYPT "nip04_decrypt"
|
||||
|
||||
/*
|
||||
* Check whether `verb` is allowed to execute against `role`.
|
||||
* Returns ENFORCE_OK if allowed, or an ENFORCE_ERR_* code.
|
||||
*
|
||||
* The enforcement rules are:
|
||||
* - All nostr verbs (sign_event, get_public_key, nip44_*, nip04_*) require:
|
||||
* purpose == PURPOSE_NOSTR and curve == CURVE_SECP256K1
|
||||
* - Unknown verbs return ENFORCE_ERR_UNKNOWN_VERB (fail-closed).
|
||||
*/
|
||||
int enforce_verb_role(const char *verb, const role_entry_t *role);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for an enforcement error code.
|
||||
*/
|
||||
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 64
|
||||
|
||||
/* Prompt behavior */
|
||||
typedef enum {
|
||||
PROMPT_NEVER = 0,
|
||||
PROMPT_FIRST_PER_BOOT,
|
||||
PROMPT_EVERY_REQUEST,
|
||||
PROMPT_DENY
|
||||
} prompt_mode_t;
|
||||
|
||||
/* A single policy entry */
|
||||
typedef struct {
|
||||
char caller[POLICY_CALLER_MAX_LEN]; /* e.g. "uid:1000" or "*" for any */
|
||||
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;
|
||||
prompt_mode_t prompt;
|
||||
} policy_entry_t;
|
||||
|
||||
/* Policy table */
|
||||
typedef struct {
|
||||
policy_entry_t entries[POLICY_MAX_ENTRIES];
|
||||
int count;
|
||||
} policy_table_t;
|
||||
|
||||
/* Policy check result */
|
||||
#define POLICY_ALLOW 0
|
||||
#define POLICY_DENY -1
|
||||
#define POLICY_PROMPT -2 /* would need user confirmation */
|
||||
#define POLICY_NO_MATCH -3 /* no policy entry matched (fail-closed = deny) */
|
||||
|
||||
/* Initialize policy table */
|
||||
void policy_table_init(policy_table_t *table);
|
||||
|
||||
/* Initialize default policy: allow same-uid, deny others */
|
||||
void policy_init_default(policy_table_t *table, uid_t owner_uid);
|
||||
|
||||
/* Add a policy entry. Returns 0 on success, -1 if full. */
|
||||
int policy_table_add(policy_table_t *table, const policy_entry_t *entry);
|
||||
|
||||
/*
|
||||
* Check whether caller_id is allowed to invoke `verb` on `role_name` with given `purpose`.
|
||||
* Returns POLICY_ALLOW, POLICY_DENY, POLICY_PROMPT, or POLICY_NO_MATCH.
|
||||
*/
|
||||
int policy_check(const policy_table_t *table, const char *caller_id,
|
||||
const char *verb, const char *role_name, const char *purpose);
|
||||
|
||||
/* Parse prompt mode from string */
|
||||
prompt_mode_t prompt_mode_from_str(const char *s);
|
||||
|
||||
/* Prompt mode to string */
|
||||
const char *prompt_mode_to_str(prompt_mode_t m);
|
||||
|
||||
|
||||
/* from crypto.h */
|
||||
|
||||
|
||||
/* Per-role derived key material (stored in secure memory) */
|
||||
typedef struct {
|
||||
secure_buf_t private_key; /* 32 bytes, mlock'd */
|
||||
unsigned char public_key[32];
|
||||
char pubkey_hex[65]; /* 64 hex chars + null */
|
||||
char npub[128]; /* bech32 npub */
|
||||
int valid;
|
||||
} derived_key_t;
|
||||
|
||||
/* Key store — holds derived keys for all roles */
|
||||
typedef struct {
|
||||
derived_key_t keys[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} key_store_t;
|
||||
|
||||
/* Derive keys for all roles in the table using the loaded mnemonic.
|
||||
* Populates key_store and sets role->pubkey_hex and role->derived for each role.
|
||||
* Only derives for roles with purpose=nostr and curve=secp256k1 (for now).
|
||||
* Returns number of keys derived, or -1 on error. */
|
||||
int crypto_derive_all(key_store_t *store, role_table_t *table, const mnemonic_state_t *mnemonic);
|
||||
|
||||
/* Get the derived private key for a role (by table index). Returns NULL if not derived. */
|
||||
const unsigned char *crypto_get_private_key(const key_store_t *store, int role_index);
|
||||
|
||||
/* Get the derived public key hex for a role. Returns NULL if not derived. */
|
||||
const char *crypto_get_pubkey_hex(const key_store_t *store, int role_index);
|
||||
|
||||
/* Sign a Nostr event. event_json is the unsigned event JSON string.
|
||||
* Returns a newly-allocated string containing the signed event JSON, or NULL on error.
|
||||
* Caller must free() the returned string. */
|
||||
char *crypto_sign_event(const key_store_t *store, int role_index, const char *event_json);
|
||||
|
||||
/* Zeroize all derived keys in the store. */
|
||||
void crypto_wipe(key_store_t *store);
|
||||
|
||||
|
||||
/* from dispatcher.h */
|
||||
|
||||
|
||||
/* Dispatcher context — holds references to shared state */
|
||||
typedef struct {
|
||||
role_table_t *role_table;
|
||||
mnemonic_state_t *mnemonic;
|
||||
key_store_t *key_store;
|
||||
} dispatcher_ctx_t;
|
||||
|
||||
/* Initialize dispatcher context */
|
||||
void dispatcher_init(dispatcher_ctx_t *ctx, role_table_t *table, mnemonic_state_t *mnemonic, key_store_t *key_store);
|
||||
|
||||
/*
|
||||
* Process a JSON-RPC request string and produce a JSON-RPC response string.
|
||||
*
|
||||
* The caller owns the returned string and must free() it.
|
||||
* Returns NULL only on catastrophic allocation failure.
|
||||
*
|
||||
* Response format on success:
|
||||
* { "id": "...", "result": "..." }
|
||||
*
|
||||
* Response format on error:
|
||||
* { "id": "...", "error": { "code": <int>, "message": "..." } }
|
||||
*
|
||||
* Error codes:
|
||||
* -32700 Parse error (invalid JSON)
|
||||
* -32600 Invalid request (missing id/method/params)
|
||||
* -32601 Method not found (unknown verb after enforcement)
|
||||
* -32602 Invalid params
|
||||
* 1001 ambiguous_role_selector
|
||||
* 1002 role_not_found
|
||||
* 1003 no_default_role
|
||||
* 1004 purpose_mismatch
|
||||
* 1005 curve_mismatch
|
||||
* 1006 mnemonic_not_loaded
|
||||
*/
|
||||
char *dispatcher_handle_request(dispatcher_ctx_t *ctx, const char *json_request);
|
||||
|
||||
|
||||
/* from server.h */
|
||||
|
||||
|
||||
#define SERVER_SOCKET_NAME_MAX 108
|
||||
#define SERVER_MAX_MSG_SIZE 65536
|
||||
|
||||
/* Caller identity */
|
||||
typedef struct {
|
||||
uid_t uid;
|
||||
gid_t gid;
|
||||
pid_t pid;
|
||||
char caller_id[64]; /* "uid:<n>" */
|
||||
} caller_identity_t;
|
||||
|
||||
/* Server context */
|
||||
typedef struct {
|
||||
char socket_name[SERVER_SOCKET_NAME_MAX]; /* abstract namespace name (without \0 prefix) */
|
||||
char last_error[256];
|
||||
int listen_fd;
|
||||
int running;
|
||||
dispatcher_ctx_t *dispatcher;
|
||||
policy_table_t *policy;
|
||||
int socket_name_explicit;
|
||||
} server_ctx_t;
|
||||
|
||||
/* Initialize server context. socket_name is the abstract namespace name (e.g. "nsigner").
|
||||
* socket_name_explicit should be non-zero when provided via --socket-name override. */
|
||||
void server_init(server_ctx_t *ctx, const char *socket_name, int socket_name_explicit,
|
||||
dispatcher_ctx_t *dispatcher, policy_table_t *policy);
|
||||
|
||||
/* Start listening. Returns 0 on success, -1 on error. */
|
||||
int server_start(server_ctx_t *ctx);
|
||||
|
||||
/* Get human-readable description of last server error. */
|
||||
const char *server_last_error(const server_ctx_t *ctx);
|
||||
|
||||
/* Handle one pending connection (non-blocking). Returns 1 if handled, 0 if nothing pending, -1 on error.
|
||||
* activity_cb is called with a description string for the TUI activity log. */
|
||||
typedef void (*server_activity_cb)(const char *message, void *user_data);
|
||||
int server_handle_one(server_ctx_t *ctx, server_activity_cb cb, void *cb_data);
|
||||
|
||||
/* Stop server and close socket */
|
||||
void server_stop(server_ctx_t *ctx);
|
||||
|
||||
/* Extract caller identity from connected fd */
|
||||
int server_get_caller(int fd, caller_identity_t *out);
|
||||
|
||||
|
||||
/* from socket_name.h */
|
||||
|
||||
|
||||
/*
|
||||
* Generate random socket name in format: nsigner_<word1>_<word2>
|
||||
* Returns 0 on success, -1 on error.
|
||||
*/
|
||||
int socket_name_random(char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from main.h */
|
||||
/*
|
||||
* nsigner main header - version information
|
||||
*
|
||||
* Version macros are auto-updated by increment_and_push.sh.
|
||||
*/
|
||||
|
||||
|
||||
/* Version information (auto-updated by build/version tooling) */
|
||||
#define NSIGNER_VERSION_MAJOR 0
|
||||
#define NSIGNER_VERSION_MINOR 0
|
||||
#define NSIGNER_VERSION_PATCH 2
|
||||
#define NSIGNER_VERSION "v0.0.2"
|
||||
|
||||
|
||||
/* NSIGNER_HEADERLESS_DECLS_END */
|
||||
|
||||
#include <string.h>
|
||||
|
||||
|
||||
@@ -1,89 +0,0 @@
|
||||
#ifndef NSIGNER_ROLE_TABLE_H
|
||||
#define NSIGNER_ROLE_TABLE_H
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
/* Maximum limits */
|
||||
#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 /* 64 hex chars + null + pad */
|
||||
#define ROLE_TABLE_MAX_ENTRIES 64
|
||||
|
||||
/* Purpose enum for fast comparison (string form kept for config/display) */
|
||||
typedef enum {
|
||||
PURPOSE_NOSTR = 0,
|
||||
PURPOSE_BITCOIN,
|
||||
PURPOSE_SSH,
|
||||
PURPOSE_AGE,
|
||||
PURPOSE_FIPS,
|
||||
PURPOSE_UNKNOWN
|
||||
} role_purpose_t;
|
||||
|
||||
/* Curve enum */
|
||||
typedef enum {
|
||||
CURVE_SECP256K1 = 0,
|
||||
CURVE_ED25519,
|
||||
CURVE_X25519,
|
||||
CURVE_UNKNOWN
|
||||
} role_curve_t;
|
||||
|
||||
/* Selector type — how this role's key is addressed */
|
||||
typedef enum {
|
||||
SELECTOR_NOSTR_INDEX, /* uses nostr_index shorthand */
|
||||
SELECTOR_ROLE_PATH /* uses explicit full path */
|
||||
} role_selector_type_t;
|
||||
|
||||
/* A single role entry */
|
||||
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; /* valid if selector_type == SELECTOR_NOSTR_INDEX */
|
||||
char role_path[ROLE_PATH_MAX]; /* valid if selector_type == SELECTOR_ROLE_PATH */
|
||||
char pubkey_hex[ROLE_PUBKEY_HEX_MAX]; /* filled after derivation, empty until then */
|
||||
int derived; /* 1 if pubkey_hex has been populated */
|
||||
} role_entry_t;
|
||||
|
||||
/* The role table */
|
||||
typedef struct {
|
||||
role_entry_t entries[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} role_table_t;
|
||||
|
||||
/* Initialize an empty role table */
|
||||
void role_table_init(role_table_t *table);
|
||||
|
||||
/* Add a role entry. Returns 0 on success, -1 if table full, -2 if name duplicate. */
|
||||
int role_table_add(role_table_t *table, const role_entry_t *entry);
|
||||
|
||||
/* Find a role by name. Returns pointer to entry or NULL. */
|
||||
role_entry_t *role_table_find_by_name(role_table_t *table, const char *name);
|
||||
|
||||
/* Find a role by nostr_index. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_nostr_index(role_table_t *table, int index);
|
||||
|
||||
/* Find a role by role_path. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_path(role_table_t *table, const char *path);
|
||||
|
||||
/* Get the default role (named "main"). Returns pointer or NULL if no "main" role. */
|
||||
role_entry_t *role_table_get_default(role_table_t *table);
|
||||
|
||||
/* Parse purpose string to enum */
|
||||
role_purpose_t role_purpose_from_str(const char *s);
|
||||
|
||||
/* Parse curve string to enum */
|
||||
role_curve_t role_curve_from_str(const char *s);
|
||||
|
||||
/* Purpose enum to string */
|
||||
const char *role_purpose_to_str(role_purpose_t p);
|
||||
|
||||
/* Curve enum to string */
|
||||
const char *role_curve_to_str(role_curve_t c);
|
||||
|
||||
#endif /* NSIGNER_ROLE_TABLE_H */
|
||||
442
src/secure_mem.c
442
src/secure_mem.c
@@ -1,6 +1,446 @@
|
||||
#define _GNU_SOURCE
|
||||
|
||||
#include "secure_mem.h"
|
||||
/* NSIGNER_HEADERLESS_DECLS_BEGIN */
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
#include <cJSON.h>
|
||||
|
||||
/* from secure_mem.h */
|
||||
|
||||
|
||||
/*
|
||||
* Secure memory buffer — mlock'd, zeroized on free.
|
||||
* Used for mnemonic phrases, private keys, and any sensitive material.
|
||||
*/
|
||||
typedef struct {
|
||||
void *data; /* pointer to locked allocation */
|
||||
size_t size; /* usable size in bytes */
|
||||
int locked; /* 1 if mlock succeeded */
|
||||
} secure_buf_t;
|
||||
|
||||
/* Allocate a secure buffer of `size` bytes. Returns 0 on success, -1 on failure. */
|
||||
int secure_buf_alloc(secure_buf_t *buf, size_t size);
|
||||
|
||||
/* Zeroize and free a secure buffer. Always succeeds (idempotent). */
|
||||
void secure_buf_free(secure_buf_t *buf);
|
||||
|
||||
/* Zeroize `len` bytes at `ptr` in a way the compiler cannot optimize away. */
|
||||
void secure_memzero(void *ptr, size_t len);
|
||||
|
||||
|
||||
/* from mnemonic.h */
|
||||
|
||||
|
||||
/* Maximum mnemonic length: 24 words * 10 chars avg + spaces + null = 256 is safe */
|
||||
#define MNEMONIC_MAX_LEN 256
|
||||
|
||||
/*
|
||||
* Mnemonic state — holds the loaded mnemonic in secure memory.
|
||||
* Only one mnemonic is active at a time per process.
|
||||
*/
|
||||
typedef struct {
|
||||
secure_buf_t buf; /* secure storage for the mnemonic string */
|
||||
int loaded; /* 1 if a mnemonic is currently loaded */
|
||||
int word_count; /* 12, 15, 18, 21, or 24 */
|
||||
} mnemonic_state_t;
|
||||
|
||||
/* Initialize mnemonic state (must be called before use). */
|
||||
void mnemonic_init(mnemonic_state_t *state);
|
||||
|
||||
/* Load a mnemonic string into secure memory. Validates word count (12/15/18/21/24).
|
||||
* Returns 0 on success, -1 on invalid input, -2 on memory error. */
|
||||
int mnemonic_load(mnemonic_state_t *state, const char *phrase);
|
||||
|
||||
/* Zeroize and unload the mnemonic. Idempotent. */
|
||||
void mnemonic_unload(mnemonic_state_t *state);
|
||||
|
||||
/* Check if a mnemonic is currently loaded. */
|
||||
int mnemonic_is_loaded(const mnemonic_state_t *state);
|
||||
|
||||
/* Get the mnemonic string (only valid while loaded). Returns NULL if not loaded. */
|
||||
const char *mnemonic_get_phrase(const mnemonic_state_t *state);
|
||||
|
||||
/* Generate a new BIP-39 mnemonic phrase (12/15/18/21/24 words) into out.
|
||||
* Returns 0 on success, -1 on invalid arguments or generation failure. */
|
||||
int mnemonic_generate(int word_count, char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from role_table.h */
|
||||
|
||||
|
||||
/* Maximum limits */
|
||||
#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 /* 64 hex chars + null + pad */
|
||||
#define ROLE_TABLE_MAX_ENTRIES 64
|
||||
|
||||
/* Purpose enum for fast comparison (string form kept for config/display) */
|
||||
typedef enum {
|
||||
PURPOSE_NOSTR = 0,
|
||||
PURPOSE_BITCOIN,
|
||||
PURPOSE_SSH,
|
||||
PURPOSE_AGE,
|
||||
PURPOSE_FIPS,
|
||||
PURPOSE_UNKNOWN
|
||||
} role_purpose_t;
|
||||
|
||||
/* Curve enum */
|
||||
typedef enum {
|
||||
CURVE_SECP256K1 = 0,
|
||||
CURVE_ED25519,
|
||||
CURVE_X25519,
|
||||
CURVE_UNKNOWN
|
||||
} role_curve_t;
|
||||
|
||||
/* Selector type — how this role's key is addressed */
|
||||
typedef enum {
|
||||
SELECTOR_NOSTR_INDEX, /* uses nostr_index shorthand */
|
||||
SELECTOR_ROLE_PATH /* uses explicit full path */
|
||||
} role_selector_type_t;
|
||||
|
||||
/* A single role entry */
|
||||
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; /* valid if selector_type == SELECTOR_NOSTR_INDEX */
|
||||
char role_path[ROLE_PATH_MAX]; /* valid if selector_type == SELECTOR_ROLE_PATH */
|
||||
char pubkey_hex[ROLE_PUBKEY_HEX_MAX]; /* filled after derivation, empty until then */
|
||||
int derived; /* 1 if pubkey_hex has been populated */
|
||||
} role_entry_t;
|
||||
|
||||
/* The role table */
|
||||
typedef struct {
|
||||
role_entry_t entries[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} role_table_t;
|
||||
|
||||
/* Initialize an empty role table */
|
||||
void role_table_init(role_table_t *table);
|
||||
|
||||
/* Add a role entry. Returns 0 on success, -1 if table full, -2 if name duplicate. */
|
||||
int role_table_add(role_table_t *table, const role_entry_t *entry);
|
||||
|
||||
/* Find a role by name. Returns pointer to entry or NULL. */
|
||||
role_entry_t *role_table_find_by_name(role_table_t *table, const char *name);
|
||||
|
||||
/* Find a role by nostr_index. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_nostr_index(role_table_t *table, int index);
|
||||
|
||||
/* Find a role by role_path. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_path(role_table_t *table, const char *path);
|
||||
|
||||
/* Get the default role (named "main"). Returns pointer or NULL if no "main" role. */
|
||||
role_entry_t *role_table_get_default(role_table_t *table);
|
||||
|
||||
/* Parse purpose string to enum */
|
||||
role_purpose_t role_purpose_from_str(const char *s);
|
||||
|
||||
/* Parse curve string to enum */
|
||||
role_curve_t role_curve_from_str(const char *s);
|
||||
|
||||
/* Purpose enum to string */
|
||||
const char *role_purpose_to_str(role_purpose_t p);
|
||||
|
||||
/* Curve enum to string */
|
||||
const char *role_curve_to_str(role_curve_t c);
|
||||
|
||||
|
||||
/* from selector.h */
|
||||
|
||||
|
||||
/* Error codes for selector resolution */
|
||||
#define SELECTOR_OK 0
|
||||
#define SELECTOR_ERR_AMBIGUOUS -1 /* multiple selectors specified */
|
||||
#define SELECTOR_ERR_NOT_FOUND -2 /* no matching role in table */
|
||||
#define SELECTOR_ERR_NO_DEFAULT -3 /* no selector given and no "main" role exists */
|
||||
|
||||
/* Parsed selector from a request's options object */
|
||||
typedef struct {
|
||||
int has_role; /* 1 if "role" field was present */
|
||||
char role_name[ROLE_NAME_MAX];
|
||||
|
||||
int has_nostr_index; /* 1 if "nostr_index" field was present */
|
||||
int nostr_index;
|
||||
|
||||
int has_role_path; /* 1 if "role_path" field was present */
|
||||
char role_path[ROLE_PATH_MAX];
|
||||
} selector_request_t;
|
||||
|
||||
/* Initialize a selector request (all fields zeroed/unset) */
|
||||
void selector_request_init(selector_request_t *req);
|
||||
|
||||
/*
|
||||
* Resolve a selector request against the role table.
|
||||
* On success (returns SELECTOR_OK), *out points to the matched role_entry_t.
|
||||
* On failure, returns one of the SELECTOR_ERR_* codes and *out is NULL.
|
||||
*/
|
||||
int selector_resolve(const selector_request_t *req, role_table_t *table, role_entry_t **out);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for a selector error code.
|
||||
*/
|
||||
const char *selector_strerror(int err);
|
||||
|
||||
|
||||
/* from enforcement.h */
|
||||
|
||||
|
||||
/* Error codes */
|
||||
#define ENFORCE_OK 0
|
||||
#define ENFORCE_ERR_PURPOSE -1 /* purpose mismatch */
|
||||
#define ENFORCE_ERR_CURVE -2 /* curve mismatch */
|
||||
#define ENFORCE_ERR_UNKNOWN_VERB -3 /* verb not recognized */
|
||||
|
||||
/* Known verbs */
|
||||
#define VERB_SIGN_EVENT "sign_event"
|
||||
#define VERB_GET_PUBLIC_KEY "get_public_key"
|
||||
#define VERB_NIP44_ENCRYPT "nip44_encrypt"
|
||||
#define VERB_NIP44_DECRYPT "nip44_decrypt"
|
||||
#define VERB_NIP04_ENCRYPT "nip04_encrypt"
|
||||
#define VERB_NIP04_DECRYPT "nip04_decrypt"
|
||||
|
||||
/*
|
||||
* Check whether `verb` is allowed to execute against `role`.
|
||||
* Returns ENFORCE_OK if allowed, or an ENFORCE_ERR_* code.
|
||||
*
|
||||
* The enforcement rules are:
|
||||
* - All nostr verbs (sign_event, get_public_key, nip44_*, nip04_*) require:
|
||||
* purpose == PURPOSE_NOSTR and curve == CURVE_SECP256K1
|
||||
* - Unknown verbs return ENFORCE_ERR_UNKNOWN_VERB (fail-closed).
|
||||
*/
|
||||
int enforce_verb_role(const char *verb, const role_entry_t *role);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for an enforcement error code.
|
||||
*/
|
||||
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 64
|
||||
|
||||
/* Prompt behavior */
|
||||
typedef enum {
|
||||
PROMPT_NEVER = 0,
|
||||
PROMPT_FIRST_PER_BOOT,
|
||||
PROMPT_EVERY_REQUEST,
|
||||
PROMPT_DENY
|
||||
} prompt_mode_t;
|
||||
|
||||
/* A single policy entry */
|
||||
typedef struct {
|
||||
char caller[POLICY_CALLER_MAX_LEN]; /* e.g. "uid:1000" or "*" for any */
|
||||
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;
|
||||
prompt_mode_t prompt;
|
||||
} policy_entry_t;
|
||||
|
||||
/* Policy table */
|
||||
typedef struct {
|
||||
policy_entry_t entries[POLICY_MAX_ENTRIES];
|
||||
int count;
|
||||
} policy_table_t;
|
||||
|
||||
/* Policy check result */
|
||||
#define POLICY_ALLOW 0
|
||||
#define POLICY_DENY -1
|
||||
#define POLICY_PROMPT -2 /* would need user confirmation */
|
||||
#define POLICY_NO_MATCH -3 /* no policy entry matched (fail-closed = deny) */
|
||||
|
||||
/* Initialize policy table */
|
||||
void policy_table_init(policy_table_t *table);
|
||||
|
||||
/* Initialize default policy: allow same-uid, deny others */
|
||||
void policy_init_default(policy_table_t *table, uid_t owner_uid);
|
||||
|
||||
/* Add a policy entry. Returns 0 on success, -1 if full. */
|
||||
int policy_table_add(policy_table_t *table, const policy_entry_t *entry);
|
||||
|
||||
/*
|
||||
* Check whether caller_id is allowed to invoke `verb` on `role_name` with given `purpose`.
|
||||
* Returns POLICY_ALLOW, POLICY_DENY, POLICY_PROMPT, or POLICY_NO_MATCH.
|
||||
*/
|
||||
int policy_check(const policy_table_t *table, const char *caller_id,
|
||||
const char *verb, const char *role_name, const char *purpose);
|
||||
|
||||
/* Parse prompt mode from string */
|
||||
prompt_mode_t prompt_mode_from_str(const char *s);
|
||||
|
||||
/* Prompt mode to string */
|
||||
const char *prompt_mode_to_str(prompt_mode_t m);
|
||||
|
||||
|
||||
/* from crypto.h */
|
||||
|
||||
|
||||
/* Per-role derived key material (stored in secure memory) */
|
||||
typedef struct {
|
||||
secure_buf_t private_key; /* 32 bytes, mlock'd */
|
||||
unsigned char public_key[32];
|
||||
char pubkey_hex[65]; /* 64 hex chars + null */
|
||||
char npub[128]; /* bech32 npub */
|
||||
int valid;
|
||||
} derived_key_t;
|
||||
|
||||
/* Key store — holds derived keys for all roles */
|
||||
typedef struct {
|
||||
derived_key_t keys[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} key_store_t;
|
||||
|
||||
/* Derive keys for all roles in the table using the loaded mnemonic.
|
||||
* Populates key_store and sets role->pubkey_hex and role->derived for each role.
|
||||
* Only derives for roles with purpose=nostr and curve=secp256k1 (for now).
|
||||
* Returns number of keys derived, or -1 on error. */
|
||||
int crypto_derive_all(key_store_t *store, role_table_t *table, const mnemonic_state_t *mnemonic);
|
||||
|
||||
/* Get the derived private key for a role (by table index). Returns NULL if not derived. */
|
||||
const unsigned char *crypto_get_private_key(const key_store_t *store, int role_index);
|
||||
|
||||
/* Get the derived public key hex for a role. Returns NULL if not derived. */
|
||||
const char *crypto_get_pubkey_hex(const key_store_t *store, int role_index);
|
||||
|
||||
/* Sign a Nostr event. event_json is the unsigned event JSON string.
|
||||
* Returns a newly-allocated string containing the signed event JSON, or NULL on error.
|
||||
* Caller must free() the returned string. */
|
||||
char *crypto_sign_event(const key_store_t *store, int role_index, const char *event_json);
|
||||
|
||||
/* Zeroize all derived keys in the store. */
|
||||
void crypto_wipe(key_store_t *store);
|
||||
|
||||
|
||||
/* from dispatcher.h */
|
||||
|
||||
|
||||
/* Dispatcher context — holds references to shared state */
|
||||
typedef struct {
|
||||
role_table_t *role_table;
|
||||
mnemonic_state_t *mnemonic;
|
||||
key_store_t *key_store;
|
||||
} dispatcher_ctx_t;
|
||||
|
||||
/* Initialize dispatcher context */
|
||||
void dispatcher_init(dispatcher_ctx_t *ctx, role_table_t *table, mnemonic_state_t *mnemonic, key_store_t *key_store);
|
||||
|
||||
/*
|
||||
* Process a JSON-RPC request string and produce a JSON-RPC response string.
|
||||
*
|
||||
* The caller owns the returned string and must free() it.
|
||||
* Returns NULL only on catastrophic allocation failure.
|
||||
*
|
||||
* Response format on success:
|
||||
* { "id": "...", "result": "..." }
|
||||
*
|
||||
* Response format on error:
|
||||
* { "id": "...", "error": { "code": <int>, "message": "..." } }
|
||||
*
|
||||
* Error codes:
|
||||
* -32700 Parse error (invalid JSON)
|
||||
* -32600 Invalid request (missing id/method/params)
|
||||
* -32601 Method not found (unknown verb after enforcement)
|
||||
* -32602 Invalid params
|
||||
* 1001 ambiguous_role_selector
|
||||
* 1002 role_not_found
|
||||
* 1003 no_default_role
|
||||
* 1004 purpose_mismatch
|
||||
* 1005 curve_mismatch
|
||||
* 1006 mnemonic_not_loaded
|
||||
*/
|
||||
char *dispatcher_handle_request(dispatcher_ctx_t *ctx, const char *json_request);
|
||||
|
||||
|
||||
/* from server.h */
|
||||
|
||||
|
||||
#define SERVER_SOCKET_NAME_MAX 108
|
||||
#define SERVER_MAX_MSG_SIZE 65536
|
||||
|
||||
/* Caller identity */
|
||||
typedef struct {
|
||||
uid_t uid;
|
||||
gid_t gid;
|
||||
pid_t pid;
|
||||
char caller_id[64]; /* "uid:<n>" */
|
||||
} caller_identity_t;
|
||||
|
||||
/* Server context */
|
||||
typedef struct {
|
||||
char socket_name[SERVER_SOCKET_NAME_MAX]; /* abstract namespace name (without \0 prefix) */
|
||||
char last_error[256];
|
||||
int listen_fd;
|
||||
int running;
|
||||
dispatcher_ctx_t *dispatcher;
|
||||
policy_table_t *policy;
|
||||
int socket_name_explicit;
|
||||
} server_ctx_t;
|
||||
|
||||
/* Initialize server context. socket_name is the abstract namespace name (e.g. "nsigner").
|
||||
* socket_name_explicit should be non-zero when provided via --socket-name override. */
|
||||
void server_init(server_ctx_t *ctx, const char *socket_name, int socket_name_explicit,
|
||||
dispatcher_ctx_t *dispatcher, policy_table_t *policy);
|
||||
|
||||
/* Start listening. Returns 0 on success, -1 on error. */
|
||||
int server_start(server_ctx_t *ctx);
|
||||
|
||||
/* Get human-readable description of last server error. */
|
||||
const char *server_last_error(const server_ctx_t *ctx);
|
||||
|
||||
/* Handle one pending connection (non-blocking). Returns 1 if handled, 0 if nothing pending, -1 on error.
|
||||
* activity_cb is called with a description string for the TUI activity log. */
|
||||
typedef void (*server_activity_cb)(const char *message, void *user_data);
|
||||
int server_handle_one(server_ctx_t *ctx, server_activity_cb cb, void *cb_data);
|
||||
|
||||
/* Stop server and close socket */
|
||||
void server_stop(server_ctx_t *ctx);
|
||||
|
||||
/* Extract caller identity from connected fd */
|
||||
int server_get_caller(int fd, caller_identity_t *out);
|
||||
|
||||
|
||||
/* from socket_name.h */
|
||||
|
||||
|
||||
/*
|
||||
* Generate random socket name in format: nsigner_<word1>_<word2>
|
||||
* Returns 0 on success, -1 on error.
|
||||
*/
|
||||
int socket_name_random(char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from main.h */
|
||||
/*
|
||||
* nsigner main header - version information
|
||||
*
|
||||
* Version macros are auto-updated by increment_and_push.sh.
|
||||
*/
|
||||
|
||||
|
||||
/* Version information (auto-updated by build/version tooling) */
|
||||
#define NSIGNER_VERSION_MAJOR 0
|
||||
#define NSIGNER_VERSION_MINOR 0
|
||||
#define NSIGNER_VERSION_PATCH 2
|
||||
#define NSIGNER_VERSION "v0.0.2"
|
||||
|
||||
|
||||
/* NSIGNER_HEADERLESS_DECLS_END */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
@@ -1,25 +0,0 @@
|
||||
#ifndef NSIGNER_SECURE_MEM_H
|
||||
#define NSIGNER_SECURE_MEM_H
|
||||
|
||||
#include <stddef.h>
|
||||
|
||||
/*
|
||||
* Secure memory buffer — mlock'd, zeroized on free.
|
||||
* Used for mnemonic phrases, private keys, and any sensitive material.
|
||||
*/
|
||||
typedef struct {
|
||||
void *data; /* pointer to locked allocation */
|
||||
size_t size; /* usable size in bytes */
|
||||
int locked; /* 1 if mlock succeeded */
|
||||
} secure_buf_t;
|
||||
|
||||
/* Allocate a secure buffer of `size` bytes. Returns 0 on success, -1 on failure. */
|
||||
int secure_buf_alloc(secure_buf_t *buf, size_t size);
|
||||
|
||||
/* Zeroize and free a secure buffer. Always succeeds (idempotent). */
|
||||
void secure_buf_free(secure_buf_t *buf);
|
||||
|
||||
/* Zeroize `len` bytes at `ptr` in a way the compiler cannot optimize away. */
|
||||
void secure_memzero(void *ptr, size_t len);
|
||||
|
||||
#endif /* NSIGNER_SECURE_MEM_H */
|
||||
442
src/selector.c
442
src/selector.c
@@ -1,4 +1,444 @@
|
||||
#include "selector.h"
|
||||
/* NSIGNER_HEADERLESS_DECLS_BEGIN */
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
#include <cJSON.h>
|
||||
|
||||
/* from secure_mem.h */
|
||||
|
||||
|
||||
/*
|
||||
* Secure memory buffer — mlock'd, zeroized on free.
|
||||
* Used for mnemonic phrases, private keys, and any sensitive material.
|
||||
*/
|
||||
typedef struct {
|
||||
void *data; /* pointer to locked allocation */
|
||||
size_t size; /* usable size in bytes */
|
||||
int locked; /* 1 if mlock succeeded */
|
||||
} secure_buf_t;
|
||||
|
||||
/* Allocate a secure buffer of `size` bytes. Returns 0 on success, -1 on failure. */
|
||||
int secure_buf_alloc(secure_buf_t *buf, size_t size);
|
||||
|
||||
/* Zeroize and free a secure buffer. Always succeeds (idempotent). */
|
||||
void secure_buf_free(secure_buf_t *buf);
|
||||
|
||||
/* Zeroize `len` bytes at `ptr` in a way the compiler cannot optimize away. */
|
||||
void secure_memzero(void *ptr, size_t len);
|
||||
|
||||
|
||||
/* from mnemonic.h */
|
||||
|
||||
|
||||
/* Maximum mnemonic length: 24 words * 10 chars avg + spaces + null = 256 is safe */
|
||||
#define MNEMONIC_MAX_LEN 256
|
||||
|
||||
/*
|
||||
* Mnemonic state — holds the loaded mnemonic in secure memory.
|
||||
* Only one mnemonic is active at a time per process.
|
||||
*/
|
||||
typedef struct {
|
||||
secure_buf_t buf; /* secure storage for the mnemonic string */
|
||||
int loaded; /* 1 if a mnemonic is currently loaded */
|
||||
int word_count; /* 12, 15, 18, 21, or 24 */
|
||||
} mnemonic_state_t;
|
||||
|
||||
/* Initialize mnemonic state (must be called before use). */
|
||||
void mnemonic_init(mnemonic_state_t *state);
|
||||
|
||||
/* Load a mnemonic string into secure memory. Validates word count (12/15/18/21/24).
|
||||
* Returns 0 on success, -1 on invalid input, -2 on memory error. */
|
||||
int mnemonic_load(mnemonic_state_t *state, const char *phrase);
|
||||
|
||||
/* Zeroize and unload the mnemonic. Idempotent. */
|
||||
void mnemonic_unload(mnemonic_state_t *state);
|
||||
|
||||
/* Check if a mnemonic is currently loaded. */
|
||||
int mnemonic_is_loaded(const mnemonic_state_t *state);
|
||||
|
||||
/* Get the mnemonic string (only valid while loaded). Returns NULL if not loaded. */
|
||||
const char *mnemonic_get_phrase(const mnemonic_state_t *state);
|
||||
|
||||
/* Generate a new BIP-39 mnemonic phrase (12/15/18/21/24 words) into out.
|
||||
* Returns 0 on success, -1 on invalid arguments or generation failure. */
|
||||
int mnemonic_generate(int word_count, char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from role_table.h */
|
||||
|
||||
|
||||
/* Maximum limits */
|
||||
#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 /* 64 hex chars + null + pad */
|
||||
#define ROLE_TABLE_MAX_ENTRIES 64
|
||||
|
||||
/* Purpose enum for fast comparison (string form kept for config/display) */
|
||||
typedef enum {
|
||||
PURPOSE_NOSTR = 0,
|
||||
PURPOSE_BITCOIN,
|
||||
PURPOSE_SSH,
|
||||
PURPOSE_AGE,
|
||||
PURPOSE_FIPS,
|
||||
PURPOSE_UNKNOWN
|
||||
} role_purpose_t;
|
||||
|
||||
/* Curve enum */
|
||||
typedef enum {
|
||||
CURVE_SECP256K1 = 0,
|
||||
CURVE_ED25519,
|
||||
CURVE_X25519,
|
||||
CURVE_UNKNOWN
|
||||
} role_curve_t;
|
||||
|
||||
/* Selector type — how this role's key is addressed */
|
||||
typedef enum {
|
||||
SELECTOR_NOSTR_INDEX, /* uses nostr_index shorthand */
|
||||
SELECTOR_ROLE_PATH /* uses explicit full path */
|
||||
} role_selector_type_t;
|
||||
|
||||
/* A single role entry */
|
||||
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; /* valid if selector_type == SELECTOR_NOSTR_INDEX */
|
||||
char role_path[ROLE_PATH_MAX]; /* valid if selector_type == SELECTOR_ROLE_PATH */
|
||||
char pubkey_hex[ROLE_PUBKEY_HEX_MAX]; /* filled after derivation, empty until then */
|
||||
int derived; /* 1 if pubkey_hex has been populated */
|
||||
} role_entry_t;
|
||||
|
||||
/* The role table */
|
||||
typedef struct {
|
||||
role_entry_t entries[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} role_table_t;
|
||||
|
||||
/* Initialize an empty role table */
|
||||
void role_table_init(role_table_t *table);
|
||||
|
||||
/* Add a role entry. Returns 0 on success, -1 if table full, -2 if name duplicate. */
|
||||
int role_table_add(role_table_t *table, const role_entry_t *entry);
|
||||
|
||||
/* Find a role by name. Returns pointer to entry or NULL. */
|
||||
role_entry_t *role_table_find_by_name(role_table_t *table, const char *name);
|
||||
|
||||
/* Find a role by nostr_index. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_nostr_index(role_table_t *table, int index);
|
||||
|
||||
/* Find a role by role_path. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_path(role_table_t *table, const char *path);
|
||||
|
||||
/* Get the default role (named "main"). Returns pointer or NULL if no "main" role. */
|
||||
role_entry_t *role_table_get_default(role_table_t *table);
|
||||
|
||||
/* Parse purpose string to enum */
|
||||
role_purpose_t role_purpose_from_str(const char *s);
|
||||
|
||||
/* Parse curve string to enum */
|
||||
role_curve_t role_curve_from_str(const char *s);
|
||||
|
||||
/* Purpose enum to string */
|
||||
const char *role_purpose_to_str(role_purpose_t p);
|
||||
|
||||
/* Curve enum to string */
|
||||
const char *role_curve_to_str(role_curve_t c);
|
||||
|
||||
|
||||
/* from selector.h */
|
||||
|
||||
|
||||
/* Error codes for selector resolution */
|
||||
#define SELECTOR_OK 0
|
||||
#define SELECTOR_ERR_AMBIGUOUS -1 /* multiple selectors specified */
|
||||
#define SELECTOR_ERR_NOT_FOUND -2 /* no matching role in table */
|
||||
#define SELECTOR_ERR_NO_DEFAULT -3 /* no selector given and no "main" role exists */
|
||||
|
||||
/* Parsed selector from a request's options object */
|
||||
typedef struct {
|
||||
int has_role; /* 1 if "role" field was present */
|
||||
char role_name[ROLE_NAME_MAX];
|
||||
|
||||
int has_nostr_index; /* 1 if "nostr_index" field was present */
|
||||
int nostr_index;
|
||||
|
||||
int has_role_path; /* 1 if "role_path" field was present */
|
||||
char role_path[ROLE_PATH_MAX];
|
||||
} selector_request_t;
|
||||
|
||||
/* Initialize a selector request (all fields zeroed/unset) */
|
||||
void selector_request_init(selector_request_t *req);
|
||||
|
||||
/*
|
||||
* Resolve a selector request against the role table.
|
||||
* On success (returns SELECTOR_OK), *out points to the matched role_entry_t.
|
||||
* On failure, returns one of the SELECTOR_ERR_* codes and *out is NULL.
|
||||
*/
|
||||
int selector_resolve(const selector_request_t *req, role_table_t *table, role_entry_t **out);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for a selector error code.
|
||||
*/
|
||||
const char *selector_strerror(int err);
|
||||
|
||||
|
||||
/* from enforcement.h */
|
||||
|
||||
|
||||
/* Error codes */
|
||||
#define ENFORCE_OK 0
|
||||
#define ENFORCE_ERR_PURPOSE -1 /* purpose mismatch */
|
||||
#define ENFORCE_ERR_CURVE -2 /* curve mismatch */
|
||||
#define ENFORCE_ERR_UNKNOWN_VERB -3 /* verb not recognized */
|
||||
|
||||
/* Known verbs */
|
||||
#define VERB_SIGN_EVENT "sign_event"
|
||||
#define VERB_GET_PUBLIC_KEY "get_public_key"
|
||||
#define VERB_NIP44_ENCRYPT "nip44_encrypt"
|
||||
#define VERB_NIP44_DECRYPT "nip44_decrypt"
|
||||
#define VERB_NIP04_ENCRYPT "nip04_encrypt"
|
||||
#define VERB_NIP04_DECRYPT "nip04_decrypt"
|
||||
|
||||
/*
|
||||
* Check whether `verb` is allowed to execute against `role`.
|
||||
* Returns ENFORCE_OK if allowed, or an ENFORCE_ERR_* code.
|
||||
*
|
||||
* The enforcement rules are:
|
||||
* - All nostr verbs (sign_event, get_public_key, nip44_*, nip04_*) require:
|
||||
* purpose == PURPOSE_NOSTR and curve == CURVE_SECP256K1
|
||||
* - Unknown verbs return ENFORCE_ERR_UNKNOWN_VERB (fail-closed).
|
||||
*/
|
||||
int enforce_verb_role(const char *verb, const role_entry_t *role);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for an enforcement error code.
|
||||
*/
|
||||
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 64
|
||||
|
||||
/* Prompt behavior */
|
||||
typedef enum {
|
||||
PROMPT_NEVER = 0,
|
||||
PROMPT_FIRST_PER_BOOT,
|
||||
PROMPT_EVERY_REQUEST,
|
||||
PROMPT_DENY
|
||||
} prompt_mode_t;
|
||||
|
||||
/* A single policy entry */
|
||||
typedef struct {
|
||||
char caller[POLICY_CALLER_MAX_LEN]; /* e.g. "uid:1000" or "*" for any */
|
||||
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;
|
||||
prompt_mode_t prompt;
|
||||
} policy_entry_t;
|
||||
|
||||
/* Policy table */
|
||||
typedef struct {
|
||||
policy_entry_t entries[POLICY_MAX_ENTRIES];
|
||||
int count;
|
||||
} policy_table_t;
|
||||
|
||||
/* Policy check result */
|
||||
#define POLICY_ALLOW 0
|
||||
#define POLICY_DENY -1
|
||||
#define POLICY_PROMPT -2 /* would need user confirmation */
|
||||
#define POLICY_NO_MATCH -3 /* no policy entry matched (fail-closed = deny) */
|
||||
|
||||
/* Initialize policy table */
|
||||
void policy_table_init(policy_table_t *table);
|
||||
|
||||
/* Initialize default policy: allow same-uid, deny others */
|
||||
void policy_init_default(policy_table_t *table, uid_t owner_uid);
|
||||
|
||||
/* Add a policy entry. Returns 0 on success, -1 if full. */
|
||||
int policy_table_add(policy_table_t *table, const policy_entry_t *entry);
|
||||
|
||||
/*
|
||||
* Check whether caller_id is allowed to invoke `verb` on `role_name` with given `purpose`.
|
||||
* Returns POLICY_ALLOW, POLICY_DENY, POLICY_PROMPT, or POLICY_NO_MATCH.
|
||||
*/
|
||||
int policy_check(const policy_table_t *table, const char *caller_id,
|
||||
const char *verb, const char *role_name, const char *purpose);
|
||||
|
||||
/* Parse prompt mode from string */
|
||||
prompt_mode_t prompt_mode_from_str(const char *s);
|
||||
|
||||
/* Prompt mode to string */
|
||||
const char *prompt_mode_to_str(prompt_mode_t m);
|
||||
|
||||
|
||||
/* from crypto.h */
|
||||
|
||||
|
||||
/* Per-role derived key material (stored in secure memory) */
|
||||
typedef struct {
|
||||
secure_buf_t private_key; /* 32 bytes, mlock'd */
|
||||
unsigned char public_key[32];
|
||||
char pubkey_hex[65]; /* 64 hex chars + null */
|
||||
char npub[128]; /* bech32 npub */
|
||||
int valid;
|
||||
} derived_key_t;
|
||||
|
||||
/* Key store — holds derived keys for all roles */
|
||||
typedef struct {
|
||||
derived_key_t keys[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} key_store_t;
|
||||
|
||||
/* Derive keys for all roles in the table using the loaded mnemonic.
|
||||
* Populates key_store and sets role->pubkey_hex and role->derived for each role.
|
||||
* Only derives for roles with purpose=nostr and curve=secp256k1 (for now).
|
||||
* Returns number of keys derived, or -1 on error. */
|
||||
int crypto_derive_all(key_store_t *store, role_table_t *table, const mnemonic_state_t *mnemonic);
|
||||
|
||||
/* Get the derived private key for a role (by table index). Returns NULL if not derived. */
|
||||
const unsigned char *crypto_get_private_key(const key_store_t *store, int role_index);
|
||||
|
||||
/* Get the derived public key hex for a role. Returns NULL if not derived. */
|
||||
const char *crypto_get_pubkey_hex(const key_store_t *store, int role_index);
|
||||
|
||||
/* Sign a Nostr event. event_json is the unsigned event JSON string.
|
||||
* Returns a newly-allocated string containing the signed event JSON, or NULL on error.
|
||||
* Caller must free() the returned string. */
|
||||
char *crypto_sign_event(const key_store_t *store, int role_index, const char *event_json);
|
||||
|
||||
/* Zeroize all derived keys in the store. */
|
||||
void crypto_wipe(key_store_t *store);
|
||||
|
||||
|
||||
/* from dispatcher.h */
|
||||
|
||||
|
||||
/* Dispatcher context — holds references to shared state */
|
||||
typedef struct {
|
||||
role_table_t *role_table;
|
||||
mnemonic_state_t *mnemonic;
|
||||
key_store_t *key_store;
|
||||
} dispatcher_ctx_t;
|
||||
|
||||
/* Initialize dispatcher context */
|
||||
void dispatcher_init(dispatcher_ctx_t *ctx, role_table_t *table, mnemonic_state_t *mnemonic, key_store_t *key_store);
|
||||
|
||||
/*
|
||||
* Process a JSON-RPC request string and produce a JSON-RPC response string.
|
||||
*
|
||||
* The caller owns the returned string and must free() it.
|
||||
* Returns NULL only on catastrophic allocation failure.
|
||||
*
|
||||
* Response format on success:
|
||||
* { "id": "...", "result": "..." }
|
||||
*
|
||||
* Response format on error:
|
||||
* { "id": "...", "error": { "code": <int>, "message": "..." } }
|
||||
*
|
||||
* Error codes:
|
||||
* -32700 Parse error (invalid JSON)
|
||||
* -32600 Invalid request (missing id/method/params)
|
||||
* -32601 Method not found (unknown verb after enforcement)
|
||||
* -32602 Invalid params
|
||||
* 1001 ambiguous_role_selector
|
||||
* 1002 role_not_found
|
||||
* 1003 no_default_role
|
||||
* 1004 purpose_mismatch
|
||||
* 1005 curve_mismatch
|
||||
* 1006 mnemonic_not_loaded
|
||||
*/
|
||||
char *dispatcher_handle_request(dispatcher_ctx_t *ctx, const char *json_request);
|
||||
|
||||
|
||||
/* from server.h */
|
||||
|
||||
|
||||
#define SERVER_SOCKET_NAME_MAX 108
|
||||
#define SERVER_MAX_MSG_SIZE 65536
|
||||
|
||||
/* Caller identity */
|
||||
typedef struct {
|
||||
uid_t uid;
|
||||
gid_t gid;
|
||||
pid_t pid;
|
||||
char caller_id[64]; /* "uid:<n>" */
|
||||
} caller_identity_t;
|
||||
|
||||
/* Server context */
|
||||
typedef struct {
|
||||
char socket_name[SERVER_SOCKET_NAME_MAX]; /* abstract namespace name (without \0 prefix) */
|
||||
char last_error[256];
|
||||
int listen_fd;
|
||||
int running;
|
||||
dispatcher_ctx_t *dispatcher;
|
||||
policy_table_t *policy;
|
||||
int socket_name_explicit;
|
||||
} server_ctx_t;
|
||||
|
||||
/* Initialize server context. socket_name is the abstract namespace name (e.g. "nsigner").
|
||||
* socket_name_explicit should be non-zero when provided via --socket-name override. */
|
||||
void server_init(server_ctx_t *ctx, const char *socket_name, int socket_name_explicit,
|
||||
dispatcher_ctx_t *dispatcher, policy_table_t *policy);
|
||||
|
||||
/* Start listening. Returns 0 on success, -1 on error. */
|
||||
int server_start(server_ctx_t *ctx);
|
||||
|
||||
/* Get human-readable description of last server error. */
|
||||
const char *server_last_error(const server_ctx_t *ctx);
|
||||
|
||||
/* Handle one pending connection (non-blocking). Returns 1 if handled, 0 if nothing pending, -1 on error.
|
||||
* activity_cb is called with a description string for the TUI activity log. */
|
||||
typedef void (*server_activity_cb)(const char *message, void *user_data);
|
||||
int server_handle_one(server_ctx_t *ctx, server_activity_cb cb, void *cb_data);
|
||||
|
||||
/* Stop server and close socket */
|
||||
void server_stop(server_ctx_t *ctx);
|
||||
|
||||
/* Extract caller identity from connected fd */
|
||||
int server_get_caller(int fd, caller_identity_t *out);
|
||||
|
||||
|
||||
/* from socket_name.h */
|
||||
|
||||
|
||||
/*
|
||||
* Generate random socket name in format: nsigner_<word1>_<word2>
|
||||
* Returns 0 on success, -1 on error.
|
||||
*/
|
||||
int socket_name_random(char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from main.h */
|
||||
/*
|
||||
* nsigner main header - version information
|
||||
*
|
||||
* Version macros are auto-updated by increment_and_push.sh.
|
||||
*/
|
||||
|
||||
|
||||
/* Version information (auto-updated by build/version tooling) */
|
||||
#define NSIGNER_VERSION_MAJOR 0
|
||||
#define NSIGNER_VERSION_MINOR 0
|
||||
#define NSIGNER_VERSION_PATCH 2
|
||||
#define NSIGNER_VERSION "v0.0.2"
|
||||
|
||||
|
||||
/* NSIGNER_HEADERLESS_DECLS_END */
|
||||
|
||||
#include <string.h>
|
||||
|
||||
|
||||
@@ -1,39 +0,0 @@
|
||||
#ifndef NSIGNER_SELECTOR_H
|
||||
#define NSIGNER_SELECTOR_H
|
||||
|
||||
#include "role_table.h"
|
||||
|
||||
/* Error codes for selector resolution */
|
||||
#define SELECTOR_OK 0
|
||||
#define SELECTOR_ERR_AMBIGUOUS -1 /* multiple selectors specified */
|
||||
#define SELECTOR_ERR_NOT_FOUND -2 /* no matching role in table */
|
||||
#define SELECTOR_ERR_NO_DEFAULT -3 /* no selector given and no "main" role exists */
|
||||
|
||||
/* Parsed selector from a request's options object */
|
||||
typedef struct {
|
||||
int has_role; /* 1 if "role" field was present */
|
||||
char role_name[ROLE_NAME_MAX];
|
||||
|
||||
int has_nostr_index; /* 1 if "nostr_index" field was present */
|
||||
int nostr_index;
|
||||
|
||||
int has_role_path; /* 1 if "role_path" field was present */
|
||||
char role_path[ROLE_PATH_MAX];
|
||||
} selector_request_t;
|
||||
|
||||
/* Initialize a selector request (all fields zeroed/unset) */
|
||||
void selector_request_init(selector_request_t *req);
|
||||
|
||||
/*
|
||||
* Resolve a selector request against the role table.
|
||||
* On success (returns SELECTOR_OK), *out points to the matched role_entry_t.
|
||||
* On failure, returns one of the SELECTOR_ERR_* codes and *out is NULL.
|
||||
*/
|
||||
int selector_resolve(const selector_request_t *req, role_table_t *table, role_entry_t **out);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for a selector error code.
|
||||
*/
|
||||
const char *selector_strerror(int err);
|
||||
|
||||
#endif /* NSIGNER_SELECTOR_H */
|
||||
446
src/server.c
446
src/server.c
@@ -1,10 +1,446 @@
|
||||
#define _GNU_SOURCE
|
||||
#include "server.h"
|
||||
|
||||
#include "enforcement.h"
|
||||
#include "selector.h"
|
||||
#include "cjson/cJSON.h"
|
||||
#include "socket_name.h"
|
||||
/* NSIGNER_HEADERLESS_DECLS_BEGIN */
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
#include <cJSON.h>
|
||||
|
||||
/* from secure_mem.h */
|
||||
|
||||
|
||||
/*
|
||||
* Secure memory buffer — mlock'd, zeroized on free.
|
||||
* Used for mnemonic phrases, private keys, and any sensitive material.
|
||||
*/
|
||||
typedef struct {
|
||||
void *data; /* pointer to locked allocation */
|
||||
size_t size; /* usable size in bytes */
|
||||
int locked; /* 1 if mlock succeeded */
|
||||
} secure_buf_t;
|
||||
|
||||
/* Allocate a secure buffer of `size` bytes. Returns 0 on success, -1 on failure. */
|
||||
int secure_buf_alloc(secure_buf_t *buf, size_t size);
|
||||
|
||||
/* Zeroize and free a secure buffer. Always succeeds (idempotent). */
|
||||
void secure_buf_free(secure_buf_t *buf);
|
||||
|
||||
/* Zeroize `len` bytes at `ptr` in a way the compiler cannot optimize away. */
|
||||
void secure_memzero(void *ptr, size_t len);
|
||||
|
||||
|
||||
/* from mnemonic.h */
|
||||
|
||||
|
||||
/* Maximum mnemonic length: 24 words * 10 chars avg + spaces + null = 256 is safe */
|
||||
#define MNEMONIC_MAX_LEN 256
|
||||
|
||||
/*
|
||||
* Mnemonic state — holds the loaded mnemonic in secure memory.
|
||||
* Only one mnemonic is active at a time per process.
|
||||
*/
|
||||
typedef struct {
|
||||
secure_buf_t buf; /* secure storage for the mnemonic string */
|
||||
int loaded; /* 1 if a mnemonic is currently loaded */
|
||||
int word_count; /* 12, 15, 18, 21, or 24 */
|
||||
} mnemonic_state_t;
|
||||
|
||||
/* Initialize mnemonic state (must be called before use). */
|
||||
void mnemonic_init(mnemonic_state_t *state);
|
||||
|
||||
/* Load a mnemonic string into secure memory. Validates word count (12/15/18/21/24).
|
||||
* Returns 0 on success, -1 on invalid input, -2 on memory error. */
|
||||
int mnemonic_load(mnemonic_state_t *state, const char *phrase);
|
||||
|
||||
/* Zeroize and unload the mnemonic. Idempotent. */
|
||||
void mnemonic_unload(mnemonic_state_t *state);
|
||||
|
||||
/* Check if a mnemonic is currently loaded. */
|
||||
int mnemonic_is_loaded(const mnemonic_state_t *state);
|
||||
|
||||
/* Get the mnemonic string (only valid while loaded). Returns NULL if not loaded. */
|
||||
const char *mnemonic_get_phrase(const mnemonic_state_t *state);
|
||||
|
||||
/* Generate a new BIP-39 mnemonic phrase (12/15/18/21/24 words) into out.
|
||||
* Returns 0 on success, -1 on invalid arguments or generation failure. */
|
||||
int mnemonic_generate(int word_count, char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from role_table.h */
|
||||
|
||||
|
||||
/* Maximum limits */
|
||||
#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 /* 64 hex chars + null + pad */
|
||||
#define ROLE_TABLE_MAX_ENTRIES 64
|
||||
|
||||
/* Purpose enum for fast comparison (string form kept for config/display) */
|
||||
typedef enum {
|
||||
PURPOSE_NOSTR = 0,
|
||||
PURPOSE_BITCOIN,
|
||||
PURPOSE_SSH,
|
||||
PURPOSE_AGE,
|
||||
PURPOSE_FIPS,
|
||||
PURPOSE_UNKNOWN
|
||||
} role_purpose_t;
|
||||
|
||||
/* Curve enum */
|
||||
typedef enum {
|
||||
CURVE_SECP256K1 = 0,
|
||||
CURVE_ED25519,
|
||||
CURVE_X25519,
|
||||
CURVE_UNKNOWN
|
||||
} role_curve_t;
|
||||
|
||||
/* Selector type — how this role's key is addressed */
|
||||
typedef enum {
|
||||
SELECTOR_NOSTR_INDEX, /* uses nostr_index shorthand */
|
||||
SELECTOR_ROLE_PATH /* uses explicit full path */
|
||||
} role_selector_type_t;
|
||||
|
||||
/* A single role entry */
|
||||
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; /* valid if selector_type == SELECTOR_NOSTR_INDEX */
|
||||
char role_path[ROLE_PATH_MAX]; /* valid if selector_type == SELECTOR_ROLE_PATH */
|
||||
char pubkey_hex[ROLE_PUBKEY_HEX_MAX]; /* filled after derivation, empty until then */
|
||||
int derived; /* 1 if pubkey_hex has been populated */
|
||||
} role_entry_t;
|
||||
|
||||
/* The role table */
|
||||
typedef struct {
|
||||
role_entry_t entries[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} role_table_t;
|
||||
|
||||
/* Initialize an empty role table */
|
||||
void role_table_init(role_table_t *table);
|
||||
|
||||
/* Add a role entry. Returns 0 on success, -1 if table full, -2 if name duplicate. */
|
||||
int role_table_add(role_table_t *table, const role_entry_t *entry);
|
||||
|
||||
/* Find a role by name. Returns pointer to entry or NULL. */
|
||||
role_entry_t *role_table_find_by_name(role_table_t *table, const char *name);
|
||||
|
||||
/* Find a role by nostr_index. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_nostr_index(role_table_t *table, int index);
|
||||
|
||||
/* Find a role by role_path. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_path(role_table_t *table, const char *path);
|
||||
|
||||
/* Get the default role (named "main"). Returns pointer or NULL if no "main" role. */
|
||||
role_entry_t *role_table_get_default(role_table_t *table);
|
||||
|
||||
/* Parse purpose string to enum */
|
||||
role_purpose_t role_purpose_from_str(const char *s);
|
||||
|
||||
/* Parse curve string to enum */
|
||||
role_curve_t role_curve_from_str(const char *s);
|
||||
|
||||
/* Purpose enum to string */
|
||||
const char *role_purpose_to_str(role_purpose_t p);
|
||||
|
||||
/* Curve enum to string */
|
||||
const char *role_curve_to_str(role_curve_t c);
|
||||
|
||||
|
||||
/* from selector.h */
|
||||
|
||||
|
||||
/* Error codes for selector resolution */
|
||||
#define SELECTOR_OK 0
|
||||
#define SELECTOR_ERR_AMBIGUOUS -1 /* multiple selectors specified */
|
||||
#define SELECTOR_ERR_NOT_FOUND -2 /* no matching role in table */
|
||||
#define SELECTOR_ERR_NO_DEFAULT -3 /* no selector given and no "main" role exists */
|
||||
|
||||
/* Parsed selector from a request's options object */
|
||||
typedef struct {
|
||||
int has_role; /* 1 if "role" field was present */
|
||||
char role_name[ROLE_NAME_MAX];
|
||||
|
||||
int has_nostr_index; /* 1 if "nostr_index" field was present */
|
||||
int nostr_index;
|
||||
|
||||
int has_role_path; /* 1 if "role_path" field was present */
|
||||
char role_path[ROLE_PATH_MAX];
|
||||
} selector_request_t;
|
||||
|
||||
/* Initialize a selector request (all fields zeroed/unset) */
|
||||
void selector_request_init(selector_request_t *req);
|
||||
|
||||
/*
|
||||
* Resolve a selector request against the role table.
|
||||
* On success (returns SELECTOR_OK), *out points to the matched role_entry_t.
|
||||
* On failure, returns one of the SELECTOR_ERR_* codes and *out is NULL.
|
||||
*/
|
||||
int selector_resolve(const selector_request_t *req, role_table_t *table, role_entry_t **out);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for a selector error code.
|
||||
*/
|
||||
const char *selector_strerror(int err);
|
||||
|
||||
|
||||
/* from enforcement.h */
|
||||
|
||||
|
||||
/* Error codes */
|
||||
#define ENFORCE_OK 0
|
||||
#define ENFORCE_ERR_PURPOSE -1 /* purpose mismatch */
|
||||
#define ENFORCE_ERR_CURVE -2 /* curve mismatch */
|
||||
#define ENFORCE_ERR_UNKNOWN_VERB -3 /* verb not recognized */
|
||||
|
||||
/* Known verbs */
|
||||
#define VERB_SIGN_EVENT "sign_event"
|
||||
#define VERB_GET_PUBLIC_KEY "get_public_key"
|
||||
#define VERB_NIP44_ENCRYPT "nip44_encrypt"
|
||||
#define VERB_NIP44_DECRYPT "nip44_decrypt"
|
||||
#define VERB_NIP04_ENCRYPT "nip04_encrypt"
|
||||
#define VERB_NIP04_DECRYPT "nip04_decrypt"
|
||||
|
||||
/*
|
||||
* Check whether `verb` is allowed to execute against `role`.
|
||||
* Returns ENFORCE_OK if allowed, or an ENFORCE_ERR_* code.
|
||||
*
|
||||
* The enforcement rules are:
|
||||
* - All nostr verbs (sign_event, get_public_key, nip44_*, nip04_*) require:
|
||||
* purpose == PURPOSE_NOSTR and curve == CURVE_SECP256K1
|
||||
* - Unknown verbs return ENFORCE_ERR_UNKNOWN_VERB (fail-closed).
|
||||
*/
|
||||
int enforce_verb_role(const char *verb, const role_entry_t *role);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for an enforcement error code.
|
||||
*/
|
||||
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 64
|
||||
|
||||
/* Prompt behavior */
|
||||
typedef enum {
|
||||
PROMPT_NEVER = 0,
|
||||
PROMPT_FIRST_PER_BOOT,
|
||||
PROMPT_EVERY_REQUEST,
|
||||
PROMPT_DENY
|
||||
} prompt_mode_t;
|
||||
|
||||
/* A single policy entry */
|
||||
typedef struct {
|
||||
char caller[POLICY_CALLER_MAX_LEN]; /* e.g. "uid:1000" or "*" for any */
|
||||
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;
|
||||
prompt_mode_t prompt;
|
||||
} policy_entry_t;
|
||||
|
||||
/* Policy table */
|
||||
typedef struct {
|
||||
policy_entry_t entries[POLICY_MAX_ENTRIES];
|
||||
int count;
|
||||
} policy_table_t;
|
||||
|
||||
/* Policy check result */
|
||||
#define POLICY_ALLOW 0
|
||||
#define POLICY_DENY -1
|
||||
#define POLICY_PROMPT -2 /* would need user confirmation */
|
||||
#define POLICY_NO_MATCH -3 /* no policy entry matched (fail-closed = deny) */
|
||||
|
||||
/* Initialize policy table */
|
||||
void policy_table_init(policy_table_t *table);
|
||||
|
||||
/* Initialize default policy: allow same-uid, deny others */
|
||||
void policy_init_default(policy_table_t *table, uid_t owner_uid);
|
||||
|
||||
/* Add a policy entry. Returns 0 on success, -1 if full. */
|
||||
int policy_table_add(policy_table_t *table, const policy_entry_t *entry);
|
||||
|
||||
/*
|
||||
* Check whether caller_id is allowed to invoke `verb` on `role_name` with given `purpose`.
|
||||
* Returns POLICY_ALLOW, POLICY_DENY, POLICY_PROMPT, or POLICY_NO_MATCH.
|
||||
*/
|
||||
int policy_check(const policy_table_t *table, const char *caller_id,
|
||||
const char *verb, const char *role_name, const char *purpose);
|
||||
|
||||
/* Parse prompt mode from string */
|
||||
prompt_mode_t prompt_mode_from_str(const char *s);
|
||||
|
||||
/* Prompt mode to string */
|
||||
const char *prompt_mode_to_str(prompt_mode_t m);
|
||||
|
||||
|
||||
/* from crypto.h */
|
||||
|
||||
|
||||
/* Per-role derived key material (stored in secure memory) */
|
||||
typedef struct {
|
||||
secure_buf_t private_key; /* 32 bytes, mlock'd */
|
||||
unsigned char public_key[32];
|
||||
char pubkey_hex[65]; /* 64 hex chars + null */
|
||||
char npub[128]; /* bech32 npub */
|
||||
int valid;
|
||||
} derived_key_t;
|
||||
|
||||
/* Key store — holds derived keys for all roles */
|
||||
typedef struct {
|
||||
derived_key_t keys[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} key_store_t;
|
||||
|
||||
/* Derive keys for all roles in the table using the loaded mnemonic.
|
||||
* Populates key_store and sets role->pubkey_hex and role->derived for each role.
|
||||
* Only derives for roles with purpose=nostr and curve=secp256k1 (for now).
|
||||
* Returns number of keys derived, or -1 on error. */
|
||||
int crypto_derive_all(key_store_t *store, role_table_t *table, const mnemonic_state_t *mnemonic);
|
||||
|
||||
/* Get the derived private key for a role (by table index). Returns NULL if not derived. */
|
||||
const unsigned char *crypto_get_private_key(const key_store_t *store, int role_index);
|
||||
|
||||
/* Get the derived public key hex for a role. Returns NULL if not derived. */
|
||||
const char *crypto_get_pubkey_hex(const key_store_t *store, int role_index);
|
||||
|
||||
/* Sign a Nostr event. event_json is the unsigned event JSON string.
|
||||
* Returns a newly-allocated string containing the signed event JSON, or NULL on error.
|
||||
* Caller must free() the returned string. */
|
||||
char *crypto_sign_event(const key_store_t *store, int role_index, const char *event_json);
|
||||
|
||||
/* Zeroize all derived keys in the store. */
|
||||
void crypto_wipe(key_store_t *store);
|
||||
|
||||
|
||||
/* from dispatcher.h */
|
||||
|
||||
|
||||
/* Dispatcher context — holds references to shared state */
|
||||
typedef struct {
|
||||
role_table_t *role_table;
|
||||
mnemonic_state_t *mnemonic;
|
||||
key_store_t *key_store;
|
||||
} dispatcher_ctx_t;
|
||||
|
||||
/* Initialize dispatcher context */
|
||||
void dispatcher_init(dispatcher_ctx_t *ctx, role_table_t *table, mnemonic_state_t *mnemonic, key_store_t *key_store);
|
||||
|
||||
/*
|
||||
* Process a JSON-RPC request string and produce a JSON-RPC response string.
|
||||
*
|
||||
* The caller owns the returned string and must free() it.
|
||||
* Returns NULL only on catastrophic allocation failure.
|
||||
*
|
||||
* Response format on success:
|
||||
* { "id": "...", "result": "..." }
|
||||
*
|
||||
* Response format on error:
|
||||
* { "id": "...", "error": { "code": <int>, "message": "..." } }
|
||||
*
|
||||
* Error codes:
|
||||
* -32700 Parse error (invalid JSON)
|
||||
* -32600 Invalid request (missing id/method/params)
|
||||
* -32601 Method not found (unknown verb after enforcement)
|
||||
* -32602 Invalid params
|
||||
* 1001 ambiguous_role_selector
|
||||
* 1002 role_not_found
|
||||
* 1003 no_default_role
|
||||
* 1004 purpose_mismatch
|
||||
* 1005 curve_mismatch
|
||||
* 1006 mnemonic_not_loaded
|
||||
*/
|
||||
char *dispatcher_handle_request(dispatcher_ctx_t *ctx, const char *json_request);
|
||||
|
||||
|
||||
/* from server.h */
|
||||
|
||||
|
||||
#define SERVER_SOCKET_NAME_MAX 108
|
||||
#define SERVER_MAX_MSG_SIZE 65536
|
||||
|
||||
/* Caller identity */
|
||||
typedef struct {
|
||||
uid_t uid;
|
||||
gid_t gid;
|
||||
pid_t pid;
|
||||
char caller_id[64]; /* "uid:<n>" */
|
||||
} caller_identity_t;
|
||||
|
||||
/* Server context */
|
||||
typedef struct {
|
||||
char socket_name[SERVER_SOCKET_NAME_MAX]; /* abstract namespace name (without \0 prefix) */
|
||||
char last_error[256];
|
||||
int listen_fd;
|
||||
int running;
|
||||
dispatcher_ctx_t *dispatcher;
|
||||
policy_table_t *policy;
|
||||
int socket_name_explicit;
|
||||
} server_ctx_t;
|
||||
|
||||
/* Initialize server context. socket_name is the abstract namespace name (e.g. "nsigner").
|
||||
* socket_name_explicit should be non-zero when provided via --socket-name override. */
|
||||
void server_init(server_ctx_t *ctx, const char *socket_name, int socket_name_explicit,
|
||||
dispatcher_ctx_t *dispatcher, policy_table_t *policy);
|
||||
|
||||
/* Start listening. Returns 0 on success, -1 on error. */
|
||||
int server_start(server_ctx_t *ctx);
|
||||
|
||||
/* Get human-readable description of last server error. */
|
||||
const char *server_last_error(const server_ctx_t *ctx);
|
||||
|
||||
/* Handle one pending connection (non-blocking). Returns 1 if handled, 0 if nothing pending, -1 on error.
|
||||
* activity_cb is called with a description string for the TUI activity log. */
|
||||
typedef void (*server_activity_cb)(const char *message, void *user_data);
|
||||
int server_handle_one(server_ctx_t *ctx, server_activity_cb cb, void *cb_data);
|
||||
|
||||
/* Stop server and close socket */
|
||||
void server_stop(server_ctx_t *ctx);
|
||||
|
||||
/* Extract caller identity from connected fd */
|
||||
int server_get_caller(int fd, caller_identity_t *out);
|
||||
|
||||
|
||||
/* from socket_name.h */
|
||||
|
||||
|
||||
/*
|
||||
* Generate random socket name in format: nsigner_<word1>_<word2>
|
||||
* Returns 0 on success, -1 on error.
|
||||
*/
|
||||
int socket_name_random(char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from main.h */
|
||||
/*
|
||||
* nsigner main header - version information
|
||||
*
|
||||
* Version macros are auto-updated by increment_and_push.sh.
|
||||
*/
|
||||
|
||||
|
||||
/* Version information (auto-updated by build/version tooling) */
|
||||
#define NSIGNER_VERSION_MAJOR 0
|
||||
#define NSIGNER_VERSION_MINOR 0
|
||||
#define NSIGNER_VERSION_PATCH 2
|
||||
#define NSIGNER_VERSION "v0.0.2"
|
||||
|
||||
|
||||
/* NSIGNER_HEADERLESS_DECLS_END */
|
||||
|
||||
#include <arpa/inet.h>
|
||||
#include <errno.h>
|
||||
|
||||
52
src/server.h
52
src/server.h
@@ -1,52 +0,0 @@
|
||||
#ifndef NSIGNER_SERVER_H
|
||||
#define NSIGNER_SERVER_H
|
||||
|
||||
#include "dispatcher.h"
|
||||
#include "policy.h"
|
||||
#include <sys/types.h>
|
||||
|
||||
#define SERVER_SOCKET_NAME_MAX 108
|
||||
#define SERVER_MAX_MSG_SIZE 65536
|
||||
|
||||
/* Caller identity */
|
||||
typedef struct {
|
||||
uid_t uid;
|
||||
gid_t gid;
|
||||
pid_t pid;
|
||||
char caller_id[64]; /* "uid:<n>" */
|
||||
} caller_identity_t;
|
||||
|
||||
/* Server context */
|
||||
typedef struct {
|
||||
char socket_name[SERVER_SOCKET_NAME_MAX]; /* abstract namespace name (without \0 prefix) */
|
||||
char last_error[256];
|
||||
int listen_fd;
|
||||
int running;
|
||||
dispatcher_ctx_t *dispatcher;
|
||||
policy_table_t *policy;
|
||||
int socket_name_explicit;
|
||||
} server_ctx_t;
|
||||
|
||||
/* Initialize server context. socket_name is the abstract namespace name (e.g. "nsigner").
|
||||
* socket_name_explicit should be non-zero when provided via --socket-name override. */
|
||||
void server_init(server_ctx_t *ctx, const char *socket_name, int socket_name_explicit,
|
||||
dispatcher_ctx_t *dispatcher, policy_table_t *policy);
|
||||
|
||||
/* Start listening. Returns 0 on success, -1 on error. */
|
||||
int server_start(server_ctx_t *ctx);
|
||||
|
||||
/* Get human-readable description of last server error. */
|
||||
const char *server_last_error(const server_ctx_t *ctx);
|
||||
|
||||
/* Handle one pending connection (non-blocking). Returns 1 if handled, 0 if nothing pending, -1 on error.
|
||||
* activity_cb is called with a description string for the TUI activity log. */
|
||||
typedef void (*server_activity_cb)(const char *message, void *user_data);
|
||||
int server_handle_one(server_ctx_t *ctx, server_activity_cb cb, void *cb_data);
|
||||
|
||||
/* Stop server and close socket */
|
||||
void server_stop(server_ctx_t *ctx);
|
||||
|
||||
/* Extract caller identity from connected fd */
|
||||
int server_get_caller(int fd, caller_identity_t *out);
|
||||
|
||||
#endif /* NSIGNER_SERVER_H */
|
||||
@@ -1,6 +1,446 @@
|
||||
#define _GNU_SOURCE
|
||||
|
||||
#include "socket_name.h"
|
||||
/* NSIGNER_HEADERLESS_DECLS_BEGIN */
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
#include <cJSON.h>
|
||||
|
||||
/* from secure_mem.h */
|
||||
|
||||
|
||||
/*
|
||||
* Secure memory buffer — mlock'd, zeroized on free.
|
||||
* Used for mnemonic phrases, private keys, and any sensitive material.
|
||||
*/
|
||||
typedef struct {
|
||||
void *data; /* pointer to locked allocation */
|
||||
size_t size; /* usable size in bytes */
|
||||
int locked; /* 1 if mlock succeeded */
|
||||
} secure_buf_t;
|
||||
|
||||
/* Allocate a secure buffer of `size` bytes. Returns 0 on success, -1 on failure. */
|
||||
int secure_buf_alloc(secure_buf_t *buf, size_t size);
|
||||
|
||||
/* Zeroize and free a secure buffer. Always succeeds (idempotent). */
|
||||
void secure_buf_free(secure_buf_t *buf);
|
||||
|
||||
/* Zeroize `len` bytes at `ptr` in a way the compiler cannot optimize away. */
|
||||
void secure_memzero(void *ptr, size_t len);
|
||||
|
||||
|
||||
/* from mnemonic.h */
|
||||
|
||||
|
||||
/* Maximum mnemonic length: 24 words * 10 chars avg + spaces + null = 256 is safe */
|
||||
#define MNEMONIC_MAX_LEN 256
|
||||
|
||||
/*
|
||||
* Mnemonic state — holds the loaded mnemonic in secure memory.
|
||||
* Only one mnemonic is active at a time per process.
|
||||
*/
|
||||
typedef struct {
|
||||
secure_buf_t buf; /* secure storage for the mnemonic string */
|
||||
int loaded; /* 1 if a mnemonic is currently loaded */
|
||||
int word_count; /* 12, 15, 18, 21, or 24 */
|
||||
} mnemonic_state_t;
|
||||
|
||||
/* Initialize mnemonic state (must be called before use). */
|
||||
void mnemonic_init(mnemonic_state_t *state);
|
||||
|
||||
/* Load a mnemonic string into secure memory. Validates word count (12/15/18/21/24).
|
||||
* Returns 0 on success, -1 on invalid input, -2 on memory error. */
|
||||
int mnemonic_load(mnemonic_state_t *state, const char *phrase);
|
||||
|
||||
/* Zeroize and unload the mnemonic. Idempotent. */
|
||||
void mnemonic_unload(mnemonic_state_t *state);
|
||||
|
||||
/* Check if a mnemonic is currently loaded. */
|
||||
int mnemonic_is_loaded(const mnemonic_state_t *state);
|
||||
|
||||
/* Get the mnemonic string (only valid while loaded). Returns NULL if not loaded. */
|
||||
const char *mnemonic_get_phrase(const mnemonic_state_t *state);
|
||||
|
||||
/* Generate a new BIP-39 mnemonic phrase (12/15/18/21/24 words) into out.
|
||||
* Returns 0 on success, -1 on invalid arguments or generation failure. */
|
||||
int mnemonic_generate(int word_count, char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from role_table.h */
|
||||
|
||||
|
||||
/* Maximum limits */
|
||||
#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 /* 64 hex chars + null + pad */
|
||||
#define ROLE_TABLE_MAX_ENTRIES 64
|
||||
|
||||
/* Purpose enum for fast comparison (string form kept for config/display) */
|
||||
typedef enum {
|
||||
PURPOSE_NOSTR = 0,
|
||||
PURPOSE_BITCOIN,
|
||||
PURPOSE_SSH,
|
||||
PURPOSE_AGE,
|
||||
PURPOSE_FIPS,
|
||||
PURPOSE_UNKNOWN
|
||||
} role_purpose_t;
|
||||
|
||||
/* Curve enum */
|
||||
typedef enum {
|
||||
CURVE_SECP256K1 = 0,
|
||||
CURVE_ED25519,
|
||||
CURVE_X25519,
|
||||
CURVE_UNKNOWN
|
||||
} role_curve_t;
|
||||
|
||||
/* Selector type — how this role's key is addressed */
|
||||
typedef enum {
|
||||
SELECTOR_NOSTR_INDEX, /* uses nostr_index shorthand */
|
||||
SELECTOR_ROLE_PATH /* uses explicit full path */
|
||||
} role_selector_type_t;
|
||||
|
||||
/* A single role entry */
|
||||
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; /* valid if selector_type == SELECTOR_NOSTR_INDEX */
|
||||
char role_path[ROLE_PATH_MAX]; /* valid if selector_type == SELECTOR_ROLE_PATH */
|
||||
char pubkey_hex[ROLE_PUBKEY_HEX_MAX]; /* filled after derivation, empty until then */
|
||||
int derived; /* 1 if pubkey_hex has been populated */
|
||||
} role_entry_t;
|
||||
|
||||
/* The role table */
|
||||
typedef struct {
|
||||
role_entry_t entries[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} role_table_t;
|
||||
|
||||
/* Initialize an empty role table */
|
||||
void role_table_init(role_table_t *table);
|
||||
|
||||
/* Add a role entry. Returns 0 on success, -1 if table full, -2 if name duplicate. */
|
||||
int role_table_add(role_table_t *table, const role_entry_t *entry);
|
||||
|
||||
/* Find a role by name. Returns pointer to entry or NULL. */
|
||||
role_entry_t *role_table_find_by_name(role_table_t *table, const char *name);
|
||||
|
||||
/* Find a role by nostr_index. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_nostr_index(role_table_t *table, int index);
|
||||
|
||||
/* Find a role by role_path. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_path(role_table_t *table, const char *path);
|
||||
|
||||
/* Get the default role (named "main"). Returns pointer or NULL if no "main" role. */
|
||||
role_entry_t *role_table_get_default(role_table_t *table);
|
||||
|
||||
/* Parse purpose string to enum */
|
||||
role_purpose_t role_purpose_from_str(const char *s);
|
||||
|
||||
/* Parse curve string to enum */
|
||||
role_curve_t role_curve_from_str(const char *s);
|
||||
|
||||
/* Purpose enum to string */
|
||||
const char *role_purpose_to_str(role_purpose_t p);
|
||||
|
||||
/* Curve enum to string */
|
||||
const char *role_curve_to_str(role_curve_t c);
|
||||
|
||||
|
||||
/* from selector.h */
|
||||
|
||||
|
||||
/* Error codes for selector resolution */
|
||||
#define SELECTOR_OK 0
|
||||
#define SELECTOR_ERR_AMBIGUOUS -1 /* multiple selectors specified */
|
||||
#define SELECTOR_ERR_NOT_FOUND -2 /* no matching role in table */
|
||||
#define SELECTOR_ERR_NO_DEFAULT -3 /* no selector given and no "main" role exists */
|
||||
|
||||
/* Parsed selector from a request's options object */
|
||||
typedef struct {
|
||||
int has_role; /* 1 if "role" field was present */
|
||||
char role_name[ROLE_NAME_MAX];
|
||||
|
||||
int has_nostr_index; /* 1 if "nostr_index" field was present */
|
||||
int nostr_index;
|
||||
|
||||
int has_role_path; /* 1 if "role_path" field was present */
|
||||
char role_path[ROLE_PATH_MAX];
|
||||
} selector_request_t;
|
||||
|
||||
/* Initialize a selector request (all fields zeroed/unset) */
|
||||
void selector_request_init(selector_request_t *req);
|
||||
|
||||
/*
|
||||
* Resolve a selector request against the role table.
|
||||
* On success (returns SELECTOR_OK), *out points to the matched role_entry_t.
|
||||
* On failure, returns one of the SELECTOR_ERR_* codes and *out is NULL.
|
||||
*/
|
||||
int selector_resolve(const selector_request_t *req, role_table_t *table, role_entry_t **out);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for a selector error code.
|
||||
*/
|
||||
const char *selector_strerror(int err);
|
||||
|
||||
|
||||
/* from enforcement.h */
|
||||
|
||||
|
||||
/* Error codes */
|
||||
#define ENFORCE_OK 0
|
||||
#define ENFORCE_ERR_PURPOSE -1 /* purpose mismatch */
|
||||
#define ENFORCE_ERR_CURVE -2 /* curve mismatch */
|
||||
#define ENFORCE_ERR_UNKNOWN_VERB -3 /* verb not recognized */
|
||||
|
||||
/* Known verbs */
|
||||
#define VERB_SIGN_EVENT "sign_event"
|
||||
#define VERB_GET_PUBLIC_KEY "get_public_key"
|
||||
#define VERB_NIP44_ENCRYPT "nip44_encrypt"
|
||||
#define VERB_NIP44_DECRYPT "nip44_decrypt"
|
||||
#define VERB_NIP04_ENCRYPT "nip04_encrypt"
|
||||
#define VERB_NIP04_DECRYPT "nip04_decrypt"
|
||||
|
||||
/*
|
||||
* Check whether `verb` is allowed to execute against `role`.
|
||||
* Returns ENFORCE_OK if allowed, or an ENFORCE_ERR_* code.
|
||||
*
|
||||
* The enforcement rules are:
|
||||
* - All nostr verbs (sign_event, get_public_key, nip44_*, nip04_*) require:
|
||||
* purpose == PURPOSE_NOSTR and curve == CURVE_SECP256K1
|
||||
* - Unknown verbs return ENFORCE_ERR_UNKNOWN_VERB (fail-closed).
|
||||
*/
|
||||
int enforce_verb_role(const char *verb, const role_entry_t *role);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for an enforcement error code.
|
||||
*/
|
||||
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 64
|
||||
|
||||
/* Prompt behavior */
|
||||
typedef enum {
|
||||
PROMPT_NEVER = 0,
|
||||
PROMPT_FIRST_PER_BOOT,
|
||||
PROMPT_EVERY_REQUEST,
|
||||
PROMPT_DENY
|
||||
} prompt_mode_t;
|
||||
|
||||
/* A single policy entry */
|
||||
typedef struct {
|
||||
char caller[POLICY_CALLER_MAX_LEN]; /* e.g. "uid:1000" or "*" for any */
|
||||
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;
|
||||
prompt_mode_t prompt;
|
||||
} policy_entry_t;
|
||||
|
||||
/* Policy table */
|
||||
typedef struct {
|
||||
policy_entry_t entries[POLICY_MAX_ENTRIES];
|
||||
int count;
|
||||
} policy_table_t;
|
||||
|
||||
/* Policy check result */
|
||||
#define POLICY_ALLOW 0
|
||||
#define POLICY_DENY -1
|
||||
#define POLICY_PROMPT -2 /* would need user confirmation */
|
||||
#define POLICY_NO_MATCH -3 /* no policy entry matched (fail-closed = deny) */
|
||||
|
||||
/* Initialize policy table */
|
||||
void policy_table_init(policy_table_t *table);
|
||||
|
||||
/* Initialize default policy: allow same-uid, deny others */
|
||||
void policy_init_default(policy_table_t *table, uid_t owner_uid);
|
||||
|
||||
/* Add a policy entry. Returns 0 on success, -1 if full. */
|
||||
int policy_table_add(policy_table_t *table, const policy_entry_t *entry);
|
||||
|
||||
/*
|
||||
* Check whether caller_id is allowed to invoke `verb` on `role_name` with given `purpose`.
|
||||
* Returns POLICY_ALLOW, POLICY_DENY, POLICY_PROMPT, or POLICY_NO_MATCH.
|
||||
*/
|
||||
int policy_check(const policy_table_t *table, const char *caller_id,
|
||||
const char *verb, const char *role_name, const char *purpose);
|
||||
|
||||
/* Parse prompt mode from string */
|
||||
prompt_mode_t prompt_mode_from_str(const char *s);
|
||||
|
||||
/* Prompt mode to string */
|
||||
const char *prompt_mode_to_str(prompt_mode_t m);
|
||||
|
||||
|
||||
/* from crypto.h */
|
||||
|
||||
|
||||
/* Per-role derived key material (stored in secure memory) */
|
||||
typedef struct {
|
||||
secure_buf_t private_key; /* 32 bytes, mlock'd */
|
||||
unsigned char public_key[32];
|
||||
char pubkey_hex[65]; /* 64 hex chars + null */
|
||||
char npub[128]; /* bech32 npub */
|
||||
int valid;
|
||||
} derived_key_t;
|
||||
|
||||
/* Key store — holds derived keys for all roles */
|
||||
typedef struct {
|
||||
derived_key_t keys[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} key_store_t;
|
||||
|
||||
/* Derive keys for all roles in the table using the loaded mnemonic.
|
||||
* Populates key_store and sets role->pubkey_hex and role->derived for each role.
|
||||
* Only derives for roles with purpose=nostr and curve=secp256k1 (for now).
|
||||
* Returns number of keys derived, or -1 on error. */
|
||||
int crypto_derive_all(key_store_t *store, role_table_t *table, const mnemonic_state_t *mnemonic);
|
||||
|
||||
/* Get the derived private key for a role (by table index). Returns NULL if not derived. */
|
||||
const unsigned char *crypto_get_private_key(const key_store_t *store, int role_index);
|
||||
|
||||
/* Get the derived public key hex for a role. Returns NULL if not derived. */
|
||||
const char *crypto_get_pubkey_hex(const key_store_t *store, int role_index);
|
||||
|
||||
/* Sign a Nostr event. event_json is the unsigned event JSON string.
|
||||
* Returns a newly-allocated string containing the signed event JSON, or NULL on error.
|
||||
* Caller must free() the returned string. */
|
||||
char *crypto_sign_event(const key_store_t *store, int role_index, const char *event_json);
|
||||
|
||||
/* Zeroize all derived keys in the store. */
|
||||
void crypto_wipe(key_store_t *store);
|
||||
|
||||
|
||||
/* from dispatcher.h */
|
||||
|
||||
|
||||
/* Dispatcher context — holds references to shared state */
|
||||
typedef struct {
|
||||
role_table_t *role_table;
|
||||
mnemonic_state_t *mnemonic;
|
||||
key_store_t *key_store;
|
||||
} dispatcher_ctx_t;
|
||||
|
||||
/* Initialize dispatcher context */
|
||||
void dispatcher_init(dispatcher_ctx_t *ctx, role_table_t *table, mnemonic_state_t *mnemonic, key_store_t *key_store);
|
||||
|
||||
/*
|
||||
* Process a JSON-RPC request string and produce a JSON-RPC response string.
|
||||
*
|
||||
* The caller owns the returned string and must free() it.
|
||||
* Returns NULL only on catastrophic allocation failure.
|
||||
*
|
||||
* Response format on success:
|
||||
* { "id": "...", "result": "..." }
|
||||
*
|
||||
* Response format on error:
|
||||
* { "id": "...", "error": { "code": <int>, "message": "..." } }
|
||||
*
|
||||
* Error codes:
|
||||
* -32700 Parse error (invalid JSON)
|
||||
* -32600 Invalid request (missing id/method/params)
|
||||
* -32601 Method not found (unknown verb after enforcement)
|
||||
* -32602 Invalid params
|
||||
* 1001 ambiguous_role_selector
|
||||
* 1002 role_not_found
|
||||
* 1003 no_default_role
|
||||
* 1004 purpose_mismatch
|
||||
* 1005 curve_mismatch
|
||||
* 1006 mnemonic_not_loaded
|
||||
*/
|
||||
char *dispatcher_handle_request(dispatcher_ctx_t *ctx, const char *json_request);
|
||||
|
||||
|
||||
/* from server.h */
|
||||
|
||||
|
||||
#define SERVER_SOCKET_NAME_MAX 108
|
||||
#define SERVER_MAX_MSG_SIZE 65536
|
||||
|
||||
/* Caller identity */
|
||||
typedef struct {
|
||||
uid_t uid;
|
||||
gid_t gid;
|
||||
pid_t pid;
|
||||
char caller_id[64]; /* "uid:<n>" */
|
||||
} caller_identity_t;
|
||||
|
||||
/* Server context */
|
||||
typedef struct {
|
||||
char socket_name[SERVER_SOCKET_NAME_MAX]; /* abstract namespace name (without \0 prefix) */
|
||||
char last_error[256];
|
||||
int listen_fd;
|
||||
int running;
|
||||
dispatcher_ctx_t *dispatcher;
|
||||
policy_table_t *policy;
|
||||
int socket_name_explicit;
|
||||
} server_ctx_t;
|
||||
|
||||
/* Initialize server context. socket_name is the abstract namespace name (e.g. "nsigner").
|
||||
* socket_name_explicit should be non-zero when provided via --socket-name override. */
|
||||
void server_init(server_ctx_t *ctx, const char *socket_name, int socket_name_explicit,
|
||||
dispatcher_ctx_t *dispatcher, policy_table_t *policy);
|
||||
|
||||
/* Start listening. Returns 0 on success, -1 on error. */
|
||||
int server_start(server_ctx_t *ctx);
|
||||
|
||||
/* Get human-readable description of last server error. */
|
||||
const char *server_last_error(const server_ctx_t *ctx);
|
||||
|
||||
/* Handle one pending connection (non-blocking). Returns 1 if handled, 0 if nothing pending, -1 on error.
|
||||
* activity_cb is called with a description string for the TUI activity log. */
|
||||
typedef void (*server_activity_cb)(const char *message, void *user_data);
|
||||
int server_handle_one(server_ctx_t *ctx, server_activity_cb cb, void *cb_data);
|
||||
|
||||
/* Stop server and close socket */
|
||||
void server_stop(server_ctx_t *ctx);
|
||||
|
||||
/* Extract caller identity from connected fd */
|
||||
int server_get_caller(int fd, caller_identity_t *out);
|
||||
|
||||
|
||||
/* from socket_name.h */
|
||||
|
||||
|
||||
/*
|
||||
* Generate random socket name in format: nsigner_<word1>_<word2>
|
||||
* Returns 0 on success, -1 on error.
|
||||
*/
|
||||
int socket_name_random(char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from main.h */
|
||||
/*
|
||||
* nsigner main header - version information
|
||||
*
|
||||
* Version macros are auto-updated by increment_and_push.sh.
|
||||
*/
|
||||
|
||||
|
||||
/* Version information (auto-updated by build/version tooling) */
|
||||
#define NSIGNER_VERSION_MAJOR 0
|
||||
#define NSIGNER_VERSION_MINOR 0
|
||||
#define NSIGNER_VERSION_PATCH 2
|
||||
#define NSIGNER_VERSION "v0.0.2"
|
||||
|
||||
|
||||
/* NSIGNER_HEADERLESS_DECLS_END */
|
||||
|
||||
#include <nostr_core/utils.h>
|
||||
|
||||
|
||||
@@ -1,12 +0,0 @@
|
||||
#ifndef NSIGNER_SOCKET_NAME_H
|
||||
#define NSIGNER_SOCKET_NAME_H
|
||||
|
||||
#include <stddef.h>
|
||||
|
||||
/*
|
||||
* Generate random socket name in format: nsigner_<word1>_<word2>
|
||||
* Returns 0 on success, -1 on error.
|
||||
*/
|
||||
int socket_name_random(char *out, size_t out_len);
|
||||
|
||||
#endif /* NSIGNER_SOCKET_NAME_H */
|
||||
@@ -1,7 +1,446 @@
|
||||
#include "../src/dispatcher.h"
|
||||
/* NSIGNER_HEADERLESS_DECLS_BEGIN */
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
#include <cJSON.h>
|
||||
|
||||
#include "../src/enforcement.h"
|
||||
#include "../src/role_table.h"
|
||||
/* from secure_mem.h */
|
||||
|
||||
|
||||
/*
|
||||
* Secure memory buffer — mlock'd, zeroized on free.
|
||||
* Used for mnemonic phrases, private keys, and any sensitive material.
|
||||
*/
|
||||
typedef struct {
|
||||
void *data; /* pointer to locked allocation */
|
||||
size_t size; /* usable size in bytes */
|
||||
int locked; /* 1 if mlock succeeded */
|
||||
} secure_buf_t;
|
||||
|
||||
/* Allocate a secure buffer of `size` bytes. Returns 0 on success, -1 on failure. */
|
||||
int secure_buf_alloc(secure_buf_t *buf, size_t size);
|
||||
|
||||
/* Zeroize and free a secure buffer. Always succeeds (idempotent). */
|
||||
void secure_buf_free(secure_buf_t *buf);
|
||||
|
||||
/* Zeroize `len` bytes at `ptr` in a way the compiler cannot optimize away. */
|
||||
void secure_memzero(void *ptr, size_t len);
|
||||
|
||||
|
||||
/* from mnemonic.h */
|
||||
|
||||
|
||||
/* Maximum mnemonic length: 24 words * 10 chars avg + spaces + null = 256 is safe */
|
||||
#define MNEMONIC_MAX_LEN 256
|
||||
|
||||
/*
|
||||
* Mnemonic state — holds the loaded mnemonic in secure memory.
|
||||
* Only one mnemonic is active at a time per process.
|
||||
*/
|
||||
typedef struct {
|
||||
secure_buf_t buf; /* secure storage for the mnemonic string */
|
||||
int loaded; /* 1 if a mnemonic is currently loaded */
|
||||
int word_count; /* 12, 15, 18, 21, or 24 */
|
||||
} mnemonic_state_t;
|
||||
|
||||
/* Initialize mnemonic state (must be called before use). */
|
||||
void mnemonic_init(mnemonic_state_t *state);
|
||||
|
||||
/* Load a mnemonic string into secure memory. Validates word count (12/15/18/21/24).
|
||||
* Returns 0 on success, -1 on invalid input, -2 on memory error. */
|
||||
int mnemonic_load(mnemonic_state_t *state, const char *phrase);
|
||||
|
||||
/* Zeroize and unload the mnemonic. Idempotent. */
|
||||
void mnemonic_unload(mnemonic_state_t *state);
|
||||
|
||||
/* Check if a mnemonic is currently loaded. */
|
||||
int mnemonic_is_loaded(const mnemonic_state_t *state);
|
||||
|
||||
/* Get the mnemonic string (only valid while loaded). Returns NULL if not loaded. */
|
||||
const char *mnemonic_get_phrase(const mnemonic_state_t *state);
|
||||
|
||||
/* Generate a new BIP-39 mnemonic phrase (12/15/18/21/24 words) into out.
|
||||
* Returns 0 on success, -1 on invalid arguments or generation failure. */
|
||||
int mnemonic_generate(int word_count, char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from role_table.h */
|
||||
|
||||
|
||||
/* Maximum limits */
|
||||
#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 /* 64 hex chars + null + pad */
|
||||
#define ROLE_TABLE_MAX_ENTRIES 64
|
||||
|
||||
/* Purpose enum for fast comparison (string form kept for config/display) */
|
||||
typedef enum {
|
||||
PURPOSE_NOSTR = 0,
|
||||
PURPOSE_BITCOIN,
|
||||
PURPOSE_SSH,
|
||||
PURPOSE_AGE,
|
||||
PURPOSE_FIPS,
|
||||
PURPOSE_UNKNOWN
|
||||
} role_purpose_t;
|
||||
|
||||
/* Curve enum */
|
||||
typedef enum {
|
||||
CURVE_SECP256K1 = 0,
|
||||
CURVE_ED25519,
|
||||
CURVE_X25519,
|
||||
CURVE_UNKNOWN
|
||||
} role_curve_t;
|
||||
|
||||
/* Selector type — how this role's key is addressed */
|
||||
typedef enum {
|
||||
SELECTOR_NOSTR_INDEX, /* uses nostr_index shorthand */
|
||||
SELECTOR_ROLE_PATH /* uses explicit full path */
|
||||
} role_selector_type_t;
|
||||
|
||||
/* A single role entry */
|
||||
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; /* valid if selector_type == SELECTOR_NOSTR_INDEX */
|
||||
char role_path[ROLE_PATH_MAX]; /* valid if selector_type == SELECTOR_ROLE_PATH */
|
||||
char pubkey_hex[ROLE_PUBKEY_HEX_MAX]; /* filled after derivation, empty until then */
|
||||
int derived; /* 1 if pubkey_hex has been populated */
|
||||
} role_entry_t;
|
||||
|
||||
/* The role table */
|
||||
typedef struct {
|
||||
role_entry_t entries[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} role_table_t;
|
||||
|
||||
/* Initialize an empty role table */
|
||||
void role_table_init(role_table_t *table);
|
||||
|
||||
/* Add a role entry. Returns 0 on success, -1 if table full, -2 if name duplicate. */
|
||||
int role_table_add(role_table_t *table, const role_entry_t *entry);
|
||||
|
||||
/* Find a role by name. Returns pointer to entry or NULL. */
|
||||
role_entry_t *role_table_find_by_name(role_table_t *table, const char *name);
|
||||
|
||||
/* Find a role by nostr_index. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_nostr_index(role_table_t *table, int index);
|
||||
|
||||
/* Find a role by role_path. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_path(role_table_t *table, const char *path);
|
||||
|
||||
/* Get the default role (named "main"). Returns pointer or NULL if no "main" role. */
|
||||
role_entry_t *role_table_get_default(role_table_t *table);
|
||||
|
||||
/* Parse purpose string to enum */
|
||||
role_purpose_t role_purpose_from_str(const char *s);
|
||||
|
||||
/* Parse curve string to enum */
|
||||
role_curve_t role_curve_from_str(const char *s);
|
||||
|
||||
/* Purpose enum to string */
|
||||
const char *role_purpose_to_str(role_purpose_t p);
|
||||
|
||||
/* Curve enum to string */
|
||||
const char *role_curve_to_str(role_curve_t c);
|
||||
|
||||
|
||||
/* from selector.h */
|
||||
|
||||
|
||||
/* Error codes for selector resolution */
|
||||
#define SELECTOR_OK 0
|
||||
#define SELECTOR_ERR_AMBIGUOUS -1 /* multiple selectors specified */
|
||||
#define SELECTOR_ERR_NOT_FOUND -2 /* no matching role in table */
|
||||
#define SELECTOR_ERR_NO_DEFAULT -3 /* no selector given and no "main" role exists */
|
||||
|
||||
/* Parsed selector from a request's options object */
|
||||
typedef struct {
|
||||
int has_role; /* 1 if "role" field was present */
|
||||
char role_name[ROLE_NAME_MAX];
|
||||
|
||||
int has_nostr_index; /* 1 if "nostr_index" field was present */
|
||||
int nostr_index;
|
||||
|
||||
int has_role_path; /* 1 if "role_path" field was present */
|
||||
char role_path[ROLE_PATH_MAX];
|
||||
} selector_request_t;
|
||||
|
||||
/* Initialize a selector request (all fields zeroed/unset) */
|
||||
void selector_request_init(selector_request_t *req);
|
||||
|
||||
/*
|
||||
* Resolve a selector request against the role table.
|
||||
* On success (returns SELECTOR_OK), *out points to the matched role_entry_t.
|
||||
* On failure, returns one of the SELECTOR_ERR_* codes and *out is NULL.
|
||||
*/
|
||||
int selector_resolve(const selector_request_t *req, role_table_t *table, role_entry_t **out);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for a selector error code.
|
||||
*/
|
||||
const char *selector_strerror(int err);
|
||||
|
||||
|
||||
/* from enforcement.h */
|
||||
|
||||
|
||||
/* Error codes */
|
||||
#define ENFORCE_OK 0
|
||||
#define ENFORCE_ERR_PURPOSE -1 /* purpose mismatch */
|
||||
#define ENFORCE_ERR_CURVE -2 /* curve mismatch */
|
||||
#define ENFORCE_ERR_UNKNOWN_VERB -3 /* verb not recognized */
|
||||
|
||||
/* Known verbs */
|
||||
#define VERB_SIGN_EVENT "sign_event"
|
||||
#define VERB_GET_PUBLIC_KEY "get_public_key"
|
||||
#define VERB_NIP44_ENCRYPT "nip44_encrypt"
|
||||
#define VERB_NIP44_DECRYPT "nip44_decrypt"
|
||||
#define VERB_NIP04_ENCRYPT "nip04_encrypt"
|
||||
#define VERB_NIP04_DECRYPT "nip04_decrypt"
|
||||
|
||||
/*
|
||||
* Check whether `verb` is allowed to execute against `role`.
|
||||
* Returns ENFORCE_OK if allowed, or an ENFORCE_ERR_* code.
|
||||
*
|
||||
* The enforcement rules are:
|
||||
* - All nostr verbs (sign_event, get_public_key, nip44_*, nip04_*) require:
|
||||
* purpose == PURPOSE_NOSTR and curve == CURVE_SECP256K1
|
||||
* - Unknown verbs return ENFORCE_ERR_UNKNOWN_VERB (fail-closed).
|
||||
*/
|
||||
int enforce_verb_role(const char *verb, const role_entry_t *role);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for an enforcement error code.
|
||||
*/
|
||||
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 64
|
||||
|
||||
/* Prompt behavior */
|
||||
typedef enum {
|
||||
PROMPT_NEVER = 0,
|
||||
PROMPT_FIRST_PER_BOOT,
|
||||
PROMPT_EVERY_REQUEST,
|
||||
PROMPT_DENY
|
||||
} prompt_mode_t;
|
||||
|
||||
/* A single policy entry */
|
||||
typedef struct {
|
||||
char caller[POLICY_CALLER_MAX_LEN]; /* e.g. "uid:1000" or "*" for any */
|
||||
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;
|
||||
prompt_mode_t prompt;
|
||||
} policy_entry_t;
|
||||
|
||||
/* Policy table */
|
||||
typedef struct {
|
||||
policy_entry_t entries[POLICY_MAX_ENTRIES];
|
||||
int count;
|
||||
} policy_table_t;
|
||||
|
||||
/* Policy check result */
|
||||
#define POLICY_ALLOW 0
|
||||
#define POLICY_DENY -1
|
||||
#define POLICY_PROMPT -2 /* would need user confirmation */
|
||||
#define POLICY_NO_MATCH -3 /* no policy entry matched (fail-closed = deny) */
|
||||
|
||||
/* Initialize policy table */
|
||||
void policy_table_init(policy_table_t *table);
|
||||
|
||||
/* Initialize default policy: allow same-uid, deny others */
|
||||
void policy_init_default(policy_table_t *table, uid_t owner_uid);
|
||||
|
||||
/* Add a policy entry. Returns 0 on success, -1 if full. */
|
||||
int policy_table_add(policy_table_t *table, const policy_entry_t *entry);
|
||||
|
||||
/*
|
||||
* Check whether caller_id is allowed to invoke `verb` on `role_name` with given `purpose`.
|
||||
* Returns POLICY_ALLOW, POLICY_DENY, POLICY_PROMPT, or POLICY_NO_MATCH.
|
||||
*/
|
||||
int policy_check(const policy_table_t *table, const char *caller_id,
|
||||
const char *verb, const char *role_name, const char *purpose);
|
||||
|
||||
/* Parse prompt mode from string */
|
||||
prompt_mode_t prompt_mode_from_str(const char *s);
|
||||
|
||||
/* Prompt mode to string */
|
||||
const char *prompt_mode_to_str(prompt_mode_t m);
|
||||
|
||||
|
||||
/* from crypto.h */
|
||||
|
||||
|
||||
/* Per-role derived key material (stored in secure memory) */
|
||||
typedef struct {
|
||||
secure_buf_t private_key; /* 32 bytes, mlock'd */
|
||||
unsigned char public_key[32];
|
||||
char pubkey_hex[65]; /* 64 hex chars + null */
|
||||
char npub[128]; /* bech32 npub */
|
||||
int valid;
|
||||
} derived_key_t;
|
||||
|
||||
/* Key store — holds derived keys for all roles */
|
||||
typedef struct {
|
||||
derived_key_t keys[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} key_store_t;
|
||||
|
||||
/* Derive keys for all roles in the table using the loaded mnemonic.
|
||||
* Populates key_store and sets role->pubkey_hex and role->derived for each role.
|
||||
* Only derives for roles with purpose=nostr and curve=secp256k1 (for now).
|
||||
* Returns number of keys derived, or -1 on error. */
|
||||
int crypto_derive_all(key_store_t *store, role_table_t *table, const mnemonic_state_t *mnemonic);
|
||||
|
||||
/* Get the derived private key for a role (by table index). Returns NULL if not derived. */
|
||||
const unsigned char *crypto_get_private_key(const key_store_t *store, int role_index);
|
||||
|
||||
/* Get the derived public key hex for a role. Returns NULL if not derived. */
|
||||
const char *crypto_get_pubkey_hex(const key_store_t *store, int role_index);
|
||||
|
||||
/* Sign a Nostr event. event_json is the unsigned event JSON string.
|
||||
* Returns a newly-allocated string containing the signed event JSON, or NULL on error.
|
||||
* Caller must free() the returned string. */
|
||||
char *crypto_sign_event(const key_store_t *store, int role_index, const char *event_json);
|
||||
|
||||
/* Zeroize all derived keys in the store. */
|
||||
void crypto_wipe(key_store_t *store);
|
||||
|
||||
|
||||
/* from dispatcher.h */
|
||||
|
||||
|
||||
/* Dispatcher context — holds references to shared state */
|
||||
typedef struct {
|
||||
role_table_t *role_table;
|
||||
mnemonic_state_t *mnemonic;
|
||||
key_store_t *key_store;
|
||||
} dispatcher_ctx_t;
|
||||
|
||||
/* Initialize dispatcher context */
|
||||
void dispatcher_init(dispatcher_ctx_t *ctx, role_table_t *table, mnemonic_state_t *mnemonic, key_store_t *key_store);
|
||||
|
||||
/*
|
||||
* Process a JSON-RPC request string and produce a JSON-RPC response string.
|
||||
*
|
||||
* The caller owns the returned string and must free() it.
|
||||
* Returns NULL only on catastrophic allocation failure.
|
||||
*
|
||||
* Response format on success:
|
||||
* { "id": "...", "result": "..." }
|
||||
*
|
||||
* Response format on error:
|
||||
* { "id": "...", "error": { "code": <int>, "message": "..." } }
|
||||
*
|
||||
* Error codes:
|
||||
* -32700 Parse error (invalid JSON)
|
||||
* -32600 Invalid request (missing id/method/params)
|
||||
* -32601 Method not found (unknown verb after enforcement)
|
||||
* -32602 Invalid params
|
||||
* 1001 ambiguous_role_selector
|
||||
* 1002 role_not_found
|
||||
* 1003 no_default_role
|
||||
* 1004 purpose_mismatch
|
||||
* 1005 curve_mismatch
|
||||
* 1006 mnemonic_not_loaded
|
||||
*/
|
||||
char *dispatcher_handle_request(dispatcher_ctx_t *ctx, const char *json_request);
|
||||
|
||||
|
||||
/* from server.h */
|
||||
|
||||
|
||||
#define SERVER_SOCKET_NAME_MAX 108
|
||||
#define SERVER_MAX_MSG_SIZE 65536
|
||||
|
||||
/* Caller identity */
|
||||
typedef struct {
|
||||
uid_t uid;
|
||||
gid_t gid;
|
||||
pid_t pid;
|
||||
char caller_id[64]; /* "uid:<n>" */
|
||||
} caller_identity_t;
|
||||
|
||||
/* Server context */
|
||||
typedef struct {
|
||||
char socket_name[SERVER_SOCKET_NAME_MAX]; /* abstract namespace name (without \0 prefix) */
|
||||
char last_error[256];
|
||||
int listen_fd;
|
||||
int running;
|
||||
dispatcher_ctx_t *dispatcher;
|
||||
policy_table_t *policy;
|
||||
int socket_name_explicit;
|
||||
} server_ctx_t;
|
||||
|
||||
/* Initialize server context. socket_name is the abstract namespace name (e.g. "nsigner").
|
||||
* socket_name_explicit should be non-zero when provided via --socket-name override. */
|
||||
void server_init(server_ctx_t *ctx, const char *socket_name, int socket_name_explicit,
|
||||
dispatcher_ctx_t *dispatcher, policy_table_t *policy);
|
||||
|
||||
/* Start listening. Returns 0 on success, -1 on error. */
|
||||
int server_start(server_ctx_t *ctx);
|
||||
|
||||
/* Get human-readable description of last server error. */
|
||||
const char *server_last_error(const server_ctx_t *ctx);
|
||||
|
||||
/* Handle one pending connection (non-blocking). Returns 1 if handled, 0 if nothing pending, -1 on error.
|
||||
* activity_cb is called with a description string for the TUI activity log. */
|
||||
typedef void (*server_activity_cb)(const char *message, void *user_data);
|
||||
int server_handle_one(server_ctx_t *ctx, server_activity_cb cb, void *cb_data);
|
||||
|
||||
/* Stop server and close socket */
|
||||
void server_stop(server_ctx_t *ctx);
|
||||
|
||||
/* Extract caller identity from connected fd */
|
||||
int server_get_caller(int fd, caller_identity_t *out);
|
||||
|
||||
|
||||
/* from socket_name.h */
|
||||
|
||||
|
||||
/*
|
||||
* Generate random socket name in format: nsigner_<word1>_<word2>
|
||||
* Returns 0 on success, -1 on error.
|
||||
*/
|
||||
int socket_name_random(char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from main.h */
|
||||
/*
|
||||
* nsigner main header - version information
|
||||
*
|
||||
* Version macros are auto-updated by increment_and_push.sh.
|
||||
*/
|
||||
|
||||
|
||||
/* Version information (auto-updated by build/version tooling) */
|
||||
#define NSIGNER_VERSION_MAJOR 0
|
||||
#define NSIGNER_VERSION_MINOR 0
|
||||
#define NSIGNER_VERSION_PATCH 2
|
||||
#define NSIGNER_VERSION "v0.0.2"
|
||||
|
||||
|
||||
/* NSIGNER_HEADERLESS_DECLS_END */
|
||||
|
||||
#include <nostr_core/nostr_common.h>
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
@@ -82,8 +521,8 @@ int main(void) {
|
||||
memset(&key_store, 0, sizeof(key_store));
|
||||
dispatcher_init(&dispatcher, &table, &mnemonic, &key_store);
|
||||
|
||||
derived = crypto_init();
|
||||
check_condition("crypto_init succeeds", derived == 0);
|
||||
derived = nostr_init();
|
||||
check_condition("nostr_init succeeds", derived == 0);
|
||||
|
||||
derived = crypto_derive_all(&key_store, &table, &mnemonic);
|
||||
check_condition("crypto_derive_all derives at least one key", derived >= 1);
|
||||
@@ -162,7 +601,7 @@ int main(void) {
|
||||
free(resp);
|
||||
|
||||
crypto_wipe(&key_store);
|
||||
crypto_cleanup();
|
||||
nostr_cleanup();
|
||||
|
||||
printf("%d/12 tests passed\n", g_passes);
|
||||
|
||||
|
||||
@@ -1,4 +1,444 @@
|
||||
#include "../src/enforcement.h"
|
||||
/* NSIGNER_HEADERLESS_DECLS_BEGIN */
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
#include <cJSON.h>
|
||||
|
||||
/* from secure_mem.h */
|
||||
|
||||
|
||||
/*
|
||||
* Secure memory buffer — mlock'd, zeroized on free.
|
||||
* Used for mnemonic phrases, private keys, and any sensitive material.
|
||||
*/
|
||||
typedef struct {
|
||||
void *data; /* pointer to locked allocation */
|
||||
size_t size; /* usable size in bytes */
|
||||
int locked; /* 1 if mlock succeeded */
|
||||
} secure_buf_t;
|
||||
|
||||
/* Allocate a secure buffer of `size` bytes. Returns 0 on success, -1 on failure. */
|
||||
int secure_buf_alloc(secure_buf_t *buf, size_t size);
|
||||
|
||||
/* Zeroize and free a secure buffer. Always succeeds (idempotent). */
|
||||
void secure_buf_free(secure_buf_t *buf);
|
||||
|
||||
/* Zeroize `len` bytes at `ptr` in a way the compiler cannot optimize away. */
|
||||
void secure_memzero(void *ptr, size_t len);
|
||||
|
||||
|
||||
/* from mnemonic.h */
|
||||
|
||||
|
||||
/* Maximum mnemonic length: 24 words * 10 chars avg + spaces + null = 256 is safe */
|
||||
#define MNEMONIC_MAX_LEN 256
|
||||
|
||||
/*
|
||||
* Mnemonic state — holds the loaded mnemonic in secure memory.
|
||||
* Only one mnemonic is active at a time per process.
|
||||
*/
|
||||
typedef struct {
|
||||
secure_buf_t buf; /* secure storage for the mnemonic string */
|
||||
int loaded; /* 1 if a mnemonic is currently loaded */
|
||||
int word_count; /* 12, 15, 18, 21, or 24 */
|
||||
} mnemonic_state_t;
|
||||
|
||||
/* Initialize mnemonic state (must be called before use). */
|
||||
void mnemonic_init(mnemonic_state_t *state);
|
||||
|
||||
/* Load a mnemonic string into secure memory. Validates word count (12/15/18/21/24).
|
||||
* Returns 0 on success, -1 on invalid input, -2 on memory error. */
|
||||
int mnemonic_load(mnemonic_state_t *state, const char *phrase);
|
||||
|
||||
/* Zeroize and unload the mnemonic. Idempotent. */
|
||||
void mnemonic_unload(mnemonic_state_t *state);
|
||||
|
||||
/* Check if a mnemonic is currently loaded. */
|
||||
int mnemonic_is_loaded(const mnemonic_state_t *state);
|
||||
|
||||
/* Get the mnemonic string (only valid while loaded). Returns NULL if not loaded. */
|
||||
const char *mnemonic_get_phrase(const mnemonic_state_t *state);
|
||||
|
||||
/* Generate a new BIP-39 mnemonic phrase (12/15/18/21/24 words) into out.
|
||||
* Returns 0 on success, -1 on invalid arguments or generation failure. */
|
||||
int mnemonic_generate(int word_count, char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from role_table.h */
|
||||
|
||||
|
||||
/* Maximum limits */
|
||||
#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 /* 64 hex chars + null + pad */
|
||||
#define ROLE_TABLE_MAX_ENTRIES 64
|
||||
|
||||
/* Purpose enum for fast comparison (string form kept for config/display) */
|
||||
typedef enum {
|
||||
PURPOSE_NOSTR = 0,
|
||||
PURPOSE_BITCOIN,
|
||||
PURPOSE_SSH,
|
||||
PURPOSE_AGE,
|
||||
PURPOSE_FIPS,
|
||||
PURPOSE_UNKNOWN
|
||||
} role_purpose_t;
|
||||
|
||||
/* Curve enum */
|
||||
typedef enum {
|
||||
CURVE_SECP256K1 = 0,
|
||||
CURVE_ED25519,
|
||||
CURVE_X25519,
|
||||
CURVE_UNKNOWN
|
||||
} role_curve_t;
|
||||
|
||||
/* Selector type — how this role's key is addressed */
|
||||
typedef enum {
|
||||
SELECTOR_NOSTR_INDEX, /* uses nostr_index shorthand */
|
||||
SELECTOR_ROLE_PATH /* uses explicit full path */
|
||||
} role_selector_type_t;
|
||||
|
||||
/* A single role entry */
|
||||
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; /* valid if selector_type == SELECTOR_NOSTR_INDEX */
|
||||
char role_path[ROLE_PATH_MAX]; /* valid if selector_type == SELECTOR_ROLE_PATH */
|
||||
char pubkey_hex[ROLE_PUBKEY_HEX_MAX]; /* filled after derivation, empty until then */
|
||||
int derived; /* 1 if pubkey_hex has been populated */
|
||||
} role_entry_t;
|
||||
|
||||
/* The role table */
|
||||
typedef struct {
|
||||
role_entry_t entries[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} role_table_t;
|
||||
|
||||
/* Initialize an empty role table */
|
||||
void role_table_init(role_table_t *table);
|
||||
|
||||
/* Add a role entry. Returns 0 on success, -1 if table full, -2 if name duplicate. */
|
||||
int role_table_add(role_table_t *table, const role_entry_t *entry);
|
||||
|
||||
/* Find a role by name. Returns pointer to entry or NULL. */
|
||||
role_entry_t *role_table_find_by_name(role_table_t *table, const char *name);
|
||||
|
||||
/* Find a role by nostr_index. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_nostr_index(role_table_t *table, int index);
|
||||
|
||||
/* Find a role by role_path. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_path(role_table_t *table, const char *path);
|
||||
|
||||
/* Get the default role (named "main"). Returns pointer or NULL if no "main" role. */
|
||||
role_entry_t *role_table_get_default(role_table_t *table);
|
||||
|
||||
/* Parse purpose string to enum */
|
||||
role_purpose_t role_purpose_from_str(const char *s);
|
||||
|
||||
/* Parse curve string to enum */
|
||||
role_curve_t role_curve_from_str(const char *s);
|
||||
|
||||
/* Purpose enum to string */
|
||||
const char *role_purpose_to_str(role_purpose_t p);
|
||||
|
||||
/* Curve enum to string */
|
||||
const char *role_curve_to_str(role_curve_t c);
|
||||
|
||||
|
||||
/* from selector.h */
|
||||
|
||||
|
||||
/* Error codes for selector resolution */
|
||||
#define SELECTOR_OK 0
|
||||
#define SELECTOR_ERR_AMBIGUOUS -1 /* multiple selectors specified */
|
||||
#define SELECTOR_ERR_NOT_FOUND -2 /* no matching role in table */
|
||||
#define SELECTOR_ERR_NO_DEFAULT -3 /* no selector given and no "main" role exists */
|
||||
|
||||
/* Parsed selector from a request's options object */
|
||||
typedef struct {
|
||||
int has_role; /* 1 if "role" field was present */
|
||||
char role_name[ROLE_NAME_MAX];
|
||||
|
||||
int has_nostr_index; /* 1 if "nostr_index" field was present */
|
||||
int nostr_index;
|
||||
|
||||
int has_role_path; /* 1 if "role_path" field was present */
|
||||
char role_path[ROLE_PATH_MAX];
|
||||
} selector_request_t;
|
||||
|
||||
/* Initialize a selector request (all fields zeroed/unset) */
|
||||
void selector_request_init(selector_request_t *req);
|
||||
|
||||
/*
|
||||
* Resolve a selector request against the role table.
|
||||
* On success (returns SELECTOR_OK), *out points to the matched role_entry_t.
|
||||
* On failure, returns one of the SELECTOR_ERR_* codes and *out is NULL.
|
||||
*/
|
||||
int selector_resolve(const selector_request_t *req, role_table_t *table, role_entry_t **out);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for a selector error code.
|
||||
*/
|
||||
const char *selector_strerror(int err);
|
||||
|
||||
|
||||
/* from enforcement.h */
|
||||
|
||||
|
||||
/* Error codes */
|
||||
#define ENFORCE_OK 0
|
||||
#define ENFORCE_ERR_PURPOSE -1 /* purpose mismatch */
|
||||
#define ENFORCE_ERR_CURVE -2 /* curve mismatch */
|
||||
#define ENFORCE_ERR_UNKNOWN_VERB -3 /* verb not recognized */
|
||||
|
||||
/* Known verbs */
|
||||
#define VERB_SIGN_EVENT "sign_event"
|
||||
#define VERB_GET_PUBLIC_KEY "get_public_key"
|
||||
#define VERB_NIP44_ENCRYPT "nip44_encrypt"
|
||||
#define VERB_NIP44_DECRYPT "nip44_decrypt"
|
||||
#define VERB_NIP04_ENCRYPT "nip04_encrypt"
|
||||
#define VERB_NIP04_DECRYPT "nip04_decrypt"
|
||||
|
||||
/*
|
||||
* Check whether `verb` is allowed to execute against `role`.
|
||||
* Returns ENFORCE_OK if allowed, or an ENFORCE_ERR_* code.
|
||||
*
|
||||
* The enforcement rules are:
|
||||
* - All nostr verbs (sign_event, get_public_key, nip44_*, nip04_*) require:
|
||||
* purpose == PURPOSE_NOSTR and curve == CURVE_SECP256K1
|
||||
* - Unknown verbs return ENFORCE_ERR_UNKNOWN_VERB (fail-closed).
|
||||
*/
|
||||
int enforce_verb_role(const char *verb, const role_entry_t *role);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for an enforcement error code.
|
||||
*/
|
||||
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 64
|
||||
|
||||
/* Prompt behavior */
|
||||
typedef enum {
|
||||
PROMPT_NEVER = 0,
|
||||
PROMPT_FIRST_PER_BOOT,
|
||||
PROMPT_EVERY_REQUEST,
|
||||
PROMPT_DENY
|
||||
} prompt_mode_t;
|
||||
|
||||
/* A single policy entry */
|
||||
typedef struct {
|
||||
char caller[POLICY_CALLER_MAX_LEN]; /* e.g. "uid:1000" or "*" for any */
|
||||
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;
|
||||
prompt_mode_t prompt;
|
||||
} policy_entry_t;
|
||||
|
||||
/* Policy table */
|
||||
typedef struct {
|
||||
policy_entry_t entries[POLICY_MAX_ENTRIES];
|
||||
int count;
|
||||
} policy_table_t;
|
||||
|
||||
/* Policy check result */
|
||||
#define POLICY_ALLOW 0
|
||||
#define POLICY_DENY -1
|
||||
#define POLICY_PROMPT -2 /* would need user confirmation */
|
||||
#define POLICY_NO_MATCH -3 /* no policy entry matched (fail-closed = deny) */
|
||||
|
||||
/* Initialize policy table */
|
||||
void policy_table_init(policy_table_t *table);
|
||||
|
||||
/* Initialize default policy: allow same-uid, deny others */
|
||||
void policy_init_default(policy_table_t *table, uid_t owner_uid);
|
||||
|
||||
/* Add a policy entry. Returns 0 on success, -1 if full. */
|
||||
int policy_table_add(policy_table_t *table, const policy_entry_t *entry);
|
||||
|
||||
/*
|
||||
* Check whether caller_id is allowed to invoke `verb` on `role_name` with given `purpose`.
|
||||
* Returns POLICY_ALLOW, POLICY_DENY, POLICY_PROMPT, or POLICY_NO_MATCH.
|
||||
*/
|
||||
int policy_check(const policy_table_t *table, const char *caller_id,
|
||||
const char *verb, const char *role_name, const char *purpose);
|
||||
|
||||
/* Parse prompt mode from string */
|
||||
prompt_mode_t prompt_mode_from_str(const char *s);
|
||||
|
||||
/* Prompt mode to string */
|
||||
const char *prompt_mode_to_str(prompt_mode_t m);
|
||||
|
||||
|
||||
/* from crypto.h */
|
||||
|
||||
|
||||
/* Per-role derived key material (stored in secure memory) */
|
||||
typedef struct {
|
||||
secure_buf_t private_key; /* 32 bytes, mlock'd */
|
||||
unsigned char public_key[32];
|
||||
char pubkey_hex[65]; /* 64 hex chars + null */
|
||||
char npub[128]; /* bech32 npub */
|
||||
int valid;
|
||||
} derived_key_t;
|
||||
|
||||
/* Key store — holds derived keys for all roles */
|
||||
typedef struct {
|
||||
derived_key_t keys[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} key_store_t;
|
||||
|
||||
/* Derive keys for all roles in the table using the loaded mnemonic.
|
||||
* Populates key_store and sets role->pubkey_hex and role->derived for each role.
|
||||
* Only derives for roles with purpose=nostr and curve=secp256k1 (for now).
|
||||
* Returns number of keys derived, or -1 on error. */
|
||||
int crypto_derive_all(key_store_t *store, role_table_t *table, const mnemonic_state_t *mnemonic);
|
||||
|
||||
/* Get the derived private key for a role (by table index). Returns NULL if not derived. */
|
||||
const unsigned char *crypto_get_private_key(const key_store_t *store, int role_index);
|
||||
|
||||
/* Get the derived public key hex for a role. Returns NULL if not derived. */
|
||||
const char *crypto_get_pubkey_hex(const key_store_t *store, int role_index);
|
||||
|
||||
/* Sign a Nostr event. event_json is the unsigned event JSON string.
|
||||
* Returns a newly-allocated string containing the signed event JSON, or NULL on error.
|
||||
* Caller must free() the returned string. */
|
||||
char *crypto_sign_event(const key_store_t *store, int role_index, const char *event_json);
|
||||
|
||||
/* Zeroize all derived keys in the store. */
|
||||
void crypto_wipe(key_store_t *store);
|
||||
|
||||
|
||||
/* from dispatcher.h */
|
||||
|
||||
|
||||
/* Dispatcher context — holds references to shared state */
|
||||
typedef struct {
|
||||
role_table_t *role_table;
|
||||
mnemonic_state_t *mnemonic;
|
||||
key_store_t *key_store;
|
||||
} dispatcher_ctx_t;
|
||||
|
||||
/* Initialize dispatcher context */
|
||||
void dispatcher_init(dispatcher_ctx_t *ctx, role_table_t *table, mnemonic_state_t *mnemonic, key_store_t *key_store);
|
||||
|
||||
/*
|
||||
* Process a JSON-RPC request string and produce a JSON-RPC response string.
|
||||
*
|
||||
* The caller owns the returned string and must free() it.
|
||||
* Returns NULL only on catastrophic allocation failure.
|
||||
*
|
||||
* Response format on success:
|
||||
* { "id": "...", "result": "..." }
|
||||
*
|
||||
* Response format on error:
|
||||
* { "id": "...", "error": { "code": <int>, "message": "..." } }
|
||||
*
|
||||
* Error codes:
|
||||
* -32700 Parse error (invalid JSON)
|
||||
* -32600 Invalid request (missing id/method/params)
|
||||
* -32601 Method not found (unknown verb after enforcement)
|
||||
* -32602 Invalid params
|
||||
* 1001 ambiguous_role_selector
|
||||
* 1002 role_not_found
|
||||
* 1003 no_default_role
|
||||
* 1004 purpose_mismatch
|
||||
* 1005 curve_mismatch
|
||||
* 1006 mnemonic_not_loaded
|
||||
*/
|
||||
char *dispatcher_handle_request(dispatcher_ctx_t *ctx, const char *json_request);
|
||||
|
||||
|
||||
/* from server.h */
|
||||
|
||||
|
||||
#define SERVER_SOCKET_NAME_MAX 108
|
||||
#define SERVER_MAX_MSG_SIZE 65536
|
||||
|
||||
/* Caller identity */
|
||||
typedef struct {
|
||||
uid_t uid;
|
||||
gid_t gid;
|
||||
pid_t pid;
|
||||
char caller_id[64]; /* "uid:<n>" */
|
||||
} caller_identity_t;
|
||||
|
||||
/* Server context */
|
||||
typedef struct {
|
||||
char socket_name[SERVER_SOCKET_NAME_MAX]; /* abstract namespace name (without \0 prefix) */
|
||||
char last_error[256];
|
||||
int listen_fd;
|
||||
int running;
|
||||
dispatcher_ctx_t *dispatcher;
|
||||
policy_table_t *policy;
|
||||
int socket_name_explicit;
|
||||
} server_ctx_t;
|
||||
|
||||
/* Initialize server context. socket_name is the abstract namespace name (e.g. "nsigner").
|
||||
* socket_name_explicit should be non-zero when provided via --socket-name override. */
|
||||
void server_init(server_ctx_t *ctx, const char *socket_name, int socket_name_explicit,
|
||||
dispatcher_ctx_t *dispatcher, policy_table_t *policy);
|
||||
|
||||
/* Start listening. Returns 0 on success, -1 on error. */
|
||||
int server_start(server_ctx_t *ctx);
|
||||
|
||||
/* Get human-readable description of last server error. */
|
||||
const char *server_last_error(const server_ctx_t *ctx);
|
||||
|
||||
/* Handle one pending connection (non-blocking). Returns 1 if handled, 0 if nothing pending, -1 on error.
|
||||
* activity_cb is called with a description string for the TUI activity log. */
|
||||
typedef void (*server_activity_cb)(const char *message, void *user_data);
|
||||
int server_handle_one(server_ctx_t *ctx, server_activity_cb cb, void *cb_data);
|
||||
|
||||
/* Stop server and close socket */
|
||||
void server_stop(server_ctx_t *ctx);
|
||||
|
||||
/* Extract caller identity from connected fd */
|
||||
int server_get_caller(int fd, caller_identity_t *out);
|
||||
|
||||
|
||||
/* from socket_name.h */
|
||||
|
||||
|
||||
/*
|
||||
* Generate random socket name in format: nsigner_<word1>_<word2>
|
||||
* Returns 0 on success, -1 on error.
|
||||
*/
|
||||
int socket_name_random(char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from main.h */
|
||||
/*
|
||||
* nsigner main header - version information
|
||||
*
|
||||
* Version macros are auto-updated by increment_and_push.sh.
|
||||
*/
|
||||
|
||||
|
||||
/* Version information (auto-updated by build/version tooling) */
|
||||
#define NSIGNER_VERSION_MAJOR 0
|
||||
#define NSIGNER_VERSION_MINOR 0
|
||||
#define NSIGNER_VERSION_PATCH 2
|
||||
#define NSIGNER_VERSION "v0.0.2"
|
||||
|
||||
|
||||
/* NSIGNER_HEADERLESS_DECLS_END */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
@@ -1,5 +1,447 @@
|
||||
#define _GNU_SOURCE
|
||||
|
||||
/* NSIGNER_HEADERLESS_DECLS_BEGIN */
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
#include <cJSON.h>
|
||||
|
||||
/* from secure_mem.h */
|
||||
|
||||
|
||||
/*
|
||||
* Secure memory buffer — mlock'd, zeroized on free.
|
||||
* Used for mnemonic phrases, private keys, and any sensitive material.
|
||||
*/
|
||||
typedef struct {
|
||||
void *data; /* pointer to locked allocation */
|
||||
size_t size; /* usable size in bytes */
|
||||
int locked; /* 1 if mlock succeeded */
|
||||
} secure_buf_t;
|
||||
|
||||
/* Allocate a secure buffer of `size` bytes. Returns 0 on success, -1 on failure. */
|
||||
int secure_buf_alloc(secure_buf_t *buf, size_t size);
|
||||
|
||||
/* Zeroize and free a secure buffer. Always succeeds (idempotent). */
|
||||
void secure_buf_free(secure_buf_t *buf);
|
||||
|
||||
/* Zeroize `len` bytes at `ptr` in a way the compiler cannot optimize away. */
|
||||
void secure_memzero(void *ptr, size_t len);
|
||||
|
||||
|
||||
/* from mnemonic.h */
|
||||
|
||||
|
||||
/* Maximum mnemonic length: 24 words * 10 chars avg + spaces + null = 256 is safe */
|
||||
#define MNEMONIC_MAX_LEN 256
|
||||
|
||||
/*
|
||||
* Mnemonic state — holds the loaded mnemonic in secure memory.
|
||||
* Only one mnemonic is active at a time per process.
|
||||
*/
|
||||
typedef struct {
|
||||
secure_buf_t buf; /* secure storage for the mnemonic string */
|
||||
int loaded; /* 1 if a mnemonic is currently loaded */
|
||||
int word_count; /* 12, 15, 18, 21, or 24 */
|
||||
} mnemonic_state_t;
|
||||
|
||||
/* Initialize mnemonic state (must be called before use). */
|
||||
void mnemonic_init(mnemonic_state_t *state);
|
||||
|
||||
/* Load a mnemonic string into secure memory. Validates word count (12/15/18/21/24).
|
||||
* Returns 0 on success, -1 on invalid input, -2 on memory error. */
|
||||
int mnemonic_load(mnemonic_state_t *state, const char *phrase);
|
||||
|
||||
/* Zeroize and unload the mnemonic. Idempotent. */
|
||||
void mnemonic_unload(mnemonic_state_t *state);
|
||||
|
||||
/* Check if a mnemonic is currently loaded. */
|
||||
int mnemonic_is_loaded(const mnemonic_state_t *state);
|
||||
|
||||
/* Get the mnemonic string (only valid while loaded). Returns NULL if not loaded. */
|
||||
const char *mnemonic_get_phrase(const mnemonic_state_t *state);
|
||||
|
||||
/* Generate a new BIP-39 mnemonic phrase (12/15/18/21/24 words) into out.
|
||||
* Returns 0 on success, -1 on invalid arguments or generation failure. */
|
||||
int mnemonic_generate(int word_count, char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from role_table.h */
|
||||
|
||||
|
||||
/* Maximum limits */
|
||||
#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 /* 64 hex chars + null + pad */
|
||||
#define ROLE_TABLE_MAX_ENTRIES 64
|
||||
|
||||
/* Purpose enum for fast comparison (string form kept for config/display) */
|
||||
typedef enum {
|
||||
PURPOSE_NOSTR = 0,
|
||||
PURPOSE_BITCOIN,
|
||||
PURPOSE_SSH,
|
||||
PURPOSE_AGE,
|
||||
PURPOSE_FIPS,
|
||||
PURPOSE_UNKNOWN
|
||||
} role_purpose_t;
|
||||
|
||||
/* Curve enum */
|
||||
typedef enum {
|
||||
CURVE_SECP256K1 = 0,
|
||||
CURVE_ED25519,
|
||||
CURVE_X25519,
|
||||
CURVE_UNKNOWN
|
||||
} role_curve_t;
|
||||
|
||||
/* Selector type — how this role's key is addressed */
|
||||
typedef enum {
|
||||
SELECTOR_NOSTR_INDEX, /* uses nostr_index shorthand */
|
||||
SELECTOR_ROLE_PATH /* uses explicit full path */
|
||||
} role_selector_type_t;
|
||||
|
||||
/* A single role entry */
|
||||
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; /* valid if selector_type == SELECTOR_NOSTR_INDEX */
|
||||
char role_path[ROLE_PATH_MAX]; /* valid if selector_type == SELECTOR_ROLE_PATH */
|
||||
char pubkey_hex[ROLE_PUBKEY_HEX_MAX]; /* filled after derivation, empty until then */
|
||||
int derived; /* 1 if pubkey_hex has been populated */
|
||||
} role_entry_t;
|
||||
|
||||
/* The role table */
|
||||
typedef struct {
|
||||
role_entry_t entries[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} role_table_t;
|
||||
|
||||
/* Initialize an empty role table */
|
||||
void role_table_init(role_table_t *table);
|
||||
|
||||
/* Add a role entry. Returns 0 on success, -1 if table full, -2 if name duplicate. */
|
||||
int role_table_add(role_table_t *table, const role_entry_t *entry);
|
||||
|
||||
/* Find a role by name. Returns pointer to entry or NULL. */
|
||||
role_entry_t *role_table_find_by_name(role_table_t *table, const char *name);
|
||||
|
||||
/* Find a role by nostr_index. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_nostr_index(role_table_t *table, int index);
|
||||
|
||||
/* Find a role by role_path. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_path(role_table_t *table, const char *path);
|
||||
|
||||
/* Get the default role (named "main"). Returns pointer or NULL if no "main" role. */
|
||||
role_entry_t *role_table_get_default(role_table_t *table);
|
||||
|
||||
/* Parse purpose string to enum */
|
||||
role_purpose_t role_purpose_from_str(const char *s);
|
||||
|
||||
/* Parse curve string to enum */
|
||||
role_curve_t role_curve_from_str(const char *s);
|
||||
|
||||
/* Purpose enum to string */
|
||||
const char *role_purpose_to_str(role_purpose_t p);
|
||||
|
||||
/* Curve enum to string */
|
||||
const char *role_curve_to_str(role_curve_t c);
|
||||
|
||||
|
||||
/* from selector.h */
|
||||
|
||||
|
||||
/* Error codes for selector resolution */
|
||||
#define SELECTOR_OK 0
|
||||
#define SELECTOR_ERR_AMBIGUOUS -1 /* multiple selectors specified */
|
||||
#define SELECTOR_ERR_NOT_FOUND -2 /* no matching role in table */
|
||||
#define SELECTOR_ERR_NO_DEFAULT -3 /* no selector given and no "main" role exists */
|
||||
|
||||
/* Parsed selector from a request's options object */
|
||||
typedef struct {
|
||||
int has_role; /* 1 if "role" field was present */
|
||||
char role_name[ROLE_NAME_MAX];
|
||||
|
||||
int has_nostr_index; /* 1 if "nostr_index" field was present */
|
||||
int nostr_index;
|
||||
|
||||
int has_role_path; /* 1 if "role_path" field was present */
|
||||
char role_path[ROLE_PATH_MAX];
|
||||
} selector_request_t;
|
||||
|
||||
/* Initialize a selector request (all fields zeroed/unset) */
|
||||
void selector_request_init(selector_request_t *req);
|
||||
|
||||
/*
|
||||
* Resolve a selector request against the role table.
|
||||
* On success (returns SELECTOR_OK), *out points to the matched role_entry_t.
|
||||
* On failure, returns one of the SELECTOR_ERR_* codes and *out is NULL.
|
||||
*/
|
||||
int selector_resolve(const selector_request_t *req, role_table_t *table, role_entry_t **out);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for a selector error code.
|
||||
*/
|
||||
const char *selector_strerror(int err);
|
||||
|
||||
|
||||
/* from enforcement.h */
|
||||
|
||||
|
||||
/* Error codes */
|
||||
#define ENFORCE_OK 0
|
||||
#define ENFORCE_ERR_PURPOSE -1 /* purpose mismatch */
|
||||
#define ENFORCE_ERR_CURVE -2 /* curve mismatch */
|
||||
#define ENFORCE_ERR_UNKNOWN_VERB -3 /* verb not recognized */
|
||||
|
||||
/* Known verbs */
|
||||
#define VERB_SIGN_EVENT "sign_event"
|
||||
#define VERB_GET_PUBLIC_KEY "get_public_key"
|
||||
#define VERB_NIP44_ENCRYPT "nip44_encrypt"
|
||||
#define VERB_NIP44_DECRYPT "nip44_decrypt"
|
||||
#define VERB_NIP04_ENCRYPT "nip04_encrypt"
|
||||
#define VERB_NIP04_DECRYPT "nip04_decrypt"
|
||||
|
||||
/*
|
||||
* Check whether `verb` is allowed to execute against `role`.
|
||||
* Returns ENFORCE_OK if allowed, or an ENFORCE_ERR_* code.
|
||||
*
|
||||
* The enforcement rules are:
|
||||
* - All nostr verbs (sign_event, get_public_key, nip44_*, nip04_*) require:
|
||||
* purpose == PURPOSE_NOSTR and curve == CURVE_SECP256K1
|
||||
* - Unknown verbs return ENFORCE_ERR_UNKNOWN_VERB (fail-closed).
|
||||
*/
|
||||
int enforce_verb_role(const char *verb, const role_entry_t *role);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for an enforcement error code.
|
||||
*/
|
||||
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 64
|
||||
|
||||
/* Prompt behavior */
|
||||
typedef enum {
|
||||
PROMPT_NEVER = 0,
|
||||
PROMPT_FIRST_PER_BOOT,
|
||||
PROMPT_EVERY_REQUEST,
|
||||
PROMPT_DENY
|
||||
} prompt_mode_t;
|
||||
|
||||
/* A single policy entry */
|
||||
typedef struct {
|
||||
char caller[POLICY_CALLER_MAX_LEN]; /* e.g. "uid:1000" or "*" for any */
|
||||
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;
|
||||
prompt_mode_t prompt;
|
||||
} policy_entry_t;
|
||||
|
||||
/* Policy table */
|
||||
typedef struct {
|
||||
policy_entry_t entries[POLICY_MAX_ENTRIES];
|
||||
int count;
|
||||
} policy_table_t;
|
||||
|
||||
/* Policy check result */
|
||||
#define POLICY_ALLOW 0
|
||||
#define POLICY_DENY -1
|
||||
#define POLICY_PROMPT -2 /* would need user confirmation */
|
||||
#define POLICY_NO_MATCH -3 /* no policy entry matched (fail-closed = deny) */
|
||||
|
||||
/* Initialize policy table */
|
||||
void policy_table_init(policy_table_t *table);
|
||||
|
||||
/* Initialize default policy: allow same-uid, deny others */
|
||||
void policy_init_default(policy_table_t *table, uid_t owner_uid);
|
||||
|
||||
/* Add a policy entry. Returns 0 on success, -1 if full. */
|
||||
int policy_table_add(policy_table_t *table, const policy_entry_t *entry);
|
||||
|
||||
/*
|
||||
* Check whether caller_id is allowed to invoke `verb` on `role_name` with given `purpose`.
|
||||
* Returns POLICY_ALLOW, POLICY_DENY, POLICY_PROMPT, or POLICY_NO_MATCH.
|
||||
*/
|
||||
int policy_check(const policy_table_t *table, const char *caller_id,
|
||||
const char *verb, const char *role_name, const char *purpose);
|
||||
|
||||
/* Parse prompt mode from string */
|
||||
prompt_mode_t prompt_mode_from_str(const char *s);
|
||||
|
||||
/* Prompt mode to string */
|
||||
const char *prompt_mode_to_str(prompt_mode_t m);
|
||||
|
||||
|
||||
/* from crypto.h */
|
||||
|
||||
|
||||
/* Per-role derived key material (stored in secure memory) */
|
||||
typedef struct {
|
||||
secure_buf_t private_key; /* 32 bytes, mlock'd */
|
||||
unsigned char public_key[32];
|
||||
char pubkey_hex[65]; /* 64 hex chars + null */
|
||||
char npub[128]; /* bech32 npub */
|
||||
int valid;
|
||||
} derived_key_t;
|
||||
|
||||
/* Key store — holds derived keys for all roles */
|
||||
typedef struct {
|
||||
derived_key_t keys[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} key_store_t;
|
||||
|
||||
/* Derive keys for all roles in the table using the loaded mnemonic.
|
||||
* Populates key_store and sets role->pubkey_hex and role->derived for each role.
|
||||
* Only derives for roles with purpose=nostr and curve=secp256k1 (for now).
|
||||
* Returns number of keys derived, or -1 on error. */
|
||||
int crypto_derive_all(key_store_t *store, role_table_t *table, const mnemonic_state_t *mnemonic);
|
||||
|
||||
/* Get the derived private key for a role (by table index). Returns NULL if not derived. */
|
||||
const unsigned char *crypto_get_private_key(const key_store_t *store, int role_index);
|
||||
|
||||
/* Get the derived public key hex for a role. Returns NULL if not derived. */
|
||||
const char *crypto_get_pubkey_hex(const key_store_t *store, int role_index);
|
||||
|
||||
/* Sign a Nostr event. event_json is the unsigned event JSON string.
|
||||
* Returns a newly-allocated string containing the signed event JSON, or NULL on error.
|
||||
* Caller must free() the returned string. */
|
||||
char *crypto_sign_event(const key_store_t *store, int role_index, const char *event_json);
|
||||
|
||||
/* Zeroize all derived keys in the store. */
|
||||
void crypto_wipe(key_store_t *store);
|
||||
|
||||
|
||||
/* from dispatcher.h */
|
||||
|
||||
|
||||
/* Dispatcher context — holds references to shared state */
|
||||
typedef struct {
|
||||
role_table_t *role_table;
|
||||
mnemonic_state_t *mnemonic;
|
||||
key_store_t *key_store;
|
||||
} dispatcher_ctx_t;
|
||||
|
||||
/* Initialize dispatcher context */
|
||||
void dispatcher_init(dispatcher_ctx_t *ctx, role_table_t *table, mnemonic_state_t *mnemonic, key_store_t *key_store);
|
||||
|
||||
/*
|
||||
* Process a JSON-RPC request string and produce a JSON-RPC response string.
|
||||
*
|
||||
* The caller owns the returned string and must free() it.
|
||||
* Returns NULL only on catastrophic allocation failure.
|
||||
*
|
||||
* Response format on success:
|
||||
* { "id": "...", "result": "..." }
|
||||
*
|
||||
* Response format on error:
|
||||
* { "id": "...", "error": { "code": <int>, "message": "..." } }
|
||||
*
|
||||
* Error codes:
|
||||
* -32700 Parse error (invalid JSON)
|
||||
* -32600 Invalid request (missing id/method/params)
|
||||
* -32601 Method not found (unknown verb after enforcement)
|
||||
* -32602 Invalid params
|
||||
* 1001 ambiguous_role_selector
|
||||
* 1002 role_not_found
|
||||
* 1003 no_default_role
|
||||
* 1004 purpose_mismatch
|
||||
* 1005 curve_mismatch
|
||||
* 1006 mnemonic_not_loaded
|
||||
*/
|
||||
char *dispatcher_handle_request(dispatcher_ctx_t *ctx, const char *json_request);
|
||||
|
||||
|
||||
/* from server.h */
|
||||
|
||||
|
||||
#define SERVER_SOCKET_NAME_MAX 108
|
||||
#define SERVER_MAX_MSG_SIZE 65536
|
||||
|
||||
/* Caller identity */
|
||||
typedef struct {
|
||||
uid_t uid;
|
||||
gid_t gid;
|
||||
pid_t pid;
|
||||
char caller_id[64]; /* "uid:<n>" */
|
||||
} caller_identity_t;
|
||||
|
||||
/* Server context */
|
||||
typedef struct {
|
||||
char socket_name[SERVER_SOCKET_NAME_MAX]; /* abstract namespace name (without \0 prefix) */
|
||||
char last_error[256];
|
||||
int listen_fd;
|
||||
int running;
|
||||
dispatcher_ctx_t *dispatcher;
|
||||
policy_table_t *policy;
|
||||
int socket_name_explicit;
|
||||
} server_ctx_t;
|
||||
|
||||
/* Initialize server context. socket_name is the abstract namespace name (e.g. "nsigner").
|
||||
* socket_name_explicit should be non-zero when provided via --socket-name override. */
|
||||
void server_init(server_ctx_t *ctx, const char *socket_name, int socket_name_explicit,
|
||||
dispatcher_ctx_t *dispatcher, policy_table_t *policy);
|
||||
|
||||
/* Start listening. Returns 0 on success, -1 on error. */
|
||||
int server_start(server_ctx_t *ctx);
|
||||
|
||||
/* Get human-readable description of last server error. */
|
||||
const char *server_last_error(const server_ctx_t *ctx);
|
||||
|
||||
/* Handle one pending connection (non-blocking). Returns 1 if handled, 0 if nothing pending, -1 on error.
|
||||
* activity_cb is called with a description string for the TUI activity log. */
|
||||
typedef void (*server_activity_cb)(const char *message, void *user_data);
|
||||
int server_handle_one(server_ctx_t *ctx, server_activity_cb cb, void *cb_data);
|
||||
|
||||
/* Stop server and close socket */
|
||||
void server_stop(server_ctx_t *ctx);
|
||||
|
||||
/* Extract caller identity from connected fd */
|
||||
int server_get_caller(int fd, caller_identity_t *out);
|
||||
|
||||
|
||||
/* from socket_name.h */
|
||||
|
||||
|
||||
/*
|
||||
* Generate random socket name in format: nsigner_<word1>_<word2>
|
||||
* Returns 0 on success, -1 on error.
|
||||
*/
|
||||
int socket_name_random(char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from main.h */
|
||||
/*
|
||||
* nsigner main header - version information
|
||||
*
|
||||
* Version macros are auto-updated by increment_and_push.sh.
|
||||
*/
|
||||
|
||||
|
||||
/* Version information (auto-updated by build/version tooling) */
|
||||
#define NSIGNER_VERSION_MAJOR 0
|
||||
#define NSIGNER_VERSION_MINOR 0
|
||||
#define NSIGNER_VERSION_PATCH 2
|
||||
#define NSIGNER_VERSION "v0.0.2"
|
||||
|
||||
|
||||
/* NSIGNER_HEADERLESS_DECLS_END */
|
||||
|
||||
#include <arpa/inet.h>
|
||||
#include <errno.h>
|
||||
#include <signal.h>
|
||||
|
||||
@@ -1,4 +1,444 @@
|
||||
#include "../src/mnemonic.h"
|
||||
/* NSIGNER_HEADERLESS_DECLS_BEGIN */
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
#include <cJSON.h>
|
||||
|
||||
/* from secure_mem.h */
|
||||
|
||||
|
||||
/*
|
||||
* Secure memory buffer — mlock'd, zeroized on free.
|
||||
* Used for mnemonic phrases, private keys, and any sensitive material.
|
||||
*/
|
||||
typedef struct {
|
||||
void *data; /* pointer to locked allocation */
|
||||
size_t size; /* usable size in bytes */
|
||||
int locked; /* 1 if mlock succeeded */
|
||||
} secure_buf_t;
|
||||
|
||||
/* Allocate a secure buffer of `size` bytes. Returns 0 on success, -1 on failure. */
|
||||
int secure_buf_alloc(secure_buf_t *buf, size_t size);
|
||||
|
||||
/* Zeroize and free a secure buffer. Always succeeds (idempotent). */
|
||||
void secure_buf_free(secure_buf_t *buf);
|
||||
|
||||
/* Zeroize `len` bytes at `ptr` in a way the compiler cannot optimize away. */
|
||||
void secure_memzero(void *ptr, size_t len);
|
||||
|
||||
|
||||
/* from mnemonic.h */
|
||||
|
||||
|
||||
/* Maximum mnemonic length: 24 words * 10 chars avg + spaces + null = 256 is safe */
|
||||
#define MNEMONIC_MAX_LEN 256
|
||||
|
||||
/*
|
||||
* Mnemonic state — holds the loaded mnemonic in secure memory.
|
||||
* Only one mnemonic is active at a time per process.
|
||||
*/
|
||||
typedef struct {
|
||||
secure_buf_t buf; /* secure storage for the mnemonic string */
|
||||
int loaded; /* 1 if a mnemonic is currently loaded */
|
||||
int word_count; /* 12, 15, 18, 21, or 24 */
|
||||
} mnemonic_state_t;
|
||||
|
||||
/* Initialize mnemonic state (must be called before use). */
|
||||
void mnemonic_init(mnemonic_state_t *state);
|
||||
|
||||
/* Load a mnemonic string into secure memory. Validates word count (12/15/18/21/24).
|
||||
* Returns 0 on success, -1 on invalid input, -2 on memory error. */
|
||||
int mnemonic_load(mnemonic_state_t *state, const char *phrase);
|
||||
|
||||
/* Zeroize and unload the mnemonic. Idempotent. */
|
||||
void mnemonic_unload(mnemonic_state_t *state);
|
||||
|
||||
/* Check if a mnemonic is currently loaded. */
|
||||
int mnemonic_is_loaded(const mnemonic_state_t *state);
|
||||
|
||||
/* Get the mnemonic string (only valid while loaded). Returns NULL if not loaded. */
|
||||
const char *mnemonic_get_phrase(const mnemonic_state_t *state);
|
||||
|
||||
/* Generate a new BIP-39 mnemonic phrase (12/15/18/21/24 words) into out.
|
||||
* Returns 0 on success, -1 on invalid arguments or generation failure. */
|
||||
int mnemonic_generate(int word_count, char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from role_table.h */
|
||||
|
||||
|
||||
/* Maximum limits */
|
||||
#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 /* 64 hex chars + null + pad */
|
||||
#define ROLE_TABLE_MAX_ENTRIES 64
|
||||
|
||||
/* Purpose enum for fast comparison (string form kept for config/display) */
|
||||
typedef enum {
|
||||
PURPOSE_NOSTR = 0,
|
||||
PURPOSE_BITCOIN,
|
||||
PURPOSE_SSH,
|
||||
PURPOSE_AGE,
|
||||
PURPOSE_FIPS,
|
||||
PURPOSE_UNKNOWN
|
||||
} role_purpose_t;
|
||||
|
||||
/* Curve enum */
|
||||
typedef enum {
|
||||
CURVE_SECP256K1 = 0,
|
||||
CURVE_ED25519,
|
||||
CURVE_X25519,
|
||||
CURVE_UNKNOWN
|
||||
} role_curve_t;
|
||||
|
||||
/* Selector type — how this role's key is addressed */
|
||||
typedef enum {
|
||||
SELECTOR_NOSTR_INDEX, /* uses nostr_index shorthand */
|
||||
SELECTOR_ROLE_PATH /* uses explicit full path */
|
||||
} role_selector_type_t;
|
||||
|
||||
/* A single role entry */
|
||||
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; /* valid if selector_type == SELECTOR_NOSTR_INDEX */
|
||||
char role_path[ROLE_PATH_MAX]; /* valid if selector_type == SELECTOR_ROLE_PATH */
|
||||
char pubkey_hex[ROLE_PUBKEY_HEX_MAX]; /* filled after derivation, empty until then */
|
||||
int derived; /* 1 if pubkey_hex has been populated */
|
||||
} role_entry_t;
|
||||
|
||||
/* The role table */
|
||||
typedef struct {
|
||||
role_entry_t entries[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} role_table_t;
|
||||
|
||||
/* Initialize an empty role table */
|
||||
void role_table_init(role_table_t *table);
|
||||
|
||||
/* Add a role entry. Returns 0 on success, -1 if table full, -2 if name duplicate. */
|
||||
int role_table_add(role_table_t *table, const role_entry_t *entry);
|
||||
|
||||
/* Find a role by name. Returns pointer to entry or NULL. */
|
||||
role_entry_t *role_table_find_by_name(role_table_t *table, const char *name);
|
||||
|
||||
/* Find a role by nostr_index. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_nostr_index(role_table_t *table, int index);
|
||||
|
||||
/* Find a role by role_path. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_path(role_table_t *table, const char *path);
|
||||
|
||||
/* Get the default role (named "main"). Returns pointer or NULL if no "main" role. */
|
||||
role_entry_t *role_table_get_default(role_table_t *table);
|
||||
|
||||
/* Parse purpose string to enum */
|
||||
role_purpose_t role_purpose_from_str(const char *s);
|
||||
|
||||
/* Parse curve string to enum */
|
||||
role_curve_t role_curve_from_str(const char *s);
|
||||
|
||||
/* Purpose enum to string */
|
||||
const char *role_purpose_to_str(role_purpose_t p);
|
||||
|
||||
/* Curve enum to string */
|
||||
const char *role_curve_to_str(role_curve_t c);
|
||||
|
||||
|
||||
/* from selector.h */
|
||||
|
||||
|
||||
/* Error codes for selector resolution */
|
||||
#define SELECTOR_OK 0
|
||||
#define SELECTOR_ERR_AMBIGUOUS -1 /* multiple selectors specified */
|
||||
#define SELECTOR_ERR_NOT_FOUND -2 /* no matching role in table */
|
||||
#define SELECTOR_ERR_NO_DEFAULT -3 /* no selector given and no "main" role exists */
|
||||
|
||||
/* Parsed selector from a request's options object */
|
||||
typedef struct {
|
||||
int has_role; /* 1 if "role" field was present */
|
||||
char role_name[ROLE_NAME_MAX];
|
||||
|
||||
int has_nostr_index; /* 1 if "nostr_index" field was present */
|
||||
int nostr_index;
|
||||
|
||||
int has_role_path; /* 1 if "role_path" field was present */
|
||||
char role_path[ROLE_PATH_MAX];
|
||||
} selector_request_t;
|
||||
|
||||
/* Initialize a selector request (all fields zeroed/unset) */
|
||||
void selector_request_init(selector_request_t *req);
|
||||
|
||||
/*
|
||||
* Resolve a selector request against the role table.
|
||||
* On success (returns SELECTOR_OK), *out points to the matched role_entry_t.
|
||||
* On failure, returns one of the SELECTOR_ERR_* codes and *out is NULL.
|
||||
*/
|
||||
int selector_resolve(const selector_request_t *req, role_table_t *table, role_entry_t **out);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for a selector error code.
|
||||
*/
|
||||
const char *selector_strerror(int err);
|
||||
|
||||
|
||||
/* from enforcement.h */
|
||||
|
||||
|
||||
/* Error codes */
|
||||
#define ENFORCE_OK 0
|
||||
#define ENFORCE_ERR_PURPOSE -1 /* purpose mismatch */
|
||||
#define ENFORCE_ERR_CURVE -2 /* curve mismatch */
|
||||
#define ENFORCE_ERR_UNKNOWN_VERB -3 /* verb not recognized */
|
||||
|
||||
/* Known verbs */
|
||||
#define VERB_SIGN_EVENT "sign_event"
|
||||
#define VERB_GET_PUBLIC_KEY "get_public_key"
|
||||
#define VERB_NIP44_ENCRYPT "nip44_encrypt"
|
||||
#define VERB_NIP44_DECRYPT "nip44_decrypt"
|
||||
#define VERB_NIP04_ENCRYPT "nip04_encrypt"
|
||||
#define VERB_NIP04_DECRYPT "nip04_decrypt"
|
||||
|
||||
/*
|
||||
* Check whether `verb` is allowed to execute against `role`.
|
||||
* Returns ENFORCE_OK if allowed, or an ENFORCE_ERR_* code.
|
||||
*
|
||||
* The enforcement rules are:
|
||||
* - All nostr verbs (sign_event, get_public_key, nip44_*, nip04_*) require:
|
||||
* purpose == PURPOSE_NOSTR and curve == CURVE_SECP256K1
|
||||
* - Unknown verbs return ENFORCE_ERR_UNKNOWN_VERB (fail-closed).
|
||||
*/
|
||||
int enforce_verb_role(const char *verb, const role_entry_t *role);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for an enforcement error code.
|
||||
*/
|
||||
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 64
|
||||
|
||||
/* Prompt behavior */
|
||||
typedef enum {
|
||||
PROMPT_NEVER = 0,
|
||||
PROMPT_FIRST_PER_BOOT,
|
||||
PROMPT_EVERY_REQUEST,
|
||||
PROMPT_DENY
|
||||
} prompt_mode_t;
|
||||
|
||||
/* A single policy entry */
|
||||
typedef struct {
|
||||
char caller[POLICY_CALLER_MAX_LEN]; /* e.g. "uid:1000" or "*" for any */
|
||||
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;
|
||||
prompt_mode_t prompt;
|
||||
} policy_entry_t;
|
||||
|
||||
/* Policy table */
|
||||
typedef struct {
|
||||
policy_entry_t entries[POLICY_MAX_ENTRIES];
|
||||
int count;
|
||||
} policy_table_t;
|
||||
|
||||
/* Policy check result */
|
||||
#define POLICY_ALLOW 0
|
||||
#define POLICY_DENY -1
|
||||
#define POLICY_PROMPT -2 /* would need user confirmation */
|
||||
#define POLICY_NO_MATCH -3 /* no policy entry matched (fail-closed = deny) */
|
||||
|
||||
/* Initialize policy table */
|
||||
void policy_table_init(policy_table_t *table);
|
||||
|
||||
/* Initialize default policy: allow same-uid, deny others */
|
||||
void policy_init_default(policy_table_t *table, uid_t owner_uid);
|
||||
|
||||
/* Add a policy entry. Returns 0 on success, -1 if full. */
|
||||
int policy_table_add(policy_table_t *table, const policy_entry_t *entry);
|
||||
|
||||
/*
|
||||
* Check whether caller_id is allowed to invoke `verb` on `role_name` with given `purpose`.
|
||||
* Returns POLICY_ALLOW, POLICY_DENY, POLICY_PROMPT, or POLICY_NO_MATCH.
|
||||
*/
|
||||
int policy_check(const policy_table_t *table, const char *caller_id,
|
||||
const char *verb, const char *role_name, const char *purpose);
|
||||
|
||||
/* Parse prompt mode from string */
|
||||
prompt_mode_t prompt_mode_from_str(const char *s);
|
||||
|
||||
/* Prompt mode to string */
|
||||
const char *prompt_mode_to_str(prompt_mode_t m);
|
||||
|
||||
|
||||
/* from crypto.h */
|
||||
|
||||
|
||||
/* Per-role derived key material (stored in secure memory) */
|
||||
typedef struct {
|
||||
secure_buf_t private_key; /* 32 bytes, mlock'd */
|
||||
unsigned char public_key[32];
|
||||
char pubkey_hex[65]; /* 64 hex chars + null */
|
||||
char npub[128]; /* bech32 npub */
|
||||
int valid;
|
||||
} derived_key_t;
|
||||
|
||||
/* Key store — holds derived keys for all roles */
|
||||
typedef struct {
|
||||
derived_key_t keys[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} key_store_t;
|
||||
|
||||
/* Derive keys for all roles in the table using the loaded mnemonic.
|
||||
* Populates key_store and sets role->pubkey_hex and role->derived for each role.
|
||||
* Only derives for roles with purpose=nostr and curve=secp256k1 (for now).
|
||||
* Returns number of keys derived, or -1 on error. */
|
||||
int crypto_derive_all(key_store_t *store, role_table_t *table, const mnemonic_state_t *mnemonic);
|
||||
|
||||
/* Get the derived private key for a role (by table index). Returns NULL if not derived. */
|
||||
const unsigned char *crypto_get_private_key(const key_store_t *store, int role_index);
|
||||
|
||||
/* Get the derived public key hex for a role. Returns NULL if not derived. */
|
||||
const char *crypto_get_pubkey_hex(const key_store_t *store, int role_index);
|
||||
|
||||
/* Sign a Nostr event. event_json is the unsigned event JSON string.
|
||||
* Returns a newly-allocated string containing the signed event JSON, or NULL on error.
|
||||
* Caller must free() the returned string. */
|
||||
char *crypto_sign_event(const key_store_t *store, int role_index, const char *event_json);
|
||||
|
||||
/* Zeroize all derived keys in the store. */
|
||||
void crypto_wipe(key_store_t *store);
|
||||
|
||||
|
||||
/* from dispatcher.h */
|
||||
|
||||
|
||||
/* Dispatcher context — holds references to shared state */
|
||||
typedef struct {
|
||||
role_table_t *role_table;
|
||||
mnemonic_state_t *mnemonic;
|
||||
key_store_t *key_store;
|
||||
} dispatcher_ctx_t;
|
||||
|
||||
/* Initialize dispatcher context */
|
||||
void dispatcher_init(dispatcher_ctx_t *ctx, role_table_t *table, mnemonic_state_t *mnemonic, key_store_t *key_store);
|
||||
|
||||
/*
|
||||
* Process a JSON-RPC request string and produce a JSON-RPC response string.
|
||||
*
|
||||
* The caller owns the returned string and must free() it.
|
||||
* Returns NULL only on catastrophic allocation failure.
|
||||
*
|
||||
* Response format on success:
|
||||
* { "id": "...", "result": "..." }
|
||||
*
|
||||
* Response format on error:
|
||||
* { "id": "...", "error": { "code": <int>, "message": "..." } }
|
||||
*
|
||||
* Error codes:
|
||||
* -32700 Parse error (invalid JSON)
|
||||
* -32600 Invalid request (missing id/method/params)
|
||||
* -32601 Method not found (unknown verb after enforcement)
|
||||
* -32602 Invalid params
|
||||
* 1001 ambiguous_role_selector
|
||||
* 1002 role_not_found
|
||||
* 1003 no_default_role
|
||||
* 1004 purpose_mismatch
|
||||
* 1005 curve_mismatch
|
||||
* 1006 mnemonic_not_loaded
|
||||
*/
|
||||
char *dispatcher_handle_request(dispatcher_ctx_t *ctx, const char *json_request);
|
||||
|
||||
|
||||
/* from server.h */
|
||||
|
||||
|
||||
#define SERVER_SOCKET_NAME_MAX 108
|
||||
#define SERVER_MAX_MSG_SIZE 65536
|
||||
|
||||
/* Caller identity */
|
||||
typedef struct {
|
||||
uid_t uid;
|
||||
gid_t gid;
|
||||
pid_t pid;
|
||||
char caller_id[64]; /* "uid:<n>" */
|
||||
} caller_identity_t;
|
||||
|
||||
/* Server context */
|
||||
typedef struct {
|
||||
char socket_name[SERVER_SOCKET_NAME_MAX]; /* abstract namespace name (without \0 prefix) */
|
||||
char last_error[256];
|
||||
int listen_fd;
|
||||
int running;
|
||||
dispatcher_ctx_t *dispatcher;
|
||||
policy_table_t *policy;
|
||||
int socket_name_explicit;
|
||||
} server_ctx_t;
|
||||
|
||||
/* Initialize server context. socket_name is the abstract namespace name (e.g. "nsigner").
|
||||
* socket_name_explicit should be non-zero when provided via --socket-name override. */
|
||||
void server_init(server_ctx_t *ctx, const char *socket_name, int socket_name_explicit,
|
||||
dispatcher_ctx_t *dispatcher, policy_table_t *policy);
|
||||
|
||||
/* Start listening. Returns 0 on success, -1 on error. */
|
||||
int server_start(server_ctx_t *ctx);
|
||||
|
||||
/* Get human-readable description of last server error. */
|
||||
const char *server_last_error(const server_ctx_t *ctx);
|
||||
|
||||
/* Handle one pending connection (non-blocking). Returns 1 if handled, 0 if nothing pending, -1 on error.
|
||||
* activity_cb is called with a description string for the TUI activity log. */
|
||||
typedef void (*server_activity_cb)(const char *message, void *user_data);
|
||||
int server_handle_one(server_ctx_t *ctx, server_activity_cb cb, void *cb_data);
|
||||
|
||||
/* Stop server and close socket */
|
||||
void server_stop(server_ctx_t *ctx);
|
||||
|
||||
/* Extract caller identity from connected fd */
|
||||
int server_get_caller(int fd, caller_identity_t *out);
|
||||
|
||||
|
||||
/* from socket_name.h */
|
||||
|
||||
|
||||
/*
|
||||
* Generate random socket name in format: nsigner_<word1>_<word2>
|
||||
* Returns 0 on success, -1 on error.
|
||||
*/
|
||||
int socket_name_random(char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from main.h */
|
||||
/*
|
||||
* nsigner main header - version information
|
||||
*
|
||||
* Version macros are auto-updated by increment_and_push.sh.
|
||||
*/
|
||||
|
||||
|
||||
/* Version information (auto-updated by build/version tooling) */
|
||||
#define NSIGNER_VERSION_MAJOR 0
|
||||
#define NSIGNER_VERSION_MINOR 0
|
||||
#define NSIGNER_VERSION_PATCH 2
|
||||
#define NSIGNER_VERSION "v0.0.2"
|
||||
|
||||
|
||||
/* NSIGNER_HEADERLESS_DECLS_END */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
@@ -1,4 +1,444 @@
|
||||
#include "../src/policy.h"
|
||||
/* NSIGNER_HEADERLESS_DECLS_BEGIN */
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
#include <cJSON.h>
|
||||
|
||||
/* from secure_mem.h */
|
||||
|
||||
|
||||
/*
|
||||
* Secure memory buffer — mlock'd, zeroized on free.
|
||||
* Used for mnemonic phrases, private keys, and any sensitive material.
|
||||
*/
|
||||
typedef struct {
|
||||
void *data; /* pointer to locked allocation */
|
||||
size_t size; /* usable size in bytes */
|
||||
int locked; /* 1 if mlock succeeded */
|
||||
} secure_buf_t;
|
||||
|
||||
/* Allocate a secure buffer of `size` bytes. Returns 0 on success, -1 on failure. */
|
||||
int secure_buf_alloc(secure_buf_t *buf, size_t size);
|
||||
|
||||
/* Zeroize and free a secure buffer. Always succeeds (idempotent). */
|
||||
void secure_buf_free(secure_buf_t *buf);
|
||||
|
||||
/* Zeroize `len` bytes at `ptr` in a way the compiler cannot optimize away. */
|
||||
void secure_memzero(void *ptr, size_t len);
|
||||
|
||||
|
||||
/* from mnemonic.h */
|
||||
|
||||
|
||||
/* Maximum mnemonic length: 24 words * 10 chars avg + spaces + null = 256 is safe */
|
||||
#define MNEMONIC_MAX_LEN 256
|
||||
|
||||
/*
|
||||
* Mnemonic state — holds the loaded mnemonic in secure memory.
|
||||
* Only one mnemonic is active at a time per process.
|
||||
*/
|
||||
typedef struct {
|
||||
secure_buf_t buf; /* secure storage for the mnemonic string */
|
||||
int loaded; /* 1 if a mnemonic is currently loaded */
|
||||
int word_count; /* 12, 15, 18, 21, or 24 */
|
||||
} mnemonic_state_t;
|
||||
|
||||
/* Initialize mnemonic state (must be called before use). */
|
||||
void mnemonic_init(mnemonic_state_t *state);
|
||||
|
||||
/* Load a mnemonic string into secure memory. Validates word count (12/15/18/21/24).
|
||||
* Returns 0 on success, -1 on invalid input, -2 on memory error. */
|
||||
int mnemonic_load(mnemonic_state_t *state, const char *phrase);
|
||||
|
||||
/* Zeroize and unload the mnemonic. Idempotent. */
|
||||
void mnemonic_unload(mnemonic_state_t *state);
|
||||
|
||||
/* Check if a mnemonic is currently loaded. */
|
||||
int mnemonic_is_loaded(const mnemonic_state_t *state);
|
||||
|
||||
/* Get the mnemonic string (only valid while loaded). Returns NULL if not loaded. */
|
||||
const char *mnemonic_get_phrase(const mnemonic_state_t *state);
|
||||
|
||||
/* Generate a new BIP-39 mnemonic phrase (12/15/18/21/24 words) into out.
|
||||
* Returns 0 on success, -1 on invalid arguments or generation failure. */
|
||||
int mnemonic_generate(int word_count, char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from role_table.h */
|
||||
|
||||
|
||||
/* Maximum limits */
|
||||
#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 /* 64 hex chars + null + pad */
|
||||
#define ROLE_TABLE_MAX_ENTRIES 64
|
||||
|
||||
/* Purpose enum for fast comparison (string form kept for config/display) */
|
||||
typedef enum {
|
||||
PURPOSE_NOSTR = 0,
|
||||
PURPOSE_BITCOIN,
|
||||
PURPOSE_SSH,
|
||||
PURPOSE_AGE,
|
||||
PURPOSE_FIPS,
|
||||
PURPOSE_UNKNOWN
|
||||
} role_purpose_t;
|
||||
|
||||
/* Curve enum */
|
||||
typedef enum {
|
||||
CURVE_SECP256K1 = 0,
|
||||
CURVE_ED25519,
|
||||
CURVE_X25519,
|
||||
CURVE_UNKNOWN
|
||||
} role_curve_t;
|
||||
|
||||
/* Selector type — how this role's key is addressed */
|
||||
typedef enum {
|
||||
SELECTOR_NOSTR_INDEX, /* uses nostr_index shorthand */
|
||||
SELECTOR_ROLE_PATH /* uses explicit full path */
|
||||
} role_selector_type_t;
|
||||
|
||||
/* A single role entry */
|
||||
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; /* valid if selector_type == SELECTOR_NOSTR_INDEX */
|
||||
char role_path[ROLE_PATH_MAX]; /* valid if selector_type == SELECTOR_ROLE_PATH */
|
||||
char pubkey_hex[ROLE_PUBKEY_HEX_MAX]; /* filled after derivation, empty until then */
|
||||
int derived; /* 1 if pubkey_hex has been populated */
|
||||
} role_entry_t;
|
||||
|
||||
/* The role table */
|
||||
typedef struct {
|
||||
role_entry_t entries[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} role_table_t;
|
||||
|
||||
/* Initialize an empty role table */
|
||||
void role_table_init(role_table_t *table);
|
||||
|
||||
/* Add a role entry. Returns 0 on success, -1 if table full, -2 if name duplicate. */
|
||||
int role_table_add(role_table_t *table, const role_entry_t *entry);
|
||||
|
||||
/* Find a role by name. Returns pointer to entry or NULL. */
|
||||
role_entry_t *role_table_find_by_name(role_table_t *table, const char *name);
|
||||
|
||||
/* Find a role by nostr_index. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_nostr_index(role_table_t *table, int index);
|
||||
|
||||
/* Find a role by role_path. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_path(role_table_t *table, const char *path);
|
||||
|
||||
/* Get the default role (named "main"). Returns pointer or NULL if no "main" role. */
|
||||
role_entry_t *role_table_get_default(role_table_t *table);
|
||||
|
||||
/* Parse purpose string to enum */
|
||||
role_purpose_t role_purpose_from_str(const char *s);
|
||||
|
||||
/* Parse curve string to enum */
|
||||
role_curve_t role_curve_from_str(const char *s);
|
||||
|
||||
/* Purpose enum to string */
|
||||
const char *role_purpose_to_str(role_purpose_t p);
|
||||
|
||||
/* Curve enum to string */
|
||||
const char *role_curve_to_str(role_curve_t c);
|
||||
|
||||
|
||||
/* from selector.h */
|
||||
|
||||
|
||||
/* Error codes for selector resolution */
|
||||
#define SELECTOR_OK 0
|
||||
#define SELECTOR_ERR_AMBIGUOUS -1 /* multiple selectors specified */
|
||||
#define SELECTOR_ERR_NOT_FOUND -2 /* no matching role in table */
|
||||
#define SELECTOR_ERR_NO_DEFAULT -3 /* no selector given and no "main" role exists */
|
||||
|
||||
/* Parsed selector from a request's options object */
|
||||
typedef struct {
|
||||
int has_role; /* 1 if "role" field was present */
|
||||
char role_name[ROLE_NAME_MAX];
|
||||
|
||||
int has_nostr_index; /* 1 if "nostr_index" field was present */
|
||||
int nostr_index;
|
||||
|
||||
int has_role_path; /* 1 if "role_path" field was present */
|
||||
char role_path[ROLE_PATH_MAX];
|
||||
} selector_request_t;
|
||||
|
||||
/* Initialize a selector request (all fields zeroed/unset) */
|
||||
void selector_request_init(selector_request_t *req);
|
||||
|
||||
/*
|
||||
* Resolve a selector request against the role table.
|
||||
* On success (returns SELECTOR_OK), *out points to the matched role_entry_t.
|
||||
* On failure, returns one of the SELECTOR_ERR_* codes and *out is NULL.
|
||||
*/
|
||||
int selector_resolve(const selector_request_t *req, role_table_t *table, role_entry_t **out);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for a selector error code.
|
||||
*/
|
||||
const char *selector_strerror(int err);
|
||||
|
||||
|
||||
/* from enforcement.h */
|
||||
|
||||
|
||||
/* Error codes */
|
||||
#define ENFORCE_OK 0
|
||||
#define ENFORCE_ERR_PURPOSE -1 /* purpose mismatch */
|
||||
#define ENFORCE_ERR_CURVE -2 /* curve mismatch */
|
||||
#define ENFORCE_ERR_UNKNOWN_VERB -3 /* verb not recognized */
|
||||
|
||||
/* Known verbs */
|
||||
#define VERB_SIGN_EVENT "sign_event"
|
||||
#define VERB_GET_PUBLIC_KEY "get_public_key"
|
||||
#define VERB_NIP44_ENCRYPT "nip44_encrypt"
|
||||
#define VERB_NIP44_DECRYPT "nip44_decrypt"
|
||||
#define VERB_NIP04_ENCRYPT "nip04_encrypt"
|
||||
#define VERB_NIP04_DECRYPT "nip04_decrypt"
|
||||
|
||||
/*
|
||||
* Check whether `verb` is allowed to execute against `role`.
|
||||
* Returns ENFORCE_OK if allowed, or an ENFORCE_ERR_* code.
|
||||
*
|
||||
* The enforcement rules are:
|
||||
* - All nostr verbs (sign_event, get_public_key, nip44_*, nip04_*) require:
|
||||
* purpose == PURPOSE_NOSTR and curve == CURVE_SECP256K1
|
||||
* - Unknown verbs return ENFORCE_ERR_UNKNOWN_VERB (fail-closed).
|
||||
*/
|
||||
int enforce_verb_role(const char *verb, const role_entry_t *role);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for an enforcement error code.
|
||||
*/
|
||||
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 64
|
||||
|
||||
/* Prompt behavior */
|
||||
typedef enum {
|
||||
PROMPT_NEVER = 0,
|
||||
PROMPT_FIRST_PER_BOOT,
|
||||
PROMPT_EVERY_REQUEST,
|
||||
PROMPT_DENY
|
||||
} prompt_mode_t;
|
||||
|
||||
/* A single policy entry */
|
||||
typedef struct {
|
||||
char caller[POLICY_CALLER_MAX_LEN]; /* e.g. "uid:1000" or "*" for any */
|
||||
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;
|
||||
prompt_mode_t prompt;
|
||||
} policy_entry_t;
|
||||
|
||||
/* Policy table */
|
||||
typedef struct {
|
||||
policy_entry_t entries[POLICY_MAX_ENTRIES];
|
||||
int count;
|
||||
} policy_table_t;
|
||||
|
||||
/* Policy check result */
|
||||
#define POLICY_ALLOW 0
|
||||
#define POLICY_DENY -1
|
||||
#define POLICY_PROMPT -2 /* would need user confirmation */
|
||||
#define POLICY_NO_MATCH -3 /* no policy entry matched (fail-closed = deny) */
|
||||
|
||||
/* Initialize policy table */
|
||||
void policy_table_init(policy_table_t *table);
|
||||
|
||||
/* Initialize default policy: allow same-uid, deny others */
|
||||
void policy_init_default(policy_table_t *table, uid_t owner_uid);
|
||||
|
||||
/* Add a policy entry. Returns 0 on success, -1 if full. */
|
||||
int policy_table_add(policy_table_t *table, const policy_entry_t *entry);
|
||||
|
||||
/*
|
||||
* Check whether caller_id is allowed to invoke `verb` on `role_name` with given `purpose`.
|
||||
* Returns POLICY_ALLOW, POLICY_DENY, POLICY_PROMPT, or POLICY_NO_MATCH.
|
||||
*/
|
||||
int policy_check(const policy_table_t *table, const char *caller_id,
|
||||
const char *verb, const char *role_name, const char *purpose);
|
||||
|
||||
/* Parse prompt mode from string */
|
||||
prompt_mode_t prompt_mode_from_str(const char *s);
|
||||
|
||||
/* Prompt mode to string */
|
||||
const char *prompt_mode_to_str(prompt_mode_t m);
|
||||
|
||||
|
||||
/* from crypto.h */
|
||||
|
||||
|
||||
/* Per-role derived key material (stored in secure memory) */
|
||||
typedef struct {
|
||||
secure_buf_t private_key; /* 32 bytes, mlock'd */
|
||||
unsigned char public_key[32];
|
||||
char pubkey_hex[65]; /* 64 hex chars + null */
|
||||
char npub[128]; /* bech32 npub */
|
||||
int valid;
|
||||
} derived_key_t;
|
||||
|
||||
/* Key store — holds derived keys for all roles */
|
||||
typedef struct {
|
||||
derived_key_t keys[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} key_store_t;
|
||||
|
||||
/* Derive keys for all roles in the table using the loaded mnemonic.
|
||||
* Populates key_store and sets role->pubkey_hex and role->derived for each role.
|
||||
* Only derives for roles with purpose=nostr and curve=secp256k1 (for now).
|
||||
* Returns number of keys derived, or -1 on error. */
|
||||
int crypto_derive_all(key_store_t *store, role_table_t *table, const mnemonic_state_t *mnemonic);
|
||||
|
||||
/* Get the derived private key for a role (by table index). Returns NULL if not derived. */
|
||||
const unsigned char *crypto_get_private_key(const key_store_t *store, int role_index);
|
||||
|
||||
/* Get the derived public key hex for a role. Returns NULL if not derived. */
|
||||
const char *crypto_get_pubkey_hex(const key_store_t *store, int role_index);
|
||||
|
||||
/* Sign a Nostr event. event_json is the unsigned event JSON string.
|
||||
* Returns a newly-allocated string containing the signed event JSON, or NULL on error.
|
||||
* Caller must free() the returned string. */
|
||||
char *crypto_sign_event(const key_store_t *store, int role_index, const char *event_json);
|
||||
|
||||
/* Zeroize all derived keys in the store. */
|
||||
void crypto_wipe(key_store_t *store);
|
||||
|
||||
|
||||
/* from dispatcher.h */
|
||||
|
||||
|
||||
/* Dispatcher context — holds references to shared state */
|
||||
typedef struct {
|
||||
role_table_t *role_table;
|
||||
mnemonic_state_t *mnemonic;
|
||||
key_store_t *key_store;
|
||||
} dispatcher_ctx_t;
|
||||
|
||||
/* Initialize dispatcher context */
|
||||
void dispatcher_init(dispatcher_ctx_t *ctx, role_table_t *table, mnemonic_state_t *mnemonic, key_store_t *key_store);
|
||||
|
||||
/*
|
||||
* Process a JSON-RPC request string and produce a JSON-RPC response string.
|
||||
*
|
||||
* The caller owns the returned string and must free() it.
|
||||
* Returns NULL only on catastrophic allocation failure.
|
||||
*
|
||||
* Response format on success:
|
||||
* { "id": "...", "result": "..." }
|
||||
*
|
||||
* Response format on error:
|
||||
* { "id": "...", "error": { "code": <int>, "message": "..." } }
|
||||
*
|
||||
* Error codes:
|
||||
* -32700 Parse error (invalid JSON)
|
||||
* -32600 Invalid request (missing id/method/params)
|
||||
* -32601 Method not found (unknown verb after enforcement)
|
||||
* -32602 Invalid params
|
||||
* 1001 ambiguous_role_selector
|
||||
* 1002 role_not_found
|
||||
* 1003 no_default_role
|
||||
* 1004 purpose_mismatch
|
||||
* 1005 curve_mismatch
|
||||
* 1006 mnemonic_not_loaded
|
||||
*/
|
||||
char *dispatcher_handle_request(dispatcher_ctx_t *ctx, const char *json_request);
|
||||
|
||||
|
||||
/* from server.h */
|
||||
|
||||
|
||||
#define SERVER_SOCKET_NAME_MAX 108
|
||||
#define SERVER_MAX_MSG_SIZE 65536
|
||||
|
||||
/* Caller identity */
|
||||
typedef struct {
|
||||
uid_t uid;
|
||||
gid_t gid;
|
||||
pid_t pid;
|
||||
char caller_id[64]; /* "uid:<n>" */
|
||||
} caller_identity_t;
|
||||
|
||||
/* Server context */
|
||||
typedef struct {
|
||||
char socket_name[SERVER_SOCKET_NAME_MAX]; /* abstract namespace name (without \0 prefix) */
|
||||
char last_error[256];
|
||||
int listen_fd;
|
||||
int running;
|
||||
dispatcher_ctx_t *dispatcher;
|
||||
policy_table_t *policy;
|
||||
int socket_name_explicit;
|
||||
} server_ctx_t;
|
||||
|
||||
/* Initialize server context. socket_name is the abstract namespace name (e.g. "nsigner").
|
||||
* socket_name_explicit should be non-zero when provided via --socket-name override. */
|
||||
void server_init(server_ctx_t *ctx, const char *socket_name, int socket_name_explicit,
|
||||
dispatcher_ctx_t *dispatcher, policy_table_t *policy);
|
||||
|
||||
/* Start listening. Returns 0 on success, -1 on error. */
|
||||
int server_start(server_ctx_t *ctx);
|
||||
|
||||
/* Get human-readable description of last server error. */
|
||||
const char *server_last_error(const server_ctx_t *ctx);
|
||||
|
||||
/* Handle one pending connection (non-blocking). Returns 1 if handled, 0 if nothing pending, -1 on error.
|
||||
* activity_cb is called with a description string for the TUI activity log. */
|
||||
typedef void (*server_activity_cb)(const char *message, void *user_data);
|
||||
int server_handle_one(server_ctx_t *ctx, server_activity_cb cb, void *cb_data);
|
||||
|
||||
/* Stop server and close socket */
|
||||
void server_stop(server_ctx_t *ctx);
|
||||
|
||||
/* Extract caller identity from connected fd */
|
||||
int server_get_caller(int fd, caller_identity_t *out);
|
||||
|
||||
|
||||
/* from socket_name.h */
|
||||
|
||||
|
||||
/*
|
||||
* Generate random socket name in format: nsigner_<word1>_<word2>
|
||||
* Returns 0 on success, -1 on error.
|
||||
*/
|
||||
int socket_name_random(char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from main.h */
|
||||
/*
|
||||
* nsigner main header - version information
|
||||
*
|
||||
* Version macros are auto-updated by increment_and_push.sh.
|
||||
*/
|
||||
|
||||
|
||||
/* Version information (auto-updated by build/version tooling) */
|
||||
#define NSIGNER_VERSION_MAJOR 0
|
||||
#define NSIGNER_VERSION_MINOR 0
|
||||
#define NSIGNER_VERSION_PATCH 2
|
||||
#define NSIGNER_VERSION "v0.0.2"
|
||||
|
||||
|
||||
/* NSIGNER_HEADERLESS_DECLS_END */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
@@ -1,4 +1,444 @@
|
||||
#include "../src/role_table.h"
|
||||
/* NSIGNER_HEADERLESS_DECLS_BEGIN */
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
#include <cJSON.h>
|
||||
|
||||
/* from secure_mem.h */
|
||||
|
||||
|
||||
/*
|
||||
* Secure memory buffer — mlock'd, zeroized on free.
|
||||
* Used for mnemonic phrases, private keys, and any sensitive material.
|
||||
*/
|
||||
typedef struct {
|
||||
void *data; /* pointer to locked allocation */
|
||||
size_t size; /* usable size in bytes */
|
||||
int locked; /* 1 if mlock succeeded */
|
||||
} secure_buf_t;
|
||||
|
||||
/* Allocate a secure buffer of `size` bytes. Returns 0 on success, -1 on failure. */
|
||||
int secure_buf_alloc(secure_buf_t *buf, size_t size);
|
||||
|
||||
/* Zeroize and free a secure buffer. Always succeeds (idempotent). */
|
||||
void secure_buf_free(secure_buf_t *buf);
|
||||
|
||||
/* Zeroize `len` bytes at `ptr` in a way the compiler cannot optimize away. */
|
||||
void secure_memzero(void *ptr, size_t len);
|
||||
|
||||
|
||||
/* from mnemonic.h */
|
||||
|
||||
|
||||
/* Maximum mnemonic length: 24 words * 10 chars avg + spaces + null = 256 is safe */
|
||||
#define MNEMONIC_MAX_LEN 256
|
||||
|
||||
/*
|
||||
* Mnemonic state — holds the loaded mnemonic in secure memory.
|
||||
* Only one mnemonic is active at a time per process.
|
||||
*/
|
||||
typedef struct {
|
||||
secure_buf_t buf; /* secure storage for the mnemonic string */
|
||||
int loaded; /* 1 if a mnemonic is currently loaded */
|
||||
int word_count; /* 12, 15, 18, 21, or 24 */
|
||||
} mnemonic_state_t;
|
||||
|
||||
/* Initialize mnemonic state (must be called before use). */
|
||||
void mnemonic_init(mnemonic_state_t *state);
|
||||
|
||||
/* Load a mnemonic string into secure memory. Validates word count (12/15/18/21/24).
|
||||
* Returns 0 on success, -1 on invalid input, -2 on memory error. */
|
||||
int mnemonic_load(mnemonic_state_t *state, const char *phrase);
|
||||
|
||||
/* Zeroize and unload the mnemonic. Idempotent. */
|
||||
void mnemonic_unload(mnemonic_state_t *state);
|
||||
|
||||
/* Check if a mnemonic is currently loaded. */
|
||||
int mnemonic_is_loaded(const mnemonic_state_t *state);
|
||||
|
||||
/* Get the mnemonic string (only valid while loaded). Returns NULL if not loaded. */
|
||||
const char *mnemonic_get_phrase(const mnemonic_state_t *state);
|
||||
|
||||
/* Generate a new BIP-39 mnemonic phrase (12/15/18/21/24 words) into out.
|
||||
* Returns 0 on success, -1 on invalid arguments or generation failure. */
|
||||
int mnemonic_generate(int word_count, char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from role_table.h */
|
||||
|
||||
|
||||
/* Maximum limits */
|
||||
#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 /* 64 hex chars + null + pad */
|
||||
#define ROLE_TABLE_MAX_ENTRIES 64
|
||||
|
||||
/* Purpose enum for fast comparison (string form kept for config/display) */
|
||||
typedef enum {
|
||||
PURPOSE_NOSTR = 0,
|
||||
PURPOSE_BITCOIN,
|
||||
PURPOSE_SSH,
|
||||
PURPOSE_AGE,
|
||||
PURPOSE_FIPS,
|
||||
PURPOSE_UNKNOWN
|
||||
} role_purpose_t;
|
||||
|
||||
/* Curve enum */
|
||||
typedef enum {
|
||||
CURVE_SECP256K1 = 0,
|
||||
CURVE_ED25519,
|
||||
CURVE_X25519,
|
||||
CURVE_UNKNOWN
|
||||
} role_curve_t;
|
||||
|
||||
/* Selector type — how this role's key is addressed */
|
||||
typedef enum {
|
||||
SELECTOR_NOSTR_INDEX, /* uses nostr_index shorthand */
|
||||
SELECTOR_ROLE_PATH /* uses explicit full path */
|
||||
} role_selector_type_t;
|
||||
|
||||
/* A single role entry */
|
||||
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; /* valid if selector_type == SELECTOR_NOSTR_INDEX */
|
||||
char role_path[ROLE_PATH_MAX]; /* valid if selector_type == SELECTOR_ROLE_PATH */
|
||||
char pubkey_hex[ROLE_PUBKEY_HEX_MAX]; /* filled after derivation, empty until then */
|
||||
int derived; /* 1 if pubkey_hex has been populated */
|
||||
} role_entry_t;
|
||||
|
||||
/* The role table */
|
||||
typedef struct {
|
||||
role_entry_t entries[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} role_table_t;
|
||||
|
||||
/* Initialize an empty role table */
|
||||
void role_table_init(role_table_t *table);
|
||||
|
||||
/* Add a role entry. Returns 0 on success, -1 if table full, -2 if name duplicate. */
|
||||
int role_table_add(role_table_t *table, const role_entry_t *entry);
|
||||
|
||||
/* Find a role by name. Returns pointer to entry or NULL. */
|
||||
role_entry_t *role_table_find_by_name(role_table_t *table, const char *name);
|
||||
|
||||
/* Find a role by nostr_index. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_nostr_index(role_table_t *table, int index);
|
||||
|
||||
/* Find a role by role_path. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_path(role_table_t *table, const char *path);
|
||||
|
||||
/* Get the default role (named "main"). Returns pointer or NULL if no "main" role. */
|
||||
role_entry_t *role_table_get_default(role_table_t *table);
|
||||
|
||||
/* Parse purpose string to enum */
|
||||
role_purpose_t role_purpose_from_str(const char *s);
|
||||
|
||||
/* Parse curve string to enum */
|
||||
role_curve_t role_curve_from_str(const char *s);
|
||||
|
||||
/* Purpose enum to string */
|
||||
const char *role_purpose_to_str(role_purpose_t p);
|
||||
|
||||
/* Curve enum to string */
|
||||
const char *role_curve_to_str(role_curve_t c);
|
||||
|
||||
|
||||
/* from selector.h */
|
||||
|
||||
|
||||
/* Error codes for selector resolution */
|
||||
#define SELECTOR_OK 0
|
||||
#define SELECTOR_ERR_AMBIGUOUS -1 /* multiple selectors specified */
|
||||
#define SELECTOR_ERR_NOT_FOUND -2 /* no matching role in table */
|
||||
#define SELECTOR_ERR_NO_DEFAULT -3 /* no selector given and no "main" role exists */
|
||||
|
||||
/* Parsed selector from a request's options object */
|
||||
typedef struct {
|
||||
int has_role; /* 1 if "role" field was present */
|
||||
char role_name[ROLE_NAME_MAX];
|
||||
|
||||
int has_nostr_index; /* 1 if "nostr_index" field was present */
|
||||
int nostr_index;
|
||||
|
||||
int has_role_path; /* 1 if "role_path" field was present */
|
||||
char role_path[ROLE_PATH_MAX];
|
||||
} selector_request_t;
|
||||
|
||||
/* Initialize a selector request (all fields zeroed/unset) */
|
||||
void selector_request_init(selector_request_t *req);
|
||||
|
||||
/*
|
||||
* Resolve a selector request against the role table.
|
||||
* On success (returns SELECTOR_OK), *out points to the matched role_entry_t.
|
||||
* On failure, returns one of the SELECTOR_ERR_* codes and *out is NULL.
|
||||
*/
|
||||
int selector_resolve(const selector_request_t *req, role_table_t *table, role_entry_t **out);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for a selector error code.
|
||||
*/
|
||||
const char *selector_strerror(int err);
|
||||
|
||||
|
||||
/* from enforcement.h */
|
||||
|
||||
|
||||
/* Error codes */
|
||||
#define ENFORCE_OK 0
|
||||
#define ENFORCE_ERR_PURPOSE -1 /* purpose mismatch */
|
||||
#define ENFORCE_ERR_CURVE -2 /* curve mismatch */
|
||||
#define ENFORCE_ERR_UNKNOWN_VERB -3 /* verb not recognized */
|
||||
|
||||
/* Known verbs */
|
||||
#define VERB_SIGN_EVENT "sign_event"
|
||||
#define VERB_GET_PUBLIC_KEY "get_public_key"
|
||||
#define VERB_NIP44_ENCRYPT "nip44_encrypt"
|
||||
#define VERB_NIP44_DECRYPT "nip44_decrypt"
|
||||
#define VERB_NIP04_ENCRYPT "nip04_encrypt"
|
||||
#define VERB_NIP04_DECRYPT "nip04_decrypt"
|
||||
|
||||
/*
|
||||
* Check whether `verb` is allowed to execute against `role`.
|
||||
* Returns ENFORCE_OK if allowed, or an ENFORCE_ERR_* code.
|
||||
*
|
||||
* The enforcement rules are:
|
||||
* - All nostr verbs (sign_event, get_public_key, nip44_*, nip04_*) require:
|
||||
* purpose == PURPOSE_NOSTR and curve == CURVE_SECP256K1
|
||||
* - Unknown verbs return ENFORCE_ERR_UNKNOWN_VERB (fail-closed).
|
||||
*/
|
||||
int enforce_verb_role(const char *verb, const role_entry_t *role);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for an enforcement error code.
|
||||
*/
|
||||
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 64
|
||||
|
||||
/* Prompt behavior */
|
||||
typedef enum {
|
||||
PROMPT_NEVER = 0,
|
||||
PROMPT_FIRST_PER_BOOT,
|
||||
PROMPT_EVERY_REQUEST,
|
||||
PROMPT_DENY
|
||||
} prompt_mode_t;
|
||||
|
||||
/* A single policy entry */
|
||||
typedef struct {
|
||||
char caller[POLICY_CALLER_MAX_LEN]; /* e.g. "uid:1000" or "*" for any */
|
||||
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;
|
||||
prompt_mode_t prompt;
|
||||
} policy_entry_t;
|
||||
|
||||
/* Policy table */
|
||||
typedef struct {
|
||||
policy_entry_t entries[POLICY_MAX_ENTRIES];
|
||||
int count;
|
||||
} policy_table_t;
|
||||
|
||||
/* Policy check result */
|
||||
#define POLICY_ALLOW 0
|
||||
#define POLICY_DENY -1
|
||||
#define POLICY_PROMPT -2 /* would need user confirmation */
|
||||
#define POLICY_NO_MATCH -3 /* no policy entry matched (fail-closed = deny) */
|
||||
|
||||
/* Initialize policy table */
|
||||
void policy_table_init(policy_table_t *table);
|
||||
|
||||
/* Initialize default policy: allow same-uid, deny others */
|
||||
void policy_init_default(policy_table_t *table, uid_t owner_uid);
|
||||
|
||||
/* Add a policy entry. Returns 0 on success, -1 if full. */
|
||||
int policy_table_add(policy_table_t *table, const policy_entry_t *entry);
|
||||
|
||||
/*
|
||||
* Check whether caller_id is allowed to invoke `verb` on `role_name` with given `purpose`.
|
||||
* Returns POLICY_ALLOW, POLICY_DENY, POLICY_PROMPT, or POLICY_NO_MATCH.
|
||||
*/
|
||||
int policy_check(const policy_table_t *table, const char *caller_id,
|
||||
const char *verb, const char *role_name, const char *purpose);
|
||||
|
||||
/* Parse prompt mode from string */
|
||||
prompt_mode_t prompt_mode_from_str(const char *s);
|
||||
|
||||
/* Prompt mode to string */
|
||||
const char *prompt_mode_to_str(prompt_mode_t m);
|
||||
|
||||
|
||||
/* from crypto.h */
|
||||
|
||||
|
||||
/* Per-role derived key material (stored in secure memory) */
|
||||
typedef struct {
|
||||
secure_buf_t private_key; /* 32 bytes, mlock'd */
|
||||
unsigned char public_key[32];
|
||||
char pubkey_hex[65]; /* 64 hex chars + null */
|
||||
char npub[128]; /* bech32 npub */
|
||||
int valid;
|
||||
} derived_key_t;
|
||||
|
||||
/* Key store — holds derived keys for all roles */
|
||||
typedef struct {
|
||||
derived_key_t keys[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} key_store_t;
|
||||
|
||||
/* Derive keys for all roles in the table using the loaded mnemonic.
|
||||
* Populates key_store and sets role->pubkey_hex and role->derived for each role.
|
||||
* Only derives for roles with purpose=nostr and curve=secp256k1 (for now).
|
||||
* Returns number of keys derived, or -1 on error. */
|
||||
int crypto_derive_all(key_store_t *store, role_table_t *table, const mnemonic_state_t *mnemonic);
|
||||
|
||||
/* Get the derived private key for a role (by table index). Returns NULL if not derived. */
|
||||
const unsigned char *crypto_get_private_key(const key_store_t *store, int role_index);
|
||||
|
||||
/* Get the derived public key hex for a role. Returns NULL if not derived. */
|
||||
const char *crypto_get_pubkey_hex(const key_store_t *store, int role_index);
|
||||
|
||||
/* Sign a Nostr event. event_json is the unsigned event JSON string.
|
||||
* Returns a newly-allocated string containing the signed event JSON, or NULL on error.
|
||||
* Caller must free() the returned string. */
|
||||
char *crypto_sign_event(const key_store_t *store, int role_index, const char *event_json);
|
||||
|
||||
/* Zeroize all derived keys in the store. */
|
||||
void crypto_wipe(key_store_t *store);
|
||||
|
||||
|
||||
/* from dispatcher.h */
|
||||
|
||||
|
||||
/* Dispatcher context — holds references to shared state */
|
||||
typedef struct {
|
||||
role_table_t *role_table;
|
||||
mnemonic_state_t *mnemonic;
|
||||
key_store_t *key_store;
|
||||
} dispatcher_ctx_t;
|
||||
|
||||
/* Initialize dispatcher context */
|
||||
void dispatcher_init(dispatcher_ctx_t *ctx, role_table_t *table, mnemonic_state_t *mnemonic, key_store_t *key_store);
|
||||
|
||||
/*
|
||||
* Process a JSON-RPC request string and produce a JSON-RPC response string.
|
||||
*
|
||||
* The caller owns the returned string and must free() it.
|
||||
* Returns NULL only on catastrophic allocation failure.
|
||||
*
|
||||
* Response format on success:
|
||||
* { "id": "...", "result": "..." }
|
||||
*
|
||||
* Response format on error:
|
||||
* { "id": "...", "error": { "code": <int>, "message": "..." } }
|
||||
*
|
||||
* Error codes:
|
||||
* -32700 Parse error (invalid JSON)
|
||||
* -32600 Invalid request (missing id/method/params)
|
||||
* -32601 Method not found (unknown verb after enforcement)
|
||||
* -32602 Invalid params
|
||||
* 1001 ambiguous_role_selector
|
||||
* 1002 role_not_found
|
||||
* 1003 no_default_role
|
||||
* 1004 purpose_mismatch
|
||||
* 1005 curve_mismatch
|
||||
* 1006 mnemonic_not_loaded
|
||||
*/
|
||||
char *dispatcher_handle_request(dispatcher_ctx_t *ctx, const char *json_request);
|
||||
|
||||
|
||||
/* from server.h */
|
||||
|
||||
|
||||
#define SERVER_SOCKET_NAME_MAX 108
|
||||
#define SERVER_MAX_MSG_SIZE 65536
|
||||
|
||||
/* Caller identity */
|
||||
typedef struct {
|
||||
uid_t uid;
|
||||
gid_t gid;
|
||||
pid_t pid;
|
||||
char caller_id[64]; /* "uid:<n>" */
|
||||
} caller_identity_t;
|
||||
|
||||
/* Server context */
|
||||
typedef struct {
|
||||
char socket_name[SERVER_SOCKET_NAME_MAX]; /* abstract namespace name (without \0 prefix) */
|
||||
char last_error[256];
|
||||
int listen_fd;
|
||||
int running;
|
||||
dispatcher_ctx_t *dispatcher;
|
||||
policy_table_t *policy;
|
||||
int socket_name_explicit;
|
||||
} server_ctx_t;
|
||||
|
||||
/* Initialize server context. socket_name is the abstract namespace name (e.g. "nsigner").
|
||||
* socket_name_explicit should be non-zero when provided via --socket-name override. */
|
||||
void server_init(server_ctx_t *ctx, const char *socket_name, int socket_name_explicit,
|
||||
dispatcher_ctx_t *dispatcher, policy_table_t *policy);
|
||||
|
||||
/* Start listening. Returns 0 on success, -1 on error. */
|
||||
int server_start(server_ctx_t *ctx);
|
||||
|
||||
/* Get human-readable description of last server error. */
|
||||
const char *server_last_error(const server_ctx_t *ctx);
|
||||
|
||||
/* Handle one pending connection (non-blocking). Returns 1 if handled, 0 if nothing pending, -1 on error.
|
||||
* activity_cb is called with a description string for the TUI activity log. */
|
||||
typedef void (*server_activity_cb)(const char *message, void *user_data);
|
||||
int server_handle_one(server_ctx_t *ctx, server_activity_cb cb, void *cb_data);
|
||||
|
||||
/* Stop server and close socket */
|
||||
void server_stop(server_ctx_t *ctx);
|
||||
|
||||
/* Extract caller identity from connected fd */
|
||||
int server_get_caller(int fd, caller_identity_t *out);
|
||||
|
||||
|
||||
/* from socket_name.h */
|
||||
|
||||
|
||||
/*
|
||||
* Generate random socket name in format: nsigner_<word1>_<word2>
|
||||
* Returns 0 on success, -1 on error.
|
||||
*/
|
||||
int socket_name_random(char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from main.h */
|
||||
/*
|
||||
* nsigner main header - version information
|
||||
*
|
||||
* Version macros are auto-updated by increment_and_push.sh.
|
||||
*/
|
||||
|
||||
|
||||
/* Version information (auto-updated by build/version tooling) */
|
||||
#define NSIGNER_VERSION_MAJOR 0
|
||||
#define NSIGNER_VERSION_MINOR 0
|
||||
#define NSIGNER_VERSION_PATCH 2
|
||||
#define NSIGNER_VERSION "v0.0.2"
|
||||
|
||||
|
||||
/* NSIGNER_HEADERLESS_DECLS_END */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
@@ -1,4 +1,444 @@
|
||||
#include "../src/selector.h"
|
||||
/* NSIGNER_HEADERLESS_DECLS_BEGIN */
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
#include <cJSON.h>
|
||||
|
||||
/* from secure_mem.h */
|
||||
|
||||
|
||||
/*
|
||||
* Secure memory buffer — mlock'd, zeroized on free.
|
||||
* Used for mnemonic phrases, private keys, and any sensitive material.
|
||||
*/
|
||||
typedef struct {
|
||||
void *data; /* pointer to locked allocation */
|
||||
size_t size; /* usable size in bytes */
|
||||
int locked; /* 1 if mlock succeeded */
|
||||
} secure_buf_t;
|
||||
|
||||
/* Allocate a secure buffer of `size` bytes. Returns 0 on success, -1 on failure. */
|
||||
int secure_buf_alloc(secure_buf_t *buf, size_t size);
|
||||
|
||||
/* Zeroize and free a secure buffer. Always succeeds (idempotent). */
|
||||
void secure_buf_free(secure_buf_t *buf);
|
||||
|
||||
/* Zeroize `len` bytes at `ptr` in a way the compiler cannot optimize away. */
|
||||
void secure_memzero(void *ptr, size_t len);
|
||||
|
||||
|
||||
/* from mnemonic.h */
|
||||
|
||||
|
||||
/* Maximum mnemonic length: 24 words * 10 chars avg + spaces + null = 256 is safe */
|
||||
#define MNEMONIC_MAX_LEN 256
|
||||
|
||||
/*
|
||||
* Mnemonic state — holds the loaded mnemonic in secure memory.
|
||||
* Only one mnemonic is active at a time per process.
|
||||
*/
|
||||
typedef struct {
|
||||
secure_buf_t buf; /* secure storage for the mnemonic string */
|
||||
int loaded; /* 1 if a mnemonic is currently loaded */
|
||||
int word_count; /* 12, 15, 18, 21, or 24 */
|
||||
} mnemonic_state_t;
|
||||
|
||||
/* Initialize mnemonic state (must be called before use). */
|
||||
void mnemonic_init(mnemonic_state_t *state);
|
||||
|
||||
/* Load a mnemonic string into secure memory. Validates word count (12/15/18/21/24).
|
||||
* Returns 0 on success, -1 on invalid input, -2 on memory error. */
|
||||
int mnemonic_load(mnemonic_state_t *state, const char *phrase);
|
||||
|
||||
/* Zeroize and unload the mnemonic. Idempotent. */
|
||||
void mnemonic_unload(mnemonic_state_t *state);
|
||||
|
||||
/* Check if a mnemonic is currently loaded. */
|
||||
int mnemonic_is_loaded(const mnemonic_state_t *state);
|
||||
|
||||
/* Get the mnemonic string (only valid while loaded). Returns NULL if not loaded. */
|
||||
const char *mnemonic_get_phrase(const mnemonic_state_t *state);
|
||||
|
||||
/* Generate a new BIP-39 mnemonic phrase (12/15/18/21/24 words) into out.
|
||||
* Returns 0 on success, -1 on invalid arguments or generation failure. */
|
||||
int mnemonic_generate(int word_count, char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from role_table.h */
|
||||
|
||||
|
||||
/* Maximum limits */
|
||||
#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 /* 64 hex chars + null + pad */
|
||||
#define ROLE_TABLE_MAX_ENTRIES 64
|
||||
|
||||
/* Purpose enum for fast comparison (string form kept for config/display) */
|
||||
typedef enum {
|
||||
PURPOSE_NOSTR = 0,
|
||||
PURPOSE_BITCOIN,
|
||||
PURPOSE_SSH,
|
||||
PURPOSE_AGE,
|
||||
PURPOSE_FIPS,
|
||||
PURPOSE_UNKNOWN
|
||||
} role_purpose_t;
|
||||
|
||||
/* Curve enum */
|
||||
typedef enum {
|
||||
CURVE_SECP256K1 = 0,
|
||||
CURVE_ED25519,
|
||||
CURVE_X25519,
|
||||
CURVE_UNKNOWN
|
||||
} role_curve_t;
|
||||
|
||||
/* Selector type — how this role's key is addressed */
|
||||
typedef enum {
|
||||
SELECTOR_NOSTR_INDEX, /* uses nostr_index shorthand */
|
||||
SELECTOR_ROLE_PATH /* uses explicit full path */
|
||||
} role_selector_type_t;
|
||||
|
||||
/* A single role entry */
|
||||
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; /* valid if selector_type == SELECTOR_NOSTR_INDEX */
|
||||
char role_path[ROLE_PATH_MAX]; /* valid if selector_type == SELECTOR_ROLE_PATH */
|
||||
char pubkey_hex[ROLE_PUBKEY_HEX_MAX]; /* filled after derivation, empty until then */
|
||||
int derived; /* 1 if pubkey_hex has been populated */
|
||||
} role_entry_t;
|
||||
|
||||
/* The role table */
|
||||
typedef struct {
|
||||
role_entry_t entries[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} role_table_t;
|
||||
|
||||
/* Initialize an empty role table */
|
||||
void role_table_init(role_table_t *table);
|
||||
|
||||
/* Add a role entry. Returns 0 on success, -1 if table full, -2 if name duplicate. */
|
||||
int role_table_add(role_table_t *table, const role_entry_t *entry);
|
||||
|
||||
/* Find a role by name. Returns pointer to entry or NULL. */
|
||||
role_entry_t *role_table_find_by_name(role_table_t *table, const char *name);
|
||||
|
||||
/* Find a role by nostr_index. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_nostr_index(role_table_t *table, int index);
|
||||
|
||||
/* Find a role by role_path. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_path(role_table_t *table, const char *path);
|
||||
|
||||
/* Get the default role (named "main"). Returns pointer or NULL if no "main" role. */
|
||||
role_entry_t *role_table_get_default(role_table_t *table);
|
||||
|
||||
/* Parse purpose string to enum */
|
||||
role_purpose_t role_purpose_from_str(const char *s);
|
||||
|
||||
/* Parse curve string to enum */
|
||||
role_curve_t role_curve_from_str(const char *s);
|
||||
|
||||
/* Purpose enum to string */
|
||||
const char *role_purpose_to_str(role_purpose_t p);
|
||||
|
||||
/* Curve enum to string */
|
||||
const char *role_curve_to_str(role_curve_t c);
|
||||
|
||||
|
||||
/* from selector.h */
|
||||
|
||||
|
||||
/* Error codes for selector resolution */
|
||||
#define SELECTOR_OK 0
|
||||
#define SELECTOR_ERR_AMBIGUOUS -1 /* multiple selectors specified */
|
||||
#define SELECTOR_ERR_NOT_FOUND -2 /* no matching role in table */
|
||||
#define SELECTOR_ERR_NO_DEFAULT -3 /* no selector given and no "main" role exists */
|
||||
|
||||
/* Parsed selector from a request's options object */
|
||||
typedef struct {
|
||||
int has_role; /* 1 if "role" field was present */
|
||||
char role_name[ROLE_NAME_MAX];
|
||||
|
||||
int has_nostr_index; /* 1 if "nostr_index" field was present */
|
||||
int nostr_index;
|
||||
|
||||
int has_role_path; /* 1 if "role_path" field was present */
|
||||
char role_path[ROLE_PATH_MAX];
|
||||
} selector_request_t;
|
||||
|
||||
/* Initialize a selector request (all fields zeroed/unset) */
|
||||
void selector_request_init(selector_request_t *req);
|
||||
|
||||
/*
|
||||
* Resolve a selector request against the role table.
|
||||
* On success (returns SELECTOR_OK), *out points to the matched role_entry_t.
|
||||
* On failure, returns one of the SELECTOR_ERR_* codes and *out is NULL.
|
||||
*/
|
||||
int selector_resolve(const selector_request_t *req, role_table_t *table, role_entry_t **out);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for a selector error code.
|
||||
*/
|
||||
const char *selector_strerror(int err);
|
||||
|
||||
|
||||
/* from enforcement.h */
|
||||
|
||||
|
||||
/* Error codes */
|
||||
#define ENFORCE_OK 0
|
||||
#define ENFORCE_ERR_PURPOSE -1 /* purpose mismatch */
|
||||
#define ENFORCE_ERR_CURVE -2 /* curve mismatch */
|
||||
#define ENFORCE_ERR_UNKNOWN_VERB -3 /* verb not recognized */
|
||||
|
||||
/* Known verbs */
|
||||
#define VERB_SIGN_EVENT "sign_event"
|
||||
#define VERB_GET_PUBLIC_KEY "get_public_key"
|
||||
#define VERB_NIP44_ENCRYPT "nip44_encrypt"
|
||||
#define VERB_NIP44_DECRYPT "nip44_decrypt"
|
||||
#define VERB_NIP04_ENCRYPT "nip04_encrypt"
|
||||
#define VERB_NIP04_DECRYPT "nip04_decrypt"
|
||||
|
||||
/*
|
||||
* Check whether `verb` is allowed to execute against `role`.
|
||||
* Returns ENFORCE_OK if allowed, or an ENFORCE_ERR_* code.
|
||||
*
|
||||
* The enforcement rules are:
|
||||
* - All nostr verbs (sign_event, get_public_key, nip44_*, nip04_*) require:
|
||||
* purpose == PURPOSE_NOSTR and curve == CURVE_SECP256K1
|
||||
* - Unknown verbs return ENFORCE_ERR_UNKNOWN_VERB (fail-closed).
|
||||
*/
|
||||
int enforce_verb_role(const char *verb, const role_entry_t *role);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for an enforcement error code.
|
||||
*/
|
||||
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 64
|
||||
|
||||
/* Prompt behavior */
|
||||
typedef enum {
|
||||
PROMPT_NEVER = 0,
|
||||
PROMPT_FIRST_PER_BOOT,
|
||||
PROMPT_EVERY_REQUEST,
|
||||
PROMPT_DENY
|
||||
} prompt_mode_t;
|
||||
|
||||
/* A single policy entry */
|
||||
typedef struct {
|
||||
char caller[POLICY_CALLER_MAX_LEN]; /* e.g. "uid:1000" or "*" for any */
|
||||
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;
|
||||
prompt_mode_t prompt;
|
||||
} policy_entry_t;
|
||||
|
||||
/* Policy table */
|
||||
typedef struct {
|
||||
policy_entry_t entries[POLICY_MAX_ENTRIES];
|
||||
int count;
|
||||
} policy_table_t;
|
||||
|
||||
/* Policy check result */
|
||||
#define POLICY_ALLOW 0
|
||||
#define POLICY_DENY -1
|
||||
#define POLICY_PROMPT -2 /* would need user confirmation */
|
||||
#define POLICY_NO_MATCH -3 /* no policy entry matched (fail-closed = deny) */
|
||||
|
||||
/* Initialize policy table */
|
||||
void policy_table_init(policy_table_t *table);
|
||||
|
||||
/* Initialize default policy: allow same-uid, deny others */
|
||||
void policy_init_default(policy_table_t *table, uid_t owner_uid);
|
||||
|
||||
/* Add a policy entry. Returns 0 on success, -1 if full. */
|
||||
int policy_table_add(policy_table_t *table, const policy_entry_t *entry);
|
||||
|
||||
/*
|
||||
* Check whether caller_id is allowed to invoke `verb` on `role_name` with given `purpose`.
|
||||
* Returns POLICY_ALLOW, POLICY_DENY, POLICY_PROMPT, or POLICY_NO_MATCH.
|
||||
*/
|
||||
int policy_check(const policy_table_t *table, const char *caller_id,
|
||||
const char *verb, const char *role_name, const char *purpose);
|
||||
|
||||
/* Parse prompt mode from string */
|
||||
prompt_mode_t prompt_mode_from_str(const char *s);
|
||||
|
||||
/* Prompt mode to string */
|
||||
const char *prompt_mode_to_str(prompt_mode_t m);
|
||||
|
||||
|
||||
/* from crypto.h */
|
||||
|
||||
|
||||
/* Per-role derived key material (stored in secure memory) */
|
||||
typedef struct {
|
||||
secure_buf_t private_key; /* 32 bytes, mlock'd */
|
||||
unsigned char public_key[32];
|
||||
char pubkey_hex[65]; /* 64 hex chars + null */
|
||||
char npub[128]; /* bech32 npub */
|
||||
int valid;
|
||||
} derived_key_t;
|
||||
|
||||
/* Key store — holds derived keys for all roles */
|
||||
typedef struct {
|
||||
derived_key_t keys[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} key_store_t;
|
||||
|
||||
/* Derive keys for all roles in the table using the loaded mnemonic.
|
||||
* Populates key_store and sets role->pubkey_hex and role->derived for each role.
|
||||
* Only derives for roles with purpose=nostr and curve=secp256k1 (for now).
|
||||
* Returns number of keys derived, or -1 on error. */
|
||||
int crypto_derive_all(key_store_t *store, role_table_t *table, const mnemonic_state_t *mnemonic);
|
||||
|
||||
/* Get the derived private key for a role (by table index). Returns NULL if not derived. */
|
||||
const unsigned char *crypto_get_private_key(const key_store_t *store, int role_index);
|
||||
|
||||
/* Get the derived public key hex for a role. Returns NULL if not derived. */
|
||||
const char *crypto_get_pubkey_hex(const key_store_t *store, int role_index);
|
||||
|
||||
/* Sign a Nostr event. event_json is the unsigned event JSON string.
|
||||
* Returns a newly-allocated string containing the signed event JSON, or NULL on error.
|
||||
* Caller must free() the returned string. */
|
||||
char *crypto_sign_event(const key_store_t *store, int role_index, const char *event_json);
|
||||
|
||||
/* Zeroize all derived keys in the store. */
|
||||
void crypto_wipe(key_store_t *store);
|
||||
|
||||
|
||||
/* from dispatcher.h */
|
||||
|
||||
|
||||
/* Dispatcher context — holds references to shared state */
|
||||
typedef struct {
|
||||
role_table_t *role_table;
|
||||
mnemonic_state_t *mnemonic;
|
||||
key_store_t *key_store;
|
||||
} dispatcher_ctx_t;
|
||||
|
||||
/* Initialize dispatcher context */
|
||||
void dispatcher_init(dispatcher_ctx_t *ctx, role_table_t *table, mnemonic_state_t *mnemonic, key_store_t *key_store);
|
||||
|
||||
/*
|
||||
* Process a JSON-RPC request string and produce a JSON-RPC response string.
|
||||
*
|
||||
* The caller owns the returned string and must free() it.
|
||||
* Returns NULL only on catastrophic allocation failure.
|
||||
*
|
||||
* Response format on success:
|
||||
* { "id": "...", "result": "..." }
|
||||
*
|
||||
* Response format on error:
|
||||
* { "id": "...", "error": { "code": <int>, "message": "..." } }
|
||||
*
|
||||
* Error codes:
|
||||
* -32700 Parse error (invalid JSON)
|
||||
* -32600 Invalid request (missing id/method/params)
|
||||
* -32601 Method not found (unknown verb after enforcement)
|
||||
* -32602 Invalid params
|
||||
* 1001 ambiguous_role_selector
|
||||
* 1002 role_not_found
|
||||
* 1003 no_default_role
|
||||
* 1004 purpose_mismatch
|
||||
* 1005 curve_mismatch
|
||||
* 1006 mnemonic_not_loaded
|
||||
*/
|
||||
char *dispatcher_handle_request(dispatcher_ctx_t *ctx, const char *json_request);
|
||||
|
||||
|
||||
/* from server.h */
|
||||
|
||||
|
||||
#define SERVER_SOCKET_NAME_MAX 108
|
||||
#define SERVER_MAX_MSG_SIZE 65536
|
||||
|
||||
/* Caller identity */
|
||||
typedef struct {
|
||||
uid_t uid;
|
||||
gid_t gid;
|
||||
pid_t pid;
|
||||
char caller_id[64]; /* "uid:<n>" */
|
||||
} caller_identity_t;
|
||||
|
||||
/* Server context */
|
||||
typedef struct {
|
||||
char socket_name[SERVER_SOCKET_NAME_MAX]; /* abstract namespace name (without \0 prefix) */
|
||||
char last_error[256];
|
||||
int listen_fd;
|
||||
int running;
|
||||
dispatcher_ctx_t *dispatcher;
|
||||
policy_table_t *policy;
|
||||
int socket_name_explicit;
|
||||
} server_ctx_t;
|
||||
|
||||
/* Initialize server context. socket_name is the abstract namespace name (e.g. "nsigner").
|
||||
* socket_name_explicit should be non-zero when provided via --socket-name override. */
|
||||
void server_init(server_ctx_t *ctx, const char *socket_name, int socket_name_explicit,
|
||||
dispatcher_ctx_t *dispatcher, policy_table_t *policy);
|
||||
|
||||
/* Start listening. Returns 0 on success, -1 on error. */
|
||||
int server_start(server_ctx_t *ctx);
|
||||
|
||||
/* Get human-readable description of last server error. */
|
||||
const char *server_last_error(const server_ctx_t *ctx);
|
||||
|
||||
/* Handle one pending connection (non-blocking). Returns 1 if handled, 0 if nothing pending, -1 on error.
|
||||
* activity_cb is called with a description string for the TUI activity log. */
|
||||
typedef void (*server_activity_cb)(const char *message, void *user_data);
|
||||
int server_handle_one(server_ctx_t *ctx, server_activity_cb cb, void *cb_data);
|
||||
|
||||
/* Stop server and close socket */
|
||||
void server_stop(server_ctx_t *ctx);
|
||||
|
||||
/* Extract caller identity from connected fd */
|
||||
int server_get_caller(int fd, caller_identity_t *out);
|
||||
|
||||
|
||||
/* from socket_name.h */
|
||||
|
||||
|
||||
/*
|
||||
* Generate random socket name in format: nsigner_<word1>_<word2>
|
||||
* Returns 0 on success, -1 on error.
|
||||
*/
|
||||
int socket_name_random(char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from main.h */
|
||||
/*
|
||||
* nsigner main header - version information
|
||||
*
|
||||
* Version macros are auto-updated by increment_and_push.sh.
|
||||
*/
|
||||
|
||||
|
||||
/* Version information (auto-updated by build/version tooling) */
|
||||
#define NSIGNER_VERSION_MAJOR 0
|
||||
#define NSIGNER_VERSION_MINOR 0
|
||||
#define NSIGNER_VERSION_PATCH 2
|
||||
#define NSIGNER_VERSION "v0.0.2"
|
||||
|
||||
|
||||
/* NSIGNER_HEADERLESS_DECLS_END */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
@@ -1,4 +1,444 @@
|
||||
#include "../src/socket_name.h"
|
||||
/* NSIGNER_HEADERLESS_DECLS_BEGIN */
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
#include <cJSON.h>
|
||||
|
||||
/* from secure_mem.h */
|
||||
|
||||
|
||||
/*
|
||||
* Secure memory buffer — mlock'd, zeroized on free.
|
||||
* Used for mnemonic phrases, private keys, and any sensitive material.
|
||||
*/
|
||||
typedef struct {
|
||||
void *data; /* pointer to locked allocation */
|
||||
size_t size; /* usable size in bytes */
|
||||
int locked; /* 1 if mlock succeeded */
|
||||
} secure_buf_t;
|
||||
|
||||
/* Allocate a secure buffer of `size` bytes. Returns 0 on success, -1 on failure. */
|
||||
int secure_buf_alloc(secure_buf_t *buf, size_t size);
|
||||
|
||||
/* Zeroize and free a secure buffer. Always succeeds (idempotent). */
|
||||
void secure_buf_free(secure_buf_t *buf);
|
||||
|
||||
/* Zeroize `len` bytes at `ptr` in a way the compiler cannot optimize away. */
|
||||
void secure_memzero(void *ptr, size_t len);
|
||||
|
||||
|
||||
/* from mnemonic.h */
|
||||
|
||||
|
||||
/* Maximum mnemonic length: 24 words * 10 chars avg + spaces + null = 256 is safe */
|
||||
#define MNEMONIC_MAX_LEN 256
|
||||
|
||||
/*
|
||||
* Mnemonic state — holds the loaded mnemonic in secure memory.
|
||||
* Only one mnemonic is active at a time per process.
|
||||
*/
|
||||
typedef struct {
|
||||
secure_buf_t buf; /* secure storage for the mnemonic string */
|
||||
int loaded; /* 1 if a mnemonic is currently loaded */
|
||||
int word_count; /* 12, 15, 18, 21, or 24 */
|
||||
} mnemonic_state_t;
|
||||
|
||||
/* Initialize mnemonic state (must be called before use). */
|
||||
void mnemonic_init(mnemonic_state_t *state);
|
||||
|
||||
/* Load a mnemonic string into secure memory. Validates word count (12/15/18/21/24).
|
||||
* Returns 0 on success, -1 on invalid input, -2 on memory error. */
|
||||
int mnemonic_load(mnemonic_state_t *state, const char *phrase);
|
||||
|
||||
/* Zeroize and unload the mnemonic. Idempotent. */
|
||||
void mnemonic_unload(mnemonic_state_t *state);
|
||||
|
||||
/* Check if a mnemonic is currently loaded. */
|
||||
int mnemonic_is_loaded(const mnemonic_state_t *state);
|
||||
|
||||
/* Get the mnemonic string (only valid while loaded). Returns NULL if not loaded. */
|
||||
const char *mnemonic_get_phrase(const mnemonic_state_t *state);
|
||||
|
||||
/* Generate a new BIP-39 mnemonic phrase (12/15/18/21/24 words) into out.
|
||||
* Returns 0 on success, -1 on invalid arguments or generation failure. */
|
||||
int mnemonic_generate(int word_count, char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from role_table.h */
|
||||
|
||||
|
||||
/* Maximum limits */
|
||||
#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 /* 64 hex chars + null + pad */
|
||||
#define ROLE_TABLE_MAX_ENTRIES 64
|
||||
|
||||
/* Purpose enum for fast comparison (string form kept for config/display) */
|
||||
typedef enum {
|
||||
PURPOSE_NOSTR = 0,
|
||||
PURPOSE_BITCOIN,
|
||||
PURPOSE_SSH,
|
||||
PURPOSE_AGE,
|
||||
PURPOSE_FIPS,
|
||||
PURPOSE_UNKNOWN
|
||||
} role_purpose_t;
|
||||
|
||||
/* Curve enum */
|
||||
typedef enum {
|
||||
CURVE_SECP256K1 = 0,
|
||||
CURVE_ED25519,
|
||||
CURVE_X25519,
|
||||
CURVE_UNKNOWN
|
||||
} role_curve_t;
|
||||
|
||||
/* Selector type — how this role's key is addressed */
|
||||
typedef enum {
|
||||
SELECTOR_NOSTR_INDEX, /* uses nostr_index shorthand */
|
||||
SELECTOR_ROLE_PATH /* uses explicit full path */
|
||||
} role_selector_type_t;
|
||||
|
||||
/* A single role entry */
|
||||
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; /* valid if selector_type == SELECTOR_NOSTR_INDEX */
|
||||
char role_path[ROLE_PATH_MAX]; /* valid if selector_type == SELECTOR_ROLE_PATH */
|
||||
char pubkey_hex[ROLE_PUBKEY_HEX_MAX]; /* filled after derivation, empty until then */
|
||||
int derived; /* 1 if pubkey_hex has been populated */
|
||||
} role_entry_t;
|
||||
|
||||
/* The role table */
|
||||
typedef struct {
|
||||
role_entry_t entries[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} role_table_t;
|
||||
|
||||
/* Initialize an empty role table */
|
||||
void role_table_init(role_table_t *table);
|
||||
|
||||
/* Add a role entry. Returns 0 on success, -1 if table full, -2 if name duplicate. */
|
||||
int role_table_add(role_table_t *table, const role_entry_t *entry);
|
||||
|
||||
/* Find a role by name. Returns pointer to entry or NULL. */
|
||||
role_entry_t *role_table_find_by_name(role_table_t *table, const char *name);
|
||||
|
||||
/* Find a role by nostr_index. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_nostr_index(role_table_t *table, int index);
|
||||
|
||||
/* Find a role by role_path. Returns pointer or NULL. */
|
||||
role_entry_t *role_table_find_by_path(role_table_t *table, const char *path);
|
||||
|
||||
/* Get the default role (named "main"). Returns pointer or NULL if no "main" role. */
|
||||
role_entry_t *role_table_get_default(role_table_t *table);
|
||||
|
||||
/* Parse purpose string to enum */
|
||||
role_purpose_t role_purpose_from_str(const char *s);
|
||||
|
||||
/* Parse curve string to enum */
|
||||
role_curve_t role_curve_from_str(const char *s);
|
||||
|
||||
/* Purpose enum to string */
|
||||
const char *role_purpose_to_str(role_purpose_t p);
|
||||
|
||||
/* Curve enum to string */
|
||||
const char *role_curve_to_str(role_curve_t c);
|
||||
|
||||
|
||||
/* from selector.h */
|
||||
|
||||
|
||||
/* Error codes for selector resolution */
|
||||
#define SELECTOR_OK 0
|
||||
#define SELECTOR_ERR_AMBIGUOUS -1 /* multiple selectors specified */
|
||||
#define SELECTOR_ERR_NOT_FOUND -2 /* no matching role in table */
|
||||
#define SELECTOR_ERR_NO_DEFAULT -3 /* no selector given and no "main" role exists */
|
||||
|
||||
/* Parsed selector from a request's options object */
|
||||
typedef struct {
|
||||
int has_role; /* 1 if "role" field was present */
|
||||
char role_name[ROLE_NAME_MAX];
|
||||
|
||||
int has_nostr_index; /* 1 if "nostr_index" field was present */
|
||||
int nostr_index;
|
||||
|
||||
int has_role_path; /* 1 if "role_path" field was present */
|
||||
char role_path[ROLE_PATH_MAX];
|
||||
} selector_request_t;
|
||||
|
||||
/* Initialize a selector request (all fields zeroed/unset) */
|
||||
void selector_request_init(selector_request_t *req);
|
||||
|
||||
/*
|
||||
* Resolve a selector request against the role table.
|
||||
* On success (returns SELECTOR_OK), *out points to the matched role_entry_t.
|
||||
* On failure, returns one of the SELECTOR_ERR_* codes and *out is NULL.
|
||||
*/
|
||||
int selector_resolve(const selector_request_t *req, role_table_t *table, role_entry_t **out);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for a selector error code.
|
||||
*/
|
||||
const char *selector_strerror(int err);
|
||||
|
||||
|
||||
/* from enforcement.h */
|
||||
|
||||
|
||||
/* Error codes */
|
||||
#define ENFORCE_OK 0
|
||||
#define ENFORCE_ERR_PURPOSE -1 /* purpose mismatch */
|
||||
#define ENFORCE_ERR_CURVE -2 /* curve mismatch */
|
||||
#define ENFORCE_ERR_UNKNOWN_VERB -3 /* verb not recognized */
|
||||
|
||||
/* Known verbs */
|
||||
#define VERB_SIGN_EVENT "sign_event"
|
||||
#define VERB_GET_PUBLIC_KEY "get_public_key"
|
||||
#define VERB_NIP44_ENCRYPT "nip44_encrypt"
|
||||
#define VERB_NIP44_DECRYPT "nip44_decrypt"
|
||||
#define VERB_NIP04_ENCRYPT "nip04_encrypt"
|
||||
#define VERB_NIP04_DECRYPT "nip04_decrypt"
|
||||
|
||||
/*
|
||||
* Check whether `verb` is allowed to execute against `role`.
|
||||
* Returns ENFORCE_OK if allowed, or an ENFORCE_ERR_* code.
|
||||
*
|
||||
* The enforcement rules are:
|
||||
* - All nostr verbs (sign_event, get_public_key, nip44_*, nip04_*) require:
|
||||
* purpose == PURPOSE_NOSTR and curve == CURVE_SECP256K1
|
||||
* - Unknown verbs return ENFORCE_ERR_UNKNOWN_VERB (fail-closed).
|
||||
*/
|
||||
int enforce_verb_role(const char *verb, const role_entry_t *role);
|
||||
|
||||
/*
|
||||
* Return a human-readable error string for an enforcement error code.
|
||||
*/
|
||||
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 64
|
||||
|
||||
/* Prompt behavior */
|
||||
typedef enum {
|
||||
PROMPT_NEVER = 0,
|
||||
PROMPT_FIRST_PER_BOOT,
|
||||
PROMPT_EVERY_REQUEST,
|
||||
PROMPT_DENY
|
||||
} prompt_mode_t;
|
||||
|
||||
/* A single policy entry */
|
||||
typedef struct {
|
||||
char caller[POLICY_CALLER_MAX_LEN]; /* e.g. "uid:1000" or "*" for any */
|
||||
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;
|
||||
prompt_mode_t prompt;
|
||||
} policy_entry_t;
|
||||
|
||||
/* Policy table */
|
||||
typedef struct {
|
||||
policy_entry_t entries[POLICY_MAX_ENTRIES];
|
||||
int count;
|
||||
} policy_table_t;
|
||||
|
||||
/* Policy check result */
|
||||
#define POLICY_ALLOW 0
|
||||
#define POLICY_DENY -1
|
||||
#define POLICY_PROMPT -2 /* would need user confirmation */
|
||||
#define POLICY_NO_MATCH -3 /* no policy entry matched (fail-closed = deny) */
|
||||
|
||||
/* Initialize policy table */
|
||||
void policy_table_init(policy_table_t *table);
|
||||
|
||||
/* Initialize default policy: allow same-uid, deny others */
|
||||
void policy_init_default(policy_table_t *table, uid_t owner_uid);
|
||||
|
||||
/* Add a policy entry. Returns 0 on success, -1 if full. */
|
||||
int policy_table_add(policy_table_t *table, const policy_entry_t *entry);
|
||||
|
||||
/*
|
||||
* Check whether caller_id is allowed to invoke `verb` on `role_name` with given `purpose`.
|
||||
* Returns POLICY_ALLOW, POLICY_DENY, POLICY_PROMPT, or POLICY_NO_MATCH.
|
||||
*/
|
||||
int policy_check(const policy_table_t *table, const char *caller_id,
|
||||
const char *verb, const char *role_name, const char *purpose);
|
||||
|
||||
/* Parse prompt mode from string */
|
||||
prompt_mode_t prompt_mode_from_str(const char *s);
|
||||
|
||||
/* Prompt mode to string */
|
||||
const char *prompt_mode_to_str(prompt_mode_t m);
|
||||
|
||||
|
||||
/* from crypto.h */
|
||||
|
||||
|
||||
/* Per-role derived key material (stored in secure memory) */
|
||||
typedef struct {
|
||||
secure_buf_t private_key; /* 32 bytes, mlock'd */
|
||||
unsigned char public_key[32];
|
||||
char pubkey_hex[65]; /* 64 hex chars + null */
|
||||
char npub[128]; /* bech32 npub */
|
||||
int valid;
|
||||
} derived_key_t;
|
||||
|
||||
/* Key store — holds derived keys for all roles */
|
||||
typedef struct {
|
||||
derived_key_t keys[ROLE_TABLE_MAX_ENTRIES];
|
||||
int count;
|
||||
} key_store_t;
|
||||
|
||||
/* Derive keys for all roles in the table using the loaded mnemonic.
|
||||
* Populates key_store and sets role->pubkey_hex and role->derived for each role.
|
||||
* Only derives for roles with purpose=nostr and curve=secp256k1 (for now).
|
||||
* Returns number of keys derived, or -1 on error. */
|
||||
int crypto_derive_all(key_store_t *store, role_table_t *table, const mnemonic_state_t *mnemonic);
|
||||
|
||||
/* Get the derived private key for a role (by table index). Returns NULL if not derived. */
|
||||
const unsigned char *crypto_get_private_key(const key_store_t *store, int role_index);
|
||||
|
||||
/* Get the derived public key hex for a role. Returns NULL if not derived. */
|
||||
const char *crypto_get_pubkey_hex(const key_store_t *store, int role_index);
|
||||
|
||||
/* Sign a Nostr event. event_json is the unsigned event JSON string.
|
||||
* Returns a newly-allocated string containing the signed event JSON, or NULL on error.
|
||||
* Caller must free() the returned string. */
|
||||
char *crypto_sign_event(const key_store_t *store, int role_index, const char *event_json);
|
||||
|
||||
/* Zeroize all derived keys in the store. */
|
||||
void crypto_wipe(key_store_t *store);
|
||||
|
||||
|
||||
/* from dispatcher.h */
|
||||
|
||||
|
||||
/* Dispatcher context — holds references to shared state */
|
||||
typedef struct {
|
||||
role_table_t *role_table;
|
||||
mnemonic_state_t *mnemonic;
|
||||
key_store_t *key_store;
|
||||
} dispatcher_ctx_t;
|
||||
|
||||
/* Initialize dispatcher context */
|
||||
void dispatcher_init(dispatcher_ctx_t *ctx, role_table_t *table, mnemonic_state_t *mnemonic, key_store_t *key_store);
|
||||
|
||||
/*
|
||||
* Process a JSON-RPC request string and produce a JSON-RPC response string.
|
||||
*
|
||||
* The caller owns the returned string and must free() it.
|
||||
* Returns NULL only on catastrophic allocation failure.
|
||||
*
|
||||
* Response format on success:
|
||||
* { "id": "...", "result": "..." }
|
||||
*
|
||||
* Response format on error:
|
||||
* { "id": "...", "error": { "code": <int>, "message": "..." } }
|
||||
*
|
||||
* Error codes:
|
||||
* -32700 Parse error (invalid JSON)
|
||||
* -32600 Invalid request (missing id/method/params)
|
||||
* -32601 Method not found (unknown verb after enforcement)
|
||||
* -32602 Invalid params
|
||||
* 1001 ambiguous_role_selector
|
||||
* 1002 role_not_found
|
||||
* 1003 no_default_role
|
||||
* 1004 purpose_mismatch
|
||||
* 1005 curve_mismatch
|
||||
* 1006 mnemonic_not_loaded
|
||||
*/
|
||||
char *dispatcher_handle_request(dispatcher_ctx_t *ctx, const char *json_request);
|
||||
|
||||
|
||||
/* from server.h */
|
||||
|
||||
|
||||
#define SERVER_SOCKET_NAME_MAX 108
|
||||
#define SERVER_MAX_MSG_SIZE 65536
|
||||
|
||||
/* Caller identity */
|
||||
typedef struct {
|
||||
uid_t uid;
|
||||
gid_t gid;
|
||||
pid_t pid;
|
||||
char caller_id[64]; /* "uid:<n>" */
|
||||
} caller_identity_t;
|
||||
|
||||
/* Server context */
|
||||
typedef struct {
|
||||
char socket_name[SERVER_SOCKET_NAME_MAX]; /* abstract namespace name (without \0 prefix) */
|
||||
char last_error[256];
|
||||
int listen_fd;
|
||||
int running;
|
||||
dispatcher_ctx_t *dispatcher;
|
||||
policy_table_t *policy;
|
||||
int socket_name_explicit;
|
||||
} server_ctx_t;
|
||||
|
||||
/* Initialize server context. socket_name is the abstract namespace name (e.g. "nsigner").
|
||||
* socket_name_explicit should be non-zero when provided via --socket-name override. */
|
||||
void server_init(server_ctx_t *ctx, const char *socket_name, int socket_name_explicit,
|
||||
dispatcher_ctx_t *dispatcher, policy_table_t *policy);
|
||||
|
||||
/* Start listening. Returns 0 on success, -1 on error. */
|
||||
int server_start(server_ctx_t *ctx);
|
||||
|
||||
/* Get human-readable description of last server error. */
|
||||
const char *server_last_error(const server_ctx_t *ctx);
|
||||
|
||||
/* Handle one pending connection (non-blocking). Returns 1 if handled, 0 if nothing pending, -1 on error.
|
||||
* activity_cb is called with a description string for the TUI activity log. */
|
||||
typedef void (*server_activity_cb)(const char *message, void *user_data);
|
||||
int server_handle_one(server_ctx_t *ctx, server_activity_cb cb, void *cb_data);
|
||||
|
||||
/* Stop server and close socket */
|
||||
void server_stop(server_ctx_t *ctx);
|
||||
|
||||
/* Extract caller identity from connected fd */
|
||||
int server_get_caller(int fd, caller_identity_t *out);
|
||||
|
||||
|
||||
/* from socket_name.h */
|
||||
|
||||
|
||||
/*
|
||||
* Generate random socket name in format: nsigner_<word1>_<word2>
|
||||
* Returns 0 on success, -1 on error.
|
||||
*/
|
||||
int socket_name_random(char *out, size_t out_len);
|
||||
|
||||
|
||||
/* from main.h */
|
||||
/*
|
||||
* nsigner main header - version information
|
||||
*
|
||||
* Version macros are auto-updated by increment_and_push.sh.
|
||||
*/
|
||||
|
||||
|
||||
/* Version information (auto-updated by build/version tooling) */
|
||||
#define NSIGNER_VERSION_MAJOR 0
|
||||
#define NSIGNER_VERSION_MINOR 0
|
||||
#define NSIGNER_VERSION_PATCH 2
|
||||
#define NSIGNER_VERSION "v0.0.2"
|
||||
|
||||
|
||||
/* NSIGNER_HEADERLESS_DECLS_END */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
Reference in New Issue
Block a user