SHA

SHA functions

El uso es muy sencillo:

julia> using SHA

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

Cada función exportada (en el momento de escribir esto, se implementan las funciones SHA-1, SHA-2 224, 256, 384 y 512, y SHA-3 224, 256, 384 y 512) acepta ya sea un AbstractVector{UInt8}, un AbstractString o un objeto IO. Esto hace que sea trivial calcular el checksum de un archivo:

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

All SHA functions

Debido al uso coloquial de sha256 para referirse a sha2_256, se proporcionan funciones de conveniencia que mapean las llamadas a la función shaxxx() a sha2_xxx(). Para SHA-3, no existen tales coloquialismos y el usuario debe usar los nombres completos sha3_xxx().

shaxxx() toma AbstractString y objetos similares a arreglos (NTuple y Array) con elementos de tipo UInt8.

SHA-1

SHA.sha1 — Function

sha1(data)

Hashea los datos utilizando el algoritmo sha1 y devuelve el resumen resultante. Ver también SHA1_CTX.

sha1(io::IO)

Hashea datos de io utilizando el algoritmo sha1.

SHA-2

SHA.sha224 — Function

sha224(data)

Hashea los datos utilizando el algoritmo sha224 y devuelve el resumen resultante. Ver también SHA2_224_CTX.

sha224(io::IO)

Hashea datos de io utilizando el algoritmo sha224.

SHA.sha256 — Function

sha256(data)

Hashea los datos utilizando el algoritmo sha256 y devuelve el resumen resultante. Ver también SHA2_256_CTX.

sha256(io::IO)

Hashea los datos de io utilizando el algoritmo sha256.

SHA.sha384 — Function

sha384(data)

Hashea los datos utilizando el algoritmo sha384 y devuelve el digest resultante. Ver también SHA2_384_CTX.

sha384(io::IO)

Hashea datos de io utilizando el algoritmo sha384.

SHA.sha512 — Function

sha512(data)

Hashea los datos utilizando el algoritmo sha512 y devuelve el digest resultante. Ver también SHA2_512_CTX.

sha512(io::IO)

Hashea los datos de io utilizando el algoritmo sha512.

SHA.sha2_224 — Function

sha2_224(data)

Hashea los datos utilizando el algoritmo sha2_224 y devuelve el resumen resultante. Ver también SHA2_224_CTX.

sha2_224(io::IO)

Hashea datos de io utilizando el algoritmo sha2_224.

SHA.sha2_256 — Function

sha2_256(data)

Hashea los datos utilizando el algoritmo sha2_256 y devuelve el resumen resultante. Ver también SHA2_256_CTX.

sha2_256(io::IO)

Hashea datos de io utilizando el algoritmo sha2_256.

SHA.sha2_384 — Function

sha2_384(data)

Hashea los datos utilizando el algoritmo sha2_384 y devuelve el resumen resultante. Ver también SHA2_384_CTX.

sha2_384(io::IO)

Hashea datos de io utilizando el algoritmo sha2_384.

SHA.sha2_512 — Function

sha2_512(data)

Hashea los datos utilizando el algoritmo sha2_512 y devuelve el resumen resultante. Ver también SHA2_512_CTX.

sha2_512(io::IO)

Hashea datos de io utilizando el algoritmo sha2_512.

SHA-3

SHA.sha3_224 — Function

sha3_224(data)

Hashea los datos utilizando el algoritmo sha3_224 y devuelve el resumen resultante. Ver también SHA3_224_CTX.

sha3_224(io::IO)

Hashea datos de io utilizando el algoritmo sha3_224.

SHA.sha3_256 — Function

sha3_256(data)

Hashea los datos utilizando el algoritmo sha3_256 y devuelve el resumen resultante. Ver también SHA3_256_CTX.

sha3_256(io::IO)

Hashea datos de io utilizando el algoritmo sha3_256.

SHA.sha3_384 — Function

sha3_384(data)

