Safe Haskell	None
Language	GHC2021

Monocypher.C

Contents

Utils
Memory
Aead
- Incremental
BLAKE2b
- Incremental
Argon2
X25519
- Elligator
EdDSA
ChaCha20
Poly1305
- Incremental
SHA512
- Incremental
HMAC-SHA512
- Incremental
HKDF-SHA512
Ed25519
Ed25519ph
Constants

Description

Low level bindings to the monocypher C library.

Version

The Haskell library monocypher version A.B.C.D is compatible with the C library monocypher version A.B.C, which is shipped and compiled together with this Haskell library. The D part of the version number is the only one we increment in the Haskell library independently from the C library.

License

This module is dual-licensed the same way the monocypher C library is. Namely, you can choose the license you prefer among CC0-1.0 or BSD-2-Clause.

Differences from the C library

The the crypto_ prefix is dropped from every name.
The argon2 function takes all its parameters separately instead of wrapping them in different structures like the C crypto_argon2 version does. Also, the necessary work_area is allocated automatically.
The eddsa_key_pair, ed25519_key_pair and elligator_key_pair functions don't wipe the passed in seed value. Their C counterparts do.
The crypto_aead_ctx, crypto_blake2b and crypto_poly1305_ctx C structures are opaque, represented in Haskell by AEAD_CTX, BLAKE2B_CTX, etc. They can be allocated with aead_ctx_malloc, blake2b_ctx_malloc, etc.
We export type-level constants for sizes and alignments used throughout this module. The names of these constants are not official, in the sense that the C library doesn't use any names for constants, and instead it mentions numbers like 32 or 64 directly.

Synopsis

