added sources

CMakeLists.txt

@@ -0,0 +1,12 @@
+cmake_minimum_required(VERSION 2.8)
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules/")
+set(PROJECT_NAME milter-sasl)
+set(LIBS -lmilter -ljsoncpp -lcrypto)
+project(${PROJECT_NAME})
+find_package(GTest)
+find_package(OpenSSL REQUIRED)
+add_subdirectory(src)
+if (GTEST_FOUND)
+    enable_testing()
+    add_subdirectory(tests)
+endif (GTEST_FOUND)

CMakeModules/FindJsonCpp.cmake

@@ -0,0 +1,46 @@
+# -*- cmake -*-
+# - Find JSONCpp
+# Find the JSONCpp includes and library
+# This module defines
+#  JSONCPP_INCLUDE_DIRS, where to find json.h, etc.
+#  JSONCPP_LIBRARIES, the libraries needed to use jsoncpp.
+#  JSONCPP_FOUND, If false, do not try to use jsoncpp.
+#  also defined, but not for general use are
+#  JSONCPP_LIBRARIES, where to find the jsoncpp library.
+
+FIND_PATH(JSONCPP_INCLUDE_DIRS json/json.h
+        /usr/include
+        /usr/local/include
+        ${CMAKE_SOURCE_DIR}/win32-deps/include
+        PATH_SUFFIXES jsoncpp/json jsoncpp
+        )
+
+
+FIND_LIBRARY(JSONCPP_LIBRARIES NAMES jsoncpp HINTS /usr/lib /usr/local/lib 	${CMAKE_SOURCE_DIR}/win32-deps/lib)
+
+IF (JSONCPP_LIBRARIES AND JSONCPP_INCLUDE_DIRS)
+    SET(JSONCPP_LIBRARIES ${JSONCPP_LIBRARIES})
+    SET(JSONCPP_FOUND "YES")
+ELSE (JSONCPP_LIBRARIES AND JSONCPP_INCLUDE_DIRS)
+    SET(JSONCPP_FOUND "NO")
+ENDIF (JSONCPP_LIBRARIES AND JSONCPP_INCLUDE_DIRS)
+
+
+IF (JSONCPP_FOUND)
+    IF (NOT JSONCPP_FIND_QUIETLY)
+        MESSAGE(STATUS "Found JSONCpp: ${JSONCPP_LIBRARIES}")
+    ENDIF (NOT JSONCPP_FIND_QUIETLY)
+ELSE (JSONCPP_FOUND)
+    IF (JSONCPP_FIND_REQUIRED)
+        MESSAGE(FATAL_ERROR "Could not find JSONCPP library include: ${JSONCPP_INCLUDE_DIRS}, lib: ${JSONCPP_LIBRARIES}")
+    ENDIF (JSONCPP_FIND_REQUIRED)
+ENDIF (JSONCPP_FOUND)
+
+# Deprecated declarations.
+SET (NATIVE_JSONCPP_INCLUDE_PATH ${JSONCPP_INCLUDE_DIRS} )
+GET_FILENAME_COMPONENT (NATIVE_JSONCPP_LIB_PATH ${JSONCPP_LIBRARIES} PATH)
+
+MARK_AS_ADVANCED(
+        JSONCPP_LIBRARIES
+        JSONCPP_INCLUDE_DIRS
+)

README.md

@@ -0,0 +1,8 @@
+CMake C++ starter kit
+=====================
+Here is a starter kit for C++ using CMake build system. The aim is to be used with CLion. It include a test project with GTest and a cmake module to find JsonCpp library.
+
+Usage
+-----
+
+Just clone and open the directory with CLion, it will generate a target to build the exe and the tests (if GTest is found).

milter-sasl.json

@@ -0,0 +1,3 @@
+{
+  "key": "insert your AES key here"
+}

src/Business/CryptoBusiness.cpp

