Merge branch 'develop' into wallet_crypt

contrib/epee/include/net/abstract_tcp_server2.inl

@@ -326,7 +326,7 @@ bool connection<t_protocol_handler>::do_send(const void* ptr, size_t cb)
 
     boost::asio::async_write(socket_, boost::asio::buffer(m_send_que.front().data(), m_send_que.front().size()),
                              //strand_.wrap(
-                             boost::bind(&connection<t_protocol_handler>::handle_write, self, _1, _2)
+                             boost::bind(&connection<t_protocol_handler>::handle_write, self, boost::placeholders::_1, boost::placeholders::_2)
                              //)
     );
 
@@ -404,7 +404,7 @@ void connection<t_protocol_handler>::handle_write(const boost::system::error_cod
     //have more data to send
     boost::asio::async_write(socket_, boost::asio::buffer(m_send_que.front().data(), m_send_que.front().size()),
                              //strand_.wrap(
-                             boost::bind(&connection<t_protocol_handler>::handle_write, connection<t_protocol_handler>::shared_from_this(), _1, _2));
+                             boost::bind(&connection<t_protocol_handler>::handle_write, connection<t_protocol_handler>::shared_from_this(), boost::placeholders::_1, boost::placeholders::_2));
     //);
   }
   CRITICAL_REGION_END();

src/common/encryption_filter.cpp

@@ -0,0 +1,7 @@
+// Copyright (c) 2014-2019 Zano Project
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+
+#include "encryption_filter.h"
+#include "crypto/chacha8_stream.h"

src/common/encryption_filter.h

@@ -0,0 +1,243 @@
+// Copyright (c) 2014-2018 Zano Project
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#pragma once
+
+#include <iostream>
+#include <iosfwd> 
+#include <type_traits>
+#include <boost/iostreams/categories.hpp>  // sink_tag
+#include "include_base_utils.h"
+#include "crypto/chacha8.h"
+#include "crypto/chacha8_stream.h"
+
+
+namespace tools
+{
+
+  /************************************************************************/
+  /*                                                                      */
+  /************************************************************************/
+
+  class encrypt_chacha_processer_base
+  {
+  public:
+    typedef char                          char_type;
+    //typedef boost::iostreams::multichar_output_filter_tag    category;
+    //typedef boost::iostreams::flushable_tag    category;
+    static const uint32_t block_size = ECRYPT_BLOCKLENGTH;
+
+    encrypt_chacha_processer_base(std::string const &pass, const crypto::chacha8_iv& iv) :m_iv(iv), m_ctx(AUTO_VAL_INIT(m_ctx))
+    {
+      crypto::generate_chacha8_key(pass, m_key);
+      ECRYPT_keysetup(&m_ctx, &m_key.data[0], sizeof(m_key.data) * 8, sizeof(m_iv.data) * 8);
+      ECRYPT_ivsetup(&m_ctx, &m_iv.data[0]);
+    }
+    ~encrypt_chacha_processer_base()
+    {
+
+    }
+
+    template<typename cb_handler>
+    std::streamsize process(char_type const * const buf, std::streamsize const n, cb_handler cb) const
+    {
+      if (n == 0)
+        return n;
+      if (n%ECRYPT_BLOCKLENGTH == 0 && m_buff.empty())
+      {
+        std::vector<char_type> buff(n);
+        ECRYPT_encrypt_blocks(&m_ctx, (u8*)buf, (u8*)&buff[0], (u32)(n / ECRYPT_BLOCKLENGTH));
+        cb(&buff[0], n);
+        //m_underlying_stream.write(&buff[0], n);
+        return n;
+      }
+      else
+      {
+        m_buff.append(buf, n);
+        size_t encr_count = m_buff.size() - m_buff.size() % ECRYPT_BLOCKLENGTH;
+        if (!encr_count)
+          return n;
+        std::vector<char_type> buff(encr_count);
+        ECRYPT_encrypt_blocks(&m_ctx, (u8*)m_buff.data(), (u8*)&buff[0], (u32)(m_buff.size() / ECRYPT_BLOCKLENGTH));
+        //m_underlying_stream.write(&buff[0], encr_count);
+        cb(&buff[0], encr_count);
+        m_buff.erase(0, encr_count);
+        return encr_count;
+      }
+
+    }
+
+    template<typename cb_handler>
+    bool flush(cb_handler cb)
+    {
+      if (m_buff.empty())
+        return true;
+
+      std::vector<char_type> buff(m_buff.size());
+      ECRYPT_encrypt_bytes(&m_ctx, (u8*)m_buff.data(), (u8*)&buff[0], (u32)m_buff.size());
+      cb(&buff[0], m_buff.size());
+      //m_underlying_stream.write(&buff[0], m_buff.size());
+      return true;
+    }
+
+  private:
+    const crypto::chacha8_iv& m_iv;
+    mutable ECRYPT_ctx m_ctx;
+    //std::ostream &m_underlying_stream;
+    crypto::chacha8_key m_key;
+    mutable std::string m_buff;
+  };
+
+  /************************************************************************/
+  /*                                                                      */
+  /************************************************************************/
+
+
+  class encrypt_chacha_out_filter : public encrypt_chacha_processer_base
+  {
+  public:
+    typedef char                          char_type;
+    struct category :
+      public boost::iostreams::multichar_output_filter_tag,
+      public boost::iostreams::flushable_tag
+    { };
+
+    encrypt_chacha_out_filter(std::string const &pass, const crypto::chacha8_iv& iv) :encrypt_chacha_processer_base(pass, iv)
+    {
+    }
+    ~encrypt_chacha_out_filter()
+    {
+    }
+
+    template<typename t_sink>
+    std::streamsize write(t_sink& snk, char_type const * const buf, std::streamsize const n) const
+    {
+      return encrypt_chacha_processer_base::process(buf, n, [&](char_type const * const buf_lambda, std::streamsize const n_lambda) {
+        boost::iostreams::write(snk, &buf_lambda[0], n_lambda);
+      });
+    }
+
+    template<typename Sink>
+    bool flush(Sink& snk)
+    {
+
+      encrypt_chacha_processer_base::flush([&](char_type const * const buf_lambda, std::streamsize const n_lambda) {
+        boost::iostreams::write(snk, &buf_lambda[0], n_lambda);
+      });
+      return true;
+    }
+
+  private:
+  };
+
+
+  /************************************************************************/
+  /*                                                                      */
+  /************************************************************************/
+
+  class encrypt_chacha_in_filter : public encrypt_chacha_processer_base
+  {
+  public:
+    typedef char                          char_type;
+    struct category : //public boost::iostreams::seekable_device_tag,
+      public boost::iostreams::multichar_input_filter_tag,
+      public boost::iostreams::flushable_tag
+      //public boost::iostreams::seekable_filter_tag
+    { };
+    encrypt_chacha_in_filter(std::string const &pass, const crypto::chacha8_iv& iv) :encrypt_chacha_processer_base(pass, iv), m_was_eof(false)
+    {
+    }
+    ~encrypt_chacha_in_filter()
+    {
+    }
+
+    template<typename Source>
+    std::streamsize read(Source& src, char* s, std::streamsize n)
+    {
+      if (m_buff.size() >= static_cast<size_t>(n))
+      {
+        return withdraw_to_read_buff(s, n);
+      }
+      if (m_was_eof && m_buff.empty())
+      {
+        return -1;
+      }
+
+      std::streamsize size_to_read_for_decrypt = (n - m_buff.size());
+      size_to_read_for_decrypt += size_to_read_for_decrypt % encrypt_chacha_processer_base::block_size;
+      size_t offset_in_buff = m_buff.size();
+      m_buff.resize(m_buff.size() + size_to_read_for_decrypt);
+
+      std::streamsize result = boost::iostreams::read(src, (char*)&m_buff.data()[offset_in_buff], size_to_read_for_decrypt);
+      if (result == size_to_read_for_decrypt)
+      {
+        //regular read proocess, readed data enought to get decrypteds
+        encrypt_chacha_processer_base::process(&m_buff.data()[offset_in_buff], size_to_read_for_decrypt, [&](char_type const* const buf_lambda, std::streamsize const n_lambda)
+        {
+          CHECK_AND_ASSERT_THROW_MES(n_lambda == size_to_read_for_decrypt, "Error in decrypt: check n_lambda == size_to_read_for_decrypt failed");
+          std::memcpy((char*)&m_buff.data()[offset_in_buff], buf_lambda, n_lambda);
+        });
+        return withdraw_to_read_buff(s, n);
+      }
+      else
+      {
+        //been read some size_but it's basically might be eof
+        if (!m_was_eof)
+        {
+          size_t offset_before_flush = offset_in_buff;
+          if (result != -1)
+          {
+            //eof
+            encrypt_chacha_processer_base::process(&m_buff.data()[offset_in_buff], result, [&](char_type const* const buf_lambda, std::streamsize const n_lambda) {
+              std::memcpy((char*)&m_buff.data()[offset_in_buff], buf_lambda, n_lambda);
+              offset_before_flush = offset_in_buff + n_lambda;
+            });
+          }
+
+          encrypt_chacha_processer_base::flush([&](char_type const* const buf_lambda, std::streamsize const n_lambda) {
+            if (n_lambda + offset_before_flush > m_buff.size())
+            {
+              m_buff.resize(n_lambda + offset_before_flush);
+            }
+            std::memcpy((char*)&m_buff.data()[offset_before_flush], buf_lambda, n_lambda);
+            m_buff.resize(offset_before_flush + n_lambda);
+          });
+
+          //just to make sure that it's over
+          std::string buff_stub(10, ' ');
+          std::streamsize r = boost::iostreams::read(src, (char*)&buff_stub.data()[0], 10);
+          CHECK_AND_ASSERT_THROW_MES(r == -1, "expected EOF");
+          m_was_eof = true;
+          return withdraw_to_read_buff(s, n);
+        }
+        else
+        {
+          return -1;
+        }
+      }
+    }
+
+
+    template<typename Sink>
+    bool flush(Sink& snk)
+    {
+
+      return true;
+    }
+
+  private:
+
+    std::streamsize withdraw_to_read_buff(char* s, std::streamsize n)
+    {
+
+      size_t copy_size = m_buff.size() > static_cast<size_t>(n) ? static_cast<size_t>(n) : m_buff.size();
+      std::memcpy(s, m_buff.data(), copy_size);
+      m_buff.erase(0, copy_size);
+      return copy_size;
+    }   
+
+    std::string m_buff;
+    bool m_was_eof;
+  };
+}

