跳转到内容

std.crypto.scrypt

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

第 5 行

std.crypto.scrypt.blockCopy

函数

第 28 行

fn blockCopy(dst: []align(16) u32, src: []align(16) const u32, n: usize) void

参数

dst: []align(16) u32
src: []align(16) const u32
n: usize

std.crypto.scrypt.blockMix

函数

第 74 行

fn blockMix(tmp: *align(16) [16]u32, in: []align(16) const u32, out: []align(16) u32, r: u30) void

参数

tmp: *align(16) [16]u32
in: []align(16) const u32
out: []align(16) u32
r: u30

std.crypto.scrypt.blockXor

函数

第 32 行

fn blockXor(dst: []align(16) u32, src: []align(16) const u32, n: usize) void

参数

dst: []align(16) u32
src: []align(16) const u32
n: usize

std.crypto.scrypt.crypt_format

命名空间

第 212 行

std.crypto.scrypt.crypt_format.BinValue

类型函数

第 235 行

封装的二进制值,最大大小为 max_len。

只要将二进制值编码到 PHC 格式字符串中,就必须使用此类型。 包括 salt、hash,以及密钥等其他二进制参数。

初始化后,可通过 constSlice() 函数读取实际值。

pub fn BinValue(comptime max_len: usize) type

参数

max_len: usize

字段

buf: [max_len]u8 = undefined
len: usize = 0

std.crypto.scrypt.crypt_format.BinValue.capacity

常量

第 238 行

std.crypto.scrypt.crypt_format.BinValue.constSlice

函数

第 254 行

返回包含实际值的切片。

pub fn constSlice(self: *const Self) []const u8

参数

self: *const Self

std.crypto.scrypt.crypt_format.BinValue.fromB64

函数

第 258 行

fn fromB64(self: *Self, str: []const u8) !void

参数

self: *Self
str: []const u8

std.crypto.scrypt.crypt_format.BinValue.fromSlice

函数

第 245 行

包装现有字节切片

pub fn fromSlice(slice: []const u8) EncodingError!Self

参数

slice: []const u8

错误

InvalidEncoding EncodingError
NoSpaceLeft Error

std.crypto.scrypt.crypt_format.BinValue.max_encoded_length

常量

第 239 行

std.crypto.scrypt.crypt_format.BinValue.Self

别名

第 237 行

别名目标 std.crypto.scrypt.crypt_format.BinValue

std.crypto.scrypt.crypt_format.BinValue.toB64

函数

第 265 行

fn toB64(self: *const Self, buf: []u8) ![]const u8

参数

self: *const Self
buf: []u8

std.crypto.scrypt.crypt_format.calcSize

函数

第 315 行

计算序列化 params 所需的字节数

pub fn calcSize(params: anytype) usize

std.crypto.scrypt.crypt_format.Codec

类型

第 227 行

std.crypto.scrypt.crypt_format.CustomB64Codec

类型函数

第 338 行

自定义编解码器,与常规 Base64 一样将 6 位映射为 8 位,但使用自身字母表,以小端方式编码位,且还能编码整数。

fn CustomB64Codec(comptime map: [64]u8) type

参数

map: [64]u8

std.crypto.scrypt.crypt_format.CustomB64Codec.decode

函数

第 367 行

fn decode(dst: []u8, src: []const u8) !void

参数

dst: []u8
src: []const u8

std.crypto.scrypt.crypt_format.CustomB64Codec.decodedLen

函数

第 346 行

fn decodedLen(len: usize) usize

参数

len: usize

std.crypto.scrypt.crypt_format.CustomB64Codec.encode

函数

第 383 行

fn encode(dst: []u8, src: []const u8) void

参数

dst: []u8
src: []const u8

std.crypto.scrypt.crypt_format.CustomB64Codec.encodedLen

函数

第 342 行

fn encodedLen(len: usize) usize

参数

len: usize

std.crypto.scrypt.crypt_format.CustomB64Codec.intDecode

函数

第 358 行

fn intDecode(comptime T: type, src: *const [(@bitSizeOf(T) + 5) / 6]u8) !T

参数

T: type
src: *const [(@bitSizeOf(T) + 5) / 6]u8

std.crypto.scrypt.crypt_format.CustomB64Codec.intEncode

函数

第 350 行

fn intEncode(dst: []u8, src: anytype) void

参数

dst: []u8

std.crypto.scrypt.crypt_format.CustomB64Codec.map64

常量

第 340 行

std.crypto.scrypt.crypt_format.deserialize

函数

第 284 行

将字符串反序列化为结构体 T(与 HashResult 对应)。

pub fn deserialize(comptime T: type, str: []const u8) EncodingError!T

参数

T: type
str: []const u8

错误

InvalidEncoding EncodingError
NoSpaceLeft Error

std.crypto.scrypt.crypt_format.HashResult

类型函数

第 217 行

一组 scrypt 参数的标准类型,包含盐及哈希。

pub fn HashResult(comptime crypt_max_hash_len: usize) type

参数

crypt_max_hash_len: usize

字段

ln: u6
r: u30
p: u30
salt: []const u8
hash: BinValue(crypt_max_hash_len)

std.crypto.scrypt.crypt_format.prefix

常量

第 214 行

scrypt 的字符串前缀

std.crypto.scrypt.crypt_format.saltFromBin

函数

第 277 行

将二进制数据扩展为模块化 crypt 格式的盐。

pub fn saltFromBin(comptime len: usize, salt: [len]u8) [Codec.encodedLen(len)]u8

参数

len: usize
salt: [len]u8

std.crypto.scrypt.crypt_format.serialize

函数

第 305 行

将参数序列化为模块化 crypt 格式的字符串。

pub fn serialize(params: anytype, str: []u8) EncodingError![]const u8

参数

str: []u8

错误

InvalidEncoding EncodingError
NoSpaceLeft Error

std.crypto.scrypt.crypt_format.serializeTo

函数

第 322 行

fn serializeTo(params: anytype, w: *std.Io.Writer) !void

参数

w: *std.Io.Writer

std.crypto.scrypt.CryptFormatHasher

命名空间

第 468 行

使用模块化 crypt 格式进行密码哈希和验证。

std.crypto.scrypt.CryptFormatHasher.BinValue

别名

第 469 行

别名目标 std.crypto.scrypt.crypt_format.BinValue

std.crypto.scrypt.CryptFormatHasher.create

函数

第 476 行

返回以模块化 crypt 格式编码的密码的非确定性哈希

pub fn create( allocator: mem.Allocator, password: []const u8, params: Params, buf: []u8, io: std.Io, ) HasherError![]const u8

参数

allocator: mem.Allocator
password: []const u8
params: Params
buf: []u8
io: std.Io

错误

AuthenticationFailed AuthenticationError
Canceled Cancelable

调用方请求停止异步操作。

ContextTooLong ContextTooLongError
IdentityElement IdentityElementError
InvalidEncoding EncodingError
KeyMismatch KeyMismatchError
LockedMemoryLimitExceeded SpawnError

已启用 mlockall,创建线程所需的内存将超出限制。

NoSpaceLeft Error
NonCanonical NonCanonicalError
NotSquare NotSquareError
OutOfMemory SpawnError

用户空间内存不足,无法创建线程。

OutputTooLong OutputTooLongError
PasswordVerificationFailed PasswordVerificationError
SignatureVerificationFailed SignatureVerificationError
SystemResources SpawnError

内核无法分配足够内存,为子进程分配任务结构体, 或复制调用者上下文中必须复制的部分。

ThreadQuotaExceeded SpawnError

触及系统施加的线程数量限制。 以下多种限制都可能触发此错误:

  • 达到 RLIMIT_NPROC 软资源限制,由 setrlimit(2) 设置,用于限制同一真实用户标识下的进程与线程数量。
  • 达到内核的系统级进程与线程数量限制 /proc/sys/kernel/threads-max,参见 proc(5)。
  • 达到最大 PID 数量 /proc/sys/kernel/pid_max,参见 proc(5)。
  • 达到 cgroup“进程数量”(PIDs)控制器施加的 PID 限制 pids.max。
