rename the project

9 files changed, 1184 insertions, 0 deletions

diff --git a/cxx/include/aesxx/aes.hpp b/cxx/include/aesxx/aes.hpp
new file mode 100644
index 0000000..698c0ef
--- /dev/null
+++ b/cxx/include/aesxx/aes.hpp
@@ -0,0 +1,278 @@
+/**
+ * \file
+ * \author Egor Tensin <Egor.Tensin@gmail.com>
+ * \date 2015
+ * \copyright This file is licensed under the terms of the MIT License.
+ *            See LICENSE.txt for details.
+ */
+
+#pragma once
+
+#include "algorithm.hpp"
+#include "api.hpp"
+#include "error.hpp"
+#include "mode.hpp"
+
+#include <aes/all.h>
+
+#include <cstddef>
+
+#include <string>
+
+namespace aesni
+{
+    namespace aes128
+    {
+        typedef AesNI_AES128_Block Block;
+        typedef AesNI_AES128_RoundKeys RoundKeys;
+        typedef AesNI_AES128_Key Key;
+    }
+
+    template <>
+    struct Types<AESNI_AES128>
+    {
+        typedef aes128::Block Block;
+        typedef aes128::RoundKeys RoundKeys;
+        typedef aes128::Key Key;
+    };
+
+    template <>
+    std::size_t get_number_of_rounds<AESNI_AES128>()
+    {
+        return 11;
+    }
+
+    template <>
+    void from_string<AESNI_AES128>(aes128::Block& dest, const char* src)
+    {
+        aesni_AES128_parse_block(&dest, src, ErrorDetailsThrowsInDestructor());
+    }
+
+    template <>
+    std::string to_string<AESNI_AES128>(const aes128::Block& src)
+    {
+        AesNI_AES128_BlockString str;
+        aesni_AES128_format_block(&str, &src, ErrorDetailsThrowsInDestructor());
+        return { str.str };
+    }
+
+    template <>
+    std::string to_matrix_string<AESNI_AES128>(const aes128::Block& src)
+    {
+        AesNI_AES128_BlockMatrixString str;
+        aesni_AES128_format_block_as_matrix(&str, &src, ErrorDetailsThrowsInDestructor());
+        return { str.str };
+    }
+
+    template <>
+    void from_string<AESNI_AES128>(aes128::Key& dest, const char* src)
+    {
+        aesni_AES128_parse_key(&dest, src, ErrorDetailsThrowsInDestructor());
+    }
+
+    template <>
+    std::string to_string<AESNI_AES128>(const aes128::Key& src)
+    {
+        AesNI_AES128_KeyString str;
+        aesni_AES128_format_key(&str, &src, ErrorDetailsThrowsInDestructor());
+        return { str.str };
+    }
+
+    template <>
+    inline void expand_key<AESNI_AES128>(
+        const aes128::Key& key,
+        aes128::RoundKeys& encryption_keys)
+    {
+        aesni_AES128_expand_key(&key, &encryption_keys);
+    }
+
+    template <>
+    inline void derive_decryption_keys<AESNI_AES128>(
+        const aes128::RoundKeys& encryption_keys,
+        aes128::RoundKeys& decryption_keys)
+    {
+        aesni_AES128_derive_decryption_keys(
+            &encryption_keys, &decryption_keys);
+    }
+
+    AESNIXX_ENCRYPT_BLOCK_ECB(AES128);
+    AESNIXX_DECRYPT_BLOCK_ECB(AES128);
+    AESNIXX_ENCRYPT_BLOCK_CBC(AES128);
+    AESNIXX_DECRYPT_BLOCK_CBC(AES128);
+    AESNIXX_ENCRYPT_BLOCK_CFB(AES128);
+    AESNIXX_DECRYPT_BLOCK_CFB(AES128);
+    AESNIXX_ENCRYPT_BLOCK_OFB(AES128);
+    AESNIXX_DECRYPT_BLOCK_OFB(AES128);
+    AESNIXX_ENCRYPT_BLOCK_CTR(AES128);
+    AESNIXX_DECRYPT_BLOCK_CTR(AES128);
+
+    namespace aes192
+    {
+        typedef AesNI_AES192_Block Block;
+        typedef AesNI_AES192_RoundKeys RoundKeys;
+        typedef AesNI_AES192_Key Key;
+    }
+
+    template <>
+    struct Types<AESNI_AES192>
+    {
+        typedef aes192::Block Block;
+        typedef aes192::RoundKeys RoundKeys;
+        typedef aes192::Key Key;
+    };
+
+    template <>
+    std::size_t get_number_of_rounds<AESNI_AES192>()
+    {
+        return 13;
+    }
+
+    template <>
+    void from_string<AESNI_AES192>(aes192::Block& dest, const char* src)
+    {
+        aesni_AES192_parse_block(&dest, src, ErrorDetailsThrowsInDestructor());
+    }
+
+    template <>
+    std::string to_string<AESNI_AES192>(const aes192::Block& src)
+    {
+        AesNI_AES192_BlockString str;
+        aesni_AES192_format_block(&str, &src, ErrorDetailsThrowsInDestructor());
+        return { str.str };
+    }
+
+    template <>
+    std::string to_matrix_string<AESNI_AES192>(const aes192::Block& src)
+    {
+        AesNI_AES192_BlockMatrixString str;
+        aesni_AES192_format_block_as_matrix(&str, &src, ErrorDetailsThrowsInDestructor());
+        return { str.str };
+    }
+
+    template <>
+    void from_string<AESNI_AES192>(aes192::Key& dest, const char* src)
+    {
+        aesni_AES192_parse_key(&dest, src, ErrorDetailsThrowsInDestructor());
+    }
+
+    template <>
+    std::string to_string<AESNI_AES192>(const aes192::Key& src)
+    {
+        AesNI_AES192_KeyString str;
+        aesni_AES192_format_key(&str, &src, ErrorDetailsThrowsInDestructor());
+        return { str.str };
+    }
+
+    template <>
+    inline void expand_key<AESNI_AES192>(
+        const aes192::Key& key,
+        aes192::RoundKeys& encryption_keys)
+    {
+        aesni_AES192_expand_key(&key, &encryption_keys);
+    }
+
+    template <>
+    inline void derive_decryption_keys<AESNI_AES192>(
+        const aes192::RoundKeys& encryption_keys,
+        aes192::RoundKeys& decryption_keys)
+    {
+        aesni_AES192_derive_decryption_keys(
+            &encryption_keys, &decryption_keys);
+    }
+
+    AESNIXX_ENCRYPT_BLOCK_ECB(AES192);
+    AESNIXX_DECRYPT_BLOCK_ECB(AES192);
+    AESNIXX_ENCRYPT_BLOCK_CBC(AES192);
+    AESNIXX_DECRYPT_BLOCK_CBC(AES192);
+    AESNIXX_ENCRYPT_BLOCK_CFB(AES192);
+    AESNIXX_DECRYPT_BLOCK_CFB(AES192);
+    AESNIXX_ENCRYPT_BLOCK_OFB(AES192);
+    AESNIXX_DECRYPT_BLOCK_OFB(AES192);
+    AESNIXX_ENCRYPT_BLOCK_CTR(AES192);
+    AESNIXX_DECRYPT_BLOCK_CTR(AES192);
+
+    namespace aes256
+    {
+        typedef AesNI_AES256_Block Block;
+        typedef AesNI_AES256_RoundKeys RoundKeys;
+        typedef AesNI_AES256_Key Key;
+    }
+
+    template <>
+    struct Types<AESNI_AES256>
+    {
+        typedef aes256::Block Block;
+        typedef aes256::RoundKeys RoundKeys;
+        typedef aes256::Key Key;
+    };
+
+    template <>
+    std::size_t get_number_of_rounds<AESNI_AES256>()
+    {
+        return 15;
+    }
+
+    template <>
+    void from_string<AESNI_AES256>(aes256::Block& dest, const char* src)
+    {
+        aesni_AES256_parse_block(&dest, src, ErrorDetailsThrowsInDestructor());
+    }
+
+    template <>
+    std::string to_string<AESNI_AES256>(const aes256::Block& src)
+    {
+        AesNI_AES256_BlockString str;
+        aesni_AES256_format_block(&str, &src, ErrorDetailsThrowsInDestructor());
+        return { str.str };
+    }
+
+    template <>
+    std::string to_matrix_string<AESNI_AES256>(const aes256::Block& src)
+    {
+        AesNI_AES256_BlockMatrixString str;
+        aesni_AES256_format_block_as_matrix(&str, &src, ErrorDetailsThrowsInDestructor());
+        return { str.str };
+    }
+
+    template <>
+    void from_string<AESNI_AES256>(aes256::Key& dest, const char* src)
+    {
+        aesni_AES256_parse_key(&dest, src, ErrorDetailsThrowsInDestructor());
+    }
+
+    template <>
+    std::string to_string<AESNI_AES256>(const aes256::Key& src)
+    {
+        AesNI_AES256_KeyString str;
+        aesni_AES256_format_key(&str, &src, ErrorDetailsThrowsInDestructor());
+        return { str.str };
+    }
+
+    template <>
+    inline void expand_key<AESNI_AES256>(
+        const aes256::Key& key,
+        aes256::RoundKeys& encryption_keys)
+    {
+        aesni_AES256_expand_key(&key, &encryption_keys);
+    }
+
+    template <>
+    inline void derive_decryption_keys<AESNI_AES256>(
+        const aes256::RoundKeys& encryption_keys,
+        aes256::RoundKeys& decryption_keys)
+    {
+        aesni_AES256_derive_decryption_keys(
+            &encryption_keys, &decryption_keys);
+    }
+
+    AESNIXX_ENCRYPT_BLOCK_ECB(AES256);
+    AESNIXX_DECRYPT_BLOCK_ECB(AES256);
+    AESNIXX_ENCRYPT_BLOCK_CBC(AES256);
+    AESNIXX_DECRYPT_BLOCK_CBC(AES256);
+    AESNIXX_ENCRYPT_BLOCK_CFB(AES256);
+    AESNIXX_DECRYPT_BLOCK_CFB(AES256);
+    AESNIXX_ENCRYPT_BLOCK_OFB(AES256);
+    AESNIXX_DECRYPT_BLOCK_OFB(AES256);
+    AESNIXX_ENCRYPT_BLOCK_CTR(AES256);
+    AESNIXX_DECRYPT_BLOCK_CTR(AES256);
+}
diff --git a/cxx/include/aesxx/algorithm.hpp b/cxx/include/aesxx/algorithm.hpp
new file mode 100644
index 0000000..e2c73ac
--- /dev/null
+++ b/cxx/include/aesxx/algorithm.hpp
@@ -0,0 +1,16 @@
+/**
+ * \file
+ * \author Egor Tensin <Egor.Tensin@gmail.com>
+ * \date 2015
+ * \copyright This file is licensed under the terms of the MIT License.
+ *            See LICENSE.txt for details.
+ */
+
+#pragma once
+
+#include <aes/all.h>
+
+namespace aesni
+{
+    typedef AesNI_Algorithm Algorithm;
+}
diff --git a/cxx/include/aesxx/all.hpp b/cxx/include/aesxx/all.hpp
new file mode 100644
index 0000000..7c80d3b
--- /dev/null
+++ b/cxx/include/aesxx/all.hpp
@@ -0,0 +1,18 @@
+/**
+ * \file
+ * \author Egor Tensin <Egor.Tensin@gmail.com>
+ * \date 2015
+ * \copyright This file is licensed under the terms of the MIT License.
+ *            See LICENSE.txt for details.
+ */
+
+#pragma once
+
+#include "aes.hpp"
+#include "algorithm.hpp"
+#include "api.hpp"
+#include "box.hpp"
+#include "data.hpp"
+#include "debug.hpp"
+#include "error.hpp"
+#include "mode.hpp"
diff --git a/cxx/include/aesxx/api.hpp b/cxx/include/aesxx/api.hpp
new file mode 100644
index 0000000..6995ae2
--- /dev/null
+++ b/cxx/include/aesxx/api.hpp
@@ -0,0 +1,171 @@
+/**
+ * \file
+ * \author Egor Tensin <Egor.Tensin@gmail.com>
+ * \date 2015
+ * \copyright This file is licensed under the terms of the MIT License.
+ *            See LICENSE.txt for details.
+ */
+
+#pragma once
+
+#include "algorithm.hpp"
+#include "mode.hpp"
+
+#include <cstddef>
+
+#include <string>
+#include <type_traits>
+
+namespace aesni
+{
+    template <Algorithm algorithm>
+    struct Types;
+
+    template <Algorithm algorithm>
+    std::size_t get_number_of_rounds();
+
+    template <Algorithm algorithm>
+    void from_string(
+        typename Types<algorithm>::Block&,
+        const char*);
+
+    template <Algorithm algorithm>
+    inline void from_string(
+        typename Types<algorithm>::Block& dest,
+        const std::string& src)
+    {
+        from_string<algorithm>(dest, src.c_str());
+    }
+
+    template <Algorithm algorithm>
+    std::string to_string(const typename Types<algorithm>::Block&);
+
+    template <Algorithm algorithm>
+    std::string to_matrix_string(const typename Types<algorithm>::Block&);
+
+    template <Algorithm algorithm>
+    void from_string(
+        typename Types<algorithm>::Key&,
+        const char*);
+
+    template <Algorithm algorithm>
+    inline void from_string(
+        typename Types<algorithm>::Key& dest,
+        const std::string& src)
+    {
+        from_string<algorithm>(dest, src.c_str());
+    }
+
+    template <Algorithm algorithm>
+    std::string to_string(const typename Types<algorithm>::Key&);
+
+    template <Algorithm algorithm>
+    inline void expand_key(
+        const typename Types<algorithm>::Key& key,
+        typename Types<algorithm>::RoundKeys& encryption_keys);
+
+    template <Algorithm algorithm>
+    inline void derive_decryption_keys(
+        const typename Types<algorithm>::RoundKeys& encryption_keys,
+        typename Types<algorithm>::RoundKeys& decryption_keys);
+
+    template <Algorithm algorithm, Mode mode, typename std::enable_if<ModeRequiresInitializationVector<mode>::value>::type* = 0>
+    inline void encrypt_block(
+        const typename Types<algorithm>::Block& plaintext,
+        const typename Types<algorithm>::RoundKeys& round_keys,
+        typename Types<algorithm>::Block& iv,
+        typename Types<algorithm>::Block& ciphertext);
+
+    template <Algorithm algorithm, Mode mode, typename std::enable_if<!ModeRequiresInitializationVector<mode>::value>::type* = 0>
+    inline void encrypt_block(
+        const typename Types<algorithm>::Block& plaintext,
+        const typename Types<algorithm>::RoundKeys& round_keys,
+        typename Types<algorithm>::Block& ciphertext);
+
+    template <Algorithm algorithm, Mode mode, typename std::enable_if<!ModeRequiresInitializationVector<mode>::value>::type* = 0>
+    inline void encrypt_block(
+        const typename Types<algorithm>::Block& plaintext,
+        const typename Types<algorithm>::RoundKeys& round_keys,
+        typename Types<algorithm>::Block&,
+        typename Types<algorithm>::Block& ciphertext)
+    {
+        encrypt_block<algorithm, mode>(plaintext, round_keys, ciphertext);
+    }
+
+    template <Algorithm algorithm, Mode mode, typename std::enable_if<ModeRequiresInitializationVector<mode>::value>::type* = 0>
+    inline void decrypt_block(
+        const typename Types<algorithm>::Block& ciphertext,
+        const typename Types<algorithm>::RoundKeys& round_keys,
+        typename Types<algorithm>::Block& iv,
+        typename Types<algorithm>::Block& plaintext);
+
+    template <Algorithm algorithm, Mode mode, typename std::enable_if<!ModeRequiresInitializationVector<mode>::value>::type* = 0>
+    inline void decrypt_block(
+        const typename Types<algorithm>::Block& ciphertext,
+        const typename Types<algorithm>::RoundKeys& round_keys,
+        typename Types<algorithm>::Block& plaintext);
+
+    template <Algorithm algorithm, Mode mode, typename std::enable_if<!ModeRequiresInitializationVector<mode>::value>::type* = 0>
+    inline void decrypt_block(
+        const typename Types<algorithm>::Block& ciphertext,
+        const typename Types<algorithm>::RoundKeys& round_keys,
+        typename Types<algorithm>::Block&,
+        typename Types<algorithm>::Block& plaintext)
+    {
+        decrypt_block<algorithm, mode>(ciphertext, round_keys, plaintext);
+    }
+
+    template <Algorithm algorithm, Mode mode>
+    struct EncryptWrapper
+    {
+        EncryptWrapper(
+            const typename Types<algorithm>::Key& key,
+            const typename Types<algorithm>::Block& iv) : iv(iv)
+        {
+            expand_key<algorithm>(key, encryption_keys);
+        }
+
+        inline void encrypt_block(
+            const typename Types<algorithm>::Block& plaintext,
+            typename Types<algorithm>::Block& ciphertext)
+        {
+            aesni::encrypt_block<algorithm, mode>(
+                plaintext, encryption_keys, iv, ciphertext);
+        }
+
+        typename Types<algorithm>::Block iv;
+        typename Types<algorithm>::RoundKeys encryption_keys;
+    };
+
+    template <Algorithm algorithm, Mode mode>
+    struct DecryptWrapper
+    {
+        DecryptWrapper(
+            const typename Types<algorithm>::Key& key,
+            const typename Types<algorithm>::Block& iv) : iv(iv)
+        {
+            typename Types<algorithm>::RoundKeys encryption_keys;
+            expand_key<algorithm>(key, encryption_keys);
+
+            if (ModeUsesEncryptionKeysOnly<mode>::value)
+            {
+                decryption_keys = encryption_keys;
+            }
+            else
+            {
+                derive_decryption_keys<algorithm>(encryption_keys, decryption_keys);
+            }
+        }
+
+        inline void decrypt_block(
+            const typename Types<algorithm>::Block& ciphertext,
+            typename Types<algorithm>::Block& plaintext)
+        {
+            aesni::decrypt_block<algorithm, mode>(
+                ciphertext, decryption_keys, iv, plaintext);
+        }
+
+        typename Types<algorithm>::Block iv;
+        typename Types<algorithm>::RoundKeys decryption_keys;
+    };
+}
diff --git a/cxx/include/aesxx/box.hpp b/cxx/include/aesxx/box.hpp
new file mode 100644
index 0000000..ffca6ce
--- /dev/null
+++ b/cxx/include/aesxx/box.hpp
@@ -0,0 +1,212 @@
+/**
+ * \file
+ * \author Egor Tensin <Egor.Tensin@gmail.com>
+ * \date 2015
+ * \copyright This file is licensed under the terms of the MIT License.
+ *            See LICENSE.txt for details.
+ */
+
+#pragma once
+
+#include "algorithm.hpp"
+#include "error.hpp"
+#include "mode.hpp"
+
+#include <aes/all.h>
+
+#include <cassert>
+#include <cstddef>
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace aesni
+{
+    class Box
+    {
+    public:
+        typedef AesNI_BoxBlock Block;
+        typedef AesNI_BoxKey Key;
+
+        static std::string format_key(const Key& src, Algorithm algorithm)
+        {
+            AesNI_BoxKeyString str;
+            aesni_box_format_key(
+                &str, algorithm, &src, ErrorDetailsThrowsInDestructor());
+            return reinterpret_cast<const char*>(&str);
+        }
+
+        static std::string format_block(const Block& src, Algorithm algorithm)
+        {
+            AesNI_BoxBlockString str;
+            aesni_box_format_block(
+                &str, algorithm, &src, ErrorDetailsThrowsInDestructor());
+            return reinterpret_cast<const char*>(&str);
+        }
+
+        static void parse_block(
+            Block& dest,
+            Algorithm algorithm,
+            const char* src)
+        {
+            aesni_box_parse_block(&dest, algorithm, src,
+                ErrorDetailsThrowsInDestructor());
+        }
+
+        static void parse_block(
+            Block& dest,
+            Algorithm algorithm,
+            const std::string& src)
+        {
+            parse_block(dest, algorithm, src.c_str());
+        }
+
+        static void parse_key(
+            Key& dest,
+            Algorithm algorithm,
+            const char* src)
+        {
+            aesni_box_parse_key(&dest, algorithm, src,
+                ErrorDetailsThrowsInDestructor());
+        }
+
+        static void parse_key(
+            Key& dest,
+            Algorithm algorithm,
+            const std::string& src)
+        {
+            parse_key(dest, algorithm, src.c_str());
+        }
+
+        Box(Algorithm algorithm, const Key& key)
+            : algorithm(algorithm)
+            , mode(AESNI_ECB)
+        {
+            aesni_box_init(&impl, algorithm, &key, mode, nullptr,
+                ErrorDetailsThrowsInDestructor());
+        }
+
+        Box(Algorithm algorithm, const Key& key, Mode mode, const Block& iv)
+            : algorithm(algorithm)
+            , mode(mode)
+        {
+            aesni_box_init(&impl, algorithm, &key, mode, &iv,
+                ErrorDetailsThrowsInDestructor());
+        }
+
+        void encrypt_block(const Block& plaintext, Block& ciphertext)
+        {
+            aesni_box_encrypt_block(
+                &impl, &plaintext, &ciphertext,
+                ErrorDetailsThrowsInDestructor());
+        }
+
+        void decrypt_block(const Block& ciphertext, Block& plaintext)
+        {
+            aesni_box_decrypt_block(
+                &impl, &ciphertext, &plaintext,
+                ErrorDetailsThrowsInDestructor());
+        }
+
+        std::vector<unsigned char> encrypt_buffer(
+            const void* src_buf,
+            std::size_t src_size)
+        {
+            std::size_t dest_size;
+
+            aesni_box_encrypt_buffer(
+                &impl,
+                src_buf,
+                src_size,
+                nullptr,
+                &dest_size,
+                aesni::ErrorDetailsThrowsInDestructor());
+
+            std::vector<unsigned char> dest_buf;
+            dest_buf.resize(dest_size);
+
+            aesni_box_encrypt_buffer(
+                &impl,
+                src_buf,
+                src_size,
+                dest_buf.data(),
+                &dest_size,
+                aesni::ErrorDetailsThrowsInDestructor());
+
+            dest_buf.resize(dest_size);
+            return dest_buf;
+        }
+
+        std::vector<unsigned char> decrypt_buffer(
+            const void* src_buf,
+            std::size_t src_size)
+        {
+            std::size_t dest_size;
+
+            aesni_box_decrypt_buffer(
+                &impl,
+                src_buf,
+                src_size,
+                nullptr,
+                &dest_size,
+                aesni::ErrorDetailsThrowsInDestructor());
+
+            std::vector<unsigned char> dest_buf;
+            dest_buf.resize(dest_size);
+
+            aesni_box_decrypt_buffer(
+                &impl,
+                src_buf,
+                src_size,
+                dest_buf.data(),
+                &dest_size,
+                aesni::ErrorDetailsThrowsInDestructor());
+
+            dest_buf.resize(dest_size);
+            return dest_buf;
+        }
+
+        std::string format_block(const Block& src)
+        {
+            return format_block(src, get_algorithm());
+        }
+
+        std::string format_key(const Key& src)
+        {
+            return format_key(src, get_algorithm());
+        }
+
+        void parse_block(Block& dest, const char* src)
+        {
+            parse_block(dest, get_algorithm(), src);
+        }
+
+        void parse_block(Block& dest, const std::string& src)
+        {
+            parse_block(dest, src.c_str());
+        }
+
+        void parse_key(Key& dest, const char* src)
+        {
+            parse_key(dest, get_algorithm(), src);
+        }
+
+        void parse_key(Key& dest, const std::string& src)
+        {
+            parse_key(dest, src.c_str());
+        }
+
+        Algorithm get_algorithm() const { return algorithm; }
+
+        Mode get_mode() const { return mode; }
+
+    private:
+        Key key;
+
+        Algorithm algorithm;
+        Mode mode;
+
+        AesNI_Box impl;
+    };
+}
diff --git a/cxx/include/aesxx/data.hpp b/cxx/include/aesxx/data.hpp
new file mode 100644
index 0000000..f52fe3e
--- /dev/null
+++ b/cxx/include/aesxx/data.hpp
@@ -0,0 +1,58 @@
+/**
+ * \file
+ * \author Egor Tensin <Egor.Tensin@gmail.com>
+ * \date 2015
+ * \copyright This file is licensed under the terms of the MIT License.
+ *            See LICENSE.txt for details.
+ */
+
+#pragma once
+
+#include "error.hpp"
+
+#include <aes/all.h>
+
+namespace aesni
+{
+    typedef AesNI_Block128 Block128;
+
+    inline void make_block(Block128& dest, int hi3, int hi2, int lo1, int lo0)
+    {
+        dest = aesni_make_block128(hi3, hi2, lo1, lo0);
+    }
+
+    inline void load_block(Block128& dest, const void* src)
+    {
+        dest = aesni_load_block128(src);
+    }
+
+    inline void load_block_aligned(Block128& dest, const void* src)
+    {
+        dest = aesni_load_block128_aligned(src);
+    }
+
+    inline void store_block(void* dest, Block128& src)
+    {
+        aesni_store_block128(dest, src);
+    }
+
+    inline void store_block_aligned(void* dest, Block128& src)
+    {
+        aesni_store_block128_aligned(dest, src);
+    }
+
+    inline Block128 xor_blocks(Block128& a, Block128& b)
+    {
+        return aesni_xor_block128(a, b);
+    }
+
+    inline Block128 reverse_byte_order(Block128& block)
+    {
+        return aesni_reverse_byte_order_block128(block);
+    }
+
+    inline Block128 inc_block(Block128& block)
+    {
+        return aesni_inc_block128(block);
+    }
+}
diff --git a/cxx/include/aesxx/debug.hpp b/cxx/include/aesxx/debug.hpp
new file mode 100644
index 0000000..f3e35f4
--- /dev/null
+++ b/cxx/include/aesxx/debug.hpp
@@ -0,0 +1,177 @@
+/**
+ * \file
+ * \author Egor Tensin <Egor.Tensin@gmail.com>
+ * \date 2015
+ * \copyright This file is licensed under the terms of the MIT License.
+ *            See LICENSE.txt for details.
+ */
+
+#pragma once
+
+#ifdef WIN32
+#include <Windows.h>
+#include <DbgHelp.h>
+#pragma comment(lib, "DbgHelp.Lib")
+#endif
+
+#include <cstddef>
+
+#include <sstream>
+#include <string>
+
+namespace aesni
+{
+    namespace aux
+    {
+        class CallStackFormatter
+        {
+        public:
+            CallStackFormatter() = default;
+
+            std::string format_address(const void* addr) const
+            {
+                #ifdef WIN32
+                return format_address_win32(addr);
+                #else
+                return format_address_fallback(addr);
+                #endif
+            }
+
+        private:
+            template <typename T>
+            static std::string put_between_brackets(const T& x)
+            {
+                std::ostringstream oss;
+                oss << "[" << x << "]";
+                return oss.str();
+            }
+
+            template <typename T>
+            static std::string stringify(const T& x)
+            {
+                std::ostringstream oss;
+                oss << x;
+                return oss.str();
+            }
+
+            static std::string format_address_fallback(const void* addr)
+            {
+                return put_between_brackets(addr);
+            }
+
+            static std::string format_module(
+                const std::string& module_name,
+                const void* offset = nullptr)
+            {
+                if (offset == nullptr)
+                    return put_between_brackets(module_name);
+                else
+                    return put_between_brackets(module_name + "+" + stringify(offset));
+            }
+
+            static std::string format_symbol(
+                const std::string& symbol_name,
+                const void* offset = nullptr)
+            {
+                return format_module(symbol_name, offset);
+            }
+
+            static std::string format_symbol(
+                const std::string& module_name,
+                const std::string& symbol_name,
+                const void* offset = nullptr)
+            {
+                return format_symbol(module_name + "!" + symbol_name, offset);
+            }
+
+            #ifdef WIN32
+            class DbgHelp
+            {
+            public:
+                DbgHelp()
+                {
+                    initialized_flag = SymInitialize(GetCurrentProcess(), NULL, TRUE) != FALSE;
+                }
+
+                bool initialized() const
+                {
+                    return initialized_flag;
+                }
+
+                ~DbgHelp()
+                {
+                    if (initialized_flag)
+                        SymCleanup(GetCurrentProcess());
+                }
+
+            private:
+                bool initialized_flag = false;
+
+                DbgHelp(const DbgHelp&) = delete;
+                DbgHelp& operator=(const DbgHelp&) = delete;
+            };
+
+            DbgHelp dbghelp;
+
+            std::string format_address_win32(const void* addr) const
+            {
+                if (!dbghelp.initialized())
+                    return format_address_fallback(addr);
+
+                DWORD64 symbol_info_buf[sizeof(SYMBOL_INFO) + MAX_SYM_NAME];
+                const auto symbol_info = reinterpret_cast<SYMBOL_INFO*>(symbol_info_buf);
+                symbol_info->SizeOfStruct = sizeof(SYMBOL_INFO);
+                symbol_info->MaxNameLen = MAX_SYM_NAME;
+
+                IMAGEHLP_MODULE64 module_info;
+                module_info.SizeOfStruct = sizeof(IMAGEHLP_MODULE64);
+
+                DWORD64 symbol_offset;
+
+                const auto symbol_resolved = SymFromAddr(
+                    GetCurrentProcess(),
+                    reinterpret_cast<DWORD64>(addr),
+                    &symbol_offset,
+                    symbol_info);
+
+                if (symbol_resolved)
+                {
+                    const auto module_resolved = SymGetModuleInfo64(
+                        GetCurrentProcess(),
+                        symbol_info->ModBase,
+                        &module_info);
+
+                    if (module_resolved)
+                    {
+                        return format_symbol(
+                            module_info.ModuleName,
+                            symbol_info->Name,
+                            reinterpret_cast<const void*>(symbol_offset));
+                    }
+                    else
+                    {
+                        return format_symbol(symbol_info->Name, addr);
+                    }
+                }
+                else
+                {
+                    const auto module_resolved = SymGetModuleInfo64(
+                        GetCurrentProcess(),
+                        reinterpret_cast<DWORD64>(addr),
+                        &module_info);
+
+                    if (module_resolved)
+                    {
+                        const auto module_offset = reinterpret_cast<const char*>(addr) - module_info.BaseOfImage;
+                        return format_module(module_info.ModuleName, module_offset);
+                    }
+                    else
+                    {
+                        return format_address_fallback(addr);
+                    }
+                }
+            }
+            #endif
+        };
+    }
+}
diff --git a/cxx/include/aesxx/error.hpp b/cxx/include/aesxx/error.hpp
new file mode 100644
index 0000000..1f22535
--- /dev/null
+++ b/cxx/include/aesxx/error.hpp
@@ -0,0 +1,98 @@
+/**
+ * \file
+ * \author Egor Tensin <Egor.Tensin@gmail.com>
+ * \date 2015
+ * \copyright This file is licensed under the terms of the MIT License.
+ *            See LICENSE.txt for details.
+ */
+
+#pragma once
+
+#include "debug.hpp"
+
+#include <aes/all.h>
+
+#include <boost/config.hpp>
+
+#include <cstdlib>
+#include <cstring>
+
+#include <algorithm>
+#include <functional>
+#include <ostream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+namespace aesni
+{
+    class Error : public std::runtime_error
+    {
+    public:
+        Error(const AesNI_ErrorDetails& err_details)
+            : std::runtime_error(format_error_message(err_details))
+        {
+            copy_call_stack(err_details);
+        }
+
+        void for_each_in_call_stack(const std::function<void (void*, const std::string&)>& callback) const
+        {
+            aux::CallStackFormatter formatter;
+            std::for_each(call_stack, call_stack + call_stack_size, [&formatter, &callback] (void* addr)
+            {
+                callback(addr, formatter.format_address(addr));
+            });
+        }
+
+    private:
+        static std::string format_error_message(const AesNI_ErrorDetails& err_details)
+        {
+            std::vector<char> buf;
+            buf.resize(aesni_format_error(&err_details, NULL, 0));
+            aesni_format_error(&err_details, buf.data(), buf.size());
+            return { buf.begin(), buf.end() };
+        }
+
+        void copy_call_stack(const AesNI_ErrorDetails& err_details)
+        {
+            call_stack_size = err_details.call_stack_size;
+            std::memcpy(call_stack, err_details.call_stack, call_stack_size * sizeof(void*));
+        }
+
+        void* call_stack[AESNI_MAX_CALL_STACK_LENGTH];
+        std::size_t call_stack_size;
+    };
+
+    std::ostream& operator<<(std::ostream& os, const Error& e)
+    {
+        os << "AesNI error: " << e.what() << '\n';
+        os << "Call stack:\n";
+        e.for_each_in_call_stack([&os] (void* addr, const std::string& name)
+        {
+            os << '\t' << addr << ' ' << name << '\n';
+        });
+        return os;
+    }
+
+    class ErrorDetailsThrowsInDestructor
+    {
+    public:
+        ErrorDetailsThrowsInDestructor()
+        {
+            aesni_success(get());
+        }
+
+        ~ErrorDetailsThrowsInDestructor() BOOST_NOEXCEPT_IF(false)
+        {
+            if (aesni_is_error(aesni_get_error_code(get())))
+                throw Error(impl);
+        }
+
+        AesNI_ErrorDetails* get() { return &impl; }
+
+        operator AesNI_ErrorDetails*() { return get(); }
+
+    private:
+        AesNI_ErrorDetails impl;
+    };
+}
diff --git a/cxx/include/aesxx/mode.hpp b/cxx/include/aesxx/mode.hpp
new file mode 100644
index 0000000..706c4b5
--- /dev/null
+++ b/cxx/include/aesxx/mode.hpp
@@ -0,0 +1,156 @@
+/**
+ * \file
+ * \author Egor Tensin <Egor.Tensin@gmail.com>
+ * \date 2015
+ * \copyright This file is licensed under the terms of the MIT License.
+ *            See LICENSE.txt for details.
+ */
+
+#pragma once
+
+#include <aes/all.h>
+
+#include <type_traits>
+
+namespace aesni
+{
+    typedef AesNI_Mode Mode;
+
+    template <Mode mode>
+    struct ModeRequiresInitializationVector : public std::true_type
+    { };
+
+    template <>
+    struct ModeRequiresInitializationVector<AESNI_ECB> : public std::false_type
+    { };
+
+    template <Mode mode>
+    struct ModeUsesEncryptionKeysOnly : public std::true_type
+    { };
+
+    inline bool mode_requires_initialization_vector(Mode mode)
+    {
+        return mode != AESNI_ECB;
+    }
+
+    template <>
+    struct ModeUsesEncryptionKeysOnly<AESNI_ECB> : public std::false_type
+    { };
+
+    template <>
+    struct ModeUsesEncryptionKeysOnly<AESNI_CBC> : public std::false_type
+    { };
+
+    inline bool mode_uses_encryption_keys_only(Mode mode)
+    {
+        return mode != AESNI_ECB && mode != AESNI_CBC;
+    }
+
+#define AESNIXX_ENCRYPT_BLOCK_ECB(prefix) \
+    template <> \
+    inline void encrypt_block<AESNI_## prefix, AESNI_ECB>( \
+        const typename Types<AESNI_## prefix>::Block& plaintext, \
+        const typename Types<AESNI_## prefix>::RoundKeys& encryption_keys, \
+        typename Types<AESNI_## prefix>::Block& ciphertext) \
+    { \
+        ciphertext = aesni_## prefix ##_encrypt_block_ECB(plaintext, &encryption_keys); \
+    }
+
+#define AESNIXX_DECRYPT_BLOCK_ECB(prefix) \
+    template <> \
+    inline void decrypt_block<AESNI_## prefix, AESNI_ECB>( \
+        const typename Types<AESNI_## prefix>::Block& ciphertext, \
+        const typename Types<AESNI_## prefix>::RoundKeys& decryption_keys, \
+        typename Types<AESNI_## prefix>::Block& plaintext) \
+    { \
+        plaintext = aesni_## prefix ##_decrypt_block_ECB(ciphertext, &decryption_keys); \
+    }
+
+#define AESNIXX_ENCRYPT_BLOCK_CBC(prefix) \
+    template <> \
+    inline void encrypt_block<AESNI_## prefix, AESNI_CBC>( \
+        const typename Types<AESNI_## prefix>::Block& plaintext, \
+        const typename Types<AESNI_## prefix>::RoundKeys& encryption_keys, \
+        typename Types<AESNI_## prefix>::Block& iv, \
+        typename Types<AESNI_## prefix>::Block& ciphertext) \
+    { \
+        ciphertext = aesni_## prefix ##_encrypt_block_CBC(plaintext, &encryption_keys, iv, &iv); \
+    }
+
+#define AESNIXX_DECRYPT_BLOCK_CBC(prefix) \
+    template <> \
+    inline void decrypt_block<AESNI_## prefix, AESNI_CBC>( \
+        const typename Types<AESNI_## prefix>::Block& ciphertext, \
+        const typename Types<AESNI_## prefix>::RoundKeys& decryption_keys, \
+        typename Types<AESNI_## prefix>::Block& iv, \
+        typename Types<AESNI_## prefix>::Block& plaintext) \
+    { \
+        plaintext = aesni_## prefix ##_decrypt_block_CBC(ciphertext, &decryption_keys, iv, &iv); \
+    }
+
+#define AESNIXX_ENCRYPT_BLOCK_CFB(prefix) \
+    template <> \
+    inline void encrypt_block<AESNI_## prefix, AESNI_CFB>( \
+        const typename Types<AESNI_## prefix>::Block& plaintext, \
+        const typename Types<AESNI_## prefix>::RoundKeys& encryption_keys, \
+        typename Types<AESNI_## prefix>::Block& iv, \
+        typename Types<AESNI_## prefix>::Block& ciphertext) \
+    { \
+        ciphertext = aesni_## prefix ##_encrypt_block_CFB(plaintext, &encryption_keys, iv, &iv); \
+    }
+
+#define AESNIXX_DECRYPT_BLOCK_CFB(prefix) \
+    template <> \
+    inline void decrypt_block<AESNI_## prefix, AESNI_CFB>( \
+        const typename Types<AESNI_## prefix>::Block& ciphertext, \
+        const typename Types<AESNI_## prefix>::RoundKeys& encryption_keys, \
+        typename Types<AESNI_## prefix>::Block& iv, \
+        typename Types<AESNI_## prefix>::Block& plaintext) \
+    { \
+        plaintext = aesni_## prefix ##_decrypt_block_CFB(ciphertext, &encryption_keys, iv, &iv); \
+    }
+
+#define AESNIXX_ENCRYPT_BLOCK_OFB(prefix) \
+    template <> \
+    inline void encrypt_block<AESNI_## prefix, AESNI_OFB>( \
+        const typename Types<AESNI_## prefix>::Block& plaintext, \
+        const typename Types<AESNI_## prefix>::RoundKeys& encryption_keys, \
+        typename Types<AESNI_## prefix>::Block& iv, \
+        typename Types<AESNI_## prefix>::Block& ciphertext) \
+    { \
+        ciphertext = aesni_## prefix ##_encrypt_block_OFB(plaintext, &encryption_keys, iv, &iv); \
+    }
+
+#define AESNIXX_DECRYPT_BLOCK_OFB(prefix) \
+    template <> \
+    inline void decrypt_block<AESNI_## prefix, AESNI_OFB>( \
+        const typename Types<AESNI_## prefix>::Block& ciphertext, \
+        const typename Types<AESNI_## prefix>::RoundKeys& encryption_keys, \
+        typename Types<AESNI_## prefix>::Block& iv, \
+        typename Types<AESNI_## prefix>::Block& plaintext) \
+    { \
+        plaintext = aesni_## prefix ##_decrypt_block_OFB(ciphertext, &encryption_keys, iv, &iv); \
+    }
+
+#define AESNIXX_ENCRYPT_BLOCK_CTR(prefix) \
+    template <> \
+    inline void encrypt_block<AESNI_## prefix, AESNI_CTR>( \
+        const typename Types<AESNI_## prefix>::Block& plaintext, \
+        const typename Types<AESNI_## prefix>::RoundKeys& encryption_keys, \
+        typename Types<AESNI_## prefix>::Block& iv, \
+        typename Types<AESNI_## prefix>::Block& ciphertext) \
+    { \
+        ciphertext = aesni_## prefix ##_encrypt_block_CTR(plaintext, &encryption_keys, iv, &iv); \
+    }
+
+#define AESNIXX_DECRYPT_BLOCK_CTR(prefix) \
+    template <> \
+    inline void decrypt_block<AESNI_## prefix, AESNI_CTR>( \
+        const typename Types<AESNI_## prefix>::Block& ciphertext, \
+        const typename Types<AESNI_## prefix>::RoundKeys& encryption_keys, \
+        typename Types<AESNI_## prefix>::Block& iv, \
+        typename Types<AESNI_## prefix>::Block& plaintext) \
+    { \
+        plaintext = aesni_## prefix ##_decrypt_block_CTR(ciphertext, &encryption_keys, iv, &iv); \
+    }
+}