verify16 :: Ptr Word8 -> Ptr Word8 -> CInt
verify32 :: Ptr Word8 -> Ptr Word8 -> CInt
verify64 :: Ptr Word8 -> Ptr Word8 -> CInt
wipe :: Ptr Word8 -> CSize -> IO ()
aead_lock :: Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> CSize -> Ptr Word8 -> CSize -> IO ()
aead_unlock :: Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> CSize -> Ptr Word8 -> CSize -> IO CInt
newtype AEAD_CTX = AEAD_CTX (ForeignPtr AEAD_CTX)
aead_ctx_malloc :: IO AEAD_CTX
aead_init_x :: Ptr AEAD_CTX -> Ptr Word8 -> Ptr Word8 -> IO ()
aead_init_djb :: Ptr AEAD_CTX -> Ptr Word8 -> Ptr Word8 -> IO ()
aead_init_ietf :: Ptr AEAD_CTX -> Ptr Word8 -> Ptr Word8 -> IO ()
aead_write :: Ptr AEAD_CTX -> Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> CSize -> Ptr Word8 -> CSize -> IO ()
aead_read :: Ptr AEAD_CTX -> Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> CSize -> Ptr Word8 -> CSize -> IO CInt
blake2b :: Ptr Word8 -> CSize -> Ptr Word8 -> CSize -> IO ()
blake2b_keyed :: Ptr Word8 -> CSize -> Ptr Word8 -> CSize -> Ptr Word8 -> CSize -> IO ()
newtype BLAKE2B_CTX = BLAKE2B_CTX (ForeignPtr BLAKE2B_CTX)
blake2b_ctx_malloc :: IO BLAKE2B_CTX
blake2b_init :: Ptr BLAKE2B_CTX -> CSize -> IO ()
blake2b_keyed_init :: Ptr BLAKE2B_CTX -> CSize -> Ptr Word8 -> CSize -> IO ()
blake2b_update :: Ptr BLAKE2B_CTX -> Ptr Word8 -> CSize -> IO ()
blake2b_final :: Ptr BLAKE2B_CTX -> Ptr Word8 -> IO ()
data Argon2Algorithm
argon2 :: Ptr Word8 -> Word32 -> Argon2Algorithm -> Word32 -> Word32 -> Word32 -> Ptr Word8 -> Word32 -> Ptr Word8 -> Word32 -> Ptr Word8 -> Word32 -> Ptr Word8 -> Word32 -> IO ()
x25519_public_key :: Ptr Word8 -> Ptr Word8 -> IO ()
x25519 :: Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> IO ()
x25519_to_eddsa :: Ptr Word8 -> Ptr Word8 -> IO ()
x25519_inverse :: Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> IO ()
x25519_dirty_small :: Ptr Word8 -> Ptr Word8 -> IO ()
x25519_dirty_fast :: Ptr Word8 -> Ptr Word8 -> IO ()
elligator_map :: Ptr Word8 -> Ptr Word8 -> IO ()
elligator_rev :: Ptr Word8 -> Ptr Word8 -> Word8 -> IO CInt
elligator_key_pair :: Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> IO ()
eddsa_key_pair :: Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> IO ()
eddsa_sign :: Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> CSize -> IO ()
eddsa_check :: Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> CSize -> IO CInt
eddsa_to_x25519 :: Ptr Word8 -> Ptr Word8 -> IO ()
eddsa_trim_scalar :: Ptr Word8 -> Ptr Word8 -> IO ()
eddsa_reduce :: Ptr Word8 -> Ptr Word8 -> IO ()
eddsa_mul_add :: Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> IO ()
eddsa_scalarbase :: Ptr Word8 -> Ptr Word8 -> IO ()
eddsa_check_equation :: Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> IO CInt
chacha20_h :: Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> IO ()
chacha20_djb :: Ptr Word8 -> Ptr Word8 -> CSize -> Ptr Word8 -> Ptr Word8 -> Word64 -> IO Word64
chacha20_ietf :: Ptr Word8 -> Ptr Word8 -> CSize -> Ptr Word8 -> Ptr Word8 -> Word32 -> IO Word32
chacha20_x :: Ptr Word8 -> Ptr Word8 -> CSize -> Ptr Word8 -> Ptr Word8 -> Word64 -> IO Word64
poly1305 :: Ptr Word8 -> Ptr Word8 -> CSize -> Ptr Word8 -> IO ()
newtype POLY1305_CTX = POLY1305_CTX (ForeignPtr POLY1305_CTX)
poly1305_ctx_malloc :: IO POLY1305_CTX
poly1305_init :: Ptr POLY1305_CTX -> Ptr Word8 -> IO ()
poly1305_update :: Ptr POLY1305_CTX -> Ptr Word8 -> CSize -> IO ()
poly1305_final :: Ptr POLY1305_CTX -> Ptr Word8 -> IO ()
sha512 :: Ptr Word8 -> Ptr Word8 -> CSize -> IO ()
newtype SHA512_CTX = SHA512_CTX (ForeignPtr SHA512_CTX)
sha512_ctx_malloc :: IO SHA512_CTX
sha512_init :: Ptr SHA512_CTX -> IO ()
sha512_update :: Ptr SHA512_CTX -> Ptr Word8 -> CSize -> IO ()
sha512_final :: Ptr SHA512_CTX -> Ptr Word8 -> IO ()
sha512_hmac :: Ptr Word8 -> Ptr Word8 -> CSize -> Ptr Word8 -> CSize -> IO ()
newtype SHA512_HMAC_CTX = SHA512_HMAC_CTX (ForeignPtr SHA512_HMAC_CTX)
sha512_hmac_ctx_malloc :: IO SHA512_HMAC_CTX
sha512_hmac_init :: Ptr SHA512_HMAC_CTX -> Ptr Word8 -> CSize -> IO ()
sha512_hmac_update :: Ptr SHA512_HMAC_CTX -> Ptr Word8 -> CSize -> IO ()
sha512_hmac_final :: Ptr SHA512_HMAC_CTX -> Ptr Word8 -> IO ()
sha512_hkdf_expand :: Ptr Word8 -> CSize -> Ptr Word8 -> CSize -> Ptr Word8 -> CSize -> IO ()
sha512_hkdf :: Ptr Word8 -> CSize -> Ptr Word8 -> CSize -> Ptr Word8 -> CSize -> Ptr Word8 -> CSize -> IO ()
ed25519_key_pair :: Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> IO ()
ed25519_sign :: Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> CSize -> IO ()
ed25519_check :: Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> CSize -> IO CInt
ed25519_ph_sign :: Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> IO ()
ed25519_ph_check :: Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> IO CInt
type AEAD_CTX_SIZE = 48
type AEAD_CTX_ALIGNMENT = 8
type BLAKE2B_HASH_MAX_SIZE = 64
type BLAKE2B_KEY_MAX_SIZE = 64
type BLAKE2B_CTX_SIZE = 224
type BLAKE2B_CTX_ALIGNMENT = 8
type X25519_POINT_SIZE = 32
type X25519_PUBLIC_KEY_SIZE = 32
type X25519_SECRET_KEY_SIZE = 32
type X25519_SHARED_SECRET_SIZE = 32
type ED25519_SECRET_KEY_SIZE = 64
type ED25519_PUBLIC_KEY_SIZE = 32
type ED25519_SEED_SIZE = 32
type ED25519_SIGNATURE_SIZE = 64
type EDDSA_POINT_SIZE = 32
type EDDSA_PUBLIC_KEY_SIZE = 32
type EDDSA_SECRET_KEY_SIZE = 64
type EDDSA_SEED_SIZE = 32
type EDDSA_SHARED_SECRET_SIZE = 32
type EDDSA_SIGNATURE_SIZE = 64
type CHACHA20_OUT_SIZE = 32
type CHACHA20_KEY_SIZE = 32
type CHACHA20_DJB_NONCE_SIZE = 8
type CHACHA20_IETF_NONCE_SIZE = 12
type CHACHA20_X_NONCE_SIZE = 24
type HCHACHA20_NONCE_SIZE = 16
type POLY1305_KEY_SIZE = 32
type POLY1305_MAC_SIZE = 16
type POLY1305_CTX_SIZE = 80
type POLY1305_CTX_ALIGNMENT = 8
type ELLIGATOR_HIDDEN_SIZE = 32
type ELLIGATOR_SEED_SIZE = 32
type SHA512_HASH_SIZE = 64
type SHA512_CTX_SIZE = 216
type SHA512_CTX_ALIGNMENT = 8
type SHA512_HMAC_CTX_SIZE = 344
type SHA512_HMAC_CTX_ALIGNMENT = 8

Utils

verify16 Source #

Arguments

:: Ptr Word8	`const uint8_t a[16]`.
-> Ptr Word8	`const uint8_t b[16]`.
-> CInt	`0` if `a` and `b` are equal, `-1` otherwise.

See crypto_verify16()

verify32 Source #

Arguments

:: Ptr Word8	`const uint8_t a[32]`.
-> Ptr Word8	`const uint8_t b[32]`.
-> CInt	`0` if `a` and `b` are equal, `-1` otherwise.