Unexpected SpawnError
UnexpectedSubgroup UnexpectedSubgroupError
WeakParameters WeakParametersError
WeakPublicKey WeakPublicKeyError

std.crypto.scrypt.CryptFormatHasher.createWithSalt

函数

第 490 行

返回以模块化 crypt 格式编码的确定性密码哈希。 使用所提供的盐,而非随机生成盐。

pub fn createWithSalt( allocator: mem.Allocator, password: []const u8, params: Params, buf: []u8, salt_bin: *const [default_salt_len]u8, ) HasherError![]const u8

参数

allocator: mem.Allocator
password: []const u8
params: Params
buf: []u8
salt_bin: *const [default_salt_len]u8

错误

AuthenticationFailed AuthenticationError
Canceled Cancelable

调用方请求停止异步操作。

ContextTooLong ContextTooLongError
IdentityElement IdentityElementError
InvalidEncoding EncodingError
KeyMismatch KeyMismatchError
LockedMemoryLimitExceeded SpawnError

已启用 mlockall,创建线程所需的内存将超出限制。

NoSpaceLeft Error
NonCanonical NonCanonicalError
NotSquare NotSquareError
OutOfMemory SpawnError

用户空间内存不足,无法创建线程。

OutputTooLong OutputTooLongError
PasswordVerificationFailed PasswordVerificationError
SignatureVerificationFailed SignatureVerificationError
SystemResources SpawnError

内核无法分配足够内存,为子进程分配任务结构体, 或复制调用者上下文中必须复制的部分。

ThreadQuotaExceeded SpawnError

触及系统施加的线程数量限制。 以下多种限制都可能触发此错误:

  • 达到 RLIMIT_NPROC 软资源限制,由 setrlimit(2) 设置,用于限制同一真实用户标识下的进程与线程数量。
  • 达到内核的系统级进程与线程数量限制 /proc/sys/kernel/threads-max,参见 proc(5)。
  • 达到最大 PID 数量 /proc/sys/kernel/pid_max,参见 proc(5)。
  • 达到 cgroup“进程数量”(PIDs)控制器施加的 PID 限制 pids.max。
Unexpected SpawnError
UnexpectedSubgroup UnexpectedSubgroupError
WeakParameters WeakParametersError
WeakPublicKey WeakPublicKeyError

std.crypto.scrypt.CryptFormatHasher.HashResult

类型

第 470 行

std.crypto.scrypt.CryptFormatHasher.pwhash_str_length

常量

第 473 行

create() 函数返回的字符串长度。

usize

std.crypto.scrypt.CryptFormatHasher.verify

函数

第 512 行

根据模块化 crypt 格式的字符串验证密码

pub fn verify( allocator: mem.Allocator, str: []const u8, password: []const u8, ) HasherError!void

参数

allocator: mem.Allocator
str: []const u8
password: []const u8

错误

AuthenticationFailed AuthenticationError
Canceled Cancelable

调用方请求停止异步操作。

ContextTooLong ContextTooLongError
IdentityElement IdentityElementError
InvalidEncoding EncodingError
KeyMismatch KeyMismatchError
LockedMemoryLimitExceeded SpawnError

已启用 mlockall,创建线程所需的内存将超出限制。

NoSpaceLeft Error
NonCanonical NonCanonicalError
NotSquare NotSquareError
OutOfMemory SpawnError

用户空间内存不足,无法创建线程。

OutputTooLong OutputTooLongError
PasswordVerificationFailed PasswordVerificationError
SignatureVerificationFailed SignatureVerificationError
SystemResources SpawnError

内核无法分配足够内存,为子进程分配任务结构体, 或复制调用者上下文中必须复制的部分。

ThreadQuotaExceeded SpawnError

触及系统施加的线程数量限制。 以下多种限制都可能触发此错误:

  • 达到 RLIMIT_NPROC 软资源限制,由 setrlimit(2) 设置,用于限制同一真实用户标识下的进程与线程数量。
  • 达到内核的系统级进程与线程数量限制 /proc/sys/kernel/threads-max,参见 proc(5)。
  • 达到最大 PID 数量 /proc/sys/kernel/pid_max,参见 proc(5)。
  • 达到 cgroup“进程数量”(PIDs)控制器施加的 PID 限制 pids.max。
Unexpected SpawnError
UnexpectedSubgroup UnexpectedSubgroupError
WeakParameters WeakParametersError
WeakPublicKey WeakPublicKeyError

std.crypto.scrypt.crypto

别名

第 6 行

别名目标 std.crypto

std.crypto.scrypt.default_hash_len

常量

第 24 行

std.crypto.scrypt.default_salt_len

常量

第 23 行

std.crypto.scrypt.EncodingError

别名

第 18 行

别名目标 std.crypto.phc_encoding.Error

std.crypto.scrypt.Error

别名

第 19 行

别名目标 std.crypto.pwhash.Error

std.crypto.scrypt.fmt

别名

第 7 行

别名目标 std.fmt

std.crypto.scrypt.HasherError

别名

第 17 行

别名目标 std.crypto.pwhash.HasherError

std.crypto.scrypt.HashOptions

容器

第 531 行

密码哈希选项。

scrypt 需要分配器。

字段

allocator: ?mem.Allocator
params: Params
encoding: pwhash.Encoding

std.crypto.scrypt.HmacSha256

别名

第 15 行

别名目标 std.crypto.hmac.sha2.HmacSha256

std.crypto.scrypt.integerify

函数

第 83 行

fn integerify(b: []align(16) const u32, r: u30) u64

参数

b: []align(16) const u32
r: u30

std.crypto.scrypt.kdf

函数

第 178 行

应用 scrypt 从密码生成密钥。

scrypt 定义于 RFC 7914。

allocator:mem.Allocator。

derived_key:用于存放生成密钥、大小适当的切片,通常长 16 或 32 字节。 可以未初始化;所有字节均会被覆写。 最大大小为 derived_key.len / 32 == 0xffff_ffff。

password:任意长度的字节序列。

salt:任意长度的字节序列。

params:Params。

pub fn kdf( allocator: mem.Allocator, derived_key: []u8, password: []const u8, salt: []const u8, params: Params, ) KdfError!void

参数

allocator: mem.Allocator
derived_key: []u8
password: []const u8
salt: []const u8
params: Params

错误

AuthenticationFailed AuthenticationError
Canceled Cancelable

调用方请求停止异步操作。

ContextTooLong ContextTooLongError
IdentityElement IdentityElementError
InvalidEncoding EncodingError
KeyMismatch KeyMismatchError
LockedMemoryLimitExceeded SpawnError

已启用 mlockall,创建线程所需的内存将超出限制。

NonCanonical NonCanonicalError
NotSquare NotSquareError
OutOfMemory SpawnError

用户空间内存不足,无法创建线程。

OutputTooLong OutputTooLongError
PasswordVerificationFailed PasswordVerificationError
SignatureVerificationFailed SignatureVerificationError
SystemResources SpawnError

内核无法分配足够内存,为子进程分配任务结构体, 或复制调用者上下文中必须复制的部分。

ThreadQuotaExceeded SpawnError

触及系统施加的线程数量限制。 以下多种限制都可能触发此错误:

  • 达到 RLIMIT_NPROC 软资源限制,由 setrlimit(2) 设置,用于限制同一真实用户标识下的进程与线程数量。
  • 达到内核的系统级进程与线程数量限制 /proc/sys/kernel/threads-max,参见 proc(5)。
  • 达到最大 PID 数量 /proc/sys/kernel/pid_max,参见 proc(5)。
  • 达到 cgroup“进程数量”(PIDs)控制器施加的 PID 限制 pids.max。
Unexpected SpawnError
UnexpectedSubgroup UnexpectedSubgroupError
WeakParameters WeakParametersError
WeakPublicKey WeakPublicKeyError

std.crypto.scrypt.KdfError

别名

