沙

SHA功能

用法非常简单:

julia> using SHA

julia> bytes2hex(sha256("test"))
"9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"

每个导出的函数（在写这篇文章的时候，SHA-1，SHA-2 224，256，384和512，和SHA-3 224，256，384和512函数实现）需要在任一 AbstractVector{UInt8}，安 抽象字符串 或一个 伊俄 对象。这使得校验和文件变得微不足道:

shell> cat /tmp/test.txt
test
julia> using SHA

julia> open("/tmp/test.txt") do f
           sha2_256(f)
       end
32-element Vector{UInt8}:
 0x9f
 0x86
 0xd0
 0x81
 0x88
 0x4c
 0x7d
 0x65
    ⋮
 0x5d
 0x6c
 0x15
 0xb0
 0xf0
 0x0a
 0x08

所有SHA功能

由于口语用法 沙256 以参考 沙2_256，提供方便功能，映射 沙xxx() 函数调用 sha2_xxx(). 对于SHA-3，不存在这样的口语，用户必须使用完整的 sha3_xxx（） 名字。

沙xxx() 需要 抽象字符串 和类数组对象（N.n.n.n. 和 向量资料）与类型的元素 UInt8.

*SHA-1*

# *`莎。sha1`*-函数

sha1(data)

使用 sha1 算法并返回结果摘要。请参阅 SHA1_CTX.

sha1(io::IO)

使用io的哈希数据 sha1 算法。

*SHA-2*

# *`莎。沙224`*-函数

sha224(data)

使用 沙224 算法并返回结果摘要。请参阅 SHA2_224_CTX.

sha224(io::IO)

使用io的哈希数据 沙224 算法。

# *`莎。沙256`*-函数

sha256(data)

使用 沙256 算法并返回结果摘要。请参阅 SHA2_256_CTX.

sha256(io::IO)

使用io的哈希数据 沙256 算法。

# *`莎。沙384`*-函数

sha384(data)

使用 沙384 算法并返回结果摘要。请参阅 SHA2_384_CTX.

sha384(io::IO)

使用io的哈希数据 沙384 算法。

# *`莎。沙512`*-函数

sha512(data)

使用 沙512 算法并返回结果摘要。请参阅 SHA2_512_CTX.

sha512(io::IO)

使用io的哈希数据 沙512 算法。

# *`莎。沙2_224`*-函数

sha2_224(data)

使用 沙2_224 算法并返回结果摘要。请参阅 SHA2_224_CTX.

sha2_224(io::IO)

使用io的哈希数据 沙2_224 算法。

# *`莎。沙2_256`*-函数

sha2_256(data)

使用 沙2_256 算法并返回结果摘要。请参阅 SHA2_256_CTX.

sha2_256(io::IO)

使用io的哈希数据 沙2_256 算法。

# *`莎。沙2_384`*-函数

sha2_384(data)

使用 沙2_384 算法并返回结果摘要。请参阅 SHA2_384_CTX.

sha2_384(io::IO)

使用io的哈希数据 沙2_384 算法。

# *`莎。沙2_512`*-函数

sha2_512(data)

使用 沙2_512 算法并返回结果摘要。请参阅 SHA2_512_CTX.

sha2_512(io::IO)

使用io的哈希数据 沙2_512 算法。

# *`莎。sha2_512_224`*-函数

sha2_512_224(data)

使用 sha2_512_224 算法并返回结果摘要。请参阅 SHA2_512_224_CTX.

sha2_512_224(io::IO)

使用io的哈希数据 sha2_512_224 算法。

# *`莎。sha2_512_256`*-函数

sha2_512_256(data)

使用 sha2_512_256 算法并返回结果摘要。请参阅 SHA2_512_256_CTX.

sha2_512_256(io::IO)

使用io的哈希数据 sha2_512_256 算法。

*SHA-3*

# *`莎。沙3_224`*-函数

sha3_224(data)

使用 沙3_224 算法并返回结果摘要。请参阅 SHA3_224_CTX.

sha3_224(io::IO)

使用io的哈希数据 沙3_224 算法。

# *`莎。沙3_256`*-函数

sha3_256(data)

使用 沙3_256 算法并返回结果摘要。请参阅 SHA3_256_CTX.

sha3_256(io::IO)

使用io的哈希数据 沙3_256 算法。

# *`莎。沙3_384`*-函数

sha3_384(data)

使用 沙3_384 算法并返回结果摘要。请参阅 SHA3_384_CTX.

sha3_384(io::IO)

使用io的哈希数据 沙3_384 算法。

# *`莎。沙3_512`*-函数

sha3_512(data)

使用 沙3_512 算法并返回结果摘要。请参阅 SHA3_512_CTX.

