Асимметричное шифрование

#include <iostream>
#include <Windows.h>
#include <fstream>
#include <vector>
#include <map>
#include <io.h>
#include "RandomV2.h"
 
#pragma warning(disable : 4996)
 
#ifdef __cpp_lib_experimental_filesystem
#define _SILENCE_EXPERIMENTAL_FILESYSTEM_DEPRECATION_WARNING
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem::v1;
#elif __cpp_lib_filesystem
#include <filesystem>
namespace fs = std::filesystem;
#else
#error "no filesystem support ='("
#endif
 
using std::wifstream,
      std::wofstream,
      std::ifstream,
      std::ofstream,
      std::string,
      std::wstring,
      std::vector,
      std::wcout,
      std::map,
      std::stringstream;
using namespace effolkronium;
std::locale utf8;
random_local rd{};
 
class NoConvCodecvt : public std::codecvt<char, char, mbstate_t>
{
public:
    virtual bool do_always_noconv() const throw() override
    {
        return true;
    }
};
 
namespace CryptInstaller {
 
    namespace Path {
 
        template <typename _WStr> wstring GetPathW(_WStr path) {
            vector<wchar_t> pathBuf;
            DWORD copied = 0;
            do {
                pathBuf.resize(pathBuf.size() + 260);
                copied = GetModuleFileNameW(nullptr, &pathBuf.at(0), pathBuf.size());
            } while (copied >= pathBuf.size());
            pathBuf.resize(copied);
            wstring path_(pathBuf.begin(), pathBuf.end());
            return fs::path(path_).parent_path().wstring() + L"\\" + wstring(path);
        }
 
        template <typename _Str> string GetPath(_Str path) {
            vector<char> pathBuf;
            DWORD copied = 0;
            do {
                pathBuf.resize(pathBuf.size() + 260);
                copied = GetModuleFileNameA(nullptr, &pathBuf.at(0), pathBuf.size());
            } while (copied >= pathBuf.size());
            pathBuf.resize(copied);
            string path_(pathBuf.begin(), pathBuf.end());
            return fs::path(path_).parent_path().string() + "\\" + string(path);
        }
 
    }
 
    namespace Crypt {
 
        class File {
        protected:
            size_t key_pos = 0;
            string key;
        public:
            File(string _key) : key(_key) {}
            vector<char> encrypt(vector<char> mess) {
                vector<char> vkey;
                vector<char> result;
 
                for (size_t i = 0; i < key.size(); i++) vkey.push_back(key[i]);
 
                char r;
                for (size_t i = 0; i < mess.size(); i++) {
                    if (key_pos >= vkey.size()) key_pos = 0;
                    r = mess[i];
                    r ^= vkey[key_pos];
                    result.push_back(r);
                    key_pos++;
                }
 
                return result;
            }
 
            vector<char> decrypt(vector<char> mess) {
                vector<char> vmess;
                vector<char> vkey;
                vector<char> result;
 
                for (size_t i = 1; i <= mess.size(); i++) vmess.push_back(mess[mess.size() - i]);
                for (size_t i = 0; i < key.size(); i++) vkey.push_back(key[i]);
 
                char r;
                for (size_t i = 0; i < vmess.size(); i++) {
                    if (key_pos >= vkey.size()) key_pos = 0;
                    r = vmess[i];
                    r ^= vkey[key_pos];
                    result.push_back(r);
                    key_pos++;
                }
 
                vector<char> buff;
                for (size_t i = 1; i <= result.size(); i++) buff.push_back(result[result.size() - i]);
                return buff;
            }
        };
 
        void encrypt(ifstream& in, ofstream& out, string key) {
            in.imbue(utf8);
 
            in.setstate(0);
            out.setstate(0);
 
            in.seekg(0, std::ios::end);
            size_t block_size = in.tellg();
            in.seekg(0, std::ios::beg);
 
            vector<char> buff;
            buff.resize(block_size);
            vector<char> output;
            output.resize(block_size);
 
            File crypt(key);
 
            in.read(&buff[0], block_size);
            output = crypt.encrypt(buff);
            out.write(&output[0], output.size());
 
            wcout << std::to_wstring(block_size) << L"\n";
            in.setstate(0);
            out.setstate(0);
        }
 
        void decrypt(ifstream& in, ofstream& out, string key) {
            out.imbue(utf8);
 
            in.setstate(0);
            out.setstate(0);
 
            in.seekg(0, std::ios::end);
            size_t block_size = in.tellg();
            in.seekg(0, std::ios::beg);
 
            vector<char> buff;
            buff.resize(block_size);
            vector<char> output;
            output.resize(block_size);
 
            File crypt(key);
 
            in.read(&buff[0], block_size);
            output = crypt.decrypt(buff);
            out.write(&output[0], output.size());
 
            wcout << std::to_wstring(block_size) << L"\n";
            in.setstate(0);
            out.setstate(0);
        }
 
