size_t ZlibRecompress(unsigned char *src, size_t src_len, size_t size_leanified /*= 0*/)
{
if (!is_fast)
{
size_t s = 0;
unsigned char *buffer = (unsigned char *)tinfl_decompress_mem_to_heap(src, src_len, &s, TINFL_FLAG_PARSE_ZLIB_HEADER);
if (!buffer)
{
std::cerr << "Decompress Zlib data failed." << std::endl;
}
else
{
ZopfliOptions zopfli_options;
ZopfliInitOptions(&zopfli_options);
zopfli_options.numiterations = iterations;
size_t new_size = 0;
unsigned char *out_buffer = NULL;
ZopfliZlibCompress(&zopfli_options, buffer, s, &out_buffer, &new_size);
mz_free(buffer);
if (new_size < src_len)
{
memcpy(src - size_leanified, out_buffer, new_size);
delete[] out_buffer;
return new_size;
}
delete[] out_buffer;
}
}
memmove(src - size_leanified, src, src_len);
return src_len;
}
int zopfli_deflate(
unsigned char *dest,
size_t *destLen,
const unsigned char *source,
size_t sourceLen,
int level
){
#ifdef FEOS
return -1;
#else
ZopfliOptions options;
ZopfliInitOptions(&options);
options.numiterations=level;
size_t __compsize=0;
unsigned char bp = 0;
unsigned char *COMPBUF=NULL;
ZopfliDeflate(&options, 2 /* Dynamic block */, 1, source, sourceLen, &bp, &COMPBUF, &__compsize);
if(__compsize<=*destLen){
memcpy(dest,COMPBUF,__compsize);
*destLen=__compsize;
}
free(COMPBUF);
return __compsize>*destLen;
#endif
}
/* You can use this function in Your own lib calls/applications.
ZopfliFormat is required but can be passed as simple number.
ZopfliOptions, ZopfliPredefinedSplits and ZopfliAdditionalData
structures are optional and can be NULL.
ZopfliPredefinedSplits structure holds 3 variables being
an array of block split offsets, number of block split offsets
and if to perform additional auto splitting between predefined
split points (0 or 1). size_t array, size_t and int.
ZopfliAdditonalData structure can hold 2 variables being
file timestamp and name. If timestamp is omitted, lower possible
value will be used for GZ and ZIP. If file name is omitted
GZ will not store filename and ZIP will use input data CRC32 as
file name.
*/
DLL_PUBLIC void ZopfliCompress(ZopfliOptions* options, const ZopfliFormat output_type,
const unsigned char* in, size_t insize,
unsigned char** out, size_t* outsize, ZopfliPredefinedSplits* sp,
const ZopfliAdditionalData* moredata) {
if(in == NULL || out == NULL || outsize == NULL) {
fprintf(stderr,"Critical Error: one or more required pointers are NULL\n");
exit(EXIT_FAILURE);
} else {
ZopfliOptions* optionslib = Zmalloc(sizeof(*optionslib));
if(options == NULL) {
ZopfliInitOptions(optionslib);
optionslib->verbose = 0;
} else {
optionslib = options;
mui = options->maxfailiterations;
}
if (output_type == ZOPFLI_FORMAT_GZIP || output_type == ZOPFLI_FORMAT_GZIP_NAME) {
ZopfliGzipCompress(optionslib, in, insize, out, outsize, sp, moredata);
} else if (output_type == ZOPFLI_FORMAT_ZLIB) {
ZopfliZlibCompress(optionslib, in, insize, out, outsize, sp);
} else if (output_type == ZOPFLI_FORMAT_ZIP) {
ZopfliZipCompress(optionslib, in, insize, out, outsize, sp, moredata);
} else if (output_type == ZOPFLI_FORMAT_DEFLATE) {
unsigned char bp = 0;
ZopfliDeflate(optionslib, 2 /* Dynamic block */, 1,
in, insize, &bp, out, outsize, sp);
} else {
fprintf(stderr,"Error: No output format specified.\n");
exit (EXIT_FAILURE);
}
free(optionslib);
}
}
HRESULT
WINAPI
CreateCompression(
OUT PVOID *context,
IN ULONG reserved
)
{
auto cc = new CompressionContext();
if (cc == NULL) return E_OUTOFMEMORY;
cc->input_buffer = NULL;
cc->output_buffer = NULL;
ZopfliInitOptions(&cc->options);
*context = cc;
auto cmd_line_res = CreateCmdLine(&cc->cmd_line_context);
if (cmd_line_res != S_OK) return cmd_line_res;
if (ProcCreateCompression == NULL) return E_FAIL;
return ProcCreateCompression(&cc->iis_compression_context, reserved);
}
int zopfli_convert(const char *in_file, const char *out_file, const ZopfliConfig *zopfli_config) {
ZopfliOptions options;
ZopfliFormat output_type = ZOPFLI_FORMAT_GZIP;
ZopfliInitOptions(&options);
if (zopfli_config->type == 1) {
output_type = ZOPFLI_FORMAT_DEFLATE;
} else if (zopfli_config->type == 2) {
output_type = ZOPFLI_FORMAT_GZIP;
} else {
output_type = DEFAULT_FORMAT;
}
if (zopfli_config->numiterations > 0) {
options.numiterations = zopfli_config->numiterations;
}
CompressFile(&options, output_type, in_file, out_file);
return 0;
}
int main(int argc, char* argv[]) {
ZopfliOptions options;
ZopfliFormat output_type = ZOPFLI_FORMAT_GZIP;
const char* filename = 0;
int output_to_stdout = 0;
int i;
ZopfliInitOptions(&options);
for (i = 1; i < argc; i++) {
const char* arg = argv[i];
if (StringsEqual(arg, "-v")) options.verbose = 1;
else if (StringsEqual(arg, "-c")) output_to_stdout = 1;
else if (StringsEqual(arg, "--deflate")) {
output_type = ZOPFLI_FORMAT_DEFLATE;
}
else if (StringsEqual(arg, "--zlib")) output_type = ZOPFLI_FORMAT_ZLIB;
else if (StringsEqual(arg, "--gzip")) output_type = ZOPFLI_FORMAT_GZIP;
else if (StringsEqual(arg, "--splitlast")) options.blocksplittinglast = 1;
else if (arg[0] == '-' && arg[1] == '-' && arg[2] == 'i'
&& arg[3] >= '0' && arg[3] <= '9') {
options.numiterations = atoi(arg + 3);
}
else if (StringsEqual(arg, "-h")) {
fprintf(stderr,
"Usage: zopfli [OPTION]... FILE...\n"
" -h gives this help\n"
" -c write the result on standard output, instead of disk"
" filename + '.gz'\n"
" -v verbose mode\n"
" --i# perform # iterations (default 15). More gives"
" more compression but is slower."
" Examples: --i10, --i50, --i1000\n");
fprintf(stderr,
" --gzip output to gzip format (default)\n"
" --zlib output to zlib format instead of gzip\n"
" --deflate output to deflate format instead of gzip\n"
" --splitlast do block splitting last instead of first\n");
return 0;
}
}
if (options.numiterations < 1) {
fprintf(stderr, "Error: must have 1 or more iterations");
return 0;
}
for (i = 1; i < argc; i++) {
if (argv[i][0] != '-') {
char* outfilename;
filename = argv[i];
if (output_to_stdout) {
outfilename = 0;
} else if (output_type == ZOPFLI_FORMAT_GZIP) {
outfilename = AddStrings(filename, ".gz");
} else if (output_type == ZOPFLI_FORMAT_ZLIB) {
outfilename = AddStrings(filename, ".zlib");
} else {
assert(output_type == ZOPFLI_FORMAT_DEFLATE);
outfilename = AddStrings(filename, ".deflate");
}
if (options.verbose && outfilename) {
fprintf(stderr, "Saving to: %s\n", outfilename);
}
CompressFile(&options, output_type, filename, outfilename);
free(outfilename);
}
}
if (!filename) {
fprintf(stderr,
"Please provide filename\nFor help, type: %s -h\n", argv[0]);
}
return 0;
}
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;
}
size_t Gz::Leanify(size_t size_leanified /*= 0*/)
{
// written according to this specification
// http://www.gzip.org/zlib/rfc-gzip.html
if (size <= 18)
{
std::cerr << "Not a valid GZ file." << std::endl;
return Format::Leanify(size_leanified);
}
depth++;
char flags = *(fp + 3);
// set the flags to 0, remove all unnecessary section
*(fp + 3 - size_leanified) = 0;
char *p_read = fp + 10;
char *p_write = p_read - size_leanified;
*(p_write - 2) = 2; // XFL
if (flags & (1 << 2)) // FEXTRA
{
p_read += *(uint16_t *)p_read + 2;
}
std::string filename;
if (flags & (1 << 3)) // FNAME
{
for (int i = 1; i < depth; i++)
{
std::cout << "-> ";
}
std::cout << p_read << std::endl;
filename = std::string(p_read);
while (p_read < fp + size && *p_read++)
{
// skip string
}
}
if (flags & (1 << 4)) // FCOMMENT
{
while (p_read < fp + size && *p_read++)
{
// skip string
}
}
if (flags & (1 << 1)) // FHCRC
{
p_read += 2;
}
if (p_read >= fp + size)
{
return Format::Leanify(size_leanified);
}
if (size_leanified)
{
memmove(fp - size_leanified, fp, 10);
}
if (is_fast)
{
memmove(p_write, p_read, fp + size - p_read);
return size - (p_read - p_write);
}
uint32_t uncompressed_size = *(uint32_t *)(fp + size - 4);
uint32_t crc = *(uint32_t *)(fp + size - 8);
size_t original_size = fp + size - 8 - p_read;
size_t s = 0;
unsigned char *buffer = (unsigned char *)tinfl_decompress_mem_to_heap(p_read, original_size, &s, 0);
if (!buffer ||
s != uncompressed_size ||
crc != mz_crc32(0, buffer, uncompressed_size))
{
std::cerr << "GZ corrupted!" << std::endl;
mz_free(buffer);
memmove(p_write, p_read, original_size + 8);
return size - (p_read - p_write);
}
uncompressed_size = LeanifyFile(buffer, uncompressed_size, 0, filename);
ZopfliOptions options;
ZopfliInitOptions(&options);
options.numiterations = iterations;
unsigned char bp = 0, *out = NULL;
size_t outsize = 0;
ZopfliDeflate(&options, 2, 1, buffer, uncompressed_size, &bp, &out, &outsize);
if (outsize < original_size)
{
memcpy(p_write, out, outsize);
p_write += outsize;
*(uint32_t *)p_write = mz_crc32(0, buffer, uncompressed_size);
*(uint32_t *)(p_write + 4) = uncompressed_size;
}
else
{
memmove(p_write, p_read, original_size + 8);
p_write += original_size;
}
mz_free(buffer);
delete[] out;
depth--;
fp -= size_leanified;
return p_write + 8 - fp;
}
void init_zopfli()
{
ZopfliInitOptions(&options);
}
