← Back to branch summary

~ubuntu-branches/ubuntu/lucid/clamav/lucid-updates

« back to all changes in this revision

Viewing changes to libclamav/disasm.c

  • Committer: Package Import Robot
  • Author(s): Chris, Marc Deslauriers, Chris Pollock
  • Date: 2015-02-08 07:54:07 UTC
  • mfrom: (81.1.10 lucid-security)
  • Revision ID: package-import@ubuntu.com-20150208075407-sjpyx5pb5emtexcl
Tags: 0.98.6+dfsg-0ubuntu0.10.04.1
https://launchpad.net/bugs/1420819
[ Marc Deslauriers ]
* Updated to 0.98.6 to fix security issues, including CVE-2014-9328.
  (LP: #1420819)
* Removed upstreamed patches:
  - d/p/0002-Add-an-additional-n-after-the-number-in-the-pidfile.patch
  - d/p/0017-Bump-.so-version-number.patch

[ Chris Pollock ]
* Drop dh_autoreconf from build-depends
* Remove use of dh_autoreconf from debian/rules
* Adjust list of no LLVM architectures in debian/rules to include powerpc
  to avoid FTBFS on lucid

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/disasm.c
1
1
/*
2
 
 *  Copyright (C) 2008 Sourcefire, Inc.
 
2
 *  Copyright (C) 2008-2013 Sourcefire, Inc.
 
3
 *  Copyright (C) 2014 Cisco Systems, Inc. and/or its affiliates.
 
4
 *  All rights reserved.
3
5
 *
4
6
 *  Authors: aCaB <acab@clamav.net>
5
7
 *
30
32
 
31
33
#include "disasmpriv.h"
32
34
#include "disasm.h"
 
35
#include "clamav.h"
33
36
 
34
37
enum ADDRS {
35
38
  ADDR_REG_EAX,
89
92
 
90
93
static const uint8_t regmap[SIZE_DWORD+1][ADDR_REG_GS+1] = {
91
94
  /* SIZE_BYTE */
92
 
  {REG_AL, REG_CL, REG_DL, REG_BL, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID}, 
 
95
  {X86_REG_AL, X86_REG_CL, X86_REG_DL, X86_REG_BL, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID}, 
93
96
  /* SIZE_BYTEH */
94
 
  {REG_AH, REG_CH, REG_DH, REG_BH, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID}, 
 
97
  {X86_REG_AH, X86_REG_CH, X86_REG_DH, X86_REG_BH, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID}, 
95
98
  /* SIZE_WORD */
96
 
  {REG_AX, REG_CX, REG_DX, REG_BX, REG_SP, REG_BP, REG_SI, REG_DI, REG_ES, REG_CS, REG_SS, REG_DS, REG_FS, REG_GS},
 
99
  {X86_REG_AX, X86_REG_CX, X86_REG_DX, X86_REG_BX, X86_REG_SP, X86_REG_BP, X86_REG_SI, X86_REG_DI, X86_REG_ES, X86_REG_CS, X86_REG_SS, X86_REG_DS, X86_REG_FS, X86_REG_GS},
97
100
  /* SIZE_DWORD */
98
 
  {REG_EAX, REG_ECX, REG_EDX, REG_EBX, REG_ESP, REG_EBP, REG_ESI, REG_EDI, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID}
 
101
  {X86_REG_EAX, X86_REG_ECX, X86_REG_EDX, X86_REG_EBX, X86_REG_ESP, X86_REG_EBP, X86_REG_ESI, X86_REG_EDI, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID}
99
102
};
100
103
 
101
104
static const uint8_t mrm_regmap[3][8] = {
102
105
  /* SIZEB */
103
 
  {REG_AL, REG_CL, REG_DL, REG_BL, REG_AH, REG_CH, REG_DH, REG_BH},
 
106
  {X86_REG_AL, X86_REG_CL, X86_REG_DL, X86_REG_BL, X86_REG_AH, X86_REG_CH, X86_REG_DH, X86_REG_BH},
104
107
  /* SIZEW */
105
 
  {REG_AX, REG_CX, REG_DX, REG_BX, REG_SP, REG_BP, REG_SI, REG_DI},
 
108
  {X86_REG_AX, X86_REG_CX, X86_REG_DX, X86_REG_BX, X86_REG_SP, X86_REG_BP, X86_REG_SI, X86_REG_DI},
106
109
  /* SIZED */
107
 
  {REG_EAX, REG_ECX, REG_EDX, REG_EBX, REG_ESP, REG_EBP, REG_ESI, REG_EDI}
 
110
  {X86_REG_EAX, X86_REG_ECX, X86_REG_EDX, X86_REG_EBX, X86_REG_ESP, X86_REG_EBP, X86_REG_ESI, X86_REG_EDI}
108
111
};
109
112
 
