utils: refactor command line parsing

11 files changed, 437 insertions, 440 deletions

diff --git a/test/cavp.py b/test/cavp.py
index 2508bda..fb719f4 100644
--- a/test/cavp.py
+++ b/test/cavp.py
@@ -80,24 +80,24 @@ class _TestVectorsFile:
             init_vectors = self._parser.get(section, 'iv')
         return keys, plaintexts, ciphertexts, init_vectors
 
-    def _run_tests(self, tool, inputs, expected_output):
+    def _run_tests(self, tool, inputs, expected_output, use_boxes=False):
         for expected_output_chunk, input_chunk in _split_into_chunks(expected_output, list(inputs)):
-            actual_output = tool(self.algorithm(), self.mode(), input_chunk)
+            actual_output = tool(self.algorithm(), self.mode(), input_chunk, use_boxes=use_boxes)
             if not _assert_output(actual_output, expected_output_chunk):
                 return _TestExitCode.FAILURE
         return _TestExitCode.SUCCESS
 
-    def run_encryption_tests(self, tools):
+    def run_encryption_tests(self, tools, use_boxes=False):
         logging.info('Running encryption tests...')
         keys, plaintexts, ciphertexts, init_vectors = self._extract_test_data('ENCRYPT')
         inputs = _gen_encryption_inputs(keys, plaintexts, init_vectors)
-        return self._run_tests(tools.run_encrypt_block, inputs, ciphertexts)
+        return self._run_tests(tools.run_encrypt_block, inputs, ciphertexts, use_boxes)
 
-    def run_decryption_tests(self, tools):
+    def run_decryption_tests(self, tools, use_boxes=False):
         logging.info('Running decryption tests...')
         keys, plaintexts, ciphertexts, init_vectors = self._extract_test_data('DECRYPT')
         inputs = _gen_decryption_inputs(keys, ciphertexts, init_vectors)
-        return self._run_tests(tools.run_decrypt_block, inputs, plaintexts)
+        return self._run_tests(tools.run_decrypt_block, inputs, plaintexts, use_boxes)
 
     def _parse(self):
         logging.info('Trying to parse test vectors file name \'{0}\'...'.format(self._fn))
@@ -145,7 +145,7 @@ class _TestVectorsFile:
             logging.warn('Unknown or unsupported mode: ' + self._fn)
             return None
 
-def _parse_archive_and_run_tests(tools, archive_path):
+def _parse_archive_and_run_tests(tools, archive_path, use_boxes=False):
     archive = zipfile.ZipFile(archive_path)
     exit_codes = []
     for fn in archive.namelist():
@@ -153,13 +153,13 @@ def _parse_archive_and_run_tests(tools, archive_path):
         if member.recognized():
             member.parse()
             try:
-                exit_codes.append(member.run_encryption_tests(tools))
+                exit_codes.append(member.run_encryption_tests(tools, use_boxes))
             except Exception as e:
                 logging.error('Encountered an exception!')
                 logging.exception(e)
                 exit_codes.append(_TestExitCode.ERROR)
             try:
-                exit_codes.append(member.run_decryption_tests(tools))
+                exit_codes.append(member.run_decryption_tests(tools, use_boxes))
             except Exception as e:
                 logging.error('Encountered an exception!')
                 logging.exception(e)
@@ -201,5 +201,5 @@ if __name__ == '__main__':
         logging_options['filename'] = args.log
     logging.basicConfig(**logging_options)
 
-    tools = toolkit.Tools(args.path, use_sde=args.sde, use_boxes=args.box)
-    _parse_archive_and_run_tests(tools, args.archive)
+    tools = toolkit.Tools(args.path, use_sde=args.sde)
+    _parse_archive_and_run_tests(tools, args.archive, use_boxes=args.box)
diff --git a/test/nist-sp-800-38a.py b/test/nist-sp-800-38a.py
index 7189dde..05f0a39 100644
--- a/test/nist-sp-800-38a.py
+++ b/test/nist-sp-800-38a.py
@@ -146,7 +146,7 @@ def _assert_output(actual, expected):
 class _TestExitCode:
     SUCCESS, FAILURE, ERROR, SKIPPED = range(4)
 
-def _run_encryption_tests(tools, algo, mode):
+def _run_encryption_tests(tools, algo, mode, use_boxes=False):
     logging.info('Running encryption tests...')
     key = _keys[algo]
     iv = None
@@ -154,13 +154,13 @@ def _run_encryption_tests(tools, algo, mode):
         iv = _init_vectors[algo][mode]
     ciphertexts = _ciphertexts[algo][mode]
     _input = toolkit.EncryptionInput(key, _plaintexts, iv=iv)
-    actual_output = tools.run_encrypt_block(algo, mode, _input)
+    actual_output = tools.run_encrypt_block(algo, mode, _input, use_boxes)
     if _assert_output(actual_output, ciphertexts):
         return _TestExitCode.SUCCESS
     else:
         return _TestExitCode.FAILURE
 
-def _run_decryption_tests(tools, algo, mode):
+def _run_decryption_tests(tools, algo, mode, use_boxes=False):
     logging.info('Running decryption tests...')
     key = _keys[algo]
     iv = None
@@ -168,7 +168,7 @@ def _run_decryption_tests(tools, algo, mode):
         iv = _init_vectors[algo][mode]
     ciphertexts = _ciphertexts[algo][mode]
     _input = toolkit.DecryptionInput(key, ciphertexts, iv=iv)
-    actual_output = tools.run_decrypt_block(algo, mode, _input)
+    actual_output = tools.run_decrypt_block(algo, mode, _input, use_boxes)
     if _assert_output(actual_output, _plaintexts):
         return _TestExitCode.SUCCESS
     else:
@@ -186,7 +186,7 @@ if __name__ == '__main__':
     parser.add_argument('--log', '-l', help='set log file path')
     args = parser.parse_args()
 
