Commit a7122b73231808a8a07b79c84e1eaac9cf4c28aa | zig

.gitattributes+1

...	@@ -5,6 +5,7 @@ langref.html.in text eol=lf	...	@@ -5,6 +5,7 @@ langref.html.in text eol=lf
5	lib/std/compress/testdata/** binary	5	lib/std/compress/testdata/** binary
6	lib/std/compress/deflate/testdata/** binary	6	lib/std/compress/deflate/testdata/** binary
7	lib/std/compress/flate/testdata/** binary	7	lib/std/compress/flate/testdata/** binary
		8	lib/std/crypto/codecs/asn1/der/testdata/** binary
8		9
9	lib/include/** linguist-vendored	10	lib/include/** linguist-vendored
10	lib/libc/** linguist-vendored	11	lib/libc/** linguist-vendored

lib/std/crypto.zig+4-2

 @@ -214,13 +214,15 @@ pub const ff = @import("crypto/ff.zig");
 /// This is a thread-local, cryptographically secure pseudo random number generator.
 pub const random = @import("crypto/tlcsprng.zig").interface;
+/// Encoding and decoding
+pub const codecs = @import("crypto/codecs.zig");
 const std = @import("std.zig");
 pub const errors = @import("crypto/errors.zig");
 pub const tls = @import("crypto/tls.zig");
 pub const Certificate = @import("crypto/Certificate.zig");
-pub const asn1 = @import("crypto/asn1.zig");
 /// Side-channels mitigations.
 pub const SideChannelsMitigations = enum {
 @@ -335,7 +337,7 @@ test {
     _ = errors;
     _ = tls;
     _ = Certificate;
-    _ = asn1;
+    _ = codecs;
 }
 test "CSPRNG" {

lib/std/crypto/asn1.zig deleted-359

...	@@ -1,359 +0,0 @@
1	//! ASN.1 types for public consumption.
2	const std = @import("std");
3	pub const der = @import("./asn1/der.zig");
4	pub const Oid = @import("./asn1/Oid.zig");
5
6	pub const Index = u32;
7
8	pub const Tag = struct {
9	number: Number,
10	/// Whether this ASN.1 type contains other ASN.1 types.
11	constructed: bool,
12	class: Class,
13
14	/// These values apply to class == .universal.
15	pub const Number = enum(u16) {
16	// 0 is reserved by spec
17	boolean = 1,
18	integer = 2,
19	bitstring = 3,
20	octetstring = 4,
21	null = 5,
22	oid = 6,
23	object_descriptor = 7,
24	real = 9,
25	enumerated = 10,
26	embedded = 11,
27	string_utf8 = 12,
28	oid_relative = 13,
29	time = 14,
30	// 15 is reserved to mean that the tag is >= 32
31	sequence = 16,
32	/// Elements may appear in any order.
33	sequence_of = 17,
34	string_numeric = 18,
35	string_printable = 19,
36	string_teletex = 20,
37	string_videotex = 21,
38	string_ia5 = 22,
39	utc_time = 23,
40	generalized_time = 24,
41	string_graphic = 25,
42	string_visible = 26,
43	string_general = 27,
44	string_universal = 28,
45	string_char = 29,
46	string_bmp = 30,
47	date = 31,
48	time_of_day = 32,
49	date_time = 33,
50	duration = 34,
51	/// IRI = Internationalized Resource Identifier
52	oid_iri = 35,
53	oid_iri_relative = 36,
54	_,
55	};
56
57	pub const Class = enum(u2) {
58	universal,
59	application,
60	context_specific,
61	private,
62	};
63
64	pub fn init(number: Tag.Number, constructed: bool, class: Tag.Class) Tag {
65	return .{ .number = number, .constructed = constructed, .class = class };
66	}
67
68	pub fn universal(number: Tag.Number, constructed: bool) Tag {
69	return .{ .number = number, .constructed = constructed, .class = .universal };
70	}
71
72	pub fn decode(reader: anytype) !Tag {
73	const tag1: FirstTag = @bitCast(try reader.readByte());
74	var number: u14 = tag1.number;
75
76	if (tag1.number == 15) {
77	const tag2: NextTag = @bitCast(try reader.readByte());
78	number = tag2.number;
79	if (tag2.continues) {
80	const tag3: NextTag = @bitCast(try reader.readByte());
81	number = (number << 7) + tag3.number;
82	if (tag3.continues) return error.InvalidLength;
83	}
84	}
85
86	return Tag{
87	.number = @enumFromInt(number),
88	.constructed = tag1.constructed,
89	.class = tag1.class,
90	};
91	}
92
93	pub fn encode(self: Tag, writer: anytype) @TypeOf(writer).Error!void {
94	var tag1 = FirstTag{
95	.number = undefined,
96	.constructed = self.constructed,
97	.class = self.class,
98	};
99
100	var buffer: [3]u8 = undefined;
101	var stream = std.io.fixedBufferStream(&buffer);
102	var writer2 = stream.writer();
103
104	switch (@intFromEnum(self.number)) {
105	0...std.math.maxInt(u5) => \|n\| {
106	tag1.number = @intCast(n);
107	writer2.writeByte(@bitCast(tag1)) catch unreachable;
108	},
109	std.math.maxInt(u5) + 1...std.math.maxInt(u7) => \|n\| {
110	tag1.number = 15;
111	const tag2 = NextTag{ .number = @intCast(n), .continues = false };
112	writer2.writeByte(@bitCast(tag1)) catch unreachable;
113	writer2.writeByte(@bitCast(tag2)) catch unreachable;
114	},
115	else => \|n\| {
116	tag1.number = 15;
117	const tag2 = NextTag{ .number = @intCast(n >> 7), .continues = true };
118	const tag3 = NextTag{ .number = @truncate(n), .continues = false };
119	writer2.writeByte(@bitCast(tag1)) catch unreachable;
120	writer2.writeByte(@bitCast(tag2)) catch unreachable;
121	writer2.writeByte(@bitCast(tag3)) catch unreachable;
122	},
123	}
124
125	_ = try writer.write(stream.getWritten());
126	}
127
128	const FirstTag = packed struct(u8) { number: u5, constructed: bool, class: Tag.Class };
129	const NextTag = packed struct(u8) { number: u7, continues: bool };
130
131	pub fn toExpected(self: Tag) ExpectedTag {
132	return ExpectedTag{
133	.number = self.number,
134	.constructed = self.constructed,
135	.class = self.class,
136	};
137	}
138
139	pub fn fromZig(comptime T: type) Tag {
140	switch (@typeInfo(T)) {
141	.@"struct", .@"enum", .@"union" => {
142	if (@hasDecl(T, "asn1_tag")) return T.asn1_tag;
143	},
144	else => {},
145	}
146
147	switch (@typeInfo(T)) {
148	.@"struct", .@"union" => return universal(.sequence, true),
149	.bool => return universal(.boolean, false),
150	.int => return universal(.integer, false),
151	.@"enum" => \|e\| {
152	if (@hasDecl(T, "oids")) return Oid.asn1_tag;
153	return universal(if (e.is_exhaustive) .enumerated else .integer, false);
154	},
155	.optional => \|o\| return fromZig(o.child),
156	.null => return universal(.null, false),
157	else => @compileError("cannot map Zig type to asn1_tag " ++ @typeName(T)),
158	}
159	}
160	};
161
162	test Tag {
163	const buf = [_]u8{0xa3};
164	var stream = std.io.fixedBufferStream(&buf);
165	const t = Tag.decode(stream.reader());
166	try std.testing.expectEqual(Tag.init(@enumFromInt(3), true, .context_specific), t);
167	}
168
169	/// A decoded view.
170	pub const Element = struct {
171	tag: Tag,
172	slice: Slice,
173
174	pub const Slice = struct {
175	start: Index,
176	end: Index,
177
178	pub fn len(self: Slice) Index {
179	return self.end - self.start;
180	}
181
182	pub fn view(self: Slice, bytes: []const u8) []const u8 {
183	return bytes[self.start..self.end];
184	}
185	};
186
187	pub const DecodeError = error{ InvalidLength, EndOfStream };
188
189	/// Safely decode a DER/BER/CER element at `index`:
190	/// - Ensures length uses shortest form
191	/// - Ensures length is within `bytes`
192	/// - Ensures length is less than `std.math.maxInt(Index)`
193	pub fn decode(bytes: []const u8, index: Index) DecodeError!Element {
194	var stream = std.io.fixedBufferStream(bytes[index..]);
195	var reader = stream.reader();
196
197	const tag = try Tag.decode(reader);
198	const size_or_len_size = try reader.readByte();
199
200	var start = index + 2;
201	var end = start + size_or_len_size;
202	// short form between 0-127
203	if (size_or_len_size < 128) {
204	if (end > bytes.len) return error.InvalidLength;
205	} else {
206	// long form between 0 and std.math.maxInt(u1024)
207	const len_size: u7 = @truncate(size_or_len_size);
208	start += len_size;
209	if (len_size > @sizeOf(Index)) return error.InvalidLength;
210
211	const len = try reader.readVarInt(Index, .big, len_size);
212	if (len < 128) return error.InvalidLength; // should have used short form
213
214	end = std.math.add(Index, start, len) catch return error.InvalidLength;
215	if (end > bytes.len) return error.InvalidLength;
216	}
217
218	return Element{ .tag = tag, .slice = Slice{ .start = start, .end = end } };
219	}
220	};
221
222	test Element {
223	const short_form = [_]u8{ 0x30, 0x03, 0x02, 0x01, 0x09 };
224	try std.testing.expectEqual(Element{
225	.tag = Tag.universal(.sequence, true),
226	.slice = Element.Slice{ .start = 2, .end = short_form.len },
227	}, Element.decode(&short_form, 0));
228
229	const long_form = [_]u8{ 0x30, 129, 129 } ++ [_]u8{0} ** 129;
230	try std.testing.expectEqual(Element{
231	.tag = Tag.universal(.sequence, true),
232	.slice = Element.Slice{ .start = 3, .end = long_form.len },
233	}, Element.decode(&long_form, 0));
234	}
235
236	/// For decoding.
237	pub const ExpectedTag = struct {
238	number: ?Tag.Number = null,
239	constructed: ?bool = null,
240	class: ?Tag.Class = null,
241
242	pub fn init(number: ?Tag.Number, constructed: ?bool, class: ?Tag.Class) ExpectedTag {
243	return .{ .number = number, .constructed = constructed, .class = class };
244	}
245
246	pub fn primitive(number: ?Tag.Number) ExpectedTag {
247	return .{ .number = number, .constructed = false, .class = .universal };
248	}
249
250	pub fn match(self: ExpectedTag, tag: Tag) bool {
251	if (self.number) \|e\| {
252	if (tag.number != e) return false;
253	}
254	if (self.constructed) \|e\| {
255	if (tag.constructed != e) return false;
256	}
257	if (self.class) \|e\| {
258	if (tag.class != e) return false;
259	}
260	return true;
261	}
262	};
263
264	pub const FieldTag = struct {
265	number: std.meta.Tag(Tag.Number),
266	class: Tag.Class,
267	explicit: bool = true,
268
269	pub fn initExplicit(number: std.meta.Tag(Tag.Number), class: Tag.Class) FieldTag {
270	return .{ .number = number, .class = class, .explicit = true };
271	}
272
273	pub fn initImplicit(number: std.meta.Tag(Tag.Number), class: Tag.Class) FieldTag {
274	return .{ .number = number, .class = class, .explicit = false };
275	}
276
277	pub fn fromContainer(comptime Container: type, comptime field_name: []const u8) ?FieldTag {
278	if (@hasDecl(Container, "asn1_tags") and @hasField(@TypeOf(Container.asn1_tags), field_name)) {
279	return @field(Container.asn1_tags, field_name);
280	}
281
282	return null;
283	}
284
285	pub fn toTag(self: FieldTag) Tag {
286	return Tag.init(@enumFromInt(self.number), self.explicit, self.class);
287	}
288	};
289
290	pub const BitString = struct {
291	/// Number of bits in rightmost byte that are unused.
292	right_padding: u3 = 0,
293	bytes: []const u8,
294
295	pub fn bitLen(self: BitString) usize {
296	return self.bytes.len * 8 - self.right_padding;
297	}
298
299	const asn1_tag = Tag.universal(.bitstring, false);
300
301	pub fn decodeDer(decoder: *der.Decoder) !BitString {
302	const ele = try decoder.element(asn1_tag.toExpected());
303	const bytes = decoder.view(ele);
304
305	if (bytes.len < 1) return error.InvalidBitString;
306	const padding = bytes[0];
307	if (padding >= 8) return error.InvalidBitString;
308	const right_padding: u3 = @intCast(padding);
309
310	// DER requires that unused bits be zero.
311	if (@ctz(bytes[bytes.len - 1]) < right_padding) return error.InvalidBitString;
312
313	return BitString{ .bytes = bytes[1..], .right_padding = right_padding };
314	}
315
316	pub fn encodeDer(self: BitString, encoder: *der.Encoder) !void {
317	try encoder.writer().writeAll(self.bytes);
318	try encoder.writer().writeByte(self.right_padding);
319	try encoder.length(self.bytes.len + 1);
320	try encoder.tag(asn1_tag);
321	}
322	};
323
324	pub fn Opaque(comptime tag: Tag) type {
325	return struct {
326	bytes: []const u8,
327
328	pub fn decodeDer(decoder: *der.Decoder) !@This() {
329	const ele = try decoder.element(tag.toExpected());
330	if (tag.constructed) decoder.index = ele.slice.end;
331	return .{ .bytes = decoder.view(ele) };
332	}
333
334	pub fn encodeDer(self: @This(), encoder: *der.Encoder) !void {
335	try encoder.tagBytes(tag, self.bytes);
336	}
337	};
338	}
339
340	/// Use sparingly.
341	pub const Any = struct {
342	tag: Tag,
343	bytes: []const u8,
344
345	pub fn decodeDer(decoder: *der.Decoder) !@This() {
346	const ele = try decoder.element(ExpectedTag{});
347	return .{ .tag = ele.tag, .bytes = decoder.view(ele) };
348	}
349
350	pub fn encodeDer(self: @This(), encoder: *der.Encoder) !void {
351	try encoder.tagBytes(self.tag, self.bytes);
352	}
353	};
354
355	test {
356	_ = der;
357	_ = Oid;
358	_ = @import("asn1/test.zig");
359	}

lib/std/crypto/asn1/Oid.zig deleted-210

...	@@ -1,210 +0,0 @@
1	//! Globally unique hierarchical identifier made of a sequence of integers.
2	//!
3	//! Commonly used to identify standards, algorithms, certificate extensions,
4	//! organizations, or policy documents.
5	encoded: []const u8,
6
7	pub const InitError = std.fmt.ParseIntError \|\| error{MissingPrefix} \|\| std.io.FixedBufferStream(u8).WriteError;
8
9	pub fn fromDot(dot_notation: []const u8, out: []u8) InitError!Oid {
10	var split = std.mem.splitScalar(u8, dot_notation, '.');
11	const first_str = split.next() orelse return error.MissingPrefix;
12	const second_str = split.next() orelse return error.MissingPrefix;
13
14	const first = try std.fmt.parseInt(u8, first_str, 10);
15	const second = try std.fmt.parseInt(u8, second_str, 10);
16
17	var stream = std.io.fixedBufferStream(out);
18	var writer = stream.writer();
19
20	try writer.writeByte(first * 40 + second);
21
22	var i: usize = 1;
23	while (split.next()) \|s\| {
24	var parsed = try std.fmt.parseUnsigned(Arc, s, 10);
25	const n_bytes = if (parsed == 0) 0 else std.math.log(Arc, encoding_base, parsed);
26
27	for (0..n_bytes) \|j\| {
28	const place = std.math.pow(Arc, encoding_base, n_bytes - @as(Arc, @intCast(j)));
29	const digit: u8 = @intCast(@divFloor(parsed, place));
30
31	try writer.writeByte(digit \| 0x80);
32	parsed -= digit * place;
33
34	i += 1;
35	}
36	try writer.writeByte(@intCast(parsed));
37	i += 1;
38	}
39
40	return .{ .encoded = stream.getWritten() };
41	}
42
43	test fromDot {
44	var buf: [256]u8 = undefined;
45	for (test_cases) \|t\| {
46	const actual = try fromDot(t.dot_notation, &buf);
47	try std.testing.expectEqualSlices(u8, t.encoded, actual.encoded);
48	}
49	}
50
51	pub fn toDot(self: Oid, writer: anytype) @TypeOf(writer).Error!void {
52	const encoded = self.encoded;
53	const first = @divTrunc(encoded[0], 40);
54	const second = encoded[0] - first * 40;
55	try writer.print("{d}.{d}", .{ first, second });
56
57	var i: usize = 1;
58	while (i != encoded.len) {
59	const n_bytes: usize = brk: {
60	var res: usize = 1;
61	var j: usize = i;
62	while (encoded[j] & 0x80 != 0) {
63	res += 1;
64	j += 1;
65	}
66	break :brk res;
67	};
68
69	var n: usize = 0;
70	for (0..n_bytes) \|j\| {
71	const place = std.math.pow(usize, encoding_base, n_bytes - j - 1);
72	n += place * (encoded[i] & 0b01111111);
73	i += 1;
74	}
75	try writer.print(".{d}", .{n});
76	}
77	}
78
79	test toDot {
80	var buf: [256]u8 = undefined;
81
82	for (test_cases) \|t\| {
83	var stream = std.io.fixedBufferStream(&buf);
84	try toDot(Oid{ .encoded = t.encoded }, stream.writer());
85	try std.testing.expectEqualStrings(t.dot_notation, stream.getWritten());
86	}
87	}
88
89	const TestCase = struct {
90	encoded: []const u8,
91	dot_notation: []const u8,
92
93	pub fn init(comptime hex: []const u8, dot_notation: []const u8) TestCase {
94	return .{ .encoded = &hexToBytes(hex), .dot_notation = dot_notation };
95	}
96	};
97
98	const test_cases = [_]TestCase{
99	// https://learn.microsoft.com/en-us/windows/win32/seccertenroll/about-object-identifier
100	TestCase.init("2b0601040182371514", "1.3.6.1.4.1.311.21.20"),
101	// https://luca.ntop.org/Teaching/Appunti/asn1.html
102	TestCase.init("2a864886f70d", "1.2.840.113549"),
103	// https://www.sysadmins.lv/blog-en/how-to-encode-object-identifier-to-an-asn1-der-encoded-string.aspx
104	TestCase.init("2a868d20", "1.2.100000"),
105	TestCase.init("2a864886f70d01010b", "1.2.840.113549.1.1.11"),
106	TestCase.init("2b6570", "1.3.101.112"),
107	};
108
109	pub const asn1_tag = asn1.Tag.init(.oid, false, .universal);
110
111	pub fn decodeDer(decoder: *der.Decoder) !Oid {
112	const ele = try decoder.element(asn1_tag.toExpected());
113	return Oid{ .encoded = decoder.view(ele) };
114	}
115
116	pub fn encodeDer(self: Oid, encoder: *der.Encoder) !void {
117	try encoder.tagBytes(asn1_tag, self.encoded);
118	}
119
120	fn encodedLen(dot_notation: []const u8) usize {
121	var buf: [256]u8 = undefined;
122	const oid = fromDot(dot_notation, &buf) catch unreachable;
123	return oid.encoded.len;
124	}
125
126	/// Returns encoded bytes of OID.
127	fn encodeComptime(comptime dot_notation: []const u8) [encodedLen(dot_notation)]u8 {
128	@setEvalBranchQuota(4000);
129	comptime var buf: [256]u8 = undefined;
130	const oid = comptime fromDot(dot_notation, &buf) catch unreachable;
131	return oid.encoded[0..oid.encoded.len].*;
132	}
133
134	test encodeComptime {
135	try std.testing.expectEqual(
136	hexToBytes("2b0601040182371514"),
137	comptime encodeComptime("1.3.6.1.4.1.311.21.20"),
138	);
139	}
140
141	pub fn fromDotComptime(comptime dot_notation: []const u8) Oid {
142	const tmp = comptime encodeComptime(dot_notation);
143	return Oid{ .encoded = &tmp };
144	}
145
146	/// Maps of:
147	/// - Oid -> enum
148	/// - Enum -> oid
149	pub fn StaticMap(comptime Enum: type) type {
150	const enum_info = @typeInfo(Enum).@"enum";
151	const EnumToOid = std.EnumArray(Enum, []const u8);
152	const ReturnType = struct {
153	oid_to_enum: std.StaticStringMap(Enum),
154	enum_to_oid: EnumToOid,
155
156	pub fn oidToEnum(self: @This(), encoded: []const u8) ?Enum {
157	return self.oid_to_enum.get(encoded);
158	}
159
160	pub fn enumToOid(self: @This(), value: Enum) Oid {
161	const bytes = self.enum_to_oid.get(value);
162	return .{ .encoded = bytes };
163	}
164	};
165
166	return struct {
167	pub fn initComptime(comptime key_pairs: anytype) ReturnType {
168	const struct_info = @typeInfo(@TypeOf(key_pairs)).@"struct";
169	const error_msg = "Each field of '" ++ @typeName(Enum) ++ "' must map to exactly one OID";
170	if (!enum_info.is_exhaustive or enum_info.fields.len != struct_info.fields.len) {
171	@compileError(error_msg);
172	}
173
174	comptime var enum_to_oid = EnumToOid.initUndefined();
175
176	const KeyPair = struct { []const u8, Enum };
177	comptime var static_key_pairs: [enum_info.fields.len]KeyPair = undefined;
178
179	comptime for (enum_info.fields, 0..) \|f, i\| {
180	if (!@hasField(@TypeOf(key_pairs), f.name)) {
181	@compileError("Field '" ++ f.name ++ "' missing Oid.StaticMap entry");
182	}
183	const encoded = &encodeComptime(@field(key_pairs, f.name));
184	const tag: Enum = @enumFromInt(f.value);
185	static_key_pairs[i] = .{ encoded, tag };
186	enum_to_oid.set(tag, encoded);
187	};
188
189	const oid_to_enum = std.StaticStringMap(Enum).initComptime(static_key_pairs);
190	if (oid_to_enum.values().len != enum_info.fields.len) @compileError(error_msg);
191
192	return ReturnType{ .oid_to_enum = oid_to_enum, .enum_to_oid = enum_to_oid };
193	}
194	};
195	}
196
197	/// Strictly for testing.
198	fn hexToBytes(comptime hex: []const u8) [hex.len / 2]u8 {
199	var res: [hex.len / 2]u8 = undefined;
200	_ = std.fmt.hexToBytes(&res, hex) catch unreachable;
201	return res;
202	}
203
204	const std = @import("std");
205	const Oid = @This();
206	const Arc = u32;
207	const encoding_base = 128;
208	const Allocator = std.mem.Allocator;
209	const der = @import("der.zig");
210	const asn1 = @import("../asn1.zig");

lib/std/crypto/asn1/der.zig deleted-55

...	@@ -1,55 +0,0 @@
1	//! Distinguised Encoding Rules as defined in X.690 and X.691.
2	//!
3	//! Subset of Basic Encoding Rules (BER) which eliminates flexibility in
4	//! an effort to acheive normality. Used in PKI.
5	const std = @import("std");
6	const asn1 = @import("../asn1.zig");
7
8	pub const Decoder = @import("der/Decoder.zig");
9	pub const Encoder = @import("der/Encoder.zig");
10
11	pub fn decode(comptime T: type, encoded: []const u8) !T {
12	var decoder = Decoder{ .bytes = encoded };
13	const res = try decoder.any(T);
14	std.debug.assert(decoder.index == encoded.len);
15	return res;
16	}
17
18	/// Caller owns returned memory.
19	pub fn encode(allocator: std.mem.Allocator, value: anytype) ![]u8 {
20	var encoder = Encoder.init(allocator);
21	defer encoder.deinit();
22	try encoder.any(value);
23	return try encoder.buffer.toOwnedSlice();
24	}
25
26	test encode {
27	// https://lapo.it/asn1js/#MAgGAyoDBAIBBA
28	const Value = struct { a: asn1.Oid, b: i32 };
29	const test_case = .{
30	.value = Value{ .a = asn1.Oid.fromDotComptime("1.2.3.4"), .b = 4 },
31	.encoded = &[_]u8{ 0x30, 0x08, 0x06, 0x03, 0x2A, 0x03, 0x04, 0x02, 0x01, 0x04 },
32	};
33	const allocator = std.testing.allocator;
34	const actual = try encode(allocator, test_case.value);
35	defer allocator.free(actual);
36
37	try std.testing.expectEqualSlices(u8, test_case.encoded, actual);
38	}
39
40	test decode {
41	// https://lapo.it/asn1js/#MAgGAyoDBAIBBA
42	const Value = struct { a: asn1.Oid, b: i32 };
43	const test_case = .{
44	.value = Value{ .a = asn1.Oid.fromDotComptime("1.2.3.4"), .b = 4 },
45	.encoded = &[_]u8{ 0x30, 0x08, 0x06, 0x03, 0x2A, 0x03, 0x04, 0x02, 0x01, 0x04 },
46	};
47	const decoded = try decode(Value, test_case.encoded);
48
49	try std.testing.expectEqualDeep(test_case.value, decoded);
50	}
51
52	test {
53	_ = Decoder;
54	_ = Encoder;
55	}

lib/std/crypto/asn1/der/ArrayListReverse.zig deleted-97

...	@@ -1,97 +0,0 @@
1	//! An ArrayList that grows backwards. Counts nested prefix length fields
2	//! in O(n) instead of O(n^depth) at the cost of extra buffering.
3	//!
4	//! Laid out in memory like:
5	//! capacity \|--------------------------\|
6	//! data \|-------------\|
7	data: []u8,
8	capacity: usize,
9	allocator: Allocator,
10
11	const ArrayListReverse = @This();
12	const Error = Allocator.Error;
13
14	pub fn init(allocator: Allocator) ArrayListReverse {
15	return .{ .data = &.{}, .capacity = 0, .allocator = allocator };
16	}
17
18	pub fn deinit(self: *ArrayListReverse) void {
19	self.allocator.free(self.allocatedSlice());
20	}
21
22	pub fn ensureCapacity(self: *ArrayListReverse, new_capacity: usize) Error!void {
23	if (self.capacity >= new_capacity) return;
24
25	const old_memory = self.allocatedSlice();
26	// Just make a new allocation to not worry about aliasing.
27	const new_memory = try self.allocator.alloc(u8, new_capacity);
28	@memcpy(new_memory[new_capacity - self.data.len ..], self.data);
29	self.allocator.free(old_memory);
30	self.data.ptr = new_memory.ptr + new_capacity - self.data.len;
31	self.capacity = new_memory.len;
32	}
33
34	pub fn prependSlice(self: *ArrayListReverse, data: []const u8) Error!void {
35	try self.ensureCapacity(self.data.len + data.len);
36	const old_len = self.data.len;
37	const new_len = old_len + data.len;
38	assert(new_len <= self.capacity);
39	self.data.len = new_len;
40
41	const end = self.data.ptr;
42	const begin = end - data.len;
43	const slice = begin[0..data.len];
44	@memcpy(slice, data);
45	self.data.ptr = begin;
46	}
47
48	pub const Writer = std.io.Writer(*ArrayListReverse, Error, prependSliceSize);
49	/// Warning: This writer writes backwards. `fn print` will NOT work as expected.
50	pub fn writer(self: *ArrayListReverse) Writer {
51	return .{ .context = self };
52	}
53
54	fn prependSliceSize(self: *ArrayListReverse, data: []const u8) Error!usize {
55	try self.prependSlice(data);
56	return data.len;
57	}
58
59	fn allocatedSlice(self: *ArrayListReverse) []u8 {
60	return (self.data.ptr + self.data.len - self.capacity)[0..self.capacity];
61	}
62
63	/// Invalidates all element pointers.
64	pub fn clearAndFree(self: *ArrayListReverse) void {
65	self.allocator.free(self.allocatedSlice());
66	self.data.len = 0;
67	self.capacity = 0;
68	}
69
70	/// The caller owns the returned memory.
71	/// Capacity is cleared, making deinit() safe but unnecessary to call.
72	pub fn toOwnedSlice(self: *ArrayListReverse) Error![]u8 {
73	const new_memory = try self.allocator.alloc(u8, self.data.len);
74	@memcpy(new_memory, self.data);
75	@memset(self.data, undefined);
76	self.clearAndFree();
77	return new_memory;
78	}
79
80	const std = @import("std");
81	const Allocator = std.mem.Allocator;
82	const assert = std.debug.assert;
83	const testing = std.testing;
84
85	test ArrayListReverse {
86	var b = ArrayListReverse.init(testing.allocator);
87	defer b.deinit();
88	const data: []const u8 = &.{ 4, 5, 6 };
89	try b.prependSlice(data);
90	try testing.expectEqual(data.len, b.data.len);
91	try testing.expectEqualSlices(u8, data, b.data);
92
93	const data2: []const u8 = &.{ 1, 2, 3 };
94	try b.prependSlice(data2);
95	try testing.expectEqual(data.len + data2.len, b.data.len);
96	try testing.expectEqualSlices(u8, data2 ++ data, b.data);
97	}

lib/std/crypto/asn1/der/Decoder.zig deleted-170

...	@@ -1,170 +0,0 @@
1	//! A secure DER parser that:
2	//! - Prefers calling `fn decodeDer(self: @This(), decoder: *der.Decoder)`
3	//! - Does NOT allocate. If you wish to parse lists you can do so lazily
4	//! with an opaque type.
5	//! - Does NOT read memory outside `bytes`.
6	//! - Does NOT return elements with slices outside `bytes`.
7	//! - Errors on values that do NOT follow DER rules:
8	//! - Lengths that could be represented in a shorter form.
9	//! - Booleans that are not 0xff or 0x00.
10	bytes: []const u8,
11	index: Index = 0,
12	/// The field tag of the most recently visited field.
13	/// This is needed because we might visit an implicitly tagged container with a `fn decodeDer`.
14	field_tag: ?FieldTag = null,
15
16	/// Expect a value.
17	pub fn any(self: *Decoder, comptime T: type) !T {
18	if (std.meta.hasFn(T, "decodeDer")) return try T.decodeDer(self);
19
20	const tag = Tag.fromZig(T).toExpected();
21	switch (@typeInfo(T)) {
22	.@"struct" => {
23	const ele = try self.element(tag);
24	defer self.index = ele.slice.end; // don't force parsing all fields
25
26	var res: T = undefined;
27
28	inline for (std.meta.fields(T)) \|f\| {
29	self.field_tag = FieldTag.fromContainer(T, f.name);
30
31	if (self.field_tag) \|ft\| {
32	if (ft.explicit) {
33	const seq = try self.element(ft.toTag().toExpected());
34	self.index = seq.slice.start;
35	self.field_tag = null;
36	}
37	}
38
39	@field(res, f.name) = self.any(f.type) catch \|err\| brk: {
40	if (f.defaultValue()) \|d\| {
41	break :brk d;
42	}
43	return err;
44	};
45	// DER encodes null values by skipping them.
46	if (@typeInfo(f.type) == .optional and @field(res, f.name) == null) {
47	if (f.defaultValue()) \|d\| @field(res, f.name) = d;
48	}
49	}
50
51	return res;
52	},
53	.bool => {
54	const ele = try self.element(tag);
55	const bytes = self.view(ele);
56	if (bytes.len != 1) return error.InvalidBool;
57
58	return switch (bytes[0]) {
59	0x00 => false,
60	0xff => true,
61	else => error.InvalidBool,
62	};
63	},
64	.int => {
65	const ele = try self.element(tag);
66	const bytes = self.view(ele);
67	return try int(T, bytes);
68	},
69	.@"enum" => \|e\| {
70	const ele = try self.element(tag);
71	const bytes = self.view(ele);
72	if (@hasDecl(T, "oids")) {
73	return T.oids.oidToEnum(bytes) orelse return error.UnknownOid;
74	}
75	return @enumFromInt(try int(e.tag_type, bytes));
76	},
77	.optional => \|o\| return self.any(o.child) catch return null,
78	else => @compileError("cannot decode type " ++ @typeName(T)),
79	}
80	}
81
82	//// Expect a sequence.
83	pub fn sequence(self: *Decoder) !Element {
84	return try self.element(ExpectedTag.init(.sequence, true, .universal));
85	}
86
87	//// Expect an element.
88	pub fn element(
89	self: *Decoder,
90	expected: ExpectedTag,
91	) (error{ EndOfStream, UnexpectedElement } \|\| Element.DecodeError)!Element {
92	if (self.index >= self.bytes.len) return error.EndOfStream;
93
94	const res = try Element.decode(self.bytes, self.index);
95	var e = expected;
96	if (self.field_tag) \|ft\| {
97	e.number = @enumFromInt(ft.number);
98	e.class = ft.class;
99	}
100	if (!e.match(res.tag)) {
101	return error.UnexpectedElement;
102	}
103
104	self.index = if (res.tag.constructed) res.slice.start else res.slice.end;
105	return res;
106	}
107
108	/// View of element bytes.
109	pub fn view(self: Decoder, elem: Element) []const u8 {
110	return elem.slice.view(self.bytes);
111	}
112
113	fn int(comptime T: type, value: []const u8) error{ NonCanonical, LargeValue }!T {
114	if (@typeInfo(T).int.bits % 8 != 0) @compileError("T must be byte aligned");
115
116	var bytes = value;
117	if (bytes.len >= 2) {
118	if (bytes[0] == 0) {
119	if (@clz(bytes[1]) > 0) return error.NonCanonical;
120	bytes.ptr += 1;
121	}
122	if (bytes[0] == 0xff and @clz(bytes[1]) == 0) return error.NonCanonical;
123	}
124
125	if (bytes.len > @sizeOf(T)) return error.LargeValue;
126	if (@sizeOf(T) == 1) return @bitCast(bytes[0]);
127
128	return std.mem.readVarInt(T, bytes, .big);
129	}
130
131	test int {
132	try expectEqual(@as(u8, 1), try int(u8, &[_]u8{1}));
133	try expectError(error.NonCanonical, int(u8, &[_]u8{ 0, 1 }));
134	try expectError(error.NonCanonical, int(u8, &[_]u8{ 0xff, 0xff }));
135
136	const big = [_]u8{ 0xef, 0xff };
137	try expectError(error.LargeValue, int(u8, &big));
138	try expectEqual(0xefff, int(u16, &big));
139	}
140
141	test Decoder {
142	var parser = Decoder{ .bytes = @embedFile("./testdata/id_ecc.pub.der") };
143	const seq = try parser.sequence();
144
145	{
146	const seq2 = try parser.sequence();
147	_ = try parser.element(ExpectedTag.init(.oid, false, .universal));
148	_ = try parser.element(ExpectedTag.init(.oid, false, .universal));
149
150	try std.testing.expectEqual(parser.index, seq2.slice.end);
151	}
152	_ = try parser.element(ExpectedTag.init(.bitstring, false, .universal));
153
154	try std.testing.expectEqual(parser.index, seq.slice.end);
155	try std.testing.expectEqual(parser.index, parser.bytes.len);
156	}
157
158	const std = @import("std");
159	const builtin = @import("builtin");
160	const asn1 = @import("../../asn1.zig");
161	const Oid = @import("../Oid.zig");
162
163	const expectEqual = std.testing.expectEqual;
164	const expectError = std.testing.expectError;
165	const Decoder = @This();
166	const Index = asn1.Index;
167	const Tag = asn1.Tag;
168	const FieldTag = asn1.FieldTag;
169	const ExpectedTag = asn1.ExpectedTag;
170	const Element = asn1.Element;

lib/std/crypto/asn1/der/Encoder.zig deleted-166

...	@@ -1,166 +0,0 @@
1	//! A buffered DER encoder.
2	//!
3	//! Prefers calling container's `fn encodeDer(self: @This(), encoder: *der.Encoder)`.
4	//! That function should encode values, lengths, then tags.
5	buffer: ArrayListReverse,
6	/// The field tag set by a parent container.
7	/// This is needed because we might visit an implicitly tagged container with a `fn encodeDer`.
8	field_tag: ?FieldTag = null,
9
10	pub fn init(allocator: std.mem.Allocator) Encoder {
11	return Encoder{ .buffer = ArrayListReverse.init(allocator) };
12	}
13
14	pub fn deinit(self: *Encoder) void {
15	self.buffer.deinit();
16	}
17
18	/// Encode any value.
19	pub fn any(self: *Encoder, val: anytype) !void {
20	const T = @TypeOf(val);
21	try self.anyTag(Tag.fromZig(T), val);
22	}
23
24	fn anyTag(self: *Encoder, tag_: Tag, val: anytype) !void {
25	const T = @TypeOf(val);
26	if (std.meta.hasFn(T, "encodeDer")) return try val.encodeDer(self);
27	const start = self.buffer.data.len;
28	const merged_tag = self.mergedTag(tag_);
29
30	switch (@typeInfo(T)) {
31	.@"struct" => \|info\| {
32	inline for (0..info.fields.len) \|i\| {
33	const f = info.fields[info.fields.len - i - 1];
34	const field_val = @field(val, f.name);
35	const field_tag = FieldTag.fromContainer(T, f.name);
36
37	// > The encoding of a set value or sequence value shall not include an encoding for any
38	// > component value which is equal to its default value.
39	const is_default = if (f.is_comptime) false else if (f.default_value_ptr) \|v\| brk: {
40	const default_val: *const f.type = @alignCast(@ptrCast(v));
41	break :brk std.mem.eql(u8, std.mem.asBytes(default_val), std.mem.asBytes(&field_val));
42	} else false;
43
44	if (!is_default) {
45	const start2 = self.buffer.data.len;
46	self.field_tag = field_tag;
47	// will merge with self.field_tag.
48	// may mutate self.field_tag.
49	try self.anyTag(Tag.fromZig(f.type), field_val);
50	if (field_tag) \|ft\| {
51	if (ft.explicit) {
52	try self.length(self.buffer.data.len - start2);
53	try self.tag(ft.toTag());
54	self.field_tag = null;
55	}
56	}
57	}
58	}
59	},
60	.bool => try self.buffer.prependSlice(&[_]u8{if (val) 0xff else 0}),
61	.int => try self.int(T, val),
62	.@"enum" => \|e\| {
63	if (@hasDecl(T, "oids")) {
64	return self.any(T.oids.enumToOid(val));
65	} else {
66	try self.int(e.tag_type, @intFromEnum(val));
67	}
68	},
69	.optional => if (val) \|v\| return try self.anyTag(tag_, v),
70	.null => {},
71	else => @compileError("cannot encode type " ++ @typeName(T)),
72	}
73
74	try self.length(self.buffer.data.len - start);
75	try self.tag(merged_tag);
76	}
77
78	/// Encode a tag.
79	pub fn tag(self: *Encoder, tag_: Tag) !void {
80	const t = self.mergedTag(tag_);
81	try t.encode(self.writer());
82	}
83
84	fn mergedTag(self: *Encoder, tag_: Tag) Tag {
85	var res = tag_;
86	if (self.field_tag) \|ft\| {
87	if (!ft.explicit) {
88	res.number = @enumFromInt(ft.number);
89	res.class = ft.class;
90	}
91	}
92	return res;
93	}
94
95	/// Encode a length.
96	pub fn length(self: *Encoder, len: usize) !void {
97	const writer_ = self.writer();
98	if (len < 128) {
99	try writer_.writeInt(u8, @intCast(len), .big);
100	return;
101	}
102	inline for ([_]type{ u8, u16, u32 }) \|T\| {
103	if (len < std.math.maxInt(T)) {
104	try writer_.writeInt(T, @intCast(len), .big);
105	try writer_.writeInt(u8, @sizeOf(T) \| 0x80, .big);
106	return;
107	}
108	}
109	return error.InvalidLength;
110	}
111
112	/// Encode a tag and length-prefixed bytes.
113	pub fn tagBytes(self: *Encoder, tag_: Tag, bytes: []const u8) !void {
114	try self.buffer.prependSlice(bytes);
115	try self.length(bytes.len);
116	try self.tag(tag_);
117	}
118
119	/// Warning: This writer writes backwards. `fn print` will NOT work as expected.
120	pub fn writer(self: *Encoder) ArrayListReverse.Writer {
121	return self.buffer.writer();
122	}
123
124	fn int(self: *Encoder, comptime T: type, value: T) !void {
125	const big = std.mem.nativeTo(T, value, .big);
126	const big_bytes = std.mem.asBytes(&big);
127
128	const bits_needed = @bitSizeOf(T) - @clz(value);
129	const needs_padding: u1 = if (value == 0)
130	1
131	else if (bits_needed > 8) brk: {
132	const RightShift = std.meta.Int(.unsigned, @bitSizeOf(@TypeOf(bits_needed)) - 1);
133	const right_shift: RightShift = @intCast(bits_needed - 9);
134	break :brk if (value >> right_shift == 0x1ff) 1 else 0;
135	} else 0;
136	const bytes_needed = try std.math.divCeil(usize, bits_needed, 8) + needs_padding;
137
138	const writer_ = self.writer();
139	for (0..bytes_needed - needs_padding) \|i\| try writer_.writeByte(big_bytes[big_bytes.len - i - 1]);
140	if (needs_padding == 1) try writer_.writeByte(0);
141	}
142
143	test int {
144	const allocator = std.testing.allocator;
145	var encoder = Encoder.init(allocator);
146	defer encoder.deinit();
147
148	try encoder.int(u8, 0);
149	try std.testing.expectEqualSlices(u8, &[_]u8{0}, encoder.buffer.data);
150
151	encoder.buffer.clearAndFree();
152	try encoder.int(u16, 0x00ff);
153	try std.testing.expectEqualSlices(u8, &[_]u8{0xff}, encoder.buffer.data);
154
155	encoder.buffer.clearAndFree();
156	try encoder.int(u32, 0xffff);
157	try std.testing.expectEqualSlices(u8, &[_]u8{ 0, 0xff, 0xff }, encoder.buffer.data);
158	}
159
160	const std = @import("std");
161	const Oid = @import("../Oid.zig");
162	const asn1 = @import("../../asn1.zig");
163	const ArrayListReverse = @import("./ArrayListReverse.zig");
164	const Tag = asn1.Tag;
165	const FieldTag = asn1.FieldTag;
166	const Encoder = @This();

lib/std/crypto/asn1/der/testdata/all_types.der deleted

Binary files a/lib/std/crypto/asn1/der/testdata/all_types.der and /dev/null differ

lib/std/crypto/asn1/der/testdata/id_ecc.pub.der deleted

Binary files a/lib/std/crypto/asn1/der/testdata/id_ecc.pub.der and /dev/null differ

lib/std/crypto/asn1/test.zig deleted-80

...	@@ -1,80 +0,0 @@
1	const std = @import("std");
2	const asn1 = @import("../asn1.zig");
3
4	const der = asn1.der;
5	const Tag = asn1.Tag;
6	const FieldTag = asn1.FieldTag;
7
8	/// An example that uses all ASN1 types and available implementation features.
9	const AllTypes = struct {
10	a: u8 = 0,
11	b: asn1.BitString,
12	c: C,
13	d: asn1.Opaque(Tag.universal(.string_utf8, false)),
14	e: asn1.Opaque(Tag.universal(.octetstring, false)),
15	f: ?u16,
16	g: ?Nested,
17	h: asn1.Any,
18
19	pub const asn1_tags = .{
20	.a = FieldTag.initExplicit(0, .context_specific),
21	.b = FieldTag.initExplicit(1, .context_specific),
22	.c = FieldTag.initImplicit(2, .context_specific),
23	.g = FieldTag.initImplicit(3, .context_specific),
24	};
25
26	const C = enum {
27	a,
28	b,
29
30	pub const oids = asn1.Oid.StaticMap(@This()).initComptime(.{
31	.a = "1.2.3.4",
32	.b = "1.2.3.5",
33	});
34	};
35
36	const Nested = struct {
37	inner: Asn1T,
38	sum: i16,
39
40	const Asn1T = struct { a: u8, b: i16 };
41
42	pub fn decodeDer(decoder: *der.Decoder) !Nested {
43	const inner = try decoder.any(Asn1T);
44	return Nested{ .inner = inner, .sum = inner.a + inner.b };
45	}
46
47	pub fn encodeDer(self: Nested, encoder: *der.Encoder) !void {
48	try encoder.any(self.inner);
49	}
50	};
51	};
52
53	test AllTypes {
54	const expected = AllTypes{
55	.a = 2,
56	.b = asn1.BitString{ .bytes = &[_]u8{ 0x04, 0xa0 } },
57	.c = .a,
58	.d = .{ .bytes = "asdf" },
59	.e = .{ .bytes = "fdsa" },
60	.f = (1 << 8) + 1,
61	.g = .{ .inner = .{ .a = 4, .b = 5 }, .sum = 9 },
62	.h = .{ .tag = Tag.init(.string_ia5, false, .universal), .bytes = "asdf" },
63	};
64	// https://lapo.it/asn1js/#MC-gAwIBAqEFAwMABKCCAyoDBAwEYXNkZgQEZmRzYQICAQGjBgIBBAIBBRYEYXNkZg
65	const path = "./der/testdata/all_types.der";
66	const encoded = @embedFile(path);
67	const actual = try asn1.der.decode(AllTypes, encoded);
68	try std.testing.expectEqualDeep(expected, actual);
69
70	const allocator = std.testing.allocator;
71	const buf = try asn1.der.encode(allocator, expected);
72	defer allocator.free(buf);
73	try std.testing.expectEqualSlices(u8, encoded, buf);
74
75	// Use this to update test file.
76	// const dir = try std.fs.cwd().openDir("lib/std/crypto/asn1", .{});
77	// var file = try dir.createFile(path, .{});
78	// defer file.close();
79	// try file.writeAll(buf);
80	}

lib/std/crypto/codecs.zig created+3

...	@@ -0,0 +1,3 @@
1	pub const asn1 = @import("codecs/asn1.zig");
2	pub const Base64 = @import("codecs/base64_hex_ct.zig").Base64;
3	pub const Hex = @import("codecs/base64_hex_ct.zig").Hex;

lib/std/crypto/codecs/asn1.zig created+359

...	@@ -0,0 +1,359 @@
1	//! ASN.1 types for public consumption.
2	const std = @import("std");
3	pub const der = @import("./asn1/der.zig");
4	pub const Oid = @import("./asn1/Oid.zig");
5
6	pub const Index = u32;
7
8	pub const Tag = struct {
9	number: Number,
10	/// Whether this ASN.1 type contains other ASN.1 types.
11	constructed: bool,
12	class: Class,
13
14	/// These values apply to class == .universal.
15	pub const Number = enum(u16) {
16	// 0 is reserved by spec
17	boolean = 1,
18	integer = 2,
19	bitstring = 3,
20	octetstring = 4,
21	null = 5,
22	oid = 6,
23	object_descriptor = 7,
24	real = 9,
25	enumerated = 10,
26	embedded = 11,
27	string_utf8 = 12,
28	oid_relative = 13,
29	time = 14,
30	// 15 is reserved to mean that the tag is >= 32
31	sequence = 16,
32	/// Elements may appear in any order.
33	sequence_of = 17,
34	string_numeric = 18,
35	string_printable = 19,
36	string_teletex = 20,
37	string_videotex = 21,
38	string_ia5 = 22,
39	utc_time = 23,
40	generalized_time = 24,
41	string_graphic = 25,
42	string_visible = 26,
43	string_general = 27,
44	string_universal = 28,
45	string_char = 29,
46	string_bmp = 30,
47	date = 31,
48	time_of_day = 32,
49	date_time = 33,
50	duration = 34,
51	/// IRI = Internationalized Resource Identifier
52	oid_iri = 35,
53	oid_iri_relative = 36,
54	_,
55	};
56
57	pub const Class = enum(u2) {
58	universal,
59	application,
60	context_specific,
61	private,
62	};
63
64	pub fn init(number: Tag.Number, constructed: bool, class: Tag.Class) Tag {
65	return .{ .number = number, .constructed = constructed, .class = class };
66	}
67
68	pub fn universal(number: Tag.Number, constructed: bool) Tag {
69	return .{ .number = number, .constructed = constructed, .class = .universal };
70	}
71
72	pub fn decode(reader: anytype) !Tag {
73	const tag1: FirstTag = @bitCast(try reader.readByte());
74	var number: u14 = tag1.number;
75
76	if (tag1.number == 15) {
77	const tag2: NextTag = @bitCast(try reader.readByte());
78	number = tag2.number;
79	if (tag2.continues) {
80	const tag3: NextTag = @bitCast(try reader.readByte());
81	number = (number << 7) + tag3.number;
82	if (tag3.continues) return error.InvalidLength;
83	}
84	}
85
86	return Tag{
87	.number = @enumFromInt(number),
88	.constructed = tag1.constructed,
89	.class = tag1.class,
90	};
91	}
92
93	pub fn encode(self: Tag, writer: anytype) @TypeOf(writer).Error!void {
94	var tag1 = FirstTag{
95	.number = undefined,
96	.constructed = self.constructed,
97	.class = self.class,
98	};
99
100	var buffer: [3]u8 = undefined;
101	var stream = std.io.fixedBufferStream(&buffer);
102	var writer2 = stream.writer();
103
104	switch (@intFromEnum(self.number)) {
105	0...std.math.maxInt(u5) => \|n\| {
106	tag1.number = @intCast(n);
107	writer2.writeByte(@bitCast(tag1)) catch unreachable;
108	},
109	std.math.maxInt(u5) + 1...std.math.maxInt(u7) => \|n\| {
110	tag1.number = 15;
111	const tag2 = NextTag{ .number = @intCast(n), .continues = false };
112	writer2.writeByte(@bitCast(tag1)) catch unreachable;
113	writer2.writeByte(@bitCast(tag2)) catch unreachable;
114	},
115	else => \|n\| {
116	tag1.number = 15;
117	const tag2 = NextTag{ .number = @intCast(n >> 7), .continues = true };
118	const tag3 = NextTag{ .number = @truncate(n), .continues = false };
119	writer2.writeByte(@bitCast(tag1)) catch unreachable;
120	writer2.writeByte(@bitCast(tag2)) catch unreachable;
121	writer2.writeByte(@bitCast(tag3)) catch unreachable;
122	},
123	}
124
125	_ = try writer.write(stream.getWritten());
126	}
127
128	const FirstTag = packed struct(u8) { number: u5, constructed: bool, class: Tag.Class };
129	const NextTag = packed struct(u8) { number: u7, continues: bool };
130
131	pub fn toExpected(self: Tag) ExpectedTag {
132	return ExpectedTag{
133	.number = self.number,
134	.constructed = self.constructed,
135	.class = self.class,
136	};
137	}
138
139	pub fn fromZig(comptime T: type) Tag {
140	switch (@typeInfo(T)) {
141	.@"struct", .@"enum", .@"union" => {
142	if (@hasDecl(T, "asn1_tag")) return T.asn1_tag;
143	},
144	else => {},
145	}
146
147	switch (@typeInfo(T)) {
148	.@"struct", .@"union" => return universal(.sequence, true),
149	.bool => return universal(.boolean, false),
150	.int => return universal(.integer, false),
151	.@"enum" => \|e\| {
152	if (@hasDecl(T, "oids")) return Oid.asn1_tag;
153	return universal(if (e.is_exhaustive) .enumerated else .integer, false);
154	},
155	.optional => \|o\| return fromZig(o.child),
156	.null => return universal(.null, false),
157	else => @compileError("cannot map Zig type to asn1_tag " ++ @typeName(T)),
158	}
159	}
160	};
161
162	test Tag {
163	const buf = [_]u8{0xa3};
164	var stream = std.io.fixedBufferStream(&buf);
165	const t = Tag.decode(stream.reader());
166	try std.testing.expectEqual(Tag.init(@enumFromInt(3), true, .context_specific), t);
167	}
168
169	/// A decoded view.
170	pub const Element = struct {
171	tag: Tag,
172	slice: Slice,
173
174	pub const Slice = struct {
175	start: Index,
176	end: Index,
177
178	pub fn len(self: Slice) Index {
179	return self.end - self.start;
180	}
181
182	pub fn view(self: Slice, bytes: []const u8) []const u8 {
183	return bytes[self.start..self.end];
184	}
185	};
186
187	pub const DecodeError = error{ InvalidLength, EndOfStream };
188
189	/// Safely decode a DER/BER/CER element at `index`:
190	/// - Ensures length uses shortest form
191	/// - Ensures length is within `bytes`
192	/// - Ensures length is less than `std.math.maxInt(Index)`
193	pub fn decode(bytes: []const u8, index: Index) DecodeError!Element {
194	var stream = std.io.fixedBufferStream(bytes[index..]);
195	var reader = stream.reader();
196
197	const tag = try Tag.decode(reader);
198	const size_or_len_size = try reader.readByte();
199
200	var start = index + 2;
201	var end = start + size_or_len_size;
202	// short form between 0-127
203	if (size_or_len_size < 128) {
204	if (end > bytes.len) return error.InvalidLength;
205	} else {
206	// long form between 0 and std.math.maxInt(u1024)
207	const len_size: u7 = @truncate(size_or_len_size);
208	start += len_size;
209	if (len_size > @sizeOf(Index)) return error.InvalidLength;
210
211	const len = try reader.readVarInt(Index, .big, len_size);
212	if (len < 128) return error.InvalidLength; // should have used short form
213
214	end = std.math.add(Index, start, len) catch return error.InvalidLength;
215	if (end > bytes.len) return error.InvalidLength;
216	}
217
218	return Element{ .tag = tag, .slice = Slice{ .start = start, .end = end } };
219	}
220	};
221
222	test Element {
223	const short_form = [_]u8{ 0x30, 0x03, 0x02, 0x01, 0x09 };
224	try std.testing.expectEqual(Element{
225	.tag = Tag.universal(.sequence, true),
226	.slice = Element.Slice{ .start = 2, .end = short_form.len },
227	}, Element.decode(&short_form, 0));
228
229	const long_form = [_]u8{ 0x30, 129, 129 } ++ [_]u8{0} ** 129;
230	try std.testing.expectEqual(Element{
231	.tag = Tag.universal(.sequence, true),
232	.slice = Element.Slice{ .start = 3, .end = long_form.len },
233	}, Element.decode(&long_form, 0));
234	}
235
236	/// For decoding.
237	pub const ExpectedTag = struct {
238	number: ?Tag.Number = null,
239	constructed: ?bool = null,
240	class: ?Tag.Class = null,
241
242	pub fn init(number: ?Tag.Number, constructed: ?bool, class: ?Tag.Class) ExpectedTag {
243	return .{ .number = number, .constructed = constructed, .class = class };
244	}
245
246	pub fn primitive(number: ?Tag.Number) ExpectedTag {
247	return .{ .number = number, .constructed = false, .class = .universal };
248	}
249
250	pub fn match(self: ExpectedTag, tag: Tag) bool {
251	if (self.number) \|e\| {
252	if (tag.number != e) return false;
253	}
254	if (self.constructed) \|e\| {
255	if (tag.constructed != e) return false;
256	}
257	if (self.class) \|e\| {
258	if (tag.class != e) return false;
259	}
260	return true;
261	}
262	};
263
264	pub const FieldTag = struct {
265	number: std.meta.Tag(Tag.Number),
266	class: Tag.Class,
267	explicit: bool = true,
268
269	pub fn initExplicit(number: std.meta.Tag(Tag.Number), class: Tag.Class) FieldTag {
270	return .{ .number = number, .class = class, .explicit = true };
271	}
272
273	pub fn initImplicit(number: std.meta.Tag(Tag.Number), class: Tag.Class) FieldTag {
274	return .{ .number = number, .class = class, .explicit = false };
275	}
276
277	pub fn fromContainer(comptime Container: type, comptime field_name: []const u8) ?FieldTag {
278	if (@hasDecl(Container, "asn1_tags") and @hasField(@TypeOf(Container.asn1_tags), field_name)) {
279	return @field(Container.asn1_tags, field_name);
280	}
281
282	return null;
283	}
284
285	pub fn toTag(self: FieldTag) Tag {
286	return Tag.init(@enumFromInt(self.number), self.explicit, self.class);
287	}
288	};
289
290	pub const BitString = struct {
291	/// Number of bits in rightmost byte that are unused.
292	right_padding: u3 = 0,
293	bytes: []const u8,
294
295	pub fn bitLen(self: BitString) usize {
296	return self.bytes.len * 8 - self.right_padding;
297	}
298
299	const asn1_tag = Tag.universal(.bitstring, false);
300
301	pub fn decodeDer(decoder: *der.Decoder) !BitString {
302	const ele = try decoder.element(asn1_tag.toExpected());
303	const bytes = decoder.view(ele);
304
305	if (bytes.len < 1) return error.InvalidBitString;
306	const padding = bytes[0];
307	if (padding >= 8) return error.InvalidBitString;
308	const right_padding: u3 = @intCast(padding);
309
310	// DER requires that unused bits be zero.
311	if (@ctz(bytes[bytes.len - 1]) < right_padding) return error.InvalidBitString;
312
313	return BitString{ .bytes = bytes[1..], .right_padding = right_padding };
314	}
315
316	pub fn encodeDer(self: BitString, encoder: *der.Encoder) !void {
317	try encoder.writer().writeAll(self.bytes);
318	try encoder.writer().writeByte(self.right_padding);
319	try encoder.length(self.bytes.len + 1);
320	try encoder.tag(asn1_tag);
321	}
322	};
323
324	pub fn Opaque(comptime tag: Tag) type {
325	return struct {
326	bytes: []const u8,
327
328	pub fn decodeDer(decoder: *der.Decoder) !@This() {
329	const ele = try decoder.element(tag.toExpected());
330	if (tag.constructed) decoder.index = ele.slice.end;
331	return .{ .bytes = decoder.view(ele) };
332	}
333
334	pub fn encodeDer(self: @This(), encoder: *der.Encoder) !void {
335	try encoder.tagBytes(tag, self.bytes);
336	}
337	};
338	}
339
340	/// Use sparingly.
341	pub const Any = struct {
342	tag: Tag,
343	bytes: []const u8,
344
345	pub fn decodeDer(decoder: *der.Decoder) !@This() {
346	const ele = try decoder.element(ExpectedTag{});
347	return .{ .tag = ele.tag, .bytes = decoder.view(ele) };
348	}
349
350	pub fn encodeDer(self: @This(), encoder: *der.Encoder) !void {
351	try encoder.tagBytes(self.tag, self.bytes);
352	}
353	};
354
355	test {
356	_ = der;
357	_ = Oid;
358	_ = @import("asn1/test.zig");
359	}

lib/std/crypto/codecs/asn1/Oid.zig created+210

...	@@ -0,0 +1,210 @@
1	//! Globally unique hierarchical identifier made of a sequence of integers.
2	//!
3	//! Commonly used to identify standards, algorithms, certificate extensions,
4	//! organizations, or policy documents.
5	encoded: []const u8,
6
7	pub const InitError = std.fmt.ParseIntError \|\| error{MissingPrefix} \|\| std.io.FixedBufferStream(u8).WriteError;
8
9	pub fn fromDot(dot_notation: []const u8, out: []u8) InitError!Oid {
10	var split = std.mem.splitScalar(u8, dot_notation, '.');
11	const first_str = split.next() orelse return error.MissingPrefix;
12	const second_str = split.next() orelse return error.MissingPrefix;
13
14	const first = try std.fmt.parseInt(u8, first_str, 10);
15	const second = try std.fmt.parseInt(u8, second_str, 10);
16
17	var stream = std.io.fixedBufferStream(out);
18	var writer = stream.writer();
19
20	try writer.writeByte(first * 40 + second);
21
22	var i: usize = 1;
23	while (split.next()) \|s\| {
24	var parsed = try std.fmt.parseUnsigned(Arc, s, 10);
25	const n_bytes = if (parsed == 0) 0 else std.math.log(Arc, encoding_base, parsed);
26
27	for (0..n_bytes) \|j\| {
28	const place = std.math.pow(Arc, encoding_base, n_bytes - @as(Arc, @intCast(j)));
29	const digit: u8 = @intCast(@divFloor(parsed, place));
30
31	try writer.writeByte(digit \| 0x80);
32	parsed -= digit * place;
33
34	i += 1;
35	}
36	try writer.writeByte(@intCast(parsed));
37	i += 1;
38	}
39
40	return .{ .encoded = stream.getWritten() };
41	}
42
43	test fromDot {
44	var buf: [256]u8 = undefined;
45	for (test_cases) \|t\| {
46	const actual = try fromDot(t.dot_notation, &buf);
47	try std.testing.expectEqualSlices(u8, t.encoded, actual.encoded);
48	}
49	}
50
51	pub fn toDot(self: Oid, writer: anytype) @TypeOf(writer).Error!void {
52	const encoded = self.encoded;
53	const first = @divTrunc(encoded[0], 40);
54	const second = encoded[0] - first * 40;
55	try writer.print("{d}.{d}", .{ first, second });
56
57	var i: usize = 1;
58	while (i != encoded.len) {
59	const n_bytes: usize = brk: {
60	var res: usize = 1;
61	var j: usize = i;
62	while (encoded[j] & 0x80 != 0) {
63	res += 1;
64	j += 1;
65	}
66	break :brk res;
67	};
68
69	var n: usize = 0;
70	for (0..n_bytes) \|j\| {
71	const place = std.math.pow(usize, encoding_base, n_bytes - j - 1);
72	n += place * (encoded[i] & 0b01111111);
73	i += 1;
74	}
75	try writer.print(".{d}", .{n});
76	}
77	}
78
79	test toDot {
80	var buf: [256]u8 = undefined;
81
82	for (test_cases) \|t\| {
83	var stream = std.io.fixedBufferStream(&buf);
84	try toDot(Oid{ .encoded = t.encoded }, stream.writer());
85	try std.testing.expectEqualStrings(t.dot_notation, stream.getWritten());
86	}
87	}
88
89	const TestCase = struct {
90	encoded: []const u8,
91	dot_notation: []const u8,
92
93	pub fn init(comptime hex: []const u8, dot_notation: []const u8) TestCase {
94	return .{ .encoded = &hexToBytes(hex), .dot_notation = dot_notation };
95	}
96	};
97
98	const test_cases = [_]TestCase{
99	// https://learn.microsoft.com/en-us/windows/win32/seccertenroll/about-object-identifier
100	TestCase.init("2b0601040182371514", "1.3.6.1.4.1.311.21.20"),
101	// https://luca.ntop.org/Teaching/Appunti/asn1.html
102	TestCase.init("2a864886f70d", "1.2.840.113549"),
103	// https://www.sysadmins.lv/blog-en/how-to-encode-object-identifier-to-an-asn1-der-encoded-string.aspx
104	TestCase.init("2a868d20", "1.2.100000"),
105	TestCase.init("2a864886f70d01010b", "1.2.840.113549.1.1.11"),
106	TestCase.init("2b6570", "1.3.101.112"),
107	};
108
109	pub const asn1_tag = asn1.Tag.init(.oid, false, .universal);
110
111	pub fn decodeDer(decoder: *der.Decoder) !Oid {
112	const ele = try decoder.element(asn1_tag.toExpected());
113	return Oid{ .encoded = decoder.view(ele) };
114	}
115
116	pub fn encodeDer(self: Oid, encoder: *der.Encoder) !void {
117	try encoder.tagBytes(asn1_tag, self.encoded);
118	}
119
120	fn encodedLen(dot_notation: []const u8) usize {
121	var buf: [256]u8 = undefined;
122	const oid = fromDot(dot_notation, &buf) catch unreachable;
123	return oid.encoded.len;
124	}
125
126	/// Returns encoded bytes of OID.
127	fn encodeComptime(comptime dot_notation: []const u8) [encodedLen(dot_notation)]u8 {
128	@setEvalBranchQuota(4000);
129	comptime var buf: [256]u8 = undefined;
130	const oid = comptime fromDot(dot_notation, &buf) catch unreachable;
131	return oid.encoded[0..oid.encoded.len].*;
132	}
133
134	test encodeComptime {
135	try std.testing.expectEqual(
136	hexToBytes("2b0601040182371514"),
137	comptime encodeComptime("1.3.6.1.4.1.311.21.20"),
138	);
139	}
140
141	pub fn fromDotComptime(comptime dot_notation: []const u8) Oid {
142	const tmp = comptime encodeComptime(dot_notation);
143	return Oid{ .encoded = &tmp };
144	}
145
146	/// Maps of:
147	/// - Oid -> enum
148	/// - Enum -> oid
149	pub fn StaticMap(comptime Enum: type) type {
150	const enum_info = @typeInfo(Enum).@"enum";
151	const EnumToOid = std.EnumArray(Enum, []const u8);
152	const ReturnType = struct {
153	oid_to_enum: std.StaticStringMap(Enum),
154	enum_to_oid: EnumToOid,
155
156	pub fn oidToEnum(self: @This(), encoded: []const u8) ?Enum {
157	return self.oid_to_enum.get(encoded);
158	}
159
160	pub fn enumToOid(self: @This(), value: Enum) Oid {
161	const bytes = self.enum_to_oid.get(value);
162	return .{ .encoded = bytes };
163	}
164	};
165
166	return struct {
167	pub fn initComptime(comptime key_pairs: anytype) ReturnType {
168	const struct_info = @typeInfo(@TypeOf(key_pairs)).@"struct";
169	const error_msg = "Each field of '" ++ @typeName(Enum) ++ "' must map to exactly one OID";
170	if (!enum_info.is_exhaustive or enum_info.fields.len != struct_info.fields.len) {
171	@compileError(error_msg);
172	}
173
174	comptime var enum_to_oid = EnumToOid.initUndefined();
175
176	const KeyPair = struct { []const u8, Enum };
177	comptime var static_key_pairs: [enum_info.fields.len]KeyPair = undefined;
178
179	comptime for (enum_info.fields, 0..) \|f, i\| {
180	if (!@hasField(@TypeOf(key_pairs), f.name)) {
181	@compileError("Field '" ++ f.name ++ "' missing Oid.StaticMap entry");
182	}
183	const encoded = &encodeComptime(@field(key_pairs, f.name));
184	const tag: Enum = @enumFromInt(f.value);
185	static_key_pairs[i] = .{ encoded, tag };
186	enum_to_oid.set(tag, encoded);
187	};
188
189	const oid_to_enum = std.StaticStringMap(Enum).initComptime(static_key_pairs);
190	if (oid_to_enum.values().len != enum_info.fields.len) @compileError(error_msg);
191
192	return ReturnType{ .oid_to_enum = oid_to_enum, .enum_to_oid = enum_to_oid };
193	}
194	};
195	}
196
197	/// Strictly for testing.
198	fn hexToBytes(comptime hex: []const u8) [hex.len / 2]u8 {
199	var res: [hex.len / 2]u8 = undefined;
200	_ = std.fmt.hexToBytes(&res, hex) catch unreachable;
201	return res;
202	}
203
204	const std = @import("std");
205	const Oid = @This();
206	const Arc = u32;
207	const encoding_base = 128;
208	const Allocator = std.mem.Allocator;
209	const der = @import("der.zig");
210	const asn1 = @import("../asn1.zig");

lib/std/crypto/codecs/asn1/der.zig created+55

...	@@ -0,0 +1,55 @@
1	//! Distinguised Encoding Rules as defined in X.690 and X.691.
2	//!
3	//! Subset of Basic Encoding Rules (BER) which eliminates flexibility in
4	//! an effort to acheive normality. Used in PKI.
5	const std = @import("std");
6	const asn1 = @import("../asn1.zig");
7
8	pub const Decoder = @import("der/Decoder.zig");
9	pub const Encoder = @import("der/Encoder.zig");
10
11	pub fn decode(comptime T: type, encoded: []const u8) !T {
12	var decoder = Decoder{ .bytes = encoded };
13	const res = try decoder.any(T);
14	std.debug.assert(decoder.index == encoded.len);
15	return res;
16	}
17
18	/// Caller owns returned memory.
19	pub fn encode(allocator: std.mem.Allocator, value: anytype) ![]u8 {
20	var encoder = Encoder.init(allocator);
21	defer encoder.deinit();
22	try encoder.any(value);
23	return try encoder.buffer.toOwnedSlice();
24	}
25
26	test encode {
27	// https://lapo.it/asn1js/#MAgGAyoDBAIBBA
28	const Value = struct { a: asn1.Oid, b: i32 };
29	const test_case = .{
30	.value = Value{ .a = asn1.Oid.fromDotComptime("1.2.3.4"), .b = 4 },
31	.encoded = &[_]u8{ 0x30, 0x08, 0x06, 0x03, 0x2A, 0x03, 0x04, 0x02, 0x01, 0x04 },
32	};
33	const allocator = std.testing.allocator;
34	const actual = try encode(allocator, test_case.value);
35	defer allocator.free(actual);
36
37	try std.testing.expectEqualSlices(u8, test_case.encoded, actual);
38	}
39
40	test decode {
41	// https://lapo.it/asn1js/#MAgGAyoDBAIBBA
42	const Value = struct { a: asn1.Oid, b: i32 };
43	const test_case = .{
44	.value = Value{ .a = asn1.Oid.fromDotComptime("1.2.3.4"), .b = 4 },
45	.encoded = &[_]u8{ 0x30, 0x08, 0x06, 0x03, 0x2A, 0x03, 0x04, 0x02, 0x01, 0x04 },
46	};
47	const decoded = try decode(Value, test_case.encoded);
48
49	try std.testing.expectEqualDeep(test_case.value, decoded);
50	}
51
52	test {
53	_ = Decoder;
54	_ = Encoder;
55	}

lib/std/crypto/codecs/asn1/der/ArrayListReverse.zig created+97

...	@@ -0,0 +1,97 @@
1	//! An ArrayList that grows backwards. Counts nested prefix length fields
2	//! in O(n) instead of O(n^depth) at the cost of extra buffering.
3	//!
4	//! Laid out in memory like:
5	//! capacity \|--------------------------\|
6	//! data \|-------------\|
7	data: []u8,
8	capacity: usize,
9	allocator: Allocator,
10
11	const ArrayListReverse = @This();
12	const Error = Allocator.Error;
13
14	pub fn init(allocator: Allocator) ArrayListReverse {
15	return .{ .data = &.{}, .capacity = 0, .allocator = allocator };
16	}
17
18	pub fn deinit(self: *ArrayListReverse) void {
19	self.allocator.free(self.allocatedSlice());
20	}
21
22	pub fn ensureCapacity(self: *ArrayListReverse, new_capacity: usize) Error!void {
23	if (self.capacity >= new_capacity) return;
24
25	const old_memory = self.allocatedSlice();
26	// Just make a new allocation to not worry about aliasing.
27	const new_memory = try self.allocator.alloc(u8, new_capacity);
28	@memcpy(new_memory[new_capacity - self.data.len ..], self.data);
29	self.allocator.free(old_memory);
30	self.data.ptr = new_memory.ptr + new_capacity - self.data.len;
31	self.capacity = new_memory.len;
32	}
33
34	pub fn prependSlice(self: *ArrayListReverse, data: []const u8) Error!void {
35	try self.ensureCapacity(self.data.len + data.len);
36	const old_len = self.data.len;
37	const new_len = old_len + data.len;
38	assert(new_len <= self.capacity);
39	self.data.len = new_len;
40
41	const end = self.data.ptr;
42	const begin = end - data.len;
43	const slice = begin[0..data.len];
44	@memcpy(slice, data);
45	self.data.ptr = begin;
46	}
47
48	pub const Writer = std.io.Writer(*ArrayListReverse, Error, prependSliceSize);
49	/// Warning: This writer writes backwards. `fn print` will NOT work as expected.
50	pub fn writer(self: *ArrayListReverse) Writer {
51	return .{ .context = self };
52	}
53
54	fn prependSliceSize(self: *ArrayListReverse, data: []const u8) Error!usize {
55	try self.prependSlice(data);
56	return data.len;
57	}
58
59	fn allocatedSlice(self: *ArrayListReverse) []u8 {
60	return (self.data.ptr + self.data.len - self.capacity)[0..self.capacity];
61	}
62
63	/// Invalidates all element pointers.
64	pub fn clearAndFree(self: *ArrayListReverse) void {
65	self.allocator.free(self.allocatedSlice());
66	self.data.len = 0;
67	self.capacity = 0;
68	}
69
70	/// The caller owns the returned memory.
71	/// Capacity is cleared, making deinit() safe but unnecessary to call.
72	pub fn toOwnedSlice(self: *ArrayListReverse) Error![]u8 {
73	const new_memory = try self.allocator.alloc(u8, self.data.len);
74	@memcpy(new_memory, self.data);
75	@memset(self.data, undefined);
76	self.clearAndFree();
77	return new_memory;
78	}
79
80	const std = @import("std");
81	const Allocator = std.mem.Allocator;
82	const assert = std.debug.assert;
83	const testing = std.testing;
84
85	test ArrayListReverse {
86	var b = ArrayListReverse.init(testing.allocator);
87	defer b.deinit();
88	const data: []const u8 = &.{ 4, 5, 6 };
89	try b.prependSlice(data);
90	try testing.expectEqual(data.len, b.data.len);
91	try testing.expectEqualSlices(u8, data, b.data);
92
93	const data2: []const u8 = &.{ 1, 2, 3 };
94	try b.prependSlice(data2);
95	try testing.expectEqual(data.len + data2.len, b.data.len);
96	try testing.expectEqualSlices(u8, data2 ++ data, b.data);
97	}

lib/std/crypto/codecs/asn1/der/Decoder.zig created+170

...	@@ -0,0 +1,170 @@
1	//! A secure DER parser that:
2	//! - Prefers calling `fn decodeDer(self: @This(), decoder: *der.Decoder)`
3	//! - Does NOT allocate. If you wish to parse lists you can do so lazily
4	//! with an opaque type.
5	//! - Does NOT read memory outside `bytes`.
6	//! - Does NOT return elements with slices outside `bytes`.
7	//! - Errors on values that do NOT follow DER rules:
8	//! - Lengths that could be represented in a shorter form.
9	//! - Booleans that are not 0xff or 0x00.
10	bytes: []const u8,
11	index: Index = 0,
12	/// The field tag of the most recently visited field.
13	/// This is needed because we might visit an implicitly tagged container with a `fn decodeDer`.
14	field_tag: ?FieldTag = null,
15
16	/// Expect a value.
17	pub fn any(self: *Decoder, comptime T: type) !T {
18	if (std.meta.hasFn(T, "decodeDer")) return try T.decodeDer(self);
19
20	const tag = Tag.fromZig(T).toExpected();
21	switch (@typeInfo(T)) {
22	.@"struct" => {
23	const ele = try self.element(tag);
24	defer self.index = ele.slice.end; // don't force parsing all fields
25
26	var res: T = undefined;
27
28	inline for (std.meta.fields(T)) \|f\| {
29	self.field_tag = FieldTag.fromContainer(T, f.name);
30
31	if (self.field_tag) \|ft\| {
32	if (ft.explicit) {
33	const seq = try self.element(ft.toTag().toExpected());
34	self.index = seq.slice.start;
35	self.field_tag = null;
36	}
37	}
38
39	@field(res, f.name) = self.any(f.type) catch \|err\| brk: {
40	if (f.defaultValue()) \|d\| {
41	break :brk d;
42	}
43	return err;
44	};
45	// DER encodes null values by skipping them.
46	if (@typeInfo(f.type) == .optional and @field(res, f.name) == null) {
47	if (f.defaultValue()) \|d\| @field(res, f.name) = d;
48	}
49	}
50
51	return res;
52	},
53	.bool => {
54	const ele = try self.element(tag);
55	const bytes = self.view(ele);
56	if (bytes.len != 1) return error.InvalidBool;
57
58	return switch (bytes[0]) {
59	0x00 => false,
60	0xff => true,
61	else => error.InvalidBool,
62	};
63	},
64	.int => {
65	const ele = try self.element(tag);
66	const bytes = self.view(ele);
67	return try int(T, bytes);
68	},
69	.@"enum" => \|e\| {
70	const ele = try self.element(tag);
71	const bytes = self.view(ele);
72	if (@hasDecl(T, "oids")) {
73	return T.oids.oidToEnum(bytes) orelse return error.UnknownOid;
74	}
75	return @enumFromInt(try int(e.tag_type, bytes));
76	},
77	.optional => \|o\| return self.any(o.child) catch return null,
78	else => @compileError("cannot decode type " ++ @typeName(T)),
79	}
80	}
81
82	//// Expect a sequence.
83	pub fn sequence(self: *Decoder) !Element {
84	return try self.element(ExpectedTag.init(.sequence, true, .universal));
85	}
86
87	//// Expect an element.
88	pub fn element(
89	self: *Decoder,
90	expected: ExpectedTag,
91	) (error{ EndOfStream, UnexpectedElement } \|\| Element.DecodeError)!Element {
92	if (self.index >= self.bytes.len) return error.EndOfStream;
93
94	const res = try Element.decode(self.bytes, self.index);
95	var e = expected;
96	if (self.field_tag) \|ft\| {
97	e.number = @enumFromInt(ft.number);
98	e.class = ft.class;
99	}
100	if (!e.match(res.tag)) {
101	return error.UnexpectedElement;
102	}
103
104	self.index = if (res.tag.constructed) res.slice.start else res.slice.end;
105	return res;
106	}
107
108	/// View of element bytes.
109	pub fn view(self: Decoder, elem: Element) []const u8 {
110	return elem.slice.view(self.bytes);
111	}
112
113	fn int(comptime T: type, value: []const u8) error{ NonCanonical, LargeValue }!T {
114	if (@typeInfo(T).int.bits % 8 != 0) @compileError("T must be byte aligned");
115
116	var bytes = value;
117	if (bytes.len >= 2) {
118	if (bytes[0] == 0) {
119	if (@clz(bytes[1]) > 0) return error.NonCanonical;
120	bytes.ptr += 1;
121	}
122	if (bytes[0] == 0xff and @clz(bytes[1]) == 0) return error.NonCanonical;
123	}
124
125	if (bytes.len > @sizeOf(T)) return error.LargeValue;
126	if (@sizeOf(T) == 1) return @bitCast(bytes[0]);
127
128	return std.mem.readVarInt(T, bytes, .big);
129	}
130
131	test int {
132	try expectEqual(@as(u8, 1), try int(u8, &[_]u8{1}));
133	try expectError(error.NonCanonical, int(u8, &[_]u8{ 0, 1 }));
134	try expectError(error.NonCanonical, int(u8, &[_]u8{ 0xff, 0xff }));
135
136	const big = [_]u8{ 0xef, 0xff };
137	try expectError(error.LargeValue, int(u8, &big));
138	try expectEqual(0xefff, int(u16, &big));
139	}
140
141	test Decoder {
142	var parser = Decoder{ .bytes = @embedFile("./testdata/id_ecc.pub.der") };
143	const seq = try parser.sequence();
144
145	{
146	const seq2 = try parser.sequence();
147	_ = try parser.element(ExpectedTag.init(.oid, false, .universal));
148	_ = try parser.element(ExpectedTag.init(.oid, false, .universal));
149
150	try std.testing.expectEqual(parser.index, seq2.slice.end);
151	}
152	_ = try parser.element(ExpectedTag.init(.bitstring, false, .universal));
153
154	try std.testing.expectEqual(parser.index, seq.slice.end);
155	try std.testing.expectEqual(parser.index, parser.bytes.len);
156	}
157
158	const std = @import("std");
159	const builtin = @import("builtin");
160	const asn1 = @import("../../asn1.zig");
161	const Oid = @import("../Oid.zig");
162
163	const expectEqual = std.testing.expectEqual;
164	const expectError = std.testing.expectError;
165	const Decoder = @This();
166	const Index = asn1.Index;
167	const Tag = asn1.Tag;
168	const FieldTag = asn1.FieldTag;
169	const ExpectedTag = asn1.ExpectedTag;
170	const Element = asn1.Element;

lib/std/crypto/codecs/asn1/der/Encoder.zig created+166

...	@@ -0,0 +1,166 @@
1	//! A buffered DER encoder.
2	//!
3	//! Prefers calling container's `fn encodeDer(self: @This(), encoder: *der.Encoder)`.
4	//! That function should encode values, lengths, then tags.
5	buffer: ArrayListReverse,
6	/// The field tag set by a parent container.
7	/// This is needed because we might visit an implicitly tagged container with a `fn encodeDer`.
8	field_tag: ?FieldTag = null,
9
10	pub fn init(allocator: std.mem.Allocator) Encoder {
11	return Encoder{ .buffer = ArrayListReverse.init(allocator) };
12	}
13
14	pub fn deinit(self: *Encoder) void {
15	self.buffer.deinit();
16	}
17
18	/// Encode any value.
19	pub fn any(self: *Encoder, val: anytype) !void {
20	const T = @TypeOf(val);
21	try self.anyTag(Tag.fromZig(T), val);
22	}
23
24	fn anyTag(self: *Encoder, tag_: Tag, val: anytype) !void {
25	const T = @TypeOf(val);
26	if (std.meta.hasFn(T, "encodeDer")) return try val.encodeDer(self);
27	const start = self.buffer.data.len;
28	const merged_tag = self.mergedTag(tag_);
29
30	switch (@typeInfo(T)) {
31	.@"struct" => \|info\| {
32	inline for (0..info.fields.len) \|i\| {
33	const f = info.fields[info.fields.len - i - 1];
34	const field_val = @field(val, f.name);
35	const field_tag = FieldTag.fromContainer(T, f.name);
36
37	// > The encoding of a set value or sequence value shall not include an encoding for any
38	// > component value which is equal to its default value.
39	const is_default = if (f.is_comptime) false else if (f.default_value_ptr) \|v\| brk: {
40	const default_val: *const f.type = @alignCast(@ptrCast(v));
41	break :brk std.mem.eql(u8, std.mem.asBytes(default_val), std.mem.asBytes(&field_val));
42	} else false;
43
44	if (!is_default) {
45	const start2 = self.buffer.data.len;
46	self.field_tag = field_tag;
47	// will merge with self.field_tag.
48	// may mutate self.field_tag.
49	try self.anyTag(Tag.fromZig(f.type), field_val);
50	if (field_tag) \|ft\| {
51	if (ft.explicit) {
52	try self.length(self.buffer.data.len - start2);
53	try self.tag(ft.toTag());
54	self.field_tag = null;
55	}
56	}
57	}
58	}
59	},
60	.bool => try self.buffer.prependSlice(&[_]u8{if (val) 0xff else 0}),
61	.int => try self.int(T, val),
62	.@"enum" => \|e\| {
63	if (@hasDecl(T, "oids")) {
64	return self.any(T.oids.enumToOid(val));
65	} else {
66	try self.int(e.tag_type, @intFromEnum(val));
67	}
68	},
69	.optional => if (val) \|v\| return try self.anyTag(tag_, v),
70	.null => {},
71	else => @compileError("cannot encode type " ++ @typeName(T)),
72	}
73
74	try self.length(self.buffer.data.len - start);
75	try self.tag(merged_tag);
76	}
77
78	/// Encode a tag.
79	pub fn tag(self: *Encoder, tag_: Tag) !void {
80	const t = self.mergedTag(tag_);
81	try t.encode(self.writer());
82	}
83
84	fn mergedTag(self: *Encoder, tag_: Tag) Tag {
85	var res = tag_;
86	if (self.field_tag) \|ft\| {
87	if (!ft.explicit) {
88	res.number = @enumFromInt(ft.number);
89	res.class = ft.class;
90	}
91	}
92	return res;
93	}
94
95	/// Encode a length.
96	pub fn length(self: *Encoder, len: usize) !void {
97	const writer_ = self.writer();
98	if (len < 128) {
99	try writer_.writeInt(u8, @intCast(len), .big);
100	return;
101	}
102	inline for ([_]type{ u8, u16, u32 }) \|T\| {
103	if (len < std.math.maxInt(T)) {
104	try writer_.writeInt(T, @intCast(len), .big);
105	try writer_.writeInt(u8, @sizeOf(T) \| 0x80, .big);
106	return;
107	}
108	}
109	return error.InvalidLength;
110	}
111
112	/// Encode a tag and length-prefixed bytes.
113	pub fn tagBytes(self: *Encoder, tag_: Tag, bytes: []const u8) !void {
114	try self.buffer.prependSlice(bytes);
115	try self.length(bytes.len);
116	try self.tag(tag_);
117	}
118
119	/// Warning: This writer writes backwards. `fn print` will NOT work as expected.
120	pub fn writer(self: *Encoder) ArrayListReverse.Writer {
121	return self.buffer.writer();
122	}
123
124	fn int(self: *Encoder, comptime T: type, value: T) !void {
125	const big = std.mem.nativeTo(T, value, .big);
126	const big_bytes = std.mem.asBytes(&big);
127
128	const bits_needed = @bitSizeOf(T) - @clz(value);
129	const needs_padding: u1 = if (value == 0)
130	1
131	else if (bits_needed > 8) brk: {
132	const RightShift = std.meta.Int(.unsigned, @bitSizeOf(@TypeOf(bits_needed)) - 1);
133	const right_shift: RightShift = @intCast(bits_needed - 9);
134	break :brk if (value >> right_shift == 0x1ff) 1 else 0;
135	} else 0;
136	const bytes_needed = try std.math.divCeil(usize, bits_needed, 8) + needs_padding;
137
138	const writer_ = self.writer();
139	for (0..bytes_needed - needs_padding) \|i\| try writer_.writeByte(big_bytes[big_bytes.len - i - 1]);
140	if (needs_padding == 1) try writer_.writeByte(0);
141	}
142
143	test int {
144	const allocator = std.testing.allocator;
145	var encoder = Encoder.init(allocator);
146	defer encoder.deinit();
147
148	try encoder.int(u8, 0);
149	try std.testing.expectEqualSlices(u8, &[_]u8{0}, encoder.buffer.data);
150
151	encoder.buffer.clearAndFree();
152	try encoder.int(u16, 0x00ff);
153	try std.testing.expectEqualSlices(u8, &[_]u8{0xff}, encoder.buffer.data);
154
155	encoder.buffer.clearAndFree();
156	try encoder.int(u32, 0xffff);
157	try std.testing.expectEqualSlices(u8, &[_]u8{ 0, 0xff, 0xff }, encoder.buffer.data);
158	}
159
160	const std = @import("std");
161	const Oid = @import("../Oid.zig");
162	const asn1 = @import("../../asn1.zig");
163	const ArrayListReverse = @import("./ArrayListReverse.zig");
164	const Tag = asn1.Tag;
165	const FieldTag = asn1.FieldTag;
166	const Encoder = @This();

lib/std/crypto/codecs/asn1/der/testdata/all_types.der created

Binary files /dev/null and b/lib/std/crypto/codecs/asn1/der/testdata/all_types.der differ

lib/std/crypto/codecs/asn1/der/testdata/id_ecc.pub.der created

Binary files /dev/null and b/lib/std/crypto/codecs/asn1/der/testdata/id_ecc.pub.der differ

lib/std/crypto/codecs/asn1/test.zig created+80

...	@@ -0,0 +1,80 @@
1	const std = @import("std");
2	const asn1 = @import("../asn1.zig");
3
4	const der = asn1.der;
5	const Tag = asn1.Tag;
6	const FieldTag = asn1.FieldTag;
7
8	/// An example that uses all ASN1 types and available implementation features.
9	const AllTypes = struct {
10	a: u8 = 0,
11	b: asn1.BitString,
12	c: C,
13	d: asn1.Opaque(Tag.universal(.string_utf8, false)),
14	e: asn1.Opaque(Tag.universal(.octetstring, false)),
15	f: ?u16,
16	g: ?Nested,
17	h: asn1.Any,
18
19	pub const asn1_tags = .{
20	.a = FieldTag.initExplicit(0, .context_specific),
21	.b = FieldTag.initExplicit(1, .context_specific),
22	.c = FieldTag.initImplicit(2, .context_specific),
23	.g = FieldTag.initImplicit(3, .context_specific),
24	};
25
26	const C = enum {
27	a,
28	b,
29
30	pub const oids = asn1.Oid.StaticMap(@This()).initComptime(.{
31	.a = "1.2.3.4",
32	.b = "1.2.3.5",
33	});
34	};
35
36	const Nested = struct {
37	inner: Asn1T,
38	sum: i16,
39
40	const Asn1T = struct { a: u8, b: i16 };
41
42	pub fn decodeDer(decoder: *der.Decoder) !Nested {
43	const inner = try decoder.any(Asn1T);
44	return Nested{ .inner = inner, .sum = inner.a + inner.b };
45	}
46
47	pub fn encodeDer(self: Nested, encoder: *der.Encoder) !void {
48	try encoder.any(self.inner);
49	}
50	};
51	};
52
53	test AllTypes {
54	const expected = AllTypes{
55	.a = 2,
56	.b = asn1.BitString{ .bytes = &[_]u8{ 0x04, 0xa0 } },
57	.c = .a,
58	.d = .{ .bytes = "asdf" },
59	.e = .{ .bytes = "fdsa" },
60	.f = (1 << 8) + 1,
61	.g = .{ .inner = .{ .a = 4, .b = 5 }, .sum = 9 },
62	.h = .{ .tag = Tag.init(.string_ia5, false, .universal), .bytes = "asdf" },
63	};
64	// https://lapo.it/asn1js/#MC-gAwIBAqEFAwMABKCCAyoDBAwEYXNkZgQEZmRzYQICAQGjBgIBBAIBBRYEYXNkZg
65	const path = "./der/testdata/all_types.der";
66	const encoded = @embedFile(path);
67	const actual = try asn1.der.decode(AllTypes, encoded);
68	try std.testing.expectEqualDeep(expected, actual);
69
70	const allocator = std.testing.allocator;
71	const buf = try asn1.der.encode(allocator, expected);
72	defer allocator.free(buf);
73	try std.testing.expectEqualSlices(u8, encoded, buf);
74
75	// Use this to update test file.
76	// const dir = try std.fs.cwd().openDir("lib/std/crypto/asn1", .{});
77	// var file = try dir.createFile(path, .{});
78	// defer file.close();
79	// try file.writeAll(buf);
80	}

lib/std/crypto/codecs/base64_hex_ct.zig created+463

...	@@ -0,0 +1,463 @@
1	//! Hexadecimal and Base64 codecs designed for cryptographic use.
2	//! This file provides (best-effort) constant-time encoding and decoding functions for hexadecimal and Base64 formats.
3	//! This is designed to be used in cryptographic applications where timing attacks are a concern.
4	const std = @import("std");
5	const testing = std.testing;
6	const StaticBitSet = std.StaticBitSet;
7
8	pub const Error = error{
9	/// An invalid character was found in the input.
10	InvalidCharacter,
11	/// The input is not properly padded.
12	InvalidPadding,
13	/// The input buffer is too small to hold the output.
14	NoSpaceLeft,
15	/// The input and output buffers are not the same size.
16	SizeMismatch,
17	};
18
19	/// (best-effort) constant time hexadecimal encoding and decoding.
20	pub const hex = struct {
21	/// Encodes a binary buffer into a hexadecimal string.
22	/// The output buffer must be twice the size of the input buffer.
23	pub fn encode(encoded: []u8, bin: []const u8, comptime case: std.fmt.Case) error{SizeMismatch}!void {
24	if (encoded.len / 2 != bin.len) {
25	return error.SizeMismatch;
26	}
27	for (bin, 0..) \|v, i\| {
28	const b: u16 = v >> 4;
29	const c: u16 = v & 0xf;
30	const off = if (case == .upper) 32 else 0;
31	const x =
32	((87 - off + c + (((c -% 10) >> 8) & ~@as(u16, 38 - off))) & 0xff) << 8 \|
33	((87 - off + b + (((b -% 10) >> 8) & ~@as(u16, 38 - off))) & 0xff);
34	encoded[i * 2] = @truncate(x);
35	encoded[i * 2 + 1] = @truncate(x >> 8);
36	}
37	}
38
39	/// Decodes a hexadecimal string into a binary buffer.
40	/// The output buffer must be half the size of the input buffer.
41	pub fn decode(bin: []u8, encoded: []const u8) error{ SizeMismatch, InvalidCharacter, InvalidPadding }!void {
42	if (encoded.len % 2 != 0) {
43	return error.InvalidPadding;
44	}
45	if (bin.len < encoded.len / 2) {
46	return error.SizeMismatch;
47	}
48	_ = decodeAny(bin, encoded, null) catch \|err\| {
49	switch (err) {
50	error.InvalidCharacter => return error.InvalidCharacter,
51	error.InvalidPadding => return error.InvalidPadding,
52	else => unreachable,
53	}
54	};
55	}
56
57	/// A decoder that ignores certain characters.
58	/// The decoder will skip any characters that are in the ignore list.
59	pub const DecoderWithIgnore = struct {
60	/// The characters to ignore.
61	ignored_chars: StaticBitSet(256) = undefined,
62
63	/// Decodes a hexadecimal string into a binary buffer.
64	/// The output buffer must be half the size of the input buffer.
65	pub fn decode(
66	self: DecoderWithIgnore,
67	bin: []u8,
68	encoded: []const u8,
69	) error{ NoSpaceLeft, InvalidCharacter, InvalidPadding }![]const u8 {
70	return decodeAny(bin, encoded, self.ignored_chars);
71	}
72
73	/// Returns the decoded length of a hexadecimal string, ignoring any characters in the ignore list.
74	/// This operation does not run in constant time, but it aims to avoid leaking information about the underlying hexadecimal string.
75	pub fn decodedLenForSlice(decoder: DecoderWithIgnore, encoded: []const u8) !usize {
76	var hex_len = encoded.len;
77	for (encoded) \|c\| {
78	if (decoder.ignored_chars.isSet(c)) hex_len -= 1;
79	}
80	if (hex_len % 2 != 0) {
81	return error.InvalidPadding;
82	}
83	return hex_len / 2;
84	}
85
86	/// Returns the maximum possible decoded size for a given input length after skipping ignored characters.
87	pub fn decodedLenUpperBound(hex_len: usize) usize {
88	return hex_len / 2;
89	}
90	};
91
92	/// Creates a new decoder that ignores certain characters.
93	/// The decoder will skip any characters that are in the ignore list.
94	/// The ignore list must not contain any valid hexadecimal characters.
95	pub fn decoderWithIgnore(ignore_chars: []const u8) error{InvalidCharacter}!DecoderWithIgnore {
96	var ignored_chars = StaticBitSet(256).initEmpty();
97	for (ignore_chars) \|c\| {
98	switch (c) {
99	'0'...'9', 'a'...'f', 'A'...'F' => return error.InvalidCharacter,
100	else => if (ignored_chars.isSet(c)) return error.InvalidCharacter,
101	}
102	ignored_chars.set(c);
103	}
104	return DecoderWithIgnore{ .ignored_chars = ignored_chars };
105	}
106
107	fn decodeAny(
108	bin: []u8,
109	encoded: []const u8,
110	ignored_chars: ?StaticBitSet(256),
111	) error{ NoSpaceLeft, InvalidCharacter, InvalidPadding }![]const u8 {
112	var bin_pos: usize = 0;
113	var state: bool = false;
114	var c_acc: u8 = 0;
115	for (encoded) \|c\| {
116	const c_num = c ^ 48;
117	const c_num0: u8 = @truncate((@as(u16, c_num) -% 10) >> 8);
118	const c_alpha: u8 = (c & ~@as(u8, 32)) -% 55;
119	const c_alpha0: u8 = @truncate(((@as(u16, c_alpha) -% 10) ^ (@as(u16, c_alpha) -% 16)) >> 8);
120	if ((c_num0 \| c_alpha0) == 0) {
121	if (ignored_chars) \|set\| {
122	if (set.isSet(c)) {
123	continue;
124	}
125	}
126	return error.InvalidCharacter;
127	}
128	const c_val = (c_num0 & c_num) \| (c_alpha0 & c_alpha);
129	if (bin_pos >= bin.len) {
130	return error.NoSpaceLeft;
131	}
132	if (!state) {
133	c_acc = c_val << 4;
134	} else {
135	bin[bin_pos] = c_acc \| c_val;
136	bin_pos += 1;
137	}
138	state = !state;
139	}
140	if (state) {
141	return error.InvalidPadding;
142	}
143	return bin[0..bin_pos];
144	}
145	};
146
147	/// (best-effort) constant time base64 encoding and decoding.
148	pub const base64 = struct {
149	/// The base64 variant to use.
150	pub const Variant = packed struct {
151	/// Use the URL-safe alphabet instead of the standard alphabet.
152	urlsafe_alphabet: bool = false,
153	/// Enable padding with '=' characters.
154	padding: bool = true,
155
156	/// The standard base64 variant.
157	pub const standard: Variant = .{ .urlsafe_alphabet = false, .padding = true };
158	/// The URL-safe base64 variant.
159	pub const urlsafe: Variant = .{ .urlsafe_alphabet = true, .padding = true };
160	/// The standard base64 variant without padding.
161	pub const standard_nopad: Variant = .{ .urlsafe_alphabet = false, .padding = false };
162	/// The URL-safe base64 variant without padding.
163	pub const urlsafe_nopad: Variant = .{ .urlsafe_alphabet = true, .padding = false };
164	};
165
166	/// Returns the length of the encoded base64 string for a given length.
167	pub fn encodedLen(bin_len: usize, variant: Variant) usize {
168	if (variant.padding) {
169	return (bin_len + 2) / 3 * 4;
170	} else {
171	const leftover = bin_len % 3;
172	return bin_len / 3 * 4 + (leftover * 4 + 2) / 3;
173	}
174	}
175
176	/// Returns the maximum possible decoded size for a given input length - The actual length may be less if the input includes padding.
177	/// `InvalidPadding` is returned if the input length is not valid.
178	pub fn decodedLen(b64_len: usize, variant: Variant) !usize {
179	var result = b64_len / 4 * 3;
180	const leftover = b64_len % 4;
181	if (variant.padding) {
182	if (leftover % 4 != 0) return error.InvalidPadding;
183	} else {
184	if (leftover % 4 == 1) return error.InvalidPadding;
185	result += leftover * 3 / 4;
186	}
187	return result;
188	}
189
190	/// Encodes a binary buffer into a base64 string.
191	/// The output buffer must be at least `encodedLen(bin.len)` bytes long.
192	pub fn encode(encoded: []u8, bin: []const u8, comptime variant: Variant) error{NoSpaceLeft}![]const u8 {
193	var acc_len: u4 = 0;
194	var b64_pos: usize = 0;
195	var acc: u16 = 0;
196	const nibbles = bin.len / 3;
197	const remainder = bin.len - 3 * nibbles;
198	var b64_len = nibbles * 4;
199	if (remainder != 0) {
200	b64_len += if (variant.padding) 4 else 2 + (remainder >> 1);
201	}
202	if (encoded.len < b64_len) {
203	return error.NoSpaceLeft;
204	}
205	const urlsafe = variant.urlsafe_alphabet;
206	for (bin) \|v\| {
207	acc = (acc << 8) + v;
208	acc_len += 8;
209	while (acc_len >= 6) {
210	acc_len -= 6;
211	encoded[b64_pos] = charFromByte(@as(u6, @truncate(acc >> acc_len)), urlsafe);
212	b64_pos += 1;
213	}
214	}
215	if (acc_len > 0) {
216	encoded[b64_pos] = charFromByte(@as(u6, @truncate(acc << (6 - acc_len))), urlsafe);
217	b64_pos += 1;
218	}
219	while (b64_pos < b64_len) {
220	encoded[b64_pos] = '=';
221	b64_pos += 1;
222	}
223	return encoded[0..b64_pos];
224	}
225
226	/// Decodes a base64 string into a binary buffer.
227	/// The output buffer must be at least `decodedLenUpperBound(encoded.len)` bytes long.
228	pub fn decode(bin: []u8, encoded: []const u8, comptime variant: Variant) error{ InvalidCharacter, InvalidPadding }![]const u8 {
229	return decodeAny(bin, encoded, variant, null) catch \|err\| {
230	switch (err) {
231	error.InvalidCharacter => return error.InvalidCharacter,
232	error.InvalidPadding => return error.InvalidPadding,
233	else => unreachable,
234	}
235	};
236	}
237
238	//// A decoder that ignores certain characters.
239	pub const DecoderWithIgnore = struct {
240	/// The characters to ignore.
241	ignored_chars: StaticBitSet(256) = undefined,
242
243	/// Decodes a base64 string into a binary buffer.
244	/// The output buffer must be at least `decodedLenUpperBound(encoded.len)` bytes long.
245	pub fn decode(
246	self: DecoderWithIgnore,
247	bin: []u8,
248	encoded: []const u8,
249	comptime variant: Variant,
250	) error{ NoSpaceLeft, InvalidCharacter, InvalidPadding }![]const u8 {
251	return decodeAny(bin, encoded, variant, self.ignored_chars);
252	}
253
254	/// Returns the decoded length of a base64 string, ignoring any characters in the ignore list.
255	/// This operation does not run in constant time, but it aims to avoid leaking information about the underlying base64 string.
256	pub fn decodedLenForSlice(decoder: DecoderWithIgnore, encoded: []const u8, variant: Variant) !usize {
257	var b64_len = encoded.len;
258	for (encoded) \|c\| {
259	if (decoder.ignored_chars.isSet(c)) b64_len -= 1;
260	}
261	return base64.decodedLen(b64_len, variant);
262	}
263
264	/// Returns the maximum possible decoded size for a given input length after skipping ignored characters.
265	pub fn decodedLenUpperBound(b64_len: usize) usize {
266	return b64_len / 3 * 4;
267	}
268	};
269
270	/// Creates a new decoder that ignores certain characters.
271	pub fn decoderWithIgnore(ignore_chars: []const u8) error{InvalidCharacter}!DecoderWithIgnore {
272	var ignored_chars = StaticBitSet(256).initEmpty();
273	for (ignore_chars) \|c\| {
274	switch (c) {
275	'A'...'Z', 'a'...'z', '0'...'9' => return error.InvalidCharacter,
276	else => if (ignored_chars.isSet(c)) return error.InvalidCharacter,
277	}
278	ignored_chars.set(c);
279	}
280	return DecoderWithIgnore{ .ignored_chars = ignored_chars };
281	}
282
283	inline fn eq(x: u8, y: u8) u8 {
284	return ~@as(u8, @truncate((0 -% (@as(u16, x) ^ @as(u16, y))) >> 8));
285	}
286
287	inline fn gt(x: u8, y: u8) u8 {
288	return @truncate((@as(u16, y) -% @as(u16, x)) >> 8);
289	}
290
291	inline fn ge(x: u8, y: u8) u8 {
292	return ~gt(y, x);
293	}
294
295	inline fn lt(x: u8, y: u8) u8 {
296	return gt(y, x);
297	}
298
299	inline fn le(x: u8, y: u8) u8 {
300	return ge(y, x);
301	}
302
303	inline fn charFromByte(x: u8, comptime urlsafe: bool) u8 {
304	return (lt(x, 26) & (x +% 'A')) \|
305	(ge(x, 26) & lt(x, 52) & (x +% 'a' -% 26)) \|
306	(ge(x, 52) & lt(x, 62) & (x +% '0' -% 52)) \|
307	(eq(x, 62) & '+') \| (eq(x, 63) & if (urlsafe) '_' else '/');
308	}
309
310	inline fn byteFromChar(c: u8, comptime urlsafe: bool) u8 {
311	const x =
312	(ge(c, 'A') & le(c, 'Z') & (c -% 'A')) \|
313	(ge(c, 'a') & le(c, 'z') & (c -% 'a' +% 26)) \|
314	(ge(c, '0') & le(c, '9') & (c -% '0' +% 52)) \|
315	(eq(c, '+') & 62) \| (eq(c, if (urlsafe) '_' else '/') & 63);
316	return x \| (eq(x, 0) & ~eq(c, 'A'));
317	}
318
319	fn skipPadding(
320	encoded: []const u8,
321	padding_len: usize,
322	ignored_chars: ?StaticBitSet(256),
323	) error{InvalidPadding}![]const u8 {
324	var b64_pos: usize = 0;
325	var i = padding_len;
326	while (i > 0) {
327	if (b64_pos >= encoded.len) {
328	return error.InvalidPadding;
329	}
330	const c = encoded[b64_pos];
331	if (c == '=') {
332	i -= 1;
333	} else if (ignored_chars) \|set\| {
334	if (!set.isSet(c)) {
335	return error.InvalidPadding;
336	}
337	}
338	b64_pos += 1;
339	}
340	return encoded[b64_pos..];
341	}
342
343	fn decodeAny(
344	bin: []u8,
345	encoded: []const u8,
346	comptime variant: Variant,
347	ignored_chars: ?StaticBitSet(256),
348	) error{ NoSpaceLeft, InvalidCharacter, InvalidPadding }![]const u8 {
349	var acc: u16 = 0;
350	var acc_len: u4 = 0;
351	var bin_pos: usize = 0;
352	var premature_end: ?usize = null;
353	const urlsafe = variant.urlsafe_alphabet;
354	for (encoded, 0..) \|c, b64_pos\| {
355	const d = byteFromChar(c, urlsafe);
356	if (d == 0xff) {
357	if (ignored_chars) \|set\| {
358	if (set.isSet(c)) continue;
359	}
360	premature_end = b64_pos;
361	break;
362	}
363	acc = (acc << 6) + d;
364	acc_len += 6;
365	if (acc_len >= 8) {
366	acc_len -= 8;
367	if (bin_pos >= bin.len) {
368	return error.NoSpaceLeft;
369	}
370	bin[bin_pos] = @truncate(acc >> acc_len);
371	bin_pos += 1;
372	}
373	}
374	if (acc_len > 4 or (acc & ((@as(u16, 1) << acc_len) -% 1)) != 0) {
375	return error.InvalidCharacter;
376	}
377	const padding_len = acc_len / 2;
378	if (premature_end) \|pos\| {
379	const remaining =
380	if (variant.padding)
381	try skipPadding(encoded[pos..], padding_len, ignored_chars)
382	else
383	encoded[pos..];
384	if (ignored_chars) \|set\| {
385	for (remaining) \|c\| {
386	if (!set.isSet(c)) {
387	return error.InvalidCharacter;
388	}
389	}
390	} else if (remaining.len != 0) {
391	return error.InvalidCharacter;
392	}
393	} else if (variant.padding and padding_len != 0) {
394	return error.InvalidPadding;
395	}
396	return bin[0..bin_pos];
397	}
398	};
399
400	test "hex" {
401	var default_rng = std.Random.DefaultPrng.init(testing.random_seed);
402	var rng = default_rng.random();
403	var bin_buf: [1000]u8 = undefined;
404	rng.bytes(&bin_buf);
405	var bin2_buf: [bin_buf.len]u8 = undefined;
406	var hex_buf: [bin_buf.len * 2]u8 = undefined;
407	for (0..1000) \|_\| {
408	const bin_len = rng.intRangeAtMost(usize, 0, bin_buf.len);
409	const bin = bin_buf[0..bin_len];
410	const bin2 = bin2_buf[0..bin_len];
411	inline for (.{ .lower, .upper }) \|case\| {
412	const hex_len = bin_len * 2;
413	const encoded = hex_buf[0..hex_len];
414	try hex.encode(encoded, bin, case);
415	try hex.decode(bin2, encoded);
416	try testing.expectEqualSlices(u8, bin, bin2);
417	}
418	}
419	}
420
421	test "base64" {
422	var default_rng = std.Random.DefaultPrng.init(testing.random_seed);
423	var rng = default_rng.random();
424	var bin_buf: [1000]u8 = undefined;
425	rng.bytes(&bin_buf);
426	var bin2_buf: [bin_buf.len]u8 = undefined;
427	var b64_buf: [(bin_buf.len + 3) / 3 * 4]u8 = undefined;
428	for (0..1000) \|_\| {
429	const bin_len = rng.intRangeAtMost(usize, 0, bin_buf.len);
430	const bin = bin_buf[0..bin_len];
431	const bin2 = bin2_buf[0..bin_len];
432	inline for ([_]base64.Variant{
433	.standard,
434	.standard_nopad,
435	.urlsafe,
436	.urlsafe_nopad,
437	}) \|variant\| {
438	const b64_len = base64.encodedLen(bin_len, variant);
439	const encoded_buf = b64_buf[0..b64_len];
440	const encoded = try base64.encode(encoded_buf, bin, variant);
441	const decoded = try base64.decode(bin2, encoded, variant);
442	try testing.expectEqualSlices(u8, bin, decoded);
443	}
444	}
445	}
446
447	test "hex with ignored chars" {
448	const encoded = "01020304050607\n08090A0B0C0D0E0F\n";
449	const expected = [_]u8{ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
450	var bin_buf: [encoded.len / 2]u8 = undefined;
451	try testing.expectError(error.InvalidCharacter, hex.decode(&bin_buf, encoded));
452	const bin = try (try hex.decoderWithIgnore("\r\n")).decode(&bin_buf, encoded);
453	try testing.expectEqualSlices(u8, &expected, bin);
454	}
455
456	test "base64 with ignored chars" {
457	const encoded = "dGVzdCBi\r\nYXNlNjQ=\n";
458	const expected = "test base64";
459	var bin_buf: [base64.DecoderWithIgnore.decodedLenUpperBound(encoded.len)]u8 = undefined;
460	try testing.expectError(error.InvalidCharacter, base64.decode(&bin_buf, encoded, .standard));
461	const bin = try (try base64.decoderWithIgnore("\r\n")).decode(&bin_buf, encoded, .standard);
462	try testing.expectEqualSlices(u8, expected, bin);
463	}

author	Frank Denis <124872+jedisct1@users.noreply.github.com> 2025-04-12 20:13:45+02:00
committer	GitHub <noreply@github.com> 2025-04-12 20:13:45+02:00
log	a7122b73231808a8a07b79c84e1eaac9cf4c28aa
tree	edafeb2bbf26110b704a23167f9cb08008460b4b
parent	9352f379e8a08bcc5a3bfc851bfb6c6a662000af
signature	Signed by PGP key B5690EEEBB952194

std.crypto: add constant-time codecs (#23420)