@@ -0,0 +1,116 @@
+//
+// Created by robin on 2/26/17.
+//
+
+#include <openssl/aes.h>
+#include <cstring>
+#include "CryptoBusiness.h"
+
+std::string CryptoBusiness::_hex = "0123456789ABCDEF";
+
+CryptoBusiness::CryptoBusiness()
+{
+
+}
+
+std::string CryptoBusiness::getKey() const
+{
+    return _key;
+}
+
+void CryptoBusiness::setKey(std::string key)
+{
+    _key = key;
+}
+
+std::string CryptoBusiness::encrypt16(std::string data)
+{
+    unsigned char enc_out[16 * sizeof(char)];
+    AES_KEY enc_key;
+    AES_set_encrypt_key((const unsigned char*)_key.c_str(), 128, &enc_key);
+    AES_encrypt((const unsigned char*)data.c_str(), enc_out, &enc_key);
+    return std::string((char*)enc_out, 16 * sizeof(char));
+}
+
+std::string CryptoBusiness::encrypt(std::string data)
+{
+    std::string out;
+    if (data.length() % 16 != 0)
+    {
+        data += std::string(16 - data.length() % 16, 0);
+    }
+    for (size_t i = 0; i < data.length(); i += 16)
+    {
+        out += encrypt16(data.substr(i, i + 16));
+    }
+    return out;
+}
+
+std::string CryptoBusiness::decrypt16(std::string data)
+{
+    unsigned char dec_out[16 * sizeof(char)];
+    memset(dec_out, 0, 16);
+    AES_KEY dec_key;
+    AES_set_decrypt_key((const unsigned char*)_key.c_str(), 128, &dec_key);
+    AES_decrypt((const unsigned char*)data.c_str(), dec_out, &dec_key);
+    int s = 16;
+    for(int i = 15; i >= 0 && dec_out[i] == 0; --i)
+        --s;
+    return std::string((char*)dec_out, s);
+}
+
+std::string CryptoBusiness::decrypt(std::string data)
+{
+    std::string out;
+    for (size_t i = 0; i < data.length(); i += 16)
+    {
+        out += decrypt16(data.substr(i, i + 16));
+    }
+    return out;
+}
+
+std::string CryptoBusiness::toHex(std::string data)
+{
+    size_t len = data.length();
+
+    std::string output;
+    output.reserve(2 * len);
+    for (size_t i = 0; i < len; ++i)
+    {
+        const unsigned char c = data[i];
+        output.push_back(_hex[c >> 4]);
+        output.push_back(_hex[c & 15]);
+    }
+    return output;
+}
+
+std::string CryptoBusiness::fromHex(std::string data)
+{
+    size_t len = data.length();
+
+    std::string output;
+    output.reserve(len / 2);
+    for (size_t i = 0; i < len; i += 2)
+    {
+        char a = data[i];
+        const char* p = std::lower_bound(_hex.c_str(), _hex.c_str() + 16, a);
+
+        char b = data[i + 1];
+        const char* q = std::lower_bound(_hex.c_str(), _hex.c_str() + 16, b);
+
+        output.push_back(((p - _hex.c_str()) << 4) | (q - _hex.c_str()));
+    }
+    return output;
+}
+
+std::string CryptoBusiness::encryptToHex(std::string data)
+{
+    auto encrypted = encrypt(data);
+    return toHex(encrypted);
+}
+
+std::string CryptoBusiness::decryptFromHex(std::string data)
+{
+    auto d = fromHex(data);
+    return decrypt(d);
+}

src/Business/CryptoBusiness.h

@@ -0,0 +1,43 @@
+//
+// Created by robin on 2/26/17.
+//
+
+#ifndef MILTER_SASL_CRYPTOBUSINESS_H
+#define MILTER_SASL_CRYPTOBUSINESS_H
+
+#include <string>
+
+class CryptoBusiness
+{
+public:
+    CryptoBusiness();
+
+    std::string getKey() const;
+
+    void setKey(std::string key);
+
+    std::string encryptToHex(std::string data);
+
+    std::string encrypt(std::string data);
+
+    std::string decryptFromHex(std::string data);
+
+    std::string decrypt(std::string data);
+
+    std::string toHex(std::string data);
+
+    std::string fromHex(std::string data);
+
+protected:
+    std::string encrypt16(std::string data);
+
+    std::string decrypt16(std::string data);
+
+private:
+    std::string _key;
+
+    static std::string _hex;
+};
+
+
+#endif //MILTER_SASL_CRYPTOBUSINESS_H

src/CMakeLists.txt

@@ -0,0 +1,15 @@
+include_directories(.)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+set(SOURCE_FILES
+  main.cpp
+  Interface/MainClass.cpp
+  Interface/MainClass.h
+  Interface/CommandLineParser.cpp
+  Interface/CommandLineParser.h
+  DBO/CommandLineOption.cpp
+  DBO/CommandLineOption.h
+        Business/CryptoBusiness.cpp
+  Business/CryptoBusiness.h)
+
+add_executable(${PROJECT_NAME} ${SOURCE_FILES})
+target_link_libraries(${PROJECT_NAME} ${LIBS})

