std.crypto.pcurves.p384.AffineCoordinates
container
A point in affine coordinates.
Fields
std.crypto.pcurves.p384.AffineCoordinates.cMov
function
fn cMov(p: *AffineCoordinates, a: AffineCoordinates, c: u1) void
Parameters
std.crypto.pcurves.p384.AffineCoordinates.identityElement
constant
Identity element in affine coordinates.
std.crypto.pcurves.p384.AffineCoordinates.neg
function
pub fn neg(p: AffineCoordinates) AffineCoordinates
Parameters
std.crypto.pcurves.p384.crypto
alias
Alias of std.crypto
std.crypto.pcurves.p384.EncodingError
alias
Alias of std.crypto.errors.EncodingError
std.crypto.pcurves.p384.IdentityElementError
alias
std.crypto.pcurves.p384.mem
alias
Alias of std.mem
std.crypto.pcurves.p384.meta
alias
Alias of std.meta
std.crypto.pcurves.p384.NonCanonicalError
alias
Alias of std.crypto.errors.NonCanonicalError
std.crypto.pcurves.p384.NotSquareError
alias
Alias of std.crypto.errors.NotSquareError
std.crypto.pcurves.p384.P384
container
Group operations over P384.
Fields
FescalarbasePointidentityElementBrejectIdentityfromAffineCoordinatesfromSerializedAffineCoordinatesrecoverYfromSec1toCompressedSec1toUncompressedSec1randomnegdbladdMixedaddsubsubMixedaffineCoordinatesequivalentcMovpcSelectslidepcMulpcMul16precomputebasePointPcmulmulPublicmulDoubleBasePublic
std.crypto.pcurves.p384.P384.add
function
Add P384 points.
pub fn add(p: P384, q: P384) P384
Parameters
std.crypto.pcurves.p384.P384.addMixed
function
Add P384 points, the second being specified using affine coordinates.
pub fn addMixed(p: P384, q: AffineCoordinates) P384
Parameters
p: P384
q: AffineCoordinates
std.crypto.pcurves.p384.P384.affineCoordinates
function
Return affine coordinates.
pub fn affineCoordinates(p: P384) AffineCoordinates
Parameters
p: P384
std.crypto.pcurves.p384.P384.B
constant
std.crypto.pcurves.p384.P384.basePoint
constant
The P384 base point.
std.crypto.pcurves.p384.P384.basePointPc
constant
std.crypto.pcurves.p384.P384.cMov
function
fn cMov(p: *P384, a: P384, c: u1) void
Parameters
std.crypto.pcurves.p384.P384.dbl
function
Double a P384 point.
pub fn dbl(p: P384) P384
Parameters
p: P384
std.crypto.pcurves.p384.P384.equivalent
function
Return true if both coordinate sets represent the same point.
pub fn equivalent(a: P384, b: P384) bool
Parameters
std.crypto.pcurves.p384.P384.Fe
alias
The underlying prime field.
Alias of std.crypto.pcurves.p384.field.Fe
std.crypto.pcurves.p384.P384.fromAffineCoordinates
function
Create a point from affine coordinates after checking that they match the curve equation.
pub fn fromAffineCoordinates(p: AffineCoordinates) EncodingError!P384
Parameters
Errors
- InvalidEncoding EncodingError
std.crypto.pcurves.p384.P384.fromSec1
function
Deserialize a SEC1-encoded point.
pub fn fromSec1(s: []const u8) (EncodingError || NotSquareError || NonCanonicalError)!P384
Parameters
s: []const u8
std.crypto.pcurves.p384.P384.fromSerializedAffineCoordinates
function
Create a point from serialized affine coordinates.
pub fn fromSerializedAffineCoordinates(xs: [48]u8, ys: [48]u8, endian: std.lang.Endian) (NonCanonicalError || EncodingError)!P384
Parameters
std.crypto.pcurves.p384.P384.identityElement
constant
The P384 neutral element.
std.crypto.pcurves.p384.P384.mul
function
Multiply an elliptic curve point by a scalar. Return error.IdentityElement if the result is the identity element.
pub fn mul(p: P384, s_: [48]u8, endian: std.lang.Endian) IdentityElementError!P384
Parameters
Errors
- IdentityElement IdentityElementError
std.crypto.pcurves.p384.P384.mulDoubleBasePublic
function
Double-base multiplication of public parameters - Compute (p1s1)+(p2s2) IN VARIABLE TIME This can be used for signature verification.
pub fn mulDoubleBasePublic(p1: P384, s1_: [48]u8, p2: P384, s2_: [48]u8, endian: std.lang.Endian) IdentityElementError!P384
Parameters
Errors
- IdentityElement IdentityElementError
std.crypto.pcurves.p384.P384.mulPublic
function
Multiply an elliptic curve point by a PUBLIC scalar IN VARIABLE TIME This can be used for signature verification.
pub fn mulPublic(p: P384, s_: [48]u8, endian: std.lang.Endian) IdentityElementError!P384
Parameters
Errors
- IdentityElement IdentityElementError
std.crypto.pcurves.p384.P384.neg
function
Flip the sign of the X coordinate.
pub fn neg(p: P384) P384
Parameters
p: P384
std.crypto.pcurves.p384.P384.pcMul
function
fn pcMul(pc: *const [9]P384, s: [48]u8, comptime vartime: bool) IdentityElementError!P384
Parameters
Errors
- IdentityElement IdentityElementError
std.crypto.pcurves.p384.P384.pcMul16
function
fn pcMul16(pc: *const [16]P384, s: [48]u8, comptime vartime: bool) IdentityElementError!P384
Parameters
Errors
- IdentityElement IdentityElementError
std.crypto.pcurves.p384.P384.pcSelect
function
fn pcSelect(comptime n: usize, pc: *const [n]P384, b: u8) P384
Parameters
std.crypto.pcurves.p384.P384.precompute
function
fn precompute(p: P384, comptime count: usize) [1 + count]P384
Parameters
p: P384
count: usize
std.crypto.pcurves.p384.P384.random
function
Return a random point.
pub fn random(io: std.Io) P384
Parameters
std.crypto.pcurves.p384.P384.recoverY
function
Recover the Y coordinate from the X coordinate.
pub fn recoverY(x: Fe, is_odd: bool) NotSquareError!Fe
Parameters
x: Fe
is_odd: bool
Errors
- NotSquare NotSquareError
std.crypto.pcurves.p384.P384.rejectIdentity
function
Reject the neutral element.
pub fn rejectIdentity(p: P384) IdentityElementError!void
Parameters
p: P384
Errors
- IdentityElement IdentityElementError
std.crypto.pcurves.p384.P384.scalar
alias
Field arithmetic mod the order of the main subgroup.
Alias of std.crypto.pcurves.p384.scalar
std.crypto.pcurves.p384.P384.slide
function
fn slide(s: [48]u8) [2 * 48 + 1]i8
Parameters
s: [48]u8
std.crypto.pcurves.p384.P384.sub
function
Subtract P384 points.
pub fn sub(p: P384, q: P384) P384
Parameters
std.crypto.pcurves.p384.P384.subMixed
function
Subtract P384 points, the second being specified using affine coordinates.
pub fn subMixed(p: P384, q: AffineCoordinates) P384
Parameters
p: P384
q: AffineCoordinates
std.crypto.pcurves.p384.P384.toCompressedSec1
function
Serialize a point using the compressed SEC-1 format.
pub fn toCompressedSec1(p: P384) [49]u8
Parameters
p: P384
std.crypto.pcurves.p384.P384.toUncompressedSec1
function
Serialize a point using the uncompressed SEC-1 format.
pub fn toUncompressedSec1(p: P384) [97]u8
Parameters
p: P384
std.crypto.pcurves.p384.std
alias
Alias of std
Source code
std/crypto/pcurves/p384.zig
const std = @import("std");
const crypto = std.crypto;
const mem = std.mem;
const meta = std.meta;
const EncodingError = crypto.errors.EncodingError;
const IdentityElementError = crypto.errors.IdentityElementError;
const NonCanonicalError = crypto.errors.NonCanonicalError;
const NotSquareError = crypto.errors.NotSquareError;
/// Group operations over P384.
pub const P384 = struct {
/// The underlying prime field.
pub const Fe = @import("p384/field.zig").Fe;
/// Field arithmetic mod the order of the main subgroup.
pub const scalar = @import("p384/scalar.zig");
x: Fe,
y: Fe,
z: Fe = Fe.one,
is_base: bool = false,
/// The P384 base point.
pub const basePoint = P384{
.x = Fe.fromInt(26247035095799689268623156744566981891852923491109213387815615900925518854738050089022388053975719786650872476732087) catch unreachable,
.y = Fe.fromInt(8325710961489029985546751289520108179287853048861315594709205902480503199884419224438643760392947333078086511627871) catch unreachable,
.z = Fe.one,
.is_base = true,
};
/// The P384 neutral element.
pub const identityElement = P384{ .x = Fe.zero, .y = Fe.one, .z = Fe.zero };
pub const B = Fe.fromInt(27580193559959705877849011840389048093056905856361568521428707301988689241309860865136260764883745107765439761230575) catch unreachable;
/// Reject the neutral element.
pub fn rejectIdentity(p: P384) IdentityElementError!void {
const affine_0 = @intFromBool(p.x.equivalent(AffineCoordinates.identityElement.x)) & (@intFromBool(p.y.isZero()) | @intFromBool(p.y.equivalent(AffineCoordinates.identityElement.y)));
const is_identity = @intFromBool(p.z.isZero()) | affine_0;
if (is_identity != 0) {
return error.IdentityElement;
}
}
/// Create a point from affine coordinates after checking that they match the curve equation.
pub fn fromAffineCoordinates(p: AffineCoordinates) EncodingError!P384 {
const x = p.x;
const y = p.y;
const x3AxB = x.sq().mul(x).sub(x).sub(x).sub(x).add(B);
const yy = y.sq();
if (!x3AxB.equivalent(yy)) {
return error.InvalidEncoding;
}
return .{ .x = x, .y = y, .z = Fe.one };
}
/// Create a point from serialized affine coordinates.
pub fn fromSerializedAffineCoordinates(xs: [48]u8, ys: [48]u8, endian: std.lang.Endian) (NonCanonicalError || EncodingError)!P384 {
const x = try Fe.fromBytes(xs, endian);
const y = try Fe.fromBytes(ys, endian);
return fromAffineCoordinates(.{ .x = x, .y = y });
}
/// Recover the Y coordinate from the X coordinate.
pub fn recoverY(x: Fe, is_odd: bool) NotSquareError!Fe {
const x3AxB = x.sq().mul(x).sub(x).sub(x).sub(x).add(B);
var y = try x3AxB.sqrt();
const yn = y.neg();
y.cMov(yn, @intFromBool(is_odd) ^ @intFromBool(y.isOdd()));
return y;
}
/// Deserialize a SEC1-encoded point.
pub fn fromSec1(s: []const u8) (EncodingError || NotSquareError || NonCanonicalError)!P384 {
if (s.len < 1) return error.InvalidEncoding;
const encoding_type = s[0];
const encoded = s[1..];
switch (encoding_type) {
0 => {
if (encoded.len != 0) return error.InvalidEncoding;
return P384.identityElement;
},
2, 3 => {
if (encoded.len != 48) return error.InvalidEncoding;
const x = try Fe.fromBytes(encoded[0..48].*, .big);
const y_is_odd = (encoding_type == 3);
const y = try recoverY(x, y_is_odd);
return P384{ .x = x, .y = y };
},
4 => {
if (encoded.len != 96) return error.InvalidEncoding;
const x = try Fe.fromBytes(encoded[0..48].*, .big);
const y = try Fe.fromBytes(encoded[48..96].*, .big);
return P384.fromAffineCoordinates(.{ .x = x, .y = y });
},
else => return error.InvalidEncoding,
}
}
/// Serialize a point using the compressed SEC-1 format.
pub fn toCompressedSec1(p: P384) [49]u8 {
var out: [49]u8 = undefined;
const xy = p.affineCoordinates();
out[0] = if (xy.y.isOdd()) 3 else 2;
out[1..].* = xy.x.toBytes(.big);
return out;
}
/// Serialize a point using the uncompressed SEC-1 format.
pub fn toUncompressedSec1(p: P384) [97]u8 {
var out: [97]u8 = undefined;
out[0] = 4;
const xy = p.affineCoordinates();
out[1..49].* = xy.x.toBytes(.big);
out[49..97].* = xy.y.toBytes(.big);
return out;
}
/// Return a random point.
pub fn random(io: std.Io) P384 {
const n = scalar.random(io, .little);
return basePoint.mul(n, .little) catch unreachable;
}
/// Flip the sign of the X coordinate.
pub fn neg(p: P384) P384 {
return .{ .x = p.x, .y = p.y.neg(), .z = p.z };
}
/// Double a P384 point.
// Algorithm 6 from https://eprint.iacr.org/2015/1060.pdf
pub fn dbl(p: P384) P384 {
var t0 = p.x.sq();
var t1 = p.y.sq();
var t2 = p.z.sq();
var t3 = p.x.mul(p.y);
t3 = t3.dbl();
var Z3 = p.x.mul(p.z);
Z3 = Z3.add(Z3);
var Y3 = B.mul(t2);
Y3 = Y3.sub(Z3);
var X3 = Y3.dbl();
Y3 = X3.add(Y3);
X3 = t1.sub(Y3);
Y3 = t1.add(Y3);
Y3 = X3.mul(Y3);
X3 = X3.mul(t3);
t3 = t2.dbl();
t2 = t2.add(t3);
Z3 = B.mul(Z3);
Z3 = Z3.sub(t2);
Z3 = Z3.sub(t0);
t3 = Z3.dbl();
Z3 = Z3.add(t3);
t3 = t0.dbl();
t0 = t3.add(t0);
t0 = t0.sub(t2);
t0 = t0.mul(Z3);
Y3 = Y3.add(t0);
t0 = p.y.mul(p.z);
t0 = t0.dbl();
Z3 = t0.mul(Z3);
X3 = X3.sub(Z3);
Z3 = t0.mul(t1);
Z3 = Z3.dbl().dbl();
return .{
.x = X3,
.y = Y3,
.z = Z3,
};
}
/// Add P384 points, the second being specified using affine coordinates.
// Algorithm 5 from https://eprint.iacr.org/2015/1060.pdf
pub fn addMixed(p: P384, q: AffineCoordinates) P384 {
var t0 = p.x.mul(q.x);
var t1 = p.y.mul(q.y);
var t3 = q.x.add(q.y);
var t4 = p.x.add(p.y);
t3 = t3.mul(t4);
t4 = t0.add(t1);
t3 = t3.sub(t4);
t4 = q.y.mul(p.z);
t4 = t4.add(p.y);
var Y3 = q.x.mul(p.z);
Y3 = Y3.add(p.x);
var Z3 = B.mul(p.z);
var X3 = Y3.sub(Z3);
Z3 = X3.dbl();
X3 = X3.add(Z3);
Z3 = t1.sub(X3);
X3 = t1.add(X3);
Y3 = B.mul(Y3);
t1 = p.z.dbl();
var t2 = t1.add(p.z);
Y3 = Y3.sub(t2);
Y3 = Y3.sub(t0);
t1 = Y3.dbl();
Y3 = t1.add(Y3);
t1 = t0.dbl();
t0 = t1.add(t0);
t0 = t0.sub(t2);
t1 = t4.mul(Y3);
t2 = t0.mul(Y3);
Y3 = X3.mul(Z3);
Y3 = Y3.add(t2);
X3 = t3.mul(X3);
X3 = X3.sub(t1);
Z3 = t4.mul(Z3);
t1 = t3.mul(t0);
Z3 = Z3.add(t1);
var ret = P384{
.x = X3,
.y = Y3,
.z = Z3,
};
ret.cMov(p, @intFromBool(q.x.isZero()));
return ret;
}
/// Add P384 points.
// Algorithm 4 from https://eprint.iacr.org/2015/1060.pdf
pub fn add(p: P384, q: P384) P384 {
var t0 = p.x.mul(q.x);
var t1 = p.y.mul(q.y);
var t2 = p.z.mul(q.z);
var t3 = p.x.add(p.y);
var t4 = q.x.add(q.y);
t3 = t3.mul(t4);
t4 = t0.add(t1);
t3 = t3.sub(t4);
t4 = p.y.add(p.z);
var X3 = q.y.add(q.z);
t4 = t4.mul(X3);
X3 = t1.add(t2);
t4 = t4.sub(X3);
X3 = p.x.add(p.z);
var Y3 = q.x.add(q.z);
X3 = X3.mul(Y3);
Y3 = t0.add(t2);
Y3 = X3.sub(Y3);
var Z3 = B.mul(t2);
X3 = Y3.sub(Z3);
Z3 = X3.dbl();
X3 = X3.add(Z3);
Z3 = t1.sub(X3);
X3 = t1.add(X3);
Y3 = B.mul(Y3);
t1 = t2.dbl();
t2 = t1.add(t2);
Y3 = Y3.sub(t2);
Y3 = Y3.sub(t0);
t1 = Y3.dbl();
Y3 = t1.add(Y3);
t1 = t0.dbl();
t0 = t1.add(t0);
t0 = t0.sub(t2);
t1 = t4.mul(Y3);
t2 = t0.mul(Y3);
Y3 = X3.mul(Z3);
Y3 = Y3.add(t2);
X3 = t3.mul(X3);
X3 = X3.sub(t1);
Z3 = t4.mul(Z3);
t1 = t3.mul(t0);
Z3 = Z3.add(t1);
return .{
.x = X3,
.y = Y3,
.z = Z3,
};
}
/// Subtract P384 points.
pub fn sub(p: P384, q: P384) P384 {
return p.add(q.neg());
}
/// Subtract P384 points, the second being specified using affine coordinates.
pub fn subMixed(p: P384, q: AffineCoordinates) P384 {
return p.addMixed(q.neg());
}
/// Return affine coordinates.
pub fn affineCoordinates(p: P384) AffineCoordinates {
const affine_0 = @intFromBool(p.x.equivalent(AffineCoordinates.identityElement.x)) & (@intFromBool(p.y.isZero()) | @intFromBool(p.y.equivalent(AffineCoordinates.identityElement.y)));
const is_identity = @intFromBool(p.z.isZero()) | affine_0;
const zinv = p.z.invert();
var ret = AffineCoordinates{
.x = p.x.mul(zinv),
.y = p.y.mul(zinv),
};
ret.cMov(AffineCoordinates.identityElement, is_identity);
return ret;
}
/// Return true if both coordinate sets represent the same point.
pub fn equivalent(a: P384, b: P384) bool {
if (a.sub(b).rejectIdentity()) {
return false;
} else |_| {
return true;
}
}
fn cMov(p: *P384, a: P384, c: u1) void {
p.x.cMov(a.x, c);
p.y.cMov(a.y, c);
p.z.cMov(a.z, c);
}
fn pcSelect(comptime n: usize, pc: *const [n]P384, b: u8) P384 {
var t = P384.identityElement;
comptime var i: u8 = 1;
inline while (i < pc.len) : (i += 1) {
t.cMov(pc[i], @as(u1, @truncate((@as(usize, b ^ i) -% 1) >> 8)));
}
return t;
}
fn slide(s: [48]u8) [2 * 48 + 1]i8 {
var e: [2 * 48 + 1]i8 = undefined;
for (s, 0..) |x, i| {
e[i * 2 + 0] = @as(i8, @as(u4, @truncate(x)));
e[i * 2 + 1] = @as(i8, @as(u4, @truncate(x >> 4)));
}
// Now, e[0..63] is between 0 and 15, e[63] is between 0 and 7
var carry: i8 = 0;
for (e[0..96]) |*x| {
x.* += carry;
carry = (x.* + 8) >> 4;
x.* -= carry * 16;
std.debug.assert(x.* >= -8 and x.* <= 8);
}
e[96] = carry;
// Now, e[*] is between -8 and 8, including e[64]
std.debug.assert(carry >= -8 and carry <= 8);
return e;
}
fn pcMul(pc: *const [9]P384, s: [48]u8, comptime vartime: bool) IdentityElementError!P384 {
std.debug.assert(vartime);
const e = slide(s);
var q = P384.identityElement;
var pos = e.len - 1;
while (true) : (pos -= 1) {
const slot = e[pos];
if (slot > 0) {
q = q.add(pc[@as(usize, @intCast(slot))]);
} else if (slot < 0) {
q = q.sub(pc[@as(usize, @intCast(-slot))]);
}
if (pos == 0) break;
q = q.dbl().dbl().dbl().dbl();
}
try q.rejectIdentity();
return q;
}
fn pcMul16(pc: *const [16]P384, s: [48]u8, comptime vartime: bool) IdentityElementError!P384 {
var q = P384.identityElement;
var pos: usize = 380;
while (true) : (pos -= 4) {
const slot = @as(u4, @truncate((s[pos >> 3] >> @as(u3, @truncate(pos)))));
if (vartime) {
if (slot != 0) {
q = q.add(pc[slot]);
}
} else {
q = q.add(pcSelect(16, pc, slot));
}
if (pos == 0) break;
q = q.dbl().dbl().dbl().dbl();
}
try q.rejectIdentity();
return q;
}
fn precompute(p: P384, comptime count: usize) [1 + count]P384 {
var pc: [1 + count]P384 = undefined;
pc[0] = P384.identityElement;
pc[1] = p;
var i: usize = 2;
while (i <= count) : (i += 1) {
pc[i] = if (i % 2 == 0) pc[i / 2].dbl() else pc[i - 1].add(p);
}
return pc;
}
const basePointPc = pc: {
@setEvalBranchQuota(70000);
break :pc precompute(P384.basePoint, 15);
};
/// Multiply an elliptic curve point by a scalar.
/// Return error.IdentityElement if the result is the identity element.
pub fn mul(p: P384, s_: [48]u8, endian: std.lang.Endian) IdentityElementError!P384 {
const s = if (endian == .little) s_ else Fe.orderSwap(s_);
if (p.is_base) {
return pcMul16(&basePointPc, s, false);
}
try p.rejectIdentity();
const pc = precompute(p, 15);
return pcMul16(&pc, s, false);
}
/// Multiply an elliptic curve point by a *PUBLIC* scalar *IN VARIABLE TIME*
/// This can be used for signature verification.
pub fn mulPublic(p: P384, s_: [48]u8, endian: std.lang.Endian) IdentityElementError!P384 {
const s = if (endian == .little) s_ else Fe.orderSwap(s_);
if (p.is_base) {
return pcMul16(&basePointPc, s, true);
}
try p.rejectIdentity();
const pc = precompute(p, 8);
return pcMul(&pc, s, true);
}
/// Double-base multiplication of public parameters - Compute (p1*s1)+(p2*s2) *IN VARIABLE TIME*
/// This can be used for signature verification.
pub fn mulDoubleBasePublic(p1: P384, s1_: [48]u8, p2: P384, s2_: [48]u8, endian: std.lang.Endian) IdentityElementError!P384 {
const s1 = if (endian == .little) s1_ else Fe.orderSwap(s1_);
const s2 = if (endian == .little) s2_ else Fe.orderSwap(s2_);
try p1.rejectIdentity();
var pc1_array: [9]P384 = undefined;
const pc1 = if (p1.is_base) basePointPc[0..9] else pc: {
pc1_array = precompute(p1, 8);
break :pc &pc1_array;
};
try p2.rejectIdentity();
var pc2_array: [9]P384 = undefined;
const pc2 = if (p2.is_base) basePointPc[0..9] else pc: {
pc2_array = precompute(p2, 8);
break :pc &pc2_array;
};
const e1 = slide(s1);
const e2 = slide(s2);
var q = P384.identityElement;
var pos: usize = 2 * 48;
while (true) : (pos -= 1) {
const slot1 = e1[pos];
if (slot1 > 0) {
q = q.add(pc1[@as(usize, @intCast(slot1))]);
} else if (slot1 < 0) {
q = q.sub(pc1[@as(usize, @intCast(-slot1))]);
}
const slot2 = e2[pos];
if (slot2 > 0) {
q = q.add(pc2[@as(usize, @intCast(slot2))]);
} else if (slot2 < 0) {
q = q.sub(pc2[@as(usize, @intCast(-slot2))]);
}
if (pos == 0) break;
q = q.dbl().dbl().dbl().dbl();
}
try q.rejectIdentity();
return q;
}
};
/// A point in affine coordinates.
pub const AffineCoordinates = struct {
x: P384.Fe,
y: P384.Fe,
/// Identity element in affine coordinates.
pub const identityElement = AffineCoordinates{ .x = P384.identityElement.x, .y = P384.identityElement.y };
pub fn neg(p: AffineCoordinates) AffineCoordinates {
return .{ .x = p.x, .y = p.y.neg() };
}
fn cMov(p: *AffineCoordinates, a: AffineCoordinates, c: u1) void {
p.x.cMov(a.x, c);
p.y.cMov(a.y, c);
}
};
test {
_ = @import("tests/p384.zig");
}