sha3_512(io::IO)

使用io的哈希数据 沙3_512 算法。

使用上下文

要从多个项目创建哈希 SHAX_XXX_CTX（） 类型可用于创建一个有状态的哈希对象，该对象使用 更新！ 并与 消化！

julia> using SHA

julia> ctx = SHA2_256_CTX()
SHA2 256-bit hash state

julia> update!(ctx, b"some data")
0x0000000000000009

julia> update!(ctx, b"some more data")
0x0000000000000017

julia> digest!(ctx)
32-element Vector{UInt8}:
 0xbe
 0xcf
 0x23
 0xda
 0xaf
 0x02
 0xf7
 0xa3
 0x57
 0x92
    ⋮
 0x89
 0x4f
 0x59
 0xd8
 0xb3
 0xb4
 0x81
 0x8b
 0xc5

请注意，在撰写本文时，SHA3代码没有被优化，因此大约比SHA2慢一个数量级。

# *`莎。更新！`*-函数

update!(context, data[, datalen])

使用数据中的字节更新SHA上下文。请参阅 消化！用于最终确定散列。

*例子*

julia> ctx = SHA1_CTX()
SHA1 hash state

julia> update!(ctx, b"data to to be hashed")

# *`莎。消化！`*-函数

digest!(context)

完成SHA上下文并将哈希返回为字节数组（向量{Uint8}). 调用后更新上下文 消化！ 就会出错。

*例子*

julia> ctx = SHA1_CTX()
SHA1 hash state

julia> update!(ctx, b"data to to be hashed")

julia> digest!(ctx)
20-element Vector{UInt8}:
 0x83
 0xe4
 ⋮
 0x89
 0xf5

julia> update!(ctx, b"more data")
ERROR: Cannot update CTX after `digest!` has been called on it
[...]

所有SHA上下文类型

*SHA-1*

# *`莎。SHA1_CTX`*-类型

SHA1_CTX()

构造空SHA1上下文。

*SHA-2*

还提供方便类型，其中 沙XXX_CTX 是一个类型别名 SHA2_XXX_CTX.

# *`莎。SHA224_CTX`*-类型

SHA2_224_CTX()

构造空SHA2_224上下文。

# *`莎。SHA256_CTX`*-类型

SHA2_256_CTX()

构造空SHA2_256上下文。

# *`莎。SHA384_CTX`*-类型

SHA2_384()

构造空SHA2_384上下文。

# *`莎。SHA512_CTX`*-类型

SHA2_512_CTX()

构造空SHA2_512上下文。

# *`莎。SHA2_224_CTX`*-类型

SHA2_224_CTX()

构造空SHA2_224上下文。

# *`莎。SHA2_256_CTX`*-类型

SHA2_256_CTX()

构造空SHA2_256上下文。

# *`莎。SHA2_384_CTX`*-类型

SHA2_384()

构造空SHA2_384上下文。

# *`莎。SHA2_512_CTX`*-类型

SHA2_512_CTX()

构造空SHA2_512上下文。

# *`莎。SHA2_512_224_CTX`*-类型

SHA2_512_224_CTX()

构造空SHA2_512/224上下文并设置初始哈希值。

有关初始值的来源，请参阅https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf[FIPS180-4,5.3.6.1SHA-512/224]

# *`莎。SHA2_512_256_CTX`*-类型

SHA2_512_256_CTX()

构造空SHA2_512/256上下文并设置初始哈希值。

有关初始值的来源，请参阅https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf[FIPS180-4,5.3.6.2SHA-512/256]

*SHA-3*

# *`莎。SHA3_224_CTX`*-类型

SHA3_224_CTX()

构造空SHA3_224上下文。

# *`莎。SHA3_256_CTX`*-类型

SHA3_256_CTX()

构造空SHA3_256上下文。

# *`莎。SHA3_384_CTX`*-类型

SHA3_384_CTX()

构造空SHA3_384上下文。

# *`莎。SHA3_512_CTX`*-类型

SHA3_512_CTX()

构造空SHA3_512上下文。

HMAC功能

julia> using SHA

julia> key = collect(codeunits("key_string"))
10-element Vector{UInt8}:
 0x6b
 0x65
 0x79
 0x5f
 0x73
 0x74
 0x72
 0x69
 0x6e
 0x67

julia> bytes2hex(hmac_sha3_256(key, "test-message"))
"bc49a6f2aa29b27ee5ed1e944edd7f3d153e8a01535d98b5e24dac9a589a6248"

要从多个项目创建散列， HMAC_CTX（） 类型可用于创建一个有状态的哈希对象，该对象使用 更新！ 并与 消化！.

julia> using SHA