-    tools = toolkit.Tools(args.path, use_sde=args.sde, use_boxes=args.box)
+    tools = toolkit.Tools(args.path, use_sde=args.sde)
 
     logging_options = {
         'format': '%(asctime)s | %(module)s | %(levelname)s | %(message)s',
@@ -216,13 +216,13 @@ if __name__ == '__main__':
             mode = maybe_mode
             logging.info('Mode: ' + mode)
             try:
-                exit_codes.append(_run_encryption_tests(tools, algo, mode))
+                exit_codes.append(_run_encryption_tests(tools, algo, mode, use_boxes=args.box))
             except Exception as e:
                 logging.error('Encountered an exception!')
                 logging.exception(e)
                 exit_codes.append(_TestExitCode.ERROR)
             try:
-                exit_codes.append(_run_decryption_tests(tools, algo, mode))
+                exit_codes.append(_run_decryption_tests(tools, algo, mode, use_boxes=args.box))
             except Exception as e:
                 logging.error('Encountered an exception!')
                 logging.exception(e)
diff --git a/test/toolkit.py b/test/toolkit.py
index 50a42c9..170bccf 100644
--- a/test/toolkit.py
+++ b/test/toolkit.py
@@ -25,10 +25,10 @@ def mode_requires_init_vector(mode):
     return mode != ECB
 
 def to_supported_algorithm(s):
-    algo = is_algorithm_supported(s)
-    if algo is None:
+    algorithm = is_algorithm_supported(s)
+    if algorithm is None:
         raise NotImplementedError('unsupported algorithm ' + s)
-    return algo
+    return algorithm
 
 def is_algorithm_supported(s):
     s = s.lower()
@@ -77,7 +77,7 @@ class DecryptionInput:
         return args
 
 class Tools:
-    def __init__(self, search_dirs, use_sde=False, use_boxes=False):
+    def __init__(self, search_dirs, use_sde=False):
         if search_dirs:
             if isinstance(search_dirs, str):
                 os.environ['PATH'] += os.pathsep + search_dirs
@@ -86,7 +86,6 @@ class Tools:
             else:
                 os.environ['PATH'] += os.pathsep + str(search_dirs)
         self._use_sde = use_sde
-        self._use_boxes = use_boxes
         self._logger = logging.getLogger(__name__)
 
     _ENCRYPT_BLOCK = 'encrypt_block.exe'
@@ -94,11 +93,8 @@ class Tools:
     _ENCRYPT_FILE = 'encrypt_file.exe'
     _DECRYPT_FILE = 'decrypt_file.exe'
 
-    def run(self, tool_path, algo, mode, args):
+    def run(self, tool_path, args):
         cmd_list = ['sde', '--', tool_path] if self._use_sde else [tool_path]
-        if self._use_boxes:
-            cmd_list.append('-b')
-        cmd_list.extend(('-a', algo, '-m', mode))
         cmd_list.extend(args)
         logging.info('Trying to execute: {0}'.format(
             subprocess.list2cmdline(cmd_list)))
@@ -126,32 +122,54 @@ class Tools:
             args.extend(tail.to_args())
         return args
 
-    def run_encrypt_block(self, algo, mode, inputs):
+    def run_encrypt_block(self, algorithm, mode, inputs, use_boxes=False):
+        args = [
+            '--algorithm', algorithm,
+            '--mode', mode,
+        ]
+        if use_boxes:
+            args.append('--box')
         if isinstance(inputs, collections.Iterable):
-            args = self._block_inputs_to_args(iter(inputs))
+            args.extend(self._block_inputs_to_args(iter(inputs)))
         else:
-            args = inputs.to_args()
-        return self.run(self._ENCRYPT_BLOCK, algo, mode, args)
-
-    def run_decrypt_block(self, algo, mode, inputs):
+            args.extend(inputs.to_args())
+        return self.run(self._ENCRYPT_BLOCK, args)
+
+    def run_decrypt_block(self, algorithm, mode, inputs, use_boxes=False):
+        args = [
+            '--algorithm', algorithm,
+            '--mode', mode,
+        ]
+        if use_boxes:
+            args.append('--box')
         if isinstance(inputs, collections.Iterable):
-            args = self._block_inputs_to_args(iter(inputs))
+            args.extend(self._block_inputs_to_args(iter(inputs)))
         else:
-            args = inputs.to_args()
-        return self.run(self._DECRYPT_BLOCK, algo, mode, args)
-
-    def run_encrypt_file(self, algo, mode, key, input_path, output_path, iv=None):
+            args.extend(inputs.to_args())
+        return self.run(self._DECRYPT_BLOCK, args)
+
+    def run_encrypt_file(self, algorithm, mode, key, input_path, output_path, iv=None):
+        args = [
+            '--algorithm', algorithm,
+            '--mode', mode,
+            '--key', key,
+            '--input-path', input_path,
+            '--output-path', output_path]
         if mode_requires_init_vector(mode):
             if not iv:
-                raise ValueError('mode \'{}\' requires init vector'.format(mode))
-            return self.run(self._ENCRYPT_FILE, algo, mode, (key, iv, input_path, output_path))
-        else:
-            return self.run(self._ENCRYPT_FILE, algo, mode, (key, input_path, output_path))
-
-    def run_decrypt_file(self, algo, mode, key, input_path, output_path, iv=None):
+                raise ValueError('mode \'{}\' requires initialization vector'.format(mode))
+            args.extend(('--iv', iv))
+        return self.run(self._ENCRYPT_FILE, args)
+
+    def run_decrypt_file(self, algorithm, mode, key, input_path, output_path, iv=None):
+        args = [
+            '--algorithm', algorithm,
+            '--mode', mode,
+            '--key', key,
+            '--input-path', input_path,
+            '--output-path', output_path]
         if mode_requires_init_vector(mode):
             if not iv:
-                raise ValueError('mode \'{}\' requires init vector'.format(mode))
-            return self.run(self._DECRYPT_FILE, algo, mode, (key, iv, input_path, output_path))
-        else:
-            return self.run(self._DECRYPT_FILE, algo, mode, (key, input_path, output_path))
+                raise ValueError('mode \'{}\' requires initialization vector'.format(mode))
+            args.extend(('--iv', iv))
+        return self.run(self._DECRYPT_FILE, args)
diff --git a/utils/block_cmd_parser.hpp b/utils/block_cmd_parser.hpp
index 3468d58..988ef52 100644
--- a/utils/block_cmd_parser.hpp
+++ b/utils/block_cmd_parser.hpp
@@ -16,8 +16,11 @@
 #include <boost/filesystem.hpp>
 #include <boost/program_options.hpp>
 
+#include <iterator>
+#include <deque>
 #include <ostream>
 #include <string>
+#include <utility>
 #include <vector>
 
 namespace
@@ -40,26 +43,87 @@ namespace
             "the selected mode of operation is not implemented");
     }
 
