Authorize NWC clients, verify requests, and move to libnostr-z 0.5.0

.github/workflows/ci.yml

@@ -0,0 +1,44 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        zig: [0.16.0, 0.17.0]
+
+    runs-on: ${{ matrix.os }}
+    if: github.event.pull_request.draft != true
+
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+        with:
+          persist-credentials: false
+
+      - name: Install dependencies (Linux)
+        if: runner.os == 'Linux'
+        run: sudo apt-get update && sudo apt-get install -y libsecp256k1-dev libssl-dev
+
+      - name: Install dependencies (macOS)
+        if: runner.os == 'macOS'
+        run: brew install secp256k1 openssl@3
+
+      - name: Setup Zig
+        uses: mlugg/setup-zig@d1434d08867e3ee9daa34448df10607b98908d29 # v2
+        with:
+          version: ${{ matrix.zig }}
+
+      - name: Build
+        run: zig build
+
+      - name: Test
+        run: zig build test

.gitignore

@@ -1,3 +1,4 @@
 zig-out/
 .zig-cache/
+zig-pkg/
 puck.toml

README.md

@@ -16,8 +16,10 @@ Nostr Wallet Connect (NIP-47) server in Zig with LNbits backend.
 
 ```toml
 [nostr]
-privkey = "nsec1..."  # or hex
+# nsec or hex; the config parser does not accept trailing comments
+privkey = "nsec1..."
 relay = "wss://relay.example.com"
+client_pubkeys = ["<CLIENT_PUBKEY>"]
 
 [lnbits]
 host = "http://127.0.0.1:5000"
@@ -41,11 +43,16 @@ nostr+walletconnect://<PUBKEY>?relay=<RELAY>&secret=<CLIENT_SECRET>
 
 - `PUBKEY` - Puck's pubkey (shown on startup)
 - `RELAY` - Your relay URL
-- `CLIENT_SECRET` - Random 32-byte hex (client generates this)
+- `CLIENT_SECRET` - Random 32-byte hex secret for this connection
+
+Add the public key of `CLIENT_SECRET` (hex or npub, for example from `nak key public <CLIENT_SECRET>`) to `client_pubkeys`, one entry per connection, and restart Puck. Requests from any other key are ignored. Puck does not store the secret.
+
+Requests must use NIP-44 (`["encryption", "nip44_v2"]`); NIP-04 requests get an `UNSUPPORTED_ENCRYPTION` error. Requests older than 10 minutes, past their `expiration` tag, or already seen are ignored.
 
 Use with Alby, Amethyst, Damus, or any NWC-compatible app.
 
 ## Requirements
 
-- Zig 0.15+
+- Zig 0.16.0 or 0.17.0
+- OpenSSL 3 development libraries (`libssl-dev` on Debian/Ubuntu, `openssl@3` on macOS)
 - LNbits instance with funded wallet

build.zig

@@ -21,14 +21,14 @@ pub fn build(b: *std.Build) void {
         }),
     });
 
-    exe.root_module.strip = optimize == .ReleaseSmall or optimize == .ReleaseFast;
-    exe.linkLibC();
+    exe.root_module.strip = optimize == std.builtin.OptimizeMode.ReleaseSmall or optimize == std.builtin.OptimizeMode.ReleaseFast;
+    exe.root_module.link_libc = true;
 
     b.installArtifact(exe);
 
     const run_cmd = b.addRunArtifact(exe);
     run_cmd.step.dependOn(b.getInstallStep());
-    if (b.args) |args| run_cmd.addArgs(args);
+    if (comptime @hasDecl(std.Build.Step.Run, "addPassthruArgs")) run_cmd.addPassthruArgs() else if (b.args) |args| run_cmd.addArgs(args);
     b.step("run", "Run the NWC server").dependOn(&run_cmd.step);
 
     const unit_tests = b.addTest(.{
@@ -41,7 +41,7 @@ pub fn build(b: *std.Build) void {
             },
         }),
     });
-    unit_tests.linkLibC();
+    unit_tests.root_module.link_libc = true;
 
     const run_unit_tests = b.addRunArtifact(unit_tests);
     b.step("test", "Run unit tests").dependOn(&run_unit_tests.step);

build.zig.zon

@@ -4,8 +4,8 @@
     .fingerprint = 0x8cf1558f8ea40aa6,
     .dependencies = .{
         .nostr = .{
-            .url = "https://github.com/privkeyio/libnostr-z/archive/refs/tags/v0.1.7.tar.gz",
-            .hash = "nostr-0.1.7-JY6OcFu-BQCqNx3PvtNKi6Af_rbeXCh_4CkIth3srMdP",
+            .url = "https://github.com/privkeyio/libnostr-z/archive/5accad27a7ad71d503cd3c8152ea9540d2c23cda.tar.gz",
+            .hash = "nostr-0.5.0-JY6OcKMgEABIisCx3kmE4ybZbmnO5PyWyodAGjukxEJs",
         },
     },
     .paths = .{

puck.toml.example

@@ -1,6 +1,7 @@
 [nostr]
 privkey = "nsec1..."
 relay = "wss://relay.getalby.com/v1"
+client_pubkeys = ["<client-pubkey-hex-or-npub>"]
 
 [lnbits]
 host = "https://legend.lnbits.com"

src/config.zig

@@ -5,28 +5,31 @@ pub const Config = struct {
     privkey: [32]u8,
     pubkey: [32]u8,
     relay: []const u8,
+    client_pubkeys: std.ArrayListUnmanaged([32]u8),
     lnbits_host: []const u8,
     lnbits_admin_key: []const u8,
 
     _allocated: std.ArrayListUnmanaged([]const u8),
     _allocator: std.mem.Allocator,
 
-    pub fn load(allocator: std.mem.Allocator, path: []const u8) !Config {
+    pub fn load(allocator: std.mem.Allocator, io: std.Io, path: []const u8) !Config {
+        const content = try std.Io.Dir.cwd().readFileAlloc(io, path, allocator, .limited(1024 * 1024));
+        defer allocator.free(content);
+        return parse(allocator, content);
+    }
+
+    pub fn parse(allocator: std.mem.Allocator, content: []const u8) !Config {
         var config = Config{
             .privkey = undefined,
             .pubkey = undefined,
             .relay = "",
+            .client_pubkeys = .empty,
             .lnbits_host = "",
             .lnbits_admin_key = "",
-            ._allocated = .{},
+            ._allocated = .empty,
             ._allocator = allocator,
         };
-
-        const file = try std.fs.cwd().openFile(path, .{});
-        defer file.close();
-
-        const content = try file.readToEndAlloc(allocator, 1024 * 1024);
-        defer allocator.free(content);
+        errdefer config.deinit();
 
         var section: []const u8 = "";
         var lines = std.mem.splitScalar(u8, content, '\n');
@@ -43,11 +46,7 @@ pub const Config = struct {
 
             const eq_pos = std.mem.indexOf(u8, trimmed, "=") orelse continue;
             const key = std.mem.trim(u8, trimmed[0..eq_pos], " \t");
-            var value = std.mem.trim(u8, trimmed[eq_pos + 1 ..], " \t");
-
-            if (value.len >= 2 and value[0] == '"' and value[value.len - 1] == '"') {
-                value = value[1 .. value.len - 1];
-            }
+            const value = unquote(std.mem.trim(u8, trimmed[eq_pos + 1 ..], " \t"));
 
             if (std.mem.eql(u8, section, "nostr")) {
                 if (std.mem.eql(u8, key, "privkey")) {
@@ -56,6 +55,8 @@ pub const Config = struct {
                     has_privkey = true;
                 } else if (std.mem.eql(u8, key, "relay")) {
                     config.relay = try config.allocString(value);
+                } else if (std.mem.eql(u8, key, "client_pubkeys")) {
+                    try config.addClientPubkeys(allocator, value);
                 }
             } else if (std.mem.eql(u8, section, "lnbits")) {
                 if (std.mem.eql(u8, key, "host")) {
@@ -68,18 +69,50 @@ pub const Config = struct {
 
         if (!has_privkey) return error.MissingPrivkey;
         if (config.relay.len == 0) return error.MissingRelay;
+        if (config.client_pubkeys.items.len == 0) return error.MissingClientPubkeys;
         if (config.lnbits_host.len == 0) return error.MissingLnbitsHost;
         if (config.lnbits_admin_key.len == 0) return error.MissingLnbitsKey;
 
         return config;
     }
 
+    pub fn isAuthorized(self: *const Config, pubkey: *const [32]u8) bool {
+        for (self.client_pubkeys.items) |*pk| {
+            if (std.mem.eql(u8, pk, pubkey)) return true;
+        }
+        return false;
+    }
+
+    fn unquote(value: []const u8) []const u8 {
+        if (value.len >= 2 and value[0] == '"' and value[value.len - 1] == '"') {
+            return value[1 .. value.len - 1];
+        }
+        return value;
+    }
+
+    fn addClientPubkeys(self: *Config, allocator: std.mem.Allocator, value: []const u8) !void {
+        var list = value;
+        if (list.len >= 2 and list[0] == '[' and list[list.len - 1] == ']') {
+            list = list[1 .. list.len - 1];
+        }
+        var items = std.mem.splitScalar(u8, list, ',');
+        while (items.next()) |item| {
+            const entry = unquote(std.mem.trim(u8, item, " \t"));
+            if (entry.len == 0) continue;
+            const pk = try parsePubkey(allocator, entry);
+            if (!self.isAuthorized(&pk)) try self.client_pubkeys.append(self._allocator, pk);
+        }
+    }
+
     fn parsePrivkey(allocator: std.mem.Allocator, value: []const u8) ![32]u8 {
         if (std.mem.startsWith(u8, value, "nsec1")) {
             const decoded = nostr.bech32.decodeNostr(allocator, value) catch return error.InvalidPrivkey;
             switch (decoded) {
                 .seckey => |sk| return sk,
-                else => return error.InvalidPrivkey,
+                else => {
+                    decoded.deinit(allocator);
+                    return error.InvalidPrivkey;
+                },
             }
         } else if (value.len == 64) {
             var key: [32]u8 = undefined;
@@ -89,8 +122,27 @@ pub const Config = struct {
         return error.InvalidPrivkey;
     }
 
+    fn parsePubkey(allocator: std.mem.Allocator, value: []const u8) ![32]u8 {
+        if (std.mem.startsWith(u8, value, "npub1")) {
+            const decoded = nostr.bech32.decodeNostr(allocator, value) catch return error.InvalidClientPubkey;
+            switch (decoded) {
+                .pubkey => |pk| return pk,
+                else => {
+                    decoded.deinit(allocator);
+                    return error.InvalidClientPubkey;
+                },
+            }
+        } else if (value.len == 64) {
+            var key: [32]u8 = undefined;
+            _ = std.fmt.hexToBytes(&key, value) catch return error.InvalidClientPubkey;
+            return key;
+        }
+        return error.InvalidClientPubkey;
+    }
+
     fn allocString(self: *Config, value: []const u8) ![]const u8 {
         const copy = try self._allocator.dupe(u8, value);
+        errdefer self._allocator.free(copy);
         try self._allocated.append(self._allocator, copy);
         return copy;
     }
@@ -100,5 +152,76 @@ pub const Config = struct {
             self._allocator.free(s);
         }
         self._allocated.deinit(self._allocator);
+        self.client_pubkeys.deinit(self._allocator);
+        std.crypto.secureZero(u8, &self.privkey);
     }
 };
+
+const test_privkey = "0000000000000000000000000000000000000000000000000000000000000001";
+const test_client = "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798";
+
+test "parse full config with client pubkey list" {
+    try nostr.init();
+    defer nostr.cleanup();
+
+    const content =
+        \\[nostr]
+        \\privkey = "
+    ++ test_privkey ++
+        \\"
+        \\relay = "ws://127.0.0.1:7777"
+        \\client_pubkeys = ["
+    ++ test_client ++
+        \\", "c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5"]
+        \\
+        \\[lnbits]
+        \\host = "http://127.0.0.1:5000"
+        \\admin_key = "abc"
+    ;
+    var config = try Config.parse(std.testing.allocator, content);
+    defer config.deinit();
+
+    try std.testing.expectEqualStrings("ws://127.0.0.1:7777", config.relay);
+    try std.testing.expectEqual(@as(usize, 2), config.client_pubkeys.items.len);
+
+    var client: [32]u8 = undefined;
+    _ = try std.fmt.hexToBytes(&client, test_client);
+    try std.testing.expect(config.isAuthorized(&client));
+    const stranger: [32]u8 = @splat(1);
+    try std.testing.expect(!config.isAuthorized(&stranger));
+}
+
+test "config without client pubkeys is rejected" {
+    try nostr.init();
+    defer nostr.cleanup();
+
+    const content =
+        \\[nostr]
+        \\privkey = "
+    ++ test_privkey ++
+        \\"
+        \\relay = "ws://127.0.0.1:7777"
+        \\[lnbits]
+        \\host = "http://127.0.0.1:5000"
+        \\admin_key = "abc"
+    ;
+    try std.testing.expectError(error.MissingClientPubkeys, Config.parse(std.testing.allocator, content));
+}
+
+test "invalid client pubkey is rejected" {
+    try nostr.init();
+    defer nostr.cleanup();
+
+    const content =
+        \\[nostr]
+        \\privkey = "
+    ++ test_privkey ++
+        \\"
+        \\relay = "ws://127.0.0.1:7777"
+        \\client_pubkeys = "not-a-key"
+        \\[lnbits]
+        \\host = "http://127.0.0.1:5000"
+        \\admin_key = "abc"
+    ;
+    try std.testing.expectError(error.InvalidClientPubkey, Config.parse(std.testing.allocator, content));
+}