第 16 行

别名目标 std.crypto.pwhash.KdfError

std.crypto.scrypt.math

别名

第 8 行

别名目标 std.math

std.crypto.scrypt.max_hash_len

常量

第 26 行

std.crypto.scrypt.max_int

常量

第 22 行

std.crypto.scrypt.max_salt_len

常量

第 25 行

std.crypto.scrypt.max_size

常量

第 21 行

std.crypto.scrypt.mem

别名

第 9 行

别名目标 std.mem

std.crypto.scrypt.meta

别名

第 10 行

别名目标 std.meta

std.crypto.scrypt.Params

容器

第 123 行

Scrypt 参数

字段

ln: u6

CPU/内存成本参数 [ln] 为 log2(N)。

r: u30

[r]esource 资源使用参数指定块大小。

p: u30

[p]arallelization 并行化参数。 较大的 [p] 值可增加 scrypt 的计算开销,而 不增加内存使用量。

std.crypto.scrypt.Params.fromLimits

函数

第 148 行

根据操作次数和内存限制创建参数,其中 mem_limit 以字节为单位

pub fn fromLimits(ops_limit: u64, mem_limit: usize) Self

参数

ops_limit: u64
mem_limit: usize

std.crypto.scrypt.Params.interactive

常量

第 138 行

交互式登录的基准参数

std.crypto.scrypt.Params.owasp

常量

第 145 行

根据 OWASP 备忘单 推荐的参数。

std.crypto.scrypt.Params.Self

别名

第 124 行

别名目标 std.crypto.scrypt.Params

std.crypto.scrypt.Params.sensitive

常量

第 141 行

离线使用的基准参数

std.crypto.scrypt.phc_format

别名

第 13 行

别名目标 std.crypto.phc_encoding

std.crypto.scrypt.PhcFormatHasher

命名空间

第 401 行

使用 PHC 格式对密码进行哈希和验证。

std.crypto.scrypt.PhcFormatHasher.alg_id

常量

第 402 行

std.crypto.scrypt.PhcFormatHasher.BinValue

别名

第 403 行

别名目标 std.crypto.phc_encoding.BinValue

std.crypto.scrypt.PhcFormatHasher.create

函数

第 415 行

返回密码的非确定性哈希,编码为 PHC 格式字符串

pub fn create( allocator: mem.Allocator, password: []const u8, params: Params, buf: []u8, io: std.Io, ) HasherError![]const u8

参数

allocator: mem.Allocator
password: []const u8
params: Params
buf: []u8
io: std.Io

错误

AuthenticationFailed AuthenticationError
Canceled Cancelable

调用方请求停止异步操作。

ContextTooLong ContextTooLongError
IdentityElement IdentityElementError
InvalidEncoding EncodingError
KeyMismatch KeyMismatchError
LockedMemoryLimitExceeded SpawnError

已启用 mlockall,创建线程所需的内存将超出限制。

NoSpaceLeft Error
NonCanonical NonCanonicalError
NotSquare NotSquareError
OutOfMemory SpawnError

用户空间内存不足,无法创建线程。

OutputTooLong OutputTooLongError
PasswordVerificationFailed PasswordVerificationError
SignatureVerificationFailed SignatureVerificationError
SystemResources SpawnError

内核无法分配足够内存,为子进程分配任务结构体, 或复制调用者上下文中必须复制的部分。

ThreadQuotaExceeded SpawnError

触及系统施加的线程数量限制。 以下多种限制都可能触发此错误:

  • 达到 RLIMIT_NPROC 软资源限制,由 setrlimit(2) 设置,用于限制同一真实用户标识下的进程与线程数量。
  • 达到内核的系统级进程与线程数量限制 /proc/sys/kernel/threads-max,参见 proc(5)。
  • 达到最大 PID 数量 /proc/sys/kernel/pid_max,参见 proc(5)。
  • 达到 cgroup“进程数量”(PIDs)控制器施加的 PID 限制 pids.max。
Unexpected SpawnError
UnexpectedSubgroup UnexpectedSubgroupError
WeakParameters WeakParametersError
WeakPublicKey WeakPublicKeyError

std.crypto.scrypt.PhcFormatHasher.createWithSalt

函数

第 429 行

返回密码的确定性哈希,编码为 PHC 格式字符串。 使用提供的盐值,而非随机生成盐值。

pub fn createWithSalt( allocator: mem.Allocator, password: []const u8, params: Params, buf: []u8, salt: *const [default_salt_len]u8, ) HasherError![]const u8

参数

allocator: mem.Allocator
password: []const u8
params: Params
buf: []u8
salt: *const [default_salt_len]u8

错误

AuthenticationFailed AuthenticationError
Canceled Cancelable

调用方请求停止异步操作。

ContextTooLong ContextTooLongError
IdentityElement IdentityElementError
InvalidEncoding EncodingError
KeyMismatch KeyMismatchError
LockedMemoryLimitExceeded SpawnError

已启用 mlockall,创建线程所需的内存将超出限制。

NoSpaceLeft Error
NonCanonical NonCanonicalError
NotSquare NotSquareError
OutOfMemory SpawnError

用户空间内存不足,无法创建线程。

OutputTooLong OutputTooLongError
PasswordVerificationFailed PasswordVerificationError
SignatureVerificationFailed SignatureVerificationError
SystemResources SpawnError

内核无法分配足够内存,为子进程分配任务结构体, 或复制调用者上下文中必须复制的部分。

ThreadQuotaExceeded SpawnError

触及系统施加的线程数量限制。 以下多种限制都可能触发此错误:

  • 达到 RLIMIT_NPROC 软资源限制,由 setrlimit(2) 设置,用于限制同一真实用户标识下的进程与线程数量。
  • 达到内核的系统级进程与线程数量限制 /proc/sys/kernel/threads-max,参见 proc(5)。
  • 达到最大 PID 数量 /proc/sys/kernel/pid_max,参见 proc(5)。
  • 达到 cgroup“进程数量”(PIDs)控制器施加的 PID 限制 pids.max。
Unexpected SpawnError
UnexpectedSubgroup UnexpectedSubgroupError
WeakParameters WeakParametersError
WeakPublicKey WeakPublicKeyError

std.crypto.scrypt.PhcFormatHasher.HashResult

容器

第 405 行

字段

alg_id: []const u8
ln: u6
r: u30
p: u30
salt: BinValue(max_salt_len)
hash: BinValue(max_hash_len)

std.crypto.scrypt.PhcFormatHasher.verify

函数

第 450 行

根据 PHC 格式编码字符串验证密码

pub fn verify( allocator: mem.Allocator, str: []const u8, password: []const u8, ) HasherError!void

参数

allocator: mem.Allocator
str: []const u8
password: []const u8

错误

AuthenticationFailed AuthenticationError
Canceled Cancelable

调用方请求停止异步操作。

ContextTooLong ContextTooLongError
IdentityElement IdentityElementError
InvalidEncoding EncodingError
KeyMismatch KeyMismatchError
LockedMemoryLimitExceeded SpawnError

已启用 mlockall,创建线程所需的内存将超出限制。

NoSpaceLeft Error
NonCanonical NonCanonicalError
NotSquare NotSquareError
OutOfMemory SpawnError

用户空间内存不足,无法创建线程。

OutputTooLong OutputTooLongError
PasswordVerificationFailed PasswordVerificationError
SignatureVerificationFailed SignatureVerificationError
SystemResources SpawnError

内核无法分配足够内存,为子进程分配任务结构体, 或复制调用者上下文中必须复制的部分。

ThreadQuotaExceeded SpawnError

触及系统施加的线程数量限制。 以下多种限制都可能触发此错误:

  • 达到 RLIMIT_NPROC 软资源限制,由 setrlimit(2) 设置,用于限制同一真实用户标识下的进程与线程数量。
  • 达到内核的系统级进程与线程数量限制 /proc/sys/kernel/threads-max,参见 proc(5)。
  • 达到最大 PID 数量 /proc/sys/kernel/pid_max,参见 proc(5)。
  • 达到 cgroup“进程数量”(PIDs)控制器施加的 PID 限制 pids.max。
