跳转到内容

std.crypto.pcurves.p256.scalar

标准库Zig 0.17.0官方原文
源码std/crypto/pcurves/p256/scalar.zig

第 1 行

std.crypto.pcurves.p256.scalar.add

函数

第 56 行

返回 a+b (mod L)

pub fn add(a: CompressedScalar, b: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!CompressedScalar

参数

错误

NonCanonical NonCanonicalError

std.crypto.pcurves.p256.scalar.common

别名

第 2 行

别名目标 std.crypto.pcurves.common

std.crypto.pcurves.p256.scalar.CompressedScalar

类型

第 17 行

规范形式的压缩标量。

std.crypto.pcurves.p256.scalar.crypto

别名

第 3 行

别名目标 std.crypto

std.crypto.pcurves.p256.scalar.debug

别名

第 4 行

别名目标 std.debug

std.crypto.pcurves.p256.scalar.encoded_length

常量

第 14 行

编码标量所需的字节数。

std.crypto.pcurves.p256.scalar.Fe

类型

第 19 行

std.crypto.pcurves.p256.scalar.Field

别名

第 8 行

别名目标 std.crypto.pcurves.common.Field

std.crypto.pcurves.p256.scalar.field_order

常量

第 28 行

标量域的阶。

std.crypto.pcurves.p256.scalar.math

别名

第 5 行

别名目标 std.math

std.crypto.pcurves.p256.scalar.mem

别名

第 6 行

别名目标 std.mem

std.crypto.pcurves.p256.scalar.mul

函数

第 46 行

返回 a*b (mod L)

pub fn mul(a: CompressedScalar, b: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!CompressedScalar

参数

错误

NonCanonical NonCanonicalError

std.crypto.pcurves.p256.scalar.mulAdd

函数

第 51 行

返回 a*b+c (mod L)

pub fn mulAdd(a: CompressedScalar, b: CompressedScalar, c: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!CompressedScalar

参数

错误

NonCanonical NonCanonicalError

std.crypto.pcurves.p256.scalar.neg

函数

第 61 行

返回 -s (mod L)

pub fn neg(s: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!CompressedScalar

参数

错误

NonCanonical NonCanonicalError

std.crypto.pcurves.p256.scalar.NonCanonicalError

别名

第 10 行

别名目标 std.crypto.errors.NonCanonicalError

std.crypto.pcurves.p256.scalar.NotSquareError

别名

第 11 行

别名目标 std.crypto.errors.NotSquareError

std.crypto.pcurves.p256.scalar.random

函数

第 71 行

返回随机标量

pub fn random(io: std.Io, endian: std.builtin.Endian) CompressedScalar

参数

io: std.Io
endian: std.builtin.Endian

std.crypto.pcurves.p256.scalar.reduce48

函数

第 36 行

将 48 字节标量约减至域的大小。

pub fn reduce48(s: [48]u8, endian: std.builtin.Endian) CompressedScalar

参数

s: [48]u8
endian: std.builtin.Endian

std.crypto.pcurves.p256.scalar.reduce64

函数

第 41 行

将 64 字节标量约减到域大小。

pub fn reduce64(s: [64]u8, endian: std.builtin.Endian) CompressedScalar

参数

s: [64]u8
endian: std.builtin.Endian

std.crypto.pcurves.p256.scalar.rejectNonCanonical

函数

第 31 行

拒绝编码不规范的标量。

pub fn rejectNonCanonical(s: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!void

参数

错误

NonCanonical NonCanonicalError

std.crypto.pcurves.p256.scalar.Scalar

容器

第 76 行

采用解包表示的标量。

字段

fe: Fe

std.crypto.pcurves.p256.scalar.Scalar.add

函数

第 123 行

计算 x+y (mod L)

pub fn add(x: Scalar, y: Scalar) Scalar

参数

x: Scalar
y: Scalar

std.crypto.pcurves.p256.scalar.Scalar.dbl

函数

第 133 行

计算 2n (mod L)

pub fn dbl(n: Scalar) Scalar

参数

n: Scalar

std.crypto.pcurves.p256.scalar.Scalar.equivalent

函数

第 118 行

若 a 和 b 等价则返回 true。

pub fn equivalent(a: Scalar, b: Scalar) bool

参数

a: Scalar
b: Scalar

std.crypto.pcurves.p256.scalar.Scalar.fromBytes

函数

第 86 行

解包标量的序列化表示。

pub fn fromBytes(s: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!Scalar

参数

错误

NonCanonical NonCanonicalError

std.crypto.pcurves.p256.scalar.Scalar.fromBytes48

函数

第 91 行

将 384 位输入约减到域大小。

pub fn fromBytes48(s: [48]u8, endian: std.builtin.Endian) Scalar

参数

s: [48]u8
endian: std.builtin.Endian

std.crypto.pcurves.p256.scalar.Scalar.fromBytes64

函数

第 97 行

将 512 位输入约减到域大小。

pub fn fromBytes64(s: [64]u8, endian: std.builtin.Endian) Scalar

参数

s: [64]u8
endian: std.builtin.Endian

std.crypto.pcurves.p256.scalar.Scalar.invert

函数

第 158 行

计算 x^-1 (mod L)

pub fn invert(n: Scalar) Scalar

参数

n: Scalar

std.crypto.pcurves.p256.scalar.Scalar.isOdd

函数

第 113 行

若标量为奇数,返回 true。

pub fn isOdd(n: Scalar) bool

参数

n: Scalar

std.crypto.pcurves.p256.scalar.Scalar.isSquare

函数

第 163 行

若 n 是模 L 的二次剩余,则返回 true。

pub fn isSquare(n: Scalar) bool

参数

n: Scalar

std.crypto.pcurves.p256.scalar.Scalar.isZero

函数

第 108 行

若标量为零,则返回 true。

pub fn isZero(n: Scalar) bool

参数

n: Scalar

std.crypto.pcurves.p256.scalar.Scalar.mul

函数

第 138 行

计算 x*y (mod L)

pub fn mul(x: Scalar, y: Scalar) Scalar

参数

x: Scalar
y: Scalar

std.crypto.pcurves.p256.scalar.Scalar.neg

函数

第 153 行

计算 -x (mod L)

pub fn neg(n: Scalar) Scalar

参数

n: Scalar

std.crypto.pcurves.p256.scalar.Scalar.one

常量

第 83 行

一。

std.crypto.pcurves.p256.scalar.Scalar.pow

函数

第 148 行

计算 x^n (mod L)

pub fn pow(a: Scalar, comptime T: type, comptime n: T) Scalar

参数

a: Scalar
T: type
n: T

std.crypto.pcurves.p256.scalar.Scalar.random

函数

第 173 行

返回小于 L 的随机标量。

pub fn random(io: std.Io) Scalar

参数

io: std.Io

std.crypto.pcurves.p256.scalar.Scalar.sq

函数

第 143 行

计算 x^2 (mod L)

pub fn sq(n: Scalar) Scalar

参数

n: Scalar

std.crypto.pcurves.p256.scalar.Scalar.sqrt

函数

第 168 行

返回 L 的平方根;若无解,则返回 NotSquare。

pub fn sqrt(n: Scalar) NotSquareError!Scalar

参数

n: Scalar

错误

NotSquare NotSquareError

std.crypto.pcurves.p256.scalar.Scalar.sub

函数

第 128 行

计算 x-y (mod L)

pub fn sub(x: Scalar, y: Scalar) Scalar

参数

x: Scalar
y: Scalar

std.crypto.pcurves.p256.scalar.Scalar.toBytes

函数

第 103 行

将标量打包为字节。

pub fn toBytes(n: Scalar, endian: std.builtin.Endian) CompressedScalar

参数

n: Scalar
endian: std.builtin.Endian

std.crypto.pcurves.p256.scalar.Scalar.zero

常量

第 80 行

零。

std.crypto.pcurves.p256.scalar.ScalarDouble

容器

第 185 行

字段

x1: Fe
x2: Fe
x3: Fe

std.crypto.pcurves.p256.scalar.ScalarDouble.fromBytes

函数

第 190 行

fn fromBytes(comptime bits: usize, s_: [bits / 8]u8, endian: std.builtin.Endian) ScalarDouble

参数

bits: usize
s_: [bits / 8]u8
endian: std.builtin.Endian

std.crypto.pcurves.p256.scalar.ScalarDouble.reduce

函数

第 219 行

fn reduce(expanded: ScalarDouble, comptime bits: usize) Scalar

参数

expanded: ScalarDouble
bits: usize

std.crypto.pcurves.p256.scalar.std

别名

第 1 行

别名目标 std

std.crypto.pcurves.p256.scalar.sub

函数

第 66 行

返回 (a-b) (mod L)

pub fn sub(a: CompressedScalar, b: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!CompressedScalar

参数

错误

NonCanonical NonCanonicalError
源码

std/crypto/pcurves/p256/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;

/// 编码标量所需的字节数。
pub const encoded_length = 32;

/// 规范形式的压缩标量。
pub const CompressedScalar = [encoded_length]u8;

const Fe = Field(.{
    .fiat = @import("p256_scalar_64.zig"),
    .field_order = 115792089210356248762697446949407573529996955224135760342422259061068512044369,
    .field_bits = 256,
    .saturated_bits = 256,
    .encoded_length = encoded_length,
});

/// 标量域的阶。
pub const field_order = Fe.field_order;

/// 拒绝编码不规范的标量。
pub fn rejectNonCanonical(s: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!void {
    return Fe.rejectNonCanonical(s, endian);
}

/// 将 48 字节标量约减至域的大小。
pub fn reduce48(s: [48]u8, endian: std.builtin.Endian) CompressedScalar {
    return Scalar.fromBytes48(s, endian).toBytes(endian);
}

/// 将 64 字节标量约减到域大小。
pub fn reduce64(s: [64]u8, endian: std.builtin.Endian) CompressedScalar {
    return Scalar.fromBytes64(s, endian).toBytes(endian);
}

/// 返回 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);
}

/// 返回 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);
}

/// 返回 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);
}

/// 返回 -s (mod L)
pub fn neg(s: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!CompressedScalar {
    return (try Scalar.fromBytes(s, endian)).neg().toBytes(endian);
}

/// 返回 (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);
}

/// 返回随机标量
pub fn random(io: std.Io, endian: std.builtin.Endian) CompressedScalar {
    return Scalar.random(io).toBytes(endian);
}

/// 采用解包表示的标量。
pub const Scalar = struct {
    fe: Fe,

    /// 零。
    pub const zero = Scalar{ .fe = Fe.zero };

    /// 一。
    pub const one = Scalar{ .fe = Fe.one };

    /// 解包标量的序列化表示。
    pub fn fromBytes(s: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!Scalar {
        return Scalar{ .fe = try Fe.fromBytes(s, endian) };
    }

    /// 将 384 位输入约减到域大小。
    pub fn fromBytes48(s: [48]u8, endian: std.builtin.Endian) Scalar {
        const t = ScalarDouble.fromBytes(384, s, endian);
        return t.reduce(384);
    }

    /// 将 512 位输入约减到域大小。
    pub fn fromBytes64(s: [64]u8, endian: std.builtin.Endian) Scalar {
        const t = ScalarDouble.fromBytes(512, s, endian);
        return t.reduce(512);
    }

    /// 将标量打包为字节。
    pub fn toBytes(n: Scalar, endian: std.builtin.Endian) CompressedScalar {
        return n.fe.toBytes(endian);
    }

    /// 若标量为零,则返回 true。
    pub fn isZero(n: Scalar) bool {
        return n.fe.isZero();
    }

    /// 若标量为奇数,返回 true。
    pub fn isOdd(n: Scalar) bool {
        return n.fe.isOdd();
    }

    /// 若 a 和 b 等价则返回 true。
    pub fn equivalent(a: Scalar, b: Scalar) bool {
        return a.fe.equivalent(b.fe);
    }

    /// 计算 x+y (mod L)
    pub fn add(x: Scalar, y: Scalar) Scalar {
        return Scalar{ .fe = x.fe.add(y.fe) };
    }

    /// 计算 x-y (mod L)
    pub fn sub(x: Scalar, y: Scalar) Scalar {
        return Scalar{ .fe = x.fe.sub(y.fe) };
    }

    /// 计算 2n (mod L)
    pub fn dbl(n: Scalar) Scalar {
        return Scalar{ .fe = n.fe.dbl() };
    }

    /// 计算 x*y (mod L)
    pub fn mul(x: Scalar, y: Scalar) Scalar {
        return Scalar{ .fe = x.fe.mul(y.fe) };
    }

    /// 计算 x^2 (mod L)
    pub fn sq(n: Scalar) Scalar {
        return Scalar{ .fe = n.fe.sq() };
    }

    /// 计算 x^n (mod L)
    pub fn pow(a: Scalar, comptime T: type, comptime n: T) Scalar {
        return Scalar{ .fe = a.fe.pow(n) };
    }

    /// 计算 -x (mod L)
    pub fn neg(n: Scalar) Scalar {
        return Scalar{ .fe = n.fe.neg() };
    }

    /// 计算 x^-1 (mod L)
    pub fn invert(n: Scalar) Scalar {
        return Scalar{ .fe = n.fe.invert() };
    }

    /// 若 n 是模 L 的二次剩余,则返回 true。
    pub fn isSquare(n: Scalar) bool {
        return n.fe.isSquare();
    }

    /// 返回 L 的平方根;若无解,则返回 NotSquare。
    pub fn sqrt(n: Scalar) NotSquareError!Scalar {
        return Scalar{ .fe = try n.fe.sqrt() };
    }

    /// 返回小于 L 的随机标量。
    pub fn random(io: std.Io) Scalar {
        var s: [48]u8 = undefined;
        while (true) {
            io.random(&s);
            const n = Scalar.fromBytes48(s, .little);
            if (!n.isZero()) {
                return n;
            }
        }
    }
};

const ScalarDouble = struct {
    x1: Fe,
    x2: Fe,
    x3: 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 * 3);

        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, .x3 = Fe.zero };
        {
            var b: [encoded_length]u8 = @splat(0);
            const len = @min(s.len, 24);
            b[0..len].* = s[0..len].*;
            t.x1 = Fe.fromBytes(b, .little) catch unreachable;
        }
        if (s_.len >= 24) {
            var b: [encoded_length]u8 = @splat(0);
            const len = @min(s.len - 24, 24);
            b[0..len].* = s[24..][0..len].*;
            t.x2 = Fe.fromBytes(b, .little) catch unreachable;
        }
        if (s_.len >= 48) {
            var b: [encoded_length]u8 = @splat(0);
            const len = s.len - 48;
            b[0..len].* = s[48..][0..len].*;
            t.x3 = 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 >= 192) {
            const st1 = Fe.fromInt(1 << 192) catch unreachable;
            fe = fe.add(expanded.x2.mul(st1));
            if (bits >= 384) {
                const st2 = st1.sq();
                fe = fe.add(expanded.x3.mul(st2));
            }
        }
        return Scalar{ .fe = fe };
    }
};