+    class CommandLineParser;
+
+    class Input
+    {
+    public:
+        Input(
+            std::string&& key_string,
+            std::string&& iv_string,
+            std::vector<std::string>&& input_block_strings)
+            : key_string(std::move(key_string))
+            , iv_string(std::make_pair<bool, std::string>(true, std::move(iv_string)))
+            , input_block_strings(input_block_strings)
+        { }
+
+        Input(
+            std::string&& key_string,
+            std::vector<std::string>&& input_block_strings)
+            : key_string(std::move(key_string))
+            , iv_string(std::make_pair<bool, std::string>(false, std::string()))
+            , input_block_strings(std::move(input_block_strings))
+        { }
+
+        const std::string& get_key_string() const { return key_string; }
+
+        const std::string& get_iv_string() const
+        {
+            if (!iv_string.first)
+                throw_iv_required();
+            return iv_string.second;
+        }
+
+        const std::vector<std::string>& get_input_block_strings() const
+        {
+            return input_block_strings;
+        }
+
+    private:
+        const std::string key_string;
+        const std::pair<bool, std::string> iv_string;
+        const std::vector<std::string> input_block_strings;
+    };
+
+    class Settings
+    {
+    public:
+        aesni::Algorithm get_algorithm() const { return algorithm; }
+        aesni::Mode get_mode() const { return mode; }
+
+        bool use_boxes() const { return use_boxes_flag; }
+        bool verbose() const { return verbose_flag; }
+
+    private:
+        aesni::Algorithm algorithm;
+        aesni::Mode mode;
+
+        bool use_boxes_flag = false;
+        bool verbose_flag = false;
+
+        friend class CommandLineParser;
+    };
+
     class CommandLineParser
     {
     public:
         CommandLineParser(const std::string& argv0)
             : prog_name(boost::filesystem::path(argv0).filename().string())
             , options("Options")
+        { }
+
+        void parse(Settings& settings, int argc, char** argv, std::vector<Input>& inputs)
         {
             namespace po = boost::program_options;
 
             options.add_options()
                 ("help,h", "show this message and exit")
-                ("box,b", po::bool_switch(&use_boxes)->default_value(false), "use the \"boxes\" interface")
-                ("mode,m", po::value<aesni::Mode>(&mode)->required(), "set mode of operation")
-                ("algorithm,a", po::value<aesni::Algorithm>(&algorithm)->required(), "set algorithm")
-                ("verbose,v", po::bool_switch(&verbose)->default_value(false), "enable verbose output");
-        }
+                ("box,b", po::bool_switch(&settings.use_boxes_flag)->default_value(false), "use the \"boxes\" interface")
+                ("mode,m", po::value<aesni::Mode>(&settings.mode)->required(), "set mode of operation")
+                ("algorithm,a", po::value<aesni::Algorithm>(&settings.algorithm)->required(), "set algorithm")
+                ("verbose,v", po::bool_switch(&settings.verbose_flag)->default_value(false), "enable verbose output");
 
-        void parse(int argc, char** argv)
-        {
-            namespace po = boost::program_options;
+            std::vector<std::string> args;
 
             po::options_description hidden_options;
             hidden_options.add_options()
@@ -84,17 +148,66 @@ namespace
             }
 
             po::notify(vm);
+
+            parse_inputs(settings, inputs, std::deque<std::string>(
+                std::make_move_iterator(args.begin()),
+                std::make_move_iterator(args.end())
+            ));
         }
 
-        bool requested_help() const { return help_flag; }
-
-        aesni::Mode mode;
-        aesni::Algorithm algorithm;
-        bool use_boxes;
-        std::vector<std::string> args;
-        bool verbose;
+        bool exit_with_usage() const { return help_flag; }
 
     private:
+        static void parse_inputs(
+            const Settings& settings,
+            std::vector<Input>& inputs,
+            std::deque<std::string>&& args)
+        {
+            while (!args.empty())
+            {
+                auto key_string = std::move(args.front());
+                args.pop_front();
+
+                std::string iv_string;
+
+                if (aesni::mode_requires_initialization_vector(settings.get_mode()))
+                {
+                    if (args.empty())
+                        throw_iv_required();
+                    iv_string = std::move(args.front());
+                    args.pop_front();
+                }
+
+                std::vector<std::string> input_block_strings;
+
+                while (!args.empty())
+                {
+                    if (args.front() == "--")
+                    {
+                        args.pop_front();
+                        break;
+                    }
+
+                    input_block_strings.emplace_back(std::move(args.front()));
+                    args.pop_front();
+                }
+
+                if (aesni::mode_requires_initialization_vector(settings.get_mode()))
+                {
+                    inputs.emplace_back(
+                        std::move(key_string),
+                        std::move(iv_string),
+                        std::move(input_block_strings));
+                }
+                else
+                {
+                    inputs.emplace_back(
+                        std::move(key_string),
+                        std::move(input_block_strings));
+                }
+            }
+        }
+
         const std::string prog_name;
         boost::program_options::options_description options;
 
diff --git a/utils/decrypt_block.cpp b/utils/decrypt_block.cpp
index 30409e0..a8c9625 100644
--- a/utils/decrypt_block.cpp
+++ b/utils/decrypt_block.cpp
@@ -13,7 +13,6 @@
 
 #include <boost/program_options.hpp>
 
-#include <deque>
 #include <exception>
 #include <iostream>
 #include <iterator>
@@ -23,40 +22,31 @@ namespace
 {
     template <aesni::Algorithm algorithm, aesni::Mode mode>
     void decrypt_with_mode(
-        const std::string& key_str,
-        std::deque<std::string>& ciphertexts,
+        const Input& input,
         bool verbose = false)
     {
         typename aesni::Types<algorithm>::Block iv;
 
         if (aesni::ModeRequiresInitializationVector<mode>())
         {
-            if (ciphertexts.empty())
-                throw_iv_required();
-
-            aesni::from_string<algorithm>(iv, ciphertexts.front());
-            ciphertexts.pop_front();
-
+            aesni::from_string<algorithm>(iv, input.get_iv_string());
             if (verbose)
                 dump_iv<algorithm>(iv);
         }
 
         typename aesni::Types<algorithm>::Key key;
-        aesni::from_string<algorithm>(key, key_str);
-
+        aesni::from_string<algorithm>(key, input.get_key_string());
         if (verbose)
             dump_key<algorithm>(key);
 
         aesni::DecryptWrapper<algorithm, mode> decrypt(key, iv);
-
         if (verbose)
             dump_wrapper<algorithm, mode>(decrypt);
 
-        while (!ciphertexts.empty())
+        for (const auto& input_block_string : input.get_input_block_strings())
         {
             typename aesni::Types<algorithm>::Block ciphertext, plaintext;
-            aesni::from_string<algorithm>(ciphertext, ciphertexts.front());
-            ciphertexts.pop_front();
+            aesni::from_string<algorithm>(ciphertext, input_block_string);
 
             decrypt.decrypt_block(ciphertext, plaintext);
 
@@ -68,7 +58,7 @@ namespace
             }
             else
             {
-                std::cout << aesni::to_string<algorithm>(plaintext) << "\n";
+                std::cout << aesni::to_string<algorithm>(plaintext) << '\n';
             }
         }
     }