Unexpected SpawnError
UnexpectedSubgroup UnexpectedSubgroupError
WeakParameters WeakParametersError
WeakPublicKey WeakPublicKeyError

std.crypto.scrypt.pwhash

别名

第 11 行

别名目标 std.crypto.pwhash

std.crypto.scrypt.QuarterRound

容器

第 38 行

字段

a: usize
b: usize
c: usize
d: u6

std.crypto.scrypt.Rp

函数

第 40 行

fn Rp(a: usize, b: usize, c: usize, d: u6) QuarterRound

参数

a: usize
b: usize
c: usize
d: u6

std.crypto.scrypt.run_long_tests

原始类型

第 587 行

std.crypto.scrypt.salsa8core

函数

第 44 行

fn salsa8core(b: *align(16) [16]u32) void

参数

b: *align(16) [16]u32

std.crypto.scrypt.salsaXor

函数

第 68 行

fn salsaXor(tmp: *align(16) [16]u32, in: []align(16) const u32, out: []align(16) u32) void

参数

tmp: *align(16) [16]u32
in: []align(16) const u32
out: []align(16) u32

std.crypto.scrypt.smix

函数

第 88 行

fn smix(b: []align(16) u8, r: u30, n: usize, v: []align(16) u32, xy: []align(16) u32) void

参数

b: []align(16) u8
r: u30
n: usize
v: []align(16) u32
xy: []align(16) u32

std.crypto.scrypt.std

别名

第 5 行

别名目标 std

std.crypto.scrypt.strHash

函数

第 539 行

使用 scrypt 密钥派生函数计算口令哈希。 返回的字符串包含验证所需的全部参数。

pub fn strHash( password: []const u8, options: HashOptions, out: []u8, io: std.Io, ) Error![]const u8

参数

password: []const u8
options: HashOptions
out: []u8
io: std.Io

错误

AllocatorRequired Error
AuthenticationFailed AuthenticationError
Canceled Cancelable

调用方请求停止异步操作。

ContextTooLong ContextTooLongError
IdentityElement IdentityElementError
InvalidEncoding EncodingError
KeyMismatch KeyMismatchError
LockedMemoryLimitExceeded SpawnError

已启用 mlockall,创建线程所需的内存将超出限制。

NoSpaceLeft Error
NonCanonical NonCanonicalError
NotSquare NotSquareError
OutOfMemory SpawnError

用户空间内存不足,无法创建线程。

OutputTooLong OutputTooLongError
PasswordVerificationFailed PasswordVerificationError
SignatureVerificationFailed SignatureVerificationError
SystemResources SpawnError

内核无法分配足够内存,为子进程分配任务结构体, 或复制调用者上下文中必须复制的部分。

ThreadQuotaExceeded SpawnError

触及系统施加的线程数量限制。 以下多种限制都可能触发此错误:

  • 达到 RLIMIT_NPROC 软资源限制,由 setrlimit(2) 设置,用于限制同一真实用户标识下的进程与线程数量。
  • 达到内核的系统级进程与线程数量限制 /proc/sys/kernel/threads-max,参见 proc(5)。
  • 达到最大 PID 数量 /proc/sys/kernel/pid_max,参见 proc(5)。
  • 达到 cgroup“进程数量”(PIDs)控制器施加的 PID 限制 pids.max。
Unexpected SpawnError
UnexpectedSubgroup UnexpectedSubgroupError
WeakParameters WeakParametersError
WeakPublicKey WeakPublicKeyError

std.crypto.scrypt.strHashWithSalt

函数

第 555 行

使用 scrypt 密钥派生函数确定性地计算密码哈希。 返回包含验证所需全部参数的字符串。 使用提供的盐,而非随机生成。

pub fn strHashWithSalt( password: []const u8, options: HashOptions, out: []u8, salt: *const [default_salt_len]u8, ) Error![]const u8

参数

password: []const u8
options: HashOptions
out: []u8
salt: *const [default_salt_len]u8

错误

AllocatorRequired Error
AuthenticationFailed AuthenticationError
Canceled Cancelable

调用方请求停止异步操作。

ContextTooLong ContextTooLongError
IdentityElement IdentityElementError
InvalidEncoding EncodingError
KeyMismatch KeyMismatchError
LockedMemoryLimitExceeded SpawnError

已启用 mlockall,创建线程所需的内存将超出限制。

NoSpaceLeft Error
NonCanonical NonCanonicalError
NotSquare NotSquareError
OutOfMemory SpawnError

用户空间内存不足,无法创建线程。

OutputTooLong OutputTooLongError
PasswordVerificationFailed PasswordVerificationError
SignatureVerificationFailed SignatureVerificationError
SystemResources SpawnError

内核无法分配足够内存,为子进程分配任务结构体, 或复制调用者上下文中必须复制的部分。

ThreadQuotaExceeded SpawnError

触及系统施加的线程数量限制。 以下多种限制都可能触发此错误:

  • 达到 RLIMIT_NPROC 软资源限制,由 setrlimit(2) 设置,用于限制同一真实用户标识下的进程与线程数量。
  • 达到内核的系统级进程与线程数量限制 /proc/sys/kernel/threads-max,参见 proc(5)。
  • 达到最大 PID 数量 /proc/sys/kernel/pid_max,参见 proc(5)。
  • 达到 cgroup“进程数量”(PIDs)控制器施加的 PID 限制 pids.max。
Unexpected SpawnError
UnexpectedSubgroup UnexpectedSubgroupError
WeakParameters WeakParametersError
WeakPublicKey WeakPublicKeyError

std.crypto.scrypt.strVerify

函数

第 574 行

验证先前计算的哈希对给定密码是否有效。

pub fn strVerify( str: []const u8, password: []const u8, options: VerifyOptions, ) Error!void

参数

str: []const u8
password: []const u8
options: VerifyOptions

错误

AllocatorRequired Error
AuthenticationFailed AuthenticationError
Canceled Cancelable

调用方请求停止异步操作。

ContextTooLong ContextTooLongError
IdentityElement IdentityElementError
InvalidEncoding EncodingError
KeyMismatch KeyMismatchError
LockedMemoryLimitExceeded SpawnError

已启用 mlockall,创建线程所需的内存将超出限制。

NoSpaceLeft Error
NonCanonical NonCanonicalError
NotSquare NotSquareError
OutOfMemory SpawnError

用户空间内存不足,无法创建线程。

OutputTooLong OutputTooLongError
PasswordVerificationFailed PasswordVerificationError
SignatureVerificationFailed SignatureVerificationError
SystemResources SpawnError

内核无法分配足够内存,为子进程分配任务结构体, 或复制调用者上下文中必须复制的部分。

ThreadQuotaExceeded SpawnError

触及系统施加的线程数量限制。 以下多种限制都可能触发此错误:

  • 达到 RLIMIT_NPROC 软资源限制,由 setrlimit(2) 设置,用于限制同一真实用户标识下的进程与线程数量。
  • 达到内核的系统级进程与线程数量限制 /proc/sys/kernel/threads-max,参见 proc(5)。
  • 达到最大 PID 数量 /proc/sys/kernel/pid_max,参见 proc(5)。
  • 达到 cgroup“进程数量”(PIDs)控制器施加的 PID 限制 pids.max。
Unexpected SpawnError
UnexpectedSubgroup UnexpectedSubgroupError
WeakParameters WeakParametersError
WeakPublicKey WeakPublicKeyError

std.crypto.scrypt.VerifyOptions

容器

第 569 行

哈希校验选项。

字段

allocator: mem.Allocator
源码

std/crypto/scrypt.zig

// https://tools.ietf.org/html/rfc7914
// https://github.com/golang/crypto/blob/master/scrypt/scrypt.go
// https://github.com/Tarsnap/scrypt