See crypto_verify32()

verify64 Source #

Arguments

:: Ptr Word8	`const uint8_t a[64]`.
-> Ptr Word8	`const uint8_t b[64]`.
-> CInt	`0` if `a` and `b` are equal, `-1` otherwise.

See crypto_verify64()

Memory

wipe Source #

Arguments

:: Ptr Word8	`void * secret`.
-> CSize	`size_t size`.
-> IO ()

wipe

Aead

aead_lock Source #

Arguments

:: Ptr Word8	`uint8_t * cipher_text`.
-> Ptr Word8	`uint8_t mac[POLY1305_MAC_SIZE]`.
-> Ptr Word8	`const uint8_t key[CHACHA20_KEY_SIZE]`.
-> Ptr Word8	`const uint8_t nonce[CHACHA20_X_NONCE_SIZE]`.
-> Ptr Word8	`const uint8_t * ad`.
-> CSize	`size_t ad_size`.
-> Ptr Word8	`const uint8_t * plain_text`.
-> CSize	`size_t text_size`.
-> IO ()

See crypto_aead_lock()

aead_unlock Source #

Arguments

:: Ptr Word8	`uint8_t * plain_text`.
-> Ptr Word8	`const uint8_t mac[POLY1305_MAC_SIZE]`.
-> Ptr Word8	`const uint8_t key[CHACHA20_KEY_SIZE]`.
-> Ptr Word8	`const uint8_t nonce[CHACHA20_X_NONCE_SIZE]`.
-> Ptr Word8	`const uint8_t * ad`.
-> CSize	`size_t ad_size`.
-> Ptr Word8	`const uint8_t * cipher_text`.
-> CSize	`size_t text_size`.
-> IO CInt	`0` on successful decryption, `-1` otherwise.

See crypto_aead_unlock()

Incremental

newtype AEAD_CTX Source #

See crypto_aead_ctx.

Allocate with aead_ctx_malloc.

Constructors

AEAD_CTX (ForeignPtr AEAD_CTX)

The constructor is exposed in case your want to obtain the ForeignPtr by means other than aead_ctx_malloc.

You can use withForeignPtr to obtain the Ptr necessary by many of the functions in this module.

Instances

Instances details

Storable AEAD_CTX Source #	Peek allocates memory using `aead_ctx_malloc`, so it will be automatically wiped when unreachable.
Instance details Defined in Monocypher.C Methods sizeOf :: AEAD_CTX -> Int # alignment :: AEAD_CTX -> Int # peekElemOff :: Ptr AEAD_CTX -> Int -> IO AEAD_CTX # pokeElemOff :: Ptr AEAD_CTX -> Int -> AEAD_CTX -> IO () # peekByteOff :: Ptr b -> Int -> IO AEAD_CTX # pokeByteOff :: Ptr b -> Int -> AEAD_CTX -> IO () # peek :: Ptr AEAD_CTX -> IO AEAD_CTX # poke :: Ptr AEAD_CTX -> AEAD_CTX -> IO () #

aead_ctx_malloc :: IO AEAD_CTX Source #

Allocated with mallocForeignPtr, but also automatically wiped when not reachable anymore, before being freed.

aead_init_x Source #

Arguments

:: Ptr AEAD_CTX	`crypto_aead_ctx * ctx`. Allocate with `aead_ctx_malloc`
-> Ptr Word8	`const uint8_t key[CHACHA20_KEY_SIZE]`.
-> Ptr Word8	`const uint8_t nonce[CHACHA20_X_NONCE_SIZE]`.
-> IO ()

See crypto_aead_init_x()

aead_init_djb Source #

Arguments

:: Ptr AEAD_CTX	`crypto_aead_ctx * ctx`. Allocate with `aead_ctx_malloc`
-> Ptr Word8	`const uint8_t key[CHACHA20_KEY_SIZE]`.
-> Ptr Word8	`const uint8_t nonce[CHACHA20_DJB_NONCE_SIZE]`.
-> IO ()

See crypto_aead_init_djb()

aead_init_ietf Source #

Arguments

:: Ptr AEAD_CTX	`crypto_aead_ctx * ctx`. Allocate with `aead_ctx_malloc`
-> Ptr Word8	`const uint8_t key[CHACHA20_KEY_SIZE]`.
-> Ptr Word8	`const uint8_t nonce[CHACHA20_IETF_NONCE_SIZE]`.
-> IO ()

See crypto_aead_init_ietf()

aead_write Source #

Arguments

:: Ptr AEAD_CTX	`crypto_aead_ctx * ctx`.
-> Ptr Word8	`uint8_t * cipher_text`.
-> Ptr Word8	`uint8_t mac[POLY1305_MAC_SIZE]`.
-> Ptr Word8	`const uint8_t * ad`.
-> CSize	`size_t ad_size`.
-> Ptr Word8	`const uint8_t * plain_text`.
-> CSize	`size_t text_size`.
-> IO ()

See crypto_aead_write()

aead_read Source #

Arguments

:: Ptr AEAD_CTX	`crypto_aead_ctx * ctx`.
-> Ptr Word8	`uint8_t * plain_text`.
-> Ptr Word8	`const uint8_t mac[POLY1305_MAC_SIZE]`.
-> Ptr Word8	`const uint8_t * ad`.
-> CSize	`size_t ad_size`.
-> Ptr Word8	`const uint8_t * cipher_text`.
-> CSize	`size_t text_size`.
-> IO CInt	`0` on successful decryption, `-1` otherwise.

