+31

README.md

reviewed

··· 94 94 const post = try zat.json.extractAt(FeedPost, allocator, value, .{"post"}); 95 95 ``` 96 96 97 97 + ### jwt verification 98 98 + 99 99 + verify service auth tokens: 100 100 + 101 101 + ```zig 102 102 + var jwt = try zat.Jwt.parse(allocator, token_string); 103 103 + defer jwt.deinit(); 104 104 + 105 105 + // check claims 106 106 + if (jwt.isExpired()) return error.TokenExpired; 107 107 + if (!std.mem.eql(u8, jwt.payload.aud, expected_audience)) return error.InvalidAudience; 108 108 + 109 109 + // verify signature against issuer's public key (from DID document) 110 110 + try jwt.verify(public_key_multibase); 111 111 + ``` 112 112 + 113 113 + supports ES256 (P-256) and ES256K (secp256k1) signing algorithms. 114 114 + 115 115 + ### multibase decoding 116 116 + 117 117 + decode public keys from DID documents: 118 118 + 119 119 + ```zig 120 120 + const key_bytes = try zat.multibase.decode(allocator, "zQ3sh..."); 121 121 + defer allocator.free(key_bytes); 122 122 + 123 123 + const parsed = try zat.multicodec.parsePublicKey(key_bytes); 124 124 + // parsed.key_type: .secp256k1 or .p256 125 125 + // parsed.raw: 33-byte compressed public key 126 126 + ``` 127 127 + 97 128 ## specs 98 129 99 130 validation follows [atproto.com/specs](https://atproto.com/specs/atp).

+255

src/internal/jwt.zig

reviewed