const std = @import("std");
const crypto = std.crypto;
const fmt = std.fmt;
const math = std.math;
const mem = std.mem;
const meta = std.meta;
const pwhash = crypto.pwhash;

const phc_format = @import("phc_encoding.zig");

const HmacSha256 = crypto.auth.hmac.sha2.HmacSha256;
const KdfError = pwhash.KdfError;
const HasherError = pwhash.HasherError;
const EncodingError = phc_format.Error;
const Error = pwhash.Error;

const max_size = math.maxInt(usize);
const max_int = max_size >> 1;
pub const default_salt_len = 32;
const default_hash_len = 32;
const max_salt_len = 64;
const max_hash_len = 64;

fn blockCopy(dst: []align(16) u32, src: []align(16) const u32, n: usize) void {
    @memcpy(dst[0 .. n * 16], src[0 .. n * 16]);
}

fn blockXor(dst: []align(16) u32, src: []align(16) const u32, n: usize) void {
    for (src[0 .. n * 16], 0..) |v, i| {
        dst[i] ^= v;
    }
}

const QuarterRound = struct { a: usize, b: usize, c: usize, d: u6 };

fn Rp(a: usize, b: usize, c: usize, d: u6) QuarterRound {
    return QuarterRound{ .a = a, .b = b, .c = c, .d = d };
}

fn salsa8core(b: *align(16) [16]u32) void {
    const arx_steps = comptime [_]QuarterRound{
        Rp(4, 0, 12, 7),   Rp(8, 4, 0, 9),    Rp(12, 8, 4, 13),   Rp(0, 12, 8, 18),
        Rp(9, 5, 1, 7),    Rp(13, 9, 5, 9),   Rp(1, 13, 9, 13),   Rp(5, 1, 13, 18),
        Rp(14, 10, 6, 7),  Rp(2, 14, 10, 9),  Rp(6, 2, 14, 13),   Rp(10, 6, 2, 18),
        Rp(3, 15, 11, 7),  Rp(7, 3, 15, 9),   Rp(11, 7, 3, 13),   Rp(15, 11, 7, 18),
        Rp(1, 0, 3, 7),    Rp(2, 1, 0, 9),    Rp(3, 2, 1, 13),    Rp(0, 3, 2, 18),
        Rp(6, 5, 4, 7),    Rp(7, 6, 5, 9),    Rp(4, 7, 6, 13),    Rp(5, 4, 7, 18),
        Rp(11, 10, 9, 7),  Rp(8, 11, 10, 9),  Rp(9, 8, 11, 13),   Rp(10, 9, 8, 18),
        Rp(12, 15, 14, 7), Rp(13, 12, 15, 9), Rp(14, 13, 12, 13), Rp(15, 14, 13, 18),
    };
    var x = b.*;
    var j: usize = 0;
    while (j < 8) : (j += 2) {
        inline for (arx_steps) |r| {
            x[r.a] ^= math.rotl(u32, x[r.b] +% x[r.c], r.d);
        }
    }
    j = 0;
    while (j < 16) : (j += 1) {
        b[j] +%= x[j];
    }
}

fn salsaXor(tmp: *align(16) [16]u32, in: []align(16) const u32, out: []align(16) u32) void {
    blockXor(tmp, in, 1);
    salsa8core(tmp);
    blockCopy(out, tmp, 1);
}

fn blockMix(tmp: *align(16) [16]u32, in: []align(16) const u32, out: []align(16) u32, r: u30) void {
    blockCopy(tmp, @alignCast(in[(2 * r - 1) * 16 ..]), 1);
    var i: usize = 0;
    while (i < 2 * r) : (i += 2) {
        salsaXor(tmp, @alignCast(in[i * 16 ..]), @alignCast(out[i * 8 ..]));
        salsaXor(tmp, @alignCast(in[i * 16 + 16 ..]), @alignCast(out[i * 8 + r * 16 ..]));
    }
}

fn integerify(b: []align(16) const u32, r: u30) u64 {
    const j = (2 * r - 1) * 16;
    return @as(u64, b[j]) | @as(u64, b[j + 1]) << 32;
}

fn smix(b: []align(16) u8, r: u30, n: usize, v: []align(16) u32, xy: []align(16) u32) void {
    const x: []align(16) u32 = @alignCast(xy[0 .. 32 * r]);
    const y: []align(16) u32 = @alignCast(xy[32 * r ..]);

    for (x, 0..) |*v1, j| {
        v1.* = mem.readInt(u32, b[4 * j ..][0..4], .little);
    }

    var tmp: [16]u32 align(16) = undefined;
    var i: usize = 0;
    while (i < n) : (i += 2) {
        blockCopy(@alignCast(v[i * (32 * r) ..]), x, 2 * r);
        blockMix(&tmp, x, y, r);

        blockCopy(@alignCast(v[(i + 1) * (32 * r) ..]), y, 2 * r);
        blockMix(&tmp, y, x, r);
    }

    i = 0;
    while (i < n) : (i += 2) {
        var j = @as(usize, @intCast(integerify(x, r) & (n - 1)));
        blockXor(x, @alignCast(v[j * (32 * r) ..]), 2 * r);
        blockMix(&tmp, x, y, r);

        j = @as(usize, @intCast(integerify(y, r) & (n - 1)));
        blockXor(y, @alignCast(v[j * (32 * r) ..]), 2 * r);
        blockMix(&tmp, y, x, r);
    }

    for (x, 0..) |v1, j| {
        mem.writeInt(u32, b[4 * j ..][0..4], v1, .little);
    }
}

/// Scrypt 参数
pub const Params = struct {
    const Self = @This();

    /// CPU/内存成本参数 [ln] 为 log2(N)。
    ln: u6,

    /// [r]esource 资源使用参数指定块大小。
    r: u30,

    /// [p]arallelization 并行化参数。
    /// 较大的 [p] 值可增加 scrypt 的计算开销,而
    /// 不增加内存使用量。
    p: u30,

    /// 交互式登录的基准参数
    pub const interactive = Self.fromLimits(524288, 16777216);

    /// 离线使用的基准参数
    pub const sensitive = Self.fromLimits(33554432, 1073741824);

    /// 根据 [OWASP 备忘单](https://cheatsheetseries.owasp.org/cheatsheets/Password_Storage_Cheat_Sheet.html)
    /// 推荐的参数。
    pub const owasp = Self{ .ln = 17, .r = 8, .p = 1 };

    /// 根据操作次数和内存限制创建参数,其中 mem_limit 以字节为单位
    pub fn fromLimits(ops_limit: u64, mem_limit: usize) Self {
        const ops = @max(32768, ops_limit);
        const r: u30 = 8;
        if (ops < mem_limit / 32) {
            const max_n = ops / (r * 4);
            return Self{ .r = r, .p = 1, .ln = @as(u6, @intCast(math.log2(max_n))) };
        } else {
            const max_n = mem_limit / (@as(usize, @intCast(r)) * 128);
            const ln = @as(u6, @intCast(math.log2(max_n)));
            const max_rp = @min(0x3fffffff, (ops / 4) / (@as(u64, 1) << ln));
            return Self{ .r = r, .p = @as(u30, @intCast(max_rp / @as(u64, r))), .ln = ln };
        }
    }
};