See crypto_aead_read()

BLAKE2b

blake2b Source #

Arguments

:: Ptr Word8	`uint8_t * hash`.
-> CSize	`size_t hash_size`.
-> Ptr Word8	`const uint8_t * message`.
-> CSize	`size_t message_size`.
-> IO ()

See crypto_blake2b()

blake2b_keyed Source #

Arguments

:: Ptr Word8	`uint8_t * hash`.
-> CSize	`size_t hash_size`.
-> Ptr Word8	`const uint8_t * key`.
-> CSize	`size_t key_size`.
-> Ptr Word8	`const uint8_t * message`.
-> CSize	`size_t message_size`.
-> IO ()

See crypto_blake2b_keyed()

Incremental

newtype BLAKE2B_CTX Source #

See crypto_blake2b_ctx. Allocate with blake2b_ctx_malloc.

Constructors

BLAKE2B_CTX (ForeignPtr BLAKE2B_CTX)

The constructor is exposed in case your want to obtain the ForeignPtr by means other than blake2b_ctx_malloc.

You can use withForeignPtr to obtain the Ptr necessary by many of the functions in this module.

Instances

Instances details

Storable BLAKE2B_CTX Source #

Peek allocates memory using blake2b_ctx_malloc, so it will be automatically wiped when unreachable.

Instance details

Defined in Monocypher.C

Methods

sizeOf :: BLAKE2B_CTX -> Int #

alignment :: BLAKE2B_CTX -> Int #

peekElemOff :: Ptr BLAKE2B_CTX -> Int -> IO BLAKE2B_CTX #

pokeElemOff :: Ptr BLAKE2B_CTX -> Int -> BLAKE2B_CTX -> IO () #

peekByteOff :: Ptr b -> Int -> IO BLAKE2B_CTX #

pokeByteOff :: Ptr b -> Int -> BLAKE2B_CTX -> IO () #

peek :: Ptr BLAKE2B_CTX -> IO BLAKE2B_CTX #

poke :: Ptr BLAKE2B_CTX -> BLAKE2B_CTX -> IO () #

blake2b_ctx_malloc :: IO BLAKE2B_CTX Source #

Allocated with mallocForeignPtr, but also automatically wiped when not reachable anymore, before being freed.

blake2b_init Source #

Arguments

:: Ptr BLAKE2B_CTX	`crypto_blake2b_ctx * ctx`. Allocate with `blake2b_ctx_malloc`.
-> CSize	`size_t hash_size`.
-> IO ()

See crypto_blake2b_init()

blake2b_keyed_init Source #

Arguments

:: Ptr BLAKE2B_CTX	`crypto_blake2b_ctx * ctx`. Allocate with `blake2b_ctx_malloc`.
-> CSize	`size_t hash_size`.
-> Ptr Word8	`const uint8_t * key`.
-> CSize	`size_t key_size`.
-> IO ()

See crypto_blake2b_keyed_init()

blake2b_update Source #

Arguments

:: Ptr BLAKE2B_CTX	`crypto_blake2b_ctx * ctx`.
-> Ptr Word8	`const uint8_t * message`.
-> CSize	`size_t message_size`.
-> IO ()

See crypto_blake2b_update()

blake2b_final Source #

Arguments

:: Ptr BLAKE2B_CTX	`crypto_blake2b_ctx * ctx`.
-> Ptr Word8	`uint8_t * hash`.
-> IO ()

See crypto_blake2b_final()

Argon2

data Argon2Algorithm Source #

Instances

Instances details

Enum Argon2Algorithm Source #
Instance details Defined in Monocypher.C Methods succ :: Argon2Algorithm -> Argon2Algorithm # pred :: Argon2Algorithm -> Argon2Algorithm # toEnum :: Int -> Argon2Algorithm # fromEnum :: Argon2Algorithm -> Int # enumFrom :: Argon2Algorithm -> [Argon2Algorithm] # enumFromThen :: Argon2Algorithm -> Argon2Algorithm -> [Argon2Algorithm] # enumFromTo :: Argon2Algorithm -> Argon2Algorithm -> [Argon2Algorithm] # enumFromThenTo :: Argon2Algorithm -> Argon2Algorithm -> Argon2Algorithm -> [Argon2Algorithm] #
Show Argon2Algorithm Source #
Instance details Defined in Monocypher.C Methods showsPrec :: Int -> Argon2Algorithm -> ShowS # show :: Argon2Algorithm -> String # showList :: [Argon2Algorithm] -> ShowS #
Eq Argon2Algorithm Source #
Instance details Defined in Monocypher.C Methods (==) :: Argon2Algorithm -> Argon2Algorithm -> Bool # (/=) :: Argon2Algorithm -> Argon2Algorithm -> Bool #
Ord Argon2Algorithm Source #
Instance details Defined in Monocypher.C Methods compare :: Argon2Algorithm -> Argon2Algorithm -> Ordering # (<) :: Argon2Algorithm -> Argon2Algorithm -> Bool # (<=) :: Argon2Algorithm -> Argon2Algorithm -> Bool # (>) :: Argon2Algorithm -> Argon2Algorithm -> Bool # (>=) :: Argon2Algorithm -> Argon2Algorithm -> Bool # max :: Argon2Algorithm -> Argon2Algorithm -> Argon2Algorithm # min :: Argon2Algorithm -> Argon2Algorithm -> Argon2Algorithm #