src/DBO/CommandLineOption.cpp

@@ -0,0 +1,98 @@
+//
+// Created by robin on 8/8/15.
+//
+
+#include "CommandLineOption.h"
+
+CommandLineOption::CommandLineOption(const std::string &longName, char shortName, const std::string &description,
+                                     const std::string &valueName, const std::string &defaultValue)
+    : _longName(longName)
+    , _shortName(shortName)
+    , _description(description)
+    , _valueName(valueName)
+    , _defaultValue(defaultValue)
+    , _isSet(false)
+{
+}
+
+const std::string &CommandLineOption::getLongName() const
+{
+    return _longName;
+}
+
+void CommandLineOption::setLongName(const std::string &longName)
+{
+    _longName = longName;
+}
+
+char CommandLineOption::getShortName() const
+{
+    return _shortName;
+}
+
+void CommandLineOption::setShortName(char shortName)
+{
+    _shortName = shortName;
+}
+
+const std::string &CommandLineOption::getDescription() const
+{
+    return _description;
+}
+
+void CommandLineOption::setDescription(const std::string &description)
+{
+    _description = description;
+}
+
+const std::string &CommandLineOption::getValueName() const
+{
+    return _valueName;
+}
+
+void CommandLineOption::setValueName(const std::string &valueName)
+{
+    _valueName = valueName;
+}
+
+const std::string &CommandLineOption::getDefaultValue() const
+{
+    return _defaultValue;
+}
+
+void CommandLineOption::setDefaultValue(const std::string &defaultValue)
+{
+    _defaultValue = defaultValue;
+}
+
+const std::vector<std::string> &CommandLineOption::getValues() const
+{
+    return _values;
+}
+
+void CommandLineOption::addValue(const std::string &value)
+{
+    _values.push_back(value);
+}
+
+bool CommandLineOption::isSet() const
+{
+    return _isSet;
+}
+
+void CommandLineOption::setIsSet(bool isSet)
+{
+    _isSet = isSet;
+}
+
+bool CommandLineOption::hasValue() const
+{
+    return !_valueName.empty();
+}
+
+const std::string &CommandLineOption::getValue() const
+{
+    if (_values.empty())
+        return _defaultValue;
+    return _values[_values.size() - 1];
+}

src/DBO/CommandLineOption.h

@@ -0,0 +1,66 @@
+//
+// Created by robin on 8/8/15.
+//
+
+#ifndef PDNS_SLAVE_COMMANDLINEOPTION_H
+#define PDNS_SLAVE_COMMANDLINEOPTION_H
+
+# include <string>
+# include <vector>
+
+class CommandLineOption
+{
+public:
+    CommandLineOption(const std::string& longName, char shortName, const std::string& description,
+                      const std::string& valueName = "", const std::string& defaultValue = "");
+
+    const std::string &getLongName() const;
+
+    void setLongName(const std::string &longName);
+
+    char getShortName() const;
+
+    void setShortName(char shortName);
+
+    const std::string &getDescription() const;
+
+    void setDescription(const std::string &description);
+
+    const std::string &getValueName() const;
+
+    void setValueName(const std::string &valueName);
+
+    const std::string &getDefaultValue() const;
+
+    void setDefaultValue(const std::string &defaultValue);
+
+    const std::vector<std::string> &getValues() const;
+
+    const std::string &getValue() const;
+
+    void addValue(const std::string &value);
+
+    bool isSet() const;
+
+    void setIsSet(bool isSet);
+
+    bool hasValue() const;
+
+private:
+    std::string _longName;
+
+    char _shortName;
+
+    std::string _description;
+
+    std::string _valueName;
+
+    std::string _defaultValue;
+
+    std::vector<std::string> _values;
+
+    bool _isSet;
+};
+
+
+#endif //PDNS_SLAVE_COMMANDLINEOPTION_H

src/Interface/CommandLineParser.cpp