/// 应用 scrypt 从密码生成密钥。
///
/// scrypt 定义于 RFC 7914。
///
/// allocator:mem.Allocator。
///
/// derived_key:用于存放生成密钥、大小适当的切片,通常长 16 或 32 字节。
///              可以未初始化;所有字节均会被覆写。
///              最大大小为 `derived_key.len / 32 == 0xffff_ffff`。
///
/// password:任意长度的字节序列。
///
/// salt:任意长度的字节序列。
///
/// params:Params。
pub fn kdf(
    allocator: mem.Allocator,
    derived_key: []u8,
    password: []const u8,
    salt: []const u8,
    params: Params,
) KdfError!void {
    if (derived_key.len == 0) return KdfError.WeakParameters;
    if (derived_key.len / 32 > 0xffff_ffff) return KdfError.OutputTooLong;
    if (params.ln == 0 or params.r == 0 or params.p == 0) return KdfError.WeakParameters;

    const n64 = @as(u64, 1) << params.ln;
    if (n64 > max_size) return KdfError.WeakParameters;
    const n = @as(usize, @intCast(n64));
    if (@as(u64, params.r) * @as(u64, params.p) >= 1 << 30 or
        params.r > max_int / 128 / @as(u64, params.p) or
        params.r > max_int / 256 or
        n > max_int / 128 / @as(u64, params.r)) return KdfError.WeakParameters;

    const xy = try allocator.alignedAlloc(u32, .@"16", 64 * params.r);
    defer allocator.free(xy);
    const v = try allocator.alignedAlloc(u32, .@"16", 32 * n * params.r);
    defer allocator.free(v);
    var dk = try allocator.alignedAlloc(u8, .@"16", params.p * 128 * params.r);
    defer allocator.free(dk);

    try pwhash.pbkdf2(dk, password, salt, 1, HmacSha256);
    var i: u32 = 0;
    while (i < params.p) : (i += 1) {
        smix(@alignCast(dk[i * 128 * params.r ..]), params.r, n, v, xy);
    }
    try pwhash.pbkdf2(derived_key, password, dk, 1, HmacSha256);
}

const crypt_format = struct {
    /// scrypt 的字符串前缀
    pub const prefix = "$7$";

    /// 一组 scrypt 参数的标准类型,包含盐及哈希。
    pub fn HashResult(comptime crypt_max_hash_len: usize) type {
        return struct {
            ln: u6,
            r: u30,
            p: u30,
            salt: []const u8,
            hash: BinValue(crypt_max_hash_len),
        };
    }

    const Codec = CustomB64Codec("./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".*);

    /// 封装的二进制值,最大大小为 `max_len`。
    ///
    /// 只要将二进制值编码到 PHC 格式字符串中,就必须使用此类型。
    /// 包括 `salt`、`hash`,以及密钥等其他二进制参数。
    ///
    /// 初始化后,可通过 `constSlice()` 函数读取实际值。
    pub fn BinValue(comptime max_len: usize) type {
        return struct {
            const Self = @This();
            const capacity = max_len;
            const max_encoded_length = Codec.encodedLen(max_len);

            buf: [max_len]u8 = undefined,
            len: usize = 0,

            /// 包装现有字节切片
            pub fn fromSlice(slice: []const u8) EncodingError!Self {
                if (slice.len > capacity) return EncodingError.NoSpaceLeft;
                var bin_value: Self = undefined;
                @memcpy(bin_value.buf[0..slice.len], slice);
                bin_value.len = slice.len;
                return bin_value;
            }

            /// 返回包含实际值的切片。
            pub fn constSlice(self: *const Self) []const u8 {
                return self.buf[0..self.len];
            }

            fn fromB64(self: *Self, str: []const u8) !void {
                const len = Codec.decodedLen(str.len);
                if (len > self.buf.len) return EncodingError.NoSpaceLeft;
                try Codec.decode(self.buf[0..len], str);
                self.len = len;
            }

            fn toB64(self: *const Self, buf: []u8) ![]const u8 {
                const value = self.constSlice();
                const len = Codec.encodedLen(value.len);
                if (len > buf.len) return EncodingError.NoSpaceLeft;
                const encoded = buf[0..len];
                Codec.encode(encoded, value);
                return encoded;
            }
        };
    }

    /// 将二进制数据扩展为模块化 crypt 格式的盐。
    pub fn saltFromBin(comptime len: usize, salt: [len]u8) [Codec.encodedLen(len)]u8 {
        var buf: [Codec.encodedLen(len)]u8 = undefined;
        Codec.encode(&buf, &salt);
        return buf;
    }

    /// 将字符串反序列化为结构体 `T`(与 `HashResult` 对应)。
    pub fn deserialize(comptime T: type, str: []const u8) EncodingError!T {
        var out: T = undefined;

        if (str.len < 16) return EncodingError.InvalidEncoding;
        if (!mem.eql(u8, prefix, str[0..3])) return EncodingError.InvalidEncoding;
        out.ln = try Codec.intDecode(u6, str[3..4]);
        out.r = try Codec.intDecode(u30, str[4..9]);
        out.p = try Codec.intDecode(u30, str[9..14]);

        var it = mem.splitScalar(u8, str[14..], '$');

        const salt = it.first();
        if (@hasField(T, "salt")) out.salt = salt;

        const hash_str = it.next() orelse return EncodingError.InvalidEncoding;
        if (@hasField(T, "hash")) try out.hash.fromB64(hash_str);

        return out;
    }

    /// 将参数序列化为模块化 crypt 格式的字符串。
    pub fn serialize(params: anytype, str: []u8) EncodingError![]const u8 {
        var w: std.Io.Writer = .fixed(str);
        serializeTo(params, &w) catch |err| switch (err) {
            error.WriteFailed => return error.NoSpaceLeft,
            else => |e| return e,
        };
        return w.buffered();
    }

    /// 计算序列化 `params` 所需的字节数
    pub fn calcSize(params: anytype) usize {
        var trash: [128]u8 = undefined;
        var d: std.Io.Writer.Discarding = .init(&trash);
        serializeTo(params, &d.writer) catch unreachable;
        return @intCast(d.fullCount());
    }

    fn serializeTo(params: anytype, w: *std.Io.Writer) !void {
        var header: [14]u8 = undefined;
        header[0..3].* = prefix.*;
        Codec.intEncode(header[3..4], params.ln);
        Codec.intEncode(header[4..9], params.r);
        Codec.intEncode(header[9..14], params.p);
        try w.writeAll(&header);
        try w.writeAll(params.salt);
        try w.writeAll("$");
        var buf: [@TypeOf(params.hash).max_encoded_length]u8 = undefined;
        const hash_str = try params.hash.toB64(&buf);
        try w.writeAll(hash_str);
    }

    /// 自定义编解码器,与常规 Base64 一样将 6 位映射为 8 位,但使用自身字母表,以小端方式编码位,且还能编码整数。
    ///
    fn CustomB64Codec(comptime map: [64]u8) type {
        return struct {
            const map64 = map;

            fn encodedLen(len: usize) usize {
                return (len * 4 + 2) / 3;
            }

            fn decodedLen(len: usize) usize {
                return len / 4 * 3 + (len % 4) * 3 / 4;
            }

            fn intEncode(dst: []u8, src: anytype) void {
                var n = src;
                for (dst) |*x| {
                    x.* = map64[@as(u6, @truncate(n))];
                    n = math.shr(@TypeOf(src), n, 6);
                }
            }

            fn intDecode(comptime T: type, src: *const [(@bitSizeOf(T) + 5) / 6]u8) !T {
                var v: T = 0;
                for (src, 0..) |x, i| {
                    const vi = mem.findScalar(u8, &map64, x) orelse return EncodingError.InvalidEncoding;
                    v |= @as(T, @intCast(vi)) << @as(math.Log2Int(T), @intCast(i * 6));
                }
                return v;
            }

            fn decode(dst: []u8, src: []const u8) !void {
                std.debug.assert(dst.len == decodedLen(src.len));
                var i: usize = 0;
                while (i < src.len / 4) : (i += 1) {
                    mem.writeInt(u24, dst[i * 3 ..][0..3], try intDecode(u24, src[i * 4 ..][0..4]), .little);
                }
                const leftover = src[i * 4 ..];
                var v: u24 = 0;
                for (leftover, 0..) |_, j| {
                    v |= @as(u24, try intDecode(u6, leftover[j..][0..1])) << @as(u5, @intCast(j * 6));
                }
                for (dst[i * 3 ..], 0..) |*x, j| {
                    x.* = @as(u8, @truncate(v >> @as(u5, @intCast(j * 8))));
                }
            }

            fn encode(dst: []u8, src: []const u8) void {
                std.debug.assert(dst.len == encodedLen(src.len));
                var i: usize = 0;
                while (i < src.len / 3) : (i += 1) {
                    intEncode(dst[i * 4 ..][0..4], mem.readInt(u24, src[i * 3 ..][0..3], .little));
                }
                const leftover = src[i * 3 ..];
                var v: u24 = 0;
                for (leftover, 0..) |x, j| {
                    v |= @as(u24, x) << @as(u5, @intCast(j * 8));
                }
                intEncode(dst[i * 4 ..], v);
            }
        };
    }
};