··· 1 1 + //! JWT parsing and verification for AT Protocol 2 2 + //! 3 3 + //! parses and verifies JWTs used in AT Protocol service auth. 4 4 + //! supports ES256 (P-256) and ES256K (secp256k1) signing. 5 5 + //! 6 6 + //! see: https://atproto.com/specs/xrpc#service-auth 7 7 + 8 8 + const std = @import("std"); 9 9 + const crypto = std.crypto; 10 10 + const json = @import("json.zig"); 11 11 + const multibase = @import("multibase.zig"); 12 12 + const multicodec = @import("multicodec.zig"); 13 13 + 14 14 + /// JWT signing algorithm 15 15 + pub const Algorithm = enum { 16 16 + ES256, // P-256 / secp256r1 17 17 + ES256K, // secp256k1 18 18 + 19 19 + pub fn fromString(s: []const u8) ?Algorithm { 20 20 + if (std.mem.eql(u8, s, "ES256")) return .ES256; 21 21 + if (std.mem.eql(u8, s, "ES256K")) return .ES256K; 22 22 + return null; 23 23 + } 24 24 + }; 25 25 + 26 26 + /// parsed JWT header 27 27 + pub const Header = struct { 28 28 + alg: Algorithm, 29 29 + typ: []const u8, 30 30 + }; 31 31 + 32 32 + /// parsed JWT payload (AT Protocol service auth claims) 33 33 + pub const Payload = struct { 34 34 + /// issuer DID (account making the request) 35 35 + iss: []const u8, 36 36 + /// audience DID (service receiving the request) 37 37 + aud: []const u8, 38 38 + /// expiration timestamp (unix seconds) 39 39 + exp: i64, 40 40 + /// issued-at timestamp (unix seconds) 41 41 + iat: ?i64 = null, 42 42 + /// unique nonce for replay prevention 43 43 + jti: ?[]const u8 = null, 44 44 + /// lexicon method (optional, may become required) 45 45 + lxm: ?[]const u8 = null, 46 46 + }; 47 47 + 48 48 + /// parsed JWT with raw components 49 49 + pub const Jwt = struct { 50 50 + allocator: std.mem.Allocator, 51 51 + 52 52 + /// decoded header 53 53 + header: Header, 54 54 + /// decoded payload 55 55 + payload: Payload, 56 56 + /// raw signature bytes (r || s, 64 bytes) 57 57 + signature: []u8, 58 58 + /// the signed portion (header.payload) for verification 59 59 + signed_input: []const u8, 60 60 + /// original token for reference 61 61 + raw_token: []const u8, 62 62 + 63 63 + /// parse a JWT token string 64 64 + pub fn parse(allocator: std.mem.Allocator, token: []const u8) !Jwt { 65 65 + // split on dots: header.payload.signature 66 66 + var parts: [3][]const u8 = undefined; 67 67 + var part_idx: usize = 0; 68 68 + var it = std.mem.splitScalar(u8, token, '.'); 69 69 + 70 70 + while (it.next()) |part| { 71 71 + if (part_idx >= 3) return error.InvalidJwt; 72 72 + parts[part_idx] = part; 73 73 + part_idx += 1; 74 74 + } 75 75 + 76 76 + if (part_idx != 3) return error.InvalidJwt; 77 77 + 78 78 + const header_b64 = parts[0]; 79 79 + const payload_b64 = parts[1]; 80 80 + const sig_b64 = parts[2]; 81 81 + 82 82 + // find signed input (everything before last dot) 83 83 + const last_dot = std.mem.lastIndexOfScalar(u8, token, '.') orelse return error.InvalidJwt; 84 84 + const signed_input = token[0..last_dot]; 85 85 + 86 86 + // decode header 87 87 + const header_json = try base64UrlDecode(allocator, header_b64); 88 88 + defer allocator.free(header_json); 89 89 + 90 90 + const header = try parseHeader(allocator, header_json); 91 91 + 92 92 + // decode payload 93 93 + const payload_json = try base64UrlDecode(allocator, payload_b64); 94 94 + defer allocator.free(payload_json); 95 95 + 96 96 + const payload = try parsePayload(allocator, payload_json); 97 97 + 98 98 + // decode signature 99 99 + const signature = try base64UrlDecode(allocator, sig_b64); 100 100 + errdefer allocator.free(signature); 101 101 + 102 102 + // JWT signatures should be 64 bytes (r || s) 103 103 + if (signature.len != 64) { 104 104 + allocator.free(signature); 105 105 + return error.InvalidSignatureLength; 106 106 + } 107 107 + 108 108 + return .{ 109 109 + .allocator = allocator, 110 110 + .header = header, 111 111 + .payload = payload, 112 112 + .signature = signature, 113 113 + .signed_input = signed_input, 114 114 + .raw_token = token, 115 115 + }; 116 116 + } 117 117 + 118 118 + /// verify the JWT signature against a public key 119 119 + /// public_key should be multibase-encoded (from DID document) 120 120 + pub fn verify(self: *const Jwt, public_key_multibase: []const u8) !void { 121 121 + // decode multibase key 122 122 + const key_bytes = try multibase.decode(self.allocator, public_key_multibase); 123 123 + defer self.allocator.free(key_bytes); 124 124 + 125 125 + // parse multicodec to get key type and raw bytes 126 126 + const parsed_key = try multicodec.parsePublicKey(key_bytes); 127 127 + 128 128 + // verify key type matches algorithm 129 129 + switch (self.header.alg) { 130 130 + .ES256K => { 131 131 + if (parsed_key.key_type != .secp256k1) return error.AlgorithmKeyMismatch; 132 132 + try verifySecp256k1(self.signed_input, self.signature, parsed_key.raw); 133 133 + }, 134 134 + .ES256 => { 135 135 + if (parsed_key.key_type != .p256) return error.AlgorithmKeyMismatch; 136 136 + try verifyP256(self.signed_input, self.signature, parsed_key.raw); 137 137 + }, 138 138 + } 139 139 + } 140 140 + 141 141 + /// check if the token is expired 142 142 + pub fn isExpired(self: *const Jwt) bool { 143 143 + const now = std.time.timestamp(); 144 144 + return now > self.payload.exp; 145 145 + } 146 146 + 147 147 + /// check if the token is expired with clock skew tolerance (in seconds) 148 148 + pub fn isExpiredWithSkew(self: *const Jwt, skew_seconds: i64) bool { 149 149 + const now = std.time.timestamp(); 150 150 + return now > (self.payload.exp + skew_seconds); 151 151 + } 152 152 + 153 153 + pub fn deinit(self: *Jwt) void { 154 154 + self.allocator.free(self.signature); 155 155 + } 156 156 + }; 157 157 + 158 158 + // === internal helpers === 159 159 + 160 160 + fn base64UrlDecode(allocator: std.mem.Allocator, input: []const u8) ![]u8 { 161 161 + const decoder = &std.base64.url_safe_no_pad.Decoder; 162 162 + const size = try decoder.calcSizeForSlice(input); 163 163 + const output = try allocator.alloc(u8, size); 164 164 + errdefer allocator.free(output); 165 165 + try decoder.decode(output, input); 166 166 + return output; 167 167 + } 168 168 + 169 169 + fn parseHeader(allocator: std.mem.Allocator, header_json: []const u8) !Header { 170 170 + _ = allocator; 171 171 + const parsed = try std.json.parseFromSlice(std.json.Value, std.heap.page_allocator, header_json, .{}); 172 172 + defer parsed.deinit(); 173 173 + 174 174 + const alg_str = json.getString(parsed.value, "alg") orelse return error.MissingAlgorithm; 175 175 + const alg = Algorithm.fromString(alg_str) orelse return error.UnsupportedAlgorithm; 176 176 + const typ = json.getString(parsed.value, "typ") orelse "JWT"; 177 177 + 178 178 + return .{ 179 179 + .alg = alg, 180 180 + .typ = typ, 181 181 + }; 182 182 + } 183 183 + 184 184 + fn parsePayload(allocator: std.mem.Allocator, payload_json: []const u8) !Payload { 185 185 + _ = allocator; 186 186 + const parsed = try std.json.parseFromSlice(std.json.Value, std.heap.page_allocator, payload_json, .{}); 187 187 + defer parsed.deinit(); 188 188 + 189 189 + const iss = json.getString(parsed.value, "iss") orelse return error.MissingIssuer; 190 190 + const aud = json.getString(parsed.value, "aud") orelse return error.MissingAudience; 191 191 + const exp = json.getInt(parsed.value, "exp") orelse return error.MissingExpiration; 192 192 + 193 193 + return .{ 194 194 + .iss = iss, 195 195 + .aud = aud, 196 196 + .exp = exp, 197 197 + .iat = json.getInt(parsed.value, "iat"), 198 198 + .jti = json.getString(parsed.value, "jti"), 199 199 + .lxm = json.getString(parsed.value, "lxm"), 200 200 + }; 201 201 + } 202 202 + 203 203 + fn verifySecp256k1(message: []const u8, sig_bytes: []const u8, public_key_raw: []const u8) !void { 204 204 + const Scheme = crypto.ecdsa.EcdsaSecp256k1Sha256; 205 205 + 206 206 + // parse signature (r || s, 64 bytes) 207 207 + if (sig_bytes.len != 64) return error.InvalidSignature; 208 208 + const sig = Scheme.Signature.fromBytes(sig_bytes[0..64].*); 209 209 + 210 210 + // parse public key from SEC1 compressed format 211 211 + if (public_key_raw.len != 33) return error.InvalidPublicKey; 212 212 + const public_key = Scheme.PublicKey.fromSec1(public_key_raw) catch return error.InvalidPublicKey; 213 213 + 214 214 + // verify 215 215 + sig.verify(message, public_key) catch return error.SignatureVerificationFailed; 216 216 + } 217 217 + 218 218 + fn verifyP256(message: []const u8, sig_bytes: []const u8, public_key_raw: []const u8) !void { 219 219 + const Scheme = crypto.ecdsa.EcdsaP256Sha256; 220 220 + 221 221 + // parse signature (r || s, 64 bytes) 222 222 + if (sig_bytes.len != 64) return error.InvalidSignature; 223 223 + const sig = Scheme.Signature.fromBytes(sig_bytes[0..64].*); 224 224 + 225 225 + // parse public key from SEC1 compressed format 226 226 + if (public_key_raw.len != 33) return error.InvalidPublicKey; 227 227 + const public_key = Scheme.PublicKey.fromSec1(public_key_raw) catch return error.InvalidPublicKey; 228 228 + 229 229 + // verify 230 230 + sig.verify(message, public_key) catch return error.SignatureVerificationFailed; 231 231 + } 232 232 + 233 233 + // === tests === 234 234 + 235 235 + test "parse jwt structure" { 236 236 + // a minimal valid JWT structure (signature won't verify, just testing parsing) 237 237 + // header: {"alg":"ES256K","typ":"JWT"} 238 238 + // payload: {"iss":"did:plc:test","aud":"did:plc:service","exp":9999999999} 239 239 + const token = "eyJhbGciOiJFUzI1NksiLCJ0eXAiOiJKV1QifQ.eyJpc3MiOiJkaWQ6cGxjOnRlc3QiLCJhdWQiOiJkaWQ6cGxjOnNlcnZpY2UiLCJleHAiOjk5OTk5OTk5OTl9.AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"; 240 240 + 241 241 + var jwt = try Jwt.parse(std.testing.allocator, token); 242 242 + defer jwt.deinit(); 243 243 + 244 244 + try std.testing.expectEqual(Algorithm.ES256K, jwt.header.alg); 245 245 + try std.testing.expectEqualStrings("did:plc:test", jwt.payload.iss); 246 246 + try std.testing.expectEqualStrings("did:plc:service", jwt.payload.aud); 247 247 + try std.testing.expectEqual(@as(i64, 9999999999), jwt.payload.exp); 248 248 + } 249 249 + 250 250 + test "reject invalid jwt format" { 251 251 + // missing parts 252 252 + try std.testing.expectError(error.InvalidJwt, Jwt.parse(std.testing.allocator, "onlyonepart")); 253 253 + try std.testing.expectError(error.InvalidJwt, Jwt.parse(std.testing.allocator, "two.parts")); 254 254 + try std.testing.expectError(error.InvalidJwt, Jwt.parse(std.testing.allocator, "too.many.parts.here")); 255 255 + }