@@ -0,0 +1,79 @@
+//
+// Created by robin on 8/8/15.
+//
+
+#include <getopt.h>
+#include <iostream>
+#include "CommandLineParser.h"
+
+CommandLineParser::CommandLineParser(int argc, char **argv)
+    : _argc(argc)
+    , _argv(argv)
+{
+}
+
+bool CommandLineParser::parse()
+{
+    std::string shortOpts;
+    option opts[_options.size() + 1];
+    for (unsigned i = 0; i < _options.size(); ++i)
+    {
+        auto opt = _options[i];
+        shortOpts += opt->getShortName();
+        if (opt->hasValue())
+            shortOpts += ":";
+        opts[i].name = opt->getLongName().c_str();
+        opts[i].has_arg = opt->hasValue();
+        opts[i].flag = 0;
+        opts[i].val = opt->getShortName();
+    }
+    opts[_options.size()] = {0, 0, 0, 0};
+    int option;
+    extern int optind;
+    extern char* optarg;
+    bool valid = true;
+    while ((option = getopt_long(_argc, _argv, shortOpts.c_str(), opts, 0)) != -1)
+    {
+        bool optValid = false;
+        for (unsigned i = 0; i < _options.size(); ++i)
+        {
+            auto opt = _options[i];
+            if (opt->getShortName() == option)
+            {
+                optValid = true;
+                opt->setIsSet(true);
+                if (opt->hasValue())
+                    opt->addValue(optarg);
+            }
+        }
+        if (!optValid)
+            valid = false;
+    }
+    return optind == _argc && valid;
+}
+
+void CommandLineParser::addOption(CommandLineOption* opt)
+{
+    _options.push_back(opt);
+}
+
+int CommandLineParser::showHelp(int status, bool stdErr)
+{
+    auto& out = stdErr ? std::cerr : std::cout;
+    out << "Options:" << std::endl;
+    for (auto opt : _options)
+    {
+        out << "  -" << opt->getShortName() << ", --" << opt->getLongName();
+        if (opt->hasValue())
+        {
+            out << " <" << opt->getValueName();
+            if (opt->getDefaultValue().length())
+            {
+                out << "=" << opt->getDefaultValue();
+            }
+            out << ">";
+        }
+        out << " " << opt->getDescription() << std::endl;
+    }
+    return status;
+}

src/Interface/CommandLineParser.h

@@ -0,0 +1,30 @@
+//
+// Created by robin on 8/8/15.
+//
+
+#ifndef PDNS_SLAVE_COMMANDLINEPARSER_H
+#define PDNS_SLAVE_COMMANDLINEPARSER_H
+
+# include "DBO/CommandLineOption.h"
+
+class CommandLineParser
+{
+public:
+    CommandLineParser(int argc, char** argv);
+
+    bool parse();
+
+    int showHelp(int status = 0, bool stdErr = true);
+
+    void addOption(CommandLineOption* opt);
+
+private:
+    int _argc;
+
+    char** _argv;
+
+    std::vector<CommandLineOption*> _options;
+};
+
+
+#endif //PDNS_SLAVE_COMMANDLINEPARSER_H

src/Interface/MainClass.cpp