Hashea los datos utilizando el algoritmo sha3_384 y devuelve el resumen resultante. Ver también SHA3_384_CTX.

sha3_384(io::IO)

Hashea datos de io utilizando el algoritmo sha3_384.

SHA.sha3_512 — Function

sha3_512(data)

Hashea los datos utilizando el algoritmo sha3_512 y devuelve el resumen resultante. Ver también SHA3_512_CTX.

sha3_512(io::IO)

Hashea datos de io utilizando el algoritmo sha3_512.

Working with context

Para crear un hash a partir de múltiples elementos, se pueden utilizar los tipos SHAX_XXX_CTX() para crear un objeto hash con estado que se actualiza con update! y se finaliza con 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

Tenga en cuenta que, en el momento de escribir esto, el código SHA3 no está optimizado y, como tal, es aproximadamente un orden de magnitud más lento que SHA2.

SHA.update! — Function

update!(context, data[, datalen])

Actualiza el contexto SHA con los bytes en data. Consulta también digest! para finalizar el hash.

Ejemplos

julia> ctx = SHA1_CTX()
Estado del hash SHA1

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

SHA.digest! — Function

digest!(context)

Finaliza el contexto SHA y devuelve el hash como un array de bytes (Array{Uint8, 1}). Actualizar el contexto después de llamar a digest! en él generará un error.

Ejemplos

julia> ctx = SHA1_CTX()
Estado del hash SHA1

julia> update!(ctx, b"datos a ser hasheados")

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

julia> update!(ctx, b"más datos")
ERROR: No se puede actualizar CTX después de que se haya llamado a `digest!` en él
[...]

All SHA context types

SHA-1

SHA.SHA1_CTX — Type

SHA1_CTX()

Construye un contexto SHA1 vacío.

SHA-2

También se proporcionan tipos de conveniencia, donde SHAXXX_CTX es un alias de tipo para SHA2_XXX_CTX.

SHA.SHA224_CTX — Type

SHA2_224_CTX()

Construye un contexto SHA2_224 vacío.

SHA.SHA256_CTX — Type

SHA2_256_CTX()

Construye un contexto SHA2_256 vacío.

SHA.SHA384_CTX — Type

SHA2_384()

Construye un contexto SHA2_384 vacío.

SHA.SHA512_CTX — Type

SHA2_512_CTX()

Construye un contexto SHA2_512 vacío.

SHA.SHA2_224_CTX — Type

SHA2_224_CTX()

Construye un contexto SHA2_224 vacío.

SHA.SHA2_256_CTX — Type

SHA2_256_CTX()

Construye un contexto SHA2_256 vacío.

SHA.SHA2_384_CTX — Type

SHA2_384()

Construye un contexto SHA2_384 vacío.

SHA.SHA2_512_CTX — Type

SHA2_512_CTX()

Construye un contexto SHA2_512 vacío.

SHA-3

SHA.SHA3_224_CTX — Type

SHA3_224_CTX()

Construye un contexto SHA3_224 vacío.

SHA.SHA3_256_CTX — Type

SHA3_256_CTX()

Construye un contexto SHA3_256 vacío.

SHA.SHA3_384_CTX — Type

SHA3_384_CTX()

Construye un contexto SHA3_384 vacío.

SHA.SHA3_512_CTX — Type

SHA3_512_CTX()

Construye un contexto SHA3_512 vacío.

HMAC functions

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"

Para crear un hash a partir de múltiples elementos, se pueden utilizar los tipos HMAC_CTX() para crear un objeto hash con estado que se actualiza con update! y se finaliza con 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"

All HMAC functions

Tipo de contexto HMAC

SHA.HMAC_CTX — Type

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

Construir un contexto HMAC_CTX vacío.

SHA-1

SHA.hmac_sha1 — Function

hmac_sha1(clave, datos)

Hashea los datos utilizando el algoritmo sha1 con la clave pasada. Ver también HMAC_CTX.

hmac_sha1(clave, io::IO)

