cxx: implement "boxes"

1 files changed, 65 insertions, 109 deletions

diff --git a/utils/encrypt_bmp.cpp b/utils/encrypt_bmp.cpp
index 7e2ad21..978b954 100644
--- a/utils/encrypt_bmp.cpp
+++ b/utils/encrypt_bmp.cpp
@@ -8,8 +8,6 @@
 
 #include "file_cmd_parser.hpp"
 
-#include <aesni/all.h>
-
 #include <aesnixx/all.hpp>
 
 #include <boost/program_options.hpp>
@@ -47,43 +45,35 @@ namespace
 
         std::vector<char> src_buf;
         src_buf.reserve(size);
-        src_buf.assign(std::istreambuf_iterator<char>(ifs),
-                       std::istreambuf_iterator<char>());
+        src_buf.assign(
+            std::istreambuf_iterator<char>(ifs),
+            std::istreambuf_iterator<char>());
         return src_buf;
     }
 
-    void write_file(const std::string& path, const std::vector<char>& src)
+    void write_file(
+        const std::string& path,
+        const std::vector<unsigned char>& src)
     {
         std::ofstream ofs;
         ofs.exceptions(std::ofstream::badbit | std::ofstream::failbit);
         ofs.open(path, std::ofstream::binary);
-        ofs.write(src.data(), src.size());
+        ofs.write(reinterpret_cast<const char*>(src.data()), src.size());
     }
 
-    template <aesni::Algorithm algorithm>
-    bool encrypt_bmp_with_algorithm(
-        const AesNI_BoxKey& box_key,
-        aesni::Mode mode,
+    void encrypt_bmp(
+        aesni::Box& box,
         std::deque<std::string>& args)
     {
-        AesNI_BoxBlock iv;
-        AesNI_BoxBlock* iv_ptr = nullptr;
-
-        if (aesni::mode_requires_initialization_vector(mode))
-        {
-            if (args.empty())
-                return false;
-
-            aesni::from_string<algorithm>(iv.aes_block, args.front());
-            iv_ptr = &iv;
-            args.pop_front();
-        }
-
-        if (args.size() != 2)
-            return false;
+        if (args.empty())
+            throw_src_path_required();
+        const auto src_path = args.front();
+        args.pop_front();
 
-        const auto src_path = args[0];
-        const auto dest_path = args[1];
+        if (args.empty())
+            throw_dest_path_required();
+        const auto dest_path = args.front();
+        args.pop_front();
 
         const auto src_buf = read_file(src_path);
 
@@ -93,78 +83,44 @@ namespace
         const auto pixels = src_buf.data() + header_size;
         const auto pixels_size = src_buf.size() - header_size;
 
-        AesNI_Box box;
-
-        aesni_box_init(
-            &box,
-            algorithm,
-            &box_key,
-            mode,
-            iv_ptr,
-            aesni::ErrorDetailsThrowsInDestructor());
-
-        std::size_t cipherpixels_size;
-
-        aesni_box_encrypt_buffer(
-            &box,
-            pixels,
-            pixels_size,
-            nullptr,
-            &cipherpixels_size,
-            aesni::ErrorDetailsThrowsInDestructor());
-
-        std::vector<char> dest_buf;
-        dest_buf.resize(header_size + cipherpixels_size);
-        std::memcpy(dest_buf.data(), src_buf.data(), header_size);
-
-        aesni_box_encrypt_buffer(
-            &box,
-            pixels,
-            pixels_size,
-            dest_buf.data() + header_size,
-            &cipherpixels_size,
-            aesni::ErrorDetailsThrowsInDestructor());
+        const auto cipherpixels = box.encrypt_buffer(
+            pixels, pixels_size);
 
-        write_file(dest_path, dest_buf);
+        std::vector<unsigned char> dest_buf(header_size + cipherpixels.size());
+        std::memcpy(&dest_buf[0], bmp_header, header_size);
+        std::memcpy(&dest_buf[0] + header_size, cipherpixels.data(), cipherpixels.size());
 
-        return true;
+        write_file(dest_path, dest_buf);
     }
 
-    bool encrypt_bmp(
+    void encrypt_bmp(
         aesni::Algorithm algorithm,
         aesni::Mode mode,
         std::deque<std::string>& args)
     {
         if (args.empty())
-            return false;
+            throw_key_required();
 
-        AesNI_BoxKey box_key;
+        aesni::Box::Key key;
+        aesni::Box::parse_key(key, algorithm, args.front());
+        args.pop_front();
 
-        switch (algorithm)
+        if (aesni::mode_requires_initialization_vector(mode))
         {
-            case AESNI_AES128:
-                aesni::from_string<AESNI_AES128>(
-                    box_key.aes128_key, args.front());
-                args.pop_front();
-                return encrypt_bmp_with_algorithm<AESNI_AES128>(
-                    box_key, mode, args);
-
-            case AESNI_AES192:
-                aesni::from_string<AESNI_AES192>(
-                    box_key.aes192_key, args.front());
-                args.pop_front();
-                return encrypt_bmp_with_algorithm<AESNI_AES192>(
-                    box_key, mode, args);
-
-            case AESNI_AES256:
-                aesni::from_string<AESNI_AES256>(
-                    box_key.aes256_key, args.front());
-                args.pop_front();
-                return encrypt_bmp_with_algorithm<AESNI_AES256>(
-                    box_key, mode, args);
-
-            default:
-                return false;
+            if (args.empty())
+                throw_iv_required();
+
+            aesni::Box::Block iv;
+            aesni::Box::parse_block(iv, algorithm, args.front());
+            args.pop_front();
+
+            encrypt_bmp(
+                aesni::Box(algorithm, key, mode, iv), args);
+        }
+        else
+        {
+            encrypt_bmp(
+                aesni::Box(algorithm, key), args);
         }
     }
 }
@@ -174,38 +130,38 @@ int main(int argc, char** argv)
     try
     {
         CommandLineParser cmd_parser("encrypt_bmp.exe");
-        cmd_parser.parse(argc, argv);
-
-        if (cmd_parser.requested_help())
+        try
         {
-            std::cout << cmd_parser;
-            return 0;
-        }
+            cmd_parser.parse(argc, argv);
 
-        std::deque<std::string> args{ std::make_move_iterator(cmd_parser.args.begin()),
-                                      std::make_move_iterator(cmd_parser.args.end()) };
+            if (cmd_parser.requested_help())
+            {
+                std::cout << cmd_parser;
+                return 0;
+            }
 
-        if (!encrypt_bmp(cmd_parser.algorithm, cmd_parser.mode, args))
+            std::deque<std::string> args(
+                std::make_move_iterator(cmd_parser.args.begin()),
+                std::make_move_iterator(cmd_parser.args.end()));
+
+            encrypt_bmp(cmd_parser.algorithm, cmd_parser.mode, args);
+        }
+        catch (const boost::program_options::error& e)
         {
-            std::cout << cmd_parser;
+            std::cerr << "Usage error: " << e.what() << "\n";
+            std::cerr << cmd_parser;
+            return 1;
+        }
+        catch (const aesni::Error& e)
+        {
+            std::cerr << e;
             return 1;
         }
-
-        return 0;
-    }
-    catch (const boost::program_options::error& e)
-    {
-        std::cerr << "Usage error: " << e.what() << "\n";
-        return 1;
-    }
-    catch (const aesni::Error& e)
-    {
-        std::cerr << e;
-        return 1;
     }
     catch (const std::exception& e)
     {
         std::cerr << e.what() << "\n";
         return 1;
     }
+    return 0;
 }