yanczi/VoidArchive
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Zcalanie ręczne. Jak git nie chce po dobroci to będzie siłą

Browse source
This commit is contained in:
yanczi 2025-11-19 22:01:25 +01:00
parent 690e5278c5
commit 3bf98ba472
22 changed files with 790 additions and 457 deletions
Download patch file Download diff file Expand all files Collapse all files

14
.gitignore vendored
View file

@ -368,3 +368,17 @@ test2/
*.pak
expak/
x64/
test.*
pest2.*
*.hh
*.key
test3/
test4/
test5/
test6/
test7/
test8/
test9/
test10/
testx/
testv/

59
CompressingManager.cpp → ChunkManager.cpp
View file

@ -1,9 +1,10 @@
#include "CompressingManager.h"
#include "ChunkManager.h"
CompressingManager::CompressingManager()
ChunkManager::ChunkManager(EncryptionManager& em)
:eman(em)
{ }
CompressingManager::~CompressingManager()
ChunkManager::~ChunkManager()
{ }
//-----------------------------------------------------------------------------
@ -12,7 +13,7 @@ CompressingManager::~CompressingManager()
// Dzielenie vectora na chunki dok³adnie po 128KB
// Kompresowanie chunków bez nag³ówka
//-----------------------------------------------------------------------------
std::vector<char> CompressingManager::compress(const std::vector<char>& raw)
std::vector<char> ChunkManager::chunked(const std::vector<char>& raw, const bool& compress, const bool& encrypt)
{
//std::vector<BlockSize> blockSizes;
@ -34,25 +35,27 @@ std::vector<char> CompressingManager::compress(const std::vector<char>& raw)
// Skopiuj fragment danych do chunka
std::vector<char> chunk(begin, end);
// Obliczanie rozmiaru skompresowanego bloku
int maxZipChunkSize = LZ4_compressBound(chunkSize);
std::vector<char> outChunk;
// Buffor wyjœciowy nadpisany skompresowanymi danymi
std::vector<char> zipChunk(maxZipChunkSize);
// Kompresja
int zipSize = LZ4_compress_default(chunk.data(), zipChunk.data(), chunkSize, maxZipChunkSize);
// Zmiana rozmiaru do faktycznego rozmiaru po kompresji
zipChunk.resize(zipSize);
// 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 = zipChunk.size();
uint32_t zch = outChunk.size();
//addIntToVector<uint32_t>(compressedBlocks, chs);
lastChunkRawSize = chs;
addIntToVector<uint32_t>(compressedBlocks, zch);
compressedBlocks.insert(compressedBlocks.end(), zipChunk.begin(), zipChunk.end());
compressedBlocks.insert(compressedBlocks.end(), outChunk.begin(), outChunk.end());
blockLen++;
}
@ -60,7 +63,7 @@ std::vector<char> CompressingManager::compress(const std::vector<char>& raw)
std::vector<char> zip;
// Wstaw liczbê o iloœci bloków do vectora;
// Przekonpwertuj usigned int32 na ci¹g znkaów
//uint16_t blockLen = blockSizes .size();
// uint16_t blockLen = blockSizes .size();
addIntToVector<uint16_t>(zip, blockLen);
addIntToVector<uint32_t>(zip, maxBlockSize);
addIntToVector<uint32_t>(zip, lastChunkRawSize);
@ -76,7 +79,7 @@ std::vector<char> CompressingManager::compress(const std::vector<char>& raw)
//-----------------------------------------------------------------------------
// Dekompresja blokowa
//-----------------------------------------------------------------------------
std::vector<char> CompressingManager::decompress(const std::vector<char>& zip)
std::vector<char> ChunkManager::dechunked(const std::vector<char>& zip, const bool& compress, const bool& encrypt)
{
size_t offset = 0;
const uint16_t chunkLen = getIntFromVector<uint16_t>(zip, offset);
@ -93,23 +96,15 @@ std::vector<char> CompressingManager::decompress(const std::vector<char>& zip)
uint32_t chunkZipSize = getIntFromVector<uint32_t>(zip, offset);
// Pobierz blok chunka
std::vector<char> zipChunk(chunkZipSize);
std::memcpy(zipChunk.data(), zip.data() + offset, chunkZipSize);
std::vector<char> inChunk(chunkZipSize);
std::memcpy(inChunk.data(), zip.data() + offset, chunkZipSize);
offset += chunkZipSize;
// Jeœli flaga encrypt jest aktywna najpierw zdeszyfruj blok
std::vector<char> zipChunk = encrypt ? eman.decrypt(inChunk) : std::move(inChunk);
// Zdeklarój pusty chunk
std::vector<char> chunk(chunkSize);
// Dekompresja chunka
int sizeData = LZ4_decompress_safe(zipChunk.data(), chunk.data(), static_cast<int>(chunkZipSize), static_cast<int>(chunkSize));
if (sizeData < 0)
{
throw std::runtime_error("LZ4 Decompressing Error");
}
// Dostosowanie rozmiaru vectora po skompresowaniu
chunk.resize(sizeData);
std::vector<char> chunk = compress ? cman.decompress(zipChunk, chunkSize) : std::move(zipChunk);
// Scal chunki
chunksString.insert(chunksString.end(), chunk.begin(), chunk.end());

23
CompressingManager.h → ChunkManager.h
View file

@ -3,33 +3,30 @@
#include <vector>
#include <cstdint>
#include <cstring>
#include <lz4.h>
#include <stdexcept>
#include <algorithm>
#include <iostream>
#include "EncryptionManager.h"
#include "CompressionManager.h"
#define BLOCK_SIZE 131072 // 128KB
struct BlockSize
{
uint32_t raw;
uint32_t zip;
};
class CompressingManager
class ChunkManager
{
public:
CompressingManager();
~CompressingManager();
ChunkManager(EncryptionManager& em);
~ChunkManager();
// Kompresja danych
std::vector<char> compress(const std::vector<char>&);
std::vector<char> chunked(const std::vector<char>&, const bool&, const bool&);
// Dekompresja
std::vector<char> decompress(const std::vector<char>&);
std::vector<char> dechunked(const std::vector<char>&, const bool&, const bool&);
private:
std::vector<BlockSize> blockSizes;
EncryptionManager eman;
CompressionManager cman;
// Przekonwertuj zmienn¹ na ci¹g na vector
template <typename T>

95
CompressionManager.cpp Normal file
View file

@ -0,0 +1,95 @@
#include "CompressionManager.h"
CompressionManager::CompressionManager()
:cctx(ZSTD_createCCtx())
,dctx(ZSTD_createDCtx())
{
// Tu ustawienia pod kompresjê
const int level = COMPRESSION_LEVEL;
// Ustawienia frameless
size_t rc = 0;
// Wy³¹cza ramkê i przestawia strumieñ na czyste bloki
rc |= ZSTD_CCtx_setParameter(cctx, ZSTD_c_format, ZSTD_f_zstd1_magicless);
// Wy³¹cza sumê kontroln¹ na poziomie ramki
rc |= ZSTD_CCtx_setParameter(cctx, ZSTD_c_checksumFlag, 0);
// Wy³¹cza zapisywanie „content size” w nag³ówku ramki
rc |= ZSTD_CCtx_setParameter(cctx, ZSTD_c_contentSizeFlag, 0);
// Wy³¹cza zapisywanie identyfikatora s³ownika
rc |= ZSTD_CCtx_setParameter(cctx, ZSTD_c_dictIDFlag, 0);
// Ustawia poziom kompresji
rc |= ZSTD_CCtx_setParameter(cctx, ZSTD_c_compressionLevel, level);
if (ZSTD_isError(rc)) {
std::cerr << "ZSTD_CCtx_setParameter error" << std::endl;
ZSTD_freeCCtx(cctx);
}
/*====Tutaj Dekompresja=============================================================*/
size_t r = 0;
// Przestawia dekompresjê na czyste bloki bez nag³ówka
r |= ZSTD_DCtx_setParameter(dctx, ZSTD_d_format, ZSTD_f_zstd1_magicless);
if (ZSTD_isError(r))
{
std::cerr << "ZSTD_DCtx_setParameter error" << std::endl;
ZSTD_freeDCtx(dctx);
}
}
CompressionManager::~CompressionManager()
{
ZSTD_freeCCtx(cctx);
ZSTD_freeDCtx(dctx);
}
//-----------------------------------------------------------------------------
// Kompresja ZSTD frameless
//-----------------------------------------------------------------------------
std::vector<char> CompressionManager::compress(const std::vector<char>& input)
{
// Obs³uga pustego chunku: zwracamy pusty wynik (0 bajtów).
if (input.empty()) return {};
const size_t srcSize = input.size();
// Szacowanie rozmiaru skompresowanego vectoru
const size_t maxDst = ZSTD_compressBound(srcSize);
std::vector<char> out(maxDst);
// Faktyczna kompresja
size_t written = ZSTD_compress2(cctx, out.data(), maxDst,
input.data(), srcSize);
if (ZSTD_isError(written)) {
std::cerr << "ZSTD_compress error: " << ZSTD_getErrorName(written) << std::endl;
return {};
}
out.resize(written);
return out;
}
//-----------------------------------------------------------------------------
// Dekompresja ZSTD
//-----------------------------------------------------------------------------
std::vector<char> CompressionManager::decompress(const std::vector<char>& input, const size_t& expected)
{
std::vector<char> output(expected);
size_t dsize = ZSTD_decompressDCtx(dctx, output.data(), expected, input.data(), input.size());
if (ZSTD_isError(dsize)) {
std::cerr << "ZSTD_decompressDCtx error: " << ZSTD_getErrorName(dsize) << "\n";
return {};
}
return output;
}

29
CompressionManager.h Normal file
View file

@ -0,0 +1,29 @@
#pragma once
#include <iostream>
#include <stdexcept>
#include <algorithm>
#include <vector>
#define ZSTD_STATIC_LINKING_ONLY
#include <zstd.h>
#if ZSTD_VERSION_NUMBER < 10400
#error "Wymagane zstd >= 1.4.0 dla ZSTD_c_format / ZSTD_f_zstd1_magicless"
#endif
#define COMPRESSION_LEVEL 3
class CompressionManager
{
public:
CompressionManager();
~CompressionManager();
std::vector<char> compress(const std::vector<char>&);
std::vector<char> decompress(const std::vector<char>&, const size_t&);
private:
ZSTD_CCtx* cctx;
ZSTD_DCtx* dctx;
};

246
CreateCargo.cpp
View file

@ -20,12 +20,12 @@
#include "CreateCargo.h"
CreateCargo::CreateCargo()
:compressingFlag(false)
, filteringFlag(false)
, signature(SIGNATURE)
: signature(SIGNATURE)
, extension(EXTENSION)
, version(VERSION)
, methodFlags(0)
, offset(0)
, hppKey(false)
{
// TODO Auto-generated constructor stub
}
@ -38,12 +38,11 @@ CreateCargo::~CreateCargo() {
//-----------------------------------------------------------------------------
// Punk wejścia do tworzenia archivum
//-----------------------------------------------------------------------------
bool CreateCargo::Create(const std::string& path, bool compress, bool filters)
bool CreateCargo::Create(const std::string& path, const int16_t& flag)
{
cargoFile = path + "." + extension;
catalogPath = path;
compressingFlag = compress;
filteringFlag = filters;
methodFlags = flag;
//Sprawdzanie pakowanego kontentu
if (!std::filesystem::is_directory(path))
@ -59,9 +58,9 @@ bool CreateCargo::Create(const std::string& path, bool compress, bool filters)
}
// Pobieranie listy plików wyjątków
if (filters)
if (flag == -1)
{
std::string filterFile = path + ".txt";
std::string filterFile = path + ".json";
if (!std::filesystem::exists(filterFile))
{
std::cerr << "Error: Missing " << filterFile << " file!" << std::endl;
@ -88,6 +87,12 @@ bool CreateCargo::Create(const std::string& path, bool compress, bool filters)
return false;
}
// Zapisywanie klucza szyfruj¹cego
if (flag == 2 || flag == 3 || encList.size() > 0)
{
crypt.saveKey(catalogPath, hppKey);
}
return true;
}
@ -105,14 +110,35 @@ bool CreateCargo::GetFileList(const std::string& path)
}
else
{
if (CheckIgnorePath(tmpPath))
std::string fileRef = RemoveStartPath(PathToUnixLike(tmpPath));
PathConf pc;
if (methodFlags > -1)
{
filesList.push_back(PathToUnixLike(tmpPath));
pc.path = PathToUnixLike(tmpPath);
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) ? 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;
filesPaths.push_back(pc);
}
}
}
}
return filesList.size() > 0 ? true : false;
return filesPaths.size() > 0 ? true : false;
}
//-----------------------------------------------------------------------------
@ -160,35 +186,34 @@ CargoHead CreateCargo::CreateCargoHead(const uint32_t& filesLen, const uint64_t&
//-----------------------------------------------------------------------------
// Sprawdza czy plik znajduje się na liście
//-----------------------------------------------------------------------------
uint8_t CreateCargo::CheckFileOnTheList(const std::string& path, std::vector<char>& input, std::vector<char>& output)
void CreateCargo::computingBytes(const int16_t& flag, std::vector<char>& input, std::vector<char>& output)
{
//Flaga aktywna sprawdza czy plik jest na liście. Jeśli jest to zwraca surowedane
//Przeciwnie kompresuje dane
CompressingManager cm;
ChunkManager cm(crypt);
if (filteringFlag) {
if (FilteringData(path))
{
output = cm.compress(input);
return ZIP_FILE;
}
else
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);
return RAW_FILE;
break;
}
}
//Flaga aktywna kompresuje dane
if (compressingFlag)
{
output = cm.compress(input);
return ZIP_FILE;
}
output = std::move(input);
return RAW_FILE;
}
//-----------------------------------------------------------------------------
@ -200,7 +225,7 @@ std::vector<FilesTable> CreateCargo::ComputingHeadFiles()
CargoHead cargoHead = CreateCargoHead(0, 0);
offset += cargoHead.signature.length() + sizeof(cargoHead.version) + sizeof(cargoHead.files) + sizeof(cargoHead.table);
//Zapisanie TMP nag³owka do pliku
//Zapisanie tymczasowego nag³owka jako rezerwacja miejsca
cargo.write(cargoHead.signature.data(), cargoHead.signature.length());
cargo.write(reinterpret_cast<const char*>(&cargoHead.version), sizeof(cargoHead.version));
cargo.write(reinterpret_cast<const char*>(&cargoHead.files), sizeof(cargoHead.files));
@ -208,41 +233,41 @@ std::vector<FilesTable> CreateCargo::ComputingHeadFiles()
std::vector<FilesTable> filesTable;
//Tworzenie nag³ówków plików
for (const auto& file : filesList)
//Tworzenie nag³ówków plików jednoczeœnie zapisywanie plików
for (const auto& file : filesPaths)
{
std::string path = PathToUnixLike(RemoveStartPath(file));
std::ifstream f(file, std::ios::binary | std::ios::ate);
std::string path = PathToUnixLike(RemoveStartPath(file.path));
std::ifstream f(file.path, std::ios::binary | std::ios::ate);
//Obliczanie rozmiaru pliku
size_t size = f.tellg();
f.seekg(0, std::ios::beg);
//Wczytanie pliku do pamięci
std::vector<char> buffor(size);
f.read(buffor.data(), size);
std::vector<char> buffer(size);
f.read(buffer.data(), size);
f.close();
//Tworzenie hashu CRC
uint64_t crc = XXH64(buffor.data(), buffor.size(), VERSION);
const uint64_t crc = XXH64(buffer.data(), buffer.size(), VERSION);
//Kompresjia
std::vector<char> zip;
uint8_t method = CheckFileOnTheList(path, buffor, zip);
std::vector<char> pakBuffer;
computingBytes(file.parameter, buffer, pakBuffer);
FilesTable ft;
ft.nameFile = path;
ft.nameLen = path.length();
ft.hashName = fnv64(path);
ft.offset = offset;
ft.size = zip.size();
ft.isZip = method;
ft.size = pakBuffer.size();
ft.flag = file.parameter;
ft.crc = crc;
cargo.write(reinterpret_cast<const char*>(zip.data()), zip.size());
cargo.write(reinterpret_cast<const char*>(pakBuffer.data()), pakBuffer.size());
filesTable.push_back(ft);
offset += zip.size();
offset += pakBuffer.size();
}
return filesTable;
}
@ -254,18 +279,32 @@ void CreateCargo::GetFilters(const std::string& filterFile)
{
std::cout << "Downloading the exception list" << std::endl;
Txtpp ff(filterFile);
std::ifstream file(filterFile);
nlohmann::json jslist;
file >> jslist;
file.close();
// Lista plików do skompresowania
zipList = ff.Get(KEY_ZIP);
if (jslist.contains(KEY_ZIP))
{
zipList = jslist[KEY_ZIP].get<std::vector<std::string>>();
}
// Lista plików do zaszyfrowania
if (jslist.contains(KEY_ENCRYPT))
{
encList = jslist[KEY_ENCRYPT].get<std::vector<std::string>>();
}
// Lista plików do pominięcia
ignoreList = ff.Get(KEY_IGNORE);
if (jslist.contains(KEY_IGNORE))
{
ignoreList = jslist[KEY_IGNORE].get<std::vector<std::string>>();
}
ff.Close();
hppKey = jslist.value("keyhpp", false);
}
//-----------------------------------------------------------------------------
// Znajdź wskazany element na liście
//-----------------------------------------------------------------------------
@ -275,33 +314,23 @@ bool CreateCargo::FindOnTheList(const std::vector<std::string>& list, const std:
return it == list.end() ? false : true;
}
//-----------------------------------------------------------------------------
// Rozdzielanie paternu od œcie¿ki
//-----------------------------------------------------------------------------
void CreateCargo::ExtPatternAndPathDetection(const std::vector<std::string>& data, std::vector<std::string>& pattern, std::vector<std::string>& path)
{
for (const auto& d : data)
{
if (d.front() == '*')
{
std::string tmpPattern = d;
tmpPattern.erase(tmpPattern.begin());
pattern.push_back(UpperString(tmpPattern));
}
else
{
path.push_back(d);
}
}
}
//-----------------------------------------------------------------------------
// Sprawdzanie rozszeżeń plików
//-----------------------------------------------------------------------------
bool CreateCargo::CheckFileExtension(const std::filesystem::path& p, const std::vector<std::string>& patterns) {
std::string ext = UpperString(p.extension().string());
bool CreateCargo::CheckFileExtension(const std::string& p, const std::vector<std::string>& patterns) {
std::filesystem::path _p = p;
std::string ext = "*" + UpperString(_p.extension().string());
return FindOnTheList(patterns, ext);
for (const auto& e : patterns)
{
std::string element = UpperString(e);
if (element == ext)
{
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
@ -331,69 +360,6 @@ uint64_t CreateCargo::fnv64(const std::string& data)
return hash;
}
//-----------------------------------------------------------------------------
// Sprawdzanie czy plik znajduje siê na liœcie
//-----------------------------------------------------------------------------
bool CreateCargo::FilteringData(const std::string& path)
{
std::vector<std::string> cmPatterns;
std::vector<std::string> cmPaths;
// Rozdziel œcie¿ki i patterny na osobne listy
ExtPatternAndPathDetection(zipList, cmPatterns, cmPaths);
if (FindOnTheList(cmPatterns, ALL_FILE))
{
return true;
}
// Sprawd¿ czy istnieje plik o danym rozsze¿eniu
if (CheckFileExtension(path, cmPatterns))
{
return true;
}
// SprawdŸ czy instnieje dany plik w danej lokalizacji
if (FindOnTheList(cmPaths, path))
{
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Kasowanie z listy plików ignorow
//-----------------------------------------------------------------------------
bool CreateCargo::CheckIgnorePath(const std::string& path)
{
std::vector<std::string> igPatterns;
std::vector<std::string> igPaths;
ExtPatternAndPathDetection(ignoreList, igPatterns, igPaths);
// Sprawd¿ czy istnieje plik o danym rozsze¿eniu
if (CheckFileExtension(path, igPatterns))
{
return false;
}
// Obrubka œcierzki
// Usuwanie katalogu root
std::string cleanPath = RemoveStartPath(path);
// Przekszta³cenie œcierzki na format unixowy
std::string unixPath = PathToUnixLike(cleanPath);
// SprawdŸ czy instnieje dany plik w danej lokalizacji
if (FindOnTheList(igPaths, unixPath))
{
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Trworzenie archiwum
//-----------------------------------------------------------------------------
@ -401,7 +367,7 @@ bool CreateCargo::WriteCargo()
{
std::cout << "Packing files..." << std::endl;
uint32_t filesLen = filesList.size();
uint32_t filesLen = filesPaths.size();
//Przygotowanie nagłówków plików i przetworzenie danych
std::vector<FilesTable> filesHead = ComputingHeadFiles();
@ -424,7 +390,7 @@ bool CreateCargo::WriteCargo()
cargo.write(reinterpret_cast<const char*>(&head.offset), sizeof(head.offset));
cargo.write(reinterpret_cast<const char*>(&head.size), sizeof(head.size));
cargo.write(reinterpret_cast<const char*>(&head.crc), sizeof(head.crc));
cargo.write(reinterpret_cast<const char*>(&head.isZip), sizeof(head.isZip));
cargo.write(reinterpret_cast<const char*>(&head.flag), sizeof(head.flag));
}
//Cofnij się na początek pliku

54
CreateCargo.h
View file

@ -25,29 +25,30 @@
#include <algorithm>
#include <vector>
#include <fstream>
#include <lz4.h>
#include <stdexcept>
#include <utility>
#include <memory>
#include <string>
#include <xxhash.h>
#include <nlohmann/json.hpp>
#include "DataStruct.h"
#include "Txtpp.h"
#include "CompressingManager.h"
#include "ChunkManager.h"
#include "EncryptionManager.h"
#define COMPRESSION_LEVEL 12 // Poziom kompresji plików (3 < 12)
#define KEY_ZIP "COMPRESS" // Pliki do skompresowania
#define KEY_RAW "RAW" // Pliki które maj¹ pozostaæ w oryginalnej formie
#define KEY_IGNORE "IGNORE" // Pliki pominiête przy pakowaniu
#define KEY_CRYPT "CRYPT" // Plili które maj¹ byæ zaszyfrowane
#define KEY_ZIP "compress" // Pliki do skompresowania
#define KEY_RAW "raw" // Pliki które maj¹ pozostaæ w oryginalnej formie
#define KEY_IGNORE "ignore" // Pliki pominiête przy pakowaniu
#define KEY_ENCRYPT "encrypt" // Plili które maj¹ byæ zaszyfrowane
#define ALL_FILE ".*" // Wszystkie pliki
struct PathConf
{
std::string path;
int16_t parameter;
};
class CreateCargo {
public:
@ -55,14 +56,14 @@ public:
virtual ~CreateCargo();
// Punk wejœcia do tworzenia archivum
bool Create(const std::string&, bool, bool);
bool Create(const std::string&, const int16_t&);
private:
bool compressingFlag;
bool filteringFlag;
const std::string signature;
const std::string extension;
const uint8_t version;
const short version;
short methodFlags;
std::string catalogPath;
@ -71,11 +72,16 @@ private:
std::vector<std::string> filesList;
EncryptionManager crypt;
bool hppKey;
// listy wyj¹tków
std::vector<std::string> ignoreList;
std::vector<std::string> zipList;
std::vector<std::string> encList;
// G³ówna lista plików z parametrami
std::vector<PathConf> filesPaths;
std::ofstream cargo;
@ -101,20 +107,14 @@ private:
// Przygotowanie nag³ówków i plików
std::vector<FilesTable> ComputingHeadFiles();
// Sprawdzanie czy plik znajduje siê na liœcie
bool FilteringData(const std::string&);
// Wczytanie filtrów wyj¹tków
void GetFilters(const std::string&);
// Sprawdza czy plik znajduje siê na liœcie
uint8_t CheckFileOnTheList(const std::string&, std::vector<char>&, std::vector<char>&);
// Kasowanie z listy plików ignorow
bool CheckIgnorePath(const std::string&);
void computingBytes(const int16_t&, std::vector<char>&, std::vector<char>&);
// Sprawdzanie rozsze¿eñ plików
bool CheckFileExtension(const std::filesystem::path&, const std::vector<std::string>&);
bool CheckFileExtension(const std::string&, const std::vector<std::string>&);
// Zamieñ ca³y ci¹g na du¿e litery
std::string UpperString(std::string);
@ -122,12 +122,6 @@ private:
// Wygenerój FNV-1a HASH
uint64_t fnv64(const std::string& data);
// CRC
uint32_t crc32(const std::vector<char>&);
// Rozdzielanie paternu od œcie¿ki
void ExtPatternAndPathDetection(const std::vector<std::string>&, std::vector<std::string>&, std::vector<std::string>&);
// ZnajdŸ wskazany element na liœcie
bool FindOnTheList(const std::vector<std::string>&, const std::string&);
};

25
DataStruct.h
View file

@ -21,20 +21,29 @@
#include <cstdint>
#include <string>
#include <boost/crc.hpp>
#define EXTENSION "pak"
#define SIGNATURE "XPAK"
#define VERSION 100
#define SIGNATURE_KEY_FILE 1497713496 // XKEY
#define VERSION 300
enum StoreMethod
{
FILTERING = -1,
RAW = 0,
COMPRESS = 1,
ENCRYPT = 2,
COMPRESSxENCRYPT = 3
};
//Prgoram title
#define PROGRAM_TITLE "eXtendet PAK"
#define PROGRAM_VERSION "v1.1"
#define PROGRAM_VERSION "v1.3"
#define PROGRAM_AUTHOR "Yanczi"
#define PROGRAM_COMPILING "24 October 2025"
#define PROGRAM_COMPILING "16 November 2025"
#define PROGRAM_LICENSE "GNU LGPL v3"
//Limity
@ -50,18 +59,18 @@
struct CargoHead
{
std::string signature;
uint16_t version;
int16_t version;
uint32_t files;
uint64_t table;
};
struct FilesTable
{
uint8_t nameLen;
int16_t nameLen;
std::string nameFile;
uint64_t hashName;
uint64_t offset;
uint32_t size;
uint64_t crc;
uint8_t isZip;
int16_t flag;
};

181
EncryptionManager.cpp Normal file
View file

@ -0,0 +1,181 @@
#include "EncryptionManager.h"
EncryptionManager::EncryptionManager()
:keyReady(false)
{
if (sodium_init() < 0) {
throw std::runtime_error("libsodium init failed");
}
keyReady = false;
generateKeys();
}
std::vector<char> EncryptionManager::encrypt(const std::vector<char>& raw)
{
std::array<uint8_t, crypto_stream_chacha20_ietf_NONCEBYTES> nonce_local;
randombytes_buf(nonce_local.data(), nonce_local.size());
std::vector<char> tmp(raw.size());
if (crypto_stream_chacha20_ietf_xor_ic(
reinterpret_cast<unsigned char*>(tmp.data()),
reinterpret_cast<const unsigned char*>(raw.data()),
static_cast<uint64_t>(raw.size()),
nonce_local.data(), 0, key.data()) != 0)
{
throw std::runtime_error("crypto_stream_chacha20_ietf_xor_ic failed");
}
std::vector<char> output;
output.insert(output.end(),
reinterpret_cast<const char*>(nonce_local.data()),
reinterpret_cast<const char*>(nonce_local.data()) + nonce_local.size());
output.insert(output.end(), tmp.begin(), tmp.end());
return output;
}
void EncryptionManager::generateKeys()
{
if (keyReady) return;
//randombytes_buf(key.data(), key.size());
crypto_stream_chacha20_ietf_keygen(key.data());
keyReady = true;
}
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<int>(now);
// Wygeneruj crc kluczy
std::vector<char> keyVec(reinterpret_cast<const char*>(key.data()),
reinterpret_cast<const char*>(key.data()) + key.size());
const uint64_t crcKey = XXH64(keyVec.data(), keyVec.size(), VERSION);
// 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<const char*>(&sig), sizeof(sig));
file.write(reinterpret_cast<const char*>(&ver), sizeof(ver));
file.write(reinterpret_cast<const char*>(&time), sizeof(time));
file.write(reinterpret_cast<const char*>(keyVec.data()), keyVec.size());
file.write(reinterpret_cast<const char*>(&crcKey), sizeof(crcKey));
file.close();
if (hpp) {saveCppHeadFile(path);}
}
// Generowanie pliku nag³ówkowego CPP z kluczem i nonce
void EncryptionManager::saveCppHeadFile(const std::string& path)
{
const uint32_t keySize = crypto_stream_chacha20_ietf_KEYBYTES;
std::ofstream file(path + ".hpp");
file << "// Plik wygenerowany przez " << PROGRAM_TITLE << " " << PROGRAM_VERSION << std::endl;
file << std::endl;
file << std::endl;
file << "#pragma once" << std::endl;
file << "#include <array>" << std::endl;
file << "#include <cstdint>" << std::endl;
file << std::endl;
file << "namespace enc" << std::endl;
file << "{" << std::endl;
file << " // Klucz deszyfruj¹cy" << std::endl;
file << " const std::array<uint8_t, " << keySize << "> key{" << std::endl;
file << " " << toHex(key.data(), key.size()) << std::endl;
file << " };" << std::endl;
file << std::endl;
file << "} //namespace" << std::endl;
file.close();
}
std::string EncryptionManager::toHex(const unsigned char* data, size_t len)
{
std::ostringstream oss;
oss << std::hex << std::setfill('0');
for (size_t i = 0; i < len; ++i) {
oss << "0x" << std::setw(2) << static_cast<int>(data[i]);
if (i + 1 != len) oss << ", ";
if ((i + 1) % 12 == 0 && i + 1 != len) oss << "\n ";
}
return oss.str();
}
// Wczytaj klucz
void EncryptionManager::loadKey(const std::string& path)
{
std::ifstream file(path + ".key", std::ios::binary);
int sig;
short ver;
int time;
// Wczytaj
file.read(reinterpret_cast<char*>(&sig), sizeof(sig));
file.read(reinterpret_cast<char*>(&ver), sizeof(ver));
// SprawdŸ czy plik klucza jest poprawny
if (sig != SIGNATURE_KEY_FILE || ver != VERSION)
{
throw std::runtime_error("Invalid key file!");
}
std::vector<char> keyVec(key.size());
uint64_t crcKey;
file.read(reinterpret_cast<char*>(&time), sizeof(time));
file.read(keyVec.data(), keyVec.size());
file.read(reinterpret_cast<char*>(&crcKey), sizeof(crcKey));
// Sprawd٠integralnoϾ klucza
if (XXH64(keyVec.data(), keyVec.size(), VERSION) != crcKey)
{
throw std::runtime_error("Key integrity error!");
}
file.close();
// Przekonwertuj vector na array
key = toArray<crypto_stream_chacha20_ietf_KEYBYTES>(keyVec);
}
// Deszyfracja
std::vector<char> EncryptionManager::decrypt(const std::vector<char>& crypt)
{
const size_t cryptoSize = crypto_stream_chacha20_ietf_NONCEBYTES;
std::array<uint8_t, cryptoSize> nonce_local;
std::memcpy(nonce_local.data(),
reinterpret_cast<const uint8_t*>(crypt.data()), cryptoSize);
const size_t rawSize = crypt.size() - cryptoSize;
std::vector<char> tmp(rawSize);
std::memcpy(tmp.data(), crypt.data() + cryptoSize, rawSize);
std::vector<char> raw(rawSize);
if (crypto_stream_chacha20_ietf_xor(
reinterpret_cast<unsigned char*>(raw.data()),
reinterpret_cast<const unsigned char*>(tmp.data()),
static_cast<unsigned long long>(tmp.size()),
nonce_local.data(), key.data()) != 0)
{
throw std::runtime_error("Data decryption error!");
}
return raw;
}

47
EncryptionManager.h Normal file
View file

@ -0,0 +1,47 @@
#pragma once
#include <sodium.h>
#include <vector>
#include <array>
#include <stdexcept>
#include <fstream>
#include <ctime>
#include <iostream>
#include <xxhash.h>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include "DataStruct.h"
class EncryptionManager
{
public:
EncryptionManager();
~EncryptionManager() = default;
std::vector<char> encrypt(const std::vector<char>&);
std::vector<char> decrypt(const std::vector<char>&);
void saveKey(const std::string&, bool);
void loadKey(const std::string&);
private:
std::array<unsigned char, crypto_stream_chacha20_ietf_KEYBYTES> key{};
bool keyReady;
void generateKeys();
std::string toHex(const unsigned char*, size_t);
void saveCppHeadFile(const std::string&);
template <size_t N>
std::array<unsigned char, N> toArray(const std::vector<char>& vec) {
if (vec.size() < N) {
throw std::runtime_error("Too small vector to convert to array");
}
std::array<unsigned char, N> arr{};
std::memcpy(arr.data(), vec.data(), N);
return arr;
}
};

53
ExtractCargo.cpp
View file

@ -45,6 +45,8 @@ bool ExtractCargo::Extract(const std::string& cFile)
{
cargoFileName = cFile;
std::cout << "START EXTRACT " << cFile << std::endl;
//Sprawdź czy plik istnieje
if (!std::filesystem::exists(cargoFileName))
{
@ -59,6 +61,14 @@ bool ExtractCargo::Extract(const std::string& cFile)
return false;
}
// Wczytaj klucz deszyfruj¹cy
std::filesystem::path kdir = cargoFileName.stem();
if (std::filesystem::exists(kdir.string() + ".key"))
{
std::cout << "Decryption key detected" << std::endl;
eman.loadKey(kdir.string());
}
//Otwieranie kontenera
cargoFile.open(cargoFileName, std::ios::binary);
@ -79,7 +89,7 @@ bool ExtractCargo::Extract(const std::string& cFile)
bool ExtractCargo::CheckCargoFile()
{
std::vector<char> magic(signature.size());
uint16_t cargoVer = 0;
short cargoVer = 0;
if (!cargoFile.is_open())
{
@ -92,8 +102,6 @@ bool ExtractCargo::CheckCargoFile()
cargoFile.read(reinterpret_cast<char*>(&filesLen), sizeof(filesLen));
cargoFile.read(reinterpret_cast<char*>(&tablePosition), sizeof(tablePosition));
std::cout << std::string(magic.begin(), magic.end()) << std::endl;
if (std::string(magic.begin(), magic.end()) != signature)
{
std::cerr << "Error: Corrupted Cargo" << std::endl;
@ -126,13 +134,43 @@ bool ExtractCargo::HashValid(const std::vector<char>& data, const uint64_t& crc)
return true;
}
//-----------------------------------------------------------------------------
// Magiczna funkcja do dekompresji i deszyfracji danych
//-----------------------------------------------------------------------------
void ExtractCargo::computingBytes(const std::vector<char>& input, std::vector<char>& 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
//-----------------------------------------------------------------------------
void ExtractCargo::LoadFilesTable()
{
cargoFile.seekg(tablePosition);
for (uint32_t i = 0; i < filesLen; ++i)
{
FilesTable fhTmp;
@ -146,7 +184,7 @@ void ExtractCargo::LoadFilesTable()
cargoFile.read(reinterpret_cast<char*>(&fhTmp.offset), sizeof(fhTmp.offset));
cargoFile.read(reinterpret_cast<char*>(&fhTmp.size), sizeof(fhTmp.size));
cargoFile.read(reinterpret_cast<char*>(&fhTmp.crc), sizeof(fhTmp.crc));
cargoFile.read(reinterpret_cast<char*>(&fhTmp.isZip), sizeof(fhTmp.isZip));
cargoFile.read(reinterpret_cast<char*>(&fhTmp.flag), sizeof(fhTmp.flag));
filesHeads.push_back(fhTmp);
}
@ -157,8 +195,6 @@ void ExtractCargo::LoadFilesTable()
//-----------------------------------------------------------------------------
void ExtractCargo::ExtractingFilesFromCargo()
{
CompressingManager cm;
for (const auto& fh : filesHeads)
{
std::filesystem::path dir = cargoFileName.stem() / fh.nameFile;
@ -170,7 +206,8 @@ void ExtractCargo::ExtractingFilesFromCargo()
cargoFile.read(buffor.data(), fh.size);
std::vector<char> rawBuffor = fh.isZip ? cm.decompress(buffor) : buffor;
std::vector<char> rawBuffor;
computingBytes(buffor, rawBuffor, fh.flag);
if (!HashValid(rawBuffor, fh.crc))
{

11
ExtractCargo.h
View file

@ -31,7 +31,8 @@
#include <xxhash.h>
#include "DataStruct.h"
#include "CompressingManager.h"
#include "ChunkManager.h"
#include "EncryptionManager.h"
class ExtractCargo {
public:
@ -46,9 +47,9 @@ private:
uint32_t filesLen;
uint64_t tablePosition;
uint8_t filesHeadsOffset;
int filesHeadsOffset;
const uint8_t version;
const short version;
const std::string signature;
std::vector<FilesTable> filesHeads;
@ -56,6 +57,7 @@ private:
std::ifstream cargoFile;
EncryptionManager eman;
// Sprawdzenie poprawnoœci archiwum
@ -73,4 +75,7 @@ private:
// Utwórz katalog
void CreateDirections(std::filesystem::path);
// Magiczna funkcja do dekompresji i deszyfracji danych
void computingBytes(const std::vector<char>&, std::vector<char>&, const int16_t&);
};

4
README.md
View file

@ -89,9 +89,11 @@
**libsodium - https://github.com/jedisct1/libsodium**
**xxHash - https://github.com/Cyan4973/xxHash.git**
**LZ4 - https://github.com/lz4/lz4.git**
**Zstd - https://github.com/facebook/zstd.git**
**FTXUI - https://github.com/ArthurSonzogni/FTXUI.git**

47
TimeStamp.h Normal file
View file

@ -0,0 +1,47 @@
#pragma once
#include <cstdint>
#include <ctime>
class TimeStamp
{
public:
TimeStamp()
:time(std::time(nullptr))
{}
~TimeStamp() = default;
uint32_t get()
{
#if defined(_WIN32) localtime_s(&lt, &time);
#else localtime_r(&lt, &time);
#endif
uint16_t d = dosDate(lt);
uint16_t t = dosTime(lt);
uint32_t combined = ((uint32_t)d << 16) | t;
return combined;
}
private:
std::time_t time;
std::tm lt{};
uint16_t dosDate(const std::tm& t)
{
int year = t.tm_year + 1900;
int y = (year >= 1980) ? (year - 1980) : 0;
int m = t.tm_mon + 1;
int d = t.tm_mday;
return static_cast<uint16_t>((y << 9) | (m << 5) | d);
}
uint16_t dosTime(const std::tm& t)
{
int h = t.tm_hour;
int min = t.tm_min;
int s2 = t.tm_sec / 2;
return static_cast<uint16_t>((h << 11) | (min << 5) | s2);
}
};

174
Txtpp.h
View file

@ -1,174 +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 <https://www.gnu.org/licenses/>.
*/
#pragma once
#include <fstream>
#include <string>
#include <vector>
#include <filesystem>
#include <sstream>
#include <algorithm>
#include <cctype>
class Txtpp {
public:
Txtpp(const std::string& path = "")
{
if (path != "")
{
Load(path);
}
}
~Txtpp()
{
if (file.is_open())
{
file.close();
}
}
bool Load(const std::string& path)
{
if (!std::filesystem::exists(path))
{
return false;
}
file.open(path);
return file.is_open();
}
void Close()
{
file.close();
}
std::vector<std::string> Get(const std::string& key)
{
std::vector<std::string> tmp;
Parse(key, tmp);
return tmp;
}
template <typename T>
T getValue(const std::string& key, const std::string& val)
{
std::vector<std::string> tmp;
Parse(key, tmp);
for (const auto& line : tmp)
{
std::string cleanLine = RemoveSpaces(line);
std::string t;
std::string v;
bool tv = false;
for (const char& c : cleanLine)
{
if (c != ":") {tv = true;}
if (!tv) { t += c; }
else { v += c; }
}
}
return tmp;
}
private:
const char sectionStart = '{';
const char sectionEnd = '}';
std::ifstream file;
//-----------------------------------------------------------------------------
// Wyszukiwanie danych po kluczu
//-----------------------------------------------------------------------------
void Parse(const std::string& key, std::vector<std::string>& data)
{
std::string fullkey = sectionStart + key + sectionEnd;
std::string line;
bool wr = false;
file.clear();
file.seekg(std::ios::beg);
while (getline(file, line))
{
std::string tmp = RemoveSpaces(line);
if (tmp != "")
{
if (CheckKey(tmp))
{
wr = UpperString(tmp) == fullkey ? true : false;
}
else
{
if (wr) { data.push_back(tmp); }
}
}
}
}
//-----------------------------------------------------------------------------
// Usuwa spacje
//-----------------------------------------------------------------------------
std::string RemoveSpaces(std::string _line)
{
std::stringstream ss(_line);
char word;
std::string tmp;
std::string beforeWord = "";
while (ss >> word)
{
tmp += word;
}
return tmp;
}
//-----------------------------------------------------------------------------
// Sprawdza czy dany ci¹g jest kluczem
//-----------------------------------------------------------------------------
bool CheckKey(std::string key)
{
if (key[0] == sectionStart && key[key.length() - 1])
{
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Zamieñ ca³y ci¹g na du¿e litery
//-----------------------------------------------------------------------------
std::string UpperString(std::string s) {
std::transform(s.begin(), s.end(), s.begin(),
[](unsigned char c) { return static_cast<char>(std::toupper(c)); });
return s;
}
};

35
ViewCargo.cpp
View file

@ -58,7 +58,8 @@ bool ViewCargo::View(const std::string& path)
//Table Header
std::vector<ftxui::Element> headElements;
headElements.push_back(ftxui::text(" Zip ") | ftxui::bold);
headElements.push_back(ftxui::text(" Compressed ") | ftxui::bold);
headElements.push_back(ftxui::text(" Encrypted ") | ftxui::bold);
headElements.push_back(ftxui::text("Nazwa pliku") | ftxui::bold | ftxui::size(ftxui::WIDTH, ftxui::EQUAL, 56));
headElements.push_back(ftxui::text("Hash Name") | ftxui::bold | ftxui::size(ftxui::WIDTH, ftxui::EQUAL, 20));
@ -80,7 +81,7 @@ bool ViewCargo::View(const std::string& path)
bool ViewCargo::CheckCargoFile(const std::string& path)
{
std::vector<char> magic(signature.length());
uint16_t cargoVer = 0;
short cargoVer = 0;
std::ifstream cargo(path, std::ios::binary);
@ -143,10 +144,10 @@ void ViewCargo::GetFileList(const std::string& path)
cargo.read(reinterpret_cast<char*>(&fhTmp.offset), sizeof(fhTmp.offset));
cargo.read(reinterpret_cast<char*>(&fhTmp.size), sizeof(fhTmp.size));
cargo.read(reinterpret_cast<char*>(&fhTmp.crc), sizeof(fhTmp.crc));
cargo.read(reinterpret_cast<char*>(&fhTmp.isZip), sizeof(fhTmp.isZip));
cargo.read(reinterpret_cast<char*>(&fhTmp.flag), sizeof(fhTmp.flag));
//Tworzenie wierszy tabeli
CreateTableRow(fhTmp.nameFile, fhTmp.isZip, fhTmp.hashName);
CreateTableRow(fhTmp.nameFile, fhTmp.flag, fhTmp.hashName);
}
cargo.close();
@ -164,19 +165,35 @@ void ViewCargo::CreateTableRow(const std::string& file, const uint8_t& zip, cons
std::vector<ftxui::Element> cell;
ftxui::Element eZip;
ftxui::Element eEnc;
//Dodawanie check boxa czy plik jest spakowany czy nie
if (zip == 1)
// Ustawianie checkboxów
switch (zip)
{
case 1:
eZip = ftxui::text(" [x] ") | ftxui::color(ftxui::Color::Cyan);
}
else
{
eEnc = ftxui::text(" [ ] ") | ftxui::color(ftxui::Color::White);
break;
case 2:
eZip = ftxui::text(" [ ] ") | ftxui::color(ftxui::Color::White);
eEnc = ftxui::text(" [x] ") | ftxui::color(ftxui::Color::Cyan);
break;
case 3:
eZip = ftxui::text(" [x] ") | ftxui::color(ftxui::Color::Cyan);
eEnc = ftxui::text(" [x] ") | ftxui::color(ftxui::Color::Cyan);
break;
default:
eZip = ftxui::text(" [ ] ") | ftxui::color(ftxui::Color::White);
eEnc = ftxui::text(" [ ] ") | ftxui::color(ftxui::Color::White);
break;
}
//Dodawanie komurek
cell.push_back(eZip);
cell.push_back(eEnc | ftxui::size(ftxui::WIDTH, ftxui::EQUAL, 7));
cell.push_back(ftxui::text(file) | ftxui::size(ftxui::WIDTH, ftxui::EQUAL, 56));
cell.push_back(ftxui::text(ss.str()) | ftxui::size(ftxui::WIDTH, ftxui::EQUAL, 20));

19
license/libsodium/LICENSE.txt Normal file
View file

@ -0,0 +1,19 @@
/*
* ISC License
*
* Copyright (c) 2013-2025
* Frank Denis <j at pureftpd dot org>
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

26
license/xxhash/LICENSE.txt Normal file
View file

@ -0,0 +1,26 @@
xxHash Library
Copyright (c) 2012-2021 Yann Collet
All rights reserved.
BSD 2-Clause License (https://www.opensource.org/licenses/bsd-license.php)
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.
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.

53
voidcmd.cpp
View file

@ -40,34 +40,35 @@ void RenderHelp()
const std::string HelpInstruction =
"pakcmd <parametr> <catalog> \n"
" \n"
" -c Pack and compress with LZ4 \n"
" -p Pack files from the specified directory \n"
" -e Pack and encrypted from the specified directory \n"
" -f Pack the files according to the guidelines given in the <directory>.txt \n"
" -c Compressing \n"
" -r Raw files \n"
" -e Encrypted \n"
" -s Compressing and Encrypted \n"
" -f Pack the files according to the guidelines given in the <directory>.json \n"
" \n"
"Extracting: \n"
" -x Extract files from the specified container \n"
" \n"
"Others: \n"
" -ls List files stored in a container \n"
" \n"
" \n"
"<catalog>.txt \n"
"<catalog>.json \n"
" \n"
"Keys: \n"
" \n"
" {compress} - Compressing files \n"
" {crypt} - Encrypted files with AES256 \n"
" {crypt} - Encrypted files \n"
" {ignore} - Ignoring concrete files \n"
" \n"
" /path/to/file.ext - Concrete file \n"
" *.ext - All files with concrete extension \n"
" *.* - All files !NOT WORKING WITH {ignore} KEY! \n"
" \n";
" *.* - All files !NOT WORKING WITH {ignore} KEY! \n";
Interface tui;
tui.TextBorder(HelpTitle, HelpInstruction);
//Interface tui;
//tui.TextBorder(HelpTitle, HelpInstruction);
}
bool EmptyPath(std::string path)
static bool EmptyPath(std::string path)
{
if (path == "")
{
@ -109,17 +110,37 @@ int main(int argc, char* argv[]) {
if (!EmptyPath(path)) { return 1; }
if (!cargo.Create(path, true, false))
if (!cargo.Create(path, 1))
{
return 1;
}
i++;
}
if (arg == "-p" && i + 1 < argc)
if (arg == "-r" && i + 1 < argc)
{
path = argv[i + 1];
if (!cargo.Create(path, false, false))
if (!cargo.Create(path, 0))
{
return 1;
}
i++;
}
if (arg == "-e" && i + 1 < argc)
{
path = argv[i + 1];
if (!cargo.Create(path, 2))
{
return 1;
}
i++;
}
if (arg == "-s" && i + 1 < argc)
{
path = argv[i + 1];
if (!cargo.Create(path, 3))
{
return 1;
}
@ -130,7 +151,7 @@ int main(int argc, char* argv[]) {
{
path = argv[i + 1];
if (!EmptyPath(path)) { return 1; }
if (!cargo.Create(path, false, true))
if (!cargo.Create(path, -1))
{
return 1;
}

21
voidcmd.vcxproj
View file

@ -104,13 +104,13 @@
<PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<LanguageStandard>stdcpp17</LanguageStandard>
<AdditionalIncludeDirectories>3rd\crc\include;3rd\ftxui\include;3rd\lz4\include</AdditionalIncludeDirectories>
<AdditionalIncludeDirectories>3rd\ftxui\include;3rd\libsodium\include;3rd\json\include;3rd\zstd\include;3rd\xxhash\include;3rd\xxhash\include</AdditionalIncludeDirectories>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
<AdditionalLibraryDirectories>3rd\ftxui\Debug;3rd\lz4\lib</AdditionalLibraryDirectories>
<AdditionalDependencies>liblz4_static.lib;ftxui-component.lib;ftxui-dom.lib;ftxui-screen.lib</AdditionalDependencies>
<AdditionalLibraryDirectories>3rd\zstd\lib\Debug;3rd\ftxui\Debug;3rd\xxhash\lib\Debug;3rd\libsodium\lib\Debug</AdditionalLibraryDirectories>
<AdditionalDependencies>ftxui-component.lib;ftxui-dom.lib;ftxui-screen.lib;libsodium.lib;zstd_static.lib;xxhash.lib</AdditionalDependencies>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
@ -122,30 +122,33 @@
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<LanguageStandard>stdcpp17</LanguageStandard>
<AdditionalIncludeDirectories>3rd\crc\include;3rd\ftxui\include;3rd\lz4\include</AdditionalIncludeDirectories>
<AdditionalIncludeDirectories>3rd\ftxui\include;3rd\libsodium\include;3rd\json\include;3rd\zstd\include;3rd\xxhash\include;</AdditionalIncludeDirectories>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
<AdditionalLibraryDirectories>3rd\ftxui\Release;3rd\lz4\lib</AdditionalLibraryDirectories>
<AdditionalDependencies>liblz4_static.lib;ftxui-component.lib;ftxui-dom.lib;ftxui-screen.lib</AdditionalDependencies>
<AdditionalLibraryDirectories>3rd\zstd\lib\Release;3rd\libsodium\lib\Release;3rd\xxhash\lib\Release;3rd\ftxui\Release</AdditionalLibraryDirectories>
<AdditionalDependencies>ftxui-component.lib;ftxui-dom.lib;ftxui-screen.lib;libsodium.lib;zstd_static.lib;xxhash.lib</AdditionalDependencies>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="CompressingManager.cpp" />
<ClCompile Include="ChunkManager.cpp" />
<ClCompile Include="CompressionManager.cpp" />
<ClCompile Include="CreateCargo.cpp" />
<ClCompile Include="EncryptionManager.cpp" />
<ClCompile Include="ExtractCargo.cpp" />
<ClCompile Include="Interface.cpp" />
<ClCompile Include="ViewCargo.cpp" />
<ClCompile Include="voidcmd.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="CompressingManager.h" />
<ClInclude Include="ChunkManager.h" />
<ClInclude Include="CompressionManager.h" />
<ClInclude Include="CreateCargo.h" />
<ClInclude Include="DataStruct.h" />
<ClInclude Include="EncryptionManager.h" />
<ClInclude Include="ExtractCargo.h" />
<ClInclude Include="Interface.h" />
<ClInclude Include="Txtpp.h" />
<ClInclude Include="ViewCargo.h" />
</ItemGroup>
<ItemGroup>

25
voidcmd.vcxproj.filters
View file

@ -27,13 +27,16 @@
<ClCompile Include="ViewCargo.cpp">
<Filter>Pliki źródłowe</Filter>
</ClCompile>
<ClCompile Include="xxhash.c">
<Filter>Pliki źródłowe</Filter>
</ClCompile>
<ClCompile Include="Interface.cpp">
<Filter>Pliki źródłowe</Filter>
</ClCompile>
<ClCompile Include="CompressingManager.cpp">
<ClCompile Include="ChunkManager.cpp">
<Filter>Pliki źródłowe</Filter>
</ClCompile>
<ClCompile Include="EncryptionManager.cpp">
<Filter>Pliki źródłowe</Filter>
</ClCompile>
<ClCompile Include="CompressionManager.cpp">
<Filter>Pliki źródłowe</Filter>
</ClCompile>
</ItemGroup>
@ -47,19 +50,19 @@
<ClInclude Include="ViewCargo.h">
<Filter>Pliki nagłówkowe</Filter>
</ClInclude>
<ClInclude Include="Txtpp.h">
<Filter>Pliki nagłówkowe</Filter>
</ClInclude>
<ClInclude Include="DataStruct.h">
<Filter>Pliki nagłówkowe</Filter>
</ClInclude>
<ClInclude Include="xxhash.h">
<Filter>Pliki nagłówkowe</Filter>
</ClInclude>
<ClInclude Include="Interface.h">
<Filter>Pliki nagłówkowe</Filter>
</ClInclude>
<ClInclude Include="CompressingManager.h">
<ClInclude Include="ChunkManager.h">
<Filter>Pliki nagłówkowe</Filter>
</ClInclude>
<ClInclude Include="EncryptionManager.h">
<Filter>Pliki nagłówkowe</Filter>
</ClInclude>
<ClInclude Include="CompressionManager.h">
<Filter>Pliki nagłówkowe</Filter>
</ClInclude>
</ItemGroup>

BIN
xxhash.dll Normal file
View file

Binary file not shown.