src/crypto/chacha8_stream.c

@@ -0,0 +1,115 @@
+/*
+chacha-ref.c version 20080118
+D. J. Bernstein
+Public domain.
+*/
+
+#include "ecrypt-sync.h"
+
+#define ROTATE(v,c) (ROTL32(v,c))
+#define XOR(v,w) ((v) ^ (w))
+#define PLUS(v,w) (U32V((v) + (w)))
+#define PLUSONE(v) (PLUS((v),1))
+
+#define QUARTERROUND(a,b,c,d) \
+  x[a] = PLUS(x[a],x[b]); x[d] = ROTATE(XOR(x[d],x[a]),16); \
+  x[c] = PLUS(x[c],x[d]); x[b] = ROTATE(XOR(x[b],x[c]),12); \
+  x[a] = PLUS(x[a],x[b]); x[d] = ROTATE(XOR(x[d],x[a]), 8); \
+  x[c] = PLUS(x[c],x[d]); x[b] = ROTATE(XOR(x[b],x[c]), 7);
+
+static void salsa20_wordtobyte(u8 output[64], const u32 input[16])
+{
+  u32 x[16];
+  int i;
+
+  for (i = 0; i < 16; ++i) x[i] = input[i];
+  for (i = 8; i > 0; i -= 2) {
+    QUARTERROUND(0, 4, 8, 12)
+      QUARTERROUND(1, 5, 9, 13)
+      QUARTERROUND(2, 6, 10, 14)
+      QUARTERROUND(3, 7, 11, 15)
+      QUARTERROUND(0, 5, 10, 15)
+      QUARTERROUND(1, 6, 11, 12)
+      QUARTERROUND(2, 7, 8, 13)
+      QUARTERROUND(3, 4, 9, 14)
+  }
+  for (i = 0; i < 16; ++i) x[i] = PLUS(x[i], input[i]);
+  for (i = 0; i < 16; ++i) U32TO8_LITTLE(output + 4 * i, x[i]);
+}
+
+void ECRYPT_init(void)
+{
+  return;
+}
+
+static const char sigma[16] = "expand 32-byte k";
+static const char tau[16] = "expand 16-byte k";
+
+void ECRYPT_keysetup(ECRYPT_ctx *x, const u8 *k, u32 kbits, u32 ivbits)
+{
+  const char *constants;
+
+  x->input[4] = U8TO32_LITTLE(k + 0);
+  x->input[5] = U8TO32_LITTLE(k + 4);
+  x->input[6] = U8TO32_LITTLE(k + 8);
+  x->input[7] = U8TO32_LITTLE(k + 12);
+  if (kbits == 256) { /* recommended */
+    k += 16;
+    constants = sigma;
+  }
+  else { /* kbits == 128 */
+    constants = tau;
+  }
+  x->input[8] = U8TO32_LITTLE(k + 0);
+  x->input[9] = U8TO32_LITTLE(k + 4);
+  x->input[10] = U8TO32_LITTLE(k + 8);
+  x->input[11] = U8TO32_LITTLE(k + 12);
+  x->input[0] = U8TO32_LITTLE(constants + 0);
+  x->input[1] = U8TO32_LITTLE(constants + 4);
+  x->input[2] = U8TO32_LITTLE(constants + 8);
+  x->input[3] = U8TO32_LITTLE(constants + 12);
+}
+
+void ECRYPT_ivsetup(ECRYPT_ctx *x, const u8 *iv)
+{
+  x->input[12] = 0;
+  x->input[13] = 0;
+  x->input[14] = U8TO32_LITTLE(iv + 0);
+  x->input[15] = U8TO32_LITTLE(iv + 4);
+}
+
+void ECRYPT_encrypt_bytes(ECRYPT_ctx *x, const u8 *m, u8 *c, u32 bytes)
+{
+  u8 output[64];
+  int i;
+
+  if (!bytes) return;
+  for (;;) {
+    salsa20_wordtobyte(output, x->input);
+    x->input[12] = PLUSONE(x->input[12]);
+    if (!x->input[12]) {
+      x->input[13] = PLUSONE(x->input[13]);
+      /* stopping at 2^70 bytes per nonce is user's responsibility */
+    }
+    if (bytes <= 64) {
+      for (i = 0; i < bytes; ++i) c[i] = m[i] ^ output[i];
+      return;
+    }
+    for (i = 0; i < 64; ++i) c[i] = m[i] ^ output[i];
+    bytes -= 64;
+    c += 64;
+    m += 64;
+  }
+}
+
+void ECRYPT_decrypt_bytes(ECRYPT_ctx *x, const u8 *c, u8 *m, u32 bytes)
+{
+  ECRYPT_encrypt_bytes(x, c, m, bytes);
+}
+
+void ECRYPT_keystream_bytes(ECRYPT_ctx *x, u8 *stream, u32 bytes)
+{
+  u32 i;
+  for (i = 0; i < bytes; ++i) stream[i] = 0;
+  ECRYPT_encrypt_bytes(x, stream, stream, bytes);
+}

src/crypto/chacha8_stream.h

