LibSodium.Bindings.SHA2

Hash the content of the second buffer and put the result in the first buffer.

See: crypto_hash_sha256()

This is the opaque state held and used by the SHA-256 functions.

Its size is cryptoHashSHA256StateBytes.

See: crypto_hash_sha256_state

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.

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.

See: crypto_hash_sha256_init()

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.

See: crypto_hash_sha256_update()

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.

See: crypto_hash_sha256_final()

The size of a SHA256-hashed message.

The size of a CryptoHashSHA256State.

Authenticate a message given its size and a secret key, and produce an authenticator to be validated with cryptoAuthHMACSHA256Verify.

See: crypto_auth_hmacsha256().

Verify that an authenticator provided by cryptoAuthHMACSHA256 is correct.

See: crypto_auth_hmacsha256_verify()

Create a random key of the correct length.

See: crypto_auth_hmacsha256_keygen()

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.

See: crypto_auth_hmacsha256_state

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.

See: crypto_auth_hmacsha256_init()

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.

See: crypto_auth_hmacsha256_update()

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.

See: crypto_auth_hmacsha256_final()

The size of a CryptoAuthHMACSHA256State.

The size of a HMAC-SHA-256 hash

The size of a HMAC-SHA-256 key

Hash the content of the second buffer and put the result in the first buffer.

See: crypto_hash_sha512()

This is the opaque state held and used by the SHA-512 functions.

Its size is cryptoHashSHA512StateBytes.

See: crypto_hash_sha512_state

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.

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.

See: crypto_hash_sha512_init()

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.

See: crypto_hash_sha512_update()

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.

See: crypto_hash_sha512_final()

The size of a SHA512-hash message.

The size of a CryptoHashSHA512State.

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.

See: crypto_auth_hmacsha512_state

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.

Authenticate a message given its size and a secret key, and produce an authenticator to be validated with cryptoAuthHMACSHA512Verify.

See: crypto_auth_hmacsha512().

Verify that an authenticator provided by cryptoAuthHMACSHA512 is correct.

See: crypto_auth_hmacsha512_verify()

Create a random key of the correct length.

See: crypto_auth_hmacsha512_keygen()

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.

See: crypto_auth_hmacsha512_init()

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.

See: crypto_auth_hmacsha512_update()

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.

See: crypto_auth_hmacsha512_final()

The size of a CryptoAuthHMACSHA512State.

The size of a HMAC-SHA-512 hash

The size of a HMAC-SHA-512 key

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.

See: crypto_auth_hmacsha512256_state

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.

Authenticate a message given its size and a secret key, and produce an authenticator to be validated with cryptoAuthHMACSHA512256Verify.

See: crypto_auth_hmacsha512256().

Verify that an authenticator provided by cryptoAuthHMACSHA512256 is correct.

See: crypto_auth_hmacsha512256_verify()

Create a random key of the correct length.

See: crypto_auth_hmacsha512256_keygen()

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.

See: crypto_auth_hmacsha512256_init()

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.

See: crypto_auth_hmacsha512256_update()

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.

See: crypto_auth_hmacsha512256_final()

The size of a CryptoAuthHMACSHA512256State.

The size of a HMAC-SHA-512256 hash

The size of a HMAC-SHA-512256 key