std.crypto.pcurves.p384.scalar.add
function
Return a+b (mod L)
pub fn add(a: CompressedScalar, b: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!CompressedScalar
Parameters
Errors
- NonCanonical NonCanonicalError
std.crypto.pcurves.p384.scalar.common
alias
Alias of std.crypto.pcurves.common
std.crypto.pcurves.p384.scalar.CompressedScalar
type
A compressed scalar, in canonical form.
std.crypto.pcurves.p384.scalar.crypto
alias
Alias of std.crypto
std.crypto.pcurves.p384.scalar.debug
alias
Alias of std.debug
std.crypto.pcurves.p384.scalar.encoded_length
constant
Number of bytes required to encode a scalar.
std.crypto.pcurves.p384.scalar.Fe
type
std.crypto.pcurves.p384.scalar.Field
alias
Alias of std.crypto.pcurves.common.Field
std.crypto.pcurves.p384.scalar.field_order
constant
The scalar field order.
std.crypto.pcurves.p384.scalar.math
alias
Alias of std.math
std.crypto.pcurves.p384.scalar.mem
alias
Alias of std.mem
std.crypto.pcurves.p384.scalar.mul
function
Return a*b (mod L)
pub fn mul(a: CompressedScalar, b: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!CompressedScalar
Parameters
Errors
- NonCanonical NonCanonicalError
std.crypto.pcurves.p384.scalar.mulAdd
function
Return a*b+c (mod L)
pub fn mulAdd(a: CompressedScalar, b: CompressedScalar, c: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!CompressedScalar
Parameters
Errors
- NonCanonical NonCanonicalError
std.crypto.pcurves.p384.scalar.neg
function
Return -s (mod L)
pub fn neg(s: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!CompressedScalar
Parameters
s: CompressedScalar
endian: std.builtin.Endian
Errors
- NonCanonical NonCanonicalError
std.crypto.pcurves.p384.scalar.NonCanonicalError
alias
Alias of std.crypto.errors.NonCanonicalError
std.crypto.pcurves.p384.scalar.NotSquareError
alias
Alias of std.crypto.errors.NotSquareError
std.crypto.pcurves.p384.scalar.random
function
Return a random scalar
pub fn random(io: std.Io, endian: std.builtin.Endian) CompressedScalar
Parameters
std.crypto.pcurves.p384.scalar.reduce64
function
Reduce a 64-bytes scalar to the field size.
pub fn reduce64(s: [64]u8, endian: std.builtin.Endian) CompressedScalar
Parameters
std.crypto.pcurves.p384.scalar.rejectNonCanonical
function
Reject a scalar whose encoding is not canonical.
pub fn rejectNonCanonical(s: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!void
Parameters
s: CompressedScalar
endian: std.builtin.Endian
Errors
- NonCanonical NonCanonicalError
std.crypto.pcurves.p384.scalar.Scalar
container
A scalar in unpacked representation.
Fields
fe: Fe
std.crypto.pcurves.p384.scalar.Scalar.add
function
Compute x+y (mod L)
pub fn add(x: Scalar, y: Scalar) Scalar
Parameters
std.crypto.pcurves.p384.scalar.Scalar.dbl
function
Compute 2n (mod L)
pub fn dbl(n: Scalar) Scalar
Parameters
n: Scalar
std.crypto.pcurves.p384.scalar.Scalar.equivalent
function
Return true if a and b are equivalent.
pub fn equivalent(a: Scalar, b: Scalar) bool
Parameters
std.crypto.pcurves.p384.scalar.Scalar.fromBytes
function
Unpack a serialized representation of a scalar.
pub fn fromBytes(s: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!Scalar
Parameters
s: CompressedScalar
endian: std.builtin.Endian
Errors
- NonCanonical NonCanonicalError
std.crypto.pcurves.p384.scalar.Scalar.fromBytes64
function
Reduce a 512 bit input to the field size.
pub fn fromBytes64(s: [64]u8, endian: std.builtin.Endian) Scalar
Parameters
std.crypto.pcurves.p384.scalar.Scalar.invert
function
Compute x^-1 (mod L)
pub fn invert(n: Scalar) Scalar
Parameters
n: Scalar
std.crypto.pcurves.p384.scalar.Scalar.isOdd
function
Return true if the scalar is odd.
pub fn isOdd(n: Scalar) bool
Parameters
n: Scalar
std.crypto.pcurves.p384.scalar.Scalar.isSquare
function
Return true if n is a quadratic residue mod L.
pub fn isSquare(n: Scalar) bool
Parameters
n: Scalar
std.crypto.pcurves.p384.scalar.Scalar.isZero
function
Return true if the scalar is zero..
pub fn isZero(n: Scalar) bool
Parameters
n: Scalar
std.crypto.pcurves.p384.scalar.Scalar.mul
function
Compute x*y (mod L)
pub fn mul(x: Scalar, y: Scalar) Scalar
Parameters
std.crypto.pcurves.p384.scalar.Scalar.neg
function
Compute -x (mod L)
pub fn neg(n: Scalar) Scalar
Parameters
n: Scalar
std.crypto.pcurves.p384.scalar.Scalar.one
constant
One.
std.crypto.pcurves.p384.scalar.Scalar.pow
function
Compute x^n (mod L)
pub fn pow(a: Scalar, comptime T: type, comptime n: T) Scalar
Parameters
std.crypto.pcurves.p384.scalar.Scalar.random
function
Return a random scalar < L.
pub fn random(io: std.Io) Scalar
Parameters
std.crypto.pcurves.p384.scalar.Scalar.sq
function
Compute x^2 (mod L)
pub fn sq(n: Scalar) Scalar
Parameters
n: Scalar
std.crypto.pcurves.p384.scalar.Scalar.sqrt
function
Return the square root of L, or NotSquare if there isn't any solutions.
pub fn sqrt(n: Scalar) NotSquareError!Scalar
Parameters
n: Scalar
Errors
- NotSquare NotSquareError
std.crypto.pcurves.p384.scalar.Scalar.sub
function
Compute x-y (mod L)
pub fn sub(x: Scalar, y: Scalar) Scalar
Parameters
std.crypto.pcurves.p384.scalar.Scalar.toBytes
function
Pack a scalar into bytes.
pub fn toBytes(n: Scalar, endian: std.builtin.Endian) CompressedScalar
Parameters
std.crypto.pcurves.p384.scalar.Scalar.zero
constant
Zero.
std.crypto.pcurves.p384.scalar.ScalarDouble
container
Fields
std.crypto.pcurves.p384.scalar.ScalarDouble.fromBytes
function
fn fromBytes(comptime bits: usize, s_: [bits / 8]u8, endian: std.builtin.Endian) ScalarDouble
Parameters
std.crypto.pcurves.p384.scalar.ScalarDouble.reduce
function
fn reduce(expanded: ScalarDouble, comptime bits: usize) Scalar
Parameters
expanded: ScalarDouble
bits: usize
std.crypto.pcurves.p384.scalar.std
alias
Alias of std
std.crypto.pcurves.p384.scalar.sub
function
Return (a-b) (mod L)
pub fn sub(a: CompressedScalar, b: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!CompressedScalar
Parameters
Errors
- NonCanonical NonCanonicalError
Source code
std/crypto/pcurves/p384/scalar.zig
const std = @import("std");
const common = @import("../common.zig");
const crypto = std.crypto;
const debug = std.debug;
const math = std.math;
const mem = std.mem;
const Field = common.Field;
const NonCanonicalError = std.crypto.errors.NonCanonicalError;
const NotSquareError = std.crypto.errors.NotSquareError;
/// Number of bytes required to encode a scalar.
pub const encoded_length = 48;
/// A compressed scalar, in canonical form.
pub const CompressedScalar = [encoded_length]u8;
const Fe = Field(.{
.fiat = @import("p384_scalar_64.zig"),
.field_order = 39402006196394479212279040100143613805079739270465446667946905279627659399113263569398956308152294913554433653942643,
.field_bits = 384,
.saturated_bits = 384,
.encoded_length = encoded_length,
});
/// The scalar field order.
pub const field_order = Fe.field_order;
/// Reject a scalar whose encoding is not canonical.
pub fn rejectNonCanonical(s: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!void {
return Fe.rejectNonCanonical(s, endian);
}
/// Reduce a 64-bytes scalar to the field size.
pub fn reduce64(s: [64]u8, endian: std.builtin.Endian) CompressedScalar {
return Scalar.fromBytes64(s, endian).toBytes(endian);
}
/// Return a*b (mod L)
pub fn mul(a: CompressedScalar, b: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!CompressedScalar {
return (try Scalar.fromBytes(a, endian)).mul(try Scalar.fromBytes(b, endian)).toBytes(endian);
}
/// Return a*b+c (mod L)
pub fn mulAdd(a: CompressedScalar, b: CompressedScalar, c: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!CompressedScalar {
return (try Scalar.fromBytes(a, endian)).mul(try Scalar.fromBytes(b, endian)).add(try Scalar.fromBytes(c, endian)).toBytes(endian);
}
/// Return a+b (mod L)
pub fn add(a: CompressedScalar, b: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!CompressedScalar {
return (try Scalar.fromBytes(a, endian)).add(try Scalar.fromBytes(b, endian)).toBytes(endian);
}
/// Return -s (mod L)
pub fn neg(s: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!CompressedScalar {
return (try Scalar.fromBytes(s, endian)).neg().toBytes(endian);
}
/// Return (a-b) (mod L)
pub fn sub(a: CompressedScalar, b: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!CompressedScalar {
return (try Scalar.fromBytes(a, endian)).sub(try Scalar.fromBytes(b, endian)).toBytes(endian);
}
/// Return a random scalar
pub fn random(io: std.Io, endian: std.builtin.Endian) CompressedScalar {
return Scalar.random(io).toBytes(endian);
}
/// A scalar in unpacked representation.
pub const Scalar = struct {
fe: Fe,
/// Zero.
pub const zero = Scalar{ .fe = Fe.zero };
/// One.
pub const one = Scalar{ .fe = Fe.one };
/// Unpack a serialized representation of a scalar.
pub fn fromBytes(s: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!Scalar {
return Scalar{ .fe = try Fe.fromBytes(s, endian) };
}
/// Reduce a 512 bit input to the field size.
pub fn fromBytes64(s: [64]u8, endian: std.builtin.Endian) Scalar {
const t = ScalarDouble.fromBytes(512, s, endian);
return t.reduce(512);
}
/// Pack a scalar into bytes.
pub fn toBytes(n: Scalar, endian: std.builtin.Endian) CompressedScalar {
return n.fe.toBytes(endian);
}
/// Return true if the scalar is zero..
pub fn isZero(n: Scalar) bool {
return n.fe.isZero();
}
/// Return true if the scalar is odd.
pub fn isOdd(n: Scalar) bool {
return n.fe.isOdd();
}
/// Return true if a and b are equivalent.
pub fn equivalent(a: Scalar, b: Scalar) bool {
return a.fe.equivalent(b.fe);
}
/// Compute x+y (mod L)
pub fn add(x: Scalar, y: Scalar) Scalar {
return Scalar{ .fe = x.fe.add(y.fe) };
}
/// Compute x-y (mod L)
pub fn sub(x: Scalar, y: Scalar) Scalar {
return Scalar{ .fe = x.fe.sub(y.fe) };
}
/// Compute 2n (mod L)
pub fn dbl(n: Scalar) Scalar {
return Scalar{ .fe = n.fe.dbl() };
}
/// Compute x*y (mod L)
pub fn mul(x: Scalar, y: Scalar) Scalar {
return Scalar{ .fe = x.fe.mul(y.fe) };
}
/// Compute x^2 (mod L)
pub fn sq(n: Scalar) Scalar {
return Scalar{ .fe = n.fe.sq() };
}
/// Compute x^n (mod L)
pub fn pow(a: Scalar, comptime T: type, comptime n: T) Scalar {
return Scalar{ .fe = a.fe.pow(n) };
}
/// Compute -x (mod L)
pub fn neg(n: Scalar) Scalar {
return Scalar{ .fe = n.fe.neg() };
}
/// Compute x^-1 (mod L)
pub fn invert(n: Scalar) Scalar {
return Scalar{ .fe = n.fe.invert() };
}
/// Return true if n is a quadratic residue mod L.
pub fn isSquare(n: Scalar) bool {
return n.fe.isSquare();
}
/// Return the square root of L, or NotSquare if there isn't any solutions.
pub fn sqrt(n: Scalar) NotSquareError!Scalar {
return Scalar{ .fe = try n.fe.sqrt() };
}
/// Return a random scalar < L.
pub fn random(io: std.Io) Scalar {
var s: [64]u8 = undefined;
while (true) {
io.random(&s);
const n = Scalar.fromBytes64(s, .little);
if (!n.isZero()) {
return n;
}
}
}
};
const ScalarDouble = struct {
x1: Fe,
x2: Fe,
fn fromBytes(comptime bits: usize, s_: [bits / 8]u8, endian: std.builtin.Endian) ScalarDouble {
debug.assert(bits > 0 and bits <= 512 and bits >= Fe.saturated_bits and bits <= Fe.saturated_bits * 2);
var s = s_;
if (endian == .big) {
for (s_, 0..) |x, i| s[s.len - 1 - i] = x;
}
var t = ScalarDouble{ .x1 = undefined, .x2 = Fe.zero };
{
var b: [encoded_length]u8 = @splat(0);
const len = @min(s.len, 32);
b[0..len].* = s[0..len].*;
t.x1 = Fe.fromBytes(b, .little) catch unreachable;
}
if (s_.len >= 32) {
var b: [encoded_length]u8 = @splat(0);
const len = @min(s.len - 32, 32);
b[0..len].* = s[32..][0..len].*;
t.x2 = Fe.fromBytes(b, .little) catch unreachable;
}
return t;
}
fn reduce(expanded: ScalarDouble, comptime bits: usize) Scalar {
debug.assert(bits > 0 and bits <= Fe.saturated_bits * 3 and bits <= 512);
var fe = expanded.x1;
if (bits >= 256) {
const st1 = Fe.fromInt(1 << 256) catch unreachable;
fe = fe.add(expanded.x2.mul(st1));
}
return Scalar{ .fe = fe };
}
};