You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
234 lines
4.5 KiB
234 lines
4.5 KiB
#include <iostream>
|
|
#include <sstream>
|
|
#include <fstream>
|
|
#include <filesystem>
|
|
#include <string>
|
|
#include <random>
|
|
#include <vector>
|
|
#include <regex>
|
|
|
|
#pragma GCC diagnostic ignored "-Wattributes"
|
|
|
|
#include <sha256_literal.h>
|
|
#include <sha256.h>
|
|
|
|
using namespace std;
|
|
namespace fs = std::filesystem;
|
|
|
|
string get_uuid() {
|
|
static random_device dev;
|
|
static mt19937 rng(dev());
|
|
|
|
uniform_int_distribution<int> dist(0, 15);
|
|
|
|
const char *v = "0123456789abcdef";
|
|
const bool dash[] = { 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0 };
|
|
|
|
string res;
|
|
for (int i = 0; i < 16; i++) {
|
|
if (dash[i]) res += "-";
|
|
res += v[dist(rng)];
|
|
res += v[dist(rng)];
|
|
}
|
|
return res;
|
|
}
|
|
|
|
// DATA
|
|
// DATA_LENGTHS
|
|
// DATA_NAMES
|
|
// DATA_COUNT
|
|
// DATA_EXEC_AFTER
|
|
// DATA_EXEC_AFTER_HASH
|
|
// DATA_HASHES
|
|
#include "file.h"
|
|
|
|
#define SHA256_SIZE 32
|
|
|
|
bool verify_hash()
|
|
{
|
|
return (!DATA_EXEC_AFTER || sha256::compute((const uint8_t*)DATA_EXEC_AFTER, strlen(DATA_EXEC_AFTER)) == DATA_EXEC_AFTER_HASH);
|
|
}
|
|
|
|
array<unsigned char, SHA256_SIZE> data_hash_i(int index)
|
|
{
|
|
array<unsigned char, SHA256_SIZE> output;
|
|
auto pointer = DATA_HASHES + (index*SHA256_SIZE);
|
|
|
|
static_assert(output.size() == SHA256_SIZE);
|
|
memcpy(output.data(), pointer, SHA256_SIZE);
|
|
|
|
return output;
|
|
}
|
|
|
|
bool verify_hash(int hash_i, const unsigned char* data, size_t len)
|
|
{
|
|
#ifdef DATA_HASHED
|
|
return sha256::compute((const uint8_t*)data, len) == data_hash_i(hash_i);
|
|
#else
|
|
return true;
|
|
#endif
|
|
}
|
|
|
|
string arg_vec_int(int i)
|
|
{
|
|
stringstream ss;
|
|
ss << "%arg\\[" << i << "\\]";
|
|
return ss.str();
|
|
}
|
|
|
|
string get_exec_str(vector<string> args, string args_full, string loc)
|
|
{
|
|
string str(DATA_EXEC_AFTER);
|
|
|
|
str = regex_replace(str, std::regex("%location"), loc);
|
|
|
|
str = regex_replace(str, std::regex("%argc"), std::to_string(args.size()));
|
|
|
|
str = regex_replace(str, std::regex("%args"), args_full);
|
|
|
|
|
|
for(int i=0;i<args.size();i++)
|
|
{
|
|
str = regex_replace(str, std::regex(arg_vec_int(i)), args[i]);
|
|
}
|
|
|
|
|
|
return str;
|
|
}
|
|
|
|
string arg_strings(int argc,char** argv, vector<string>& output)
|
|
{
|
|
stringstream ss;
|
|
for(int i=1;i<argc;i++)
|
|
{
|
|
auto argi = string(argv[i]);
|
|
ss << argi;
|
|
if(i!=argc-1)
|
|
ss << ' ';
|
|
output.push_back(argi);
|
|
}
|
|
return ss.str();
|
|
}
|
|
|
|
void write_to_file(string to, const unsigned char* data, long length)
|
|
{
|
|
ofstream file;
|
|
file.open(to, ios::out | ios::binary );
|
|
file.write((const char*)data, length);
|
|
file.close();
|
|
}
|
|
|
|
long get_index(int i)
|
|
{
|
|
if(i<=0) return 0;
|
|
else return get_index(i-2) + DATA_LENGTHS[i-1];
|
|
}
|
|
|
|
const unsigned char* get_data(int i)
|
|
{
|
|
const unsigned char* data = DATA;
|
|
if(i==0) return DATA;
|
|
for(int j=0;j<i;j++)
|
|
{
|
|
data+=DATA_LENGTHS[j];
|
|
}
|
|
return data;
|
|
}
|
|
|
|
template<typename Path>
|
|
struct DirTree
|
|
{
|
|
bool clean=true;
|
|
const Path path;
|
|
DirTree(const Path input) noexcept : path(input)
|
|
{
|
|
fs::create_directory(path);
|
|
}
|
|
DirTree(DirTree&& other) noexcept : path(other.path)
|
|
{
|
|
other.clean=false;
|
|
}
|
|
DirTree(const DirTree& _) noexcept = delete;
|
|
|
|
~DirTree()
|
|
{
|
|
if(clean)
|
|
fs::remove_all(path);
|
|
}
|
|
|
|
const Path& operator &()
|
|
{
|
|
return path;
|
|
}
|
|
};
|
|
|
|
constexpr uint64_t max_sz()
|
|
{
|
|
uint64_t sz =0;
|
|
for(int i=0;i<DATA_COUNT;i++)
|
|
sz+=DATA_LENGTHS[i];
|
|
|
|
return sz;
|
|
}
|
|
|
|
int main(int argc,char** argv)
|
|
{
|
|
auto path = fs::temp_directory_path() / get_uuid();
|
|
vector<string> vecargs;
|
|
auto args = arg_strings(argc,argv, vecargs);
|
|
|
|
const auto max_size = max_sz();
|
|
static_assert(max_size == sizeof(DATA));
|
|
|
|
if(!verify_hash())
|
|
{
|
|
cerr << "Error: Bad message hash" << endl;
|
|
return 1;
|
|
}
|
|
|
|
#ifndef SILENT
|
|
cout << "Extracting " << DATA_COUNT << " files to " << path << "..." << endl;
|
|
#endif
|
|
|
|
DirTree tree(path);
|
|
uint64_t sz=0;
|
|
for(int i=0;i<DATA_COUNT;i++)
|
|
{
|
|
auto data = get_data(i);
|
|
auto data_len = DATA_LENGTHS[i];
|
|
|
|
if ((sz+=data_len) > sizeof(DATA))
|
|
{
|
|
#ifndef SILENT
|
|
cerr << "Failed: Invalid sizes (" << sz << " is larger than " << sizeof(DATA) << ")" << endl;
|
|
#endif
|
|
return 1;
|
|
}
|
|
|
|
#ifndef SILENT
|
|
cout << " <- " << DATA_NAMES[i] << " (" << data_len << ")" << flush;
|
|
#endif
|
|
if(!verify_hash(i, data, data_len)) {
|
|
#ifndef SILENT
|
|
cout << " FAILED: Invalid hash" << endl;
|
|
cerr << "Aborting." << endl;
|
|
#endif
|
|
return 1;
|
|
} else {
|
|
write_to_file(&tree / DATA_NAMES[i], data, data_len);
|
|
#ifndef SILENT
|
|
cout << " OK" << endl;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
if(DATA_EXEC_AFTER) {
|
|
string execstr = get_exec_str(vecargs, args, path);
|
|
#ifndef SILENT
|
|
cout << "exec: " << execstr << endl;
|
|
#endif
|
|
system(execstr.c_str());
|
|
}
|
|
return 0;
|
|
}
|