@@ -0,0 +1,289 @@
+/* ecrypt-sync.h */
+
+/*
+* Header file for synchronous stream ciphers without authentication
+* mechanism.
+*
+* *** Please only edit parts marked with "[edit]". ***
+*/
+
+#ifndef ECRYPT_SYNC
+#define ECRYPT_SYNC
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+#include "ecrypt-portable.h"
+
+  /* ------------------------------------------------------------------------- */
+
+  /* Cipher parameters */
+
+  /*
+  * The name of your cipher.
+  */
+#define ECRYPT_NAME "ChaCha8"
+#define ECRYPT_PROFILE "_____"
+
+  /*
+  * Specify which key and IV sizes are supported by your cipher. A user
+  * should be able to enumerate the supported sizes by running the
+  * following code:
+  *
+  * for (i = 0; ECRYPT_KEYSIZE(i) <= ECRYPT_MAXKEYSIZE; ++i)
+  *   {
+  *     keysize = ECRYPT_KEYSIZE(i);
+  *
+  *     ...
+  *   }
+  *
+  * All sizes are in bits.
+  */
+
+#define ECRYPT_MAXKEYSIZE 256                 /* [edit] */
+#define ECRYPT_KEYSIZE(i) (128 + (i)*128)     /* [edit] */
+
+#define ECRYPT_MAXIVSIZE 64                   /* [edit] */
+#define ECRYPT_IVSIZE(i) (64 + (i)*64)        /* [edit] */
+
+  /* ------------------------------------------------------------------------- */
+
+  /* Data structures */
+
+  /*
+  * ECRYPT_ctx is the structure containing the representation of the
+  * internal state of your cipher.
+  */
+
+  typedef struct
+  {
+    u32 input[16]; /* could be compressed */
+                   /*
+                   * [edit]
+                   *
+                   * Put here all state variable needed during the encryption process.
+                   */
+  } ECRYPT_ctx;
+
+  /* ------------------------------------------------------------------------- */
+
+  /* Mandatory functions */
+
+  /*
+  * Key and message independent initialization. This function will be
+  * called once when the program starts (e.g., to build expanded S-box
+  * tables).
+  */
+  void ECRYPT_init();
+
+  /*
+  * Key setup. It is the user's responsibility to select the values of
+  * keysize and ivsize from the set of supported values specified
+  * above.
+  */
+  void ECRYPT_keysetup(
+    ECRYPT_ctx* ctx,
+    const u8* key,
+    u32 keysize,                /* Key size in bits. */
+    u32 ivsize);                /* IV size in bits. */
+
+  /*
+  * IV setup. After having called ECRYPT_keysetup(), the user is
+  * allowed to call ECRYPT_ivsetup() different times in order to
+  * encrypt/decrypt different messages with the same key but different
+  * IV's.
+  */
+  void ECRYPT_ivsetup(
+    ECRYPT_ctx* ctx,
+    const u8* iv);
+
+  /*
+  * Encryption/decryption of arbitrary length messages.
+  *
+  * For efficiency reasons, the API provides two types of
+  * encrypt/decrypt functions. The ECRYPT_encrypt_bytes() function
+  * (declared here) encrypts byte strings of arbitrary length, while
+  * the ECRYPT_encrypt_blocks() function (defined later) only accepts
+  * lengths which are multiples of ECRYPT_BLOCKLENGTH.
+  *
+  * The user is allowed to make multiple calls to
+  * ECRYPT_encrypt_blocks() to incrementally encrypt a long message,
+  * but he is NOT allowed to make additional encryption calls once he
+  * has called ECRYPT_encrypt_bytes() (unless he starts a new message
+  * of course). For example, this sequence of calls is acceptable:
+  *
+  * ECRYPT_keysetup();
+  *
+  * ECRYPT_ivsetup();
+  * ECRYPT_encrypt_blocks();
+  * ECRYPT_encrypt_blocks();
+  * ECRYPT_encrypt_bytes();
+  *
+  * ECRYPT_ivsetup();
+  * ECRYPT_encrypt_blocks();
+  * ECRYPT_encrypt_blocks();
+  *
+  * ECRYPT_ivsetup();
+  * ECRYPT_encrypt_bytes();
+  *
+  * The following sequence is not:
+  *
+  * ECRYPT_keysetup();
+  * ECRYPT_ivsetup();
+  * ECRYPT_encrypt_blocks();
+  * ECRYPT_encrypt_bytes();
+  * ECRYPT_encrypt_blocks();
+  */
+
+  void ECRYPT_encrypt_bytes(
+    ECRYPT_ctx* ctx,
+    const u8* plaintext,
+    u8* ciphertext,
+    u32 msglen);                /* Message length in bytes. */
+
+  void ECRYPT_decrypt_bytes(
+    ECRYPT_ctx* ctx,
+    const u8* ciphertext,
+    u8* plaintext,
+    u32 msglen);                /* Message length in bytes. */
+
+  /* ------------------------------------------------------------------------- */
+
+  /* Optional features */
+
+  /*
+  * For testing purposes it can sometimes be useful to have a function
+  * which immediately generates keystream without having to provide it
+  * with a zero plaintext. If your cipher cannot provide this function
+  * (e.g., because it is not strictly a synchronous cipher), please
+  * reset the ECRYPT_GENERATES_KEYSTREAM flag.
+  */
+
+#define ECRYPT_GENERATES_KEYSTREAM
+#ifdef ECRYPT_GENERATES_KEYSTREAM
+
+  void ECRYPT_keystream_bytes(
+    ECRYPT_ctx* ctx,
+    u8* keystream,
+    u32 length);                /* Length of keystream in bytes. */
+
+#endif
+
+/* ------------------------------------------------------------------------- */
+
+/* Optional optimizations */
+
+/*
+* By default, the functions in this section are implemented using
+* calls to functions declared above. However, you might want to
+* implement them differently for performance reasons.
+*/
+
+/*
+* All-in-one encryption/decryption of (short) packets.
+*
+* The default definitions of these functions can be found in
+* "ecrypt-sync.c". If you want to implement them differently, please
+* undef the ECRYPT_USES_DEFAULT_ALL_IN_ONE flag.
+*/
+#define ECRYPT_USES_DEFAULT_ALL_IN_ONE        /* [edit] */
+
+  void ECRYPT_encrypt_packet(
+    ECRYPT_ctx* ctx,
+    const u8* iv,
+    const u8* plaintext,
+    u8* ciphertext,
+    u32 msglen);
+
+  void ECRYPT_decrypt_packet(
+    ECRYPT_ctx* ctx,
+    const u8* iv,
+    const u8* ciphertext,
+    u8* plaintext,
+    u32 msglen);
+
+  /*
+  * Encryption/decryption of blocks.
+  *
+  * By default, these functions are defined as macros. If you want to
+  * provide a different implementation, please undef the
+  * ECRYPT_USES_DEFAULT_BLOCK_MACROS flag and implement the functions
+  * declared below.
+  */
+
+#define ECRYPT_BLOCKLENGTH 64                  /* [edit] */
+
+#define ECRYPT_USES_DEFAULT_BLOCK_MACROS      /* [edit] */
+#ifdef ECRYPT_USES_DEFAULT_BLOCK_MACROS
+
+#define ECRYPT_encrypt_blocks(ctx, plaintext, ciphertext, blocks)  \
+  ECRYPT_encrypt_bytes(ctx, plaintext, ciphertext,                 \
+    (blocks) * ECRYPT_BLOCKLENGTH)
+
+#define ECRYPT_decrypt_blocks(ctx, ciphertext, plaintext, blocks)  \
+  ECRYPT_decrypt_bytes(ctx, ciphertext, plaintext,                 \
+    (blocks) * ECRYPT_BLOCKLENGTH)
+
+#ifdef ECRYPT_GENERATES_KEYSTREAM
+
+#define ECRYPT_keystream_blocks(ctx, keystream, blocks)            \
+  ECRYPT_keystream_bytes(ctx, keystream,                        \
+    (blocks) * ECRYPT_BLOCKLENGTH)
+
+#endif
+
+#else
+
+  void ECRYPT_encrypt_blocks(
+    ECRYPT_ctx* ctx,
+    const u8* plaintext,
+    u8* ciphertext,
+    u32 blocks);                /* Message length in blocks. */
+
+  void ECRYPT_decrypt_blocks(
+    ECRYPT_ctx* ctx,
+    const u8* ciphertext,
+    u8* plaintext,
+    u32 blocks);                /* Message length in blocks. */
+
+#ifdef ECRYPT_GENERATES_KEYSTREAM
+
+  void ECRYPT_keystream_blocks(
+    ECRYPT_ctx* ctx,
+    const u8* keystream,
+    u32 blocks);                /* Keystream length in blocks. */
+
+#endif
+
+#endif
+
+/*
+* If your cipher can be implemented in different ways, you can use
+* the ECRYPT_VARIANT parameter to allow the user to choose between
+* them at compile time (e.g., gcc -DECRYPT_VARIANT=3 ...). Please
+* only use this possibility if you really think it could make a
+* significant difference and keep the number of variants
+* (ECRYPT_MAXVARIANT) as small as possible (definitely not more than
+* 10). Note also that all variants should have exactly the same
+* external interface (i.e., the same ECRYPT_BLOCKLENGTH, etc.).
+*/
+#define ECRYPT_MAXVARIANT 1                   /* [edit] */
+
+#ifndef ECRYPT_VARIANT
+#define ECRYPT_VARIANT 1
+#endif
+
+#if (ECRYPT_VARIANT > ECRYPT_MAXVARIANT)
+#error this variant does not exist
+#endif
+
+/* ------------------------------------------------------------------------- */
+
+#if defined(__cplusplus)
+//extern "C" {
+}
+#endif
+
+#endif

src/crypto/ecrypt-config.h

@@ -0,0 +1,272 @@
+/* ecrypt-config.h */
+
+/* *** Normally, it should not be necessary to edit this file. *** */
+
+#ifndef ECRYPT_CONFIG
+#define ECRYPT_CONFIG
+
+/* ------------------------------------------------------------------------- */
+
+/* Guess the endianness of the target architecture. */
+
+/*
+* The LITTLE endian machines:
+*/
+#if defined(__ultrix)           /* Older MIPS */
+#define ECRYPT_LITTLE_ENDIAN
+#elif defined(__alpha)          /* Alpha */
+#define ECRYPT_LITTLE_ENDIAN
+#elif defined(i386)             /* x86 (gcc) */
+#define ECRYPT_LITTLE_ENDIAN
+#elif defined(__i386)           /* x86 (gcc) */
+#define ECRYPT_LITTLE_ENDIAN
+#elif defined(_M_IX86)          /* x86 (MSC, Borland) */
+#define ECRYPT_LITTLE_ENDIAN
+#elif defined(_MSC_VER)         /* x86 (surely MSC) */
+#define ECRYPT_LITTLE_ENDIAN
+#elif defined(__INTEL_COMPILER) /* x86 (surely Intel compiler icl.exe) */
+#define ECRYPT_LITTLE_ENDIAN
+
+/*
+* The BIG endian machines:
+*/
+#elif defined(sun)              /* Newer Sparc's */
+#define ECRYPT_BIG_ENDIAN
+#elif defined(__ppc__)          /* PowerPC */
+#define ECRYPT_BIG_ENDIAN
+
+/*
+* Finally machines with UNKNOWN endianness:
+*/
+#elif defined (_AIX)            /* RS6000 */
+#define ECRYPT_UNKNOWN
+#elif defined(__hpux)           /* HP-PA */
+#define ECRYPT_UNKNOWN
+#elif defined(__aux)            /* 68K */
+#define ECRYPT_UNKNOWN
+#elif defined(__dgux)           /* 88K (but P6 in latest boxes) */
+#define ECRYPT_UNKNOWN
+#elif defined(__sgi)            /* Newer MIPS */
+#define ECRYPT_UNKNOWN
+#else	                        /* Any other processor */
+#define ECRYPT_UNKNOWN
+#endif
+
+/* ------------------------------------------------------------------------- */
+
+/*
+* Find minimal-width types to store 8-bit, 16-bit, 32-bit, and 64-bit
+* integers.
+*
+* Note: to enable 64-bit types on 32-bit compilers, it might be
+* necessary to switch from ISO C90 mode to ISO C99 mode (e.g., gcc
+* -std=c99).
+*/
+
+#include <limits.h>
+
+/* --- check char --- */
+
+#if (UCHAR_MAX / 0xFU > 0xFU)
+#ifndef I8T
+#define I8T char
+#define U8C(v) (v##U)
+
+#if (UCHAR_MAX == 0xFFU)
+#define ECRYPT_I8T_IS_BYTE
+#endif
+
+#endif
+
+#if (UCHAR_MAX / 0xFFU > 0xFFU)
+#ifndef I16T
+#define I16T char
+#define U16C(v) (v##U)
+#endif
+
+#if (UCHAR_MAX / 0xFFFFU > 0xFFFFU)
+#ifndef I32T
+#define I32T char
+#define U32C(v) (v##U)
+#endif
+
+#if (UCHAR_MAX / 0xFFFFFFFFU > 0xFFFFFFFFU)
+#ifndef I64T
+#define I64T char
+#define U64C(v) (v##U)
+#define ECRYPT_NATIVE64
+#endif
+
+#endif
+#endif
+#endif
+#endif
+
+/* --- check short --- */
+
+#if (USHRT_MAX / 0xFU > 0xFU)
+#ifndef I8T
+#define I8T short
+#define U8C(v) (v##U)
+
+#if (USHRT_MAX == 0xFFU)
+#define ECRYPT_I8T_IS_BYTE
+#endif
+
+#endif
+
+#if (USHRT_MAX / 0xFFU > 0xFFU)
+#ifndef I16T
+#define I16T short
+#define U16C(v) (v##U)
+#endif
+
+#if (USHRT_MAX / 0xFFFFU > 0xFFFFU)
+#ifndef I32T
+#define I32T short
+#define U32C(v) (v##U)
+#endif
+
+#if (USHRT_MAX / 0xFFFFFFFFU > 0xFFFFFFFFU)
+#ifndef I64T
+#define I64T short
+#define U64C(v) (v##U)
+#define ECRYPT_NATIVE64
+#endif
+
+#endif
+#endif
+#endif
+#endif
+
+/* --- check int --- */
+
+#if (UINT_MAX / 0xFU > 0xFU)
+#ifndef I8T
+#define I8T int
+#define U8C(v) (v##U)
+
+#if (ULONG_MAX == 0xFFU)
+#define ECRYPT_I8T_IS_BYTE
+#endif
+
+#endif
+
+#if (UINT_MAX / 0xFFU > 0xFFU)
+#ifndef I16T
+#define I16T int
+#define U16C(v) (v##U)
+#endif
+
+#if (UINT_MAX / 0xFFFFU > 0xFFFFU)
+#ifndef I32T
+#define I32T int
+#define U32C(v) (v##U)
+#endif
+
+#if (UINT_MAX / 0xFFFFFFFFU > 0xFFFFFFFFU)
+#ifndef I64T
+#define I64T int
+#define U64C(v) (v##U)
+#define ECRYPT_NATIVE64
+#endif
+
+#endif
+#endif
+#endif
+#endif
+
+/* --- check long --- */
+
+#if (ULONG_MAX / 0xFUL > 0xFUL)
+#ifndef I8T
+#define I8T long
+#define U8C(v) (v##UL)
+
+#if (ULONG_MAX == 0xFFUL)
+#define ECRYPT_I8T_IS_BYTE
+#endif
+
+#endif
+
+#if (ULONG_MAX / 0xFFUL > 0xFFUL)
+#ifndef I16T
+#define I16T long
+#define U16C(v) (v##UL)
+#endif
+
+#if (ULONG_MAX / 0xFFFFUL > 0xFFFFUL)
+#ifndef I32T
+#define I32T long
+#define U32C(v) (v##UL)
+#endif
+
+#if (ULONG_MAX / 0xFFFFFFFFUL > 0xFFFFFFFFUL)
+#ifndef I64T
+#define I64T long
+#define U64C(v) (v##UL)
+#define ECRYPT_NATIVE64
+#endif
+
+#endif
+#endif
+#endif
+#endif
+
+/* --- check long long --- */
+
+#ifdef ULLONG_MAX
+
+#if (ULLONG_MAX / 0xFULL > 0xFULL)
+#ifndef I8T
+#define I8T long long
+#define U8C(v) (v##ULL)
+
+#if (ULLONG_MAX == 0xFFULL)
+#define ECRYPT_I8T_IS_BYTE
+#endif
+
+#endif
+
+#if (ULLONG_MAX / 0xFFULL > 0xFFULL)
+#ifndef I16T
+#define I16T long long
+#define U16C(v) (v##ULL)
+#endif
+
+#if (ULLONG_MAX / 0xFFFFULL > 0xFFFFULL)
+#ifndef I32T
+#define I32T long long
+#define U32C(v) (v##ULL)
+#endif
+
+#if (ULLONG_MAX / 0xFFFFFFFFULL > 0xFFFFFFFFULL)
+#ifndef I64T
+#define I64T long long
+#define U64C(v) (v##ULL)
+#endif
+
+#endif
+#endif
+#endif
+#endif
+
+#endif
+
+/* --- check __int64 --- */
+
+#ifdef _UI64_MAX
+
+#if (_UI64_MAX / 0xFFFFFFFFui64 > 0xFFFFFFFFui64)
+#ifndef I64T
+#define I64T __int64
+#define U64C(v) (v##ui64)
+#endif
+
+#endif
+
+#endif
+
+/* ------------------------------------------------------------------------- */
+
+#endif