argon2 Source #

Arguments

:: Ptr Word8	`uint8_t * hash`.
-> Word32	`uint32_t hash_size`.
-> Argon2Algorithm	`uint32_t algorithm`.
-> Word32	`uint32_t nb_blocks`.
-> Word32	`uint32_t nb_passes`.
-> Word32	`uint32_t nb_lanes`.
-> Ptr Word8	`const uint8_t * pass`.
-> Word32	`uint32_t pass_size`.
-> Ptr Word8	`const uint8_t * salt`.
-> Word32	`uint32_t salt_size`.
-> Ptr Word8	`const uint8_t * key`.
-> Word32	`uint32_t key_size`.
-> Ptr Word8	`const uint8_t * ad`.
-> Word32	`uint32_t ad_size`.
-> IO ()

See crypto_argon2()

Contrary to the C version of crypto_argon2(), this version takes all the inputs individually, rather than in the separate crypto_argon2_config, crypto_argon2_inputs and crypto_argon2_extras structures, and a sufficiently large work_area is automatically provided.

X25519

x25519_public_key Source #

Arguments

:: Ptr Word8	`uint8_t public_key[X25519_PUBLIC_KEY_SIZE]`.
-> Ptr Word8	`const uint8_t secret_key[X25519_SECRET_KEY_SIZE]`.
-> IO ()

See crypto_x25519_public_key()

x25519 Source #

Arguments

:: Ptr Word8	`uint8_t raw_shared_secret[X25519_SHARED_SECRET_SIZE]`.
-> Ptr Word8	`const uint8_t your_secret_key[X25519_SECRET_KEY_SIZE]`.
-> Ptr Word8	`const uint8_t their_public_key[X25519_PUBLIC_KEY_SIZE]`.
-> IO ()

See crypto_x25519()

x25519_to_eddsa Source #

Arguments

:: Ptr Word8	`uint8_t eddsa[EDDSA_PUBLIC_KEY_SIZE]`.
-> Ptr Word8	`const uint8_t x25519[X25519_PUBLIC_KEY_SIZE]`.
-> IO ()

See crypto_x25519_to_eddsa()

x25519_inverse Source #

Arguments

:: Ptr Word8	`uint8_t blind_salt[X25519_POINT_SIZE]`.
-> Ptr Word8	`const uint8_t private_key[X25519_SECRET_KEY_SIZE]`.
-> Ptr Word8	`const uint8_t curve_point[X25519_POINT_SIZE]`.
-> IO ()

See crypto_x25519_inverse()

x25519_dirty_small Source #

Arguments

:: Ptr Word8	`uint8_t pk[X25519_PUBLIC_KEY_SIZE]`.
-> Ptr Word8	`const uint8_t sk[X25519_SECRET_KEY_SIZE]`.
-> IO ()

See crypto_x25519_dirty_small()

x25519_dirty_fast Source #

Arguments

:: Ptr Word8	`uint8_t pk[X25519_PUBLIC_KEY_SIZE]`.
-> Ptr Word8	`const uint8_t sk[X25519_SECRET_KEY_SIZE]`.
-> IO ()

See crypto_x25519_dirty_fast()

Elligator

elligator_map Source #

Arguments

:: Ptr Word8	`uint8_t point[X25519_POINT_SIZE]`.
-> Ptr Word8	`const uint8_t hidden[ELLIGATOR_HIDDEN_SIZE]`.
-> IO ()

See crypto_elligator_map()

elligator_rev Source #

Arguments

:: Ptr Word8	`uint8_t hidden[ELLIGATOR_HIDDEN_SIZE]`.
-> Ptr Word8	`const uint8_t public_key[X25519_PUBLIC_KEY_SIZE]`.
-> Word8	`uint8_t tweak`.
-> IO CInt	`0` on success, `-1` if the given curve argument is unsuitable for hiding.

See crypto_elligator_rev()

elligator_key_pair Source #

Arguments

:: Ptr Word8	`uint8_t hidden[ELLIGATOR_HIDDEN_SIZE]`.
-> Ptr Word8	`uint8_t secret_key[X25519_SECRET_KEY_SIZE]`.
-> Ptr Word8	`const uint8_t seed[ELLIGATOR_SEED_SIZE]`.
-> IO ()

See crypto_elligator_key_pair().

Contrary to the C version of crypto_elligator_key_pair(), this version does not wipe the passed in seed.

EdDSA

EdDSA on Curve25519 using BLAKE2b as hash algorithm.

Warning: This is not compatible with the more commonly deployed Ed25519, which is EdDSA on Curve25519 using SHA512 as hash algorithm.

eddsa_key_pair Source #

Arguments

:: Ptr Word8	`uint8_t secret_key[EDDSA_SECRET_KEY_SIZE]`.
-> Ptr Word8	`uint8_t public_key[EDDSA_PUBLIC_KEY_SIZE]`.
-> Ptr Word8	`const uint8_t seed[EDDSA_SEED_SIZE]`.
-> IO ()

See crypto_eddsa_key_pair().

Contrary to the C version of crypto_eddsa_key_pair(), this version does not wipe the passed in seed.

eddsa_sign Source #

Arguments

