在 GitHub 上编辑

SHA

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}、一个 AbstractString 或一个 IO 对象。这使得对文件进行校验和变得非常简单

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

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

所有 SHA 函数

由于 sha256 常用于指代 sha2_256，因此提供了便利函数，将 shaxxx() 函数调用映射到 sha2_xxx()。对于 SHA-3，不存在这样的俗语，用户必须使用完整的 sha3_xxx() 名称。

shaxxx() 接收 AbstractString 和元素类型为 UInt8 的类似数组的对象（NTuple 和 Array）。

SHA-1

SHA.sha1 — 函数
sha1(data)

使用 sha1 算法对数据进行哈希并返回生成的摘要。另请参阅 SHA1_CTX。

sha1(io::IO)

使用 sha1 算法对来自 io 的数据进行哈希。

SHA-2

SHA.sha224 — 函数
sha224(data)

使用 sha224 算法对数据进行哈希并返回生成的摘要。另请参阅 SHA2_224_CTX。

sha224(io::IO)

使用 sha224 算法对来自 io 的数据进行哈希。

SHA.sha256 — 函数
sha256(data)

使用 sha256 算法对数据进行哈希并返回生成的摘要。另请参阅 SHA2_256_CTX。

sha256(io::IO)

使用 sha256 算法对来自 io 的数据进行哈希。

SHA.sha384 — 函数
sha384(data)

使用 sha384 算法对数据进行哈希并返回生成的摘要。另请参阅 SHA2_384_CTX。

sha384(io::IO)

使用 sha384 算法对来自 io 的数据进行哈希。

SHA.sha512 — 函数
sha512(data)

使用 sha512 算法对数据进行哈希并返回生成的摘要。另请参阅 SHA2_512_CTX。

sha512(io::IO)

使用 sha512 算法对来自 io 的数据进行哈希。

SHA.sha2_224 — 函数
sha2_224(data)

使用 sha2_224 算法对数据进行哈希并返回生成的摘要。另请参阅 SHA2_224_CTX。

sha2_224(io::IO)

使用 sha2_224 算法对来自 io 的数据进行哈希。

SHA.sha2_256 — 函数
sha2_256(data)

使用 sha2_256 算法对数据进行哈希并返回生成的摘要。另请参阅 SHA2_256_CTX。

sha2_256(io::IO)

使用 sha2_256 算法对来自 io 的数据进行哈希。

SHA.sha2_384 — 函数
sha2_384(data)

使用 sha2_384 算法对数据进行哈希并返回生成的摘要。另请参阅 SHA2_384_CTX。

sha2_384(io::IO)

使用 sha2_384 算法对来自 io 的数据进行哈希。

SHA.sha2_512 — 函数
sha2_512(data)

使用 sha2_512 算法对数据进行哈希并返回生成的摘要。另请参阅 SHA2_512_CTX。

sha2_512(io::IO)

使用 sha2_512 算法对来自 io 的数据进行哈希。

SHA-3

SHA.sha3_224 — 函数
sha3_224(data)

使用 sha3_224 算法对数据进行哈希并返回生成的摘要。另请参阅 SHA3_224_CTX。

sha3_224(io::IO)

使用 sha3_224 算法对来自 io 的数据进行哈希。

SHA.sha3_256 — 函数
sha3_256(data)

使用 sha3_256 算法对数据进行哈希并返回生成的摘要。另请参阅 SHA3_256_CTX。

sha3_256(io::IO)

使用 sha3_256 算法对来自 io 的数据进行哈希。

SHA.sha3_384 — 函数
sha3_384(data)

使用 sha3_384 算法对数据进行哈希并返回生成的摘要。另请参阅 SHA3_384_CTX。

sha3_384(io::IO)

使用 sha3_384 算法对来自 io 的数据进行哈希。

SHA.sha3_512 — 函数
sha3_512(data)

使用 sha3_512 算法对数据进行哈希并返回生成的摘要。另请参阅 SHA3_512_CTX。

sha3_512(io::IO)

使用 sha3_512 算法对来自 io 的数据进行哈希。

使用上下文

要从多个项目创建哈希，可以使用 SHAX_XXX_CTX() 类型创建状态化的哈希对象，并使用 update! 进行更新，并使用 digest! 完成。

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 慢一个数量级。

SHA.update! — 函数
update!(context, data[, datalen])

使用数据中的字节更新 SHA 上下文。另请参阅 digest! 以完成哈希。

示例

julia> ctx = SHA1_CTX()
SHA1 hash state

julia> update!(ctx, b"data to to be hashed")
SHA.digest! — 函数
digest!(context)

完成 SHA 上下文并返回哈希作为字节数组 (Array{Uint8, 1})。

示例

julia> ctx = SHA1_CTX()
SHA1 hash state

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

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

所有 SHA 上下文类型

SHA-1

SHA.SHA1_CTX — 类型
SHA1_CTX()

构造一个空的 SHA1 上下文。

SHA-2

还提供了便利类型，其中 SHAXXX_CTX 是 SHA2_XXX_CTX 的类型别名。

SHA.SHA224_CTX — 类型
SHA2_224_CTX()

构造一个空的 SHA2_224 上下文。

SHA.SHA256_CTX — 类型
SHA2_256_CTX()

构造一个空的 SHA2_256 上下文。

SHA.SHA384_CTX — 类型
SHA2_384()

构造一个空的 SHA2_384 上下文。