@@ -76,30 +66,29 @@ namespace
     template <aesni::Algorithm algorithm>
     void decrypt_with_algorithm(
         aesni::Mode mode,
-        const std::string& key_str,
-        std::deque<std::string>& ciphertexts,
+        const Input& input,
         bool verbose = false)
     {
         switch (mode)
         {
             case AESNI_ECB:
-                decrypt_with_mode<algorithm, AESNI_ECB>(key_str, ciphertexts, verbose);
+                decrypt_with_mode<algorithm, AESNI_ECB>(input, verbose);
                 break;
 
             case AESNI_CBC:
-                decrypt_with_mode<algorithm, AESNI_CBC>(key_str, ciphertexts, verbose);
+                decrypt_with_mode<algorithm, AESNI_CBC>(input, verbose);
                 break;
 
             case AESNI_CFB:
-                decrypt_with_mode<algorithm, AESNI_CFB>(key_str, ciphertexts, verbose);
+                decrypt_with_mode<algorithm, AESNI_CFB>(input, verbose);
                 break;
 
             case AESNI_OFB:
-                decrypt_with_mode<algorithm, AESNI_OFB>(key_str, ciphertexts, verbose);
+                decrypt_with_mode<algorithm, AESNI_OFB>(input, verbose);
                 break;
 
             case AESNI_CTR:
-                decrypt_with_mode<algorithm, AESNI_CTR>(key_str, ciphertexts, verbose);
+                decrypt_with_mode<algorithm, AESNI_CTR>(input, verbose);
                 break;
 
             default:
@@ -111,22 +100,21 @@ namespace
     void decrypt_using_cxx_api(
         aesni::Algorithm algorithm,
         aesni::Mode mode,
-        const std::string& key_str,
-        std::deque<std::string>& ciphertexts,
+        const Input& input,
         bool verbose = false)
     {
         switch (algorithm)
         {
             case AESNI_AES128:
-                decrypt_with_algorithm<AESNI_AES128>(mode, key_str, ciphertexts, verbose);
+                decrypt_with_algorithm<AESNI_AES128>(mode, input, verbose);
                 break;
 
             case AESNI_AES192:
-                decrypt_with_algorithm<AESNI_AES192>(mode, key_str, ciphertexts, verbose);
+                decrypt_with_algorithm<AESNI_AES192>(mode, input, verbose);
                 break;
 
             case AESNI_AES256:
-                decrypt_with_algorithm<AESNI_AES256>(mode, key_str, ciphertexts, verbose);
+                decrypt_with_algorithm<AESNI_AES256>(mode, input, verbose);
                 break;
 
             default:
@@ -137,46 +125,41 @@ namespace
 
     void decrypt_using_particular_box(
         aesni::Box& box,
-        std::deque<std::string>& ciphertexts)
+        const std::vector<std::string>& input_block_strings)
     {
-        while (!ciphertexts.empty())
+        for (const auto& input_block_string : input_block_strings)
         {
             aesni::Box::Block ciphertext;
-            box.parse_block(ciphertext, ciphertexts.front());
-            ciphertexts.pop_front();
+            box.parse_block(ciphertext, input_block_string);
 
             aesni::Box::Block plaintext;
             box.decrypt_block(ciphertext, plaintext);
-
-            std::cout << box.format_block(plaintext) << "\n";
+            std::cout << box.format_block(plaintext) << '\n';
         }
     }
 
     void decrypt_using_boxes(
         aesni::Algorithm algorithm,
         aesni::Mode mode,
-        const std::string& key_str,
-        std::deque<std::string>& ciphertexts)
+        const Input& input)
     {
         aesni::Box::Key key;
-        aesni::Box::parse_key(key, algorithm, key_str);
+        aesni::Box::parse_key(key, algorithm, input.get_key_string());
 
         if (aesni::mode_requires_initialization_vector(mode))
         {
-            if (ciphertexts.empty())
-                throw_iv_required();
-
             aesni::Box::Block iv;
-            aesni::Box::parse_block(iv, algorithm, ciphertexts.front());
-            ciphertexts.pop_front();
+            aesni::Box::parse_block(iv, algorithm, input.get_iv_string());
 
             decrypt_using_particular_box(
-                aesni::Box(algorithm, key, mode, iv), ciphertexts);
+                aesni::Box(algorithm, key, mode, iv),
+                input.get_input_block_strings());
         }
         else
         {
             decrypt_using_particular_box(
-                aesni::Box(algorithm, key), ciphertexts);
+                aesni::Box(algorithm, key),
+                input.get_input_block_strings());
         }
     }
 }
@@ -188,53 +171,32 @@ int main(int argc, char** argv)
         CommandLineParser cmd_parser(argv[0]);
         try
         {
-            cmd_parser.parse(argc, argv);
+            Settings settings;
+            std::vector<Input> inputs;
+            cmd_parser.parse(settings, argc, argv, inputs);
 
-            if (cmd_parser.requested_help())
+            if (cmd_parser.exit_with_usage())
             {
                 std::cout << cmd_parser;
                 return 0;
             }
 
-            std::deque<std::string> args(
-                std::make_move_iterator(cmd_parser.args.begin()),
-                std::make_move_iterator(cmd_parser.args.end()));
-
-            while (!args.empty())
+            for (const auto& input : inputs)
             {
-                const auto key = args.front();
-                args.pop_front();
-
-                std::deque<std::string> ciphertexts;
-
-                while (!args.empty())
-                {
-                    if (args.front() == "--")
-                    {
-                        args.pop_front();
-                        break;
-                    }
-
-                    ciphertexts.push_back(args.front());
-                    args.pop_front();
-                }
-
-                if (cmd_parser.use_boxes)
+                if (settings.use_boxes())
                 {
                     decrypt_using_boxes(
-                        cmd_parser.algorithm,
-                        cmd_parser.mode,
-                        key,
-                        ciphertexts);
+                        settings.get_algorithm(),
+                        settings.get_mode(),
+                        input);
                 }
                 else
                 {
                     decrypt_using_cxx_api(
-                        cmd_parser.algorithm,
-                        cmd_parser.mode,
-                        key,
-                        ciphertexts,
-                        cmd_parser.verbose);
+                        settings.get_algorithm(),
+                        settings.get_mode(),
+                        input,
+                        settings.verbose());
                 }
             }
 
diff --git a/utils/decrypt_bmp.cpp b/utils/decrypt_bmp.cpp
index a326828..e63155d 100644
--- a/utils/decrypt_bmp.cpp
+++ b/utils/decrypt_bmp.cpp
@@ -15,7 +15,6 @@
 #include <cstdlib>
 #include <cstring>
 
-#include <deque>
 #include <exception>
 #include <fstream>
 #include <iostream>
@@ -43,12 +42,12 @@ namespace
         ifs.exceptions(std::ifstream::badbit | std::ifstream::failbit);
         ifs.open(path, std::ifstream::binary);
 
-        std::vector<char> src_buf;
-        src_buf.reserve(size);
-        src_buf.assign(
+        std::vector<char> ciphertext_buf;
+        ciphertext_buf.reserve(size);
+        ciphertext_buf.assign(
             std::istreambuf_iterator<char>(ifs),
             std::istreambuf_iterator<char>());
-        return src_buf;
+        return ciphertext_buf;
     }
 
     void write_file(
@@ -63,64 +62,54 @@ namespace
 
     void decrypt_bmp(
         aesni::Box& box,
-        std::deque<std::string>& args)
+        const std::string& ciphertext_path,
+        const std::string& plaintext_path)
     {
-        if (args.empty())
-            throw_src_path_required();
-        const auto src_path = args.front();
-        args.pop_front();
+        const auto ciphertext_buf = read_file(ciphertext_path);
 
-        if (args.empty())
-            throw_dest_path_required();
-        const auto dest_path = args.front();
-        args.pop_front();
-
-        const auto src_buf = read_file(src_path);
-
-        const auto bmp_header = reinterpret_cast<const BITMAPFILEHEADER*>(src_buf.data());
+        const auto bmp_header = reinterpret_cast<const BITMAPFILEHEADER*>(ciphertext_buf.data());
 
         const auto header_size = bmp_header->bfOffBits;
-        const auto cipherpixels = src_buf.data() + header_size;
-        const auto cipherpixels_size = src_buf.size() - header_size;
+        const auto cipherpixels = ciphertext_buf.data() + header_size;
+        const auto cipherpixels_size = ciphertext_buf.size() - header_size;
 
         const auto pixels = box.decrypt_buffer(
             cipherpixels, cipherpixels_size);
 
-        std::vector<unsigned char> dest_buf(header_size + pixels.size());
-        std::memcpy(&dest_buf[0], bmp_header, header_size);
-        std::memcpy(&dest_buf[0] + header_size, pixels.data(), pixels.size());
+        std::vector<unsigned char> plaintext_buf(header_size + pixels.size());
+        std::memcpy(plaintext_buf.data(), bmp_header, header_size);
+        std::memcpy(plaintext_buf.data() + header_size, pixels.data(), pixels.size());
 
-        write_file(dest_path, dest_buf);
+        write_file(plaintext_path, plaintext_buf);
     }
 