Hashea los datos de io con la clave pasada utilizando el algoritmo sha1.

SHA-2

SHA.hmac_sha224 — Function

hmac_sha224(clave, datos)

Hashea los datos utilizando el algoritmo sha224 con la clave pasada. Ver también HMAC_CTX.

hmac_sha224(clave, io::IO)

Hashea los datos de io con la clave pasada utilizando el algoritmo sha224.

SHA.hmac_sha256 — Function

hmac_sha256(clave, datos)

Hashea los datos utilizando el algoritmo sha256 con la clave pasada. Ver también HMAC_CTX.

hmac_sha256(key, io::IO)

Hashea los datos de io con la clave pasada utilizando el algoritmo sha256.

SHA.hmac_sha384 — Function

hmac_sha384(clave, datos)

Hashea los datos utilizando el algoritmo sha384 con la clave pasada. Ver también HMAC_CTX.

hmac_sha384(clave, io::IO)

Hashea datos de io con la clave pasada utilizando el algoritmo sha384.

SHA.hmac_sha512 — Function

hmac_sha512(clave, datos)

Hashea los datos utilizando el algoritmo sha512 con la clave pasada. Ver también HMAC_CTX.

hmac_sha512(clave, io::IO)

Hashea datos de io con la clave pasada utilizando el algoritmo sha512.

SHA.hmac_sha2_224 — Function

hmac_sha2_224(clave, datos)

Hashea los datos utilizando el algoritmo sha2_224 con la clave pasada. Ver también HMAC_CTX.

hmac_sha2_224(clave, io::IO)

Hashea datos de io con la clave pasada utilizando el algoritmo sha2_224.

SHA.hmac_sha2_256 — Function

hmac_sha2_256(clave, datos)

Hashea los datos utilizando el algoritmo sha2_256 con la clave pasada. Ver también HMAC_CTX.

hmac_sha2_256(clave, io::IO)

Hashea datos de io con la clave pasada utilizando el algoritmo sha2_256.

SHA.hmac_sha2_384 — Function

hmac_sha2_384(clave, datos)

Hashea los datos utilizando el algoritmo sha2_384 con la clave pasada. Ver también HMAC_CTX.

hmac_sha2_384(clave, io::IO)

Hashea datos de io con la clave pasada utilizando el algoritmo sha2_384.

SHA.hmac_sha2_512 — Function

hmac_sha2_512(clave, datos)

Hashea los datos utilizando el algoritmo sha2_512 con la clave pasada. Consulta también HMAC_CTX.

hmac_sha2_512(clave, io::IO)

Hashea los datos de io con la clave pasada utilizando el algoritmo sha2_512.

SHA-3

SHA.hmac_sha3_224 — Function

hmac_sha3_224(clave, datos)

Hashea los datos utilizando el algoritmo sha3_224 con la clave pasada. Ver también HMAC_CTX.

hmac_sha3_224(clave, io::IO)

Hashea datos de io con la clave pasada utilizando el algoritmo sha3_224.

SHA.hmac_sha3_256 — Function

hmac_sha3_256(clave, datos)

Hashea los datos utilizando el algoritmo sha3_256 con la clave pasada. Ver también HMAC_CTX.

hmac_sha3_256(clave, io::IO)

Hashea los datos de io con la clave pasada utilizando el algoritmo sha3_256.

SHA.hmac_sha3_384 — Function

hmac_sha3_384(clave, datos)

Hashea los datos utilizando el algoritmo sha3_384 con la clave pasada. Ver también HMAC_CTX.

hmac_sha3_384(clave, io::IO)

Hashea datos de io con la clave pasada utilizando el algoritmo sha3_384.

SHA.hmac_sha3_512 — Function

hmac_sha3_512(clave, datos)

Hashea los datos utilizando el algoritmo sha3_512 con la clave pasada. Ver también HMAC_CTX.

hmac_sha3_512(clave, io::IO)

Hashea datos de io con la clave pasada utilizando el algoritmo sha3_512.