src/crypto/ecrypt-machine.h

@@ -0,0 +1,46 @@
+/* ecrypt-machine.h */
+
+/*
+* This file is included by 'ecrypt-portable.h'. It allows to override
+* the default macros for specific platforms. Please carefully check
+* the machine code generated by your compiler (with optimisations
+* turned on) before deciding to edit this file.
+*/
+
+/* ------------------------------------------------------------------------- */
+
+#if (defined(ECRYPT_DEFAULT_ROT) && !defined(ECRYPT_MACHINE_ROT))
+
+#define ECRYPT_MACHINE_ROT
+
+#if (defined(WIN32) && defined(_MSC_VER))
+
+#undef ROTL32
+#undef ROTR32
+#undef ROTL64
+#undef ROTR64
+
+#include <stdlib.h>
+
+#define ROTL32(v, n) _lrotl(v, n)
+#define ROTR32(v, n) _lrotr(v, n)
+#define ROTL64(v, n) _rotl64(v, n)
+#define ROTR64(v, n) _rotr64(v, n)
+
+#endif
+
+#endif
+
+/* ------------------------------------------------------------------------- */
+
+#if (defined(ECRYPT_DEFAULT_SWAP) && !defined(ECRYPT_MACHINE_SWAP))
+
+#define ECRYPT_MACHINE_SWAP
+
+/*
+* If you want to overwrite the default swap macros, put it here. And so on.
+*/
+
+#endif
+
+/* ------------------------------------------------------------------------- */

src/crypto/ecrypt-portable.h

@@ -0,0 +1,303 @@
+/* ecrypt-portable.h */
+
+/*
+* WARNING: the conversions defined below are implemented as macros,
+* and should be used carefully. They should NOT be used with
+* parameters which perform some action. E.g., the following two lines
+* are not equivalent:
+*
+*  1) ++x; y = ROTL32(x, n);
+*  2) y = ROTL32(++x, n);
+*/
+
+/*
+* *** Please do not edit this file. ***
+*
+* The default macros can be overridden for specific architectures by
+* editing 'ecrypt-machine.h'.
+*/
+
+#ifndef ECRYPT_PORTABLE
+#define ECRYPT_PORTABLE
+
+#include "ecrypt-config.h"
+
+/* ------------------------------------------------------------------------- */
+
+/*
+* The following types are defined (if available):
+*
+* u8:  unsigned integer type, at least 8 bits
+* u16: unsigned integer type, at least 16 bits
+* u32: unsigned integer type, at least 32 bits
+* u64: unsigned integer type, at least 64 bits
+*
+* s8, s16, s32, s64 -> signed counterparts of u8, u16, u32, u64
+*
+* The selection of minimum-width integer types is taken care of by
+* 'ecrypt-config.h'. Note: to enable 64-bit types on 32-bit
+* compilers, it might be necessary to switch from ISO C90 mode to ISO
+* C99 mode (e.g., gcc -std=c99).
+*/
+
+#ifdef I8T
+typedef signed I8T s8;
+typedef unsigned I8T u8;
+#endif
+
+#ifdef I16T
+typedef signed I16T s16;
+typedef unsigned I16T u16;
+#endif
+
+#ifdef I32T
+typedef signed I32T s32;
+typedef unsigned I32T u32;
+#endif
+
+#ifdef I64T
+typedef signed I64T s64;
+typedef unsigned I64T u64;
+#endif
+
+/*
+* The following macros are used to obtain exact-width results.
+*/
+
+#define U8V(v) ((u8)(v) & U8C(0xFF))
+#define U16V(v) ((u16)(v) & U16C(0xFFFF))
+#define U32V(v) ((u32)(v) & U32C(0xFFFFFFFF))
+#define U64V(v) ((u64)(v) & U64C(0xFFFFFFFFFFFFFFFF))
+
+/* ------------------------------------------------------------------------- */
+
+/*
+* The following macros return words with their bits rotated over n
+* positions to the left/right.
+*/
+
+#define ECRYPT_DEFAULT_ROT
+
+#define ROTL8(v, n) \
+  (U8V((v) << (n)) | ((v) >> (8 - (n))))
+
+#define ROTL16(v, n) \
+  (U16V((v) << (n)) | ((v) >> (16 - (n))))
+
+#define ROTL32(v, n) \
+  (U32V((v) << (n)) | ((v) >> (32 - (n))))
+
+#define ROTL64(v, n) \
+  (U64V((v) << (n)) | ((v) >> (64 - (n))))
+
+#define ROTR8(v, n) ROTL8(v, 8 - (n))
+#define ROTR16(v, n) ROTL16(v, 16 - (n))
+#define ROTR32(v, n) ROTL32(v, 32 - (n))
+#define ROTR64(v, n) ROTL64(v, 64 - (n))
+
+#include "ecrypt-machine.h"
+
+/* ------------------------------------------------------------------------- */
+
+/*
+* The following macros return a word with bytes in reverse order.
+*/
+
+#define ECRYPT_DEFAULT_SWAP
+
+#define SWAP16(v) \
+  ROTL16(v, 8)
+
+#define SWAP32(v) \
+  ((ROTL32(v,  8) & U32C(0x00FF00FF)) | \
+   (ROTL32(v, 24) & U32C(0xFF00FF00)))
+
+#ifdef ECRYPT_NATIVE64
+#define SWAP64(v) \
+  ((ROTL64(v,  8) & U64C(0x000000FF000000FF)) | \
+   (ROTL64(v, 24) & U64C(0x0000FF000000FF00)) | \
+   (ROTL64(v, 40) & U64C(0x00FF000000FF0000)) | \
+   (ROTL64(v, 56) & U64C(0xFF000000FF000000)))
+#else
+#define SWAP64(v) \
+  (((u64)SWAP32(U32V(v)) << 32) | (u64)SWAP32(U32V(v >> 32)))
+#endif
+
+#include "ecrypt-machine.h"
+
+#define ECRYPT_DEFAULT_WTOW
+
+#ifdef ECRYPT_LITTLE_ENDIAN
+#define U16TO16_LITTLE(v) (v)
+#define U32TO32_LITTLE(v) (v)
+#define U64TO64_LITTLE(v) (v)
+
+#define U16TO16_BIG(v) SWAP16(v)
+#define U32TO32_BIG(v) SWAP32(v)
+#define U64TO64_BIG(v) SWAP64(v)
+#endif
+
+#ifdef ECRYPT_BIG_ENDIAN
+#define U16TO16_LITTLE(v) SWAP16(v)
+#define U32TO32_LITTLE(v) SWAP32(v)
+#define U64TO64_LITTLE(v) SWAP64(v)
+
+#define U16TO16_BIG(v) (v)
+#define U32TO32_BIG(v) (v)
+#define U64TO64_BIG(v) (v)
+#endif
+
+#include "ecrypt-machine.h"
+
+/*
+* The following macros load words from an array of bytes with
+* different types of endianness, and vice versa.
+*/
+
+#define ECRYPT_DEFAULT_BTOW
+
+#if (!defined(ECRYPT_UNKNOWN) && defined(ECRYPT_I8T_IS_BYTE))
+
+#define U8TO16_LITTLE(p) U16TO16_LITTLE(((u16*)(p))[0])
+#define U8TO32_LITTLE(p) U32TO32_LITTLE(((u32*)(p))[0])
+#define U8TO64_LITTLE(p) U64TO64_LITTLE(((u64*)(p))[0])
+
+#define U8TO16_BIG(p) U16TO16_BIG(((u16*)(p))[0])
+#define U8TO32_BIG(p) U32TO32_BIG(((u32*)(p))[0])
+#define U8TO64_BIG(p) U64TO64_BIG(((u64*)(p))[0])
+
+#define U16TO8_LITTLE(p, v) (((u16*)(p))[0] = U16TO16_LITTLE(v))
+#define U32TO8_LITTLE(p, v) (((u32*)(p))[0] = U32TO32_LITTLE(v))
+#define U64TO8_LITTLE(p, v) (((u64*)(p))[0] = U64TO64_LITTLE(v))
+
+#define U16TO8_BIG(p, v) (((u16*)(p))[0] = U16TO16_BIG(v))
+#define U32TO8_BIG(p, v) (((u32*)(p))[0] = U32TO32_BIG(v))
+#define U64TO8_BIG(p, v) (((u64*)(p))[0] = U64TO64_BIG(v))
+
+#else
+
+#define U8TO16_LITTLE(p) \
+  (((u16)((p)[0])      ) | \
+   ((u16)((p)[1]) <<  8))
+
+#define U8TO32_LITTLE(p) \
+  (((u32)((p)[0])      ) | \
+   ((u32)((p)[1]) <<  8) | \
+   ((u32)((p)[2]) << 16) | \
+   ((u32)((p)[3]) << 24))
+
+#ifdef ECRYPT_NATIVE64
+#define U8TO64_LITTLE(p) \
+  (((u64)((p)[0])      ) | \
+   ((u64)((p)[1]) <<  8) | \
+   ((u64)((p)[2]) << 16) | \
+   ((u64)((p)[3]) << 24) | \
+   ((u64)((p)[4]) << 32) | \
+   ((u64)((p)[5]) << 40) | \
+   ((u64)((p)[6]) << 48) | \
+   ((u64)((p)[7]) << 56))
+#else
+#define U8TO64_LITTLE(p) \
+  ((u64)U8TO32_LITTLE(p) | ((u64)U8TO32_LITTLE((p) + 4) << 32))
+#endif
+
+#define U8TO16_BIG(p) \
+  (((u16)((p)[0]) <<  8) | \
+   ((u16)((p)[1])      ))
+
+#define U8TO32_BIG(p) \
+  (((u32)((p)[0]) << 24) | \
+   ((u32)((p)[1]) << 16) | \
+   ((u32)((p)[2]) <<  8) | \
+   ((u32)((p)[3])      ))
+
+#ifdef ECRYPT_NATIVE64
+#define U8TO64_BIG(p) \
+  (((u64)((p)[0]) << 56) | \
+   ((u64)((p)[1]) << 48) | \
+   ((u64)((p)[2]) << 40) | \
+   ((u64)((p)[3]) << 32) | \
+   ((u64)((p)[4]) << 24) | \
+   ((u64)((p)[5]) << 16) | \
+   ((u64)((p)[6]) <<  8) | \
+   ((u64)((p)[7])      ))
+#else
+#define U8TO64_BIG(p) \
+  (((u64)U8TO32_BIG(p) << 32) | (u64)U8TO32_BIG((p) + 4))
+#endif
+
+#define U16TO8_LITTLE(p, v) \
+  do { \
+    (p)[0] = U8V((v)      ); \
+    (p)[1] = U8V((v) >>  8); \
+  } while (0)
+
+#define U32TO8_LITTLE(p, v) \
+  do { \
+    (p)[0] = U8V((v)      ); \
+    (p)[1] = U8V((v) >>  8); \
+    (p)[2] = U8V((v) >> 16); \
+    (p)[3] = U8V((v) >> 24); \
+  } while (0)
+
+#ifdef ECRYPT_NATIVE64
+#define U64TO8_LITTLE(p, v) \
+  do { \
+    (p)[0] = U8V((v)      ); \
+    (p)[1] = U8V((v) >>  8); \
+    (p)[2] = U8V((v) >> 16); \
+    (p)[3] = U8V((v) >> 24); \
+    (p)[4] = U8V((v) >> 32); \
+    (p)[5] = U8V((v) >> 40); \
+    (p)[6] = U8V((v) >> 48); \
+    (p)[7] = U8V((v) >> 56); \
+  } while (0)
+#else
+#define U64TO8_LITTLE(p, v) \
+  do { \
+    U32TO8_LITTLE((p),     U32V((v)      )); \
+    U32TO8_LITTLE((p) + 4, U32V((v) >> 32)); \
+  } while (0)
+#endif
+
+#define U16TO8_BIG(p, v) \
+  do { \
+    (p)[0] = U8V((v)      ); \
+    (p)[1] = U8V((v) >>  8); \
+  } while (0)
+
+#define U32TO8_BIG(p, v) \
+  do { \
+    (p)[0] = U8V((v) >> 24); \
+    (p)[1] = U8V((v) >> 16); \
+    (p)[2] = U8V((v) >>  8); \
+    (p)[3] = U8V((v)      ); \
+  } while (0)
+
+#ifdef ECRYPT_NATIVE64
+#define U64TO8_BIG(p, v) \
+  do { \
+    (p)[0] = U8V((v) >> 56); \
+    (p)[1] = U8V((v) >> 48); \
+    (p)[2] = U8V((v) >> 40); \
+    (p)[3] = U8V((v) >> 32); \
+    (p)[4] = U8V((v) >> 24); \
+    (p)[5] = U8V((v) >> 16); \
+    (p)[6] = U8V((v) >>  8); \
+    (p)[7] = U8V((v)      ); \
+  } while (0)
+#else
+#define U64TO8_BIG(p, v) \
+  do { \
+    U32TO8_BIG((p),     U32V((v) >> 32)); \
+    U32TO8_BIG((p) + 4, U32V((v)      )); \
+  } while (0)
+#endif
+
+#endif
+
+#include "ecrypt-machine.h"
+
+/* ------------------------------------------------------------------------- */
+
+#endif

