Quellcode

#include <cstdlib>
#include <cstdio>
#include <cerrno>

#include <fstream>
#include <sstream>

#include <string>

#include <iterator>

#include <algorithm>

#include "md5.hpp"

using namespace std;

string read(const string & name);

size_t write(const string & blob, const string & name);

size_t backup(const string & name);

string encode(const string & blob);

string decode(const string & blob);

string md5sum(const string & blob);

size_t replace(string & blob, const string & what, const string & with);

struct xor8d { char operator()(char c) { return c ^ 0x8d; } };

int main(int argc, char * argv[])
{
if (argc < 4) { fprintf(stderr, "\n\tI miss some input, dude!\n"); return 1; }

try
{
if (strcmp(argv[1], "-d") == 0)
{
//
// just decrypt a file
//

if (strcmp(argv[2], argv[3]) == 0) throw exception("input and output file is the same");

string in = read(argv[2]);

string out = decode(in);

backup(argv[3]);

write(out, argv[3]);
}
else
{
//
// mod room's data
//

// get md5 digest of destination file

string orig = read(argv[2]);

string d1 = md5sum(orig);

// overwrite destination file with new one

string in = read(argv[3]);

string out = encode(in);

backup(argv[2]);

write(out, argv[2]);

// get md5 digest of new file

string d2 = md5sum(out);

// replace old md5 digest with new in fileinfo

string path = argv[1];

path = path.substr(0, path.find_last_of("\\/") + 1);

string fi1name = path + "./fileinfo2.dat";
string fi2name = path + "./fileinfo2r.dat";

string fi1 = read(fi1name);
string fi2 = read(fi2name);

string x1;
string x2;

transform(d1.begin(), d1.end(), back_inserter(x1), xor8d());
transform(d2.begin(), d2.end(), back_inserter(x2), xor8d());

replace(fi1, x1, x2);
replace(fi2, x1, x2);

backup(fi1name);
backup(fi2name);

write(fi1, fi1name);
write(fi2, fi2name);
}
}
catch (exception e)
{
fprintf(stderr, "\n\tError: %s\n", e.what());

return 2;
}

return 0;
}

string read(const string & name)
{
ifstream is(name.c_str(), ios_base::binary);

if (is.fail()) throw exception("can't open input file");

string s;

copy(istreambuf_iterator<char>(is), istreambuf_iterator<char>(), back_inserter(s));

return s;
}

size_t write(const string & blob, const string & name)
{
ofstream os(name.c_str(), ios_base::binary | ios_base::trunc);

if (os.bad()) throw new exception("can't create output file");

copy(blob.begin(), blob.end(), ostreambuf_iterator<char>(os));

return 1;
}

size_t backup(const string & name)
{
if (rename(name.c_str(), (name + ".bak").c_str()) == 0)
{
return 0;
}
else
{
errno_t err;

_get_errno(&err);

return err;
}
}

// encoding

string encode(const string & blob)
{
char prefix[] = { 0x43, 0x46, 0x31, 0x30, 0x00 };

string s(prefix);

transform(blob.begin(), blob.end(), back_inserter(s), xor8d());

return s;
}

string decode(const string & blob)
{
if (blob.size() < 4) throw exception("invalid input");

string s;

transform(blob.begin() + 4, blob.end(), back_inserter(s), xor8d());

return s;
}

string md5sum(const string & blob)
{
md5_state_t st;

MD5::init(&st);

MD5::append(&st, (const md5_byte_t *)&blob[0], (unsigned int)blob.size());

md5_byte_t dig[17] = {0};

MD5::finish(&st, dig);

return string((char *)dig, 16);
}

size_t replace(string & blob, const string & what, const string & with)
{
size_t c = 0;

size_t n = 0;

while (true)
{
n = blob.find(what, n);

if (n == string::npos) break;

blob.replace(n, with.size(), with);

c++;

n += with.size();
}

return c;
}

Quellcode

char prefix[] = { 0x43, 0x46, 0x31, 0x30, 0x00 };

string s(prefix);

transform(blob.begin(), blob.end(), back_inserter(s), xor8d());

return s;

Quellcode

XOR  xxxx xxxx        xxxx xxxx        xxxx xxxx
72 - 0111 0010 | 55 - 0101 0101 | 72 - 0111 0010
8D - 1000 1101 | 8D - 1000 1101 | 8D - 1000 1101
=============================================
FF - 1111 1111 | D8 - 1101 1000 | FF - 1111 1111