:: Ptr Word8	`uint8_t signature[EDDSA_SIGNATURE_SIZE]`.
-> Ptr Word8	`const uint8_t secret_key[EDDSA_SECRET_KEY_SIZE]`.
-> Ptr Word8	`const uint8_t * message`.
-> CSize	`size_t message_size`.
-> IO ()

See crypto_eddsa_sign()

eddsa_check Source #

Arguments

:: Ptr Word8	`const uint8_t signature[EDDSA_SIGNATURE_SIZE]`.
-> Ptr Word8	`const uint8_t public_key[EDDSA_PUBLIC_KEY_SIZE]`.
-> Ptr Word8	`const uint8_t * message`.
-> CSize	`size_t message_size`.
-> IO CInt	`0` if signature is legitimate, `-1` otherwise.

See crypto_eddsa_check()

eddsa_to_x25519 Source #

Arguments

:: Ptr Word8	`uint8_t x25519[X25519_PUBLIC_KEY_SIZE]`.
-> Ptr Word8	`const uint8_t eddsa[EDDSA_PUBLIC_KEY_SIZE]`.
-> IO ()

See crypto_eddsa_to_x25519()

eddsa_trim_scalar Source #

Arguments

:: Ptr Word8	`uint8_t out[32]`.
-> Ptr Word8	`const uint8_t in[32]`.
-> IO ()

See crypto_eddsa_trim_scalar()

eddsa_reduce Source #

Arguments

:: Ptr Word8	`uint8_t reduced[32]`.
-> Ptr Word8	`const uint8_t expanded[64]`.
-> IO ()

See crypto_eddsa_reduce()

eddsa_mul_add Source #

Arguments

:: Ptr Word8	`uint8_t r[32]`.
-> Ptr Word8	`const uint8_t a[32]`.
-> Ptr Word8	`const uint8_t b[32]`.
-> Ptr Word8	`const uint8_t c[32]`.
-> IO ()

See crypto_eddsa_mul_add()

eddsa_scalarbase Source #

Arguments

:: Ptr Word8	`uint8_t point[EDDSA_POINT_SIZE]`.
-> Ptr Word8	`const uint8_t scalar[32]`.
-> IO ()

See crypto_eddsa_scalarbase()

eddsa_check_equation Source #

Arguments

:: Ptr Word8	`const uint8_t signature[EDDSA_SIGNATURE_SIZE]`.
-> Ptr Word8	`const uint8_t public_key[EDDSA_PUBLIC_KEY_SIZE]`.
-> Ptr Word8	`const uint8_t h_ram[BLAKE2B_HASH_MAX_SIZE]`.
-> IO CInt	`0` if all checks hold, `-1` otherwise.

See crypto_eddsa_check_equation()

ChaCha20

chacha20_h Source #

Arguments

:: Ptr Word8	`uint8_t out[CHACHA20_OUT_SIZE]`.
-> Ptr Word8	`const uint8_t key[CHACHA20_KEY_SIZE]`.
-> Ptr Word8	`const uint8_t in[HCHACHA20_NONCE_SIZE]`.
-> IO ()

See crypto_chacha20_h()

chacha20_djb Source #

Arguments

:: Ptr Word8	`uint8_t * cipher_text`.
-> Ptr Word8	`const uint8_t * plain_text`.
-> CSize	`size_t text_size`.
-> Ptr Word8	`const uint8_t key[CHACHA20_KEY_SIZE]`.
-> Ptr Word8	`const uint8_t nonce[CHACHA20_DJB_NONCE_SIZE]`.
-> Word64	`uint64_t ctr`.
-> IO Word64	Next `ctr` to use with the same key and nonce values.

See crypto_chacha20_djb()

chacha20_ietf Source #

Arguments

:: Ptr Word8	`uint8_t * cipher_text`.
-> Ptr Word8	`const uint8_t * plain_text`.
-> CSize	`size_t text_size`.
-> Ptr Word8	`const uint8_t key[CHACHA20_KEY_SIZE]`.
-> Ptr Word8	`const uint8_t nonce[CHACHA20_IETF_NONCE_SIZE]`.
-> Word32	`uint32_t ctr`.
-> IO Word32	Next `ctr` to use with the same key and nonce values.

See crypto_chacha20_ietf()

chacha20_x Source #

Arguments

:: Ptr Word8	`uint8_t * cipher_text`.
-> Ptr Word8	`const uint8_t * plain_text`.
-> CSize	`size_t text_size`.
-> Ptr Word8	`const uint8_t key[CHACHA20_KEY_SIZE]`.
-> Ptr Word8	`const uint8_t nonce[CHACHA20_X_NONCE_SIZE]`.
-> Word64	`uint64_t ctr`.
-> IO Word64	Next `ctr` to use with the same key and nonce values.

See crypto_chacha20_x()

Poly1305

poly1305 Source #

Arguments

:: Ptr Word8	`uint8_t mac[POLY1305_MAC_SIZE]`.
-> Ptr Word8	`const uint8_t * message`.
-> CSize	`size_t message_size`.
-> Ptr Word8	`const uint8_t key[POLY1305_KEY_SIZE]`.
-> IO ()

See crypto_poly1305()

Incremental

newtype POLY1305_CTX Source #

See crypto_poly1305

Allocate with poly1305_ctx_malloc.

Constructors

POLY1305_CTX (ForeignPtr POLY1305_CTX)

The constructor is exposed in case your want to obtain the ForeignPtr by means other than poly1305_ctx_malloc.