-    void decrypt_bmp(
-        aesni::Algorithm algorithm,
-        aesni::Mode mode,
-        std::deque<std::string>& args)
+    void decrypt_bmp(const Settings& settings)
     {
-        if (args.empty())
-            throw_key_required();
+        const auto algorithm = settings.get_algorithm();
+        const auto mode = settings.get_mode();
+
+        const auto ciphertext_path = settings.get_input_path();
+        const auto plaintext_path = settings.get_output_path();
 
         aesni::Box::Key key;
-        aesni::Box::parse_key(key, algorithm, args.front());
-        args.pop_front();
+        aesni::Box::parse_key(key, algorithm, settings.get_key_string());
 
         if (aesni::mode_requires_initialization_vector(mode))
         {
-            if (args.empty())
-                throw_iv_required();
-
             aesni::Box::Block iv;
-            aesni::Box::parse_block(iv, algorithm, args.front());
-            args.pop_front();
+            aesni::Box::parse_block(iv, algorithm, settings.get_iv_string());
 
             decrypt_bmp(
-                aesni::Box(algorithm, key, mode, iv), args);
+                aesni::Box(algorithm, key, mode, iv),
+                ciphertext_path,
+                plaintext_path);
         }
         else
         {
             decrypt_bmp(
-                aesni::Box(algorithm, key), args);
+                aesni::Box(algorithm, key),
+                ciphertext_path,
+                plaintext_path);
         }
     }
 }
@@ -132,19 +121,16 @@ int main(int argc, char** argv)
         CommandLineParser cmd_parser(argv[0]);
         try
         {
-            cmd_parser.parse(argc, argv);
+            Settings settings;
+            cmd_parser.parse(settings, argc, argv);
 
-            if (cmd_parser.requested_help())
+            if (cmd_parser.exit_with_usage())
             {
                 std::cout << cmd_parser;
                 return 0;
             }
 
-            std::deque<std::string> args(
-                std::make_move_iterator(cmd_parser.args.begin()),
-                std::make_move_iterator(cmd_parser.args.end()));
-
-            decrypt_bmp(cmd_parser.algorithm, cmd_parser.mode, args);
+            decrypt_bmp(settings);
         }
         catch (const boost::program_options::error& e)
         {
diff --git a/utils/decrypt_file.cpp b/utils/decrypt_file.cpp
index 96aec62..2264926 100644
--- a/utils/decrypt_file.cpp
+++ b/utils/decrypt_file.cpp
@@ -14,7 +14,6 @@
 
 #include <cstdlib>
 
-#include <deque>
 #include <exception>
 #include <fstream>
 #include <iostream>
@@ -60,52 +59,42 @@ namespace
 
     void decrypt_file(
         aesni::Box& box,
-        std::deque<std::string>& args)
+        const std::string& ciphertext_path,
+        const std::string& plaintext_path)
     {
-        if (args.empty())
-            throw_src_path_required();
-        const auto src_path = args.front();
-        args.pop_front();
-
-        if (args.empty())
-            throw_dest_path_required();
-        const auto dest_path = args.front();
-        args.pop_front();
-
-        const auto src_buf = read_file(src_path);
-        const auto dest_buf = box.decrypt_buffer(
-            src_buf.data(), src_buf.size());
-        write_file(dest_path, dest_buf);
+        const auto ciphertext_buf = read_file(ciphertext_path);
+        const auto plaintext_buf = box.decrypt_buffer(
+            ciphertext_buf.data(), ciphertext_buf.size());
+        write_file(plaintext_path, plaintext_buf);
     }
 
-    void decrypt_file(
-        aesni::Algorithm algorithm,
-        aesni::Mode mode,
-        std::deque<std::string>& args)
+    void decrypt_file(const Settings& settings)
     {
-        if (args.empty())
-            throw_key_required();
+        const auto algorithm = settings.get_algorithm();
+        const auto mode = settings.get_mode();
+
+        const auto ciphertext_path = settings.get_input_path();
+        const auto plaintext_path = settings.get_output_path();
 
         aesni::Box::Key key;
-        aesni::Box::parse_key(key, algorithm, args.front());
-        args.pop_front();
+        aesni::Box::parse_key(key, algorithm, settings.get_key_string());
 
         if (aesni::mode_requires_initialization_vector(mode))
         {
-            if (args.empty())
-                throw_iv_required();
-
             aesni::Box::Block iv;
-            aesni::Box::parse_block(iv, algorithm, args.front());
-            args.pop_front();
+            aesni::Box::parse_block(iv, algorithm, settings.get_iv_string());
 
             decrypt_file(
-                aesni::Box(algorithm, key, mode, iv), args);
+                aesni::Box(algorithm, key, mode, iv),
+                ciphertext_path,
+                plaintext_path);
         }
         else
         {
             decrypt_file(
-                aesni::Box(algorithm, key), args);
+                aesni::Box(algorithm, key),
+                ciphertext_path,
+                plaintext_path);
         }
     }
 }
