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;
}