110
113
static const uint8_t mrm_sregmap[3][8] = {
111
114
  /* SIZEB */
112
 
  {REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID},
 
115
  {X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID},
113
116
  /* SIZEW */
114
 
  {REG_ES, REG_CS, REG_SS, REG_DS, REG_FS, REG_GS, REG_INVALID, REG_INVALID},
 
117
  {X86_REG_ES, X86_REG_CS, X86_REG_SS, X86_REG_DS, X86_REG_FS, X86_REG_GS, X86_REG_INVALID, X86_REG_INVALID},
115
118
  /* SIZED */
116
 
  {REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID}
 
119
  {X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID}
117
120
};
118
121
 
119
122
static const uint8_t mrm_cregmap[3][8] = {
120
123
  /* SIZEB */
121
 
  {REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID},
 
124
  {X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID},
122
125
  /* SIZEW */
123
 
  {REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID},
 
126
  {X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID},
124
127
  /* SIZED */
125
 
  {REG_CR0, REG_INVALID, REG_CR2, REG_CR3, REG_CR4, REG_INVALID, REG_INVALID, REG_INVALID}
 
128
  {X86_REG_CR0, X86_REG_INVALID, X86_REG_CR2, X86_REG_CR3, X86_REG_CR4, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID}
126
129
};
127
130
 
128
131
static const uint8_t mrm_dregmap[3][8] = {
129
132
  /* SIZEB */
130
 
  {REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID},
 
133
  {X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID},
131
134
  /* SIZEW */
132
 
  {REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID, REG_INVALID},
 
135
  {X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID, X86_REG_INVALID},
133
136
  /* SIZED */
134
 
  {REG_DR0, REG_DR1, REG_DR2, REG_DR3, REG_INVALID, REG_INVALID, REG_DR6, REG_DR7}
 
137
  {X86_REG_DR0, X86_REG_DR1, X86_REG_DR2, X86_REG_DR3, X86_REG_INVALID, X86_REG_INVALID, X86_REG_DR6, X86_REG_DR7}
135
138
};
136
139
 
137
140
static const struct {
138
141
  enum X86REGS r1;
139
142
  enum X86REGS r2;
140
143
} mrm_regmapw[8] = {
141
 
  {REG_BX, REG_SI}, {REG_BX, REG_DI}, {REG_BP, REG_SI}, {REG_BP, REG_DI}, {REG_SI, REG_INVALID}, {REG_DI, REG_INVALID}, {REG_BP, REG_INVALID}, {REG_BX, REG_INVALID}
142
 
};  
 
144
  {X86_REG_BX, X86_REG_SI}, {X86_REG_BX, X86_REG_DI}, {X86_REG_BP, X86_REG_SI}, {X86_REG_BP, X86_REG_DI}, {X86_REG_SI, X86_REG_INVALID}, {X86_REG_DI, X86_REG_INVALID}, {X86_REG_BP, X86_REG_INVALID}, {X86_REG_BX, X86_REG_INVALID}
 
145
};
143
146
 