@@ -0,0 +1,186 @@
+//
+// Created by robin on 8/8/15.
+//
+
+#include <iostream>
+#include <fstream>
+#include <sysexits.h>
+#include <jsoncpp/json/json.h>
+#include <cstring>
+#include "CommandLineParser.h"
+#include "MainClass.h"
+
+MainClass* MainClass::_instance = nullptr;
+
+MainClass *MainClass::getInstance()
+{
+    return _instance;
+}
+
+sfsistat mlfi_header(SMFICTX *ctx)
+{
+    return MainClass::getInstance()->mlfiHeader(ctx);
+}
+
+MainClass::MainClass(int argc, char *argv[])
+    : _argc(argc)
+    , _argv(argv)
+{
+    _instance = this;
+    _cryptoBusiness = std::make_shared<CryptoBusiness>();
+}
+
+MainClass::~MainClass()
+{
+}
+
+int MainClass::main()
+{
+    CommandLineParser commandLineParser(_argc, _argv);
+    CommandLineOption configOption("config", 'c', "Use FILE as configuration file.", "FILE", "/etc/milter-sasl/milter-sasl.json");
+    commandLineParser.addOption(&configOption);
+    CommandLineOption decryptOption("decrypt", 'd', "Decrypt DATA and exit. Can be specified multiple times. Use - to read from stdin.", "DATA");
+    commandLineParser.addOption(&decryptOption);
+    CommandLineOption socketOption("milter", 'm', "Launch milter and specify the socket to listen on (eg: inet:4242@localhost).", "SOCKET");
+    commandLineParser.addOption(&socketOption);
+    CommandLineOption helpOption("help", 'h', "Show this help.");
+    commandLineParser.addOption(&helpOption);
+
+    if (!commandLineParser.parse())
+    {
+        return commandLineParser.showHelp(EX_USAGE, true);
+    }
+
+    if (helpOption.isSet())
+    {
+        return commandLineParser.showHelp(0, false);
+    }
+
+    auto configFile = configOption.getValue();
+    auto configResult = loadConfig(configFile);
+    if (configResult != 0)
+    {
+        std::cerr << "Failed to read configuration file: " << strerror(configResult) << std::endl;
+        return EX_NOINPUT;
+    }
+    else if (socketOption.isSet())
+    {
+        return launchMilter(socketOption.getValue());
+    }
+    else if (decryptOption.isSet())
+    {
+        return launchDecrypt(decryptOption.getValues());
+    }
+
+    return commandLineParser.showHelp(EX_USAGE, true);
+}
+
+sfsistat MainClass::mlfiHeader(SMFICTX *ctx)
+{
+    Json::Value root;
+    auto auth_authen = smfi_getsymval(ctx, (char*)"{auth_authen}");
+    if (auth_authen)
+    {
+        root["auth_authen"] = randomizeString(auth_authen);
+    }
+    auto auth_author = smfi_getsymval(ctx, (char*)"{auth_author}");
+    if (auth_author)
+    {
+        root["auth_author"] = randomizeString(auth_author);
+    }
+    auto auth_type = smfi_getsymval(ctx, (char*)"{auth_type}");
+    if (auth_type)
+    {
+        root["auth_type"] = randomizeString(auth_type);
+    }
+
+    Json::StyledWriter w;
+    auto json = w.write(root);
+    auto encrypted = _cryptoBusiness->encryptToHex(json);
+
+    smfi_addheader(ctx, (char*)"X-Sasl-User", (char*)encrypted.c_str());
+
+    return SMFIS_CONTINUE;
+}
+
+int MainClass::loadConfig(const std::string& filePath)
+{
+    std::ifstream stream(filePath, std::ifstream::in);
+    if (stream)
+    {
+        Json::Reader reader;
+        Json::Value root;
+        reader.parse(stream, root);
+        _cryptoBusiness->setKey(root["key"].asString());
+    }
+    return errno;
+}
+
+int MainClass::launchMilter(const std::string &socket)
+{
+    srand(time(nullptr));
+    struct smfiDesc smfilter =
+            {
+                    (char*)"milter-sasl",	/* filter name */
+                    SMFI_VERSION,	/* version code -- do not change */
+                    SMFIF_ADDHDRS,	/* flags */
+                    NULL,		/* connection info filter */
+                    NULL,		/* SMTP HELO command filter */
+                    NULL,	/* envelope sender filter */
+                    NULL,		/* envelope recipient filter */
+                    NULL,	/* header filter */
+                    NULL,	/* end of header */
+                    NULL,	/* body block filter */
+                    mlfi_header,	/* end of message */
+                    NULL,	/* message aborted */
+                    NULL,	/* connection cleanup */
+                    NULL,	/* unknown/unimplemented SMTP commands */
+                    NULL,	/* DATA command filter */
+                    NULL	/* option negotiation at connection startup */
+            };
+
+    if (smfi_setconn((char*)socket.c_str()) == MI_FAILURE)
+    {
+        std::cerr << "smfi_setconn failed" << std::endl;
+        return EX_UNAVAILABLE;
+    }
+
+    if (smfi_register(smfilter) == MI_FAILURE)
+    {
+        std::cerr << "smfi_register failed" << std::endl;
+        return EX_UNAVAILABLE;
+    }
+
+    return smfi_main();
+}
+
+int MainClass::launchDecrypt(const std::vector<std::string> values)
+{
+    for (auto value : values)
+    {
+        if (value == "-")
+        {
+            std::cin >> value;
+        }
+        std::cout << _cryptoBusiness->decryptFromHex(value) << std::endl;
+    }
+    return 0;
+}
+
+std::string MainClass::randomizeString(const std::string &str)
+{
+    int cc = 2;
+    std::string out;
+    for (int i = 0; i < cc; ++i)
+    {
+        auto c = 'a' + (rand() % 26);
+        out.push_back((char)c);
+    }
+    out += "|" + str + "|";
+    for (int i = 0; i < cc; ++i)
+    {
+        auto c = 'a' + (rand() % 26);
+        out.push_back((char)c);
+    }
+    return out;
+}

