diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,9 @@ # Change log for [raaz]. +## [0.3.2] - Oct 6, 2021 + +Yet another missing header file sets. + ## [0.3.1] - Oct 6, 2021 This release ensures that missing verse.h C header files. Without that @@ -160,4 +164,6 @@ [0.2.2]: [0.2.3]: [0.3.0]: +[0.3.1]: +[0.3.2]: [raaz]: diff --git a/core/Raaz/Core/MonoidalAction.hs b/core/Raaz/Core/MonoidalAction.hs --- a/core/Raaz/Core/MonoidalAction.hs +++ b/core/Raaz/Core/MonoidalAction.hs @@ -96,9 +96,6 @@ mappend = (<>) {-# INLINE mappend #-} - mconcat = foldr mappend mempty - {-# INLINE mconcat #-} - -- | From the an element of semi-direct product Space ⋊ Monoid return -- the point. semiRSpace :: SemiR space m -> space diff --git a/implementation/cbits/raaz/cipher/chacha20/common.h b/implementation/cbits/raaz/cipher/chacha20/common.h new file mode 100644 --- /dev/null +++ b/implementation/cbits/raaz/cipher/chacha20/common.h @@ -0,0 +1,53 @@ +#pragma once + +#include +#include +#include + +typedef uint32_t Word; +typedef Word State[16]; +typedef Word Block[16]; + +/* Implementation in accordance to RFC7539 + * https://tools.ietf.org/html/rfc7539 + * + * Note that there is a difference in the rfc and the version + * published by djb. In the rfc one uses 32-bit counter and 96-bit + * nounce, whereas the published version of djb uses 64bit counter and + * 64bit nounce. + * + * As a result the maximum data that should be encrypted with this + * cipher (for a given key, iv pair). + * + * 2^32 blocks = 256 GB. + * + */ + +typedef uint32_t Counter; +typedef Word IV[3]; +typedef Word Key[8]; + +# define BLOCK_SIZE (sizeof(State)) + +#define C0 ((Word) 0x61707865) +#define C1 ((Word) 0x3320646e) +#define C2 ((Word) 0x79622d32) +#define C3 ((Word) 0x6b206574) + + +/* Vector types */ + +# ifdef HAVE_VECTOR_128 +/* Type of 128-bit SIMD instructions */ +typedef Word Vec __attribute__ ((vector_size (16))); +# endif + +# ifdef HAVE_VECTOR_256 +/* Type of 256-bit SIMD instructions */ +typedef Word Vec2 __attribute__ ((vector_size (32))); +# endif + +# ifdef HAVE_VECTOR_512 +/* Type of 512-bit SIMD instructions */ +typedef Word Vec4 __attribute__ ((vector_size (64))); +# endif diff --git a/implementation/cbits/raaz/hash/blake2/blake2b/constants.h b/implementation/cbits/raaz/hash/blake2/blake2b/constants.h new file mode 100644 --- /dev/null +++ b/implementation/cbits/raaz/hash/blake2/blake2b/constants.h @@ -0,0 +1,12 @@ +#pragma once + +#include + +const Word2b iv2b0 = 0x6a09e667f3bcc908ULL; +const Word2b iv2b1 = 0xbb67ae8584caa73bULL; +const Word2b iv2b2 = 0x3c6ef372fe94f82bULL; +const Word2b iv2b3 = 0xa54ff53a5f1d36f1ULL; +const Word2b iv2b4 = 0x510e527fade682d1ULL; +const Word2b iv2b5 = 0x9b05688c2b3e6c1fULL; +const Word2b iv2b6 = 0x1f83d9abfb41bd6bULL; +const Word2b iv2b7 = 0x5be0cd19137e2179ULL; diff --git a/implementation/cbits/raaz/hash/blake2/blake2s/constants.h b/implementation/cbits/raaz/hash/blake2/blake2s/constants.h new file mode 100644 --- /dev/null +++ b/implementation/cbits/raaz/hash/blake2/blake2s/constants.h @@ -0,0 +1,12 @@ +#pragma once + +#include + +const Word2s iv2s0 = 0x6a09e667UL; +const Word2s iv2s1 = 0xbb67ae85UL; +const Word2s iv2s2 = 0x3c6ef372UL; +const Word2s iv2s3 = 0xa54ff53aUL; +const Word2s iv2s4 = 0x510e527fUL; +const Word2s iv2s5 = 0x9b05688cUL; +const Word2s iv2s6 = 0x1f83d9abUL; +const Word2s iv2s7 = 0x5be0cd19UL; diff --git a/implementation/cbits/raaz/hash/blake2/common.h b/implementation/cbits/raaz/hash/blake2/common.h new file mode 100644 --- /dev/null +++ b/implementation/cbits/raaz/hash/blake2/common.h @@ -0,0 +1,17 @@ +#pragma once + +#include +#include + +#define HASH_SIZE 8 +#define BLOCK_SIZE 16 + +typedef uint64_t Word2b; /* basic unit for blake2b */ +typedef uint32_t Word2s; /* basic unit for blake2s */ + + +typedef Word2b Blake2b[HASH_SIZE]; +typedef Word2b Block2b[BLOCK_SIZE]; + +typedef Word2s Blake2s[HASH_SIZE]; +typedef Word2s Block2s[BLOCK_SIZE]; diff --git a/indef/buffer/Implementation.hsig b/indef/buffer/Implementation.hsig new file mode 100644 --- /dev/null +++ b/indef/buffer/Implementation.hsig @@ -0,0 +1,15 @@ +-- | An implementation of a cryptographic primitive is a method to +-- process data that is multiples of its block size. Fast +-- implementations involve other details like the alignment +-- restriction on the input buffer and all that. We package all this +-- in the following signature. +signature Implementation ( Prim, Internals + , BufferPtr, BufferAlignment + , additionalBlocks + ) where + +import Raaz.Core +data Prim +data Internals +instance Primitive Prim +instance Memory Internals diff --git a/monocypher/monocypher-3.0.0/monocypher.h b/monocypher/monocypher-3.0.0/monocypher.h new file mode 100644 --- /dev/null +++ b/monocypher/monocypher-3.0.0/monocypher.h @@ -0,0 +1,327 @@ +// Monocypher version 3.0.0 +// +// This file is dual-licensed. Choose whichever licence you want from +// the two licences listed below. +// +// The first licence is a regular 2-clause BSD licence. The second licence +// is the CC-0 from Creative Commons. It is intended to release Monocypher +// to the public domain. The BSD licence serves as a fallback option. +// +// SPDX-License-Identifier: BSD-2-Clause OR CC0-1.0 +// +// ------------------------------------------------------------------------ +// +// Copyright (c) 2017-2019, Loup Vaillant +// All rights reserved. +// +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the +// distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// ------------------------------------------------------------------------ +// +// Written in 2017-2019 by Loup Vaillant +// +// To the extent possible under law, the author(s) have dedicated all copyright +// and related neighboring rights to this software to the public domain +// worldwide. This software is distributed without any warranty. +// +// You should have received a copy of the CC0 Public Domain Dedication along +// with this software. If not, see +// + +#ifndef MONOCYPHER_H +#define MONOCYPHER_H + +#include +#include + +//////////////////////// +/// Type definitions /// +//////////////////////// + +// Vtable for EdDSA with a custom hash. +// Instantiate it to define a custom hash. +// Its size, contents, and layout, are part of the public API. +typedef struct { + void (*hash)(uint8_t hash[64], const uint8_t *message, size_t message_size); + void (*init )(void *ctx); + void (*update)(void *ctx, const uint8_t *message, size_t message_size); + void (*final )(void *ctx, uint8_t hash[64]); + size_t ctx_size; +} crypto_sign_vtable; + +// Do not rely on the size or contents of any of the types below, +// they may change without notice. + +// Poly1305 +typedef struct { + uint32_t r[4]; // constant multiplier (from the secret key) + uint32_t h[5]; // accumulated hash + uint32_t c[5]; // chunk of the message + uint32_t pad[4]; // random number added at the end (from the secret key) + size_t c_idx; // How many bytes are there in the chunk. +} crypto_poly1305_ctx; + +// Hash (Blake2b) +typedef struct { + uint64_t hash[8]; + uint64_t input_offset[2]; + uint64_t input[16]; + size_t input_idx; + size_t hash_size; +} crypto_blake2b_ctx; + +// Signatures (EdDSA) +typedef struct { + const crypto_sign_vtable *hash; + uint8_t buf[96]; + uint8_t pk [32]; +} crypto_sign_ctx_abstract; +typedef crypto_sign_ctx_abstract crypto_check_ctx_abstract; + +typedef struct { + crypto_sign_ctx_abstract ctx; + crypto_blake2b_ctx hash; +} crypto_sign_ctx; +typedef crypto_sign_ctx crypto_check_ctx; + +//////////////////////////// +/// High level interface /// +//////////////////////////// + +// Constant time comparisons +// ------------------------- + +// Return 0 if a and b are equal, -1 otherwise +int crypto_verify16(const uint8_t a[16], const uint8_t b[16]); +int crypto_verify32(const uint8_t a[32], const uint8_t b[32]); +int crypto_verify64(const uint8_t a[64], const uint8_t b[64]); + +// Erase sensitive data +// -------------------- + +// Please erase all copies +void crypto_wipe(void *secret, size_t size); + + +// Authenticated encryption +// ------------------------ + +// Direct interface +void crypto_lock(uint8_t mac[16], + uint8_t *cipher_text, + const uint8_t key[32], + const uint8_t nonce[24], + const uint8_t *plain_text, size_t text_size); +int crypto_unlock(uint8_t *plain_text, + const uint8_t key[32], + const uint8_t nonce[24], + const uint8_t mac[16], + const uint8_t *cipher_text, size_t text_size); + +// Direct interface with additional data +void crypto_lock_aead(uint8_t mac[16], + uint8_t *cipher_text, + const uint8_t key[32], + const uint8_t nonce[24], + const uint8_t *ad , size_t ad_size, + const uint8_t *plain_text, size_t text_size); +int crypto_unlock_aead(uint8_t *plain_text, + const uint8_t key[32], + const uint8_t nonce[24], + const uint8_t mac[16], + const uint8_t *ad , size_t ad_size, + const uint8_t *cipher_text, size_t text_size); + + +// General purpose hash (Blake2b) +// ------------------------------ + +// Direct interface +void crypto_blake2b(uint8_t hash[64], + const uint8_t *message, size_t message_size); + +void crypto_blake2b_general(uint8_t *hash , size_t hash_size, + const uint8_t *key , size_t key_size, // optional + const uint8_t *message , size_t message_size); + +// Incremental interface +void crypto_blake2b_init (crypto_blake2b_ctx *ctx); +void crypto_blake2b_update(crypto_blake2b_ctx *ctx, + const uint8_t *message, size_t message_size); +void crypto_blake2b_final (crypto_blake2b_ctx *ctx, uint8_t *hash); + +void crypto_blake2b_general_init(crypto_blake2b_ctx *ctx, size_t hash_size, + const uint8_t *key, size_t key_size); + +// vtable for signatures +extern const crypto_sign_vtable crypto_blake2b_vtable; + + +// Password key derivation (Argon2 i) +// ---------------------------------- +void crypto_argon2i(uint8_t *hash, uint32_t hash_size, // >= 4 + void *work_area, uint32_t nb_blocks, // >= 8 + uint32_t nb_iterations, // >= 1 + const uint8_t *password, uint32_t password_size, + const uint8_t *salt, uint32_t salt_size); // >= 8 + +void crypto_argon2i_general(uint8_t *hash, uint32_t hash_size,// >= 4 + void *work_area, uint32_t nb_blocks,// >= 8 + uint32_t nb_iterations, // >= 1 + const uint8_t *password, uint32_t password_size, + const uint8_t *salt, uint32_t salt_size,// >= 8 + const uint8_t *key, uint32_t key_size, + const uint8_t *ad, uint32_t ad_size); + + +// Key exchange (x25519 + HChacha20) +// --------------------------------- +#define crypto_key_exchange_public_key crypto_x25519_public_key +void crypto_key_exchange(uint8_t shared_key [32], + const uint8_t your_secret_key [32], + const uint8_t their_public_key[32]); + + +// Signatures (EdDSA with curve25519 + Blake2b) +// -------------------------------------------- + +// Generate public key +void crypto_sign_public_key(uint8_t public_key[32], + const uint8_t secret_key[32]); + +// Direct interface +void crypto_sign(uint8_t signature [64], + const uint8_t secret_key[32], + const uint8_t public_key[32], // optional, may be 0 + const uint8_t *message, size_t message_size); +int crypto_check(const uint8_t signature [64], + const uint8_t public_key[32], + const uint8_t *message, size_t message_size); + +// Incremental interface for signatures (2 passes) +void crypto_sign_init_first_pass(crypto_sign_ctx_abstract *ctx, + const uint8_t secret_key[32], + const uint8_t public_key[32]); +void crypto_sign_update(crypto_sign_ctx_abstract *ctx, + const uint8_t *message, size_t message_size); +void crypto_sign_init_second_pass(crypto_sign_ctx_abstract *ctx); +// use crypto_sign_update() again. +void crypto_sign_final(crypto_sign_ctx_abstract *ctx, uint8_t signature[64]); + +// Incremental interface for verification (1 pass) +void crypto_check_init (crypto_check_ctx_abstract *ctx, + const uint8_t signature[64], + const uint8_t public_key[32]); +void crypto_check_update(crypto_check_ctx_abstract *ctx, + const uint8_t *message, size_t message_size); +int crypto_check_final (crypto_check_ctx_abstract *ctx); + +// Custom hash interface +void crypto_sign_public_key_custom_hash(uint8_t public_key[32], + const uint8_t secret_key[32], + const crypto_sign_vtable *hash); +void crypto_sign_init_first_pass_custom_hash(crypto_sign_ctx_abstract *ctx, + const uint8_t secret_key[32], + const uint8_t public_key[32], + const crypto_sign_vtable *hash); +void crypto_check_init_custom_hash(crypto_check_ctx_abstract *ctx, + const uint8_t signature[64], + const uint8_t public_key[32], + const crypto_sign_vtable *hash); + +//////////////////////////// +/// Low level primitives /// +//////////////////////////// + +// For experts only. You have been warned. + +// Chacha20 +// -------- + +// Specialised hash. +void crypto_hchacha20(uint8_t out[32], + const uint8_t key[32], + const uint8_t in [16]); + +void crypto_chacha20(uint8_t *cipher_text, + const uint8_t *plain_text, + size_t text_size, + const uint8_t key[32], + const uint8_t nonce[8]); +void crypto_xchacha20(uint8_t *cipher_text, + const uint8_t *plain_text, + size_t text_size, + const uint8_t key[32], + const uint8_t nonce[24]); +void crypto_ietf_chacha20(uint8_t *cipher_text, + const uint8_t *plain_text, + size_t text_size, + const uint8_t key[32], + const uint8_t nonce[12]); +uint64_t crypto_chacha20_ctr(uint8_t *cipher_text, + const uint8_t *plain_text, + size_t text_size, + const uint8_t key[32], + const uint8_t nonce[8], + uint64_t ctr); +uint64_t crypto_xchacha20_ctr(uint8_t *cipher_text, + const uint8_t *plain_text, + size_t text_size, + const uint8_t key[32], + const uint8_t nonce[24], + uint64_t ctr); +uint32_t crypto_ietf_chacha20_ctr(uint8_t *cipher_text, + const uint8_t *plain_text, + size_t text_size, + const uint8_t key[32], + const uint8_t nonce[12], + uint32_t ctr); + + +// Poly 1305 +// --------- + +// Direct interface +void crypto_poly1305(uint8_t mac[16], + const uint8_t *message, size_t message_size, + const uint8_t key[32]); + +// Incremental interface +void crypto_poly1305_init (crypto_poly1305_ctx *ctx, const uint8_t key[32]); +void crypto_poly1305_update(crypto_poly1305_ctx *ctx, + const uint8_t *message, size_t message_size); +void crypto_poly1305_final (crypto_poly1305_ctx *ctx, uint8_t mac[16]); + + +// X-25519 +// ------- +void crypto_x25519_public_key(uint8_t public_key[32], + const uint8_t secret_key[32]); +void crypto_x25519(uint8_t raw_shared_secret[32], + const uint8_t your_secret_key [32], + const uint8_t their_public_key [32]); + +#endif // MONOCYPHER_H diff --git a/monocypher/monocypher-3.0.0/optional/monocypher-ed25519.h b/monocypher/monocypher-3.0.0/optional/monocypher-ed25519.h new file mode 100644 --- /dev/null +++ b/monocypher/monocypher-3.0.0/optional/monocypher-ed25519.h @@ -0,0 +1,139 @@ +// Monocypher version 3.0.0 +// +// This file is dual-licensed. Choose whichever licence you want from +// the two licences listed below. +// +// The first licence is a regular 2-clause BSD licence. The second licence +// is the CC-0 from Creative Commons. It is intended to release Monocypher +// to the public domain. The BSD licence serves as a fallback option. +// +// SPDX-License-Identifier: BSD-2-Clause OR CC0-1.0 +// +// ------------------------------------------------------------------------ +// +// Copyright (c) 2017-2019, Loup Vaillant +// All rights reserved. +// +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the +// distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// ------------------------------------------------------------------------ +// +// Written in 2017-2019 by Loup Vaillant +// +// To the extent possible under law, the author(s) have dedicated all copyright +// and related neighboring rights to this software to the public domain +// worldwide. This software is distributed without any warranty. +// +// You should have received a copy of the CC0 Public Domain Dedication along +// with this software. If not, see +// + +#ifndef ED25519_H +#define ED25519_H + +#include "monocypher.h" + +//////////////////////// +/// Type definitions /// +//////////////////////// + +// Do not rely on the size or content on any of those types, +// they may change without notice. +typedef struct { + uint64_t hash[8]; + uint64_t input[16]; + uint64_t input_size[2]; + size_t input_idx; +} crypto_sha512_ctx; + +typedef struct { + uint8_t key[128]; + crypto_sha512_ctx ctx; +} crypto_hmac_sha512_ctx; + +typedef struct { + crypto_sign_ctx_abstract ctx; + crypto_sha512_ctx hash; +} crypto_sign_ed25519_ctx; +typedef crypto_sign_ed25519_ctx crypto_check_ed25519_ctx; + +// SHA 512 +// ------- +void crypto_sha512_init (crypto_sha512_ctx *ctx); +void crypto_sha512_update(crypto_sha512_ctx *ctx, + const uint8_t *message, size_t message_size); +void crypto_sha512_final (crypto_sha512_ctx *ctx, uint8_t hash[64]); +void crypto_sha512(uint8_t hash[64], const uint8_t *message, size_t message_size); + +// vtable for signatures +extern const crypto_sign_vtable crypto_sha512_vtable; + + +// HMAC SHA 512 +// ------------ +void crypto_hmac_sha512_init(crypto_hmac_sha512_ctx *ctx, + const uint8_t *key, size_t key_size); +void crypto_hmac_sha512_update(crypto_hmac_sha512_ctx *ctx, + const uint8_t *message, size_t message_size); +void crypto_hmac_sha512_final(crypto_hmac_sha512_ctx *ctx, uint8_t hmac[64]); +void crypto_hmac_sha512(uint8_t hmac[64], + const uint8_t *key , size_t key_size, + const uint8_t *message, size_t message_size); + + +// Ed25519 +// ------- + +// Generate public key +void crypto_ed25519_public_key(uint8_t public_key[32], + const uint8_t secret_key[32]); + +// Direct interface +void crypto_ed25519_sign(uint8_t signature [64], + const uint8_t secret_key[32], + const uint8_t public_key[32], // optional, may be 0 + const uint8_t *message, size_t message_size); +int crypto_ed25519_check(const uint8_t signature [64], + const uint8_t public_key[32], + const uint8_t *message, size_t message_size); + +// Incremental interface +void crypto_ed25519_sign_init_first_pass(crypto_sign_ctx_abstract *ctx, + const uint8_t secret_key[32], + const uint8_t public_key[32]); +#define crypto_ed25519_sign_update crypto_sign_update +#define crypto_ed25519_sign_init_second_pass crypto_sign_init_second_pass +// use crypto_ed25519_sign_update() again. +#define crypto_ed25519_sign_final crypto_sign_final + +void crypto_ed25519_check_init(crypto_check_ctx_abstract *ctx, + const uint8_t signature[64], + const uint8_t public_key[32]); +#define crypto_ed25519_check_update crypto_check_update +#define crypto_ed25519_check_final crypto_check_final + + +#endif // ED25519_H diff --git a/raaz.cabal b/raaz.cabal --- a/raaz.cabal +++ b/raaz.cabal @@ -1,7 +1,7 @@ cabal-version: 3.0 name: raaz -version: 0.3.1 +version: 0.3.2 stability: experimental synopsis: Fast and type safe cryptography. @@ -129,7 +129,23 @@ extra-source-files: CHANGELOG.md , README.md + -- + -- C Header files are not included in cabal sdist + -- even if specified in include. + -- + , core/cbits/raaz/core/endian.h + , libverse/verse.h + + , implementation/cbits/raaz/hash/blake2/common.h + , implementation/cbits/raaz/hash/blake2/blake2b/constants.h + , implementation/cbits/raaz/hash/blake2/blake2s/constants.h + , implementation/cbits/raaz/cipher/chacha20/common.h + + + , monocypher/monocypher-3.0.0/optional/monocypher-ed25519.h + , monocypher/monocypher-3.0.0/monocypher.h + bug-reports: https://github.com/raaz-crypto/raaz/issues source-repository head @@ -200,6 +216,8 @@ extra-libraries: Advapi32, Kernel32 build-tool-depends: hsc2hs:hsc2hs + if arch(x86_64) + cc-options: -DARCH_X86_64 ----------------------------- The core library ------------------------------------------------ library core @@ -244,8 +262,8 @@ , core/cbits/raaz/core/cpusupports.c include-dirs: core/cbits includes: core/cbits/raaz/core/endian.h - install-includes: core/cbits/raaz/core/endian.h + ----------------------------- Libverse as a sublibrary ----------------------------- library libverse @@ -265,9 +283,7 @@ , libverse/verse.c include-dirs: libverse includes: verse.h - install-includes: verse.h - ---------------------- Implementation signature packages ------------- -- -- The signature package that exposes an implementation of a @@ -294,6 +310,7 @@ build-depends: core , indef hs-source-dirs: indef/buffer + signatures: Implementation exposed-modules: Buffer , Context @@ -475,21 +492,16 @@ , implementation/cbits/raaz/hash/sha512/portable.c , implementation/cbits/raaz/cipher/chacha20/cportable.c include-dirs: implementation/cbits/ - includes: implementation/cbits/raaz/hash/blake2/common.h - , implementation/cbits/raaz/hash/blake2/blake2b/constants.h - , implementation/cbits/raaz/hash/blake2/blake2s/constants.h + includes: raaz/hash/blake2/common.h + , raaz/hash/blake2/blake2b/constants.h + , raaz/hash/blake2/blake2s/constants.h + , raaz/cipher/chacha20/common.h + -------------------------- Implementation of system entropy ---------------------------- -- - -- The next conditionals perform the following configuration tasks. - -- - -- 1. Expose *all* the available sources of entropy. + -- Exposing the most suitable source of entropy in the system. -- - -- 2. Reexport the most desirable source as the module Entropy. This - -- way by mixing in the implementation component, the correct - -- entropy source is used (which can be overridden by the user if - -- they so wish -- do not try that unless you know what you are - -- doing) if os(windows) hs-source-dirs: implementation/entropy/windows/ @@ -799,10 +811,11 @@ , monocypher/monocypher-3.0.0/optional/monocypher-ed25519.c include-dirs: monocypher/monocypher-3.0.0/ - , monocypher/monocypher-3.0.0/optional + , monocypher/monocypher-3.0.0/optional/ - includes: monocypher/monocypher-3.0.0/optional/monocypher-ed25519.h - , monocypher/monocypher-3.0.0/monocypher.h + includes: monocypher-ed25519.h + , monocypher.h + build-tool-depends: hspec-discover:hspec-discover mixins: xchacha-indef requires (Implementation as ChaCha20.Implementation) , encrypt-api (Interface as Raaz.Encrypt.ChaCha20)