@@ -117,19 +106,16 @@ int main(int argc, char** argv)
         CommandLineParser cmd_parser(argv[0]);
         try
         {
-            cmd_parser.parse(argc, argv);
+            Settings settings;
+            cmd_parser.parse(settings, argc, argv);
 
-            if (cmd_parser.requested_help())
+            if (cmd_parser.exit_with_usage())
             {
                 std::cout << cmd_parser;
                 return 0;
             }
 
-            std::deque<std::string> args(
-                std::make_move_iterator(cmd_parser.args.begin()),
-                std::make_move_iterator(cmd_parser.args.end()));
-
-            decrypt_file(cmd_parser.algorithm, cmd_parser.mode, args);
+            decrypt_file(settings);
         }
         catch (const boost::program_options::error& e)
         {
diff --git a/utils/encrypt_block.cpp b/utils/encrypt_block.cpp
index 022c237..724e8c1 100644
--- a/utils/encrypt_block.cpp
+++ b/utils/encrypt_block.cpp
@@ -13,7 +13,6 @@
 
 #include <boost/program_options.hpp>
 
-#include <deque>
 #include <exception>
 #include <iostream>
 #include <iterator>
@@ -23,40 +22,32 @@ namespace
 {
     template <aesni::Algorithm algorithm, aesni::Mode mode>
     void encrypt_with_mode(
-        const std::string& key_str,
-        std::deque<std::string>& plaintexts,
+        const Input& input,
         bool verbose = false)
     {
         typename aesni::Types<algorithm>::Block iv;
 
         if (aesni::ModeRequiresInitializationVector<mode>::value)
         {
-            if (plaintexts.empty())
-                throw_iv_required();
-
-            aesni::from_string<algorithm>(iv, plaintexts.front());
-            plaintexts.pop_front();
-
+            aesni::from_string<algorithm>(iv, input.get_iv_string());
             if (verbose)
                 dump_iv<algorithm>(iv);
         }
 
         typename aesni::Types<algorithm>::Key key;
-        aesni::from_string<algorithm>(key, key_str);
-
+        aesni::from_string<algorithm>(key, input.get_key_string());
         if (verbose)
             dump_key<algorithm>(key);
 
         aesni::EncryptWrapper<algorithm, mode> encrypt(key, iv);
-
         if (verbose)
             dump_wrapper<algorithm, mode>(encrypt);
 
-        while (!plaintexts.empty())
+        for (const auto& input_block_string : input.get_input_block_strings())
         {
             typename aesni::Types<algorithm>::Block plaintext, ciphertext;
-            aesni::from_string<algorithm>(plaintext, plaintexts.front());
-            plaintexts.pop_front();
+            aesni::from_string<algorithm>(plaintext, input_block_string);
+
             encrypt.encrypt_block(plaintext, ciphertext);
 
             if (verbose)
@@ -67,7 +58,7 @@ namespace
             }
             else
             {
-                std::cout << aesni::to_string<algorithm>(ciphertext) << "\n";
+                std::cout << aesni::to_string<algorithm>(ciphertext) << '\n';
             }
         }
     }
@@ -75,30 +66,29 @@ namespace
     template <aesni::Algorithm algorithm>
     void encrypt_with_algorithm(
         aesni::Mode mode,
-        const std::string& key_str,
-        std::deque<std::string>& plaintexts,
+        const Input& input,
         bool verbose = false)
     {
         switch (mode)
         {
             case AESNI_ECB:
-                encrypt_with_mode<algorithm, AESNI_ECB>(key_str, plaintexts, verbose);
+                encrypt_with_mode<algorithm, AESNI_ECB>(input, verbose);
                 break;
 
             case AESNI_CBC:
-                encrypt_with_mode<algorithm, AESNI_CBC>(key_str, plaintexts, verbose);
+                encrypt_with_mode<algorithm, AESNI_CBC>(input, verbose);
                 break;
 
             case AESNI_CFB:
-                encrypt_with_mode<algorithm, AESNI_CFB>(key_str, plaintexts, verbose);
+                encrypt_with_mode<algorithm, AESNI_CFB>(input, verbose);
                 break;
 
             case AESNI_OFB:
-                encrypt_with_mode<algorithm, AESNI_OFB>(key_str, plaintexts, verbose);
+                encrypt_with_mode<algorithm, AESNI_OFB>(input, verbose);
                 break;
 
             case AESNI_CTR:
-                encrypt_with_mode<algorithm, AESNI_CTR>(key_str, plaintexts, verbose);
+                encrypt_with_mode<algorithm, AESNI_CTR>(input, verbose);
                 break;
 
             default:
@@ -110,22 +100,21 @@ namespace
     void encrypt_using_cxx_api(
         aesni::Algorithm algorithm,
         aesni::Mode mode,
-        const std::string& key_str,
-        std::deque<std::string>& plaintexts,
+        const Input& input,
         bool verbose = false)
     {
         switch (algorithm)
         {
             case AESNI_AES128:
-                encrypt_with_algorithm<AESNI_AES128>(mode, key_str, plaintexts, verbose);
+                encrypt_with_algorithm<AESNI_AES128>(mode, input, verbose);
                 break;
 
             case AESNI_AES192:
-                encrypt_with_algorithm<AESNI_AES192>(mode, key_str, plaintexts, verbose);
+                encrypt_with_algorithm<AESNI_AES192>(mode, input, verbose);
                 break;
 
             case AESNI_AES256:
-                encrypt_with_algorithm<AESNI_AES256>(mode, key_str, plaintexts, verbose);
+                encrypt_with_algorithm<AESNI_AES256>(mode, input, verbose);
                 break;
 
             default:
@@ -136,47 +125,39 @@ namespace
 
     void encrypt_using_particular_box(
         aesni::Box& box,
-        std::deque<std::string>& plaintexts)
+        const std::vector<std::string>& input_block_strings)
     {
-        while (!plaintexts.empty())
+        for (const auto& input_block_string : input_block_strings)
         {
             aesni::Box::Block plaintext;
-            box.parse_block(
-                plaintext, plaintexts.front());
-            plaintexts.pop_front();
+            box.parse_block(plaintext, input_block_string);
 
             aesni::Box::Block ciphertext;
             box.encrypt_block(plaintext, ciphertext);
-
-            std::cout << box.format_block(ciphertext) << "\n";
+            std::cout << box.format_block(ciphertext) << '\n';
         }
     }
 
     void encrypt_using_boxes(
         aesni::Algorithm algorithm,
         aesni::Mode mode,
-        const std::string& key_str,
-        std::deque<std::string>& plaintexts)
+        const Input& input)
     {
         aesni::Box::Key key;
-        aesni::Box::parse_key(key, algorithm, key_str);
+        aesni::Box::parse_key(key, algorithm, input.get_key_string());
 
         if (aesni::mode_requires_initialization_vector(mode))
         {
-            if (plaintexts.empty())
-                throw_iv_required();
-
             aesni::Box::Block iv;
-            aesni::Box::parse_block(iv, algorithm, plaintexts.front());
-            plaintexts.pop_front();
+            aesni::Box::parse_block(iv, algorithm, input.get_iv_string());
 
             encrypt_using_particular_box(
-                aesni::Box(algorithm, key, mode, iv), plaintexts);
+                aesni::Box(algorithm, key, mode, iv), input.get_input_block_strings());
         }
         else
         {
             encrypt_using_particular_box(
-                aesni::Box(algorithm, key), plaintexts);
+                aesni::Box(algorithm, key), input.get_input_block_strings());
         }
     }
 }
@@ -188,53 +169,32 @@ int main(int argc, char** argv)
         CommandLineParser cmd_parser(argv[0]);
         try
         {
-            cmd_parser.parse(argc, argv);
+            std::vector<Input> inputs;
+            Settings settings;
+            cmd_parser.parse(settings, argc, argv, inputs);
 
-            if (cmd_parser.requested_help())
+            if (cmd_parser.exit_with_usage())
             {
                 std::cout << cmd_parser;
                 return 0;
             }
 
-            std::deque<std::string> args(
-                std::make_move_iterator(cmd_parser.args.begin()),
-                std::make_move_iterator(cmd_parser.args.end()));
-
-            while (!args.empty())
+            for (const auto& input : inputs)
             {
-                const auto key = args.front();
-                args.pop_front();
-
-                std::deque<std::string> plaintexts;
-
-                while (!args.empty())
-                {
-                    if (args.front() == "--")
-                    {
-                        args.pop_front();
-                        break;
-                    }
-
-                    plaintexts.push_back(args.front());
-                    args.pop_front();
-                }
-
-                if (cmd_parser.use_boxes)
+                if (settings.use_boxes())
                 {
                     encrypt_using_boxes(
-                        cmd_parser.algorithm,
-                        cmd_parser.mode,
-                        key,
-                        plaintexts);
+                        settings.get_algorithm(),
+                        settings.get_mode(),
+                        input);
                 }
                 else
                 {
                     encrypt_using_cxx_api(
-                        cmd_parser.algorithm,
-                        cmd_parser.mode,
-                        key,
-                        plaintexts,
-                        cmd_parser.verbose);
+                        settings.get_algorithm(),
+                        settings.get_mode(),
+                        input,
+                        settings.verbose());
                 }
             }
 
