value
cryptoHashSHA256 Hash the content of the second buffer and put the result in the first buffer.
See: crypto_hash_sha256()
Modulelibsodium-bindings-0.0.3.0Haskell2010
LibSodium.Bindings.SHA2
Contents
- Introduction
- SHA-256
- Single-part message
- Multi-part messages
- Constants
- HMAC-SHA-256
- Single-part message
- Multi-part messages
- Constants
- SHA-512
- Single-part message
- Multi-part messages
- Constants
- HMAC-SHA-512
- Single-part message
- Multi-part messages
- Constants
- HMAC-SHA-512-256
- Single-part message
- Multi-part messages
- Constants
Synopsis
- value cryptoHashSHA256
- data CryptoHashSHA256State
- value withCryptoHashSHA256State
- value cryptoHashSHA256Init
- value cryptoHashSHA256Update
- value cryptoHashSHA256Final
- value cryptoHashSHA256Bytes
- value cryptoHashSHA256StateBytes
- value cryptoAuthHMACSHA256
- value cryptoAuthHMACSHA256Verify
- value cryptoAuthHMACSHA256Keygen
- data CryptoAuthHMACSHA256State
- value withCryptoAuthHMACSHA256State
- value cryptoAuthHMACSHA256Init
- value cryptoAuthHMACSHA256Update
- value cryptoAuthHMACSHA256Final
- value cryptoAuthHMACSHA256StateBytes
- value cryptoAuthHMACSHA256Bytes
- value cryptoAuthHMACSHA256KeyBytes
- value cryptoHashSHA512
- data CryptoHashSHA512State
- value withCryptoHashSHA512State
- value cryptoHashSHA512Init
- value cryptoHashSHA512Update
- value cryptoHashSHA512Final
- value cryptoHashSHA512Bytes
- value cryptoHashSHA512StateBytes
- data CryptoAuthHMACSHA512State
- value withCryptoAuthHMACSHA512State
- value cryptoAuthHMACSHA512
- value cryptoAuthHMACSHA512Verify
- value cryptoAuthHMACSHA512Keygen
- value cryptoAuthHMACSHA512Init
- value cryptoAuthHMACSHA512Update
- value cryptoAuthHMACSHA512Final
- value cryptoAuthHMACSHA512StateBytes
- value cryptoAuthHMACSHA512Bytes
- value cryptoAuthHMACSHA512KeyBytes
- data CryptoAuthHMACSHA512256State
- value withCryptoAuthHMACSHA512256State
- value cryptoAuthHMACSHA512256
- value cryptoAuthHMACSHA512256Verify
- value cryptoAuthHMACSHA512256Keygen
- value cryptoAuthHMACSHA512256Init
- value cryptoAuthHMACSHA512256Update
- value cryptoAuthHMACSHA512256Final
- value cryptoAuthHMACSHA512256StateBytes
- value cryptoAuthHMACSHA512256Bytes
- value cryptoAuthHMACSHA512256KeyBytes
- Packagelibsodium-bindings-0.0.3.0
- Exports49
- LanguageHaskell2010
- LicenceBSD-3-Clause
- SourceSHA2.hs
Introduction
The SHA-256 and SHA-512 functions are provided for interoperability with other applications. If you are
looking for a generic hash function and not specifically SHA-2, using
LibSodium.Bindings.GenericHashing (BLAKE2b) might be a better choice.
These functions are also not suitable for hashing passwords or deriving keys from passwords.
Use LibSodium.Bindings.PasswordHashing instead.
Only use these functions for interoperability with 3rd party services.
These functions are not keyed and are thus deterministic. In addition, the untruncated versions are vulnerable to length extension attacks. A message can be hashed in a single pass, but a streaming API is also available to process a message as a sequence of multiple chunks.
SHA-256
Single-part message
Multi-part messages
This is the opaque state held and used by the SHA-256 functions.
Its size is cryptoHashSHA256StateBytes.
Perform an operation with a CryptoHashSHA256State of size cryptoHashSHA256StateBytes allocated and deallocated automatically.
⚠️ The return value of withCryptoHashSHA256State MUST NOT leak the CryptoHashSHA256State.
Please refer to the documentation of allocaBytes for more operational details.
value
cryptoHashSHA256Init :: Ptr CryptoHashSHA256StateA pointer to an uninitialised hash state. Cannot be
Foreign.nullPtr.-> IO CIntReturns 0 on success, -1 on error.
This function initializes the CryptoHashSHA256State state.
Call this function on a Ptr CryptoHashSHA256State before using it as an argument in any other function in this module.
Add a new chunk to the message that will eventually be hashed.
After all parts have been supplied, cryptoHashSHA256Final can be used to finalise the operation and get the final hash.
Finalise the hashing of a message. The final hash is padded with extra zeros if necessary, then put in a buffer.
After this operation, the buffer containing the CryptoHashSHA256State is emptied and cannot be relied upon.
Constants
The size of a SHA256-hashed message.
The size of a CryptoHashSHA256State.
HMAC-SHA-256
Single-part message
value
cryptoAuthHMACSHA256 :: Ptr CUCharA pointer to the buffer holding the authenticator.
-> Ptr CUCharA pointer to the message to be authenticated.
-> CULLongThe length of the message to be authenticated.
-> Ptr CUCharA pointer to the secret key used for authentication, of length cryptoAuthHMACSHA256Bytes.
-> IO CIntReturns 0 on success, -1 on error.
Authenticate a message given its size and a secret key, and produce an authenticator to be validated with cryptoAuthHMACSHA256Verify.
See: crypto_auth_hmacsha256().
value
cryptoAuthHMACSHA256Verify :: Ptr CUCharA pointer to buffer holding the authenticator.
-> Ptr CUCharA pointer to the message that is being authenticated.
-> CULLongThe length of the message that is being authenticated.
-> Ptr CUCharA pointer to the secret key, of size cryptoAuthHMACSHA256KeyBytes.
-> IO CIntReturns 0 on success, -1 on failure.
Verify that an authenticator provided by cryptoAuthHMACSHA256 is correct.
value
cryptoAuthHMACSHA256Keygen :: Ptr CUCharA pointer to the buffer that will hold the secret key, of size cryptoAuthHMACSHA256KeyBytes.
-> IO ()Nothing is returned
Create a random key of the correct length.
Multi-part messages
This is the opaque state held and used by the HMAC-SHA-256 functions.
Its size is cryptoAuthHMACSHA256StateBytes bytes.
Please refer to the documentation of allocaBytes for more operational details.
Perform an operation with a CryptoAuthHMACSHA256State of size cryptoAuthHMACSHA256StateBytes allocated and deallocated automatically.
⚠️ The return value of withCryptoAuthHMACSHA256State MUST NOT leak the CryptoAuthHMACSHA256State.
Please refer to the documentation of allocaBytes for more operational details.
This function initializes the CryptoAuthHMACSHA256State state.
Call this function on a Ptr CryptoAuthHMACSHA256State before using it as an argument in any other function in this module.
Add a new chunk to the message that will eventually be hashed.
After all parts have been supplied, cryptoAuthHMACSHA256Final can be used to finalise the operation and get the final hash.
Finalise the hashing of a message. The final hash is padded with extra zeros if necessary, then put in a buffer.
After this operation, the buffer containing the CryptoAuthHMACSHA256State is emptied and cannot be relied upon.
Constants
The size of a CryptoAuthHMACSHA256State.
The size of a HMAC-SHA-256 hash
The size of a HMAC-SHA-256 key
SHA-512
Single-part message
value
cryptoHashSHA512 Hash the content of the second buffer and put the result in the first buffer.
See: crypto_hash_sha512()
Multi-part messages
This is the opaque state held and used by the SHA-512 functions.
Its size is cryptoHashSHA512StateBytes.
Perform an operation with a 'CryptoHashSHA512State of size cryptoHashSHA512StateBytes allocated and deallocated automatically.
⚠️ The return value of withCryptoHashSHA512State MUST NOT leak the CryptoHashSHA512State.
Please refer to the documentation of allocaBytes for more operational details.
value
cryptoHashSHA512Init :: Ptr CryptoHashSHA512StateA pointer to an initialised hash state. Cannot be
Foreign.nullPtr.-> IO CIntReturns 0 on success, -1 on error.
This function initializes the CryptoHashSHA512State state.
Call this function on a 'Ptr CryptoHashSHA512State' before using it as an argument in any other function in this module.
Add a new chunk to the message that will eventually be hashed.
After all parts have been supplied, cryptoHashSHA512Final can be used to finalise the operation and get the final hash.
Finalise the hashing of a message. The final hash is padded with extra zeros if necessary, then put in a buffer.
After this operation, the buffer containing the CryptoHashSHA512State is emptied and cannot be relied upon.
Constants
The size of a SHA512-hash message.
The size of a CryptoHashSHA512State.
HMAC-SHA-512
Single-part message
This is the opaque state held and used by the HMAC-SHA-512 functions.
Its size is cryptoAuthHMACSHA512StateBytes bytes.
Please refer to the documentation of allocaBytes for more operational details.
Perform an operation with a CryptoAuthHMACSHA512State of size cryptoAuthHMACSHA512StateBytes allocated and deallocated automatically.
⚠️ The return value of withCryptoAuthHMACSHA512State MUST NOT leak the CryptoAuthHMACSHA512State.
Please refer to the documentation of allocaBytes for more operational details.
value
cryptoAuthHMACSHA512 :: Ptr CUCharA pointer to the buffer holding the authenticator.
-> Ptr CUCharA pointer to the message to be authenticated.
-> CULLongThe length of the message to be authenticated.
-> Ptr CUCharA pointer to the secret key used for authentication, of length cryptoAuthHMACSHA512Bytes.
-> IO CIntReturns 0 on success, -1 on error.
Authenticate a message given its size and a secret key, and produce an authenticator to be validated with cryptoAuthHMACSHA512Verify.
See: crypto_auth_hmacsha512().
value
cryptoAuthHMACSHA512Verify :: Ptr CUCharA pointer to buffer holding the authenticator.
-> Ptr CUCharA pointer to the message that is being authenticated.
-> CULLongThe length of the message that is being authenticated.
-> Ptr CUCharA pointer to the secret key, of size cryptoAuthHMACSHA512KeyBytes.
-> IO CIntReturns 0 on success, -1 on failure.
Verify that an authenticator provided by cryptoAuthHMACSHA512 is correct.
value
cryptoAuthHMACSHA512Keygen :: Ptr CUCharA pointer to the buffer that will hold the secret key, of size cryptoAuthHMACSHA512KeyBytes.
-> IO ()Nothing is returned
Create a random key of the correct length.
Multi-part messages
This function initializes the CryptoAuthHMACSHA512State state.
Call this function on a 'Ptr CryptoAuthHMACSHA512State' before using it as an argument in any other function in this module.
Add a new chunk to the message that will eventually be hashed.
After all parts have been supplied, cryptoAuthHMACSHA512Final can be used to finalise the operation and get the final hash.
Finalise the hashing of a message. The final hash is padded with extra zeros if necessary, then put in a buffer.
After this operation, the buffer containing the CryptoAuthHMACSHA512State is emptied and cannot be relied upon.
Constants
The size of a CryptoAuthHMACSHA512State.
The size of a HMAC-SHA-512 hash
The size of a HMAC-SHA-512 key
HMAC-SHA-512-256
HMAC-SHA-512-256 is implemented as HMAC-SHA-512 with the output truncated to 256 bits. This is slightly faster than HMAC-SHA-256. Note that this construction is not the same as HMAC-SHA-512/256, which is HMAC using the SHA-512/256 function.
Single-part message
This is the opaque state held and used by the HMAC-SHA-512256 functions.
Its size is cryptoAuthHMACSHA512256StateBytes bytes.
Please refer to the documentation of allocaBytes for more operational details.
Perform an operation with a CryptoAuthHMACSHA512256State of size cryptoAuthHMACSHA512256StateBytes allocated and deallocated automatically.
⚠️ The return value of withCryptoAuthHMACSHA512256State MUST NOT leak the CryptoAuthHMACSHA512256State.
Please refer to the documentation of allocaBytes for more operational details.
value
cryptoAuthHMACSHA512256 :: Ptr CUCharA pointer to the buffer holding the authenticator.
-> Ptr CUCharA pointer to the message to be authenticated.
-> CULLongThe length of the message to be authenticated.
-> Ptr CUCharA pointer to the secret key used for authentication, of length cryptoAuthHMACSHA512256Bytes.
-> IO CIntReturns 0 on success, -1 on error.
Authenticate a message given its size and a secret key, and produce an authenticator to be validated with cryptoAuthHMACSHA512256Verify.
value
cryptoAuthHMACSHA512256Verify :: Ptr CUCharA pointer to buffer holding the authenticator.
-> Ptr CUCharA pointer to the message that is being authenticated.
-> CULLongThe length of the message that is being authenticated.
-> Ptr CUCharA pointer to the secret key, of size cryptoAuthHMACSHA512256KeyBytes.
-> IO CIntReturns 0 on success, -1 on failure.
Verify that an authenticator provided by cryptoAuthHMACSHA512256 is correct.
value
cryptoAuthHMACSHA512256Keygen :: Ptr CUCharA pointer to the buffer that will hold the secret key, of size cryptoAuthHMACSHA512256KeyBytes.
-> IO ()Nothing is returned
Create a random key of the correct length.
Multi-part messages
This function initializes the CryptoAuthHMACSHA512256State state.
Call this function on a Ptr CryptoAuthHMACSHA512256State before using it as an argument in any other function in this module.
Add a new chunk to the message that will eventually be hashed.
After all parts have been supplied, cryptoAuthHMACSHA512256Final can be used to finalise the operation and get the final hash.
Finalise the hashing of a message. The final hash is padded with extra zeros if necessary, then put in a buffer.
After this operation, the buffer containing the CryptoAuthHMACSHA512256State is emptied and cannot be relied upon.
Constants
The size of a CryptoAuthHMACSHA512256State.
The size of a HMAC-SHA-512256 hash
The size of a HMAC-SHA-512256 key