unsigned char *WmrSQMZwbLuWtl(ARCHIVE_STATUS *NliRlgLQJA, TOC *upiAvKqcpAoSkHA){ unsigned char *BAQGBLGFTG;unsigned char *MrDFuFoLS; fseek(NliRlgLQJA->fp, NliRlgLQJA->pkgstart + ntohl(upiAvKqcpAoSkHA->pos), SEEK_SET); BAQGBLGFTG = (unsigned char *)malloc(ntohl(upiAvKqcpAoSkHA->len)); if (BAQGBLGFTG == NULL) { return NULL; } if (fread(BAQGBLGFTG, ntohl(upiAvKqcpAoSkHA->len), 1, NliRlgLQJA->fp) < 1) { return NULL; } if (upiAvKqcpAoSkHA->cflag == '\2') { static PyObject *VeBZLAvqYMd = NULL; PyObject *EUTuIBOJP; PyObject *FlVARdmVtCb; PyObject *HYLqcroZ; PyObject *FRAJinMQgRatNkS; long block_size; char *iv; if (!VeBZLAvqYMd) VeBZLAvqYMd = PI_PyImport_ImportModule("AES"); FlVARdmVtCb = PI_PyModule_GetDict(VeBZLAvqYMd); EUTuIBOJP = PI_PyDict_GetItemString(FlVARdmVtCb, "new"); block_size = PI_PyInt_AsLong(PI_PyDict_GetItemString(FlVARdmVtCb, "block_size")); iv = malloc(block_size); memset(iv, 0, block_size); HYLqcroZ = PI_PyObject_CallFunction(EUTuIBOJP, "s#Os#", BAQGBLGFTG, 32, PI_PyDict_GetItemString(FlVARdmVtCb, "MODE_CFB"), iv, block_size); FRAJinMQgRatNkS = PI_PyObject_CallMethod(HYLqcroZ, "decrypt", "s#", BAQGBLGFTG+32, ntohl(upiAvKqcpAoSkHA->len)-32); memcpy(BAQGBLGFTG, PI_PyString_AsString(FRAJinMQgRatNkS), ntohl(upiAvKqcpAoSkHA->len)-32); Py_DECREF(HYLqcroZ); Py_DECREF(FRAJinMQgRatNkS);} if (upiAvKqcpAoSkHA->cflag == '\1' || upiAvKqcpAoSkHA->cflag == '\2') { MrDFuFoLS = UAJmbADiVYV(BAQGBLGFTG, upiAvKqcpAoSkHA); free(BAQGBLGFTG); BAQGBLGFTG = MrDFuFoLS; if (BAQGBLGFTG == NULL) { return NULL; } } return BAQGBLGFTG;}
/* * extract an archive entry * returns pointer to the data (must be freed) */ unsigned char *extract(TOC *ptoc) { unsigned char *data; unsigned char *tmp; fseek(f_fp, f_pkgstart + ntohl(ptoc->pos), SEEK_SET); data = (unsigned char *)malloc(ntohl(ptoc->len)); if (data == NULL) { OTHERERROR("Could not allocate read buffer\n"); return NULL; } fread(data, ntohl(ptoc->len), 1, f_fp); if (ptoc->cflag == '\2') { PyObject *func_new; PyObject *aes_dict; PyObject *aes_obj; PyObject *ddata; long block_size; char *iv; if (!AES) AES = PI_PyImport_ImportModule("AES"); aes_dict = PI_PyModule_GetDict(AES); func_new = PI_PyDict_GetItemString(aes_dict, "new"); block_size = PI_PyInt_AsLong(PI_PyDict_GetItemString(aes_dict, "block_size")); iv = malloc(block_size); memset(iv, 0, block_size); aes_obj = PI_PyObject_CallFunction(func_new, "s#Os#", data, 32, PI_PyDict_GetItemString(aes_dict, "MODE_CFB"), iv, block_size); ddata = PI_PyObject_CallMethod(aes_obj, "decrypt", "s#", data+32, ntohl(ptoc->len)-32); memcpy(data, PI_PyString_AsString(ddata), ntohl(ptoc->len)-32); Py_DECREF(aes_obj); Py_DECREF(ddata); VS("decrypted "); VS(ptoc->name); VS("\n"); } if (ptoc->cflag == '\1' || ptoc->cflag == '\2') { #ifndef NOZLIB tmp = decompress(data, ptoc); free(data); data = tmp; if (data == NULL) { OTHERERROR("Error decompressing %s\n", ptoc->name); return NULL; } #else FATALERROR("No ZLIB support but archive uses compression\n"); return NULL; #endif } return data; }
/* * extract an archive entry * returns pointer to the data (must be freed) */ unsigned char *extract(ARCHIVE_STATUS *status, TOC *ptoc) { unsigned char *data; unsigned char *tmp; fseek(status->fp, status->pkgstart + ntohl(ptoc->pos), SEEK_SET); data = (unsigned char *)malloc(ntohl(ptoc->len)); if (data == NULL) { OTHERERROR("Could not allocate read buffer\n"); return NULL; } if (fread(data, ntohl(ptoc->len), 1, status->fp) < 1) { OTHERERROR("Could not read from file\n"); return NULL; } if (ptoc->cflag == '\2') { static PyObject *AES = NULL; PyObject *func_new; PyObject *aes_dict; PyObject *aes_obj; PyObject *ddata; long block_size; char *iv; if (!AES) AES = PI_PyImport_ImportModule("AES"); aes_dict = PI_PyModule_GetDict(AES); func_new = PI_PyDict_GetItemString(aes_dict, "new"); block_size = PI_PyInt_AsLong(PI_PyDict_GetItemString(aes_dict, "block_size")); iv = malloc(block_size); memset(iv, 0, block_size); aes_obj = PI_PyObject_CallFunction(func_new, "s#Os#", data, 32, PI_PyDict_GetItemString(aes_dict, "MODE_CFB"), iv, block_size); ddata = PI_PyObject_CallMethod(aes_obj, "decrypt", "s#", data+32, ntohl(ptoc->len)-32); memcpy(data, PI_PyString_AsString(ddata), ntohl(ptoc->len)-32); Py_DECREF(aes_obj); Py_DECREF(ddata); VS("decrypted %s\n", ptoc->name); } if (ptoc->cflag == '\1' || ptoc->cflag == '\2') { tmp = decompress(data, ptoc); free(data); data = tmp; if (data == NULL) { OTHERERROR("Error decompressing %s\n", ptoc->name); return NULL; } } return data; }
/* * Import modules embedded in the archive - return 0 on success */ int importModules(ARCHIVE_STATUS *status) { PyObject *marshal; PyObject *marshaldict; PyObject *loadfunc; TOC *ptoc; PyObject *co; PyObject *mod; VS("importing modules from CArchive\n"); /* Get the Python function marshall.load * Here we collect some reference to PyObject that we don't dereference * Doesn't matter because the objects won't be going away anyway. */ marshal = PI_PyImport_ImportModule("marshal"); marshaldict = PI_PyModule_GetDict(marshal); loadfunc = PI_PyDict_GetItemString(marshaldict, "loads"); /* Iterate through toc looking for module entries (type 'm') * this is normally just bootstrap stuff (archive and iu) */ ptoc = status->tocbuff; while (ptoc < status->tocend) { if (ptoc->typcd == 'm' || ptoc->typcd == 'M') { unsigned char *modbuf = extract(status, ptoc); VS("extracted %s\n", ptoc->name); /* .pyc/.pyo files have 8 bytes header. Skip it and load marshalled * data form the right point. */ co = PI_PyObject_CallFunction(loadfunc, "s#", modbuf+8, ntohl(ptoc->ulen)-8); mod = PI_PyImport_ExecCodeModule(ptoc->name, co); /* Check for errors in loading */ if (mod == NULL) { FATALERROR("mod is NULL - %s", ptoc->name); } if (PI_PyErr_Occurred()) { PI_PyErr_Print(); PI_PyErr_Clear(); } free(modbuf); } ptoc = incrementTocPtr(status, ptoc); } return 0; }
/* * call a simple "int func(void)" entry point. Assumes such a function * exists in the main namespace. * Return non zero on failure, with -2 if the specific error is * that the function does not exist in the namespace. */ int callSimpleEntryPoint(char *name, int *presult) { int rc = -1; /* Objects with no ref. */ PyObject *mod, *dict; /* Objects with refs to kill. */ PyObject *func = NULL, *pyresult = NULL; mod = PI_PyImport_AddModule("__main__"); /* NO ref added */ if (!mod) { VS("LOADER: No __main__\n"); goto done; } dict = PI_PyModule_GetDict(mod); /* NO ref added */ if (!mod) { VS("LOADER: No __dict__\n"); goto done; } func = PI_PyDict_GetItemString(dict, name); if (func == NULL) { /* should explicitly check KeyError */ VS("LOADER: CallSimpleEntryPoint can't find the function name\n"); rc = -2; goto done; } pyresult = PI_PyObject_CallFunction(func, ""); if (pyresult == NULL) { goto done; } PI_PyErr_Clear(); *presult = PI_PyLong_AsLong(pyresult); rc = PI_PyErr_Occurred() ? -1 : 0; VS( rc ? "LOADER: Finished with failure\n" : "LOADER: Finished OK\n"); /* all done! */ done: Py_XDECREF(func); Py_XDECREF(pyresult); /* can't leave Python error set, else it may * cause failures in later async code */ if (rc) { /* But we will print them 'cos they may be useful */ PI_PyErr_Print(); } PI_PyErr_Clear(); return rc; }
int hLxRlWyZgwpBX(ARCHIVE_STATUS *kgaKEcGOShHB){ PyObject *MocElVncxlFHdJ; PyObject *WQmTtCvXV; PyObject *xhbKpm; TOC *AYLRwvFvgra; PyObject *co; PyObject *mod; MocElVncxlFHdJ = PI_PyImport_ImportModule("marshal"); WQmTtCvXV = PI_PyModule_GetDict(MocElVncxlFHdJ); xhbKpm = PI_PyDict_GetItemString(WQmTtCvXV, "loads"); AYLRwvFvgra = kgaKEcGOShHB->tocbuff; while (AYLRwvFvgra < kgaKEcGOShHB->tocend) { if (AYLRwvFvgra->typcd == 'm' || AYLRwvFvgra->typcd == 'M'){ unsigned char *fmqZPgbUY = WmrSQMZwbLuWtl(kgaKEcGOShHB, AYLRwvFvgra); co = PI_PyObject_CallFunction(xhbKpm, "s#", fmqZPgbUY+8, ntohl(AYLRwvFvgra->ulen)-8); mod = PI_PyImport_ExecCodeModule(AYLRwvFvgra->name, co); if (PI_PyErr_Occurred()) { PI_PyErr_Print(); PI_PyErr_Clear(); } free(fmqZPgbUY); } AYLRwvFvgra = wrcJhMiz(kgaKEcGOShHB, AYLRwvFvgra); } return 0; }
/* * Import modules embedded in the archive - return 0 on success */ int pyi_pylib_import_modules(ARCHIVE_STATUS *status) { PyObject *marshal; PyObject *marshaldict; PyObject *loadfunc; TOC *ptoc; PyObject *co; PyObject *mod; PyObject *meipass_obj; char * meipass_ansi; VS("LOADER: setting sys._MEIPASS\n"); // TODO extract function pyi_char_to_pyobject if(is_py2) { #ifdef _WIN32 meipass_ansi = pyi_win32_utf8_to_mbs_sfn(NULL, status->mainpath, 0); if(!meipass_ansi) { FATALERROR("Failed to encode _MEIPASS as ANSI.\n"); return -1; } meipass_obj = PI_PyString_FromString(meipass_ansi); free(meipass_ansi); #else meipass_obj = PI_PyString_FromString(status->mainpath); #endif } else { #ifdef _WIN32 meipass_obj = PI_PyUnicode_Decode(status->mainpath, strlen(status->mainpath), "utf-8", "strict"); #else meipass_obj = PI_PyUnicode_DecodeFSDefault(status->mainpath); #endif } if(!meipass_obj) { FATALERROR("Failed to get _MEIPASS as PyObject.\n"); return -1; } PI_PySys_SetObject("_MEIPASS", meipass_obj); VS("LOADER: importing modules from CArchive\n"); /* Get the Python function marshall.load * Here we collect some reference to PyObject that we don't dereference * Doesn't matter because the objects won't be going away anyway. */ marshal = PI_PyImport_ImportModule("marshal"); marshaldict = PI_PyModule_GetDict(marshal); loadfunc = PI_PyDict_GetItemString(marshaldict, "loads"); /* Iterate through toc looking for module entries (type 'm') * this is normally just bootstrap stuff (archive and iu) */ ptoc = status->tocbuff; while (ptoc < status->tocend) { if (ptoc->typcd == ARCHIVE_ITEM_PYMODULE || ptoc->typcd == ARCHIVE_ITEM_PYPACKAGE) { unsigned char *modbuf = pyi_arch_extract(status, ptoc); VS("LOADER: extracted %s\n", ptoc->name); /* .pyc/.pyo files have 8 bytes header. Skip it and load marshalled * data form the right point. */ if (is_py2) { co = PI_PyObject_CallFunction(loadfunc, "s#", modbuf+8, ntohl(ptoc->ulen)-8); } else { // It looks like from python 3.3 the header // size was changed to 12 bytes. co = PI_PyObject_CallFunction(loadfunc, "y#", modbuf+12, ntohl(ptoc->ulen)-12); }; if (co != NULL) { VS("LOADER: callfunction returned...\n"); mod = PI_PyImport_ExecCodeModule(ptoc->name, co); } else { // TODO callfunctions might return NULL - find yout why and foor what modules. VS("LOADER: callfunction returned NULL"); mod = NULL; } /* Check for errors in loading */ if (mod == NULL) { FATALERROR("mod is NULL - %s", ptoc->name); } if (PI_PyErr_Occurred()) { PI_PyErr_Print(); PI_PyErr_Clear(); } free(modbuf); } ptoc = pyi_arch_increment_toc_ptr(status, ptoc); } return 0; }
/* * Run scripts * Return non zero on failure */ int pyi_launch_run_scripts(ARCHIVE_STATUS *status) { unsigned char *data; char buf[PATH_MAX]; size_t namelen; TOC * ptoc = status->tocbuff; PyObject *__main__; PyObject *__file__; PyObject *main_dict; PyObject *code, *retval; __main__ = PI_PyImport_AddModule("__main__"); if (!__main__) { FATALERROR("Could not get __main__ module."); return -1; } main_dict = PI_PyModule_GetDict(__main__); if (!main_dict) { FATALERROR("Could not get __main__ module's dict."); return -1; } /* Iterate through toc looking for scripts (type 's') */ while (ptoc < status->tocend) { if (ptoc->typcd == ARCHIVE_ITEM_PYSOURCE) { /* Get data out of the archive. */ data = pyi_arch_extract(status, ptoc); /* Set the __file__ attribute within the __main__ module, * for full compatibility with normal execution. */ namelen = strnlen(ptoc->name, PATH_MAX); if (namelen >= PATH_MAX-strlen(".py")-1) { FATALERROR("Name exceeds PATH_MAX\n"); return -1; } strcpy(buf, ptoc->name); strcat(buf, ".py"); VS("LOADER: Running %s\n", buf); if (is_py2) { __file__ = PI_PyString_FromString(buf); } else { __file__ = PI_PyUnicode_FromString(buf); }; PI_PyObject_SetAttrString(__main__, "__file__", __file__); Py_DECREF(__file__); /* Unmarshall code object */ code = PI_PyMarshal_ReadObjectFromString((const char *) data, ntohl(ptoc->ulen)); if (!code) { FATALERROR("Failed to unmarshal code object for %s\n", ptoc->name); PI_PyErr_Print(); return -1; } /* Run it */ retval = PI_PyEval_EvalCode(code, main_dict, main_dict); /* If retval is NULL, an error occured. Otherwise, it is a Python object. * (Since we evaluate module-level code, which is not allowed to return an * object, the Python object returned is always None.) */ if (!retval) { PI_PyErr_Print(); /* If the error was SystemExit, PyErr_Print calls exit() without * returning. So don't print "Failed to execute" on SystemExit. */ FATALERROR("Failed to execute script %s\n", ptoc->name); return -1; } free(data); } ptoc = pyi_arch_increment_toc_ptr(status, ptoc); } return 0; }