        string getKey() {
            ifstream fkey(Path::GetPath("KEY-DO-NOT-REMOVE.key"));
            fkey.imbue(utf8);
 
            size_t block_size = 128;
            size_t blocks = 32;
 
            string key;
            char* buff = new char[(const size_t)block_size];
 
            for (size_t i = 0; i < blocks; i++) {
                fkey.read(buff, block_size);
                key += buff;
                fkey.ignore();
            }
 
            fkey.close();
 
            return key;
        }
    }
 
    void generateKey() {
        wofstream key(Path::GetPathW(L"KEY-DO-NOT-REMOVE.key"));
        key.imbue(utf8);
 
        const size_t block_size = 128;
        const size_t blocks = 32;
 
        wstring buff;
        buff.resize(block_size);
 
        unsigned short b;
 
        for (size_t i = 0; i < blocks; i++) {
            for (size_t j = 0; j < block_size; j++) {
 
                const unsigned short min = 0x00A0;
                const unsigned short max = 0x00FF;
 
                b = rd.get(min, max);
                //b = (rand() % (max - min) + min);
 
                buff[j] = (wchar_t)b;
            }
 
            key.write(buff.c_str(), block_size);
            key.write(L"\n", 1);
        }
        key.close();
    }
 
    void build(wchar_t* curr_path) {
        wcout << L"Читаю ключ...\n";
        
        string key = Crypt::getKey();
 
        CreateDirectoryW(Path::GetPathW(L"build\\").c_str(), NULL);
        CreateDirectoryW(Path::GetPathW(L"build\\data\\").c_str(), NULL);
 
        wcout << L"Подготовка...\n";
 
        fs::copy(curr_path, Path::GetPathW(L"build\\" + fs::path(curr_path).filename().wstring()), fs::copy_options::overwrite_existing);
        fs::copy(Path::GetPathW(L"KEY-DO-NOT-REMOVE.key"), Path::GetPathW(L"build\\KEY-DO-NOT-REMOVE.key"), fs::copy_options::overwrite_existing);
 
        wcout << L"Шифрую файлы...\n";
 
        for (auto& p : fs::directory_iterator{ Path::GetPathW(L"src\\") }) {
            ifstream in(p.path().string(), std::ios::binary);
            ofstream out("build\\data\\" + p.path().filename().string() + ".encrypted", std::ios::binary);
            Crypt::encrypt(in, out, key);
            in.close();
            out.close();
        }
    }
 
    string getRandStr() {
        string buff = "";
 
        unsigned short ch = 0;
        for (size_t i = 0; i < 20; i++) {
            ch = 0;
            while (!(ch >= 0x0030 && ch <= 0x007A && !(ch >= 0x003A && ch <= 0x0040) && !(ch >= 0x005B && ch <= 0x0060))) ch = rd.get(0x0030, 0x007A);
            buff += (char)ch;
        }
        return buff;
    }
    
    void execute(wchar_t* curr_path) {
        if (!fs::exists(Path::GetPathW(L"data\\"))) {
            MessageBoxW(GetConsoleWindow(), L"Компилируемые файлы не найдены!", curr_path, MB_OK);
            return;
        }
 
        wcout << L"Читаю ключ...\n";
 
        string key = Crypt::getKey();
 
        wcout << L"Подготовка...\n";
 
        string path = string(getenv("APPDATA")) + "\\File_" + getRandStr() + "\\";
        CreateDirectoryA(path.c_str(), NULL);
 
        wcout << L"Установка...\n";
 
        for (auto& p : fs::directory_iterator{ Path::GetPathW(L"data\\") }) {
            ifstream ff(p.path().string(), std::ios::binary);
            string fname = p.path().filename().string().substr(0, p.path().filename().string().find_last_of(".encrypted") - 9);
            ofstream of(path + fname, std::ios::binary);
            Crypt::decrypt(ff, of, key);
            ff.close();
            of.close();
        }
    }
}
 
int wmain(int** argc, wchar_t* argv[])
{
    //†
    _setmode(_fileno(stdout), 0x20000);
    setlocale(LC_ALL, "ru-RU.UTF-8");
    std::ios_base::sync_with_stdio(false);
    try {
        //utf8 = std::locale(std::locale(".1252"), new NoConvCodecvt());
        utf8 = std::locale(".1252");
    }
    catch (std::runtime_error& e) {
        //utf8 = std::locale(std::locale(".utf-8"), new NoConvCodecvt());
        utf8 = std::locale(".utf-8");
        wcout << e.what() << L"\n";
    }
    if (argc > (int**)1 && wcscmp(argv[1], L"--gen-key") == 0) {
 
        CryptInstaller::generateKey();
 
        wcout << L"Нажми любую клавишу чтобы выйти!\a";
        getwchar();
        return 0;
    }
    if (argc > (int**)1 && wcscmp(argv[1], L"--build") == 0) {
        
        CryptInstaller::build(argv[0]);
 
        wcout << L"Нажми любую клавишу чтобы выйти!\a";
        getwchar();
        return 0;
    }
 
    CryptInstaller::execute(argv[0]);
 
    wcout << L"Нажми любую клавишу чтобы выйти!\a";
    getwchar();
    return 0;
}