src/crypto/ecrypt-sync.h

@@ -0,0 +1,258 @@
+/* ecrypt-sync.h */
+
+/*
+* Header file for synchronous stream ciphers without authentication
+* mechanism.
+*
+* *** Please only edit parts marked with "[edit]". ***
+*/
+
+#ifndef ECRYPT_SYNC_AE
+#define ECRYPT_SYNC_AE
+
+#include "ecrypt-portable.h"
+
+/* ------------------------------------------------------------------------- */
+
+/* Cipher parameters */
+
+/*
+* The name of your cipher.
+*/
+#define ECRYPT_NAME "Salsa20 stream cipher"    /* [edit] */ 
+
+/*
+* Specify which key and IV sizes are supported by your cipher. A user
+* should be able to enumerate the supported sizes by running the
+* following code:
+*
+* for (i = 0; ECRYPT_KEYSIZE(i) <= ECRYPT_MAXKEYSIZE; ++i)
+*   {
+*     keysize = ECRYPT_KEYSIZE(i);
+*
+*     ...
+*   }
+*
+* All sizes are in bits.
+*/
+
+#define ECRYPT_MAXKEYSIZE 256                 /* [edit] */
+#define ECRYPT_KEYSIZE(i) (128 + (i)*128)     /* [edit] */
+
+#define ECRYPT_MAXIVSIZE 64                   /* [edit] */
+#define ECRYPT_IVSIZE(i) (64 + (i)*64)        /* [edit] */
+
+/* ------------------------------------------------------------------------- */
+
+/* Data structures */
+
+/*
+* ECRYPT_ctx is the structure containing the representation of the
+* internal state of your cipher.
+*/
+
+typedef struct
+{
+  u32 input[16]; /* could be compressed */
+                 /*
+                 * [edit]
+                 *
+                 * Put here all state variable needed during the encryption process.
+                 */
+} ECRYPT_ctx;
+
+/* ------------------------------------------------------------------------- */
+
+/* Mandatory functions */
+
+/*
+* Key and message independent initialization. This function will be
+* called once when the program starts (e.g., to build expanded S-box
+* tables).
+*/
+void ECRYPT_init();
+
+/*
+* Key setup. It is the user's responsibility to select the values of
+* keysize and ivsize from the set of supported values specified
+* above.
+*/
+void ECRYPT_keysetup(
+  ECRYPT_ctx* ctx,
+  const u8* key,
+  u32 keysize,                /* Key size in bits. */
+  u32 ivsize);                /* IV size in bits. */
+
+                              /*
+                              * IV setup. After having called ECRYPT_keysetup(), the user is
+                              * allowed to call ECRYPT_ivsetup() different times in order to
+                              * encrypt/decrypt different messages with the same key but different
+                              * IV's.
+                              */
+void ECRYPT_ivsetup(
+  ECRYPT_ctx* ctx,
+  const u8* iv);
+
+/*
+* Encryption/decryption of arbitrary length messages.
+*
+* For efficiency reasons, the API provides two types of
+* encrypt/decrypt functions. The ECRYPT_encrypt_bytes() function
+* (declared here) encrypts byte strings of arbitrary length, while
+* the ECRYPT_encrypt_blocks() function (defined later) only accepts
+* lengths which are multiples of ECRYPT_BLOCKLENGTH.
+*
+* The user is allowed to make multiple calls to
+* ECRYPT_encrypt_blocks() to incrementally encrypt a long message,
+* but he is NOT allowed to make additional encryption calls once he
+* has called ECRYPT_encrypt_bytes() (unless he starts a new message
+* of course). For example, this sequence of calls is acceptable:
+*
+* ECRYPT_keysetup();
+*
+* ECRYPT_ivsetup();
+* ECRYPT_encrypt_blocks();
+* ECRYPT_encrypt_blocks();
+* ECRYPT_encrypt_bytes();
+*
+* ECRYPT_ivsetup();
+* ECRYPT_encrypt_blocks();
+* ECRYPT_encrypt_blocks();
+*
+* ECRYPT_ivsetup();
+* ECRYPT_encrypt_bytes();
+*
+* The following sequence is not:
+*
+* ECRYPT_keysetup();
+* ECRYPT_ivsetup();
+* ECRYPT_encrypt_blocks();
+* ECRYPT_encrypt_bytes();
+* ECRYPT_encrypt_blocks();
+*/
+
+void ECRYPT_encrypt_bytes(
+  ECRYPT_ctx* ctx,
+  const u8* plaintext,
+  u8* ciphertext,
+  u32 msglen);                /* Message length in bytes. */
+
+void ECRYPT_decrypt_bytes(
+  ECRYPT_ctx* ctx,
+  const u8* ciphertext,
+  u8* plaintext,
+  u32 msglen);                /* Message length in bytes. */
+
+                              /* ------------------------------------------------------------------------- */
+
+                              /* Optional features */
+
+                              /*
+                              * For testing purposes it can sometimes be useful to have a function
+                              * which immediately generates keystream without having to provide it
+                              * with a zero plaintext. If your cipher cannot provide this function
+                              * (e.g., because it is not strictly a synchronous cipher), please
+                              * reset the ECRYPT_GENERATES_KEYSTREAM flag.
+                              */
+
+#define ECRYPT_GENERATES_KEYSTREAM
+#ifdef ECRYPT_GENERATES_KEYSTREAM
+
+void ECRYPT_keystream_bytes(
+  ECRYPT_ctx* ctx,
+  u8* keystream,
+  u32 length);                /* Length of keystream in bytes. */
+
+#endif
+
+                              /* ------------------------------------------------------------------------- */
+
+                              /* Optional optimizations */
+
+                              /*
+                              * By default, the functions in this section are implemented using
+                              * calls to functions declared above. However, you might want to
+                              * implement them differently for performance reasons.
+                              */
+
+                              /*
+                              * All-in-one encryption/decryption of (short) packets.
+                              *
+                              * The default definitions of these functions can be found in
+                              * "ecrypt-sync.c". If you want to implement them differently, please
+                              * undef the ECRYPT_USES_DEFAULT_ALL_IN_ONE flag.
+                              */
+#define ECRYPT_USES_DEFAULT_ALL_IN_ONE        /* [edit] */
+
+void ECRYPT_encrypt_packet(
+  ECRYPT_ctx* ctx,
+  const u8* iv,
+  const u8* plaintext,
+  u8* ciphertext,
+  u32 msglen);
+
+void ECRYPT_decrypt_packet(
+  ECRYPT_ctx* ctx,
+  const u8* iv,
+  const u8* ciphertext,
+  u8* plaintext,
+  u32 msglen);
+
+/*
+* Encryption/decryption of blocks.
+*
+* By default, these functions are defined as macros. If you want to
+* provide a different implementation, please undef the
+* ECRYPT_USES_DEFAULT_BLOCK_MACROS flag and implement the functions
+* declared below.
+*/
+
+#define ECRYPT_BLOCKLENGTH 64                  /* [edit] */
+
+#define ECRYPT_USES_DEFAULT_BLOCK_MACROS      /* [edit] */
+#ifdef ECRYPT_USES_DEFAULT_BLOCK_MACROS
+
+#define ECRYPT_encrypt_blocks(ctx, plaintext, ciphertext, blocks)  \
+  ECRYPT_encrypt_bytes(ctx, plaintext, ciphertext,                 \
+    (blocks) * ECRYPT_BLOCKLENGTH)
+
+#define ECRYPT_decrypt_blocks(ctx, ciphertext, plaintext, blocks)  \
+  ECRYPT_decrypt_bytes(ctx, ciphertext, plaintext,                 \
+    (blocks) * ECRYPT_BLOCKLENGTH)
+
+#ifdef ECRYPT_GENERATES_KEYSTREAM
+
+#define ECRYPT_keystream_blocks(ctx, keystream, blocks)            \
+  ECRYPT_AE_keystream_bytes(ctx, keystream,                        \
+    (blocks) * ECRYPT_BLOCKLENGTH)
+
+#endif
+
+#else
+
+void ECRYPT_encrypt_blocks(
+  ECRYPT_ctx* ctx,
+  const u8* plaintext,
+  u8* ciphertext,
+  u32 blocks);                /* Message length in blocks. */
+
+void ECRYPT_decrypt_blocks(
+  ECRYPT_ctx* ctx,
+  const u8* ciphertext,
+  u8* plaintext,
+  u32 blocks);                /* Message length in blocks. */
+
+#ifdef ECRYPT_GENERATES_KEYSTREAM
+
+void ECRYPT_keystream_blocks(
+  ECRYPT_AE_ctx* ctx,
+  const u8* keystream,
+  u32 blocks);                /* Keystream length in blocks. */
+
+#endif
+
+#endif
+
+                              /* ------------------------------------------------------------------------- */
+
+#endif

