SHA

SHA functions

L'utilisation est très simple :

julia> using SHA

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

Chaque fonction exportée (au moment de la rédaction de ce document, les fonctions SHA-1, SHA-2 224, 256, 384 et 512, ainsi que SHA-3 224, 256, 384 et 512 sont implémentées) prend en entrée soit un AbstractVector{UInt8}, soit un AbstractString ou un objet IO. Cela rend trivial le calcul d'un checksum pour un fichier :

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

En raison de l'utilisation colloquiale de sha256 pour désigner sha2_256, des fonctions de commodité sont fournies, mappant les appels de fonction shaxxx() à sha2_xxx(). Pour SHA-3, aucune de ces expressions colloquiales n'existe et l'utilisateur doit utiliser les noms complets sha3_xxx().

shaxxx() prend des AbstractString et des objets de type tableau (NTuple et Array) avec des éléments de type UInt8.

SHA-1

SHA.sha1 — Function

sha1(data)

Hachez les données en utilisant l'algorithme sha1 et renvoyez le hachage résultant. Voir aussi SHA1_CTX.

sha1(io::IO)

Hachez les données de io en utilisant l'algorithme sha1.

SHA-2

SHA.sha224 — Function

sha224(données)

Hachez les données en utilisant l'algorithme sha224 et renvoyez le hachage résultant. Voir aussi SHA2_224_CTX.

sha224(io::IO)

Hachez les données de io en utilisant l'algorithme sha224.

SHA.sha256 — Function

sha256(données)

Hachez les données en utilisant l'algorithme sha256 et renvoyez le hachage résultant. Voir aussi SHA2_256_CTX.

sha256(io::IO)

Hachez les données de io en utilisant l'algorithme sha256.

SHA.sha384 — Function

sha384(données)

Hachez les données en utilisant l'algorithme sha384 et renvoyez le hachage résultant. Voir aussi SHA2_384_CTX.

sha384(io::IO)

Hacher des données à partir de io en utilisant l'algorithme sha384.

SHA.sha512 — Function

sha512(données)

Hachez les données en utilisant l'algorithme sha512 et renvoyez le hachage résultant. Voir aussi SHA2_512_CTX.

sha512(io::IO)

Hachez les données de io en utilisant l'algorithme sha512.

SHA.sha2_224 — Function

sha2_224(data)

Hachez les données en utilisant l'algorithme sha2_224 et renvoyez le hachage résultant. Voir aussi SHA2_224_CTX.

sha2_224(io::IO)

Hachez les données de io en utilisant l'algorithme sha2_224.

SHA.sha2_256 — Function

sha2_256(données)

Hachez les données en utilisant l'algorithme sha2_256 et renvoyez le hachage résultant. Voir aussi SHA2_256_CTX.

sha2_256(io::IO)

Hachez les données de io en utilisant l'algorithme sha2_256.

SHA.sha2_384 — Function

sha2_384(data)

Hachez les données en utilisant l'algorithme sha2_384 et renvoyez le hachage résultant. Voir aussi SHA2_384_CTX.

sha2_384(io::IO)

Hachez les données de io en utilisant l'algorithme sha2_384.

SHA.sha2_512 — Function

sha2_512(data)

Hachez les données en utilisant l'algorithme sha2_512 et renvoyez le hachage résultant. Voir aussi SHA2_512_CTX.

sha2_512(io::IO)

Hachez les données de io en utilisant l'algorithme sha2_512.

SHA-3

SHA.sha3_224 — Function

sha3_224(data)

Hachez les données en utilisant l'algorithme sha3_224 et renvoyez le hachage résultant. Voir aussi SHA3_224_CTX.

sha3_224(io::IO)

Hachez les données de io en utilisant l'algorithme sha3_224.

SHA.sha3_256 — Function

sha3_256(données)

Hachez les données en utilisant l'algorithme sha3_256 et renvoyez le hachage résultant. Voir aussi SHA3_256_CTX.

sha3_256(io::IO)

Hachez les données de io en utilisant l'algorithme sha3_256.

