authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2023-11-21 20:21:57-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2023-11-22 11:32:14-07:00
log49d6dd3ecb0b5d0547f8a70b764e38af2f24f475
tree54ebc6679cc0e3acdccce720783151b38b2bb592
parent7b3556a8cff1edb63a331c5068902254b0b2126c

std.crypto.ff: simplify implementation

* Take advantage of multi-object for loops. * Remove use of BoundedArray since it had no meaningful impact on safety or readability. * Simplify some complex expressions, such as using `!` to invert a boolean value.

1 files changed, 86 insertions(+), 91 deletions(-)

lib/std/crypto/ff.zig+86-91
......@@ -12,7 +12,6 @@ const math = std.math;
1212const mem = std.mem;
1313const meta = std.meta;
1414const testing = std.testing;
15const BoundedArray = std.BoundedArray;
1615const assert = std.debug.assert;
1716const Endian = std.builtin.Endian;
1817
......@@ -63,46 +62,54 @@ pub fn Uint(comptime max_bits: comptime_int) type {
6362
6463 return struct {
6564 const Self = @This();
66
6765 const max_limbs_count = math.divCeil(usize, max_bits, t_bits) catch unreachable;
68 const Limbs = BoundedArray(Limb, max_limbs_count);
69 limbs: Limbs,
66
67 limbs_buffer: [max_limbs_count]Limb,
68 /// The number of active limbs.
69 limbs_len: usize,
7070
7171 /// Number of bytes required to serialize an integer.
7272 pub const encoded_bytes = math.divCeil(usize, max_bits, 8) catch unreachable;
7373
74 // Returns the number of active limbs.
75 fn limbs_count(self: Self) usize {
76 return self.limbs.len;
74 /// Constant slice of active limbs.
75 fn limbsConst(self: *const Self) []const Limb {
76 return self.limbs_buffer[0..self.limbs_len];
77 }
78
79 /// Mutable slice of active limbs.
80 fn limbs(self: *Self) []Limb {
81 return self.limbs_buffer[0..self.limbs_len];
7782 }
7883
7984 // Removes limbs whose value is zero from the active limbs.
8085 fn normalize(self: Self) Self {
8186 var res = self;
82 if (self.limbs_count() < 2) {
87 if (self.limbs_len < 2) {
8388 return res;
8489 }
85 var i = self.limbs_count() - 1;
86 while (i > 0 and res.limbs.get(i) == 0) : (i -= 1) {}
87 res.limbs.resize(i + 1) catch unreachable;
90 var i = self.limbs_len - 1;
91 while (i > 0 and res.limbsConst()[i] == 0) : (i -= 1) {}
92 res.limbs_len = i + 1;
93 assert(res.limbs_len <= res.limbs_buffer.len);
8894 return res;
8995 }
9096
9197 /// The zero integer.
92 pub const zero = zero: {
93 var limbs = Limbs.init(0) catch unreachable;
94 limbs.appendNTimesAssumeCapacity(0, max_limbs_count);
95 break :zero Self{ .limbs = limbs };
98 pub const zero: Self = .{
99 .limbs_buffer = [1]Limb{0} ** max_limbs_count,
100 .limbs_len = max_limbs_count,
96101 };
97102
98103 /// Creates a new big integer from a primitive type.
99104 /// This function may not run in constant time.
100 pub fn fromPrimitive(comptime T: type, x_: T) OverflowError!Self {
101 var x = x_;
102 var out = Self.zero;
103 for (0..out.limbs.capacity()) |i| {
104 const t = if (@bitSizeOf(T) > t_bits) @as(TLimb, @truncate(x)) else x;
105 out.limbs.set(i, t);
105 pub fn fromPrimitive(comptime T: type, init_value: T) OverflowError!Self {
106 var x = init_value;
107 var out: Self = .{
108 .limbs_buffer = undefined,
109 .limbs_len = max_limbs_count,
110 };
111 for (&out.limbs_buffer) |*limb| {
112 limb.* = if (@bitSizeOf(T) > t_bits) @as(TLimb, @truncate(x)) else x;
106113 x = math.shr(T, x, t_bits);
107114 }
108115 if (x != 0) {
......@@ -115,13 +122,13 @@ pub fn Uint(comptime max_bits: comptime_int) type {
115122 /// This function may not run in constant time.
116123 pub fn toPrimitive(self: Self, comptime T: type) OverflowError!T {
117124 var x: T = 0;
118 var i = self.limbs_count() - 1;
125 var i = self.limbs_len - 1;
119126 while (true) : (i -= 1) {
120127 if (@bitSizeOf(T) >= t_bits and math.shr(T, x, @bitSizeOf(T) - t_bits) != 0) {
121128 return error.Overflow;
122129 }
123130 x = math.shl(T, x, t_bits);
124 const v = math.cast(T, self.limbs.get(i)) orelse return error.Overflow;
131 const v = math.cast(T, self.limbsConst()[i]) orelse return error.Overflow;
125132 x |= v;
126133 if (i == 0) break;
127134 }
......@@ -140,9 +147,9 @@ pub fn Uint(comptime max_bits: comptime_int) type {
140147 .big => bytes.len - 1,
141148 .little => 0,
142149 };
143 for (0..self.limbs.len) |i| {
150 for (0..self.limbs_len) |i| {
144151 var remaining_bits = t_bits;
145 var limb = self.limbs.get(i);
152 var limb = self.limbsConst()[i];
146153 while (remaining_bits >= 8) {
147154 bytes[out_i] |= math.shl(u8, @as(u8, @truncate(limb)), shift);
148155 const consumed = 8 - shift;
......@@ -152,7 +159,7 @@ pub fn Uint(comptime max_bits: comptime_int) type {
152159 switch (endian) {
153160 .big => {
154161 if (out_i == 0) {
155 if (i != self.limbs.len - 1 or limb != 0) {
162 if (i != self.limbs_len - 1 or limb != 0) {
156163 return error.Overflow;
157164 }
158165 return;
......@@ -162,7 +169,7 @@ pub fn Uint(comptime max_bits: comptime_int) type {
162169 .little => {
163170 out_i += 1;
164171 if (out_i == bytes.len) {
165 if (i != self.limbs.len - 1 or limb != 0) {
172 if (i != self.limbs_len - 1 or limb != 0) {
166173 return error.Overflow;
167174 }
168175 return;
......@@ -187,20 +194,20 @@ pub fn Uint(comptime max_bits: comptime_int) type {
187194 };
188195 while (true) {
189196 const bi = bytes[i];
190 out.limbs.set(out_i, out.limbs.get(out_i) | math.shl(Limb, bi, shift));
197 out.limbs()[out_i] |= math.shl(Limb, bi, shift);
191198 shift += 8;
192199 if (shift >= t_bits) {
193200 shift -= t_bits;
194 out.limbs.set(out_i, @as(TLimb, @truncate(out.limbs.get(out_i))));
201 out.limbs()[out_i] = @as(TLimb, @truncate(out.limbs()[out_i]));
195202 const overflow = math.shr(Limb, bi, 8 - shift);
196203 out_i += 1;
197 if (out_i >= out.limbs.len) {
204 if (out_i >= out.limbs_len) {
198205 if (overflow != 0 or i != 0) {
199206 return error.Overflow;
200207 }
201208 break;
202209 }
203 out.limbs.set(out_i, overflow);
210 out.limbs()[out_i] = overflow;
204211 }
205212 switch (endian) {
206213 .big => {
......@@ -218,32 +225,31 @@ pub fn Uint(comptime max_bits: comptime_int) type {
218225
219226 /// Returns `true` if both integers are equal.
220227 pub fn eql(x: Self, y: Self) bool {
221 return crypto.utils.timingSafeEql([max_limbs_count]Limb, x.limbs.buffer, y.limbs.buffer);
228 return crypto.utils.timingSafeEql([max_limbs_count]Limb, x.limbs_buffer, y.limbs_buffer);
222229 }
223230
224231 /// Compares two integers.
225232 pub fn compare(x: Self, y: Self) math.Order {
226233 return crypto.utils.timingSafeCompare(
227234 Limb,
228 x.limbs.constSlice(),
229 y.limbs.constSlice(),
235 x.limbsConst(),
236 y.limbsConst(),
230237 .little,
231238 );
232239 }
233240
234241 /// Returns `true` if the integer is zero.
235242 pub fn isZero(x: Self) bool {
236 const x_limbs = x.limbs.constSlice();
237243 var t: Limb = 0;
238 for (0..x.limbs_count()) |i| {
239 t |= x_limbs[i];
244 for (x.limbsConst()) |elem| {
245 t |= elem;
240246 }
241247 return ct.eql(t, 0);
242248 }
243249
244250 /// Returns `true` if the integer is odd.
245251 pub fn isOdd(x: Self) bool {
246 return @as(bool, @bitCast(@as(u1, @truncate(x.limbs.get(0)))));
252 return @as(u1, @truncate(x.limbsConst()[0])) != 0;
247253 }
248254
249255 /// Adds `y` to `x`, and returns `true` if the operation overflowed.
......@@ -258,39 +264,31 @@ pub fn Uint(comptime max_bits: comptime_int) type {
258264
259265 // Replaces the limbs of `x` with the limbs of `y` if `on` is `true`.
260266 fn cmov(x: *Self, on: bool, y: Self) void {
261 const x_limbs = x.limbs.slice();
262 const y_limbs = y.limbs.constSlice();
263 for (0..y.limbs_count()) |i| {
264 x_limbs[i] = ct.select(on, y_limbs[i], x_limbs[i]);
267 for (x.limbs(), y.limbsConst()) |*x_limb, y_limb| {
268 x_limb.* = ct.select(on, y_limb, x_limb.*);
265269 }
266270 }
267271
268 // Adds `y` to `x` if `on` is `true`, and returns `true` if the operation overflowed.
272 // Adds `y` to `x` if `on` is `true`, and returns `true` if the
273 // operation overflowed.
269274 fn conditionalAddWithOverflow(x: *Self, on: bool, y: Self) u1 {
270 assert(x.limbs_count() == y.limbs_count()); // Operands must have the same size.
271 const x_limbs = x.limbs.slice();
272 const y_limbs = y.limbs.constSlice();
273
274275 var carry: u1 = 0;
275 for (0..x.limbs_count()) |i| {
276 const res = x_limbs[i] + y_limbs[i] + carry;
277 x_limbs[i] = ct.select(on, @as(TLimb, @truncate(res)), x_limbs[i]);
278 carry = @as(u1, @truncate(res >> t_bits));
276 for (x.limbs(), y.limbsConst()) |*x_limb, y_limb| {
277 const res = x_limb.* + y_limb + carry;
278 x_limb.* = ct.select(on, @as(TLimb, @truncate(res)), x_limb.*);
279 carry = @truncate(res >> t_bits);
279280 }
280281 return carry;
281282 }
282283
283 // Subtracts `y` from `x` if `on` is `true`, and returns `true` if the operation overflowed.
284 // Subtracts `y` from `x` if `on` is `true`, and returns `true` if the
285 // operation overflowed.
284286 fn conditionalSubWithOverflow(x: *Self, on: bool, y: Self) u1 {
285 assert(x.limbs_count() == y.limbs_count()); // Operands must have the same size.
286 const x_limbs = x.limbs.slice();
287 const y_limbs = y.limbs.constSlice();
288
289287 var borrow: u1 = 0;
290 for (0..x.limbs_count()) |i| {
291 const res = x_limbs[i] -% y_limbs[i] -% borrow;
292 x_limbs[i] = ct.select(on, @as(TLimb, @truncate(res)), x_limbs[i]);
293 borrow = @as(u1, @truncate(res >> t_bits));
288 for (x.limbs(), y.limbsConst()) |*x_limb, y_limb| {
289 const res = x_limb.* -% y_limb -% borrow;
290 x_limb.* = ct.select(on, @as(TLimb, @truncate(res)), x_limb.*);
291 borrow = @truncate(res >> t_bits);
294292 }
295293 return borrow;
296294 }
......@@ -315,7 +313,7 @@ fn Fe_(comptime bits: comptime_int) type {
315313
316314 // The number of active limbs to represent the field element.
317315 fn limbs_count(self: Self) usize {
318 return self.v.limbs_count();
316 return self.v.limbs_len;
319317 }
320318
321319 /// Creates a field element from a primitive.
......@@ -398,7 +396,7 @@ pub fn Modulus(comptime max_bits: comptime_int) type {
398396
399397 // Number of active limbs in the modulus.
400398 fn limbs_count(self: Self) usize {
401 return self.v.limbs_count();
399 return self.v.limbs_len;
402400 }
403401
404402 /// Actual size of the modulus, in bits.
......@@ -409,7 +407,7 @@ pub fn Modulus(comptime max_bits: comptime_int) type {
409407 /// Returns the element `1`.
410408 pub fn one(self: Self) Fe {
411409 var fe = self.zero;
412 fe.v.limbs.set(0, 1);
410 fe.v.limbs()[0] = 1;
413411 return fe;
414412 }
415413
......@@ -419,10 +417,10 @@ pub fn Modulus(comptime max_bits: comptime_int) type {
419417 if (!v_.isOdd()) return error.EvenModulus;
420418
421419 var v = v_.normalize();
422 const hi = v.limbs.get(v.limbs_count() - 1);
423 const lo = v.limbs.get(0);
420 const hi = v.limbsConst()[v.limbs_len - 1];
421 const lo = v.limbsConst()[0];
424422
425 if (v.limbs_count() < 2 and lo < 3) {
423 if (v.limbs_len < 2 and lo < 3) {
426424 return error.ModulusTooSmall;
427425 }
428426
......@@ -481,18 +479,19 @@ pub fn Modulus(comptime max_bits: comptime_int) type {
481479 const new_len = self.limbs_count();
482480 if (fe.limbs_count() < new_len) return error.Overflow;
483481 var acc: Limb = 0;
484 for (fe.v.limbs.constSlice()[new_len..]) |limb| {
482 for (fe.v.limbsConst()[new_len..]) |limb| {
485483 acc |= limb;
486484 }
487485 if (acc != 0) return error.Overflow;
488 try fe.v.limbs.resize(new_len);
486 if (new_len > fe.v.limbs_buffer.len) return error.Overflow;
487 fe.v.limbs_len = new_len;
489488 }
490489
491490 // Computes R^2 for the Montgomery representation.
492491 fn computeRR(self: *Self) void {
493492 self.rr = self.zero;
494493 const n = self.rr.limbs_count();
495 self.rr.v.limbs.set(n - 1, 1);
494 self.rr.v.limbs()[n - 1] = 1;
496495 for ((n - 1)..(2 * n)) |_| {
497496 self.shiftIn(&self.rr, 0);
498497 }
......@@ -502,9 +501,9 @@ pub fn Modulus(comptime max_bits: comptime_int) type {
502501 /// Computes x << t_bits + y (mod m)
503502 fn shiftIn(self: Self, x: *Fe, y: Limb) void {
504503 var d = self.zero;
505 const x_limbs = x.v.limbs.slice();
506 const d_limbs = d.v.limbs.slice();
507 const m_limbs = self.v.limbs.constSlice();
504 const x_limbs = x.v.limbs();
505 const d_limbs = d.v.limbs();
506 const m_limbs = self.v.limbsConst();
508507
509508 var need_sub = false;
510509 var i: usize = t_bits - 1;
......@@ -569,18 +568,18 @@ pub fn Modulus(comptime max_bits: comptime_int) type {
569568 /// Reduces an arbitrary `Uint`, converting it to a field element.
570569 pub fn reduce(self: Self, x: anytype) Fe {
571570 var out = self.zero;
572 var i = x.limbs_count() - 1;
571 var i = x.limbs_len - 1;
573572 if (self.limbs_count() >= 2) {
574573 const start = @min(i, self.limbs_count() - 2);
575574 var j = start;
576575 while (true) : (j -= 1) {
577 out.v.limbs.set(j, x.limbs.get(i));
576 out.v.limbs()[j] = x.limbsConst()[i];
578577 i -= 1;
579578 if (j == 0) break;
580579 }
581580 }
582581 while (true) : (i -= 1) {
583 self.shiftIn(&out, x.limbs.get(i));
582 self.shiftIn(&out, x.limbsConst()[i]);
584583 if (i == 0) break;
585584 }
586585 return out;
......@@ -591,10 +590,10 @@ pub fn Modulus(comptime max_bits: comptime_int) type {
591590 assert(d.limbs_count() == y.limbs_count());
592591 assert(d.limbs_count() == self.limbs_count());
593592
594 const a_limbs = x.v.limbs.constSlice();
595 const b_limbs = y.v.limbs.constSlice();
596 const d_limbs = d.v.limbs.slice();
597 const m_limbs = self.v.limbs.constSlice();
593 const a_limbs = x.v.limbsConst();
594 const b_limbs = y.v.limbsConst();
595 const d_limbs = d.v.limbs();
596 const m_limbs = self.v.limbsConst();
598597
599598 var overflow: u1 = 0;
600599 for (0..self.limbs_count()) |i| {
......@@ -685,7 +684,7 @@ pub fn Modulus(comptime max_bits: comptime_int) type {
685684 const k: u1 = @truncate(b >> j);
686685 if (k != 0) {
687686 const t = self.montgomeryMul(out, x_m);
688 @memcpy(out.v.limbs.slice(), t.v.limbs.constSlice());
687 @memcpy(out.v.limbs(), t.v.limbsConst());
689688 }
690689 if (j == 0) break;
691690 }
......@@ -731,7 +730,7 @@ pub fn Modulus(comptime max_bits: comptime_int) type {
731730 }
732731 const t1 = self.montgomeryMul(out, t0);
733732 if (public) {
734 @memcpy(out.v.limbs.slice(), t1.v.limbs.constSlice());
733 @memcpy(out.v.limbs(), t1.v.limbsConst());
735734 } else {
736735 out.v.cmov(!ct.eql(k, 0), t1.v);
737736 }
......@@ -790,9 +789,9 @@ pub fn Modulus(comptime max_bits: comptime_int) type {
790789 pub fn powPublic(self: Self, x: Fe, e: Fe) NullExponentError!Fe {
791790 var e_normalized = Fe{ .v = e.v.normalize() };
792791 var buf_: [Fe.encoded_bytes]u8 = undefined;
793 var buf = buf_[0 .. math.divCeil(usize, e_normalized.v.limbs_count() * t_bits, 8) catch unreachable];
792 var buf = buf_[0 .. math.divCeil(usize, e_normalized.v.limbs_len * t_bits, 8) catch unreachable];
794793 e_normalized.toBytes(buf, .little) catch unreachable;
795 const leading = @clz(e_normalized.v.limbs.get(e_normalized.v.limbs_count() - carry_bits));
794 const leading = @clz(e_normalized.v.limbsConst()[e_normalized.v.limbs_len - carry_bits]);
796795 buf = buf[0 .. buf.len - leading / 8];
797796 return self.powWithEncodedPublicExponent(x, buf, .little);
798797 }
......@@ -835,20 +834,16 @@ const ct_protected = struct {
835834
836835 // Compares two big integers in constant time, returning true if x < y.
837836 fn limbsCmpLt(x: anytype, y: @TypeOf(x)) bool {
838 assert(x.limbs_count() == y.limbs_count());
839 const x_limbs = x.limbs.constSlice();
840 const y_limbs = y.limbs.constSlice();
841
842837 var c: u1 = 0;
843 for (0..x.limbs_count()) |i| {
844 c = @as(u1, @truncate((x_limbs[i] -% y_limbs[i] -% c) >> t_bits));
838 for (x.limbsConst(), y.limbsConst()) |x_limb, y_limb| {
839 c = @truncate((x_limb -% y_limb -% c) >> t_bits);
845840 }
846 return @as(bool, @bitCast(c));
841 return c != 0;
847842 }
848843
849844 // Compares two big integers in constant time, returning true if x >= y.
850845 fn limbsCmpGeq(x: anytype, y: @TypeOf(x)) bool {
851 return @as(bool, @bitCast(1 - @intFromBool(ct.limbsCmpLt(x, y))));
846 return !ct.limbsCmpLt(x, y);
852847 }
853848
854849 // Multiplies two limbs and returns the result as a wide limb.