+190

src/internal/multibase.zig

reviewed

··· 1 1 + //! multibase decoder 2 2 + //! 3 3 + //! decodes multibase-encoded strings (prefix + encoded data). 4 4 + //! currently supports base58btc (z prefix) for DID document public keys. 5 5 + //! 6 6 + //! see: https://github.com/multiformats/multibase 7 7 + 8 8 + const std = @import("std"); 9 9 + 10 10 + /// multibase encoding types 11 11 + pub const Encoding = enum { 12 12 + base58btc, // z prefix 13 13 + 14 14 + pub fn fromPrefix(prefix: u8) ?Encoding { 15 15 + return switch (prefix) { 16 16 + 'z' => .base58btc, 17 17 + else => null, 18 18 + }; 19 19 + } 20 20 + }; 21 21 + 22 22 + /// decode a multibase string, returning the raw bytes 23 23 + /// the first character is the encoding prefix 24 24 + pub fn decode(allocator: std.mem.Allocator, input: []const u8) ![]u8 { 25 25 + if (input.len == 0) return error.EmptyInput; 26 26 + 27 27 + const encoding = Encoding.fromPrefix(input[0]) orelse return error.UnsupportedEncoding; 28 28 + 29 29 + return switch (encoding) { 30 30 + .base58btc => try base58btc.decode(allocator, input[1..]), 31 31 + }; 32 32 + } 33 33 + 34 34 + /// base58btc decoder (bitcoin alphabet) 35 35 + pub const base58btc = struct { 36 36 + /// bitcoin base58 alphabet 37 37 + const alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"; 38 38 + 39 39 + /// reverse lookup table 40 40 + const decode_table: [256]i8 = blk: { 41 41 + var table: [256]i8 = .{-1} ** 256; 42 42 + for (alphabet, 0..) |c, i| { 43 43 + table[c] = @intCast(i); 44 44 + } 45 45 + break :blk table; 46 46 + }; 47 47 + 48 48 + /// decode base58btc string to bytes 49 49 + pub fn decode(allocator: std.mem.Allocator, input: []const u8) ![]u8 { 50 50 + if (input.len == 0) return allocator.alloc(u8, 0); 51 51 + 52 52 + // count leading zeros (1s in base58) 53 53 + var leading_zeros: usize = 0; 54 54 + for (input) |c| { 55 55 + if (c != '1') break; 56 56 + leading_zeros += 1; 57 57 + } 58 58 + 59 59 + // estimate output size: each base58 char represents ~5.86 bits 60 60 + // use a simple overestimate: input.len bytes is more than enough 61 61 + const max_output = input.len; 62 62 + const result = try allocator.alloc(u8, max_output); 63 63 + errdefer allocator.free(result); 64 64 + 65 65 + // decode using big integer arithmetic 66 66 + // accumulator = accumulator * 58 + digit 67 67 + var acc = try std.math.big.int.Managed.init(allocator); 68 68 + defer acc.deinit(); 69 69 + 70 70 + var multiplier = try std.math.big.int.Managed.initSet(allocator, @as(u64, 58)); 71 71 + defer multiplier.deinit(); 72 72 + 73 73 + var temp = try std.math.big.int.Managed.init(allocator); 74 74 + defer temp.deinit(); 75 75 + 76 76 + for (input) |c| { 77 77 + const digit = decode_table[c]; 78 78 + if (digit < 0) { 79 79 + allocator.free(result); 80 80 + return error.InvalidCharacter; 81 81 + } 82 82 + 83 83 + // acc = acc * 58 + digit 84 84 + try temp.mul(&acc, &multiplier); 85 85 + try acc.copy(temp.toConst()); 86 86 + try acc.addScalar(&acc, @as(u8, @intCast(digit))); 87 87 + } 88 88 + 89 89 + // convert big int to bytes (big-endian for base58) 90 90 + const limbs = acc.toConst().limbs; 91 91 + const limb_count = acc.len(); 92 92 + 93 93 + // calculate byte size from limbs 94 94 + var byte_count: usize = 0; 95 95 + if (limb_count > 0 and !acc.toConst().eqlZero()) { 96 96 + const bit_count = acc.toConst().bitCountAbs(); 97 97 + byte_count = (bit_count + 7) / 8; 98 98 + } 99 99 + 100 100 + // write bytes in big-endian order 101 101 + var output_bytes = try allocator.alloc(u8, leading_zeros + byte_count); 102 102 + errdefer allocator.free(output_bytes); 103 103 + 104 104 + // leading zeros 105 105 + @memset(output_bytes[0..leading_zeros], 0); 106 106 + 107 107 + // convert limbs to big-endian bytes 108 108 + if (byte_count > 0) { 109 109 + const output_slice = output_bytes[leading_zeros..]; 110 110 + 111 111 + // limbs are in little-endian order, we need big-endian output 112 112 + var pos: usize = byte_count; 113 113 + for (limbs[0..limb_count]) |limb| { 114 114 + const limb_bytes = @sizeOf(@TypeOf(limb)); 115 115 + var i: usize = 0; 116 116 + while (i < limb_bytes and pos > 0) : (i += 1) { 117 117 + pos -= 1; 118 118 + output_slice[pos] = @truncate(limb >> @intCast(i * 8)); 119 119 + } 120 120 + } 121 121 + } 122 122 + 123 123 + allocator.free(result); 124 124 + return output_bytes; 125 125 + } 126 126 + }; 127 127 + 128 128 + // === tests === 129 129 + 130 130 + test "base58btc decode" { 131 131 + const alloc = std.testing.allocator; 132 132 + 133 133 + // "abc" in base58btc 134 134 + // "abc" = 0x616263 = 6382179 135 135 + // expected base58btc: "ZiCa" (verify with external tool) 136 136 + { 137 137 + const decoded = try base58btc.decode(alloc, "ZiCa"); 138 138 + defer alloc.free(decoded); 139 139 + try std.testing.expectEqualSlices(u8, "abc", decoded); 140 140 + } 141 141 + } 142 142 + 143 143 + test "base58btc decode with leading zeros" { 144 144 + const alloc = std.testing.allocator; 145 145 + 146 146 + // leading 1s map to leading zero bytes 147 147 + { 148 148 + const decoded = try base58btc.decode(alloc, "111"); 149 149 + defer alloc.free(decoded); 150 150 + try std.testing.expectEqual(@as(usize, 3), decoded.len); 151 151 + try std.testing.expectEqualSlices(u8, &[_]u8{ 0, 0, 0 }, decoded); 152 152 + } 153 153 + } 154 154 + 155 155 + test "multibase decode base58btc" { 156 156 + const alloc = std.testing.allocator; 157 157 + 158 158 + // z prefix = base58btc 159 159 + { 160 160 + const decoded = try decode(alloc, "zZiCa"); 161 161 + defer alloc.free(decoded); 162 162 + try std.testing.expectEqualSlices(u8, "abc", decoded); 163 163 + } 164 164 + } 165 165 + 166 166 + test "base58btc decode real multibase key - secp256k1" { 167 167 + const alloc = std.testing.allocator; 168 168 + const multicodec = @import("multicodec.zig"); 169 169 + 170 170 + // from a real DID document: zQ3shXjHeiBuRCKmM36cuYnm7YEMzhGnCmCyW92sRJ9pribSF 171 171 + // this is a compressed secp256k1 public key with multicodec prefix 172 172 + const key = "zQ3shXjHeiBuRCKmM36cuYnm7YEMzhGnCmCyW92sRJ9pribSF"; 173 173 + const decoded = try decode(alloc, key); 174 174 + defer alloc.free(decoded); 175 175 + 176 176 + // should decode to 35 bytes: 2-byte multicodec prefix (0xe7 0x01 varint) + 33-byte compressed key 177 177 + try std.testing.expectEqual(@as(usize, 35), decoded.len); 178 178 + 179 179 + // first two bytes should be secp256k1-pub multicodec prefix (0xe7 0x01 varint for 231) 180 180 + try std.testing.expectEqual(@as(u8, 0xe7), decoded[0]); 181 181 + try std.testing.expectEqual(@as(u8, 0x01), decoded[1]); 182 182 + 183 183 + // parse with multicodec 184 184 + const parsed = try multicodec.parsePublicKey(decoded); 185 185 + try std.testing.expectEqual(multicodec.KeyType.secp256k1, parsed.key_type); 186 186 + try std.testing.expectEqual(@as(usize, 33), parsed.raw.len); 187 187 + 188 188 + // compressed point prefix should be 0x02 or 0x03 189 189 + try std.testing.expect(parsed.raw[0] == 0x02 or parsed.raw[0] == 0x03); 190 190 + }