src/currency_core/account.cpp

@@ -81,7 +81,7 @@ namespace currency
     if (m_keys.account_address.flags & ACCOUNT_PUBLIC_ADDRESS_FLAG_AUDITABLE)
       auditable_flag = 1;
 
-    uint64_t auditable_flag_and_checksum = (auditable_flag & 1) | (checksum << 1);
+    uint32_t auditable_flag_and_checksum = (auditable_flag & 1) | (checksum << 1);
     std::string auditable_flag_and_checksum_word = tools::mnemonic_encoding::word_by_num(auditable_flag_and_checksum);
 
     return keys_seed_text + " " + timestamp_word + " " + auditable_flag_and_checksum_word;
@@ -148,7 +148,7 @@ namespace currency
     if (auditable_flag_and_checksum != UINT64_MAX)
     {
       auditable_flag = (auditable_flag_and_checksum & 1) != 0; // auditable flag is the lower 1 bit
-      uint16_t checksum = auditable_flag_and_checksum >> 1; // checksum -- everything else
+      uint16_t checksum = static_cast<uint16_t>(auditable_flag_and_checksum >> 1); // checksum -- everything else
       constexpr uint16_t checksum_max = tools::mnemonic_encoding::NUMWORDS >> 1; // maximum value of checksum
       crypto::hash h = crypto::cn_fast_hash(keys_seed_binary.data(), keys_seed_binary.size());
       *reinterpret_cast<uint64_t*>(&h) = m_creation_timestamp;

src/currency_core/blockchain_storage_boost_serialization.h

@@ -6,6 +6,8 @@
 
 #pragma once 
 
+#include "currency_boost_serialization.h"
+
 namespace boost
 {
   namespace serialization

src/currency_core/currency_boost_serialization.h

@@ -208,7 +208,7 @@ namespace boost
     inline void serialize(Archive &a, currency::keypair &kp, const boost::serialization::version_type ver)
     {
       a & kp.pub;
-      a & kp.sec;
+      a & kp.sec; 
     }
 
     template <class Archive>

src/currency_core/currency_config.h

@@ -146,7 +146,8 @@
 
 #define WALLET_FILE_SIGNATURE_OLD                       0x1111012101101011LL  // Bender's nightmare
 #define WALLET_FILE_SIGNATURE_V2                        0x1111011201101011LL  // another Bender's nightmare
-#define WALLET_FILE_MAX_BODY_SIZE                       0x88888888L //2GB
+#define WALLET_FILE_BINARY_HEADER_VERSION               1001
+
 #define WALLET_FILE_MAX_KEYS_SIZE                       10000 //
 #define WALLET_BRAIN_DATE_OFFSET                        1543622400
 #define WALLET_BRAIN_DATE_QUANTUM                       604800 //by last word we encode a number of week since launch of the project, 

src/wallet/wallet2.cpp

@@ -7,6 +7,8 @@
 #include <numeric>
 #include <boost/archive/binary_oarchive.hpp>
 #include <boost/archive/binary_iarchive.hpp>
+#include <boost/iostreams/stream.hpp>
+#include <boost/iostreams/filtering_stream.hpp>
 #include <boost/filesystem/fstream.hpp>
 #include <iostream>
 #include <boost/utility/value_init.hpp>
@@ -26,6 +28,7 @@ using namespace epee;
 #include "serialization/binary_utils.h"
 #include "currency_core/bc_payments_id_service.h"
 #include "version.h"
+#include "common/encryption_filter.h"
 using namespace currency;
 
 #define MINIMUM_REQUIRED_WALLET_FREE_SPACE_BYTES (100*1024*1024) // 100 MB
@@ -2120,7 +2123,7 @@ bool wallet2::reset_all()
   return true;
 }
 //----------------------------------------------------------------------------------------------------
-bool wallet2::store_keys(std::string& buff, const std::string& password, bool store_as_watch_only /* = false */)
+bool wallet2::store_keys(std::string& buff, const std::string& password, wallet2::keys_file_data& keys_file_data, bool store_as_watch_only /* = false */)
 {
   currency::account_base acc = m_account;
   if (store_as_watch_only)
@@ -2130,8 +2133,6 @@ bool wallet2::store_keys(std::string& buff, const std::string& password, bool st
   bool r = epee::serialization::store_t_to_binary(acc, account_data);
   WLT_CHECK_AND_ASSERT_MES(r, false, "failed to serialize wallet keys");
 
-  wallet2::keys_file_data keys_file_data = boost::value_initialized<wallet2::keys_file_data>();
-
   crypto::chacha8_key key;
   crypto::generate_chacha8_key(password, key);
   std::string cipher;
@@ -2148,7 +2149,8 @@ bool wallet2::store_keys(std::string& buff, const std::string& password, bool st
 bool wallet2::backup_keys(const std::string& path)
 {
   std::string buff;
-  bool r = store_keys(buff, m_password);
+  wallet2::keys_file_data keys_file_data = AUTO_VAL_INIT(keys_file_data);
+  bool r = store_keys(buff, m_password, keys_file_data);
   WLT_CHECK_AND_ASSERT_MES(r, false, "Failed to store keys");
 
   r = file_io_utils::save_string_to_file(path, buff);
@@ -2234,10 +2236,9 @@ bool wallet2::prepare_file_names(const std::wstring& file_path)
   return true;
 }
 //----------------------------------------------------------------------------------------------------
-void wallet2::load_keys(const std::string& buff, const std::string& password, uint64_t file_signature)
+void wallet2::load_keys(const std::string& buff, const std::string& password, uint64_t file_signature, keys_file_data& kf_data)
 {
   bool r = false;
-  wallet2::keys_file_data kf_data = AUTO_VAL_INIT(kf_data);
   if (file_signature == WALLET_FILE_SIGNATURE_OLD)
   {
     wallet2::keys_file_data_old kf_data_old;
@@ -2356,16 +2357,30 @@ void wallet2::load(const std::wstring& wallet_, const std::string& password)
   THROW_IF_TRUE_WALLET_EX(data_file.fail(), error::file_read_error, epee::string_encoding::convert_to_ansii(m_wallet_file));
 
   THROW_IF_TRUE_WALLET_EX(wbh.m_signature != WALLET_FILE_SIGNATURE_OLD && wbh.m_signature != WALLET_FILE_SIGNATURE_V2, error::file_read_error, epee::string_encoding::convert_to_ansii(m_wallet_file));
-  THROW_IF_TRUE_WALLET_EX(wbh.m_cb_body > WALLET_FILE_MAX_BODY_SIZE || 
+  THROW_IF_TRUE_WALLET_EX(
     wbh.m_cb_keys > WALLET_FILE_MAX_KEYS_SIZE, error::file_read_error, epee::string_encoding::convert_to_ansii(m_wallet_file));
 
 
   keys_buff.resize(wbh.m_cb_keys);
   data_file.read((char*)keys_buff.data(), wbh.m_cb_keys);
+  wallet2::keys_file_data kf_data = AUTO_VAL_INIT(kf_data);
+  load_keys(keys_buff, password, wbh.m_signature, kf_data);
 
-  load_keys(keys_buff, password, wbh.m_signature);
+  bool need_to_resync = false;
-
+  if (wbh.m_ver == 1000)
-  bool need_to_resync = !tools::portable_unserialize_obj_from_stream(*this, data_file);
+  {
+    need_to_resync = !tools::portable_unserialize_obj_from_stream(*this, data_file);
+  }
+  else
+  {
+    tools::encrypt_chacha_in_filter decrypt_filter(password, kf_data.iv);
+    boost::iostreams::filtering_istream in;
+    in.push(decrypt_filter);
+    in.push(data_file);
+    need_to_resync = !tools::portable_unserialize_obj_from_stream(*this, in);
+  }
+    
+    
 
   if (m_watch_only && !is_auditable())
     load_keys2ki(true, need_to_resync);
@@ -2405,7 +2420,8 @@ void wallet2::store(const std::wstring& path_to_save, const std::string& passwor
 
   //prepare data
   std::string keys_buff;
-  bool r = store_keys(keys_buff, password, m_watch_only);
+  wallet2::keys_file_data keys_file_data = AUTO_VAL_INIT(keys_file_data);
+  bool r = store_keys(keys_buff, password, keys_file_data, m_watch_only);
   WLT_THROW_IF_FALSE_WALLET_CMN_ERR_EX(r, "failed to store_keys for wallet " << ascii_path_to_save);
 
   //store data
@@ -2413,7 +2429,7 @@ void wallet2::store(const std::wstring& path_to_save, const std::string& passwor
   wbh.m_signature = WALLET_FILE_SIGNATURE_V2;
   wbh.m_cb_keys = keys_buff.size();
   //@#@ change it to proper
-  wbh.m_cb_body = 1000;
+  wbh.m_ver = WALLET_FILE_BINARY_HEADER_VERSION;
   std::string header_buff((const char*)&wbh, sizeof(wbh));
 
   uint64_t ts = m_core_runtime_config.get_core_time();
@@ -2428,8 +2444,13 @@ void wallet2::store(const std::wstring& path_to_save, const std::string& passwor
   data_file << header_buff << keys_buff;
 
   WLT_LOG_L0("Storing to temporary file " << tmp_file_path.string() << " ...");
+  //creating encryption stream
+  tools::encrypt_chacha_out_filter decrypt_filter(m_password, keys_file_data.iv);
+  boost::iostreams::filtering_ostream out;
+  out.push(decrypt_filter);
+  out.push(data_file);
 
-  r = tools::portble_serialize_obj_to_stream(*this, data_file);
+  r = tools::portble_serialize_obj_to_stream(*this, out);
   if (!r)
   {
     data_file.close();

src/wallet/wallet2.h

@@ -88,7 +88,9 @@ namespace tools
   {
     uint64_t m_signature;
     uint16_t m_cb_keys;
-    uint64_t m_cb_body;
+    //uint64_t m_cb_body; <-- this field never used, soo replace it with two other variables "m_ver" + and "m_reserved"
+    uint32_t m_ver;
+    uint32_t m_reserved; //for future use
   };
 #pragma pack (pop)
 
@@ -472,7 +474,7 @@ namespace tools
     void store(const std::wstring& path);
     void store(const std::wstring& path, const std::string& password);
     void store_watch_only(const std::wstring& path, const std::string& password) const;
-    bool store_keys(std::string& buff, const std::string& password, bool store_as_watch_only = false);
+    bool store_keys(std::string& buff, const std::string& password, wallet2::keys_file_data& keys_file_data, bool store_as_watch_only = false);
     std::wstring get_wallet_path()const { return m_wallet_file; }
     std::string get_wallet_password()const { return m_password; }
     currency::account_base& get_account() { return m_account; }
@@ -803,7 +805,7 @@ private:
 
     void add_transfers_to_expiration_list(const std::vector<uint64_t>& selected_transfers, uint64_t expiration, uint64_t change_amount, const crypto::hash& related_tx_id);
     void remove_transfer_from_expiration_list(uint64_t transfer_index);
-    void load_keys(const std::string& keys_file_name, const std::string& password, uint64_t file_signature);
+    void load_keys(const std::string& keys_file_name, const std::string& password, uint64_t file_signature, keys_file_data& kf_data);
     void process_new_transaction(const currency::transaction& tx, uint64_t height, const currency::block& b, const std::vector<uint64_t>* pglobal_indexes);
     void fetch_tx_global_indixes(const currency::transaction& tx, std::vector<uint64_t>& goutputs_indexes);
     void fetch_tx_global_indixes(const std::list<std::reference_wrapper<const currency::transaction>>& txs, std::vector<std::vector<uint64_t>>& goutputs_indexes);

tests/CMakeLists.txt

@@ -33,7 +33,7 @@ target_link_libraries(functional_tests rpc wallet currency_core crypto common zl
 target_link_libraries(hash-tests crypto ethash)
 target_link_libraries(hash-target-tests crypto currency_core ethash ${CMAKE_THREAD_LIBS_INIT} ${Boost_LIBRARIES})
 target_link_libraries(performance_tests currency_core common crypto zlibstatic ethash ${CMAKE_THREAD_LIBS_INIT} ${Boost_LIBRARIES})
-target_link_libraries(unit_tests wallet currency_core crypto common gtest_main zlibstatic ethash ${CMAKE_THREAD_LIBS_INIT} ${Boost_LIBRARIES})
+target_link_libraries(unit_tests wallet currency_core common crypto gtest_main zlibstatic ethash ${CMAKE_THREAD_LIBS_INIT} ${Boost_LIBRARIES})
 target_link_libraries(net_load_tests_clt currency_core common crypto gtest_main ${CMAKE_THREAD_LIBS_INIT} ${Boost_LIBRARIES})
 target_link_libraries(net_load_tests_srv currency_core common crypto gtest_main ${CMAKE_THREAD_LIBS_INIT} ${Boost_LIBRARIES})
 

tests/performance_tests/chacha_stream_performance_test.cpp

@@ -0,0 +1,186 @@
+// Copyright (c) 2014-2015 The Boolberry developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <cstdint>
+#include <vector>
+#include <boost/iostreams/stream.hpp>
+#include <boost/iostreams/invert.hpp>
+#include <boost/iostreams/filtering_stream.hpp>
+
+#include "common/encryption_filter.h"
+#include "crypto/crypto.h"
+#include "currency_core/blockchain_storage_basic.h"
+#include "currency_core/blockchain_storage_boost_serialization.h"
+#include "common/boost_serialization_helper.h"
+
+
+bool perform_crypt_stream_iteration(const std::list<currency::block_extended_info>& test_list, const crypto::chacha8_iv& iv)
+{
+  std::list<currency::block_extended_info> verification_list;
+  boost::filesystem::ofstream store_data_file;
+  store_data_file.open("./test.bin", std::ios_base::binary | std::ios_base::out | std::ios::trunc);
+  tools::encrypt_chacha_out_filter encrypt_filter("pass", iv);
+  boost::iostreams::filtering_ostream out;
+  out.push(encrypt_filter);
+  out.push(store_data_file);
+
+
+  //out << buff;
+  bool res = tools::portble_serialize_obj_to_stream(test_list, out);
+
+  out.flush();
+  store_data_file.close();
+
+  boost::filesystem::ifstream data_file;
+  data_file.open("./test.bin", std::ios_base::binary | std::ios_base::in);
+  tools::encrypt_chacha_in_filter decrypt_filter("pass", iv);
+
+  boost::iostreams::filtering_istream in;
+  in.push(decrypt_filter);
+  in.push(data_file);
+  try {
+
+    bool res2 = tools::portable_unserialize_obj_from_stream(verification_list, in);
+    CHECK_AND_ASSERT_MES(res, false, "Failed to unserialize wallet");
+    size_t i = 0;
+    CHECK_AND_ASSERT_MES(test_list.size() == verification_list.size(), false, "restored list is wrong size");
+    return true;
+  }
+  catch (std::exception& err)
+  {
+    LOG_ERROR("Exception: " << err.what());
+    return false;
+  }
+  return true;
+}
+
+bool perform_just_substream_stream_iteration(const std::list<currency::block_extended_info>& test_list, const crypto::chacha8_iv& iv)
+{
+  std::list<currency::block_extended_info> verification_list;
+  boost::filesystem::ofstream store_data_file;
+  store_data_file.open("./test3.bin", std::ios_base::binary | std::ios_base::out | std::ios::trunc);
+  //encrypt_chacha_out_filter encrypt_filter("pass", iv);
+  boost::iostreams::filtering_ostream out;
+  //out.push(encrypt_filter);
+  out.push(store_data_file);
+
+
+  //out << buff;
+  bool res = tools::portble_serialize_obj_to_stream(test_list, out);
+
+  out.flush();
+  store_data_file.close();
+
+  boost::filesystem::ifstream data_file;
+  data_file.open("./test3.bin", std::ios_base::binary | std::ios_base::in);
+  //encrypt_chacha_in_filter decrypt_filter("pass", iv);
+
+  boost::iostreams::filtering_istream in;
+  //in.push(decrypt_filter);
+  in.push(data_file);
+  try {
+
+    bool res2 = tools::portable_unserialize_obj_from_stream(verification_list, in);
+    CHECK_AND_ASSERT_MES(res, false, "Failed to unserialize wallet");
+    size_t i = 0;
+    CHECK_AND_ASSERT_MES(test_list.size() == verification_list.size(), false, "restored list is wrong size");
+    return true;
+  }
+  catch (std::exception& err)
+  {
+    LOG_ERROR("Exception: " << err.what());
+    return false;
+  }
+  return true;
+}
+
+
+bool perform_no_crypt_stream_iteration(const std::list<currency::block_extended_info>& test_list, const crypto::chacha8_iv& iv)
+{
+  std::list<currency::block_extended_info> verification_list;
+  boost::filesystem::ofstream store_data_file;
+  store_data_file.open("./test2.bin", std::ios_base::binary | std::ios_base::out | std::ios::trunc);
+//  encrypt_chacha_out_filter encrypt_filter("pass", iv);
+//  boost::iostreams::filtering_ostream out;
+//  out.push(encrypt_filter);
+//  out.push(store_data_file);
+
+
+  //out << buff;
+  bool res = tools::portble_serialize_obj_to_stream(test_list, store_data_file);
+
+  store_data_file.flush();
+  store_data_file.close();
+
+  boost::filesystem::ifstream data_file;
+  data_file.open("./test2.bin", std::ios_base::binary | std::ios_base::in);
+//  encrypt_chacha_in_filter decrypt_filter("pass", iv);
+
+//  boost::iostreams::filtering_istream in;
+//  in.push(decrypt_filter);
+//  in.push(data_file);
+  try {
+
+    bool res2 = tools::portable_unserialize_obj_from_stream(verification_list, data_file);
+    CHECK_AND_ASSERT_MES(res, false, "Failed to unserialize wallet");
+    size_t i = 0;
+    CHECK_AND_ASSERT_MES(test_list.size() == verification_list.size(), false, "restored list is wrong size");
+    return true;
+  }
+  catch (std::exception& err)
+  {
+    LOG_ERROR("Exception: " << err.what());
+    return false;
+  }
+}
+
+
+
+bool do_chacha_stream_performance_test()
+{
+  LOG_PRINT_L0("chacha_stream_test");
+  std::list<currency::block_extended_info> test_list;
+  for (size_t i = 0; i != 10000; i++) {
+    test_list.push_back(currency::block_extended_info());
+    test_list.back().height = i;
+    test_list.back().this_block_tx_fee_median = i;
+  }
+
+
+  crypto::chacha8_iv iv = crypto::rand<crypto::chacha8_iv>();
+  LOG_PRINT_L0("Running substream stream performance tests...");
+  TIME_MEASURE_START(substream_version);
+  for (size_t i = 0; i != 100; i++)
+  {
+    bool r = perform_just_substream_stream_iteration(test_list, iv);
+    CHECK_AND_ASSERT_MES(r, false, "Failed to perform_crypt_stream_iteration");
+  }
+  TIME_MEASURE_FINISH(substream_version);
+  LOG_PRINT_L0("OK.time: " << substream_version);
+  LOG_PRINT_L0("Running crypt stream performance tests...");
+  TIME_MEASURE_START(crypted_version);
+  for (size_t i = 0; i != 100; i++)
+  {
+    bool r = perform_crypt_stream_iteration(test_list, iv);
+    CHECK_AND_ASSERT_MES(r, false, "Failed to perform_crypt_stream_iteration");
+  }
+  TIME_MEASURE_FINISH(crypted_version);
+  LOG_PRINT_L0("OK.time: " << crypted_version);
+  LOG_PRINT_L0("Running non-crypt stream performance tests...");
+  TIME_MEASURE_START(non_crypted_version);
+  for (size_t i = 0; i != 100; i++)
+  {
+    bool r = perform_no_crypt_stream_iteration(test_list, iv);
+    CHECK_AND_ASSERT_MES(r, false, "Failed to perform_crypt_stream_iteration");
+  }
+  TIME_MEASURE_FINISH(non_crypted_version);
+  LOG_PRINT_L0("OK.time: " << non_crypted_version);
+
+
+
+}
+
+
+
+

tests/performance_tests/chacha_stream_performance_test.h

@@ -0,0 +1,7 @@
+// Copyright (c) 2014-2015 The Boolberry developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#pragma once
+
+bool do_chacha_stream_performance_test();

tests/performance_tests/main.cpp

@@ -17,6 +17,7 @@
 #include "is_out_to_acc.h"
 #include "core_market_performance_test.h"
 #include "serialization_performance_test.h"
+#include "chacha_stream_performance_test.h"
 #include "keccak_test.h"
 #include "blake2_test.h"
 #include "print_struct_to_json.h"
@@ -38,9 +39,10 @@ int main(int argc, char** argv)
   set_process_affinity(1);
   set_thread_high_priority();
 
+  do_chacha_stream_performance_test();
   //test_blake2();
 
-  free_space_check();
+  //free_space_check();
   
   //print_struct_to_json();
 

tests/unit_tests/chacha_stream_test.cpp

@@ -0,0 +1,142 @@
+// Copyright (c) 2012-2014 The Boolberry developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "gtest/gtest.h"
+
+#include <cstdint>
+#include <vector>
+#include <boost/iostreams/stream.hpp>
+#include <boost/iostreams/invert.hpp>
+#include <boost/iostreams/filtering_stream.hpp>
+
+#include "common/encryption_filter.h"
+#include "crypto/crypto.h"
+#include "currency_core/blockchain_storage_basic.h"
+#include "currency_core/blockchain_storage_boost_serialization.h"
+#include "common/boost_serialization_helper.h"
+
+
+TEST(chacha_stream_test, basic_test_with_serialization_on_top)
+{
+  LOG_PRINT_L0("chacha_stream_test");
+  std::list<currency::block_extended_info> test_list;
+  for(size_t i = 0; i != 1000; i++) {
+    test_list.push_back(currency::block_extended_info());
+    test_list.back().height = i;
+    test_list.back().this_block_tx_fee_median = i;
+  }
+
+  std::list<currency::block_extended_info> verification_list;
+  crypto::chacha8_iv iv = crypto::rand<crypto::chacha8_iv>();
+  boost::filesystem::ofstream store_data_file;
+  store_data_file.open("./test.bin", std::ios_base::binary | std::ios_base::out | std::ios::trunc);
+  tools::encrypt_chacha_out_filter encrypt_filter("pass", iv);
+  boost::iostreams::filtering_ostream out;
+  out.push(encrypt_filter);
+  out.push(store_data_file);
+
+
+  //out << buff;
+  bool res = tools::portble_serialize_obj_to_stream(test_list, out);
+  
+  out.flush();
+  store_data_file.close();
+
+  boost::filesystem::ifstream data_file;
+  data_file.open("./test.bin", std::ios_base::binary | std::ios_base::in);
+  tools::encrypt_chacha_in_filter decrypt_filter("pass", iv);
+
+  boost::iostreams::filtering_istream in;
+  in.push(decrypt_filter);
+  in.push(data_file);
+  try {
+    
+    bool res2 = tools::portable_unserialize_obj_from_stream(verification_list, in);
+    ASSERT_TRUE(res2);
+    size_t i = 0;
+    for(auto vle: verification_list) {
+      ASSERT_TRUE(vle.height == i);
+      ASSERT_TRUE(vle.this_block_tx_fee_median == i);
+      i++;
+    }
+    //if(verification_list != test_list) 
+  }
+  catch (std::exception& err)
+  {
+    std::cout << err.what();
+    ASSERT_TRUE(false);
+  }
+  
+}
+
+
+TEST(chacha_stream_test, diversity_test_on_different_stream_behaviour)
+{
+  LOG_PRINT_L0("chacha_stream_test");
+  //prepare buff
+  const size_t buff_size = 10000;
+  std::string buff(buff_size, ' ');
+  for(size_t i = 0; i != buff_size; i++) {
+    buff[i] = i % 255;
+  }
+
+  crypto::chacha8_iv iv = crypto::rand<crypto::chacha8_iv>();
+  boost::filesystem::ofstream store_data_file;
+  store_data_file.open("./test.bin", std::ios_base::binary | std::ios_base::out | std::ios::trunc);
+  tools::encrypt_chacha_out_filter encrypt_filter("pass", iv);
+  //boost::iostreams::stream<encrypt_chacha_sink> outputStream(sink_encrypt);
+  boost::iostreams::filtering_ostream out;
+  out.push(encrypt_filter);
+  out.push(store_data_file);
+
+  out << buff;
+
+  out.flush();
+  store_data_file.close();
+  for (size_t d = 0; d != 1000; d++)
+  {
+    boost::filesystem::ifstream data_file;
+    data_file.open("./test.bin", std::ios_base::binary | std::ios_base::in);
+    tools::encrypt_chacha_in_filter decrypt_filter("pass", iv);
+
+    boost::iostreams::filtering_istream in;
+    in.push(decrypt_filter);
+    in.push(data_file);
+
+    std::string str(buff_size + 100, ' ');
+    try {
+
+      size_t offset = 0;
+      while (offset < buff_size+1)
+      {
+        std::streamsize count = std::rand() % 100;
+        //      if (count + offset > buff_size)
+        //      {
+        //        count = buff_size - offset;
+        //      }
+        in.read((char*)&str.data()[offset], count);
+        //self check
+        size_t readed_sz = in.gcount();
+        if (!(count + offset > buff_size || readed_sz == count))
+        {
+          ASSERT_TRUE(count + offset > buff_size || readed_sz == count);
+        }
+        offset += readed_sz;
+        if (!in) {
+          break;
+        }
+      }
+      if (in) {
+        ASSERT_TRUE(false);
+      }
+      std::cout << "OK";
+    }
+    catch (std::exception& err) {
+      std::cout << err.what();
+      ASSERT_TRUE(false);
+    }
+  }
+  std::cout << "Finished OK!";
+
+}