diff --git a/utils/encrypt_bmp.cpp b/utils/encrypt_bmp.cpp
index 2f019d8..3ac5906 100644
--- a/utils/encrypt_bmp.cpp
+++ b/utils/encrypt_bmp.cpp
@@ -15,7 +15,6 @@
 #include <cstdlib>
 #include <cstring>
 
-#include <deque>
 #include <exception>
 #include <fstream>
 #include <iostream>
@@ -43,12 +42,12 @@ namespace
         ifs.exceptions(std::ifstream::badbit | std::ifstream::failbit);
         ifs.open(path, std::ifstream::binary);
 
-        std::vector<char> src_buf;
-        src_buf.reserve(size);
-        src_buf.assign(
+        std::vector<char> plaintext_buf;
+        plaintext_buf.reserve(size);
+        plaintext_buf.assign(
             std::istreambuf_iterator<char>(ifs),
             std::istreambuf_iterator<char>());
-        return src_buf;
+        return plaintext_buf;
     }
 
     void write_file(
@@ -63,64 +62,54 @@ namespace
 
     void encrypt_bmp(
         aesni::Box& box,
-        std::deque<std::string>& args)
+        const std::string& plaintext_path,
+        const std::string& ciphertext_path)
     {
-        if (args.empty())
-            throw_src_path_required();
-        const auto src_path = args.front();
-        args.pop_front();
+        const auto plaintext_buf = read_file(plaintext_path);
 
-        if (args.empty())
-            throw_dest_path_required();
-        const auto dest_path = args.front();
-        args.pop_front();
-
-        const auto src_buf = read_file(src_path);
-
-        const auto bmp_header = reinterpret_cast<const BITMAPFILEHEADER*>(src_buf.data());
+        const auto bmp_header = reinterpret_cast<const BITMAPFILEHEADER*>(plaintext_buf.data());
 
         const auto header_size = bmp_header->bfOffBits;
-        const auto pixels = src_buf.data() + header_size;
-        const auto pixels_size = src_buf.size() - header_size;
+        const auto pixels = plaintext_buf.data() + header_size;
+        const auto pixels_size = plaintext_buf.size() - header_size;
 
         const auto cipherpixels = box.encrypt_buffer(
             pixels, pixels_size);
 
-        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());
+        std::vector<unsigned char> ciphertext_buf(header_size + cipherpixels.size());
+        std::memcpy(ciphertext_buf.data(), bmp_header, header_size);
+        std::memcpy(ciphertext_buf.data() + header_size, cipherpixels.data(), cipherpixels.size());
 
-        write_file(dest_path, dest_buf);
+        write_file(ciphertext_path, ciphertext_buf);
     }
 
-    void encrypt_bmp(
-        aesni::Algorithm algorithm,
-        aesni::Mode mode,
-        std::deque<std::string>& args)
+    void encrypt_bmp(const Settings& settings)
     {
-        if (args.empty())
-            throw_key_required();
+        const auto algorithm = settings.get_algorithm();
+        const auto mode = settings.get_mode();
+
+        const auto plaintext_path = settings.get_input_path();
+        const auto ciphertext_path = settings.get_output_path();
 
         aesni::Box::Key key;
-        aesni::Box::parse_key(key, algorithm, args.front());
-        args.pop_front();
+        aesni::Box::parse_key(key, algorithm, settings.get_key_string());
 
         if (aesni::mode_requires_initialization_vector(mode))
         {
-            if (args.empty())
-                throw_iv_required();
-
             aesni::Box::Block iv;
-            aesni::Box::parse_block(iv, algorithm, args.front());
-            args.pop_front();
+            aesni::Box::parse_block(iv, algorithm, settings.get_iv_string());
 
             encrypt_bmp(
-                aesni::Box(algorithm, key, mode, iv), args);
+                aesni::Box(algorithm, key, mode, iv),
+                plaintext_path,
+                ciphertext_path);
         }
         else
         {
             encrypt_bmp(
-                aesni::Box(algorithm, key), args);
+                aesni::Box(algorithm, key),
+                plaintext_path,
+                ciphertext_path);
         }
     }
 }
@@ -132,19 +121,16 @@ int main(int argc, char** argv)
         CommandLineParser cmd_parser(argv[0]);
         try
         {
-            cmd_parser.parse(argc, argv);
+            Settings settings;
+            cmd_parser.parse(settings, argc, argv);
 
-            if (cmd_parser.requested_help())
+            if (cmd_parser.exit_with_usage())
             {
                 std::cout << cmd_parser;
                 return 0;
             }
 
-            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);
+            encrypt_bmp(settings);
         }
         catch (const boost::program_options::error& e)
         {
diff --git a/utils/encrypt_file.cpp b/utils/encrypt_file.cpp
index d1dd5e8..4651928 100644
--- a/utils/encrypt_file.cpp
+++ b/utils/encrypt_file.cpp
@@ -14,7 +14,6 @@
 
 #include <cstdlib>
 
-#include <deque>
 #include <exception>
 #include <fstream>
 #include <iostream>
@@ -40,12 +39,12 @@ namespace
         ifs.exceptions(std::ifstream::badbit | std::ifstream::failbit);
         ifs.open(path, std::ifstream::binary);
 
-        std::vector<char> src_buf;
-        src_buf.reserve(size);
-        src_buf.assign(
+        std::vector<char> plaintext_buf;
+        plaintext_buf.reserve(size);
+        plaintext_buf.assign(
             std::istreambuf_iterator<char>(ifs),
             std::istreambuf_iterator<char>());
-        return src_buf;
+        return plaintext_buf;
     }
 
     void write_file(
@@ -60,52 +59,42 @@ namespace
 
     void encrypt_file(
         aesni::Box& box,
-        std::deque<std::string>& args)
+        const std::string& plaintext_path,
+        const std::string& ciphertext_path)
     {
-        if (args.empty())
-            throw_src_path_required();
-        const auto src_path = args.front();
-        args.pop_front();
-
-        if (args.empty())
-            throw_dest_path_required();
-        const auto dest_path = args.front();
-        args.pop_front();
-
-        const auto src_buf = read_file(src_path);
-        const auto dest_buf = box.encrypt_buffer(
-            src_buf.data(), src_buf.size());
-        write_file(dest_path, dest_buf);
+        const auto plaintext_buf = read_file(plaintext_path);
+        const auto ciphertext_buf = box.encrypt_buffer(
+            plaintext_buf.data(), plaintext_buf.size());
+        write_file(ciphertext_path, ciphertext_buf);
     }
 
-    void encrypt_file(
-        aesni::Algorithm algorithm,
-        aesni::Mode mode,
-        std::deque<std::string>& args)
+    void encrypt_file(const Settings& settings)
     {
-        if (args.empty())
-            throw_key_required();
+        const auto algorithm = settings.get_algorithm();
+        const auto mode = settings.get_mode();
+
+        const auto plaintext_path = settings.get_input_path();
+        const auto ciphertext_path = settings.get_output_path();
 
         aesni::Box::Key key;
-        aesni::Box::parse_key(key, algorithm, args.front());
-        args.pop_front();
+        aesni::Box::parse_key(key, algorithm, settings.get_key_string());
 
         if (aesni::mode_requires_initialization_vector(mode))
         {
-            if (args.empty())
-                throw_iv_required();
-
             aesni::Box::Block iv;
-            aesni::Box::parse_block(iv, algorithm, args.front());
-            args.pop_front();
+            aesni::Box::parse_block(iv, algorithm, settings.get_iv_string());
 
             encrypt_file(
-                aesni::Box(algorithm, key, mode, iv), args);
+                aesni::Box(algorithm, key, mode, iv),
+                plaintext_path,
+                ciphertext_path);
         }
         else
         {
             encrypt_file(
-                aesni::Box(algorithm, key), args);
+                aesni::Box(algorithm, key),
+                plaintext_path,
+                ciphertext_path);
         }
     }
 }