+91

src/internal/multicodec.zig

reviewed

··· 1 1 + //! multicodec key parsing 2 2 + //! 3 3 + //! parses multicodec-prefixed public keys from DID documents. 4 4 + //! extracts key type and raw key bytes. 5 5 + //! 6 6 + //! see: https://github.com/multiformats/multicodec 7 7 + 8 8 + const std = @import("std"); 9 9 + 10 10 + /// supported key types for AT Protocol 11 11 + pub const KeyType = enum { 12 12 + secp256k1, // ES256K - used by most AT Protocol accounts 13 13 + p256, // ES256 - also supported 14 14 + }; 15 15 + 16 16 + /// parsed public key with type and raw bytes 17 17 + pub const PublicKey = struct { 18 18 + key_type: KeyType, 19 19 + /// raw compressed public key (33 bytes for secp256k1/p256) 20 20 + raw: []const u8, 21 21 + }; 22 22 + 23 23 + /// multicodec prefixes (unsigned varint encoding) 24 24 + /// secp256k1-pub: 0xe7 = 231, varint encoded as 0xe7 0x01 (2 bytes) 25 25 + /// p256-pub: 0x1200 = 4608, varint encoded as 0x80 0x24 (2 bytes) 26 26 + 27 27 + /// parse a multicodec-prefixed public key 28 28 + /// returns the key type and a slice pointing to the raw key bytes 29 29 + pub fn parsePublicKey(data: []const u8) !PublicKey { 30 30 + if (data.len < 2) return error.TooShort; 31 31 + 32 32 + // check for secp256k1-pub (varint 0xe7 = 231 encoded as 0xe7 0x01) 33 33 + if (data.len >= 2 and data[0] == 0xe7 and data[1] == 0x01) { 34 34 + const raw = data[2..]; 35 35 + if (raw.len != 33) return error.InvalidKeyLength; 36 36 + return .{ 37 37 + .key_type = .secp256k1, 38 38 + .raw = raw, 39 39 + }; 40 40 + } 41 41 + 42 42 + // check for p256-pub (varint 0x1200 = 4608 encoded as 0x80 0x24) 43 43 + if (data.len >= 2 and data[0] == 0x80 and data[1] == 0x24) { 44 44 + const raw = data[2..]; 45 45 + if (raw.len != 33) return error.InvalidKeyLength; 46 46 + return .{ 47 47 + .key_type = .p256, 48 48 + .raw = raw, 49 49 + }; 50 50 + } 51 51 + 52 52 + return error.UnsupportedKeyType; 53 53 + } 54 54 + 55 55 + // === tests === 56 56 + 57 57 + test "parse secp256k1 key" { 58 58 + // 0xe7 0x01 prefix (varint) + 33-byte compressed key 59 59 + var data: [35]u8 = undefined; 60 60 + data[0] = 0xe7; 61 61 + data[1] = 0x01; 62 62 + data[2] = 0x02; // compressed point prefix 63 63 + @memset(data[3..], 0xaa); 64 64 + 65 65 + const key = try parsePublicKey(&data); 66 66 + try std.testing.expectEqual(KeyType.secp256k1, key.key_type); 67 67 + try std.testing.expectEqual(@as(usize, 33), key.raw.len); 68 68 + } 69 69 + 70 70 + test "parse p256 key" { 71 71 + // 0x80 0x24 prefix + 33-byte compressed key 72 72 + var data: [35]u8 = undefined; 73 73 + data[0] = 0x80; 74 74 + data[1] = 0x24; 75 75 + data[2] = 0x03; // compressed point prefix 76 76 + @memset(data[3..], 0xbb); 77 77 + 78 78 + const key = try parsePublicKey(&data); 79 79 + try std.testing.expectEqual(KeyType.p256, key.key_type); 80 80 + try std.testing.expectEqual(@as(usize, 33), key.raw.len); 81 81 + } 82 82 + 83 83 + test "reject unsupported key type" { 84 84 + const data = [_]u8{ 0xff, 0x02, 0x00 }; 85 85 + try std.testing.expectError(error.UnsupportedKeyType, parsePublicKey(&data)); 86 86 + } 87 87 + 88 88 + test "reject too short" { 89 89 + const data = [_]u8{0xe7}; 90 90 + try std.testing.expectError(error.TooShort, parsePublicKey(&data)); 91 91 + }

+5

src/root.zig

reviewed

··· 20 20 21 21 // json helpers 22 22 pub const json = @import("internal/json.zig"); 23 23 + 24 24 + // service auth 25 25 + pub const Jwt = @import("internal/jwt.zig").Jwt; 26 26 + pub const multibase = @import("internal/multibase.zig"); 27 27 + pub const multicodec = @import("internal/multicodec.zig");