diff --git a/ChunkManager.cpp b/ChunkManager.cpp deleted file mode 100644 index cfec97b..0000000 --- a/ChunkManager.cpp +++ /dev/null @@ -1,133 +0,0 @@ -/* - * This file is part of VoidArchiveTool. - * - * Copyright (C) 2025 Yanczi - * - * Void Archive Toolis free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program. If not, see . - */ - -#include "ChunkManager.h" - -ChunkManager::ChunkManager(EncryptionManager& em) - :eman(em) -{ } - -ChunkManager::~ChunkManager() -{ } - -//----------------------------------------------------------------------------- -// Kompresja blokowa -// -// Dzielenie vectora na chunki dok³adnie po 128KB -// Kompresowanie chunków bez nag³ówka -//----------------------------------------------------------------------------- -std::vector ChunkManager::chunked(const std::vector& raw, const bool& compress, const bool& encrypt) -{ - //std::vector blockSizes; - - // Maksymalny rozmiar chunka - const size_t maxBlockSize = BLOCK_SIZE; - const size_t rawSize = raw.size(); - - uint16_t blockLen = 0; - uint32_t lastChunkRawSize; - std::vector compressedBlocks; - for (size_t offset = 0; offset < rawSize; offset += maxBlockSize) - { - // Rozmiar chunka - const size_t chunkSize = std::min(maxBlockSize, rawSize - offset); - - auto begin = raw.begin() + offset; - auto end = begin + chunkSize; - - // Skopiuj fragment danych do chunka - std::vector chunk(begin, end); - - std::vector outChunk; - - // Przetwórz chunki i przetwórz - if (compress) - { - // Zaszyfruj i skompresuj lub tylko skompresuj - outChunk = encrypt ? eman.encrypt(cman.compress(chunk)) : cman.compress(chunk); - } - else - { - // Zaszyfruj lub skopiuj - outChunk = encrypt ? eman.encrypt(chunk) : std::move(chunk); - } - - uint32_t chs = chunk.size(); - uint32_t zch = outChunk.size(); - - //addIntToVector(compressedBlocks, chs); - lastChunkRawSize = chs; - addIntToVector(compressedBlocks, zch); - compressedBlocks.insert(compressedBlocks.end(), outChunk.begin(), outChunk.end()); - - blockLen++; - } - - std::vector zip; - // Wstaw liczbê o iloœci bloków do vectora; - // Przekonpwertuj usigned int32 na ci¹g znkaów - // uint16_t blockLen = blockSizes .size(); - addIntToVector(zip, blockLen); - addIntToVector(zip, maxBlockSize); - addIntToVector(zip, lastChunkRawSize); - - // Dodaj skompresowane dane - zip.insert(zip.end(), compressedBlocks.begin(), compressedBlocks.end()); - - return zip; -} - -////////////////////////////////////////////////////////////// - -//----------------------------------------------------------------------------- -// Dekompresja blokowa -//----------------------------------------------------------------------------- -std::vector ChunkManager::dechunked(const std::vector& zip, const bool& compress, const bool& encrypt) -{ - size_t offset = 0; - const uint16_t chunkLen = getIntFromVector(zip, offset); - const uint32_t chunkBeforeSize = getIntFromVector(zip, offset); - const uint32_t chunkLastSize = getIntFromVector(zip, offset); - - std::vector chunksString; - - // Dekompresja bloków - for (size_t i = 0; i < chunkLen; ++i) - { - // Pobierz rozmiar chunków przed i po skompresowaniem - uint32_t chunkSize = i < chunkLen - 1 ? chunkBeforeSize : chunkLastSize; - uint32_t chunkZipSize = getIntFromVector(zip, offset); - - // Pobierz blok chunka - std::vector inChunk(chunkZipSize); - std::memcpy(inChunk.data(), zip.data() + offset, chunkZipSize); - offset += chunkZipSize; - - // Jeœli flaga encrypt jest aktywna najpierw zdeszyfruj blok - std::vector zipChunk = encrypt ? eman.decrypt(inChunk) : std::move(inChunk); - - // Zdeklarój pusty chunk - std::vector chunk = compress ? cman.decompress(zipChunk, chunkSize) : std::move(zipChunk); - - // Scal chunki - chunksString.insert(chunksString.end(), chunk.begin(), chunk.end()); - } - - return chunksString; -} \ No newline at end of file diff --git a/ChunkManager.h b/ChunkManager.h deleted file mode 100644 index dd453c7..0000000 --- a/ChunkManager.h +++ /dev/null @@ -1,70 +0,0 @@ -/* - * This file is part of VoidArchiveTool. - * - * Copyright (C) 2025 Yanczi - * - * Void Archive Toolis free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program. If not, see . - */ - -#pragma once - -#include -#include -#include -#include -#include -#include - -#include "EncryptionManager.h" -#include "CompressionManager.h" - -#define BLOCK_SIZE 131072 // 128KB - -class ChunkManager -{ -public: - ChunkManager(EncryptionManager& em); - ~ChunkManager(); - - // Kompresja danych - std::vector chunked(const std::vector&, const bool&, const bool&); - - // Dekompresja - std::vector dechunked(const std::vector&, const bool&, const bool&); - -private: - EncryptionManager eman; - CompressionManager cman; - - // Przekonwertuj zmienn¹ na ci¹g na vector - template - void addIntToVector(std::vector& vec, const T& val) - { - size_t tmpSize = vec.size(); - vec.resize(tmpSize + sizeof(val)); - std::memcpy(vec.data() + tmpSize, &val, sizeof(val)); - } - - // Pobierz zmienn¹ z vectora - template - T getIntFromVector(const std::vector& vec, size_t& offset) - { - T tmp{}; - std::memcpy(&tmp, vec.data() + offset, sizeof(tmp)); - offset += sizeof(tmp); - - return tmp; - } -}; - diff --git a/CompressionManager.cpp b/CompressionManager.cpp index 27a2435..0c934b8 100644 --- a/CompressionManager.cpp +++ b/CompressionManager.cpp @@ -23,9 +23,6 @@ CompressionManager::CompressionManager() :cctx(ZSTD_createCCtx()) ,dctx(ZSTD_createDCtx()) { - // Tu ustawienia pod kompresjê - const int level = COMPRESSION_LEVEL; - // Ustawienia frameless size_t rc = 0; @@ -42,7 +39,7 @@ CompressionManager::CompressionManager() rc |= ZSTD_CCtx_setParameter(cctx, ZSTD_c_dictIDFlag, 0); // Ustawia poziom kompresji - rc |= ZSTD_CCtx_setParameter(cctx, ZSTD_c_compressionLevel, level); + rc |= ZSTD_CCtx_setParameter(cctx, ZSTD_c_compressionLevel, zstd::compression_level); if (ZSTD_isError(rc)) { std::cerr << "ZSTD_CCtx_setParameter error" << std::endl; diff --git a/CompressionManager.h b/CompressionManager.h index 83eef36..5f747fb 100644 --- a/CompressionManager.h +++ b/CompressionManager.h @@ -30,7 +30,10 @@ #error "Wymagane zstd >= 1.4.0 dla ZSTD_c_format / ZSTD_f_zstd1_magicless" #endif -#define COMPRESSION_LEVEL 3 +namespace zstd +{ + inline constexpr short compression_level = 3; +} class CompressionManager { diff --git a/CreateCargo.cpp b/CreateCargo.cpp index 845a915..fe6f7aa 100644 --- a/CreateCargo.cpp +++ b/CreateCargo.cpp @@ -20,14 +20,15 @@ #include "CreateCargo.h" CreateCargo::CreateCargo() - : signature(SIGNATURE) - , extension(EXTENSION) - , version(VERSION) + : signature(fl::sigpak) + , extension(fl::extpak) , methodFlags(0) + , xxhState(XXH64_createState()) , offset(0) , hppKey(false) { // TODO Auto-generated constructor stub + XXH64_reset(xxhState, 0); } CreateCargo::~CreateCargo() { @@ -38,7 +39,7 @@ CreateCargo::~CreateCargo() { //----------------------------------------------------------------------------- // Punk wejœcia do tworzenia archivum //----------------------------------------------------------------------------- -bool CreateCargo::Create(const std::string& path, const int16_t& flag) +bool CreateCargo::Create(const std::string& path, const uint8_t& flag) { cargoFile = path + "." + extension; catalogPath = path; @@ -88,9 +89,9 @@ bool CreateCargo::Create(const std::string& path, const int16_t& flag) } // Zapisywanie klucza szyfruj¹cego - if (flag == 2 || flag == 3 || encList.size() > 0) + if (flag == flag::enc || flag == flag::ezd || encList.size() > 0) { - crypt.saveKey(catalogPath, hppKey); + eman.saveKey(catalogPath, hppKey); } return true; @@ -111,29 +112,37 @@ bool CreateCargo::GetFileList(const std::string& path) else { std::string fileRef = RemoveStartPath(PathToUnixLike(tmpPath)); - PathConf pc; - if (methodFlags > -1) + + if (fileRef.length() > 255) { - pc.path = PathToUnixLike(tmpPath); - pc.parameter = methodFlags; - filesPaths.push_back(pc); + std::cerr << "The file path is too long. It exceeds 255 characters." << std::endl; } else { - if (!FindOnTheList(ignoreList, fileRef) || !CheckFileExtension(fileRef, ignoreList)) + PathConf pc; + if (methodFlags != 0xAB) { - if (FindOnTheList(zipList, fileRef) || CheckFileExtension(fileRef, zipList)) - { - pc.parameter = FindOnTheList(encList, fileRef) || CheckFileExtension(fileRef, encList) ? 3 : 1; - } - else - { - pc.parameter = FindOnTheList(encList, fileRef) || CheckFileExtension(fileRef, encList) ? 2 : 0; - } pc.path = PathToUnixLike(tmpPath); - std::cout << pc.path << " - " << pc.parameter << std::endl; + pc.parameter = methodFlags; filesPaths.push_back(pc); } + else + { + if (!FindOnTheList(ignoreList, fileRef) || !CheckFileExtension(fileRef, ignoreList)) + { + if (FindOnTheList(zipList, fileRef) || CheckFileExtension(fileRef, zipList)) + { + pc.parameter = FindOnTheList(encList, fileRef) || CheckFileExtension(fileRef, encList) ? flag::ezd : flag::zip; + } + else + { + pc.parameter = FindOnTheList(encList, fileRef) || CheckFileExtension(fileRef, encList) ? flag::enc : flag::raw; + } + pc.path = PathToUnixLike(tmpPath); + std::cout << pc.path << " - " << pc.parameter << std::endl; + filesPaths.push_back(pc); + } + } } } } @@ -175,47 +184,13 @@ CargoHead CreateCargo::CreateCargoHead(const uint32_t& filesLen, const uint64_t& { CargoHead ch; - ch.signature = signature; - ch.version = version; - ch.files = filesLen; + ch.signature = fl::sigpak; ch.table = table; + ch.files = filesLen; return ch; } -//----------------------------------------------------------------------------- -// Sprawdza czy plik znajduje siê na liœcie -//----------------------------------------------------------------------------- -void CreateCargo::computingBytes(const int16_t& flag, std::vector& input, std::vector& output) -{ - //Flaga aktywna sprawdza czy plik jest na liœcie. Jeœli jest to zwraca surowedane - //Przeciwnie kompresuje dane - ChunkManager cm(crypt); - - switch (flag) - { - case 1: - output = cm.chunked(input, true, false); - break; - - case 2: - output = cm.chunked(input, false, true); - break; - - case 3: - output = cm.chunked(input, true, true); - break; - - case 4: - output = cm.chunked(input, false, false); - break; - - default: - output = std::move(input); - break; - } -} - //----------------------------------------------------------------------------- // Przygotowanie nag³ówków i plików //----------------------------------------------------------------------------- @@ -223,13 +198,12 @@ std::vector CreateCargo::ComputingHeadFiles() { //Utwórz header TMP. Zabezpiecza Pierwsze bajty na w³aœciwy nag³ówek CargoHead cargoHead = CreateCargoHead(0, 0); - offset += cargoHead.signature.length() + sizeof(cargoHead.version) + sizeof(cargoHead.files) + sizeof(cargoHead.table); + offset += cargoHead.signature.length() + sizeof(cargoHead.files) + sizeof(cargoHead.table); //Zapisanie tymczasowego nag³owka jako rezerwacja miejsca cargo.write(cargoHead.signature.data(), cargoHead.signature.length()); - cargo.write(reinterpret_cast(&cargoHead.version), sizeof(cargoHead.version)); - cargo.write(reinterpret_cast(&cargoHead.files), sizeof(cargoHead.files)); cargo.write(reinterpret_cast(&cargoHead.table), sizeof(cargoHead.table)); + cargo.write(reinterpret_cast(&cargoHead.files), sizeof(cargoHead.files)); std::vector filesTable; @@ -239,36 +213,108 @@ std::vector CreateCargo::ComputingHeadFiles() std::string path = PathToUnixLike(RemoveStartPath(file.path)); std::ifstream f(file.path, std::ios::binary | std::ios::ate); + std::cout << path << std::endl; + //Obliczanie rozmiaru pliku size_t size = f.tellg(); f.seekg(0, std::ios::beg); - //Wczytanie pliku do pamiêci - std::vector buffer(size); - f.read(buffer.data(), size); - f.close(); + if (size > ds::maxFileSize) + { + std::cerr << path << " is too large. It exceeds " << ds::maxFileSize / 1024 / 1024 / 1024 << "GB!" << std::endl; + } + else + { + XXH64_reset(xxhState, 0); - //Tworzenie hashu CRC - const uint64_t crc = XXH64(buffer.data(), buffer.size(), VERSION); + //Wczytanie pliku do pamiêci + std::vector buffer(ds::chunk_stream); - //Kompresjia - std::vector pakBuffer; - computingBytes(file.parameter, buffer, pakBuffer); + uint64_t sizeFile = 0; - FilesTable ft; - ft.nameFile = path; - ft.nameLen = path.length(); - ft.hashName = fnv64(path); - ft.offset = offset; - ft.size = pakBuffer.size(); - ft.flag = file.parameter; - ft.crc = crc; + const uint32_t chunkBlockSize = ds::block_size; + const uint32_t quantity = (size + chunkBlockSize) / chunkBlockSize; + const uint32_t lastChunkSize = size - (chunkBlockSize * (quantity - 1)); - cargo.write(reinterpret_cast(pakBuffer.data()), pakBuffer.size()); + // Jeœli jest ustawiona flaga inna ni¿ RAW + // Dodaj do kontenera konfiguracjê chunków + if (file.parameter != flag::raw) + { + cargo.write(reinterpret_cast(&quantity), sizeof(quantity)); + cargo.write(reinterpret_cast(&chunkBlockSize), sizeof(chunkBlockSize)); + cargo.write(reinterpret_cast(&lastChunkSize), sizeof(lastChunkSize)); + sizeFile = sizeof(quantity) + sizeof(chunkBlockSize) + sizeof(lastChunkSize); + } - filesTable.push_back(ft); - offset += pakBuffer.size(); + // Strumieniowanie danych + while (f.read(buffer.data(), ds::chunk_stream) || f.gcount() > 0) + { + const int bufferSize = f.gcount(); + buffer.resize(bufferSize); + + // Aktualizacja XXH64 + XXH64_update(xxhState, buffer.data(), buffer.size()); + + if (file.parameter == flag::raw) + { + // Zapisywanie strumienia do kontenera + cargo.write(reinterpret_cast(buffer.data()), buffer.size()); + sizeFile += bufferSize; + } + else + { + for (uint32_t ofs = 0; ofs < bufferSize; ofs += chunkBlockSize) + { + // Rozmiar chunka + const uint32_t chunkSize = std::min(chunkBlockSize, bufferSize - ofs); + + auto begin = buffer.begin() + ofs; + auto end = begin + chunkSize; + + // Skopiuj fragment danych do chunka + std::vector chunk(begin, end); + + std::vector outChunk; + + // Przetwórz chunki i przetwórz + if ((file.parameter & flag::zip) == flag::zip) + { + // Zaszyfruj i skompresuj lub tylko skompresuj + outChunk = (file.parameter & flag::enc) == flag::enc ? + eman.encrypt(cman.compress(chunk)) : cman.compress(chunk); + } + else + { + // Zaszyfruj lub skopiuj + outChunk = eman.encrypt(chunk); + } + + const uint32_t outSize = outChunk.size(); + + cargo.write(reinterpret_cast(&outSize), sizeof(outSize)); + sizeFile += sizeof(outSize); + + cargo.write(reinterpret_cast(outChunk.data()), outChunk.size()); + sizeFile += outSize; + } + } + } + + f.close(); + + FilesTable ft; + ft.nameFile = path; + ft.nameLen = path.length(); + ft.offset = offset; + ft.size = sizeFile; + ft.flag = file.parameter; + ft.crc = XXH64_digest(xxhState); + + filesTable.push_back(ft); + offset += sizeFile; + } } + return filesTable; } @@ -285,24 +331,25 @@ void CreateCargo::GetFilters(const std::string& filterFile) file.close(); // Lista plików do skompresowania - if (jslist.contains(KEY_ZIP)) + if (jslist.contains(key::zip)) { - zipList = jslist[KEY_ZIP].get>(); + zipList = jslist[key::zip].get>(); } // Lista plików do zaszyfrowania - if (jslist.contains(KEY_ENCRYPT)) + if (jslist.contains(key::enc)) { - encList = jslist[KEY_ENCRYPT].get>(); + encList = jslist[key::enc].get>(); } // Lista plików do pominiêcia - if (jslist.contains(KEY_IGNORE)) + if (jslist.contains(key::ignore)) { - ignoreList = jslist[KEY_IGNORE].get>(); + ignoreList = jslist[key::ignore].get>(); } - hppKey = jslist.value("keyhpp", false); + // Flaga tworzenia klucza jako plik nag³ówka c++ + hppKey = jslist.value(key::hpp, false); } //----------------------------------------------------------------------------- @@ -342,24 +389,6 @@ std::string CreateCargo::UpperString(std::string s) { return s; } -//----------------------------------------------------------------------------- -// Wygenerój FNV-1a HASH -//----------------------------------------------------------------------------- -uint64_t CreateCargo::fnv64(const std::string& data) -{ - const uint64_t fnvOffset = 14695981039346656037u; - const uint64_t fnvPrime = 1099511628211u; - - uint64_t hash = fnvOffset; - for (unsigned char c : data) - { - hash ^= c; - hash *= fnvPrime; - } - - return hash; -} - //----------------------------------------------------------------------------- // Trworzenie archiwum //----------------------------------------------------------------------------- @@ -386,7 +415,6 @@ bool CreateCargo::WriteCargo() cargo.write(reinterpret_cast(&head.nameLen), sizeof(head.nameLen)); cargo.write(head.nameFile.data(), head.nameLen); - cargo.write(reinterpret_cast(&head.hashName), sizeof(head.hashName)); cargo.write(reinterpret_cast(&head.offset), sizeof(head.offset)); cargo.write(reinterpret_cast(&head.size), sizeof(head.size)); cargo.write(reinterpret_cast(&head.crc), sizeof(head.crc)); @@ -401,9 +429,8 @@ bool CreateCargo::WriteCargo() //Nadpisz tymczasowy nag³ówek cargo.write(cargoHead.signature.data(), cargoHead.signature.length()); - cargo.write(reinterpret_cast(&cargoHead.version), sizeof(cargoHead.version)); - cargo.write(reinterpret_cast(&cargoHead.files), sizeof(cargoHead.files)); cargo.write(reinterpret_cast(&cargoHead.table), sizeof(cargoHead.table)); + cargo.write(reinterpret_cast(&cargoHead.files), sizeof(cargoHead.files)); cargo.close(); diff --git a/CreateCargo.h b/CreateCargo.h index e11d253..279930f 100644 --- a/CreateCargo.h +++ b/CreateCargo.h @@ -33,8 +33,8 @@ #include #include "DataStruct.h" -#include "ChunkManager.h" #include "EncryptionManager.h" +#include "CompressionManager.h" #define KEY_ZIP "compress" // Pliki do skompresowania @@ -44,10 +44,21 @@ #define ALL_FILE ".*" // Wszystkie pliki +namespace key +{ + inline constexpr std::string_view zip = "compress"; + inline constexpr std::string_view raw = "raw"; + inline constexpr std::string_view enc = "encrypt"; + inline constexpr std::string_view ignore = "ignore"; + inline constexpr std::string_view all = ".*"; + + inline constexpr std::string_view hpp = "keyhpp"; +} + struct PathConf { std::string path; - int16_t parameter; + uint8_t parameter; }; class CreateCargo { @@ -56,14 +67,15 @@ public: virtual ~CreateCargo(); // Punk wejœcia do tworzenia archivum - bool Create(const std::string&, const int16_t&); + bool Create(const std::string&, const uint8_t&); private: const std::string signature; const std::string extension; - const short version; - short methodFlags; + uint8_t methodFlags; + + XXH64_state_t* xxhState; std::string catalogPath; @@ -72,7 +84,8 @@ private: std::vector filesList; - EncryptionManager crypt; + EncryptionManager eman; + CompressionManager cman; bool hppKey; // listy wyj¹tków @@ -88,7 +101,6 @@ private: uint64_t offset; - // Tworzenie listy plików do spakowania bool GetFileList(const std::string&); @@ -110,18 +122,12 @@ private: // Wczytanie filtrów wyj¹tków void GetFilters(const std::string&); - // Sprawdza czy plik znajduje siê na liœcie - void computingBytes(const int16_t&, std::vector&, std::vector&); - // Sprawdzanie rozsze¿eñ plików bool CheckFileExtension(const std::string&, const std::vector&); // Zamieñ ca³y ci¹g na du¿e litery std::string UpperString(std::string); - // Wygenerój FNV-1a HASH - uint64_t fnv64(const std::string& data); - // ZnajdŸ wskazany element na liœcie bool FindOnTheList(const std::vector&, const std::string&); }; diff --git a/DataStruct.h b/DataStruct.h index d941faf..91bf253 100644 --- a/DataStruct.h +++ b/DataStruct.h @@ -22,55 +22,61 @@ #include #include -#define EXTENSION "pak" -#define SIGNATURE "XPAK" - -#define SIGNATURE_KEY_FILE 1497713496 // XKEY - -#define VERSION 300 - -enum StoreMethod +namespace ui { - FILTERING = -1, - RAW = 0, - COMPRESS = 1, - ENCRYPT = 2, - COMPRESSxENCRYPT = 3 -}; + inline constexpr std::string_view title = "exPak"; + inline constexpr std::string_view ver = "0.5"; +} +// Pliki +namespace fl +{ + inline constexpr std::string_view sigpak = "XPAK"; + inline constexpr std::string_view sigkey = "XKEY"; -//Prgoram title -#define PROGRAM_TITLE "eXtendet PAK" -#define PROGRAM_VERSION "v1.3" -#define PROGRAM_AUTHOR "Yanczi" -#define PROGRAM_COMPILING "16 November 2025" -#define PROGRAM_LICENSE "GNU LGPL v3" + inline constexpr std::string_view extpak = "pak"; + inline constexpr std::string_view extkey = "key"; +} -//Limity -#define MAX_FILE_SIZE 2147483648 // 2GB -#define MAX_PAK_SIZE 8796093022208 // 8TB +// Size +namespace ds +{ + // Chunki streamowania + inline constexpr uint32_t chunk_stream = 268435456; // 256MB -// Metody zapisania pliku -#define RAW_FILE 0 -#define ZIP_FILE 1 -#define CRYPT_FILE 2 -#define CRYPT_ZIP 3 + // Blok chunków + inline constexpr uint32_t block_size = 131072; // 128KB + + // Maksymalny rozmiar pliku do spakowania + inline constexpr uint64_t maxFileSize = 8589934592; // 8GB +} + +// Flagi +namespace flag +{ + inline constexpr uint8_t raw = 0x00; // Surowy plik + inline constexpr uint8_t zip = 0x0F; // Kompresja + inline constexpr uint8_t enc = 0xF0; // Szyfrowanie + inline constexpr uint8_t ezd = 0xFF; // Kompresja z szyfrowaniem + + // Flaga do aktywacji filtra zdefiniowanego w json + inline constexpr uint8_t filter = 0xAB; +} struct CargoHead { std::string signature; - int16_t version; - uint32_t files; + uint8_t version; uint64_t table; + uint32_t files; }; struct FilesTable { - int16_t nameLen; + uint8_t nameLen; std::string nameFile; - uint64_t hashName; uint64_t offset; - uint32_t size; + uint64_t size; uint64_t crc; - int16_t flag; + uint8_t flag; }; \ No newline at end of file diff --git a/EncryptionManager.cpp b/EncryptionManager.cpp index 32f533d..a44085e 100644 --- a/EncryptionManager.cpp +++ b/EncryptionManager.cpp @@ -67,9 +67,6 @@ void EncryptionManager::generateKeys() void EncryptionManager::saveKey(const std::string& path, bool hpp) { - const int sig = SIGNATURE_KEY_FILE; - const short ver = VERSION; - // Wygeneruj time stamp std::time_t now = std::time(nullptr); const int time = static_cast(now); @@ -78,14 +75,13 @@ void EncryptionManager::saveKey(const std::string& path, bool hpp) std::vector keyVec(reinterpret_cast(key.data()), reinterpret_cast(key.data()) + key.size()); - const uint64_t crcKey = XXH64(keyVec.data(), keyVec.size(), VERSION); + const uint64_t crcKey = XXH64(keyVec.data(), keyVec.size(), 0); // Zapisz ten œmietnik do pliku KEY std::ofstream file(path + ".key", std::ios::binary); if (!file) { std::cout << "Failed to save encryption key to file" << std::endl; } - file.write(reinterpret_cast(&sig), sizeof(sig)); - file.write(reinterpret_cast(&ver), sizeof(ver)); + file.write(fl::sigkey.data(), fl::sigkey.length()); file.write(reinterpret_cast(&time), sizeof(time)); file.write(reinterpret_cast(keyVec.data()), keyVec.size()); file.write(reinterpret_cast(&crcKey), sizeof(crcKey)); @@ -102,7 +98,7 @@ void EncryptionManager::saveCppHeadFile(const std::string& path) std::ofstream file(path + ".hpp"); - file << "// Plik wygenerowany przez " << PROGRAM_TITLE << " " << PROGRAM_VERSION << std::endl; + file << "// Plik wygenerowany przez " << ui::title << " " << ui::ver << std::endl; file << std::endl; file << std::endl; file << "#pragma once" << std::endl; @@ -137,17 +133,15 @@ std::string EncryptionManager::toHex(const unsigned char* data, size_t len) void EncryptionManager::loadKey(const std::string& path) { std::ifstream file(path + ".key", std::ios::binary); - - int sig; - short ver; + std::vector sig(fl::sigkey.size()); + int8_t ver; int time; // Wczytaj - file.read(reinterpret_cast(&sig), sizeof(sig)); - file.read(reinterpret_cast(&ver), sizeof(ver)); + file.read(sig.data(), sig.size()); // SprawdŸ czy plik klucza jest poprawny - if (sig != SIGNATURE_KEY_FILE || ver != VERSION) + if (std::string(sig.begin(), sig.end()) != fl::sigkey) { throw std::runtime_error("Invalid key file!"); } @@ -160,7 +154,7 @@ void EncryptionManager::loadKey(const std::string& path) file.read(reinterpret_cast(&crcKey), sizeof(crcKey)); // SprawdŸ integralnoœæ klucza - if (XXH64(keyVec.data(), keyVec.size(), VERSION) != crcKey) + if (XXH64(keyVec.data(), keyVec.size(), 0) != crcKey) { throw std::runtime_error("Key integrity error!"); } diff --git a/EncryptionManager.h b/EncryptionManager.h index c795bd7..b502b1b 100644 --- a/EncryptionManager.h +++ b/EncryptionManager.h @@ -45,6 +45,10 @@ public: void saveKey(const std::string&, bool); void loadKey(const std::string&); + // Generowanie hash BLAKE2b + //static std::array hashBlake(const std::vector&); + //static bool compareBlake(const std::vector&, const std::array&); + private: std::array key{}; bool keyReady; diff --git a/ExtractCargo.cpp b/ExtractCargo.cpp index 4b3e0be..c944347 100644 --- a/ExtractCargo.cpp +++ b/ExtractCargo.cpp @@ -22,12 +22,11 @@ ExtractCargo::ExtractCargo() :filesLen(0) , tablePosition(0) - , filesHeadsOffset(0) - , version(VERSION) - , signature(SIGNATURE) + , xxhState(XXH64_createState()) + , signature(fl::sigpak) { // TODO Auto-generated constructor stub - + XXH64_reset(xxhState, 0); } ExtractCargo::~ExtractCargo() @@ -89,7 +88,7 @@ bool ExtractCargo::Extract(const std::string& cFile) bool ExtractCargo::CheckCargoFile() { std::vector magic(signature.size()); - short cargoVer = 0; + int8_t cargoVer = 0; if (!cargoFile.is_open()) { @@ -98,73 +97,19 @@ bool ExtractCargo::CheckCargoFile() } cargoFile.read(magic.data(), magic.size()); - cargoFile.read(reinterpret_cast(&cargoVer), sizeof(cargoVer)); - cargoFile.read(reinterpret_cast(&filesLen), sizeof(filesLen)); - cargoFile.read(reinterpret_cast(&tablePosition), sizeof(tablePosition)); - if (std::string(magic.begin(), magic.end()) != signature) { std::cerr << "Error: Corrupted Cargo" << std::endl; return false; } - if (cargoVer != version) - { - std::cerr << "Error: Wrong cargo version" << std::endl; - return false; - } - - filesHeadsOffset = signature.length() + sizeof(cargoVer) + sizeof(filesLen); + // Pobierz pozycjê tablicy plików i jej rozmiar + cargoFile.read(reinterpret_cast(&tablePosition), sizeof(tablePosition)); + cargoFile.read(reinterpret_cast(&filesLen), sizeof(filesLen)); return true; } -//----------------------------------------------------------------------------- -// Sprawdzanie sumy kontrolnej -//----------------------------------------------------------------------------- -bool ExtractCargo::HashValid(const std::vector& data, const uint64_t& crc) -{ - uint64_t actualCrc = XXH64(data.data(), data.size(), VERSION); - - if (actualCrc != crc) - { - return false; - } - - return true; -} - -//----------------------------------------------------------------------------- -// Magiczna funkcja do dekompresji i deszyfracji danych -//----------------------------------------------------------------------------- -void ExtractCargo::computingBytes(const std::vector& input, std::vector& output, const int16_t& flag) -{ - ChunkManager cm(eman); - - switch (flag) - { - case 1: - output = cm.dechunked(input, true, false); - break; - - case 2: - output = cm.dechunked(input, false, true); - break; - - case 3: - output = cm.dechunked(input, true, true); - break; - - case 4: - output = cm.dechunked(input, false, false); - break; - - default: - output = input; - break; - } -} - //----------------------------------------------------------------------------- // Pobieranie nag³ówków plików //----------------------------------------------------------------------------- @@ -180,7 +125,6 @@ void ExtractCargo::LoadFilesTable() cargoFile.read(nameBuffor.data(), fhTmp.nameLen); fhTmp.nameFile = std::string(nameBuffor.begin(), nameBuffor.end()); - cargoFile.read(reinterpret_cast(&fhTmp.hashName), sizeof(fhTmp.hashName)); cargoFile.read(reinterpret_cast(&fhTmp.offset), sizeof(fhTmp.offset)); cargoFile.read(reinterpret_cast(&fhTmp.size), sizeof(fhTmp.size)); cargoFile.read(reinterpret_cast(&fhTmp.crc), sizeof(fhTmp.crc)); @@ -199,24 +143,76 @@ void ExtractCargo::ExtractingFilesFromCargo() { std::filesystem::path dir = cargoFileName.stem() / fh.nameFile; CreateDirections(dir); + + std::cout << dir.string() << std::endl; + std::ofstream file(dir, std::ios::binary); - cargoFile.seekg(fh.offset); - std::vector buffor(fh.size); - cargoFile.read(buffor.data(), fh.size); + XXH64_reset(xxhState, 0); - std::vector rawBuffor; - computingBytes(buffor, rawBuffor, fh.flag); - - if (!HashValid(rawBuffor, fh.crc)) + // Strumieñ wyci¹gaj¹cy + if (fh.flag == flag::raw) { - std::cerr << fh.nameFile << " Error: Corrupted data integration CRC" << std::endl; + for (uint64_t sc = 0; sc < fh.size; sc += ds::chunk_stream) + { + const uint32_t streamChunk = std::min(ds::chunk_stream, static_cast(fh.size - sc)); + + std::vector buffer(streamChunk); + cargoFile.read(buffer.data(), streamChunk); + XXH64_update(xxhState, buffer.data(), buffer.size()); + file.write(reinterpret_cast(buffer.data()), streamChunk); + } + } + else + { + uint32_t chunkLen; + uint32_t chunkBeforeSize; + uint32_t chunkLastSize; + + cargoFile.read(reinterpret_cast(&chunkLen), sizeof(chunkLen)); + cargoFile.read(reinterpret_cast(&chunkBeforeSize), sizeof(chunkBeforeSize)); + cargoFile.read(reinterpret_cast(&chunkLastSize), sizeof(chunkLastSize)); + + std::vector chunksString; + + // Dekompresja bloków + for (size_t i = 0; i < chunkLen; ++i) + { + // Pobierz rozmiar chunków przed i po skompresowaniem + uint32_t chunkSize = i < chunkLen - 1 ? chunkBeforeSize : chunkLastSize; + + uint32_t chunkZipSize; + cargoFile.read(reinterpret_cast(&chunkZipSize), sizeof(chunkZipSize)); + + // Pobierz blok chunka + std::vector buffer(chunkZipSize); + cargoFile.read(buffer.data(), chunkZipSize); + + std::vector rawBuffer(chunkSize); + if ((fh.flag & flag::zip) == flag::zip) + { + rawBuffer = (fh.flag & flag::enc) == flag::enc ? + cman.decompress(eman.decrypt(buffer), chunkSize) : + cman.decompress(buffer, chunkSize); + } + else + { + rawBuffer = eman.decrypt(buffer); + } + + XXH64_update(xxhState, rawBuffer.data(), rawBuffer.size()); + file.write(reinterpret_cast(rawBuffer.data()), chunkSize); + } } - file.write(reinterpret_cast(rawBuffor.data()), rawBuffor.size()); - file.close(); + + if (XXH64_digest(xxhState) != fh.crc) + { + std::cerr << dir.string() << " Error: Corrupted data integration CRC" << std::endl; + + } } std::cout << "Unpacking complete!" << std::endl; diff --git a/ExtractCargo.h b/ExtractCargo.h index 0681494..9fce5f5 100644 --- a/ExtractCargo.h +++ b/ExtractCargo.h @@ -28,11 +28,12 @@ #include #include #include +#include #include #include "DataStruct.h" -#include "ChunkManager.h" #include "EncryptionManager.h" +#include "CompressionManager.h" class ExtractCargo { public: @@ -47,9 +48,8 @@ private: uint32_t filesLen; uint64_t tablePosition; - int filesHeadsOffset; + XXH64_state_t* xxhState; - const short version; const std::string signature; std::vector filesHeads; @@ -58,7 +58,7 @@ private: std::ifstream cargoFile; EncryptionManager eman; - + CompressionManager cman; // Sprawdzenie poprawnoœci archiwum bool CheckCargoFile(); @@ -69,13 +69,7 @@ private: // Pobieranie nag³ówków plików void LoadFilesTable(); - // Sprawdzanie sumy kontrolnej - bool HashValid(const std::vector&, const uint64_t&); - // Utwórz katalog void CreateDirections(std::filesystem::path); - // Magiczna funkcja do dekompresji i deszyfracji danych - void computingBytes(const std::vector&, std::vector&, const int16_t&); - }; diff --git a/ViewCargo.cpp b/ViewCargo.cpp index d5a0df2..9b95d12 100644 --- a/ViewCargo.cpp +++ b/ViewCargo.cpp @@ -20,14 +20,7 @@ #include "ViewCargo.h" ViewCargo::ViewCargo() - :signature(SIGNATURE) - , version(VERSION) - , filesLen(0) - , tablePos(0) -{ - std::vector header = {"Comress", "Encrypt", "Path", "RefHASH"}; - list.push_back(header); -} +{} //----------------------------------------------------------------------------- // Wywo³ywanie @@ -49,28 +42,25 @@ bool ViewCargo::View(const std::string& path) } //SprawdŸ czy kontener jest prawid³owy - if (!CheckCargoFile(path)) + if (!ViewFiles(path)) { std::cerr << "Nie prawidlowa struktura kontenera Void" << std::endl; return false; } - //Pobieranie listy plików - GetFileList(path); - - //Renderowanie listy plików - RenderList(); - return true; } //----------------------------------------------------------------------------- // Sprawdzenie poprawnoœci kontenera //----------------------------------------------------------------------------- -bool ViewCargo::CheckCargoFile(const std::string& path) +bool ViewCargo::ViewFiles(const std::string& path) { - std::vector magic(signature.length()); - short cargoVer = 0; + uint64_t tabPos = 0; + uint32_t tabSize = 0; + + std::vector magic(fl::sigpak.length()); + int8_t cargoVer = 0; std::ifstream cargo(path, std::ios::binary); @@ -81,46 +71,30 @@ bool ViewCargo::CheckCargoFile(const std::string& path) } //--------------------------------------------------------------- - // Odczytywanie pierwszych 11 bajtów nag³ówka pliku - // 6 pierwszych to sygnatura - // 1 wersja kontenera - // 4 iloœæ plików w kontenerze + // Odczytywanie pierwszych 16 bajtów nag³ówka pliku + // 4 Sygnatura kontenera XPAK + // 8 Offset tablicy plików + // 4 Rozmiar tablicy plików //--------------------------------------------------------------- cargo.read(magic.data(), magic.size()); - cargo.read(reinterpret_cast(&cargoVer), sizeof(cargoVer)); - cargo.read(reinterpret_cast(&filesLen), sizeof(filesLen)); - cargo.read(reinterpret_cast(&tablePos), sizeof(tablePos)); + cargo.read(reinterpret_cast(&tabPos), sizeof(tabPos)); + cargo.read(reinterpret_cast(&tabSize), sizeof(tabSize)); //SprawdŸ czy kontener ma poprawn¹ sygnature - if (std::string(magic.begin(), magic.end()) != signature) + if (std::string(magic.begin(), magic.end()) != fl::sigpak) { std::cerr << "Error: Corrupted Cargo" << std::endl; cargo.close(); return false; } - //SprawdŸ spójnoœæ wersji kontenera - if (cargoVer != version) - { - std::cerr << "Error: Wrong cargo version" << std::endl; - cargo.close(); - return false; - } + std::cout << "ZIP" << " " << "ENC" << " " << "Path" << std::endl; - cargo.close(); + // Przeskocz do tablicy plików + cargo.seekg(tabPos); - return true; -} - -//----------------------------------------------------------------------------- -// Pobieranie listy plików z kontenera -//----------------------------------------------------------------------------- -void ViewCargo::GetFileList(const std::string& path) -{ - std::ifstream cargo(path, std::ios::binary); - cargo.seekg(tablePos); - - for (uint32_t i = 0; i < filesLen; ++i) + // Za³aduj dane o plikach + for (uint32_t i = 0; i < tabSize; ++i) { FilesTable fhTmp; cargo.read(reinterpret_cast(&fhTmp.nameLen), sizeof(fhTmp.nameLen)); @@ -129,74 +103,50 @@ void ViewCargo::GetFileList(const std::string& path) cargo.read(nameBuffor.data(), fhTmp.nameLen); fhTmp.nameFile = std::string(nameBuffor.begin(), nameBuffor.end()); - cargo.read(reinterpret_cast(&fhTmp.hashName), sizeof(fhTmp.hashName)); cargo.read(reinterpret_cast(&fhTmp.offset), sizeof(fhTmp.offset)); cargo.read(reinterpret_cast(&fhTmp.size), sizeof(fhTmp.size)); cargo.read(reinterpret_cast(&fhTmp.crc), sizeof(fhTmp.crc)); cargo.read(reinterpret_cast(&fhTmp.flag), sizeof(fhTmp.flag)); //Tworzenie wierszy tabeli - CreateTableRow(fhTmp.nameFile, fhTmp.flag, fhTmp.hashName); + ShowFile(fhTmp.nameFile, fhTmp.flag); } cargo.close(); - tui.table(list); + + return true; } //----------------------------------------------------------------------------- // Generowanie wierszy do tabeli //----------------------------------------------------------------------------- -void ViewCargo::CreateTableRow(const std::string& file, const uint8_t& zip, const uint64_t& hash) +void ViewCargo::ShowFile(const std::string& file, const uint8_t& flag) { - //Zamiania crc liczbowej na hex string - std::stringstream ss; - ss << "0x" << std::hex << std::uppercase << hash; - - //Lista - std::vector tmpList = { "[ ]", "[ ]", file, ss.str() }; - - std::vector cell; - - ftxui::Element eZip; - ftxui::Element eEnc; + std::string compresedCheck = "[ ]"; + std::string encryptedCheck = "[ ]"; // Ustawianie checkboxów - switch (zip) + switch (flag) { - case 1: - //eZip = ftxui::text(" [x] ") | ftxui::color(ftxui::Color::Cyan); - //eEnc = ftxui::text(" [ ] ") | ftxui::color(ftxui::Color::White); - tmpList[0] = "[x]"; + case flag::zip: + compresedCheck = "[x]"; break; - case 2: - tmpList[1] = "[x]"; + case flag::enc: + encryptedCheck = "[x]"; break; - case 3: - tmpList[0] = "[x]"; - tmpList[1] = "[x]"; + case flag::ezd: + compresedCheck = "[x]"; + encryptedCheck = "[x]"; break; default: - tmpList[0] = "[ ]"; - tmpList[1] = "[ ]"; + compresedCheck = "[ ]"; + encryptedCheck = "[ ]"; break; } - //Dodanie wiersza do listy - list.push_back(tmpList); -} - -//----------------------------------------------------------------------------- -// Renderowanie listy plików -//----------------------------------------------------------------------------- -void ViewCargo::RenderList() -{ - //Dodawanie wierszy do kolumn - ftxui::Element table = ftxui::vbox(std::move(filesList)); - - auto screen = ftxui::Screen::Create(ftxui::Dimension::Fit(table)); - ftxui::Render(screen, table); - screen.Print(); + // Wyœwietlanie + std::cout << compresedCheck << " " << encryptedCheck << " " << file << std::endl; } diff --git a/ViewCargo.h b/ViewCargo.h index 1ab452e..576b336 100644 --- a/ViewCargo.h +++ b/ViewCargo.h @@ -30,7 +30,6 @@ #include #include "DataStruct.h" -#include "Tui.h" class ViewCargo { public: @@ -40,19 +39,8 @@ public: bool View(const std::string&); private: - Tui tui; - const std::string signature; - const uint16_t version; - - uint32_t filesLen; - uint64_t tablePos; - std::vector filesList; - std::vector> list; - - bool CheckCargoFile(const std::string&); - void GetFileList(const std::string&); - void RenderList(); - void CreateTableRow(const std::string&, const uint8_t&, const uint64_t&); + bool ViewFiles(const std::string&); + void ShowFile(const std::string&, const uint8_t&); }; diff --git a/license/FTXUI/LICENSE.txt b/license/FTXUI/LICENSE.txt new file mode 100644 index 0000000..fe4588c --- /dev/null +++ b/license/FTXUI/LICENSE.txt @@ -0,0 +1,21 @@ +The MIT License + +Copyright (c) 2019 Arthur Sonzogni. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. \ No newline at end of file diff --git a/license/lz4/LICENSE.txt b/license/lz4/LICENSE.txt deleted file mode 100644 index 972594f..0000000 --- a/license/lz4/LICENSE.txt +++ /dev/null @@ -1,12 +0,0 @@ -This repository uses 2 different licenses : -- all files in the `lib` directory use a BSD 2-Clause license -- all other files use a GPL-2.0-or-later license, unless explicitly stated otherwise - -Relevant license is reminded at the top of each source file, -and with presence of COPYING or LICENSE file in associated directories. - -This model is selected to emphasize that -files in the `lib` directory are designed to be included into 3rd party applications, -while all other files, in `programs`, `tests` or `examples`, -are intended to be used "as is", as part of their intended scenarios, -with no intention to support 3rd party integration use cases. \ No newline at end of file diff --git a/license/zstd/LICENSE.txt b/license/zstd/LICENSE.txt new file mode 100644 index 0000000..ca66d17 --- /dev/null +++ b/license/zstd/LICENSE.txt @@ -0,0 +1,30 @@ +BSD License + +For Zstandard software + +Copyright (c) Meta Platforms, Inc. and affiliates. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + * Neither the name Facebook, nor Meta, nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \ No newline at end of file diff --git a/testx/text_file.txt b/testx/text_file.txt index ed2b7f7..02a2623 100644 --- a/testx/text_file.txt +++ b/testx/text_file.txt @@ -1,251 +1,126 @@ Nam strzelać nie kazano. - WstÄ…piÅ‚em na dziaÅ‚o - I spójrzaÅ‚em na pole; dwieÅ›cie armat grzmiaÅ‚o. - Artyleryi ruskiej ciÄ…gnÄ… siÄ™ szeregi, - Prosto, dÅ‚ugo, daleko, jako morza brzegi; - I widziaÅ‚em ich wodza: przybiegÅ‚, mieczem skinÄ…Å‚ - I jak ptak jedno skrzydÅ‚o wojska swego zwinÄ…Å‚; - Wylewa siÄ™ spod skrzydÅ‚a Å›ciÅ›niona piechota - DÅ‚ugÄ… czarnÄ… kolumnÄ…, jako lawa bÅ‚ota, - Nasypana iskrami bagnetów. Jak sÄ™py - Czarne chorÄ…gwie na Å›mierć prowadzÄ… zastÄ™py. - - Przeciw nim sterczy biaÅ‚a, wÄ…ska, zaostrzona, - Jak gÅ‚az bodzÄ…cy morze, reduta Ordona. - Sześć tylko miaÅ‚a armat; wciąż dymiÄ… i Å›wiecÄ…; - I nie tyle prÄ™dkich słów gniewne usta miecÄ…, - Nie tyle przejdzie uczuć przez duszÄ™ w rozpaczy, - Ile z tych dziaÅ‚ leciaÅ‚o bomb, kul i kartaczy. - Patrz, tam granat w sam Å›rodek kolumny siÄ™ nurza, - Jak w fale bryÅ‚a lawy, puÅ‚k dymem zachmurza; - PÄ™ka Å›ród dymu granat, szyk pod niebo leci - I ogromna Å‚ysina Å›ród kolumny Å›wieci. - - Tam kula, lecÄ…c, z dala grozi, szumi, wyje. - Ryczy jak byk przed bitwÄ…, miota siÄ™, grunt ryje; - - Już dopadÅ‚a; jak boa Å›ród kolumn siÄ™ zwija, - Pali piersiÄ…, rwie zÄ™bem, oddechem zabija. - Najstraszniejszej nie widać, lecz sÅ‚ychać po dźwiÄ™ku, - Po waleniu siÄ™ trupów, po ranionych jÄ™ku: - Gdy kolumnÄ™ od koÅ„ca do koÅ„ca przewierci, - Jak gdyby Å›rodkiem wojska przeszedÅ‚ anioÅ‚ Å›mierci. - - Gdzież jest król, co na rzezie tÅ‚umy te wyprawia? - Czy dzieli ich odwagÄ™, czy pierÅ› sam nadstawia? - Nie, on siedzi o pięćset mil na swej stolicy, - Król wielki, samowÅ‚adnik Å›wiata poÅ‚owicy; - ZmarszczyÅ‚ brwi, - i tysiÄ…ce kibitek wnet leci; - PodpisaÅ‚, - tysiÄ…c matek opÅ‚akuje dzieci; - SkinÄ…Å‚, - padajÄ… knuty od Niemna do Chiwy. - Mocarzu, jak Bóg silny, jak szatan zÅ‚oÅ›liwy, - Gdy Turków za BaÅ‚kanem twoje straszÄ… spiże, - Gdy poselstwo paryskie twoje stopy liże, - - Warszawa jedna twojej mocy siÄ™ urÄ…ga, - Podnosi na ciÄ™ rÄ™kÄ™ i koronÄ™ Å›ciÄ…ga, - KoronÄ™ Kazimierzów, Chrobrych z twojej gÅ‚owy, - BoÅ› jÄ… ukradÅ‚ i skrwawiÅ‚, synu Wasilowy! - - Car dziwi siÄ™ - ze strachu. drzÄ… Petersburczany, - Car gniewa siÄ™ - ze strachu mrÄ… jego dworzany; - Ale sypiÄ… siÄ™ wojska, których Bóg i wiara - Jest Car. - Car gniewny: umrzem, rozweselim Cara. - PosÅ‚any wódz kaukaski z siÅ‚ami pół-Å›wiata, - Wierny, czynny i sprawny - jak knut w rÄ™ku kata. - - Ura! ura! Patrz, blisko reduty, już w rowy - WalÄ… siÄ™, na faszynÄ™ kÅ‚adÄ…c swe tuÅ‚owy; - Już czerniÄ… siÄ™ na biaÅ‚ych palisadach wałów. - Jeszcze reduta w Å›rodku, jasna od wystrzałów, - Czerwieni siÄ™ nad czerniÄ…: jak w Å›rodek mrowiaka - Wrzucony motyl bÅ‚yska, - mrowie go naciska, - - ZgasÅ‚ - tak zgasÅ‚a reduta. Czyż ostatnie dziaÅ‚o - StrÄ…cone z Å‚oża w piasku paszczÄ™ zagrzebaÅ‚o? - Czy zapaÅ‚ krwiÄ… ostatni bombardyjer zalaÅ‚? - ZgasnÄ…Å‚ ogieÅ„. - Już Moskal rogatki wywalaÅ‚. - - Gdzież rÄ™czna broÅ„? - Ach, dzisiaj pracowaÅ‚a wiÄ™cej - Niż na wszystkich przeglÄ…dach za wÅ‚adzy książęcej; - ZgadÅ‚em, dlaczego milczy, - bo nieraz widziaÅ‚em - GarstkÄ™ naszych walczÄ…cÄ… z Moskali nawaÅ‚em. - Gdy godzinÄ™ woÅ‚ano dwa sÅ‚owa: pal, nabij; - Gdy oddechy dym tÅ‚umi, trud ramiona sÅ‚abi; - A wciąż grzmi rozkaz wodzów, wre żoÅ‚nierza czynność; - Na koniec bez rozkazu peÅ‚niÄ… swÄ… powinność, - Na koniec bez rozwagi, bez czucia, pamiÄ™ci, - Å»oÅ‚nierz jako mÅ‚yn palny nabija - grzmi - krÄ™ci - BroÅ„ od oka do nogi, od nogi na oko: - Aż rÄ™ka w Å‚adownicy dÅ‚ugo i gÅ‚Ä™boko - SzukaÅ‚a, nie znalazÅ‚a - i żoÅ‚nierz pobladnÄ…Å‚, - Nie znalazÅ‚szy Å‚adunku, już broniÄ… nie wÅ‚adnÄ…Å‚; - I uczuÅ‚, że go pali strzelba rozogniona; - UpuÅ›ciÅ‚ jÄ… i upadÅ‚; - nim dobijÄ…, skona. - Takem myÅ›liÅ‚, - a w szaniec nieprzyjaciół kupa - Już Å‚azÅ‚a, jak robactwo na Å›wieżego trupa. - - PociemniaÅ‚o mi w oczach - a gdym Å‚zy ocieraÅ‚, - SÅ‚yszaÅ‚em, że coÅ› do mnie mówiÅ‚ mój JeneraÅ‚. - On przez lunetÄ™ wspartÄ… na moim ramieniu - DÅ‚ugo na szturm i szaniec poglÄ…daÅ‚ w milczeniu. - Na koniec rzekÅ‚; "Stracona". - Spod lunety jego - Wymknęło siÄ™ Å‚ez kilka, - rzekÅ‚ do mnie: "Kolego, - Wzrok mÅ‚ody od szkieÅ‚ lepszy; patrzaj, tam na wale, - Znasz Ordona, czy widzisz, gdzie jest?" - "Jenerale, - Czy go znam? - Tam staÅ‚ zawsze, to dziaÅ‚o kierowaÅ‚. - Nie widzÄ™ - znajdÄ™ - dojrzÄ™! - Å›ród dymu siÄ™ schowaÅ‚: - Lecz Å›ród najgÄ™stszych kÅ‚Ä™bów dymu ileż razy - WidziaÅ‚em rÄ™kÄ™ jego, dajÄ…cÄ… rozkazy. - - WidzÄ™ go znowu, - widzÄ™ rÄ™kÄ™ - bÅ‚yskawicÄ™, - Wywija, grozi wrogom, trzyma palnÄ… Å›wiécÄ™, - BiorÄ… go - zginÄ…Å‚ - o nie, - skoczyÅ‚ w dół, - do lochów"! - "Dobrze - rzecze JeneraÅ‚ - nie odda im prochów". - - Tu blask - dym - chwila cicho - i huk jak stu gromów. - ZaćmiÅ‚o siÄ™ powietrze od ziemi wylomów, - Harmaty podskoczyÅ‚y i jak wystrzelone - ToczyÅ‚y siÄ™ na koÅ‚ach - lonty zapalone - Nie trafiÅ‚y do swoich panew. I dym wionÄ…Å‚ - Prosto ku nam; i w gÄ™stej chmurze nas ochÅ‚onÄ…Å‚. - -I nie byÅ‚o nic widać prócz granatów blasku, - +I nie byÅ‚o nic widać prócz granatów blasku I powoli dym rzedniaÅ‚, opadaÅ‚ deszcz piasku. - SpojrzaÅ‚em na redutÄ™; - waÅ‚y, palisady, - DziaÅ‚a i naszych garstka, i wrogów gromady; - Wszystko jako sen znikÅ‚o. - Tylko czarna bryÅ‚a - Ziemi nieksztaÅ‚tnej leży - rozjemcza mogiÅ‚a. - Tam i ci, co bronili, -i ci, co siÄ™ wdarli, - Pierwszy raz pokój szczery i wieczny zawarli. - Choćby cesarz Moskalom kazaÅ‚ wstać, już dusza - Moskiewska. tam raz pierwszy, cesarza nie sÅ‚usza. - Tam zagrzebane tylu set ciaÅ‚a, imiona: - Dusze gdzie? nie wiem; lecz wiem, gdzie dusza Ordona. - On bÄ™dzie Patron szaÅ„ców! - Bo dzieÅ‚o zniszczenia - W dobrej sprawie jest Å›wiÄ™te, Jak dzieÅ‚o tworzenia; - Bóg wyrzekÅ‚ sÅ‚owo staÅ„ siÄ™, Bóg i zgiÅ„ wyrzecze. - Kiedy od ludzi wiara i wolność uciecze, - Kiedy ziemiÄ™ despotyzm i duma szalona - OblejÄ…, jak Moskale redutÄ™ Ordona - - KarzÄ…c plemiÄ™ zwyciężców zbrodniami zatrute, - Bóg wysadzi tÄ™ ziemiÄ™, jak on swÄ… redutÄ™. \ No newline at end of file diff --git a/voidcmd.cpp b/voidcmd.cpp index 35e3644..22e1520 100644 --- a/voidcmd.cpp +++ b/voidcmd.cpp @@ -80,26 +80,16 @@ static bool EmptyPath(std::string path) } int main(int argc, char* argv[]) { - std::string path = ""; - - std::cout << - " 8888888b. d8888 888 d8P \n" - " 888 Y88b d88888 888 d8P \n" - " 888 888 d88P888 888 d8P \n" - " .d88b. 888 888 888 d88P d88P 888 888d88K \n" - "d8P Y8b `Y8bd8P' 8888888P\" d88P 888 8888888b \n" - "88888888 X88K 888 d88P 888 888 Y88b \n" - "Y8b. .d8\"\"8b. 888 d8888888888 888 Y88b \n" - " \"Y8888 888 888 888 d88P 888 888 Y88b\n" - << std::endl; - std::cout << "\n" << PROGRAM_VERSION << " Release " << PROGRAM_COMPILING << std::endl; - std::cout << "Author: " << PROGRAM_AUTHOR << std::endl; - std::cout << "License: " << PROGRAM_LICENSE << "\n" << std::endl; + std::cout << ui::title << std::endl << "ver. " << ui::ver << std::endl; + std::cout << "Author: Yanczi" << std::endl; + std::cout << "License: GNU LGPL v3" << "\n" << std::endl; CreateCargo cargo; ExtractCargo extract; ViewCargo viewCargo; + std::string path = ""; + for (int i = 0; i < argc; ++i) { std::string arg = argv[i]; @@ -110,7 +100,7 @@ int main(int argc, char* argv[]) { if (!EmptyPath(path)) { return 1; } - if (!cargo.Create(path, 1)) + if (!cargo.Create(path, 0x0F)) { return 1; } @@ -120,7 +110,7 @@ int main(int argc, char* argv[]) { if (arg == "-r" && i + 1 < argc) { path = argv[i + 1]; - if (!cargo.Create(path, 0)) + if (!cargo.Create(path, 0x00)) { return 1; } @@ -130,7 +120,7 @@ int main(int argc, char* argv[]) { if (arg == "-e" && i + 1 < argc) { path = argv[i + 1]; - if (!cargo.Create(path, 2)) + if (!cargo.Create(path, 0xF0)) { return 1; } @@ -140,7 +130,7 @@ int main(int argc, char* argv[]) { if (arg == "-s" && i + 1 < argc) { path = argv[i + 1]; - if (!cargo.Create(path, 3)) + if (!cargo.Create(path, 0xFF)) { return 1; } @@ -151,7 +141,7 @@ int main(int argc, char* argv[]) { { path = argv[i + 1]; if (!EmptyPath(path)) { return 1; } - if (!cargo.Create(path, -1)) + if (!cargo.Create(path, 0xAB)) { return 1; } diff --git a/voidcmd.vcxproj b/voidcmd.vcxproj index 119342f..ee82946 100644 --- a/voidcmd.vcxproj +++ b/voidcmd.vcxproj @@ -103,14 +103,14 @@ true _DEBUG;_CONSOLE;%(PreprocessorDefinitions);SODIUM_STATIC true - stdcpp17 - 3rd\ftxui\include;3rd\libsodium\include;3rd\json\include;3rd\zstd\include;3rd\xxhash\include;3rd\xxhash\include + stdcpp20 + 3rd\libsodium\include;3rd\json\include;3rd\zstd\include;3rd\xxhash\include Console true - 3rd\zstd\lib\Debug;3rd\ftxui\Debug;3rd\xxhash\lib\Debug;3rd\libsodium\x64\Debug\v143\static - ftxui-component.lib;ftxui-dom.lib;ftxui-screen.lib;libsodium.lib;zstd_static.lib;xxhash.lib + 3rd\zstd\lib\Debug;3rd\xxhash\lib\Debug;3rd\libsodium\x64\Debug\v143\static + libsodium.lib;zstd_static.lib;xxhash.lib @@ -122,33 +122,29 @@ NDEBUG;_CONSOLE;%(PreprocessorDefinitions);SODIUM_STATIC true stdcpp17 - 3rd\ftxui\include;3rd\libsodium\include;3rd\json\include;3rd\zstd\include;3rd\xxhash\include; + 3rd\libsodium\include;3rd\json\include;3rd\zstd\include;3rd\xxhash\include Console true - 3rd\zstd\lib\Release;3rd\libsodium\x64\Release\v143\static;3rd\xxhash\lib\Release;3rd\ftxui\Release - ftxui-component.lib;ftxui-dom.lib;ftxui-screen.lib;libsodium.lib;zstd_static.lib;xxhash.lib + 3rd\zstd\lib\Release;3rd\libsodium\x64\Release\v143\static;3rd\xxhash\lib\Release + libsodium.lib;zstd_static.lib;xxhash.lib - - - - diff --git a/voidcmd.vcxproj.filters b/voidcmd.vcxproj.filters index d4a64b3..4dec7bb 100644 --- a/voidcmd.vcxproj.filters +++ b/voidcmd.vcxproj.filters @@ -27,12 +27,6 @@ Pliki źródÅ‚owe - - Pliki źródÅ‚owe - - - Pliki źródÅ‚owe - Pliki źródÅ‚owe @@ -53,12 +47,6 @@ Pliki nagłówkowe - - Pliki nagłówkowe - - - Pliki nagłówkowe - Pliki nagłówkowe