@@ -117,19 +106,16 @@ int main(int argc, char** argv)
         CommandLineParser cmd_parser(argv[0]);
         try
         {
-            cmd_parser.parse(argc, argv);
+            Settings settings;
+            cmd_parser.parse(settings, argc, argv);
 
-            if (cmd_parser.requested_help())
+            if (cmd_parser.exit_with_usage())
             {
                 std::cout << cmd_parser;
                 return 0;
             }
 
-            std::deque<std::string> args(
-                std::make_move_iterator(cmd_parser.args.begin()),
-                std::make_move_iterator(cmd_parser.args.end()));
-
-            encrypt_file(cmd_parser.algorithm, cmd_parser.mode, args);
+            encrypt_file(settings);
         }
         catch (const boost::program_options::error& e)
         {
diff --git a/utils/file_cmd_parser.hpp b/utils/file_cmd_parser.hpp
index cf5d188..7d1470d 100644
--- a/utils/file_cmd_parser.hpp
+++ b/utils/file_cmd_parser.hpp
@@ -12,39 +12,51 @@
 
 #include <aesnixx/all.hpp>
 
-#include <boost/config.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/program_options.hpp>
 
 #include <ostream>
 #include <string>
-#include <vector>
+#include <utility>
 
 namespace
 {
-    BOOST_NORETURN inline void throw_key_required()
-    {
-        throw boost::program_options::error(
-            "a key is required but not specified");
-    }
+    class CommandLineParser;
 
-    BOOST_NORETURN inline void throw_iv_required()
+    class Settings
     {
-        throw boost::program_options::error(
-            "initialization vector is required for the selected mode of operation");
-    }
+    public:
+        Settings()
+            : iv(false, std::string())
+        { }
 
-    BOOST_NORETURN inline void throw_src_path_required()
-    {
-        throw boost::program_options::error(
-            "please, specify source file path");
-    }
+        aesni::Mode get_mode() const { return mode; }
+        aesni::Algorithm get_algorithm() const { return algorithm; }
 
-    BOOST_NORETURN inline void throw_dest_path_required()
-    {
-        throw boost::program_options::error(
-            "please, specify destination file path");
-    }
+        std::string get_input_path() const { return input_path; }
+        std::string get_output_path() const { return output_path; }
+
+        std::string get_key_string() const { return key; }
+
+        std::string get_iv_string() const
+        {
+            if (!iv.first)
+                throw boost::program_options::error("initialization vector is required for the selected mode of operation");
+            return iv.second;
+        }
+
+    private:
+        aesni::Mode mode;
+        aesni::Algorithm algorithm;
+
+        std::string input_path;
+        std::string output_path;
+        std::string key;
+
+        std::pair<bool, std::string> iv;
+
+        friend class CommandLineParser;
+    };
 
     class CommandLineParser
     {
@@ -52,34 +64,23 @@ namespace
         CommandLineParser(const std::string& argv0)
             : prog_name(boost::filesystem::path(argv0).filename().string())
             , options("Options")
+        { }
+
+        void parse(Settings& settings, int argc, char** argv)
         {
             namespace po = boost::program_options;
 
             options.add_options()
                 ("help,h", "show this message and exit")
-                ("mode,m", po::value<aesni::Mode>(&mode)->required(), "set mode of operation")
-                ("algorithm,a", po::value<aesni::Algorithm>(&algorithm)->required(), "set algorithm");
-        }
-
-        void parse(int argc, char** argv)
-        {
-            namespace po = boost::program_options;
-
-            po::options_description hidden_options;
-            hidden_options.add_options()
-                ("positional", po::value<std::vector<std::string>>(&args));
-
-            po::options_description all_options;
-            all_options.add(options).add(hidden_options);
-
-            po::positional_options_description positional_options;
-            positional_options.add("positional", -1);
+                ("mode,m", po::value<aesni::Mode>(&settings.mode)->required(), "set mode of operation")
+                ("algorithm,a", po::value<aesni::Algorithm>(&settings.algorithm)->required(), "set algorithm")
+                ("input-path,i", po::value<std::string>(&settings.input_path)->required(), "set input file")
+                ("output-path,o", po::value<std::string>(&settings.output_path)->required(), "set output file")
+                ("key,k", po::value<std::string>(&settings.key)->required(), "set encryption key")
+                ("iv,v", po::value<std::string>(&settings.iv.second), "set initialization vector");
 
             po::variables_map vm;
-            po::store(po::command_line_parser(argc, argv)
-                .options(all_options)
-                .positional(positional_options)
-                .run(), vm);
+            po::store(po::parse_command_line(argc, argv, options), vm);
 
             if (vm.count("help"))
             {
@@ -87,14 +88,13 @@ namespace
                 return;
             }
 
+            if (vm.count("iv"))
+                settings.iv.first = true;
+
             po::notify(vm);
         }
 
-        bool requested_help() const { return help_flag; }
-
-        aesni::Mode mode;
-        aesni::Algorithm algorithm;
-        std::vector<std::string> args;
+        bool exit_with_usage() const { return help_flag; }
 
     private:
         const std::string prog_name;
@@ -107,7 +107,7 @@ namespace
 
     std::ostream& operator<<(std::ostream& os, const CommandLineParser& cmd_parser)
     {
-        return os << "Usage: " << cmd_parser.prog_name << " [OPTIONS...] KEY [IV] SRC_PATH DEST_PATH\n"
+        return os << "Usage: " << cmd_parser.prog_name << " [OPTION...]\n"
                   << cmd_parser.options << "\n";
     }
 }