You can use withForeignPtr to obtain the Ptr necessary by many of the functions in this module.

Instances

Instances details

Storable POLY1305_CTX Source #

Peek allocates memory using poly1305_ctx_malloc, so it will be automatically wiped when unreachable.

Instance details

Defined in Monocypher.C

Methods

sizeOf :: POLY1305_CTX -> Int #

alignment :: POLY1305_CTX -> Int #

peekElemOff :: Ptr POLY1305_CTX -> Int -> IO POLY1305_CTX #

pokeElemOff :: Ptr POLY1305_CTX -> Int -> POLY1305_CTX -> IO () #

peekByteOff :: Ptr b -> Int -> IO POLY1305_CTX #

pokeByteOff :: Ptr b -> Int -> POLY1305_CTX -> IO () #

peek :: Ptr POLY1305_CTX -> IO POLY1305_CTX #

poke :: Ptr POLY1305_CTX -> POLY1305_CTX -> IO () #

poly1305_ctx_malloc :: IO POLY1305_CTX Source #

Allocated with mallocForeignPtr, but also automatically wiped when not reachable anymore, before being freed.

poly1305_init Source #

Arguments

:: Ptr POLY1305_CTX	`crypto_poly1305_ctx * ctx`. Allocate with `poly1305_ctx_malloc`.
-> Ptr Word8	`const uint8_t key[POLY1305_KEY_SIZE]`.
-> IO ()

See crypto_poly1305_init()

poly1305_update Source #

Arguments

:: Ptr POLY1305_CTX	`crypto_poly1305_ctx * ctx`.
-> Ptr Word8	`const uint8_t * message`.
-> CSize	`size_t message_size`.
-> IO ()

See crypto_poly1305_update()

poly1305_final Source #

Arguments

:: Ptr POLY1305_CTX	`crypto_poly1305_ctx * ctx`.
-> Ptr Word8	`uint8_t mac[POLY1305_MAC_SIZE]`.
-> IO ()

See crypto_poly1305_final()

SHA512

sha512 Source #

Arguments

:: Ptr Word8	`uint8_t hash[SHA512_HASH_SIZE]`.
-> Ptr Word8	`const uint8_t * message`.
-> CSize	`size_t message_size`.
-> IO ()

See crypto_sha512().

Incremental

newtype SHA512_CTX Source #

See crypto_sha512_ctx

Allocate with sha512_ctx_malloc.

Constructors

SHA512_CTX (ForeignPtr SHA512_CTX)

The constructor is exposed in case your want to obtain the ForeignPtr by means other than sha512_ctx_malloc.

You can use withForeignPtr to obtain the Ptr necessary by many of the functions in this module.

Instances

Instances details

Storable SHA512_CTX Source #

Peek allocates memory using sha512_ctx_malloc, so it will be automatically wiped when unreachable.

Instance details

Defined in Monocypher.C

Methods

sizeOf :: SHA512_CTX -> Int #

alignment :: SHA512_CTX -> Int #

peekElemOff :: Ptr SHA512_CTX -> Int -> IO SHA512_CTX #

pokeElemOff :: Ptr SHA512_CTX -> Int -> SHA512_CTX -> IO () #

peekByteOff :: Ptr b -> Int -> IO SHA512_CTX #

pokeByteOff :: Ptr b -> Int -> SHA512_CTX -> IO () #

peek :: Ptr SHA512_CTX -> IO SHA512_CTX #

poke :: Ptr SHA512_CTX -> SHA512_CTX -> IO () #

sha512_ctx_malloc :: IO SHA512_CTX Source #

Allocated with mallocForeignPtr, but also automatically wiped when not reachable anymore, before being freed.

sha512_init Source #

Arguments

:: Ptr SHA512_CTX	`crypto_sha512_ctx * ctx`.
-> IO ()

See crypto_sha512_init().

sha512_update Source #

Arguments

:: Ptr SHA512_CTX	`crypto_sha512_ctx * ctx`.
-> Ptr Word8	`const uint8_t * message`.
-> CSize	`size_t message_size`.
-> IO ()

See crypto_sha512_update().

sha512_final Source #

Arguments

:: Ptr SHA512_CTX	crypto_sha512_ctx * ctx
-> Ptr Word8	`uint8_t hash[SHA512_HASH_SIZE]`.
-> IO ()

See crypto_sha512_final().

HMAC-SHA512

sha512_hmac Source #

Arguments

:: Ptr Word8	`uint8_t hmac[SHA512_HASH_SIZE]`.
-> Ptr Word8	`const uint8_t * key`.
-> CSize	`size_t key_size`.
-> Ptr Word8	`const uint8_t * message`.
-> CSize	`size_t message_size`.
-> IO ()

See crypto_sha512_hmac().

Incremental

newtype SHA512_HMAC_CTX Source #

See crypto_sha512_hmac_ctx

Allocate with sha512_hmac_ctx_malloc.

Constructors

SHA512_HMAC_CTX (ForeignPtr SHA512_HMAC_CTX)

The constructor is exposed in case your want to obtain the ForeignPtr by means other than sha512_hmac_ctx_malloc.

You can use withForeignPtr to obtain the Ptr necessary by many of the functions in this module.

Instances

Instances details

Storable SHA512_HMAC_CTX Source #

Peek allocates memory using sha512_hmac_ctx_malloc, so it will be automatically wiped when unreachable.

Instance details

