ReviewOS

also looking at this

mail-os/mail

Harden encrypted mail storage, recovery, and forwarding

#8
Merged chris wants to merge codex/mail-storage-hardening into main
50 files +1701 -9001
packages/zig/vendor/zig-tls/src/PrivateKey.zigdeleted+0-267
Changes to packages/zig/vendor/zig-tls/src/PrivateKey.zig
@@ -1,267 +0,0 @@
1const std = @import("std");
2const Allocator = std.mem.Allocator;
3const Certificate = std.crypto.Certificate;
4const der = Certificate.der;
5const rsa = @import("rsa/rsa.zig");
6const base64 = std.base64.standard.decoderWithIgnore(" \t\r\n");
7const proto = @import("protocol.zig");
8
9const max_ecdsa_key_len = 66;
10
11signature_scheme: proto.SignatureScheme,
12
13key: union {
14 rsa: rsa.KeyPair,
15 ecdsa: [max_ecdsa_key_len]u8,
16},
17
18const PrivateKey = @This();
19
20pub fn fromFile(_: Allocator, file: std.Io.File) !PrivateKey {
21 // Read file using posix since Zig 0.16 File.reader requires Io context
22 const fd = file.handle;
23 var buf: [8192]u8 = undefined;
24 var total: usize = 0;
25 while (total < buf.len) {
26 const n = std.posix.read(fd, buf[total..]) catch break;
27 if (n == 0) break;
28 total += n;
29 }
30 return try parsePem(buf[0..total]);
31}
32
33pub fn parsePem(buf: []const u8) !PrivateKey {
34 const key_start, const key_end, const marker_version = try findKey(buf);
35 const encoded = std.mem.trim(u8, buf[key_start..key_end], " \t\r\n");
36
37 // required bytes:
38 // 2412, 1821, 1236 for rsa 4096, 3072, 2048 bits size keys
39 var decoded: [4096]u8 = undefined;
40 const n = try base64.decode(&decoded, encoded);
41
42 if (marker_version == 2) {
43 return try parseEcDer(decoded[0..n]);
44 }
45 return try parseDer(decoded[0..n]);
46}
47
48fn findKey(buf: []const u8) !struct { usize, usize, usize } {
49 const markers = [_]struct {
50 begin: []const u8,
51 end: []const u8,
52 }{
53 .{ .begin = "-----BEGIN PRIVATE KEY-----", .end = "-----END PRIVATE KEY-----" },
54 .{ .begin = "-----BEGIN EC PRIVATE KEY-----", .end = "-----END EC PRIVATE KEY-----" },
55 };
56
57 for (markers, 1..) |marker, ver| {
58 const begin_marker_start = std.mem.indexOfPos(u8, buf, 0, marker.begin) orelse continue;
59 const key_start = begin_marker_start + marker.begin.len;
60 const key_end = std.mem.indexOfPos(u8, buf, key_start, marker.end) orelse continue;
61
62 return .{ key_start, key_end, ver };
63 }
64 return error.MissingEndMarker;
65}
66
67// ref: https://asn1js.eu/#MIG2AgEAMBAGByqGSM49AgEGBSuBBAAiBIGeMIGbAgEBBDBKFkVJCtU9FR6egz3yNxKBwXd86cFzMYqyGb8hRc1zVvLdw-So_2FBtITp6jzYmFShZANiAAQ-CH3a1R0V6dFlTK8Rs4M4egrpPtdta0osysO0Zl8mkBiDsTlvJNqeAp7L2ItHgFW8k_CfhgQT6iLDacNMhKC4XOV07r_ePD-mmkvqvRmzfOowHUoVRhCKrOTmF_J9Syc
68pub fn parseDer(buf: []const u8) !PrivateKey {
69 const info = try der.Element.parse(buf, 0);
70 const version = try der.Element.parse(buf, info.slice.start);
71
72 const algo_seq = try der.Element.parse(buf, version.slice.end);
73 const algo_cat = try der.Element.parse(buf, algo_seq.slice.start);
74
75 const key_str = try der.Element.parse(buf, algo_seq.slice.end);
76 const key_seq = try der.Element.parse(buf, key_str.slice.start);
77 const key_int = try der.Element.parse(buf, key_seq.slice.start);
78
79 const category = try Certificate.parseAlgorithmCategory(buf, algo_cat);
80 switch (category) {
81 .rsaEncryption => {
82 const modulus = try der.Element.parse(buf, key_int.slice.end);
83 const public_exponent = try der.Element.parse(buf, modulus.slice.end);
84 const private_exponent = try der.Element.parse(buf, public_exponent.slice.end);
85
86 const public_key = try rsa.PublicKey.fromBytes(content(buf, modulus), content(buf, public_exponent));
87 const secret_key = try rsa.SecretKey.fromBytes(public_key.modulus, content(buf, private_exponent));
88 const key_pair = rsa.KeyPair{ .public = public_key, .secret = secret_key };
89
90 return .{
91 .signature_scheme = switch (key_pair.public.modulus.bits()) {
92 4096 => .rsa_pss_rsae_sha512,
93 3072 => .rsa_pss_rsae_sha384,
94 else => .rsa_pss_rsae_sha256,
95 },
96 .key = .{ .rsa = key_pair },
97 };
98 },
99 .X9_62_id_ecPublicKey => {
100 const key = try der.Element.parse(buf, key_int.slice.end);
101 const algo_param = try der.Element.parse(buf, algo_cat.slice.end);
102 const named_curve = try Certificate.parseNamedCurve(buf, algo_param);
103 return .{
104 .signature_scheme = signatureScheme(named_curve),
105 .key = .{ .ecdsa = ecdsaKey(buf, key) },
106 };
107 },
108 else => unreachable,
109 }
110}
111
112// References:
113// https://asn1js.eu/#MHcCAQEEINJSRKv8kSKEzLHptfAlg-LGh4_pHHlq0XLf30Q9pcztoAoGCCqGSM49AwEHoUQDQgAEJpmLyp8aGCgyMcFIJaIq_-4V1K6nPpeoih3bT2npeplF9eyXj7rm8eW9Ua6VLhq71mqtMC-YLm-IkORBVq1cuA
114// https://www.rfc-editor.org/rfc/rfc5915
115pub fn parseEcDer(bytes: []const u8) !PrivateKey {
116 const pki_msg = try der.Element.parse(bytes, 0);
117 const version = try der.Element.parse(bytes, pki_msg.slice.start);
118 const key = try der.Element.parse(bytes, version.slice.end);
119 const parameters = try der.Element.parse(bytes, key.slice.end);
120 const curve = try der.Element.parse(bytes, parameters.slice.start);
121 const named_curve = try Certificate.parseNamedCurve(bytes, curve);
122 return .{
123 .signature_scheme = signatureScheme(named_curve),
124 .key = .{ .ecdsa = ecdsaKey(bytes, key) },
125 };
126}
127
128fn signatureScheme(named_curve: Certificate.NamedCurve) proto.SignatureScheme {
129 return switch (named_curve) {
130 .X9_62_prime256v1 => .ecdsa_secp256r1_sha256,
131 .secp384r1 => .ecdsa_secp384r1_sha384,
132 .secp521r1 => .ecdsa_secp521r1_sha512,
133 };
134}
135
136fn ecdsaKey(bytes: []const u8, e: der.Element) [max_ecdsa_key_len]u8 {
137 const data = content(bytes, e);
138 var ecdsa_key: [max_ecdsa_key_len]u8 = undefined;
139 @memcpy(ecdsa_key[0..data.len], data);
140 return ecdsa_key;
141}
142
143fn content(bytes: []const u8, e: der.Element) []const u8 {
144 return bytes[e.slice.start..e.slice.end];
145}
146
147const testing = std.testing;
148const testu = @import("testu.zig");
149
150test "parse ec pem" {
151 const data = @embedFile("testdata/ec_private_key.pem");
152 var pk = try parsePem(data);
153 const priv_key = &testu.hexToBytes(
154 \\ 10 35 3d ca 1b 15 1d 06 aa 71 b8 ef f3 19 22
155 \\ 43 78 f3 20 98 1e b1 2f 2b 64 7e 71 d0 30 2a
156 \\ 90 aa e5 eb 99 c3 90 65 3d c1 26 19 be 3f 08
157 \\ 20 9b 01
158 );
159 try testing.expectEqualSlices(u8, priv_key, pk.key.ecdsa[0..priv_key.len]);
160 try testing.expectEqual(.ecdsa_secp384r1_sha384, pk.signature_scheme);
161}
162
163test "parse ec prime256v1" {
164 const data = @embedFile("testdata/ec_prime256v1_private_key.pem");
165 var pk = try parsePem(data);
166 const priv_key = &testu.hexToBytes(
167 \\ d2 52 44 ab fc 91 22 84 cc b1 e9 b5 f0 25 83
168 \\ e2 c6 87 8f e9 1c 79 6a d1 72 df df 44 3d a5
169 \\ cc ed
170 );
171 try testing.expectEqualSlices(u8, priv_key, pk.key.ecdsa[0..priv_key.len]);
172 try testing.expectEqual(.ecdsa_secp256r1_sha256, pk.signature_scheme);
173}
174
175test "parse ec secp384r1" {
176 const data = @embedFile("testdata/ec_secp384r1_private_key.pem");
177 var pk = try parsePem(data);
178 const priv_key = &testu.hexToBytes(
179 \\ ee 6d 8a 5e 0d d3 b0 c6 4b 32 40 80 e2 3a de
180 \\ 8b 1e dd e2 92 db 36 1c db 91 ea ba a1 06 0d
181 \\ 42 2d d9 a9 dc 05 43 29 f1 78 7c f9 08 af c5
182 \\ 03 1f 6d
183 );
184 try testing.expectEqualSlices(u8, priv_key, pk.key.ecdsa[0..priv_key.len]);
185 try testing.expectEqual(.ecdsa_secp384r1_sha384, pk.signature_scheme);
186}
187
188test "parse ec secp521r1" {
189 const data = @embedFile("testdata/ec_secp521r1_private_key.pem");
190 var pk = try parsePem(data);
191 const priv_key = &testu.hexToBytes(
192 \\ 01 f0 2f 5a c7 24 18 ea 68 23 8c 2e a1 b4 b8
193 \\ dc f2 11 b2 96 b0 ec 87 80 42 bf de ba f4 96
194 \\ 83 8f 9b db c6 60 a7 4c d9 60 3a e4 ba 0b df
195 \\ ae 24 d3 1b c2 6e 82 a0 88 c1 ed 17 20 0d 3a
196 \\ f1 c5 7e e8 0b 27
197 );
198 try testing.expectEqualSlices(u8, priv_key, pk.key.ecdsa[0..priv_key.len]);
199 try testing.expectEqual(.ecdsa_secp521r1_sha512, pk.signature_scheme);
200}
201
202test "parse rsa pem" {
203 const data = @embedFile("testdata/rsa_private_key.pem");
204 const pk = try parsePem(data);
205
206 // expected results from:
207 // $ openssl pkey -in testdata/rsa_private_key.pem -text -noout
208 const modulus = &testu.hexToBytes(
209 \\ 00 de f7 23 e6 75 cc 6f dd d5 6e 0f 8c 09 f8
210 \\ 62 e3 60 1b c0 7d 8c d5 04 50 2c 36 e2 3b f7
211 \\ 33 9f a1 14 af be cf 1a 0f 4c f5 cb 39 70 0e
212 \\ 3b 97 d6 21 f7 48 91 79 ca 7c 68 fc ea 62 a1
213 \\ 5a 72 4f 78 57 0e cc f2 a3 50 05 f1 4c ca 51
214 \\ 73 10 9a 18 8e 71 f5 b4 c7 3e be 4c ef 37 d4
215 \\ 84 4b 82 1c ec 08 a3 cc 07 3d 5c 0b e5 85 3f
216 \\ fe b6 44 77 8f 3c 6a 2f 33 c3 5d f6 f2 29 46
217 \\ 04 25 7e 05 d9 f8 3b 2d a4 40 66 9f 0d 6d 1a
218 \\ fa bc 0a c5 8b 86 43 30 ef 14 20 41 9d b5 cc
219 \\ 3e 63 b5 48 04 27 c9 5c d3 62 28 5f f5 b6 e4
220 \\ 77 49 99 ac 84 4a a6 67 a5 9a 1a 37 c7 60 4c
221 \\ ba c1 70 cf 57 64 4a 21 ea 05 53 10 ec 94 71
222 \\ 4a 43 04 83 00 aa 5a 28 bc f2 8c 58 14 92 d2
223 \\ 83 17 f4 7b 29 0f e7 87 a2 47 b2 53 19 12 23
224 \\ fb 4b ce 5a f8 a1 84 f9 b1 f3 bf e3 fa 10 f8
225 \\ ad af 87 ce 03 0e a0 2c 13 71 57 c4 55 44 48
226 \\ 44 cb
227 );
228 const public_exponent = &testu.hexToBytes("01 00 01");
229 const private_exponent = &testu.hexToBytes(
230 \\ 50 3b 80 98 aa a5 11 50 33 40 32 aa 02 e0 75
231 \\ bd 3a 55 62 34 0b 9c 8f bb c5 dd 4e 15 a4 03
232 \\ d8 9a 5f 56 4a 84 3d ed 69 95 3d 37 03 02 ac
233 \\ 21 1c 36 06 c4 ff 4c 63 37 d7 93 c3 48 10 a5
234 \\ fa 62 6c 7c 6f 60 02 a4 0f e4 c3 8b 0d 76 b7
235 \\ c0 2e a3 4d 86 e6 92 d1 eb db 10 d6 38 31 ea
236 \\ 15 3d d1 e8 81 c7 67 60 e7 8c 9a df 51 ce d0
237 \\ 7a 88 32 b9 c1 54 b8 7d 98 fc d4 23 1a 05 0e
238 \\ f2 ea e1 72 29 28 2a 68 b7 90 18 80 1c 21 d6
239 \\ 36 a8 6b 4a 9c dd 14 b8 9f 85 ee 95 0b f4 c6
240 \\ 17 02 aa 4d ea 4d f9 39 d7 dd 9d b4 1d d2 f8
241 \\ 92 46 0f 18 41 80 f4 ea 27 55 29 f8 37 59 bf
242 \\ 43 ec a3 eb 19 ba bc 13 06 95 3d 25 4b c9 72
243 \\ cf 41 0a 6f aa cb 79 d4 7b fa b1 09 7c e2 2f
244 \\ 85 51 44 8b c6 97 8e 46 f9 6b ac 08 87 92 ce
245 \\ af 0b bf 8c bd 27 51 8f 09 e4 d3 f9 04 ac fa
246 \\ f2 04 70 3e d9 a6 28 17 c2 2d 74 e9 25 40 02
247 \\ 49
248 );
249
250 try testing.expectEqual(.rsa_pss_rsae_sha256, pk.signature_scheme);
251 const kp = pk.key.rsa;
252 {
253 var bytes: [modulus.len]u8 = undefined;
254 try kp.public.modulus.toBytes(&bytes, .big);
255 try testing.expectEqualSlices(u8, modulus, &bytes);
256 }
257 {
258 var bytes: [private_exponent.len]u8 = undefined;
259 try kp.public.public_exponent.toBytes(&bytes, .big);
260 try testing.expectEqualSlices(u8, public_exponent, bytes[bytes.len - public_exponent.len .. bytes.len]);
261 }
262 {
263 var btytes: [private_exponent.len]u8 = undefined;
264 try kp.secret.private_exponent.toBytes(&btytes, .big);
265 try testing.expectEqualSlices(u8, private_exponent, &btytes);
266 }
267}