/// 使用 PHC 格式对密码进行哈希和验证。
const PhcFormatHasher = struct {
    const alg_id = "scrypt";
    const BinValue = phc_format.BinValue;

    const HashResult = struct {
        alg_id: []const u8,
        ln: u6,
        r: u30,
        p: u30,
        salt: BinValue(max_salt_len),
        hash: BinValue(max_hash_len),
    };

    /// 返回密码的非确定性哈希,编码为 PHC 格式字符串
    pub fn create(
        allocator: mem.Allocator,
        password: []const u8,
        params: Params,
        buf: []u8,
        io: std.Io,
    ) HasherError![]const u8 {
        var salt: [default_salt_len]u8 = undefined;
        io.random(&salt);
        return createWithSalt(allocator, password, params, buf, &salt);
    }

    /// 返回密码的确定性哈希,编码为 PHC 格式字符串。
    /// 使用提供的盐值,而非随机生成盐值。
    pub fn createWithSalt(
        allocator: mem.Allocator,
        password: []const u8,
        params: Params,
        buf: []u8,
        salt: *const [default_salt_len]u8,
    ) HasherError![]const u8 {
        var hash: [default_hash_len]u8 = undefined;
        try kdf(allocator, &hash, password, salt, params);

        return phc_format.serialize(HashResult{
            .alg_id = alg_id,
            .ln = params.ln,
            .r = params.r,
            .p = params.p,
            .salt = try BinValue(max_salt_len).fromSlice(salt),
            .hash = try BinValue(max_hash_len).fromSlice(&hash),
        }, buf);
    }

    /// 根据 PHC 格式编码字符串验证密码
    pub fn verify(
        allocator: mem.Allocator,
        str: []const u8,
        password: []const u8,
    ) HasherError!void {
        const hash_result = try phc_format.deserialize(HashResult, str);
        if (!mem.eql(u8, hash_result.alg_id, alg_id)) return HasherError.PasswordVerificationFailed;
        const params = Params{ .ln = hash_result.ln, .r = hash_result.r, .p = hash_result.p };
        const expected_hash = hash_result.hash.constSlice();
        var hash_buf: [max_hash_len]u8 = undefined;
        if (expected_hash.len > hash_buf.len) return HasherError.InvalidEncoding;
        const hash = hash_buf[0..expected_hash.len];
        try kdf(allocator, hash, password, hash_result.salt.constSlice(), params);
        if (!mem.eql(u8, hash, expected_hash)) return HasherError.PasswordVerificationFailed;
    }
};

/// 使用模块化 crypt 格式进行密码哈希和验证。
const CryptFormatHasher = struct {
    const BinValue = crypt_format.BinValue;
    const HashResult = crypt_format.HashResult(max_hash_len);

    /// create() 函数返回的字符串长度。
    pub const pwhash_str_length: usize = 101;

    /// 返回以模块化 crypt 格式编码的密码的非确定性哈希
    pub fn create(
        allocator: mem.Allocator,
        password: []const u8,
        params: Params,
        buf: []u8,
        io: std.Io,
    ) HasherError![]const u8 {
        var salt_bin: [default_salt_len]u8 = undefined;
        io.random(&salt_bin);
        return createWithSalt(allocator, password, params, buf, &salt_bin);
    }

    /// 返回以模块化 crypt 格式编码的确定性密码哈希。
    /// 使用所提供的盐,而非随机生成盐。
    pub fn createWithSalt(
        allocator: mem.Allocator,
        password: []const u8,
        params: Params,
        buf: []u8,
        salt_bin: *const [default_salt_len]u8,
    ) HasherError![]const u8 {
        const salt = crypt_format.saltFromBin(salt_bin.len, salt_bin.*);

        var hash: [default_hash_len]u8 = undefined;
        try kdf(allocator, &hash, password, &salt, params);

        return crypt_format.serialize(HashResult{
            .ln = params.ln,
            .r = params.r,
            .p = params.p,
            .salt = &salt,
            .hash = try BinValue(max_hash_len).fromSlice(&hash),
        }, buf);
    }

    /// 根据模块化 crypt 格式的字符串验证密码
    pub fn verify(
        allocator: mem.Allocator,
        str: []const u8,
        password: []const u8,
    ) HasherError!void {
        const hash_result = try crypt_format.deserialize(HashResult, str);
        const params = Params{ .ln = hash_result.ln, .r = hash_result.r, .p = hash_result.p };
        const expected_hash = hash_result.hash.constSlice();
        var hash_buf: [max_hash_len]u8 = undefined;
        if (expected_hash.len > hash_buf.len) return HasherError.InvalidEncoding;
        const hash = hash_buf[0..expected_hash.len];
        try kdf(allocator, hash, password, hash_result.salt, params);
        if (!mem.eql(u8, hash, expected_hash)) return HasherError.PasswordVerificationFailed;
    }
};

/// 密码哈希选项。
///
/// scrypt 需要分配器。
pub const HashOptions = struct {
    allocator: ?mem.Allocator,
    params: Params,
    encoding: pwhash.Encoding,
};

/// 使用 scrypt 密钥派生函数计算口令哈希。
/// 返回的字符串包含验证所需的全部参数。
pub fn strHash(
    password: []const u8,
    options: HashOptions,
    out: []u8,
    io: std.Io,
) Error![]const u8 {
    const allocator = options.allocator orelse return Error.AllocatorRequired;
    switch (options.encoding) {
        .phc => return PhcFormatHasher.create(allocator, password, options.params, out, io),
        .crypt => return CryptFormatHasher.create(allocator, password, options.params, out, io),
    }
}

/// 使用 scrypt 密钥派生函数确定性地计算密码哈希。
/// 返回包含验证所需全部参数的字符串。
/// 使用提供的盐,而非随机生成。
pub fn strHashWithSalt(
    password: []const u8,
    options: HashOptions,
    out: []u8,
    salt: *const [default_salt_len]u8,
) Error![]const u8 {
    const allocator = options.allocator orelse return Error.AllocatorRequired;
    switch (options.encoding) {
        .phc => return PhcFormatHasher.createWithSalt(allocator, password, options.params, out, salt),
        .crypt => return CryptFormatHasher.createWithSalt(allocator, password, options.params, out, salt),
    }
}

/// 哈希校验选项。
pub const VerifyOptions = struct {
    allocator: mem.Allocator,
};

/// 验证先前计算的哈希对给定密码是否有效。
pub fn strVerify(
    str: []const u8,
    password: []const u8,
    options: VerifyOptions,
) Error!void {
    if (mem.startsWith(u8, str, crypt_format.prefix)) {
        return CryptFormatHasher.verify(options.allocator, str, password);
    } else {
        return PhcFormatHasher.verify(options.allocator, str, password);
    }
}

// 这些测试运行时间过长,因此已禁用。
const run_long_tests = false;

test "kdf" {
    if (!run_long_tests) return error.SkipZigTest;

    const password = "testpass";
    const salt = "saltsalt";

    var dk: [32]u8 = undefined;
    try kdf(std.testing.allocator, &dk, password, salt, .{ .ln = 15, .r = 8, .p = 1 });

    const hex = "1e0f97c3f6609024022fbe698da29c2fe53ef1087a8e396dc6d5d2a041e886de";
    var bytes: [hex.len / 2]u8 = undefined;
    _ = try fmt.hexToBytes(&bytes, hex);

    try std.testing.expectEqualSlices(u8, &bytes, &dk);
}

