ifs.seekg(0, std::ios::end);

std::streampos sz = ifs.tellg();

ifs.seekg(0, std::ios::beg);

if (sz < 0) return false;

out.resize(static_cast<size_t>(sz));

ifs.read(out.data(), static_cast<std::streamsize>(out.size()));

return ifs.good();

std::ifstream ifs(filePath, std::ios::binary);

if (!ifs) return false;

return readAll(ifs, data);

std::ofstream ofs(filePath, std::ios::binary);

if (!ofs) return false;

ofs.write(data.data(), static_cast<std::streamsize>(data.size()));

return ofs.good();

auto now = std::chrono::high_resolution_clock::now().time_since_epoch().count();

fs::path p = fs::temp_directory_path() / ("enc_" + std::to_string(now) + extension);

return p.string();

std::string tempZipPath = getTempFilePath(".zip");

#if defined(_WIN32)

std::string redirect = " >nul 2>&1";

#else

std::string redirect = " >/dev/null 2>&1";

#endif

// zip با پسورد

// نکته: اگر می‌خواهید AES در zip باشد: -mem=AES256

std::string cmd = "7z a -tzip -p" + zipPassword + " \"" + tempZipPath + "\" \"" + inputPath + "\"" + redirect;

int ret = std::system(cmd.c_str());

if (ret != 0) return "";

return tempZipPath;

fs::create_directories(outputPath);

#if defined(_WIN32)

std::string redirect = " >nul 2>&1";

#else

std::string redirect = " >/dev/null 2>&1";

#endif

std::string cmd = "7z x -tzip -p" + zipPassword + " \"" + archivePath + "\" -o\"" + outputPath + "\" -y" + redirect;

int ret = std::system(cmd.c_str());

return (ret == 0);

static const char* digits = "0123456789abcdef";

std::string s; s.resize(len * 2);

for (size_t i = 0; i < len; ++i) {

s[2*i] = digits[(buf[i] >> 4) & 0xF];

s[2*i+1] = digits[(buf[i] ) & 0xF];

}

return s;

unsigned char hash[SHA256_DIGEST_LENGTH];

// برای domain-separation می‌توانید به‌جای key، "kid:"+key را هش کنید

SHA256(reinterpret_cast<const unsigned char*>(key.data()), key.size(), hash);

return toHex(hash, SHA256_DIGEST_LENGTH);

std::ofstream ofs(outPath, std::ios::binary);

if (!ofs) return false;

ofs << "ENCLIBv1\n";

ofs << "KID:" << keyIdHex << "\n";

ofs << "\n"; // delimiter

ofs.write(payload.data(), static_cast<std::streamsize>(payload.size()));

return ofs.good();

std::ifstream ifs(inPath, std::ios::binary);

if (!ifs) return false;

std::string line1;

if (!std::getline(ifs, line1)) return false;

if (line1 != "ENCLIBv1") return false;

std::string line2;

if (!std::getline(ifs, line2)) return false;

if (line2.rfind("KID:", 0) != 0) return false;

keyIdHexOut = line2.substr(4);

// خط خالی جداکننده

std::string empty;

if (!std::getline(ifs, empty)) return false;

// بقیه فایل = payload

payloadOut.assign(std::istreambuf_iterator<char>(ifs), std::istreambuf_iterator<char>());

return true;

keys.clear();

std::ifstream f(keysFilePath);

if (!f) return false;

std::string line;

while (std::getline(f, line)) {

// حذف spaceهای ابتدا/انتها

size_t a = line.find_first_not_of(" \t\r\n");

size_t b = line.find_last_not_of(" \t\r\n");

if (a == std::string::npos || b == std::string::npos) continue;

std::string k = line.substr(a, b - a + 1);

if (!k.empty()) keys.push_back(k);

}

// حذف تکراری‌ها بر اساس keyId

dedupeKeysById(keys);

return true;

std::unordered_set<std::string> seen;

std::vector<std::string> out;

out.reserve(keys.size());

for (auto& k : keys) {

std::string id = computeKeyIdHex(k);

if (seen.insert(id).second) out.push_back(k);

}

keys.swap(out);

std::vector<std::string> keys;

(void)loadKeysFile(keysFilePath, keys);

std::ofstream ofs(keysFilePath, std::ios::trunc);

size_t remain = 0;

for (auto& k : keys) {

if (computeKeyIdHex(k) == keyIdHex) continue; // حذف

ofs << k << "\n";

++remain;

}

return remain;

if (key.empty()) return;

size_t n = data.size(), m = key.size();

for (size_t i = 0; i < n; ++i) data[i] ^= key[i % m];

unsigned char keyBytes[32] = {0};

unsigned char iv[16] = {0};

std::memcpy(keyBytes, key.data(), std::min<size_t>(key.size(), 32));

EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();

if (!ctx) return;

if (EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, keyBytes, iv) != 1) { EVP_CIPHER_CTX_free(ctx); return; }