144
147
static const struct {
145
148
  enum X86OPS op;
1215
1218
      if(s->segment) hr += sprintf(hr, "%s:", x86regs[s->segment]);
1216
1219
      *hr++ = '[';
1217
1220
      *hr = '\0';
1218
 
      if(s->args[i].arg.marg.r1!=REG_INVALID) {
 
1221
      if(s->args[i].arg.marg.r1!=X86_REG_INVALID) {
1219
1222
        switch(s->args[i].arg.marg.scale) {
1220
1223
        case 1:
1221
1224
          hr += sprintf(hr, "%s", x86regs[s->args[i].arg.marg.r1]);
1228
1231
          gotstuff="+";
1229
1232
        }
1230
1233
      }
1231
 
      if(s->args[i].arg.marg.r2!=REG_INVALID) {
 
1234
      if(s->args[i].arg.marg.r2!=X86_REG_INVALID) {
1232
1235
        hr += sprintf(hr, "%s%s", gotstuff, x86regs[s->args[i].arg.marg.r2]);
1233
1236
        gotstuff="+";
1234
1237
      }
1305
1308
          reversed = 1;
1306
1309
        case X87_R:
1307
1310
          s->args[reversed^1].access = ACCESS_REG;
1308
 
          s->args[reversed^1].reg = REG_ST0;
 
1311
          s->args[reversed^1].reg = X86_REG_ST0;
1309
1312
        case X87_ONE:
1310
1313
          s->args[reversed].access = ACCESS_REG;
1311
 
          s->args[reversed].reg = REG_ST0 + (rm&7);
 
1314
          s->args[reversed].reg = X86_REG_ST0 + (rm&7);
1312
1315
          break;
1313
1316
        case X87_NONE:
1314
1317
          break;
1336
1339
          base&=7;
1337
1340
          
1338
1341
          s->args[0].arg.marg.scale = 1<<scale;
1339
 
          if((s->args[0].arg.marg.r2=mrm_regmap[SIZED][base])==REG_EBP && mod==0) {
1340
 
            s->args[0].arg.marg.r2=REG_INVALID;
 
1342
          if((s->args[0].arg.marg.r2=mrm_regmap[SIZED][base])==X86_REG_EBP && mod==0) {
 
1343
            s->args[0].arg.marg.r2=X86_REG_INVALID;
1341
1344
            mod=2;
1342
1345
          }
1343
 
          if((s->args[0].arg.marg.r1=mrm_regmap[SIZED][idx])==REG_ESP) {
 
1346
          if((s->args[0].arg.marg.r1=mrm_regmap[SIZED][idx])==X86_REG_ESP) {
1344
1347
            s->args[0].arg.marg.r1=s->args[0].arg.marg.r2;
1345
 
            s->args[0].arg.marg.scale = (s->args[0].arg.marg.r2!=REG_INVALID);
1346
 
            s->args[0].arg.marg.r2=REG_INVALID;
 
1348
            s->args[0].arg.marg.scale = (s->args[0].arg.marg.r2!=X86_REG_INVALID);
 
1349
            s->args[0].arg.marg.r2=X86_REG_INVALID;
1347
1350
          }
1348
1351
        } else {
1349
1352
          if (mod==0 && rm==5) {
1350
1353
            mod=2;
1351
 
            s->args[0].arg.marg.r1=REG_INVALID;
 
1354
            s->args[0].arg.marg.r1=X86_REG_INVALID;
1352
1355
          } else {
1353
1356
            s->args[0].arg.marg.scale=1;
1354
1357
            s->args[0].arg.marg.r1=mrm_regmap[SIZED][rm];
1355
1358
          }
1356
 
          s->args[0].arg.marg.r2=REG_INVALID;
 
1359
          s->args[0].arg.marg.r2=X86_REG_INVALID;
1357
1360
        }
1358
1361
        if(mod==2) mod+=mod;
1359
1362
        for (i=0; i<mod; i++) {
1363
1366
        }
1364
1367
      } else {
1365
1368
        if (mod==0 && rm==6) {
1366
 
          s->args[0].arg.marg.r1=REG_INVALID;
 
1369
          s->args[0].arg.marg.r1=X86_REG_INVALID;
1367
1370
          mod=2;
1368
1371
        } else {
1369
1372
          s->args[0].arg.marg.scale=1;
1486
1489
        }
1487
1490
 
1488
1491
        s->args[reversed^1].access = ACCESS_REG;
1489
 
        if ((s->args[reversed^1].reg = p[s->args[reversed].size][rop]) == REG_INVALID) INVALIDATE;
 
1492
        if ((s->args[reversed^1].reg = p[s->args[reversed].size][rop]) == X86_REG_INVALID) INVALIDATE;
1490
1493
 
1491
1494
        /* MOVZX size fixxup */
1492
1495
        if(s->real_op == OP_MOVZX || s->real_op == OP_MOVSX)
1523
1526
            base&=7;
1524
1527
 
1525
1528
            s->args[reversed].arg.marg.scale = 1<<scale;
1526
 
            if((s->args[reversed].arg.marg.r2=mrm_regmap[SIZED][base])==REG_EBP && mod==0) {
1527
 
              s->args[reversed].arg.marg.r2=REG_INVALID;
 
1529
            if((s->args[reversed].arg.marg.r2=mrm_regmap[SIZED][base])==X86_REG_EBP && mod==0) {
 
1530
              s->args[reversed].arg.marg.r2=X86_REG_INVALID;
1528
1531
              mod=2;
1529
1532
            }
1530
 
            if((s->args[reversed].arg.marg.r1=mrm_regmap[SIZED][idx])==REG_ESP) {
 
1533
            if((s->args[reversed].arg.marg.r1=mrm_regmap[SIZED][idx])==X86_REG_ESP) {
1531
1534
              s->args[reversed].arg.marg.r1=s->args[reversed].arg.marg.r2;
1532
 
              s->args[reversed].arg.marg.scale = (s->args[reversed].arg.marg.r2!=REG_INVALID);
1533
 
              s->args[reversed].arg.marg.r2=REG_INVALID;
 
1535
              s->args[reversed].arg.marg.scale = (s->args[reversed].arg.marg.r2!=X86_REG_INVALID);
 
1536
              s->args[reversed].arg.marg.r2=X86_REG_INVALID;
1534
1537
            }
1535
1538
          } else {
1536
1539
            if (mod==0 && rm==5) {
1537
1540
              mod=2;
1538
 
              s->args[reversed].arg.marg.r1=REG_INVALID;
 
1541
              s->args[reversed].arg.marg.r1=X86_REG_INVALID;
1539
1542
            } else {
1540
1543
              s->args[reversed].arg.marg.scale=1;
1541
1544
              s->args[reversed].arg.marg.r1=mrm_regmap[SIZED][rm];
1542
1545
            }
1543
 
            s->args[reversed].arg.marg.r2=REG_INVALID;
 
1546
            s->args[reversed].arg.marg.r2=X86_REG_INVALID;
1544
1547
          }
1545
1548
          if(mod==2) mod+=mod;
1546
1549
          for (i=0; i<mod; i++) {
1553
1556
          } else s->args[reversed].arg.marg.disp=0;
1554
1557
        } else {
1555
1558
          if (mod==0 && rm==6) {
1556
 
            s->args[reversed].arg.marg.r1=REG_INVALID;
 
1559
            s->args[reversed].arg.marg.r1=X86_REG_INVALID;
1557
1560
            mod=2;
1558
1561
          } else {
1559
1562
            s->args[reversed].arg.marg.scale=1;
1593
1596
        s->args[0].size=sizemap[x86ops[table][s->table_op].dsize][s->opsize];
1594
1597
        assert(s->args[0].size!=255);
1595
1598
        s->args[0].size>>=1;
1596
 
        s->args[0].arg.marg.r1=REG_INVALID;
1597
 
        s->args[0].arg.marg.r2=REG_INVALID;
 
1599
        s->args[0].arg.marg.r1=X86_REG_INVALID;
 
1600
        s->args[0].arg.marg.r2=X86_REG_INVALID;
1598
1601
        for (i=0; i<sz; i++) {
1599
1602
          GETBYTE(b);
1600
1603
          s->args[0].arg.marg.disp+=b<<(i*8);
1657
1660
        s->args[1].size=sizemap[x86ops[table][s->table_op].ssize][s->opsize];
1658
1661
        assert(s->args[1].size!=255);
1659
1662
        s->args[1].size>>=1;
1660
 
        s->args[1].arg.marg.r1=REG_INVALID;
1661
 
        s->args[1].arg.marg.r2=REG_INVALID;
 
1663
        s->args[1].arg.marg.r1=X86_REG_INVALID;
 
1664
        s->args[1].arg.marg.r2=X86_REG_INVALID;
1662
1665
        for (i=0; i<sz; i++) {
1663
1666
          GETBYTE(b);
1664
1667
          s->args[1].arg.marg.disp+=b<<(i*8);