packages feed

raaz 0.3.1 → 0.3.2

raw patch · 10 files changed

+612/−21 lines, 10 files

Files

CHANGELOG.md view
@@ -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]: <http://github.com/raaz-crypto/raaz/releases/tag/v0.2.2> [0.2.3]: <http://github.com/raaz-crypto/raaz/releases/tag/v0.2.3> [0.3.0]: <http://github.com/raaz-crypto/raaz/releases/tag/v0.3.0>+[0.3.1]: <http://github.com/raaz-crypto/raaz/releases/tag/v0.3.1>+[0.3.2]: <http://github.com/raaz-crypto/raaz/releases/tag/v0.3.2> [raaz]:  <http://github.com/raaz-crypto/raaz/>
core/Raaz/Core/MonoidalAction.hs view
@@ -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
+ implementation/cbits/raaz/cipher/chacha20/common.h view
@@ -0,0 +1,53 @@+#pragma once++#include <stdint.h>+#include <inttypes.h>+#include <raaz/core/endian.h>++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
+ implementation/cbits/raaz/hash/blake2/blake2b/constants.h view
@@ -0,0 +1,12 @@+#pragma once++#include <raaz/hash/blake2/common.h>++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;
+ implementation/cbits/raaz/hash/blake2/blake2s/constants.h view
@@ -0,0 +1,12 @@+#pragma once++#include <raaz/hash/blake2/common.h>++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;
+ implementation/cbits/raaz/hash/blake2/common.h view
@@ -0,0 +1,17 @@+#pragma once++#include <raaz/core/endian.h>+#include <stdint.h>++#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];
+ indef/buffer/Implementation.hsig view
@@ -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
+ monocypher/monocypher-3.0.0/monocypher.h view
@@ -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+// <https://creativecommons.org/publicdomain/zero/1.0/>++#ifndef MONOCYPHER_H+#define MONOCYPHER_H++#include <stddef.h>+#include <stdint.h>++////////////////////////+/// 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
+ monocypher/monocypher-3.0.0/optional/monocypher-ed25519.h view
@@ -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+// <https://creativecommons.org/publicdomain/zero/1.0/>++#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
raaz.cabal view
@@ -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)