aixiao/denyhosts
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity
6303c61119
denyhosts/clamscan/libclamav/mew.c

920 lines
31 KiB
C
Raw Normal View History

添加病毒扫描
2022-10-22 18:41:00 +08:00
/*
* Copyright (C) 2013-2022 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
* Copyright (C) 2007-2013 Sourcefire, Inc.
*
* Authors: Michal 'GiM' Spadlinski
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301, USA.
*/
/*
* lzma.c
*
* o2:28:18 CEST 2oo6-25-o6 - initial 0xA4/0x536
* oo:29:4o CEST 2oo6-26-o6 - 0x1cd/0x536 [+0x129]
* o2:13:19 CEST 2oo6-o1-o7, 2oo6-3o-o6 - 0x536/0x536
*
*/
#if HAVE_CONFIG_H
#include "clamav-config.h"
#endif
#include <stdio.h>
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_STRING_H
#include <string.h>
#endif
#include "clamav.h"
#include "pe.h"
#include "others.h"
#include "mew.h"
#include "packlibs.h"
#include "rebuildpe.h"
#define EC32(x) le32_to_host(x) /* Convert little endian to host */
#define CE32(x) be32_to_host(x) /* Convert big endian to host */
#define PEALIGN(o, a) (((a)) ? (((o) / (a)) * (a)) : (o))
#define PESALIGN(o, a) (((a)) ? (((o) / (a) + ((o) % (a) != 0)) * (a)) : (o))
/* modifies all parameters */
/* northfox does this shitty way,
* this should be done with just a bswap
*/
static const char *lzma_bswap_4861dc(struct lzmastate *p, const char *old_edx)
{
/* dumb_dump_start
*
old_edx was 'uint32_t *' before and in mew_lzma there was
&new_edx where new_edx = var1C
uint32_t loc_esi, loc_edi;
uint8_t *loc_eax;
p->p2 = loc_esi = 0;
p->p0 = loc_eax = (uint8_t *)*old_edx;
*old_edx = 5;
do {
loc_esi = p->p2 << 8;
loc_edi = *(uint8_t *)((loc_eax)++);
loc_esi |= loc_edi;
(*old_edx)--;
p->p2 = loc_esi;
} while (*old_edx);
p->p0 = loc_eax;
p->p1 = 0xffffffff;
* dumb_dump_end
*/
/* XXX, mine replacement */
p->p2 = EC32(CE32(((uint32_t)cli_readint32(old_edx + 1))));
p->p1 = 0xffffffff;
p->p0 = old_edx + 5;
return p->p0;
}
static uint32_t lzma_486248(struct lzmastate *p, const char **old_ecx, char *src, uint32_t size)
{
uint32_t loc_esi, loc_edi, loc_eax, loc_ecx, ret;
if (!CLI_ISCONTAINED(src, size, *old_ecx, 4) || !CLI_ISCONTAINED(src, size, p->p0, 1))
return 0xffffffff;
loc_esi = p->p1;
loc_eax = loc_esi >> 0xb;
loc_ecx = cli_readint32(*old_ecx);
ret = loc_ecx & 0xffff;
(loc_eax) *= ret;
loc_edi = p->p2;
if (loc_edi < loc_eax) {
/* 48625f */
p->p1 = loc_eax;
loc_esi = ret;
loc_edi = ((int32_t)(0x800 - ret) >> 5) + ((loc_eax & 0xffff0000) | ret);
/* signed<-sar, &|<-mov ax, [ecx] */
loc_ecx = (loc_ecx & 0xffff0000) | (loc_edi & 0xffff);
cli_writeint32(*old_ecx, loc_ecx);
ret = 0;
} else {
/* 48629e */
loc_esi -= loc_eax;
loc_edi -= loc_eax;
p->p1 = loc_esi;
p->p2 = loc_edi;
loc_eax = (loc_eax & 0xffff0000) | ret;
loc_esi = (loc_esi & 0xffff0000) | (ret >> 5);
loc_eax -= loc_esi;
loc_ecx = (loc_ecx & 0xffff0000) | (loc_eax & 0xffff);
cli_writeint32(*old_ecx, loc_ecx);
ret = 1;
}
loc_eax = p->p1;
if (loc_eax < 0x1000000) {
*old_ecx = p->p0;
loc_edi = (*(uint8_t *)(p->p0));
loc_esi = ((p->p2) << 8) | loc_edi;
(*old_ecx)++;
loc_eax <<= 8;
p->p2 = loc_esi;
p->p1 = loc_eax;
p->p0 = *old_ecx;
}
return ret;
}
static uint32_t lzma_48635C(uint8_t znaczek, const char **old_ecx, struct lzmastate *p, uint32_t *retval, char *src, uint32_t size)
{
uint32_t loc_esi = (znaczek & 0xff) >> 7, /* msb */
loc_ebx, ret;
const char *loc_edi;
znaczek <<= 1;
ret = loc_esi << 9;
loc_edi = *old_ecx;
*old_ecx = loc_edi + ret + 0x202;
if ((ret = lzma_486248(p, old_ecx, src, size)) == 0xffffffff)
return 0xffffffff;
loc_ebx = ret | 2;
while (loc_esi == ret) {
if (loc_ebx >= 0x100) {
ret = (ret & 0xffffff00) | (loc_ebx & 0xff);
*retval = ret;
return 0;
}
loc_esi = (znaczek & 0xff) >> 7;
znaczek <<= 1;
ret = ((loc_esi + 1) << 8) + loc_ebx;
*old_ecx = loc_edi + ret * 2;
if ((ret = lzma_486248(p, old_ecx, src, size)) == 0xffffffff)
return 0xffffffff;
loc_ebx += loc_ebx;
loc_ebx |= ret;
}
loc_esi = 0x100;
while (loc_ebx < loc_esi) {
loc_ebx += loc_ebx;
*old_ecx = loc_edi + loc_ebx;
if ((ret = lzma_486248(p, old_ecx, src, size)) == 0xffffffff)
return 0xffffffff;
loc_ebx |= ret;
}
ret = (ret & 0xffffff00) | (loc_ebx & 0xff);
*retval = ret;
return 0;
}
static uint32_t lzma_4862e0(struct lzmastate *p, const char **old_ecx, uint32_t *old_edx, uint32_t *retval, char *src, uint32_t size)
{
uint32_t loc_ebx, loc_esi, stack_ecx, ret;
const char *loc_edi;
loc_ebx = *old_edx;
ret = 1;
loc_edi = *old_ecx;
if (loc_ebx && !(loc_ebx & 0x80000000)) {
/* loc_4862f1 */
stack_ecx = loc_ebx;
do {
loc_esi = ret + ret;
*old_ecx = loc_edi + loc_esi;
if ((ret = lzma_486248(p, old_ecx, src, size)) == 0xffffffff)
return 0xffffffff;
ret += loc_esi;
stack_ecx--;
} while (stack_ecx);
}
/* loc_48630b */
/* unneeded
*old_ecx = (uint8_t *)loc_ebx;
*/
*old_edx = 1 << (loc_ebx & 0xff);
ret -= *old_edx;
*retval = ret;
return 0;
}
/* old_edx - write only */
static uint32_t lzma_4863da(uint32_t var0, struct lzmastate *p, const char **old_ecx, uint32_t *old_edx, uint32_t *retval, char *src, uint32_t size)
{
uint32_t ret;
const char *loc_esi = *old_ecx;
if ((ret = lzma_486248(p, old_ecx, src, size)) == 0xffffffff)
return -1;
if (ret) {
/* loc_4863ff */
*old_ecx = loc_esi + 2;
if ((ret = lzma_486248(p, old_ecx, src, size)) == 0xffffffff)
return -1;
if (ret) {
/* loc_486429 */
*old_edx = 8;
*old_ecx = loc_esi + 0x204;
if (lzma_4862e0(p, old_ecx, old_edx, &ret, src, size) == 0xffffffff)
return -1;
ret += 0x10;
} else {
/* loc_48640e */
ret = var0 << 4;
*old_edx = 3;
*old_ecx = loc_esi + 0x104 + ret;
if (lzma_4862e0(p, old_ecx, old_edx, &ret, src, size) == 0xffffffff)
return -1;
ret += 0x8;
}
} else {
/* loc_4863e9 */
ret = var0 << 4;
*old_edx = 3;
*old_ecx = loc_esi + 0x4 + ret;
if (lzma_4862e0(p, old_ecx, old_edx, &ret, src, size) == 0xffffffff)
return -1;
}
*retval = ret;
return 0;
}
static uint32_t lzma_486204(struct lzmastate *p, uint32_t old_edx, uint32_t *retval, char *src, uint32_t size)
{
uint32_t loc_esi, loc_edi, loc_ebx, loc_eax;
const char *loc_edx;
loc_esi = p->p1;
loc_edi = p->p2;
loc_eax = 0;
if (old_edx && !(old_edx & 0x80000000)) {
/* loc_4866212 */
loc_ebx = old_edx;
do {
loc_esi >>= 1;
loc_eax <<= 1;
if (loc_edi >= loc_esi) {
loc_edi -= loc_esi;
loc_eax |= 1;
}
/* loc_486222 */
if (loc_esi < 0x1000000) {
if (!CLI_ISCONTAINED(src, size, p->p0, 1))
return 0xffffffff;
loc_edx = p->p0;
loc_edi <<= 8;
loc_esi <<= 8;
loc_edi |= (*loc_edx) & 0xff; /* movzx ebp, byte ptr [edx] */
p->p0 = ++loc_edx;
}
loc_ebx--;
} while (loc_ebx);
}
p->p2 = loc_edi;
p->p1 = loc_esi;
*retval = loc_eax;
return 0;
}
static uint32_t lzma_48631a(struct lzmastate *p, const char **old_ecx, uint32_t *old_edx, uint32_t *retval, char *src, uint32_t size)
{
uint32_t copy1, copy2;
uint32_t loc_esi, loc_edi, ret;
const char *loc_ebx;
copy1 = *old_edx;
loc_edi = 0;
loc_ebx = *old_ecx;
*old_edx = 1;
copy2 = (uint32_t)loc_edi;
if (copy1 <= (uint32_t)loc_edi) {
*retval = copy2;
return 0;
}
do {
loc_esi = *old_edx + *old_edx;
*old_ecx = loc_esi + loc_ebx;
if ((ret = lzma_486248(p, old_ecx, src, size)) == 0xffffffff)
return 0xffffffff;
/* unneeded *old_ecx = loc_edi; */
*old_edx = loc_esi + ret;
/* ret <<= (uint32_t)(*old_ecx)&0xff; */
ret <<= (loc_edi & 0xff);
copy2 |= ret;
loc_edi++;
} while (loc_edi < copy1);
*retval = copy2;
return 0;
}
int mew_lzma(char *orgsource, const char *buf, uint32_t size_sum, uint32_t vma, uint32_t special)
{
uint32_t var08, var0C, var10, var14, var20, var24, var28, var34;
struct lzmastate var40;
uint32_t new_eax, new_edx, temp;
int i, mainloop;
char var1, var30;
const char *source = buf;
char *dest, *new_ebx;
const char *new_ecx, *var0C_ecxcopy;
const char *var2C;
char *pushed_esi = NULL;
const char *pushed_ebx = NULL;
uint32_t pushed_edx = 0;
uint32_t loc_esi, loc_edi;
uint8_t *var18;
if (special) {
pushed_edx = cli_readint32(source);
source += 4;
}
temp = cli_readint32(source) - vma;
source += 4;
if (!special) pushed_ebx = source;
new_ebx = orgsource + temp;
do {
mainloop = 1;
do {
/* loc_486450 */
if (!special) {
source = pushed_ebx;
if (!CLI_ISCONTAINED(orgsource, size_sum, source, 16))
return -1;
if (cli_readint32(source) == 0) {
return 0;
}
} else {
if (!CLI_ISCONTAINED(orgsource, size_sum, source, 12))
return -1;
}
var28 = cli_readint32(source);
source += 4;
temp = cli_readint32(source) - vma;
var18 = (uint8_t *)(orgsource + temp);
if (special) pushed_esi = orgsource + temp;
source += 4;
temp = cli_readint32(source);
source += 5; /* yes, five */
var2C = source;
source += temp;
if (special)
pushed_ebx = source;
else
pushed_ebx = source;
var1 = 0;
dest = new_ebx;
if (!CLI_ISCONTAINED(orgsource, size_sum, dest, 0x6E6C))
return -1;
for (i = 0; i < 0x1b9b; i++) {
cli_writeint32(dest, 0x4000400);
dest += 4;
}
loc_esi = 0;
var08 = var20 = 0;
loc_edi = 1;
var14 = var10 = var24 = 1;
if (!CLI_ISCONTAINED(orgsource, size_sum, var2C, 5))
return -1;
lzma_bswap_4861dc(&var40, var2C);
new_edx = 0;
} while (var28 <= loc_esi); /* source = 0 */
cli_dbgmsg("MEWlzma: entering do while loop\n");
do {
/* loc_4864a5 */
new_eax = var08 & 3;
new_ecx = (((loc_esi << 4) + new_eax) * 2) + new_ebx;
var0C = new_eax;
if ((new_eax = lzma_486248(&var40, &new_ecx, orgsource, size_sum)) == 0xffffffff)
return -1;
if (new_eax) {
/* loc_486549 */
new_ecx = new_ebx + loc_esi * 2 + 0x180;
var20 = 1;
/* eax=1 */
if ((new_eax = lzma_486248(&var40, &new_ecx, orgsource, size_sum)) == 0xffffffff)
return -1;
if (new_eax != 1) {
/* loc_486627 */
var24 = var10;
var10 = var14;
/* xor eax,eax; cmp esi, 7; setnl al; dec eax; add eax, 0Ah */
/* new_eax = (((loc_esi >= 7)-1)&0xFFFFFFFD) + 0xA; */
new_eax = loc_esi >= 7 ? 10 : 7;
new_ecx = new_ebx + 0x664;
var14 = loc_edi;
loc_esi = new_eax;
if (lzma_4863da(var0C, &var40, &new_ecx, &new_edx, &new_eax, orgsource, size_sum) == 0xffffffff)
return -1;
var0C = new_eax;
if (var0C >= 4)
new_eax = 3;
/* loc_486662 */
new_edx = 6;
new_eax <<= 7;
new_ecx = new_eax + new_ebx + 0x360;
if (lzma_4862e0(&var40, &new_ecx, &new_edx, &new_eax, orgsource, size_sum) == 0xffffffff)
return -1;
if (new_eax < 4) {
/* loc_4866ca */
loc_edi = new_eax;
} else {
/* loc_48667d */
uint32_t loc_ecx;
loc_ecx = ((int32_t)new_eax >> 1) - 1; /* sar */
loc_edi = ((new_eax & 1) | 2) << (loc_ecx & 0xff);
if (new_eax >= 0xe) {
/* loc_4866ab */
new_edx = loc_ecx - 4;
if (lzma_486204(&var40, new_edx, &new_eax, orgsource, size_sum) == 0xffffffff)
return -1;
loc_edi += new_eax << 4;
new_edx = 4;
new_ecx = new_ebx + 0x644;
} else {
/* loc_486691 */
new_edx = loc_ecx;
loc_ecx = loc_edi - new_eax;
new_ecx = new_ebx + loc_ecx * 2 + 0x55e;
}
/* loc_4866a2 */
if (lzma_48631a(&var40, &new_ecx, &new_edx, &new_eax, orgsource, size_sum) == 0xffffffff)
return -1;
loc_edi += new_eax;
}
loc_edi++;
} else {
/* loc_486568 */
new_ecx = new_ebx + loc_esi * 2 + 0x198;
if ((new_eax = lzma_486248(&var40, &new_ecx, orgsource, size_sum)) == 0xffffffff)
return -1;
if (new_eax) {
/* loc_4865bd */
new_ecx = new_ebx + loc_esi * 2 + 0x1B0;
if ((new_eax = lzma_486248(&var40, &new_ecx, orgsource, size_sum)) == 0xffffffff)
return -1;
if (new_eax) {
/* loc_4865d2 */
new_ecx = new_ebx + loc_esi * 2 + 0x1C8;
if ((new_eax = lzma_486248(&var40, &new_ecx, orgsource, size_sum)) == 0xffffffff)
return -1;
if (new_eax) {
/* loc_4865ea */
new_eax = var24;
var24 = var10;
} else {
/* loc_4865e5 */
new_eax = var10;
}
/* loc_4865f3 */
var10 = var14;
} else {
/* loc_4865cd */
new_eax = var14;
}
/* loc_4865f9 */
var14 = loc_edi;
loc_edi = new_eax;
} else {
/* loc_48657e */
new_eax = ((loc_esi + 0xf) << 4) + var0C;
new_ecx = new_ebx + new_eax * 2;
if ((new_eax = lzma_486248(&var40, &new_ecx, orgsource, size_sum)) == 0xffffffff)
return -1;
if (!new_eax) {
uint32_t loc_ecx;
/* loc_486593 */
loc_ecx = var08;
loc_ecx -= loc_edi;
/* loc_esi = ((((loc_esi >= 7)-1)&0xFFFFFFFE) + 0xB); */
loc_esi = loc_esi >= 7 ? 11 : 9;
if (!CLI_ISCONTAINED((uint8_t *)orgsource, size_sum, var18 + loc_ecx, 1))
return -1;
var1 = *(var18 + loc_ecx);
loc_ecx = (loc_ecx & 0xffffff00) | var1;
/* loc_4865af */
new_edx = var08++;
if (!CLI_ISCONTAINED((uint8_t *)orgsource, size_sum, var18 + new_edx, 1))
return -1;
*(var18 + new_edx) = loc_ecx & 0xff;
/* loc_4866fe */
new_eax = var08;
continue; /* !!! */
}
}
/* loc_4865fe */
new_ecx = new_ebx + 0xa68;
if (lzma_4863da(var0C, &var40, &new_ecx, &new_edx, &new_eax, orgsource, size_sum) == 0xffffffff)
return -1;
var0C = new_eax;
/* new_eax = (((loc_esi >= 7)-1)&0xFFFFFFFD) + 0xB; */
new_eax = loc_esi >= 7 ? 11 : 8;
loc_esi = new_eax;
}
/* loc_4866cd */
if (!loc_edi) {
break;
} else {
var0C += 2;
new_ecx = (char *)var18;
new_edx = new_eax = var08;
new_eax -= loc_edi;
if (((var0C < var28 - new_edx) &&
(!CLI_ISCONTAINED(orgsource, size_sum, (char *)(new_ecx + new_eax), var0C) ||
!CLI_ISCONTAINED(orgsource, size_sum, (char *)(new_ecx + new_edx), var0C))) ||
(!CLI_ISCONTAINED(orgsource, size_sum, (char *)(new_ecx + new_eax), var28 - new_edx) ||
!CLI_ISCONTAINED(orgsource, size_sum, (char *)(new_ecx + new_edx), var28 - new_edx)))
return -1;
do {
var1 = *(uint8_t *)(new_ecx + new_eax);
*(uint8_t *)(new_ecx + new_edx) = var1;
new_edx++;
new_eax++;
var0C--;
if (var0C <= 0)
break;
} while (new_edx < var28);
var08 = new_edx;
}
} else {
/* loc_4864C8 */
new_eax = (((var1 & 0xff) >> 4) * 3) << 9;
new_ecx = new_eax + new_ebx + 0xe6c;
var0C_ecxcopy = new_ecx;
if (loc_esi >= 4) {
/* loc_4864e8 */
if (loc_esi >= 10)
loc_esi -= 6;
else
loc_esi -= 3;
} else {
/* loc_4864e4 */
loc_esi = 0;
}
if (var20 == 0) {
/* loc_48651D */
new_eax = 1;
do {
/* loc_486525 */
/*new_ecx = var0C_ecxcopy;*/
new_eax += new_eax;
new_ecx += new_eax;
var34 = new_eax;
if ((new_eax = lzma_486248(&var40, &new_ecx, orgsource, size_sum)) == 0xffffffff)
return -1;
new_eax |= var34;
/* loc_486522 */
/* keeping it here instead of at the top
* seems to work faster
*/
if (new_eax < 0x100) {
new_ecx = var0C_ecxcopy;
}
} while (new_eax < 0x100);
/* loc_48653e */
var1 = (uint8_t)(new_eax & 0xff);
} else {
int t;
/* loc_4864FB */
new_eax = var08 - loc_edi;
if (!CLI_ISCONTAINED((uint8_t *)orgsource, size_sum, var18 + new_eax, 1))
return -1;
t = *(var18 + new_eax);
new_eax = (new_eax & 0xffffff00) | t;
var30 = t;
if (lzma_48635C(t, &new_ecx, &var40, &new_eax, orgsource, size_sum) == 0xffffffff)
return -1;
var20 = 0;
var1 = new_eax & 0xff;
}
/* loc_486541 */
/* unneeded: new_ecx = (new_ecx&0xffffff00) | var1; */
/* loc_4865af */
new_edx = var08++;
if (!CLI_ISCONTAINED((uint8_t *)orgsource, size_sum, var18 + new_edx, 1))
return -1;
*(var18 + new_edx) = var1;
}
/* loc_4866fe */
new_eax = var08;
} while (new_eax < var28);
while (special) {
uint32_t loc_ecx;
/* let's fix calls */
cli_dbgmsg("MEWlen: %08x ? %08x\n", new_edx, pushed_edx);
if (pushed_edx < 5 || !CLI_ISCONTAINED(orgsource, size_sum, pushed_esi, pushed_edx))
return 0; /* No point in full failing just because we can't fixxup the calls */
for (loc_ecx = 0; loc_ecx < pushed_edx - 5; loc_ecx++) {
/* 0xe8, 0xe9 call opcodes */
if (pushed_esi[loc_ecx] == '\xe8' || pushed_esi[loc_ecx] == '\xe9') {
char *adr = (char *)(pushed_esi + loc_ecx + 1);
cli_writeint32(adr, EC32(CE32((uint32_t)cli_readint32(adr))) - loc_ecx - 1);
loc_ecx += 4;
}
}
return 0; /*pushed_edx;*/
}
} while (mainloop);
return 0xbadc0de;
}
/* UPack lzma */
/* compare with 486248 */
uint32_t lzma_upack_esi_00(struct lzmastate *p, char *old_ecx, char *bb, uint32_t bl)
{
uint32_t loc_eax, ret, loc_edi;
loc_eax = p->p1 >> 0xb;
if (!CLI_ISCONTAINED(bb, bl, old_ecx, 4) || !CLI_ISCONTAINED(bb, bl, p->p0, 4)) {
if (!CLI_ISCONTAINED(bb, bl, old_ecx, 4))
cli_dbgmsg("contain error! %p %08x ecx: %p [%p]\n", bb, bl, old_ecx, bb + bl);
else
cli_dbgmsg("contain error! %p %08x p0: %p [%p]\n", bb, bl, p->p0, bb + bl);
return 0xffffffff;
}
ret = cli_readint32(old_ecx);
loc_eax *= ret;
loc_edi = cli_readint32((char *)p->p0);
loc_edi = EC32(CE32(loc_edi)); /* bswap */
loc_edi -= p->p2;
if (loc_edi < loc_eax) {
p->p1 = loc_eax;
loc_eax = (0x800 - ret) >> 5;
cli_writeint32(old_ecx, cli_readint32(old_ecx) + loc_eax);
ret = 0;
} else {
p->p2 += loc_eax;
p->p1 -= loc_eax;
loc_eax = ret >> 5;
cli_writeint32(old_ecx, cli_readint32(old_ecx) - loc_eax);
ret = 1;
}
if (((p->p1) & 0xff000000) == 0) {
p->p2 <<= 8;
p->p1 <<= 8;
p->p0++;
}
return ret;
}
/* compare with lzma_4862e0 */
/* lzma_upack_esi_4c 0x1 as eax!
*/
uint32_t lzma_upack_esi_50(struct lzmastate *p, uint32_t old_eax, uint32_t old_ecx, char **old_edx, char *old_ebp, uint32_t *retval, char *bs, uint32_t bl)
{
uint32_t loc_eax = old_eax, ret;
do {
*old_edx = old_ebp + (loc_eax << 2);
if ((ret = lzma_upack_esi_00(p, *old_edx, bs, bl)) == 0xffffffff)
return 0xffffffff;
loc_eax += loc_eax;
loc_eax += ret;
} while (loc_eax < old_ecx);
*retval = loc_eax - old_ecx;
return 0;
}
uint32_t lzma_upack_esi_54(struct lzmastate *p, uint32_t old_eax, uint32_t *old_ecx, char **old_edx, uint32_t *retval, char *bs, uint32_t bl)
{
uint32_t ret, loc_eax = old_eax;
*old_ecx = ((*old_ecx) & 0xffffff00) | 8;
ret = lzma_upack_esi_00(p, *old_edx, bs, bl);
*old_edx = ((*old_edx) + 4);
loc_eax = (loc_eax & 0xffffff00) | 1;
if (ret) {
ret = lzma_upack_esi_00(p, *old_edx, bs, bl);
loc_eax |= 8; /* mov al, 9 */
if (ret) {
*old_ecx <<= 5;
loc_eax = 0x11; /* mov al, 11 */
}
}
ret = loc_eax;
if (lzma_upack_esi_50(p, 1, *old_ecx, old_edx, *old_edx + (loc_eax << 2), &loc_eax, bs, bl) == 0xffffffff)
return 0xffffffff;
*retval = ret + loc_eax;
return 0;
}
/**
* @brief Unpack MEW 11 packed PE file
*
* @param src buffer to unpack
* @param off offset of diff
* @param ssize pe section size
* @param dsize diff size
* @param base OPTIONAL_HEADER32.ImageBase
* @param vadd RVA of pe section
* @param uselzma Bool - use LZMA
* @param filedesc File descriptor
* @return int Returns -1 on failure, 1 on success.
*/
int unmew11(char *src, uint32_t off, uint32_t ssize, uint32_t dsize, uint32_t base, uint32_t vadd, int uselzma, int filedesc)
{
uint32_t entry_point, newedi, loc_ds = dsize, loc_ss = ssize;
char *source = NULL;
const char *lesi = NULL;
char *ledi;
const char *f1;
char *f2;
int i;
struct cli_exe_section *section = NULL;
uint32_t vma = base + vadd;
uint32_t size_sum = ssize + dsize;
/* Guard against integer overflows */
if (base + vadd < base) {
cli_dbgmsg("MEW: base (%08x) + PE section RVA (%08x) exceeds max size of unsigned int (%08x)\n",
base, vadd, UINT32_MAX);
return -1;
}
if (ssize + dsize < ssize) {
cli_dbgmsg("MEW: section size (%08x) + diff size (%08x) exceeds max size of unsigned int (%08x)\n",
ssize, dsize, UINT32_MAX);
return -1;
}
if (((size_t)(src + off) < (size_t)(src)) ||
((size_t)(src + off) < (size_t)(off))) {
cli_dbgmsg("MEW: Buffer pointer (%08zx) + offset (%08zx) exceeds max size of pointer (%08lx)\n",
(size_t)src, (size_t)off, SIZE_MAX);
return -1;
}
/* Ensure that off + required data exists within buffer */
if (!CLI_ISCONTAINED(src, size_sum, src + off, 12)) {
cli_dbgmsg("MEW: Data reference exceeds size of provided buffer.\n");
return -1;
}
source = src + dsize + off;
lesi = source + 12;
entry_point = cli_readint32(source + 4);
newedi = cli_readint32(source + 8);
ledi = src + (newedi - vma);
loc_ds = size_sum - (newedi - vma);
i = 0;
loc_ss -= 12;
loc_ss -= off;
while (1) {
cli_dbgmsg("MEW unpacking section %d (%p->%p)\n", i, lesi, ledi);
if (!CLI_ISCONTAINED(src, size_sum, lesi, loc_ss) || !CLI_ISCONTAINED(src, size_sum, ledi, loc_ds)) {
cli_dbgmsg("Possibly programmer error or hand-crafted PE file, report to clamav team\n");
if (section != NULL)
free(section);
return -1;
}
if (unmew(lesi, ledi, loc_ss, loc_ds, &f1, &f2)) {
free(section);
return -1;
}
/* we don't need last section in sections since this is information for fixing imptbl */
if (!CLI_ISCONTAINED(src, size_sum, f1, 4)) {
free(section);
return -1;
}
/* XXX */
loc_ss -= (f1 + 4 - lesi);
lesi = f1 + 4;
ledi = src + (cli_readint32(f1) - vma);
loc_ds = size_sum - (cli_readint32(f1) - vma);
if (!uselzma) {
uint32_t val = PESALIGN(f2 - src, 0x1000);
void *newsect;
if (i && val < section[i].raw) {
cli_dbgmsg("MEW: WTF - please report\n");
free(section);
return -1;
}
if (!(newsect = cli_realloc(section, (i + 2) * sizeof(struct cli_exe_section)))) {
cli_dbgmsg("MEW: Out of memory\n");
free(section);
return -1;
}
section = (struct cli_exe_section *)newsect;
section[0].raw = 0;
section[0].rva = vadd;
section[i + 1].raw = val;
section[i + 1].rva = val + vadd;
section[i].rsz = section[i].vsz = ((i) ? (val - section[i].raw) : val);
/*
* bb#11212 - alternate fix, buffer is aligned
* must validate that sections do not intersect with source
* or, in other words, exceed the specified size of destination
*/
if (section[i].raw + section[i].rsz > dsize) {
cli_dbgmsg("MEW: Section %i [%d, %d] exceeds destination size %u\n",
i, section[i].raw, section[i].raw + section[i].rsz, dsize);
free(section);
return -1;
}
}
i++;
if (!cli_readint32(f1))
break;
}
/* LZMA stuff */
if (uselzma) {
free(section);
/* put everything in one section */
i = 1;
if (!CLI_ISCONTAINED(src, size_sum, src + uselzma + 8, 1)) {
cli_dbgmsg("MEW: couldn't access lzma 'special' tag\n");
return -1;
}
/* 0x50 -> push eax */
cli_dbgmsg("MEW: lzma %swas used, unpacking\n", (*(src + uselzma + 8) == '\x50') ? "special " : "");
if (!CLI_ISCONTAINED(src, size_sum, f1 + 4, 20 + 4 + 5)) {
cli_dbgmsg("MEW: lzma initialization data not available!\n");
return -1;
}
if (mew_lzma(src, f1 + 4, size_sum, vma, *(src + uselzma + 8) == '\x50')) {
return -1;
}
loc_ds = PESALIGN(loc_ds, 0x1000);
section = cli_calloc(1, sizeof(struct cli_exe_section));
if (!section) {
cli_dbgmsg("MEW: Out of memory\n");
return -1;
}
section[0].raw = 0;
section[0].rva = vadd;
section[0].rsz = section[0].vsz = dsize;
}
if (!cli_rebuildpe_align(src, section, i, base, entry_point - base, 0, 0, filedesc, 0x1000)) {
cli_dbgmsg("MEW: Rebuilding failed\n");
free(section);
return -1;
}
free(section);
return 1;
}
Reference in New Issue Copy Permalink