also looking at this
Harden encrypted mail storage, recovery, and forwarding
#8
50 files
+1701
-9001
| @@ -1,267 +0,0 @@ | ||
| 1 | const std = @import("std"); | |
| 2 | const Allocator = std.mem.Allocator; | |
| 3 | const Certificate = std.crypto.Certificate; | |
| 4 | const der = Certificate.der; | |
| 5 | const rsa = @import("rsa/rsa.zig"); | |
| 6 | const base64 = std.base64.standard.decoderWithIgnore(" \t\r\n"); | |
| 7 | const proto = @import("protocol.zig"); | |
| 8 | ||
| 9 | const max_ecdsa_key_len = 66; | |
| 10 | ||
| 11 | signature_scheme: proto.SignatureScheme, | |
| 12 | ||
| 13 | key: union { | |
| 14 | rsa: rsa.KeyPair, | |
| 15 | ecdsa: [max_ecdsa_key_len]u8, | |
| 16 | }, | |
| 17 | ||
| 18 | const PrivateKey = @This(); | |
| 19 | ||
| 20 | pub 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 | ||
| 33 | pub 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 | ||
| 48 | fn 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 | |
| 68 | pub 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 | |
| 115 | pub 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 | ||
| 128 | fn 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 | ||
| 136 | fn 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 | ||
| 143 | fn content(bytes: []const u8, e: der.Element) []const u8 { | |
| 144 | return bytes[e.slice.start..e.slice.end]; | |
| 145 | } | |
| 146 | ||
| 147 | const testing = std.testing; | |
| 148 | const testu = @import("testu.zig"); | |
| 149 | ||
| 150 | test "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 | ||
| 163 | test "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 | ||
| 175 | test "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 | ||
| 188 | test "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 | ||
| 202 | test "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 | } | |