/*
outfilename: filename to write output to, or 0 to write to stdout instead
*/
static void CompressFile(const ZopfliOptions* options,
ZopfliFormat output_type,
const char* infilename,
const char* outfilename) {
unsigned char* in;
size_t insize;
unsigned char* out = 0;
size_t outsize = 0;
LoadFile(infilename, &in, &insize);
if (insize == 0) {
fprintf(stderr, "Invalid filename: %s\n", infilename);
return;
}
ZopfliCompress(options, output_type, in, insize, &out, &outsize);
if (outfilename) {
SaveFile(outfilename, out, outsize);
} else {
size_t i;
for (i = 0; i < outsize; i++) {
/* Works only if terminal does not convert newlines. */
printf("%c", out[i]);
}
}
free(out);
free(in);
}
PyObject * compress_zopfli(char * data, size_t size)
{
unsigned char* out = 0;
size_t outsize = 0;
ZopfliCompress(&options, ZOPFLI_FORMAT_ZLIB,
(const unsigned char*)data, size, &out, &outsize);
PyObject * ret = PyString_FromStringAndSize((const char*)out, outsize);
free(out);
return ret;
}
HRESULT WINAPI Compress(
IN OUT PVOID context, // compression context
IN CONST BYTE * input_buffer, // input buffer
IN LONG input_buffer_size, // size of input buffer
IN PBYTE output_buffer, // output buffer
IN LONG output_buffer_size, // size of output buffer
OUT PLONG input_used, // amount of input buffer used
OUT PLONG output_used, // amount of output buffer used
IN INT compression_level // compression level (1...10)
)
{
if (compression_level < 0 || compression_level > 10
|| context == NULL)
return E_INVALIDARG;
auto cc = (CompressionContext *)context;
if (compression_level <= MAX_IIS_GZIP_LEVEL)
{
// do IIS compression
return ProcCompress(cc->iis_compression_context,
input_buffer, input_buffer_size, output_buffer, output_buffer_size,
input_used, output_used, compression_level * 2);
}
if (cmd_line_configured)
{
// do cmd line compression
return CmdLineCompress(cc,
input_buffer, input_buffer_size, output_buffer, output_buffer_size,
input_used, output_used, compression_level);
}
*input_used = 0;
*output_used = 0;
if (input_buffer_size > 0)
{
// copy input into our internal buffer
auto buf = (BYTE *)realloc(cc->input_buffer, cc->input_buffer_size + input_buffer_size);
if (buf == NULL) return E_OUTOFMEMORY;
cc->input_buffer = buf;
auto res = memcpy_s(cc->input_buffer + cc->input_buffer_size, input_buffer_size, input_buffer, input_buffer_size);
if (res != 0) return E_FAIL;
cc->input_buffer_size = cc->input_buffer_size + input_buffer_size;
*input_used = input_buffer_size;
}
else
{
// no more input -> compress (or continue copying compressed buffer into output)
if (cc->output_used == 0)
{
cc->options.numiterations = zopfli_iterations[compression_level - (MAX_IIS_GZIP_LEVEL + 1)];
ZopfliCompress(&cc->options, ZopfliFormat::ZOPFLI_FORMAT_GZIP, cc->input_buffer, cc->input_buffer_size, &cc->output_buffer, &cc->output_buffer_size);
if (cc->output_buffer == NULL) return E_OUTOFMEMORY;
if (cc->output_buffer_size <= 0) return E_FAIL;
}
if (cc->output_used == cc->output_buffer_size) return S_FALSE; // done
auto bytes_left = cc->output_buffer_size - cc->output_used;
auto bytes_to_copy = output_buffer_size < (LONG)bytes_left ? output_buffer_size : (LONG)bytes_left;
auto res = memcpy_s(output_buffer, output_buffer_size, cc->output_buffer + cc->output_used, bytes_to_copy);
if (res != 0) return E_FAIL;
*output_used = bytes_to_copy;
cc->output_used += bytes_to_copy;
if (cc->output_used == cc->output_buffer_size) return S_FALSE;
}
return S_OK;
}
int main() {
std::string a = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbccccccccccccaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
std::string output;
ZopfliOptions options;
ZopfliInitOptions(&options);
snappy::Compress(a.data(), a.size(), &output);
if(!checkhash((unsigned char *)output.data(), output.size(), (char *)"0x5a8f06cf6817a74bc75c3c8290196928acb04c189ecdd192a93eb3c3")) {
std::cout<<"Something wrong\n";
}
unsigned char b[] = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbccccccccccccaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
unsigned char *out = NULL;
size_t outsize = 0;
ZopfliCompress(&options, ZOPFLI_FORMAT_GZIP, b, a.size(), &out, &outsize);
if(!checkhash(out, outsize, (char *)"0x0f66ce213d2d27067ff9ffa8bbde2dd06d7f3e687549fad846169e16")) {
std::cout<<"Something wrong\n";
}
HangulInputContext* ic;
const char* p = "dekde";
const ucschar* commit;
ic = hangul_ic_new("2y");
while (*p != '\0') {
hangul_ic_process(ic, *p);
p++;
}
commit = hangul_ic_get_commit_string(ic);
int len = wcslen((const wchar_t*)commit);
if(!checkhash((unsigned char*)commit, len * sizeof(const wchar_t), (char *)"0xc9bf9374fbc9f4989afd0af7ac9824a4dcc768b33bfa3bb38e42617b")) {
std::cout<<"Something wrong\n";
}
hangul_ic_delete(ic);
static JSClass global_class = { "global",
JSCLASS_NEW_RESOLVE | JSCLASS_GLOBAL_FLAGS,
JS_PropertyStub, JS_PropertyStub, JS_PropertyStub,
JS_StrictPropertyStub,
JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub,
NULL, JSCLASS_NO_OPTIONAL_MEMBERS
};
JSRuntime *rt = JS_NewRuntime(8 * 1024 * 1024);
JSContext *cx = JS_NewContext(rt, 8192);
JS_SetOptions(cx, JSOPTION_VAROBJFIX);
JS_SetErrorReporter(cx, reportError);
JSObject *global = JS_NewCompartmentAndGlobalObject(cx, &global_class, NULL);
JS_SetGlobalObject(cx, global);
if (!JS_InitStandardClasses(cx, global)) {
return 1;
}
char source[] = "Math.random()";
jsval rval;
cx->rngSeed = 31337;
JS_EvaluateScript(cx, global, source, strlen(source),
"none", 10, &rval);
double nums[2];
nums[0] = JSVAL_TO_DOUBLE(rval);
JS_EvaluateScript(cx, global, source, strlen(source),
"none", 10, &rval);
nums[1] = JSVAL_TO_DOUBLE(rval);
if(!checkhash((unsigned char*)nums, 2 * sizeof(double), (char *)"0x61b35e8d466f24ee1ea502350ec6f5d1134fe6ec543c17845fa62f8a")) {
std::cout<<"Something wrong\n";
}
JS_DestroyContext(cx);
JS_DestroyRuntime(rt);
JS_ShutDown();
mtprngParam mt;
byte bay[] = "qqqqqqqqqqqqqqqq";
byte result[100];
for(int i=0; i< 100; i++) {
result[i] = 0;
}
mtprngSetup(&mt);
mtprngSeed(&mt, bay, 16);
mtprngNext(&mt, result, 100);
if(!checkhash((unsigned char*)&result, 100, (char *)"0x7754dfd27fe6fa00551861ff41e4f48315bd89bef6da652f182ce2d6")) {
std::cout<<"Something wrong\n";
}
ranlib::ChiSquare<double> gen(4);
gen.seed(31337);
double f[16];
for(int i = 0; i<16; i++) {
f[i] = gen.random();
}
if(!checkhash((unsigned char*)&f, 16 * sizeof(double), (char *)"0xd19d0c167fe93b11004c0167c226d2e92c17dfa36ffb243f39824098")) {
std::cout<<"Something wrong\n";
}
Botan::byte pass[] = "aaaabbbb";
Botan::PBKDF* pbkdf = Botan::get_pbkdf("PBKDF2(SHA-256)");
Botan::OctetString aes_key = pbkdf->derive_key(32, "pass1337", pass, 8, 31337);
std::string aa = aes_key.as_string();
if(!checkhash((unsigned char*)aa.c_str(), aa.size(), (char *)"0x0c33d122ed50848a676539ae48eb84db0dcbf69e9ee857094755f2d7")) {
std::cout<<"Something wrong\n";
}
std::cout<<"Answer is RUCTF_";
checkhash((unsigned char*)together, pos, (char *)"");
return 0;
}