test "kdf rfc 1" {
    if (!run_long_tests) return error.SkipZigTest;

    const password = "";
    const salt = "";

    var dk: [64]u8 = undefined;
    try kdf(std.testing.allocator, &dk, password, salt, .{ .ln = 4, .r = 1, .p = 1 });

    const hex = "77d6576238657b203b19ca42c18a0497f16b4844e3074ae8dfdffa3fede21442fcd0069ded0948f8326a753a0fc81f17e8d3e0fb2e0d3628cf35e20c38d18906";
    var bytes: [hex.len / 2]u8 = undefined;
    _ = try fmt.hexToBytes(&bytes, hex);

    try std.testing.expectEqualSlices(u8, &bytes, &dk);
}

test "kdf rfc 2" {
    if (!run_long_tests) return error.SkipZigTest;

    const password = "password";
    const salt = "NaCl";

    var dk: [64]u8 = undefined;
    try kdf(std.testing.allocator, &dk, password, salt, .{ .ln = 10, .r = 8, .p = 16 });

    const hex = "fdbabe1c9d3472007856e7190d01e9fe7c6ad7cbc8237830e77376634b3731622eaf30d92e22a3886ff109279d9830dac727afb94a83ee6d8360cbdfa2cc0640";
    var bytes: [hex.len / 2]u8 = undefined;
    _ = try fmt.hexToBytes(&bytes, hex);

    try std.testing.expectEqualSlices(u8, &bytes, &dk);
}

test "kdf rfc 3" {
    if (!run_long_tests) return error.SkipZigTest;

    const password = "pleaseletmein";
    const salt = "SodiumChloride";

    var dk: [64]u8 = undefined;
    try kdf(std.testing.allocator, &dk, password, salt, .{ .ln = 14, .r = 8, .p = 1 });

    const hex = "7023bdcb3afd7348461c06cd81fd38ebfda8fbba904f8e3ea9b543f6545da1f2d5432955613f0fcf62d49705242a9af9e61e85dc0d651e40dfcf017b45575887";
    var bytes: [hex.len / 2]u8 = undefined;
    _ = try fmt.hexToBytes(&bytes, hex);

    try std.testing.expectEqualSlices(u8, &bytes, &dk);
}

test "kdf rfc 4" {
    if (!run_long_tests) return error.SkipZigTest;

    const password = "pleaseletmein";
    const salt = "SodiumChloride";

    var dk: [64]u8 = undefined;
    try kdf(std.testing.allocator, &dk, password, salt, .{ .ln = 20, .r = 8, .p = 1 });

    const hex = "2101cb9b6a511aaeaddbbe09cf70f881ec568d574a2ffd4dabe5ee9820adaa478e56fd8f4ba5d09ffa1c6d927c40f4c337304049e8a952fbcbf45c6fa77a41a4";
    var bytes: [hex.len / 2]u8 = undefined;
    _ = try fmt.hexToBytes(&bytes, hex);

    try std.testing.expectEqualSlices(u8, &bytes, &dk);
}

test "password hashing (crypt format)" {
    if (!run_long_tests) return error.SkipZigTest;

    const alloc = std.testing.allocator;
    const io = std.testing.io;

    const str = "$7$A6....1....TrXs5Zk6s8sWHpQgWDIXTR8kUU3s6Jc3s.DtdS8M2i4$a4ik5hGDN7foMuHOW.cp.CtX01UyCeO0.JAG.AHPpx5";
    const password = "Y0!?iQa9M%5ekffW(`";
    try CryptFormatHasher.verify(alloc, str, password);

    const params = Params.interactive;
    var buf: [CryptFormatHasher.pwhash_str_length]u8 = undefined;
    const str2 = try CryptFormatHasher.create(alloc, password, params, &buf, io);
    try CryptFormatHasher.verify(alloc, str2, password);
}

test "strHash and strVerify" {
    if (!run_long_tests) return error.SkipZigTest;

    const alloc = std.testing.allocator;
    const io = std.testing.io;

    const password = "testpass";
    const params = Params.interactive;
    const verify_options: VerifyOptions = .{ .allocator = alloc };
    var buf: [128]u8 = undefined;

    {
        const str = try strHash(
            password,
            .{ .allocator = alloc, .params = params, .encoding = .crypt },
            &buf,
            io,
        );
        try strVerify(str, password, verify_options);
    }
    {
        const str = try strHash(
            password,
            .{ .allocator = alloc, .params = params, .encoding = .phc },
            &buf,
            io,
        );
        try strVerify(str, password, verify_options);
    }
}

test "unix-scrypt" {
    if (!run_long_tests) return error.SkipZigTest;

    const alloc = std.testing.allocator;

    // https://gitlab.com/jas/scrypt-unix-crypt/blob/master/unix-scrypt.txt
    {
        const str = "$7$C6..../....SodiumChloride$kBGj9fHznVYFQMEn/qDCfrDevf9YDtcDdKvEqHJLV8D";
        const password = "pleaseletmein";
        try strVerify(str, password, .{ .allocator = alloc });
    }
    // libsodium 的测试向量之一
    {
        const str = "$7$B6....1....75gBMAGwfFWZqBdyF3WdTQnWdUsuTiWjG1fF9c1jiSD$tc8RoB3.Em3/zNgMLWo2u00oGIoTyJv4fl3Fl8Tix72";
        const password = "^T5H$JYt39n%K*j:W]!1s?vg!:jGi]Ax?..l7[p0v:1jHTpla9;]bUN;?bWyCbtqg nrDFal+Jxl3,2`#^tFSu%v_+7iYse8-cCkNf!tD=KrW)";
        try strVerify(str, password, .{ .allocator = alloc });
    }
}

test "crypt format" {
    const str = "$7$C6..../....SodiumChloride$kBGj9fHznVYFQMEn/qDCfrDevf9YDtcDdKvEqHJLV8D";
    const params = try crypt_format.deserialize(crypt_format.HashResult(32), str);
    var buf: [str.len]u8 = undefined;
    const s1 = try crypt_format.serialize(params, &buf);
    try std.testing.expectEqualStrings(s1, str);
}

test "kdf fast" {
    const TestVector = struct {
        password: []const u8,
        salt: []const u8,
        params: Params,
        want: []const u8,
    };
    const test_vectors = [_]TestVector{
        .{
            .password = "p",
            .salt = "s",
            .params = .{ .ln = 1, .r = 1, .p = 1 },
            .want = &([_]u8{
                0x48, 0xb0, 0xd2, 0xa8, 0xa3, 0x27, 0x26, 0x11,
                0x98, 0x4c, 0x50, 0xeb, 0xd6, 0x30, 0xaf, 0x52,
            }),
        },
    };
    inline for (test_vectors) |v| {
        var dk: [v.want.len]u8 = undefined;
        try kdf(std.testing.allocator, &dk, v.password, v.salt, v.params);
        try std.testing.expectEqualSlices(u8, &dk, v.want);
    }
}

test "strHashWithSalt deterministic" {
    const alloc = std.testing.allocator;
    const password = "testpass";
    const salt: [default_salt_len]u8 = "0123456789abcdef0123456789abcdef".*;
    const params: Params = .{ .ln = 1, .r = 1, .p = 1 };

    var buf1: [128]u8 = undefined;
    var buf2: [128]u8 = undefined;

    const str1 = try strHashWithSalt(password, .{ .allocator = alloc, .params = params, .encoding = .phc }, &buf1, &salt);
    const str2 = try strHashWithSalt(password, .{ .allocator = alloc, .params = params, .encoding = .phc }, &buf2, &salt);
    try std.testing.expectEqualStrings(str1, str2);
    try strVerify(str1, password, .{ .allocator = alloc });

    const str3 = try strHashWithSalt(password, .{ .allocator = alloc, .params = params, .encoding = .crypt }, &buf1, &salt);
    const str4 = try strHashWithSalt(password, .{ .allocator = alloc, .params = params, .encoding = .crypt }, &buf2, &salt);
    try std.testing.expectEqualStrings(str3, str4);
    try strVerify(str3, password, .{ .allocator = alloc });
}