Defined in Monocypher.C

Methods

sizeOf :: SHA512_HMAC_CTX -> Int #

alignment :: SHA512_HMAC_CTX -> Int #

peekElemOff :: Ptr SHA512_HMAC_CTX -> Int -> IO SHA512_HMAC_CTX #

pokeElemOff :: Ptr SHA512_HMAC_CTX -> Int -> SHA512_HMAC_CTX -> IO () #

peekByteOff :: Ptr b -> Int -> IO SHA512_HMAC_CTX #

pokeByteOff :: Ptr b -> Int -> SHA512_HMAC_CTX -> IO () #

peek :: Ptr SHA512_HMAC_CTX -> IO SHA512_HMAC_CTX #

poke :: Ptr SHA512_HMAC_CTX -> SHA512_HMAC_CTX -> IO () #

sha512_hmac_ctx_malloc :: IO SHA512_HMAC_CTX Source #

Allocated with mallocForeignPtr, but also automatically wiped when not reachable anymore, before being freed.

sha512_hmac_init Source #

Arguments

:: Ptr SHA512_HMAC_CTX	`crypto_sha512_hmac_ctx * ctx`.
-> Ptr Word8	`const uint8_t * key`.
-> CSize	`size_t key_size`.
-> IO ()

See crypto_sha512_hmac_init().

sha512_hmac_update Source #

Arguments

:: Ptr SHA512_HMAC_CTX	`crypto_sha512_hmac_ctx * ctx`.
-> Ptr Word8	`const uint8_t * message`.
-> CSize	`size_t message_size`.
-> IO ()

See crypto_sha512_hmac_update().

sha512_hmac_final Source #

Arguments

:: Ptr SHA512_HMAC_CTX	`crypto_sha512_hmac_ctx * ctx`.
-> Ptr Word8	`uint8_t hmac[SHA512_HASH_SIZE]`.
-> IO ()

See crypto_sha512_hmac_final().

HKDF-SHA512

sha512_hkdf_expand Source #

Arguments

:: Ptr Word8	`uint8_t * okm`.
-> CSize	`size_t okm_size`.
-> Ptr Word8	`const uint8_t * prk`.
-> CSize	`size_t prk_size`.
-> Ptr Word8	`const uint8_t * info`.
-> CSize	`size_t info_size`.
-> IO ()

See crypto_sha512_hkdf_expand().

sha512_hkdf Source #

Arguments

:: Ptr Word8	`uint8_t * okm`.
-> CSize	`size_t okm_size`.
-> Ptr Word8	`const uint8_t * ikm`.
-> CSize	`size_t ikm_size`.
-> Ptr Word8	`const uint8_t * salt`.
-> CSize	`size_t salt_size`.
-> Ptr Word8	`const uint8_t * info`.
-> CSize	`size_t info_size`.
-> IO ()

See crypto_sha512_hkdf().

Ed25519

EdDSA on Curve25519 using SHA512 as hash algorithm.

ed25519_key_pair Source #

Arguments

:: Ptr Word8	`uint8_t secret_key[ED25519_SECRET_KEY_SIZE]`.
-> Ptr Word8	`uint8_t public_key[ED25519_PUBLIC_KEY_SIZE]`.
-> Ptr Word8	`uint8_t seed[ED25519_SEED_SIZE]`.
-> IO ()

See crypto_ed5519_key_pair().

Contrary to the C version of crypto_ed25519_key_pair(), this version does not wipe the passed in seed.

ed25519_sign Source #

Arguments

:: Ptr Word8	`uint8_t signature[ED25519_SIGNATURE_SIZE]`.
-> Ptr Word8	`const uint8_t secret_key[ED25519_SECRET_KEY_SIZE]`.
-> Ptr Word8	`const uint8_t * message`.
-> CSize	`size_t message_size`.
-> IO ()

See crypto_ed5519_sing().

ed25519_check Source #

Arguments

:: Ptr Word8	`const uint8_t signature[ED25519_SIGNATURE_SIZE]`.
-> Ptr Word8	`const uint8_t public_key[ED25519_PUBLIC_KEY_SIZE]`.
-> Ptr Word8	`const uint8_t * message`.
-> CSize	`size_t message_size`.
-> IO CInt	`0` if signature is legitimate, `-1` otherwise.

See crypto_ed5519_check().

Ed25519ph

Pre-hashed EdDSA on Curve25519 using SHA512 as hash algorithm.

Warning: This is not compatible with the more commonly deployed Ed25519, which is EdDSA on Curve25519 using SHA512 as hash algorithm without pre-hashing.

ed25519_ph_sign Source #

Arguments

:: Ptr Word8	`uint8_t signature[ED25519_SIGNATURE_SIZE]`.
-> Ptr Word8	`const uint8_t secret_key[ED25519_SECRET_KEY_SIZE]`.
-> Ptr Word8	`const uint8_t message_hash[SHA512_HASH_SIZE]`.
-> IO ()

See crypto_ed25519_ph_sign().

ed25519_ph_check Source #

Arguments

:: Ptr Word8	`const uint8_t signature[ED25519_SIGNATURE_SIZE]`.
-> Ptr Word8	`const uint8_t public_key[ED25519_PUBLIC_KEY_SIZE]`.
-> Ptr Word8	`const uint8_t message_hash[SHA512_HASH_SIZE]`.
-> IO CInt	`0` if signature is legitimate, `-1` otherwise.