julia> key = collect(codeunits("key_string"))
10-element Vector{UInt8}:
 0x6b
 0x65
 0x79
 0x5f
 0x73
 0x74
 0x72
 0x69
 0x6e
 0x67

julia> ctx = HMAC_CTX(SHA3_256_CTX(), key);

julia> update!(ctx, b"test-")
0x0000000000000000000000000000008d

julia> update!(ctx, b"message")
0x00000000000000000000000000000094

julia> bytes2hex(digest!(ctx))
"bc49a6f2aa29b27ee5ed1e944edd7f3d153e8a01535d98b5e24dac9a589a6248"

所有HMAC功能

*HMAC上下文类型*

# *`莎。HMAC_CTX`*-类型

HMAC_CTX(ctx::CTX, key::Vector{UInt8}) where {CTX<:SHA_CTX}

构造空HMAC_CTX上下文。

*SHA-1*

# *`莎。hmac_sha1`*-函数

hmac_sha1(key, data)

使用 sha1 使用传递的密钥的算法。请参阅 HMAC_CTX.

hmac_sha1(key, io::IO)

哈希数据从 伊俄 使用传递的密钥 sha1 算法。

*SHA-2*

# *`莎。hmac_sha224`*-函数

hmac_sha224(key, data)

使用 沙224 使用传递的密钥的算法。请参阅 HMAC_CTX.

hmac_sha224(key, io::IO)

哈希数据从 伊俄 使用传递的密钥 沙224 算法。

# *`莎。hmac_sha256`*-函数

hmac_sha256(key, data)

使用 沙256 使用传递的密钥的算法。请参阅 HMAC_CTX.

hmac_sha256(key, io::IO)

哈希数据从 伊俄 使用传递的密钥 沙256 算法。

# *`莎。hmac_sha384`*-函数

hmac_sha384(key, data)

使用 沙384 使用传递的密钥的算法。请参阅 HMAC_CTX.

hmac_sha384(key, io::IO)

哈希数据从 伊俄 使用传递的密钥 沙384 算法。

# *`莎。hmac_sha512`*-函数

hmac_sha512(key, data)

使用 沙512 使用传递的密钥的算法。请参阅 HMAC_CTX.

hmac_sha512(key, io::IO)

哈希数据从 伊俄 使用传递的密钥 沙512 算法。

# *`莎。hmac_sha2_224`*-函数

hmac_sha2_224(key, data)

使用 沙2_224 使用传递的密钥的算法。请参阅 HMAC_CTX.

hmac_sha2_224(key, io::IO)

哈希数据从 伊俄 使用传递的密钥 沙2_224 算法。

# *`莎。hmac_sha2_256`*-函数

hmac_sha2_256(key, data)

使用 沙2_256 使用传递的密钥的算法。请参阅 HMAC_CTX.

hmac_sha2_256(key, io::IO)

哈希数据从 伊俄 使用传递的密钥 沙2_256 算法。

# *`莎。hmac_sha2_384`*-函数

hmac_sha2_384(key, data)

使用 沙2_384 使用传递的密钥的算法。请参阅 HMAC_CTX.

hmac_sha2_384(key, io::IO)

哈希数据从 伊俄 使用传递的密钥 沙2_384 算法。

# *`莎。hmac_sha2_512`*-函数

hmac_sha2_512(key, data)

使用 沙2_512 使用传递的密钥的算法。请参阅 HMAC_CTX.

hmac_sha2_512(key, io::IO)

哈希数据从 伊俄 使用传递的密钥 沙2_512 算法。

*SHA-3*

# *`莎。hmac_sha3_224`*-函数

hmac_sha3_224(key, data)

使用 沙3_224 使用传递的密钥的算法。请参阅 HMAC_CTX.

hmac_sha3_224(key, io::IO)

哈希数据从 伊俄 使用传递的密钥 沙3_224 算法。

# *`莎。hmac_sha3_256`*-函数

hmac_sha3_256(key, data)

使用 沙3_256 使用传递的密钥的算法。请参阅 HMAC_CTX.

hmac_sha3_256(key, io::IO)

哈希数据从 伊俄 使用传递的密钥 沙3_256 算法。

# *`莎。hmac_sha3_384`*-函数

hmac_sha3_384(key, data)

使用 沙3_384 使用传递的密钥的算法。请参阅 HMAC_CTX.

hmac_sha3_384(key, io::IO)

哈希数据从 伊俄 使用传递的密钥 沙3_384 算法。

# *`莎。hmac_sha3_512`*-函数

hmac_sha3_512(key, data)

使用 沙3_512 使用传递的密钥的算法。请参阅 HMAC_CTX.

hmac_sha3_512(key, io::IO)

哈希数据从 伊俄 使用传递的密钥 沙3_512 算法。