Changeset 41


Ignore:
Timestamp:
Oct 26, 2002, 6:50:40 AM (23 years ago)
Author:
root
Message:

AutoObjProc: catch buff2 overflows
CreateHexDump: catch buffer overflow

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/dll/autoview.c

    r2 r41  
     1
     2/***********************************************************************
     3
     4  $Id$
     5
     6  Auto view
     7
     8  Copyright (c) 1993-98 M. Kimes
     9  Copyright (c) 2001, 2002 Steven H.Levine
     10
     11  Revisions     12 Sep 02 SHL - AutoObjProc: catch buff2 overflows
     12                25 Oct 02 SHL - CreateHexDump: catch buffer overflow
     13
     14***********************************************************************/
     15
     16
    117#define INCL_DOS
    218#define INCL_WIN
     
    192208
    193209
    194 ULONG CreateHexDump (CHAR *value,ULONG cbValue,CHAR *ret,ULONG retlen,
    195                      ULONG startval,BOOL longlead) {
    196 
    197   register CHAR  *p,*pp,*a;
    198   register ULONG  x = 0,y,z;
    199 
    200   if(value && cbValue && ret && retlen) {
    201     pp = p = value;
    202     a = ret;
    203     if(startval)
    204       *a++ = '\n';
    205     while(x < cbValue && a - ret < retlen) {
    206       y = x;
    207       if(longlead)
    208         sprintf(a,"%08lx  ",x + startval);
     210ULONG CreateHexDump (CHAR *pchInBuf,ULONG cbInBuf,
     211                     CHAR *pchOutBuf,ULONG cbOutBuf,
     212                     ULONG cOffset,BOOL fLongAddr)
     213{
     214  register CHAR  *pchIn,*pchReset,*pchOut;
     215  register ULONG  ibIn = 0,ibIn2,ibInFill;
     216  ULONG cbOutLine = 6 + (fLongAddr ? 4 : 0) + 16 * 3 + 1 + 16 + 1;
     217
     218  if(pchInBuf && cbInBuf && pchOutBuf && cbOutBuf) {
     219    pchIn = pchInBuf;
     220    pchOut = pchOutBuf;
     221    if(cOffset)
     222      *pchOut++ = '\n';
     223    while (ibIn < cbInBuf) {
     224      if (pchOut - pchOutBuf + cbOutLine >= cbOutBuf) {
     225        saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,"hex buf ovf");
     226        break;
     227      }
     228      pchReset = pchIn;
     229      ibIn2 = ibIn;
     230      if(fLongAddr)
     231        sprintf(pchOut,"%08lx  ",ibIn + cOffset);
    209232      else
    210         sprintf(a,"%04lx  ",x + startval);
    211       a += (6 + (startval != 0L) + ((longlead != 0L) * 4));
     233        sprintf(pchOut,"%04lx  ",ibIn + cOffset);
     234      pchOut += 6 + (fLongAddr ? 4 : 0);
    212235      do {
    213         sprintf(a,"%02hx ",*p);
    214         a += 3;
    215         p++;
    216         x++;
    217       } while(x < cbValue && (x % 16));
    218       if(x % 16) {
    219         z = x;
    220         while(z % 16) {
    221           *a++ = ' ';
    222           *a++ = ' ';
    223           *a++ = ' ';
    224           z++;
     236        sprintf(pchOut,"%02hx ",*pchIn);
     237        pchOut += 3;
     238        pchIn++;
     239        ibIn++;
     240      } while(ibIn < cbInBuf && (ibIn % 16));
     241      if(ibIn % 16) {
     242        ibInFill = ibIn;
     243        while(ibInFill % 16) {
     244          *pchOut++ = ' ';
     245          *pchOut++ = ' ';
     246          *pchOut++ = ' ';
     247          ibInFill++;
    225248        }
    226249      }
    227       *a++ = ' ';
    228       p = pp;
     250      *pchOut++ = ' ';
     251      pchIn = pchReset;
    229252      do {
    230         if(*p && *p != '\n' && *p != '\r' && *p != '\t' && *p != '\x1a')
    231           *a++ = *p++;
     253        if(*pchIn && *pchIn != '\n' && *pchIn != '\r' && *pchIn != '\t' && *pchIn != '\x1a')
     254          *pchOut++ = *pchIn++;
    232255        else {
    233           *a++ = '.';
    234           p++;
     256          *pchOut++ = '.';
     257          pchIn++;
    235258        }
    236         y++;
    237       } while(y < x);
    238       if(x < cbValue)
    239         *a++ = '\n';
    240       pp = p;
    241     }
    242     *a = 0;
    243     return (ULONG)(a - ret);
     259        ibIn2++;
     260      } while(ibIn2 < ibIn);
     261      if(ibIn < cbInBuf)
     262        *pchOut++ = '\n';
     263    } // while ibIn
     264    *pchOut = 0;
     265    return (ULONG)(pchOut - pchOutBuf);
    244266  }
    245267  return 0L;
     
    265287
    266288              HFILE     handle;
    267               ULONG     action,olen,len,l;
    268               CHAR     *buff,*buff2,*p,buffer[80];
     289              ULONG     action,olen,ibufflen,obufflen,l;
     290              CHAR     *ibuff,*obuff,*p,buffer[80];
    269291              ARC_TYPE *info;
    270292
     
    279301                          OPEN_ACCESS_READONLY,
    280302                          0L)) {
    281                 len = (AutoviewHeight < 96) ?
    282                   512 :
    283                   3072;
    284                 buff = malloc(len + 2);
    285                 if(buff) {
    286                   buff2 = malloc((AutoviewHeight < 96) ?
    287                     2049 :
    288                     9217);
    289                   if(buff2) {
    290                     *buff2 = 0;
     303                ibufflen = (AutoviewHeight < 96) ? 512 : 3072;
     304                ibuff = malloc(ibufflen + 2);
     305                if(ibuff) {
     306                  // Depends on CreateHexDump line width
     307                  obufflen = (ibufflen / 16) * (6 + 3 * 16 + 1 + 16 + 1) + 80;
     308                  obuff = malloc(obufflen + 1);
     309                  if(obuff) {
     310                    *obuff = 0;
    291311                    if(!DosRead(handle,
    292                                 buff,
    293                                 len,
    294                                 &len) &&
    295                        len) {
    296                       buff[len] = 0;
    297                       p = buff2;
    298                       if(IsBinary(buff,len)) {
    299                         olen = len;
     312                                ibuff,
     313                                ibufflen,
     314                                &ibufflen) &&
     315                       ibufflen) {
     316                      ibuff[ibufflen] = 0;
     317                      p = obuff;
     318                      if(IsBinary(ibuff,ibufflen)) {
     319                        olen = ibufflen;
     320                        // Check archive
    300321                        if(!loadedarcs)
    301322                          load_archivers();
     
    310331                                                 FILE_BEGIN :
    311332                                                 FILE_END,
    312                                                 &len)) {
     333                                                &ibufflen)) {
    313334                              if(!DosRead(handle,
    314335                                          buffer,
    315336                                          l,
    316                                           &len) &&
    317                                  len == l) {
     337                                          &ibufflen) &&
     338                                 ibufflen == l) {
    318339                                if(!memcmp(info->signature,
    319340                                           buffer,
     
    332353                          p += strlen(p);
    333354                        }
    334                         CreateHexDump(buff,
    335                                       olen,
    336                                       p,
    337                                       ((AutoviewHeight < 96) ? 2048 : 9216) -
    338                                        (p - buff2),
    339                                       0,FALSE);
     355                        CreateHexDump(ibuff,            // Input buffer
     356                                      olen,             // Input buffer size
     357                                      p,                // Output buffer
     358                                      obufflen - (p - obuff),   // Output buffer size
     359                                      0,                // Address offest
     360                                      FALSE);           // Short addresses
    340361                      }
    341362                      else {
    342 
     363                        // Text file
    343364                        register CHAR *src,*dest;
    344365                        CHAR          *endsrc;
    345366
    346                         src = buff;
    347                         dest = buff2;
    348                         endsrc = buff + len;
     367                        src = ibuff;
     368                        dest = obuff;
     369                        endsrc = ibuff + ibufflen;
    349370                        while(src < endsrc) {
    350                           if(dest == buff2 && (*src == '\t' || *src == ' ' ||
     371                          if(dest == obuff && (*src == '\t' || *src == ' ' ||
    351372                             *src == '\r' || *src == '\n')) {
    352373                            src++;
     
    370391                            dest++;
    371392                          }
    372                         }
     393                        } // while
    373394                        *dest = 0;
     395                        if (dest - obuff >= obufflen)
     396                          saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,"obuff ovf");
    374397                      }
    375                       if(*buff2)
    376                         WinSetWindowText(hwndAutoview,buff2);
     398                      if(*obuff)
     399                        WinSetWindowText(hwndAutoview,obuff);
    377400                    }
    378                     free(buff2);
     401                    free(obuff);
    379402                  }
    380                   free(buff);
     403                  free(ibuff);
    381404                }
    382405                DosClose(handle);
     
    388411              static char         fullname[CCHMAXPATH + 4];
    389412              HDIR                hdir = HDIR_CREATE;
    390               ULONG               x,nm,ml,mc;
     413              ULONG               x,nm,ml,mc,bufflen;
    391414              PBYTE               fb;
    392415              PFILEFINDBUF4       pffbFile;
     
    424447                  x++;
    425448                }
    426                 buff = malloc((CCHMAXPATHCOMP + 42) * nm);
     449                bufflen = (CCHMAXPATHCOMP + 42) * nm;
     450                buff = malloc(bufflen);
    427451                if(buff) {
    428452                  p = buff;
     
    470494                    fb += pffbFile->oNextEntryOffset;
    471495                    x++;
    472                   }
     496                  } // while
     497                  if (p - buff >= bufflen)
     498                    saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,"buff ovf");
    473499                  if(*buff)
    474500                    WinSetWindowText(hwndAutoview,buff);
     
    553579                          len = *(USHORT *)data;
    554580                          data += sizeof(USHORT);
    555                         }
     581                        } // while
     582                        if (p - buff >= 65536) {
     583                          saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,"eabuff ovf");
     584                          buff[65535] = 0;      // Try to stay alive
     585                          break;
     586                        }
    556587                        WinSetWindowText(hwndAutoMLE,buff);
    557588                        free(buff);
Note: See TracChangeset for help on using the changeset viewer.