Commit e45bdc6bd6e47ec3f7a06dbb48f24e842bf43a0d | zig

author	Frank Denis <124872+jedisct1@users.noreply.github.com> 2024-04-14 01:13:22+02:00
committer	GitHub <noreply@github.com> 2024-04-14 01:13:22+02:00
log	e45bdc6bd6e47ec3f7a06dbb48f24e842bf43a0d
tree	40e21d48696c1ed7c51535500da10b8f94c380ea
parent	a59ad719d2b838846ffd5ea77e06322b5427b4e5
signature	Signed by PGP key B5690EEEBB952194

std.crypto.pcurves.*: simpler, smaller, faster u64 addition with carry (#19644)

signature/s:

Algorithm        Before     After
---------------+---------+-------
ecdsa-p256        3707       4396
ecdsa-p384        1067       1332
ecdsa-secp256k1   4490       5147

Add ECDSA to the benchmark by the way.

7 files changed, 42 insertions(+), 73 deletions(-)

lib
- std
  - crypto
    benchmark.zig
    pcurves
    p256
    p256_64.zig
    p256_scalar_64.zig
    p384
    p384_64.zig
    p384_scalar_64.zig
    secp256k1
    secp256k1_64.zig
    secp256k1_scalar_64.zig

lib/std/crypto/benchmark.zig+6-1

...	...	@@ -131,7 +131,12 @@ pub fn benchmarkKeyExchange(comptime DhKeyExchange: anytype, comptime exchange_c
131	131	return throughput;
132	132	}
133	133
134		const signatures = [_]Crypto{Crypto{ .ty = crypto.sign.Ed25519, .name = "ed25519" }};
	134	const signatures = [_]Crypto{
	135	Crypto{ .ty = crypto.sign.Ed25519, .name = "ed25519" },
	136	Crypto{ .ty = crypto.sign.ecdsa.EcdsaP256Sha256, .name = "ecdsa-p256" },
	137	Crypto{ .ty = crypto.sign.ecdsa.EcdsaP384Sha384, .name = "ecdsa-p384" },
	138	Crypto{ .ty = crypto.sign.ecdsa.EcdsaSecp256k1Sha256, .name = "ecdsa-secp256k1" },
	139	};
135	140
136	141	pub fn benchmarkSignature(comptime Signature: anytype, comptime signatures_count: comptime_int) !u64 {
137	142	const msg = [_]u8{0} ** 64;

lib/std/crypto/pcurves/p256/p256_64.zig+6-12

...	...	@@ -73,12 +73,9 @@ pub const NonMontgomeryDomainFieldElement = [4]u64;
73	73	/// out1: [0x0 ~> 0xffffffffffffffff]
74	74	/// out2: [0x0 ~> 0x1]
75	75	inline fn addcarryxU64(out1: u64, out2: u1, arg1: u1, arg2: u64, arg3: u64) void {
76		@setRuntimeSafety(mode == .Debug);
77
78		const ov1 = @addWithOverflow(arg2, arg3);
79		const ov2 = @addWithOverflow(ov1[0], arg1);
80		out1.* = ov2[0];
81		out2.* = ov1[1] \| ov2[1];
	76	const x = @as(u128, arg2) +% arg3 +% arg1;
	77	out1.* = @truncate(x);
	78	out2.* = @truncate(x >> 64);
82	79	}
83	80
84	81	/// The function subborrowxU64 is a subtraction with borrow.
...	...	@@ -95,12 +92,9 @@ inline fn addcarryxU64(out1: u64, out2: u1, arg1: u1, arg2: u64, arg3: u64) vo
95	92	/// out1: [0x0 ~> 0xffffffffffffffff]
96	93	/// out2: [0x0 ~> 0x1]
97	94	inline fn subborrowxU64(out1: u64, out2: u1, arg1: u1, arg2: u64, arg3: u64) void {
98		@setRuntimeSafety(mode == .Debug);
99
100		const ov1 = @subWithOverflow(arg2, arg3);
101		const ov2 = @subWithOverflow(ov1[0], arg1);
102		out1.* = ov2[0];
103		out2.* = ov1[1] \| ov2[1];
	95	const x = @as(u128, arg2) -% arg3 -% arg1;
	96	out1.* = @truncate(x);
	97	out2.* = @truncate(x >> 64);
104	98	}
105	99
106	100	/// The function mulxU64 is a multiplication, returning the full double-width result.

lib/std/crypto/pcurves/p256/p256_scalar_64.zig+6-12

...	...	@@ -73,12 +73,9 @@ pub const NonMontgomeryDomainFieldElement = [4]u64;
73	73	/// out1: [0x0 ~> 0xffffffffffffffff]
74	74	/// out2: [0x0 ~> 0x1]
75	75	inline fn addcarryxU64(out1: u64, out2: u1, arg1: u1, arg2: u64, arg3: u64) void {
76		@setRuntimeSafety(mode == .Debug);
77
78		const ov1 = @addWithOverflow(arg2, arg3);
79		const ov2 = @addWithOverflow(ov1[0], arg1);
80		out1.* = ov2[0];
81		out2.* = ov1[1] \| ov2[1];
	76	const x = @as(u128, arg2) +% arg3 +% arg1;
	77	out1.* = @truncate(x);
	78	out2.* = @truncate(x >> 64);
82	79	}
83	80
84	81	/// The function subborrowxU64 is a subtraction with borrow.
...	...	@@ -95,12 +92,9 @@ inline fn addcarryxU64(out1: u64, out2: u1, arg1: u1, arg2: u64, arg3: u64) vo
95	92	/// out1: [0x0 ~> 0xffffffffffffffff]
96	93	/// out2: [0x0 ~> 0x1]
97	94	inline fn subborrowxU64(out1: u64, out2: u1, arg1: u1, arg2: u64, arg3: u64) void {
98		@setRuntimeSafety(mode == .Debug);
99
100		const ov1 = @subWithOverflow(arg2, arg3);
101		const ov2 = @subWithOverflow(ov1[0], arg1);
102		out1.* = ov2[0];
103		out2.* = ov1[1] \| ov2[1];
	95	const x = @as(u128, arg2) -% arg3 -% arg1;
	96	out1.* = @truncate(x);
	97	out2.* = @truncate(x >> 64);
104	98	}
105	99
106	100	/// The function mulxU64 is a multiplication, returning the full double-width result.

lib/std/crypto/pcurves/p384/p384_64.zig+6-12

...	...	@@ -42,12 +42,9 @@ pub const NonMontgomeryDomainFieldElement = [6]u64;
42	42	/// out1: [0x0 ~> 0xffffffffffffffff]
43	43	/// out2: [0x0 ~> 0x1]
44	44	inline fn addcarryxU64(out1: u64, out2: u1, arg1: u1, arg2: u64, arg3: u64) void {
45		@setRuntimeSafety(mode == .Debug);
46
47		const ov1 = @addWithOverflow(arg2, arg3);
48		const ov2 = @addWithOverflow(ov1[0], arg1);
49		out1.* = ov2[0];
50		out2.* = ov1[1] \| ov2[1];
	45	const x = @as(u128, arg2) +% arg3 +% arg1;
	46	out1.* = @truncate(x);
	47	out2.* = @truncate(x >> 64);
51	48	}
52	49
53	50	/// The function subborrowxU64 is a subtraction with borrow.
...	...	@@ -64,12 +61,9 @@ inline fn addcarryxU64(out1: u64, out2: u1, arg1: u1, arg2: u64, arg3: u64) vo
64	61	/// out1: [0x0 ~> 0xffffffffffffffff]
65	62	/// out2: [0x0 ~> 0x1]
66	63	inline fn subborrowxU64(out1: u64, out2: u1, arg1: u1, arg2: u64, arg3: u64) void {
67		@setRuntimeSafety(mode == .Debug);
68
69		const ov1 = @subWithOverflow(arg2, arg3);
70		const ov2 = @subWithOverflow(ov1[0], arg1);
71		out1.* = ov2[0];
72		out2.* = ov1[1] \| ov2[1];
	64	const x = @as(u128, arg2) -% arg3 -% arg1;
	65	out1.* = @truncate(x);
	66	out2.* = @truncate(x >> 64);
73	67	}
74	68
75	69	/// The function mulxU64 is a multiplication, returning the full double-width result.

lib/std/crypto/pcurves/p384/p384_scalar_64.zig+6-12

...	...	@@ -42,12 +42,9 @@ pub const NonMontgomeryDomainFieldElement = [6]u64;
42	42	/// out1: [0x0 ~> 0xffffffffffffffff]
43	43	/// out2: [0x0 ~> 0x1]
44	44	inline fn addcarryxU64(out1: u64, out2: u1, arg1: u1, arg2: u64, arg3: u64) void {
45		@setRuntimeSafety(mode == .Debug);
46
47		const ov1 = @addWithOverflow(arg2, arg3);
48		const ov2 = @addWithOverflow(ov1[0], arg1);
49		out1.* = ov2[0];
50		out2.* = ov1[1] \| ov2[1];
	45	const x = @as(u128, arg2) +% arg3 +% arg1;
	46	out1.* = @truncate(x);
	47	out2.* = @truncate(x >> 64);
51	48	}
52	49
53	50	/// The function subborrowxU64 is a subtraction with borrow.
...	...	@@ -64,12 +61,9 @@ inline fn addcarryxU64(out1: u64, out2: u1, arg1: u1, arg2: u64, arg3: u64) vo
64	61	/// out1: [0x0 ~> 0xffffffffffffffff]
65	62	/// out2: [0x0 ~> 0x1]
66	63	inline fn subborrowxU64(out1: u64, out2: u1, arg1: u1, arg2: u64, arg3: u64) void {
67		@setRuntimeSafety(mode == .Debug);
68
69		const ov1 = @subWithOverflow(arg2, arg3);
70		const ov2 = @subWithOverflow(ov1[0], arg1);
71		out1.* = ov2[0];
72		out2.* = ov1[1] \| ov2[1];
	64	const x = @as(u128, arg2) -% arg3 -% arg1;
	65	out1.* = @truncate(x);
	66	out2.* = @truncate(x >> 64);
73	67	}
74	68
75	69	/// The function mulxU64 is a multiplication, returning the full double-width result.

lib/std/crypto/pcurves/secp256k1/secp256k1_64.zig+6-12

...	...	@@ -42,12 +42,9 @@ pub const NonMontgomeryDomainFieldElement = [4]u64;
42	42	/// out1: [0x0 ~> 0xffffffffffffffff]
43	43	/// out2: [0x0 ~> 0x1]
44	44	inline fn addcarryxU64(out1: u64, out2: u1, arg1: u1, arg2: u64, arg3: u64) void {
45		@setRuntimeSafety(mode == .Debug);
46
47		const ov1 = @addWithOverflow(arg2, arg3);
48		const ov2 = @addWithOverflow(ov1[0], arg1);
49		out1.* = ov2[0];
50		out2.* = ov1[1] \| ov2[1];
	45	const x = @as(u128, arg2) +% arg3 +% arg1;
	46	out1.* = @truncate(x);
	47	out2.* = @truncate(x >> 64);
51	48	}
52	49
53	50	/// The function subborrowxU64 is a subtraction with borrow.
...	...	@@ -64,12 +61,9 @@ inline fn addcarryxU64(out1: u64, out2: u1, arg1: u1, arg2: u64, arg3: u64) vo
64	61	/// out1: [0x0 ~> 0xffffffffffffffff]
65	62	/// out2: [0x0 ~> 0x1]
66	63	inline fn subborrowxU64(out1: u64, out2: u1, arg1: u1, arg2: u64, arg3: u64) void {
67		@setRuntimeSafety(mode == .Debug);
68
69		const ov1 = @subWithOverflow(arg2, arg3);
70		const ov2 = @subWithOverflow(ov1[0], arg1);
71		out1.* = ov2[0];
72		out2.* = ov1[1] \| ov2[1];
	64	const x = @as(u128, arg2) -% arg3 -% arg1;
	65	out1.* = @truncate(x);
	66	out2.* = @truncate(x >> 64);
73	67	}
74	68
75	69	/// The function mulxU64 is a multiplication, returning the full double-width result.

lib/std/crypto/pcurves/secp256k1/secp256k1_scalar_64.zig+6-12

...	...	@@ -42,12 +42,9 @@ pub const NonMontgomeryDomainFieldElement = [4]u64;
42	42	/// out1: [0x0 ~> 0xffffffffffffffff]
43	43	/// out2: [0x0 ~> 0x1]
44	44	inline fn addcarryxU64(out1: u64, out2: u1, arg1: u1, arg2: u64, arg3: u64) void {
45		@setRuntimeSafety(mode == .Debug);
46
47		const ov1 = @addWithOverflow(arg2, arg3);
48		const ov2 = @addWithOverflow(ov1[0], arg1);
49		out1.* = ov2[0];
50		out2.* = ov1[1] \| ov2[1];
	45	const x = @as(u128, arg2) +% arg3 +% arg1;
	46	out1.* = @truncate(x);
	47	out2.* = @truncate(x >> 64);
51	48	}
52	49
53	50	/// The function subborrowxU64 is a subtraction with borrow.
...	...	@@ -64,12 +61,9 @@ inline fn addcarryxU64(out1: u64, out2: u1, arg1: u1, arg2: u64, arg3: u64) vo
64	61	/// out1: [0x0 ~> 0xffffffffffffffff]
65	62	/// out2: [0x0 ~> 0x1]
66	63	inline fn subborrowxU64(out1: u64, out2: u1, arg1: u1, arg2: u64, arg3: u64) void {
67		@setRuntimeSafety(mode == .Debug);
68
69		const ov1 = @subWithOverflow(arg2, arg3);
70		const ov2 = @subWithOverflow(ov1[0], arg1);
71		out1.* = ov2[0];
72		out2.* = ov1[1] \| ov2[1];
	64	const x = @as(u128, arg2) -% arg3 -% arg1;
	65	out1.* = @truncate(x);
	66	out2.* = @truncate(x >> 64);
73	67	}
74	68
75	69	/// The function mulxU64 is a multiplication, returning the full double-width result.