src/Interface/MainClass.h

@@ -0,0 +1,45 @@
+//
+// Created by robin on 8/8/15.
+//
+
+#ifndef PDNS_SLAVE_MAINCLASS_H
+#define PDNS_SLAVE_MAINCLASS_H
+
+#include <Business/CryptoBusiness.h>
+#include <boost/shared_ptr.hpp>
+#include "libmilter/mfapi.h"
+#include "libmilter/mfdef.h"
+
+class MainClass {
+public:
+    static MainClass* getInstance();
+
+    MainClass(int argc, char* argv[]);
+    virtual ~MainClass();
+
+    int main();
+
+    sfsistat mlfiHeader(SMFICTX *ctx);
+
+    std::string randomizeString(const std::string& str);
+
+protected:
+    int loadConfig(const std::string& filePath);
+
+    int launchMilter(const std::string& socket);
+
+    int launchDecrypt(const std::vector<std::string> values);
+
+private:
+    int _argc;
+
+    char** _argv;
+
+    std::shared_ptr<CryptoBusiness> _cryptoBusiness;
+
+    static MainClass* _instance;
+
+};
+
+
+#endif //PDNS_SLAVE_MAINCLASS_H

src/main.cpp

@@ -0,0 +1,7 @@
+#include "Interface/MainClass.h"
+
+int main(int argc, char* argv[])
+{
+    MainClass m(argc, argv);
+    return m.main();
+}

tests/CMakeLists.txt

@@ -0,0 +1,12 @@
+enable_testing()
+include_directories(${CHECK_INCLUDE_DIRS})
+include_directories(. ../src)
+find_package (Threads)
+set(LIBS ${LIBS} gtest pthread)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+add_executable(test-${PROJECT_NAME}
+        test-main.cpp
+        ../src/Business/CryptoBusiness.cpp
+  )
+target_link_libraries(test-${PROJECT_NAME} ${LIBS})
+add_test(test-${PROJECT_NAME} ${CMAKE_CURRENT_BINARY_DIR}/test-${PROJECT_NAME})

tests/milter-sasl.json

@@ -0,0 +1,3 @@
+{
+  "key": "x%p~;mZ(A4FG]CDj"
+}

tests/test-main.cpp

@@ -0,0 +1,58 @@
+#include <iostream>
+#include <string.h>
+#include <gtest/gtest.h>
+#include <Business/CryptoBusiness.h>
+
+TEST(Crypto, Basic)
+{
+  std::string key = "m{L%H$HgY##LJ&6Fs";
+  CryptoBusiness cryptoBusiness;
+  cryptoBusiness.setKey(key);
+  std::string data = "some data";
+  std::string encrypted = cryptoBusiness.encrypt(data);
+  std::string decrypted = cryptoBusiness.decrypt(encrypted);
+  ASSERT_NE(encrypted, decrypted);
+  ASSERT_EQ(data, decrypted);
+}
+
+TEST(Crypto, Hex1)
+{
+  CryptoBusiness cryptoBusiness;
+  std::string data = "some data";
+  std::string toHex = cryptoBusiness.toHex(data);
+  std::string fromHex = cryptoBusiness.fromHex(toHex);
+  ASSERT_NE(toHex, fromHex);
+  ASSERT_EQ(data, fromHex);
+}
+
+TEST(Crypto, Hex2)
+{
+  CryptoBusiness cryptoBusiness;
+  std::string data;
+  for (int i = 0; i <= 255; ++i)
+  {
+    data += (char)i;
+  }
+  std::string toHex = cryptoBusiness.toHex(data);
+  std::string fromHex = cryptoBusiness.fromHex(toHex);
+  ASSERT_NE(toHex, fromHex);
+  ASSERT_EQ(data, fromHex);
+}
+
+TEST(Crypto, EncryptHex)
+{
+  std::string key = "m{L%H$HgY##LJ&6Fs";
+  CryptoBusiness cryptoBusiness;
+  cryptoBusiness.setKey(key);
+  std::string data = "some data";
+  std::string encrypted = cryptoBusiness.encryptToHex(data);
+  std::string decrypted = cryptoBusiness.decryptFromHex(encrypted);
+  ASSERT_NE(encrypted, decrypted);
+  ASSERT_EQ(data, decrypted);
+}
+
+int main(int argc, char* argv[])
+{
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}