Не получается зашифровать файл

#include <iostream>
#include <Windows.h>
#include <fstream>
#include <vector>
#include <io.h>
#include "RandomV2.h"
 
#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::ofstream,
      std::string,
      std::wstring,
      std::vector,
      std::wcout;
using namespace effolkronium;
std::locale utf8 = std::locale("en_US.utf-8");
 
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 {
 
        wstring _encrypt(wstring mess, wstring key) {
            vector<wchar_t> vmess;
            vector<wchar_t> vkey;
            wstring result = L"";
 
            for (size_t i = 0; i < mess.size(); i++) vmess.push_back(mess[i]);
            for (size_t i = 0; i < key.size(); i++) vkey.push_back(key[i]);
 
            for (auto& sym : vmess) {
                wchar_t r = sym;
                for (auto& ksym : vkey) {
                    r ^= ksym;
                }
                result += r;
            }
            return result;
        }
 
        wstring _decrypt(wstring mess, wstring key) {
            vector<wchar_t> vmess;
            vector<wchar_t> vkey;
            wstring result = L"";
 
            for (size_t i = 0; i < mess.size(); i++) vmess.push_back(mess[i]);
            for (size_t i = 1; i <= key.size(); i++) vkey.push_back(key[key.size() - i]);
 
            for (auto& sym : vmess) {
                wchar_t r = sym;
                for (auto& ksym : vkey) {
                    r ^= ksym;
                }
                result += r;
            }
            return result;
        }
 
        void encrypt(wifstream& in, wofstream& out, wstring key) {
            in.imbue(utf8);
            out.imbue(utf8);
            
            size_t block_size = 128;
            wchar_t* buff = new wchar_t[(const size_t)block_size];
            wstring output;
            size_t block = 0;
 
            while (!in.bad() && !in.eof() && !out.bad()) {
                block++;
                in.read(buff, block_size);
                wcout << buff << L"\n";
                output = Crypt::_encrypt(buff, key);
                out.write(output.c_str(), output.size());
                wcout << L"Блок " << std::to_wstring(block) << L" [" << in.rdstate() << L"/" << out.rdstate() << L"]\n";
            }
        }
 
        void decrypt(wifstream& in, wofstream& out, wstring key) {
            in.imbue(utf8);
            out.imbue(utf8);
 
            size_t block_size = 128;
            wchar_t* buff = new wchar_t[(const size_t)block_size];
            wstring output;
            size_t block = 0;
 
            while (!in.bad() && !in.eof() && !out.bad()) {
                block++;
                in.read(buff, block_size);
                in.ignore(block_size);
                output = Crypt::_decrypt(buff, key);
                out.write(output.c_str(), output.size());
                wcout << L"Блок " << std::to_wstring(block) << L" [" << in.rdstate() << L"/" << out.rdstate() << L"]\n";
            }
        }
 
        wstring getKey() {
            wifstream fkey(Path::GetPath("KEY-DO-NOT-REMOVE.key"));
            fkey.imbue(utf8);
 
            size_t block_size = 128;
            size_t blocks = 32;
 
            wstring key;
            wchar_t* buff = new wchar_t[(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() {
        random_local rd{};
        //srand(time(0));
 
        wofstream key(Path::GetPath("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 = 0x036F;
 
                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) {
        wstring f1 = Path::GetPathW(L"f1.bin");
        wstring f2 = Path::GetPathW(L"f2.bin");
        wstring f3 = Path::GetPathW(L"f3.bin");
        wstring f4 = Path::GetPathW(L"f4.bin");
 
        if (!(
            fs::exists(f1) &&
            fs::exists(f2) &&
            fs::exists(f3) &&
            fs::exists(f4)
            )) {
            MessageBoxW(GetConsoleWindow(), L"Компилируемые файлы не найдены!", curr_path, MB_OK);
            //return;
        }
 
        wcout << L"Читаю ключ...\n";
        
        wstring key = Crypt::getKey();
 
        wcout << L"Открываю файлы для установки...\n";
 
        wifstream ff1(f1);
        wifstream ff2(f2);
        wifstream ff3(f3);
        wifstream ff4(f4);
 
        wcout << L"Создаю зашифрованные файлы...\n";
 
        CreateDirectoryW(Path::GetPathW(L"build\\").c_str(), NULL);
 
        wofstream of1(Path::GetPathW(L"build\\f1.sbin"));
        wofstream of2(Path::GetPathW(L"build\\f2.sbin"));
        wofstream of3(Path::GetPathW(L"build\\f3.sbin"));
        wofstream of4(Path::GetPathW(L"build\\f4.sbin"));
 
        fs::copy(curr_path, Path::GetPathW(L"build\\" + fs::path(curr_path).filename().wstring()), fs::copy_options::overwrite_existing);
 
        wcout << L"Шифрую файлы...\n";
 
        wcout << f1 << L"\n";
        Crypt::encrypt(ff1, of1, key);
        wcout << f2 << L"\n";
        Crypt::encrypt(ff2, of2, key);
        wcout << f3 << L"\n";
        Crypt::encrypt(ff3, of3, key);
        wcout << f4 << L"\n";
        Crypt::encrypt(ff4, of4, key);
 
        wcout << L"Закрываю файлы...\n";
 
        ff1.close();
        ff2.close();
        ff3.close();
        ff4.close();
        of1.close();
        of2.close();
        of3.close();
        of4.close();
    }
    
}
 
int wmain(int** argc, wchar_t* argv[])
{
    _setmode(_fileno(stdout), 0x20000);
    setlocale(LC_ALL, "ru-RU");
    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;
    }
}