SHA.sha3_384 — Function

sha3_384(données)

Hachez les données en utilisant l'algorithme sha3_384 et renvoyez le hachage résultant. Voir aussi SHA3_384_CTX.

sha3_384(io::IO)

Hachez les données de io en utilisant l'algorithme sha3_384.

SHA.sha3_512 — Function

sha3_512(données)

Hachez les données en utilisant l'algorithme sha3_512 et renvoyez le hachage résultant. Voir aussi SHA3_512_CTX.

sha3_512(io::IO)

Hachez les données de io en utilisant l'algorithme sha3_512.

Working with context

Pour créer un hachage à partir de plusieurs éléments, les types SHAX_XXX_CTX() peuvent être utilisés pour créer un objet de hachage avec état qui est mis à jour avec update! et finalisé avec 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

Notez qu'au moment de la rédaction de ce document, le code SHA3 n'est pas optimisé et est donc environ un ordre de grandeur plus lent que SHA2.

SHA.update! — Function

update!(context, data[, datalen])

Met à jour le contexte SHA avec les octets dans les données. Voir aussi digest! pour finaliser le hachage.

Exemples

julia> ctx = SHA1_CTX()
État de hachage SHA1

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

SHA.digest! — Function

digest!(context)

Finalisez le contexte SHA et renvoyez le hachage sous forme de tableau d'octets (Array{Uint8, 1}). Mettre à jour le contexte après avoir appelé digest! sur celui-ci entraînera une erreur.

Exemples

julia> ctx = SHA1_CTX()
État de hachage SHA1

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

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

julia> update!(ctx, b"more data")
ERREUR: Impossible de mettre à jour CTX après que `digest!` a été appelé sur celui-ci
[...]

All SHA context types

SHA-1

SHA.SHA1_CTX — Type

SHA1_CTX()

Construire un contexte SHA1 vide.

SHA-2

Des types de commodité sont également fournis, où SHAXXX_CTX est un alias de type pour SHA2_XXX_CTX.

SHA.SHA224_CTX — Type

SHA2_224_CTX()

Construire un contexte SHA2_224 vide.

SHA.SHA256_CTX — Type

SHA2_256_CTX()

Construire un contexte SHA2_256 vide.

SHA.SHA384_CTX — Type

SHA2_384()

Construire un contexte SHA2_384 vide.

SHA.SHA512_CTX — Type

SHA2_512_CTX()

Construire un contexte SHA2_512 vide.

SHA.SHA2_224_CTX — Type

SHA2_224_CTX()

Construire un contexte SHA2_224 vide.

SHA.SHA2_256_CTX — Type

SHA2_256_CTX()

Construire un contexte SHA2_256 vide.

SHA.SHA2_384_CTX — Type

SHA2_384()

Construire un contexte SHA2_384 vide.

SHA.SHA2_512_CTX — Type

SHA2_512_CTX()

Construire un contexte SHA2_512 vide.

SHA-3

SHA.SHA3_224_CTX — Type

SHA3_224_CTX()

Construire un contexte SHA3_224 vide.

SHA.SHA3_256_CTX — Type

SHA3_256_CTX()

Construire un contexte SHA3_256 vide.

SHA.SHA3_384_CTX — Type

SHA3_384_CTX()

Construire un contexte SHA3_384 vide.

SHA.SHA3_512_CTX — Type

SHA3_512_CTX()

Construire un contexte SHA3_512 vide.

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"

Pour créer un hachage à partir de plusieurs éléments, les types HMAC_CTX() peuvent être utilisés pour créer un objet de hachage avec état qui est mis à jour avec update! et finalisé avec 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

Type de contexte HMAC

SHA.HMAC_CTX — Type

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

Construit un contexte HMAC_CTX vide.

SHA-1

SHA.hmac_sha1 — Function

hmac_sha1(clé, données)

Hachez les données en utilisant l'algorithme sha1 avec la clé passée. Voir aussi HMAC_CTX.

hmac_sha1(clé, io::IO)