int outLen = static_cast<int>(data.size()) + EVP_CIPHER_block_size(EVP_aes_256_cbc());

std::vector<char> out(outLen);

int n1 = 0, n2 = 0;

if (EVP_EncryptUpdate(ctx,

reinterpret_cast<unsigned char*>(out.data()), &n1,

reinterpret_cast<const unsigned char*>(data.data()), static_cast<int>(data.size())) != 1) { EVP_CIPHER_CTX_free(ctx); return; }

if (EVP_EncryptFinal_ex(ctx, reinterpret_cast<unsigned char*>(out.data()) + n1, &n2) != 1) { EVP_CIPHER_CTX_free(ctx); return; }

EVP_CIPHER_CTX_free(ctx);

out.resize(n1 + n2);

data.swap(out);

unsigned char keyBytes[32] = {0};

unsigned char iv[16] = {0};

std::memcpy(keyBytes, key.data(), std::min<size_t>(key.size(), 32));

EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();

if (!ctx) return;

if (EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, keyBytes, iv) != 1) { EVP_CIPHER_CTX_free(ctx); return; }

std::vector<char> out(data.size());

int n1 = 0, n2 = 0;

if (EVP_DecryptUpdate(ctx,

reinterpret_cast<unsigned char*>(out.data()), &n1,

reinterpret_cast<const unsigned char*>(data.data()), static_cast<int>(data.size())) != 1) { EVP_CIPHER_CTX_free(ctx); return; }

if (EVP_DecryptFinal_ex(ctx, reinterpret_cast<unsigned char*>(out.data()) + n1, &n2) != 1) { EVP_CIPHER_CTX_free(ctx); return; }

EVP_CIPHER_CTX_free(ctx);

out.resize(n1 + n2);

data.swap(out);

const std::string& keysFilePath,

const std::string& zipPassword,

const std::string& inputPath,

const std::vector<TransformAlgorithm>& transformAlgos) {

OperationResult result{false, "", 0};

// 1) ZIP

std::string tempZip = createZipArchive(inputPath, zipPassword);

if (tempZip.empty()) { result.message = "7zip archive failed."; return result; }

// 2) Keys

std::vector<std::string> keys;

if (!loadKeysFile(keysFilePath, keys) || keys.empty()) { result.message = "keys.txt not found or empty."; return result; }

std::string key = keys.front();

std::string keyIdHex = computeKeyIdHex(key);

// 3) Read zip as bytes

std::vector<char> data;

if (!readFileToVector(tempZip, data)) { result.message = "cannot read temp zip."; fs::remove(tempZip); return result; }

// 4) Apply transforms in order

for (const auto& algo : transformAlgos) algo.encrypt(data, key);

// 5) Write HEADER + payload

if (!writeFileWithHeader(encryptedFilePath, keyIdHex, data)) {

result.message = "cannot write encrypted file."; fs::remove(tempZip); return result;

}

// 6) Remove used key locally (one-time usage policy)

size_t remaining = removeKeyById(keysFilePath, keyIdHex);

fs::remove(tempZip);

result.success = true;

result.remainingKeys = remaining;

result.message = "Encryption OK. KID=" + keyIdHex + " -> " + encryptedFilePath;

return result;

const std::string& keysFilePath,

const std::string& zipPassword,

const std::string& encryptedFilePath,

const std::vector<TransformAlgorithm>& transformAlgos) {

OperationResult result{false, "", 0};

// 1) Read header + payload

std::string keyIdHex;

std::vector<char> payload;

if (!readFileWithHeader(encryptedFilePath, keyIdHex, payload)) {

result.message = "Invalid encrypted file header (ENCLIBv1/KID).";

return result;

}

// 2) Load keys and find matching key by ID

std::vector<std::string> keys;

if (!loadKeysFile(keysFilePath, keys) || keys.empty()) { result.message = "keys.txt not found or empty."; return result; }

std::string matchedKey;

for (auto& k : keys) {

if (computeKeyIdHex(k) == keyIdHex) { matchedKey = k; break; }

}

if (matchedKey.empty()) {

result.message = "No matching key for KID=" + keyIdHex;

return result;

}

// 3) Apply transforms in reverse

for (auto it = transformAlgos.rbegin(); it != transformAlgos.rend(); ++it) {

it->decrypt(payload, matchedKey);

}

// 4) Write temp zip and extract

std::string tempZip = getTempFilePath(".zip");

if (!writeVectorToFile(tempZip, payload)) { result.message = "cannot write temp zip."; return result; }

if (!extractZipArchive(tempZip, zipPassword, outputPath)) {

fs::remove(tempZip);

result.message = "7zip extract failed. Wrong password or corrupted data.";

return result;

}

// 5) Remove used key

size_t remaining = removeKeyById(keysFilePath, keyIdHex);

fs::remove(tempZip);

result.success = true;

result.remainingKeys = remaining;

result.message = "Decryption OK. KID=" + keyIdHex + " -> " + outputPath;

return result;