SHA.SHA512_CTX — 类型
SHA2_512_CTX()

构造一个空的 SHA2_512 上下文。

SHA.SHA2_224_CTX — 类型
SHA2_224_CTX()

构造一个空的 SHA2_224 上下文。

SHA.SHA2_256_CTX — 类型
SHA2_256_CTX()

构造一个空的 SHA2_256 上下文。

SHA.SHA2_512_CTX — 类型
SHA2_512_CTX()

构造一个空的 SHA2_512 上下文。

SHA-3

SHA.SHA3_224_CTX — 类型
SHA3_224_CTX()

构造一个空的 SHA3_224 上下文。

SHA.SHA3_256_CTX — 类型
SHA3_256_CTX()

构造一个空的 SHA3_256 上下文。

SHA.SHA3_384_CTX — 类型
SHA3_384_CTX()

构造一个空的 SHA3_384 上下文。

SHA.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()类型创建有状态的哈希对象，并使用update!更新该对象，并使用digest!完成哈希计算。

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上下文类型

SHA.HMAC_CTX — 类型
HMAC_CTX(ctx::CTX, key::Vector{UInt8}) where {CTX<:SHA_CTX}

构造一个空的HMAC_CTX上下文。

SHA-1

SHA.hmac_sha1 — 函数
hmac_sha1(key, data)

使用传递的密钥，使用sha1算法对数据进行哈希计算。另请参阅 HMAC_CTX。

hmac_sha1(key, io::IO)

使用传递的密钥和sha1算法，对来自io的数据进行哈希计算。

SHA-2

SHA.hmac_sha224 — 函数
hmac_sha224(key, data)

使用传递的密钥，使用sha224算法对数据进行哈希计算。另请参阅 HMAC_CTX。

hmac_sha224(key, io::IO)

使用传递的密钥和sha224算法，对来自io的数据进行哈希计算。

SHA.hmac_sha256 — 函数
hmac_sha256(key, data)

使用传递的密钥，使用sha256算法对数据进行哈希计算。另请参阅 HMAC_CTX。

hmac_sha256(key, io::IO)

使用传递的密钥和sha256算法，对来自io的数据进行哈希计算。

SHA.hmac_sha384 — 函数
hmac_sha384(key, data)

使用传递的密钥，使用sha384算法对数据进行哈希计算。另请参阅 HMAC_CTX。

hmac_sha384(key, io::IO)

使用传递的密钥和sha384算法，对来自io的数据进行哈希计算。

SHA.hmac_sha512 — 函数
hmac_sha512(key, data)

使用传递的密钥，使用sha512算法对数据进行哈希计算。另请参阅 HMAC_CTX。

hmac_sha512(key, io::IO)

使用传递的密钥和sha512算法，对来自io的数据进行哈希计算。

SHA.hmac_sha2_224 — 函数
hmac_sha2_224(key, data)

使用传递的密钥，使用sha2_224算法对数据进行哈希计算。另请参阅 HMAC_CTX。

hmac_sha2_224(key, io::IO)

使用传递的密钥和sha2_224算法，对来自io的数据进行哈希计算。

SHA.hmac_sha2_256 — 函数
hmac_sha2_256(key, data)

使用传递的密钥，使用sha2_256算法对数据进行哈希计算。另请参阅 HMAC_CTX。

hmac_sha2_256(key, io::IO)

使用传递的密钥和sha2_256算法，对来自io的数据进行哈希计算。

SHA.hmac_sha2_384 — 函数
hmac_sha2_384(key, data)

使用传递的密钥，使用sha2_384算法对数据进行哈希计算。另请参阅 HMAC_CTX。

hmac_sha2_384(key, io::IO)

使用传递的密钥和sha2_384算法，对来自io的数据进行哈希计算。

SHA.hmac_sha2_512 — 函数
hmac_sha2_512(key, data)

使用传递的密钥，使用sha2_512算法对数据进行哈希计算。另请参阅 HMAC_CTX。

hmac_sha2_512(key, io::IO)

使用传递的密钥和sha2_512算法，对来自io的数据进行哈希计算。

SHA-3

SHA.hmac_sha3_224 — 函数
hmac_sha3_224(key, data)

使用传递的密钥，使用sha3_224算法对数据进行哈希计算。另请参阅 HMAC_CTX。

hmac_sha3_224(key, io::IO)

使用传递的密钥和sha3_224算法，对来自io的数据进行哈希计算。

SHA.hmac_sha3_256 — 函数
hmac_sha3_256(key, data)

使用传递的密钥，使用sha3_256算法对数据进行哈希计算。另请参阅 HMAC_CTX。

hmac_sha3_256(key, io::IO)

使用传递的密钥和sha3_256算法，对来自io的数据进行哈希计算。

SHA.hmac_sha3_384 — 函数
hmac_sha3_384(key, data)

使用传递的密钥，使用sha3_384算法对数据进行哈希计算。另请参阅 HMAC_CTX。

hmac_sha3_384(key, io::IO)

使用传递的密钥和sha3_384算法，对来自io的数据进行哈希计算。

SHA.hmac_sha3_512 — 函数
hmac_sha3_512(key, data)

使用传递的密钥，使用sha3_512算法对数据进行哈希计算。另请参阅 HMAC_CTX。

hmac_sha3_512(key, io::IO)

使用传递的密钥和sha3_512算法，对来自io的数据进行哈希计算。