Hache les données de io avec la clé passée en utilisant l'algorithme sha1.

SHA-2

SHA.hmac_sha224 — Function

hmac_sha224(clé, données)

Hachez les données en utilisant l'algorithme sha224 avec la clé passée. Voir aussi HMAC_CTX.

hmac_sha224(clé, io::IO)

Hache les données de io avec la clé passée en utilisant l'algorithme sha224.

SHA.hmac_sha256 — Function

hmac_sha256(clé, données)

Hachez les données en utilisant l'algorithme sha256 avec la clé passée. Voir aussi HMAC_CTX.

hmac_sha256(clé, io::IO)

Hache les données de io avec la clé passée en utilisant l'algorithme sha256.

SHA.hmac_sha384 — Function

hmac_sha384(clé, données)

Hachez les données en utilisant l'algorithme sha384 avec la clé passée. Voir aussi HMAC_CTX.

hmac_sha384(clé, io::IO)

Hache les données de io avec la clé passée en utilisant l'algorithme sha384.

SHA.hmac_sha512 — Function

hmac_sha512(clé, données)

Hachez les données en utilisant l'algorithme sha512 avec la clé passée. Voir aussi HMAC_CTX.

hmac_sha512(cle, io::IO)

Hachez les données de io avec la clé passée en utilisant l'algorithme sha512.

SHA.hmac_sha2_224 — Function

hmac_sha2_224(clé, données)

Hachez les données en utilisant l'algorithme sha2_224 avec la clé passée. Voir aussi HMAC_CTX.

hmac_sha2_224(clé, io::IO)

Hache les données de io avec la clé passée en utilisant l'algorithme sha2_224.

SHA.hmac_sha2_256 — Function

hmac_sha2_256(clé, données)

Hachez les données en utilisant l'algorithme sha2_256 avec la clé passée. Voir aussi HMAC_CTX.

hmac_sha2_256(clé, io::IO)

Hache les données de io avec la clé passée en utilisant l'algorithme sha2_256.

SHA.hmac_sha2_384 — Function

hmac_sha2_384(clé, données)

Hachez les données en utilisant l'algorithme sha2_384 avec la clé passée. Voir aussi HMAC_CTX.

hmac_sha2_384(clé, io::IO)

Hache les données de io avec la clé passée en utilisant l'algorithme sha2_384.

SHA.hmac_sha2_512 — Function

hmac_sha2_512(clé, données)

Hachez les données en utilisant l'algorithme sha2_512 avec la clé passée. Voir aussi HMAC_CTX.

hmac_sha2_512(cle, io::IO)

Hachez les données de io avec la clé passée en utilisant l'algorithme sha2_512.

SHA-3

SHA.hmac_sha3_224 — Function

hmac_sha3_224(clé, données)

Hachez les données en utilisant l'algorithme sha3_224 avec la clé passée. Voir aussi HMAC_CTX.

hmac_sha3_224(clé, io::IO)

Hache les données de io avec la clé passée en utilisant l'algorithme sha3_224.

SHA.hmac_sha3_256 — Function

hmac_sha3_256(clé, données)

Hachez les données en utilisant l'algorithme sha3_256 avec la clé passée. Voir aussi HMAC_CTX.

hmac_sha3_256(clé, io::IO)

Hache les données de io avec la clé passée en utilisant l'algorithme sha3_256.

SHA.hmac_sha3_384 — Function

hmac_sha3_384(clé, données)

Hachez les données en utilisant l'algorithme sha3_384 avec la clé passée. Voir aussi HMAC_CTX.

hmac_sha3_384(clé, io::IO)

Hachez les données de io avec la clé passée en utilisant l'algorithme sha3_384.

SHA.hmac_sha3_512 — Function

hmac_sha3_512(clé, données)

Hachez les données en utilisant l'algorithme sha3_512 avec la clé passée. Voir aussi HMAC_CTX.

hmac_sha3_512(clé, io::IO)

Hache les données de io avec la clé passée en utilisant l'algorithme sha3_512.