Changeset 871


Ignore:
Timestamp:
Nov 17, 2007, 1:13:23 AM (13 years ago)
Author:
Steven Levine
Message:

Correct hex edit buffer sizing to avoid data loss
Detect and report overflows in fixup()

Location:
trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/HISTORY

    r866 r871  
    11New stuff's at the top.  This list is not necessarily complete.
     2
     33.09(pre)
     4 o Correct hex edit buffer sizing to avoid data loss
    25
    363.08
  • trunk/dll/inis.c

    r847 r871  
    2020  19 Apr 07 SHL Use FreeDragInfoData.  Add more drag/drop error checks.
    2121  20 Aug 07 GKY Move #pragma alloc_text to end for OpenWatcom compat
     22  16 Nov 07 SHL Ensure fixup buffer sufficiently large
    2223
    2324***********************************************************************/
     
    12161217{
    12171218  INIDATA *inidata;
     1219  size_t l;
    12181220
    12191221  switch (msg) {
     
    12611263                     GetPString(IDS_INIBINARYDATASKIPTEXT)) == MBID_CANCEL)
    12621264            WinDismissDlg(hwnd, 0);
    1263           p = xmallocz(inidata->datalen * 2, pszSrcFile, __LINE__);
     1265          l = inidata->datalen * 4 + 1;
     1266          p = xmallocz(l, pszSrcFile, __LINE__);
    12641267          if (p) {
    1265             fixup(inidata->data, p, inidata->datalen * 2, inidata->datalen);
     1268            fixup(inidata->data, p, l, inidata->datalen);
    12661269            WinSetDlgItemText(hwnd, IAD_DATA, p);
    12671270            free(p);
  • trunk/dll/literal.c

    r834 r871  
    88
    99  Copyright (c) 1993-98 M. Kimes
    10   Copyright (c) 2004, 2006 Steven H.Levine
     10  Copyright (c) 2004, 2007 Steven H.Levine
    1111
    1212  Archive containers
     
    1616  22 Jul 06 SHL Check more run time errors
    1717  20 Aug 07 GKY Move #pragma alloc_text to end for OpenWatcom compat
     18  16 Nov 07 SHL Report fixup buffer overflow
    1819
    1920***********************************************************************/
     
    100101      switch (pszBuf[iBuf + 1]) {
    101102      case 'x':                        /* hexadecimal */
    102         wchar = 0;
    103         iBuf += 2;                        /* get past "\x" */
    104         if (index(HEX, (CHAR) toupper(pszBuf[iBuf])) != -1) {
    105           iBufSave = iBuf;
    106           while (((wpos = index(HEX, (CHAR) toupper(pszBuf[iBuf]))) != -1) &&
    107                  iBuf < iBufSave + 2) {
    108             wchar = (CHAR) (wchar << 4) + (CHAR) wpos;
    109             iBuf++;
    110           }
    111         }
    112         else
    113           wchar = 'x';                        /* just an x */
    114         iBuf--;
    115         *pszOut++ = wchar;
    116         break;
     103        wchar = 0;
     104        iBuf += 2;                        /* get past "\x" */
     105        if (index(HEX, (CHAR) toupper(pszBuf[iBuf])) != -1) {
     106          iBufSave = iBuf;
     107          while (((wpos = index(HEX, (CHAR) toupper(pszBuf[iBuf]))) != -1) &&
     108                 iBuf < iBufSave + 2) {
     109            wchar = (CHAR) (wchar << 4) + (CHAR) wpos;
     110            iBuf++;
     111          }
     112        }
     113        else
     114          wchar = 'x';                        /* just an x */
     115        iBuf--;
     116        *pszOut++ = wchar;
     117        break;
    117118
    118119      case '\\':                        /* we want a "\" */
    119         iBuf++;
    120         *pszOut++ = '\\';
    121         break;
     120        iBuf++;
     121        *pszOut++ = '\\';
     122        break;
    122123
    123124      case 't':                        /* tab CHAR */
    124         iBuf++;
    125         *pszOut++ = '\t';
    126         break;
     125        iBuf++;
     126        *pszOut++ = '\t';
     127        break;
    127128
    128129      case 'n':                        /* new line */
    129         iBuf++;
    130         *pszOut++ = '\n';
    131         break;
     130        iBuf++;
     131        *pszOut++ = '\n';
     132        break;
    132133
    133134      case 'r':                        /* carr return */
    134         iBuf++;
    135         *pszOut++ = '\r';
    136         break;
     135        iBuf++;
     136        *pszOut++ = '\r';
     137        break;
    137138
    138139      case 'b':                        /* back space */
    139         iBuf++;
    140         *pszOut++ = '\b';
    141         break;
     140        iBuf++;
     141        *pszOut++ = '\b';
     142        break;
    142143
    143144      case 'f':                        /* formfeed */
    144         iBuf++;
    145         *pszOut++ = '\x0c';
    146         break;
     145        iBuf++;
     146        *pszOut++ = '\x0c';
     147        break;
    147148
    148149      case 'a':                        /* bell */
    149         iBuf++;
    150         *pszOut++ = '\07';
    151         break;
     150        iBuf++;
     151        *pszOut++ = '\07';
     152        break;
    152153
    153154      case '\'':                        /* single quote */
    154         iBuf++;
    155         *pszOut++ = '\'';
    156         break;
     155        iBuf++;
     156        *pszOut++ = '\'';
     157        break;
    157158
    158159      case '\"':                        /* double quote */
    159160
    160         iBuf++;
    161         *pszOut++ = '\"';
    162         break;
     161        iBuf++;
     162        *pszOut++ = '\"';
     163        break;
    163164
    164165      default:                                /* decimal */
    165         iBuf++;                                /* get past "\" */
    166         wchar = 0;
    167         if (index(DEC, pszBuf[iBuf]) != -1) {
    168           iBufSave = iBuf;
    169           do {                                /* cvt to binary */
    170             wchar = (CHAR) (wchar * 10 + (pszBuf[iBuf++] - 48));
    171           } while (index(DEC, pszBuf[iBuf]) != -1 && iBuf < iBufSave + 3);
    172           iBuf--;
    173         }
    174         else
    175           wchar = pszBuf[iBuf];
    176         *pszOut++ = wchar;
    177         break;
     166        iBuf++;                                /* get past "\" */
     167        wchar = 0;
     168        if (index(DEC, pszBuf[iBuf]) != -1) {
     169          iBufSave = iBuf;
     170          do {                                /* cvt to binary */
     171            wchar = (CHAR) (wchar * 10 + (pszBuf[iBuf++] - 48));
     172          } while (index(DEC, pszBuf[iBuf]) != -1 && iBuf < iBufSave + 3);
     173          iBuf--;
     174        }
     175        else
     176          wchar = pszBuf[iBuf];
     177        *pszOut++ = wchar;
     178        break;
    178179      }                                        // switch
    179180      break;
     
    202203
    203204BOOL wildcard(const PSZ pszBuf, const PSZ pszWildCard,
    204               const BOOL fNotFileSpec)
     205              const BOOL fNotFileSpec)
    205206{
    206207  const CHAR *fstr = pszBuf;
     
    215216      tcard[strlen(tcard) - 1] = 0;
    216217      if (!(strchr(tcard, '?')) && !(strchr(tcard, '*'))){
    217         if (strstr(fstr, tcard)){ //strstr match for *stuff* pattern no wildcards in "stuff"
    218           xfree(tcard);
    219           return TRUE;
    220         }
    221         else{
    222           xfree(tcard);
    223           return FALSE;
    224         }
     218        if (strstr(fstr, tcard)){ //strstr match for *stuff* pattern no wildcards in "stuff"
     219          xfree(tcard);
     220          return TRUE;
     221        }
     222        else{
     223          xfree(tcard);
     224          return FALSE;
     225        }
    225226      }
    226227      xfree(tcard);
     
    228229    else   //reverse search for *stuff pattern "stuff" can contain wildcards
    229230      if (*fcard == '*' && fcard[strlen(fcard) - 1] != '*'){
    230         fstr = strrev(pszBuf);
    231         fcard = strrev(pszWildCard);
    232         reverse = TRUE;
     231        fstr = strrev(pszBuf);
     232        fcard = strrev(pszWildCard);
     233        reverse = TRUE;
    233234      }
    234235     switch (*fcard) { //fm2 standard forward search for all other cases
    235236      case '?':                                /* character substitution */
    236         fcard++;
    237         if (fNotFileSpec || (*fstr != '.' && *fstr != '/' && *fstr != '\\'))
    238           fstr++;                                /* skip (match) next character */
    239         break;
     237        fcard++;
     238        if (fNotFileSpec || (*fstr != '.' && *fstr != '/' && *fstr != '\\'))
     239          fstr++;                                /* skip (match) next character */
     240        break;
    240241
    241242      case '*':
    242         /* find next non-wild character in wildcard */
    243         while (*fcard && (*fcard == '?' || *fcard == '*'))
    244           fcard++;
    245         if (!*fcard){                        /* if last char of wildcard is *, it matches */
    246           if (reverse){
    247             fstr = strrev(pszBuf);
    248             fcard = strrev(pszWildCard);
    249           }
    250           return TRUE;
    251         }
    252         /* skip until partition, match, or eos */
    253         while (*fstr && toupper(*fstr) != toupper(*fcard) &&
    254                (fNotFileSpec || (*fstr != '\\' &&
    255                                  *fstr != '/' && *fstr != '.')))
    256           fstr++;
    257         if (!fNotFileSpec && !*fstr)        /* implicit '.' */
    258           if (*fcard == '.')
    259             fcard++;
    260         break;
     243        /* find next non-wild character in wildcard */
     244        while (*fcard && (*fcard == '?' || *fcard == '*'))
     245          fcard++;
     246        if (!*fcard){                        /* if last char of wildcard is *, it matches */
     247          if (reverse){
     248            fstr = strrev(pszBuf);
     249            fcard = strrev(pszWildCard);
     250          }
     251          return TRUE;
     252        }
     253        /* skip until partition, match, or eos */
     254        while (*fstr && toupper(*fstr) != toupper(*fcard) &&
     255               (fNotFileSpec || (*fstr != '\\' &&
     256                                 *fstr != '/' && *fstr != '.')))
     257          fstr++;
     258        if (!fNotFileSpec && !*fstr)        /* implicit '.' */
     259          if (*fcard == '.')
     260            fcard++;
     261        break;
    261262
    262263      default:
    263         if (!fNotFileSpec && ((*fstr == '/' || *fstr == '\\') &&
    264                               (*fcard == '/' || *fcard == '\\')))
    265           wmatch = TRUE;
    266         else
    267           wmatch = (toupper(*fstr) == toupper(*fcard));
    268         fstr++;
    269         fcard++;
    270         break;
     264        if (!fNotFileSpec && ((*fstr == '/' || *fstr == '\\') &&
     265                              (*fcard == '/' || *fcard == '\\')))
     266          wmatch = TRUE;
     267        else
     268          wmatch = (toupper(*fstr) == toupper(*fcard));
     269        fstr++;
     270        fcard++;
     271        break;
    271272      }
    272273  }  //while
     
    292293
    293294PSZ fixup(const PCH pachIn, PSZ pszOutBuf, const UINT cBufBytes,
    294           const UINT cInBytes)
     295          const UINT cInBytes)
    295296{
    296297  PCH pchIn = pachIn;
    297298  PCH pchOut = pszOutBuf;
    298   PSZ pszTemp;
    299   static CHAR szTemp[5] = "\\x";        // Constant prefix
    300299
    301300  // input is a character array, not a string - may not be null terminated
    302301  // cBufBytes is buffer size
    303302  if (pachIn) {
     303    // 16 Nov 07 SHL fixme to optimize counting and speed
    304304    // Ensure room for null and possible \ escape
    305     while (pchIn - pachIn < cInBytes && pchOut - pszOutBuf + 2 < cBufBytes) {
     305    while (pchIn - pachIn < cInBytes) {
     306      if (pchOut - pszOutBuf + 4 >= cBufBytes) {
     307        *pchOut = 0;
     308        Runtime_Error(pszSrcFile, __LINE__, "buffer too small for %s", pszOutBuf);
     309        break;
     310      }
     311
    306312      if (!isprint(*pchIn)) {
    307         if (*pchIn == '\r') {
    308           *pchOut++ = '\\';
    309           *pchOut++ = 'r';
    310         }
    311         else if (*pchIn == '\n') {
    312           *pchOut++ = '\\';
    313           *pchOut++ = 'n';
    314         }
    315         else if (*pchIn == '\b') {
    316           *pchOut++ = '\\';
    317           *pchOut++ = 'b';
    318         }
    319         else {
    320           sprintf(szTemp + 2, "%02x", (UCHAR)*pchIn);
    321           for (pszTemp = szTemp; *pszTemp;)
    322             *pchOut++ = *pszTemp++;
    323         }
    324         pchIn++;
     313        if (*pchIn == '\r') {
     314          *pchOut++ = '\\';
     315          *pchOut++ = 'r';
     316        }
     317        else if (*pchIn == '\n') {
     318          *pchOut++ = '\\';
     319          *pchOut++ = 'n';
     320        }
     321        else if (*pchIn == '\b') {
     322          *pchOut++ = '\\';
     323          *pchOut++ = 'b';
     324        }
     325        else {
     326          sprintf(pchOut, "\\x%02x", (UCHAR)*pchIn);
     327          pchOut += 4;
     328        }
     329        pchIn++;
    325330      }
    326331      else if (*pchIn == '\\') {
    327         *pchOut++ = '\\';
    328         *pchOut++ = '\\';
    329         pchIn++;
     332        *pchOut++ = '\\';
     333        *pchOut++ = '\\';
     334        pchIn++;
    330335      }
    331336      else
    332         *pchOut++ = *pchIn++;
    333     }                                        // while
    334   }                                        // if pachIn
     337        *pchOut++ = *pchIn++;
     338    } // while
     339
     340  } // if pachIn
    335341  *pchOut = 0;
    336342  return pszOutBuf;
  • trunk/dll/saveclip.c

    r847 r871  
    1919  20 Aug 07 GKY Move #pragma alloc_text to end for OpenWatcom compat
    2020  27 Sep 07 SHL Correct ULONGLONG size formatting
     21  16 Nov 07 SHL Ensure fixup buffer sufficiently large
    2122
    2223***********************************************************************/
     
    3839
    3940static PSZ pszSrcFile = __FILE__;
     41#define MAX_PATTERN_BYTES 80
    4042
    4143BOOL SaveToClip(HWND hwnd, CHAR * text, BOOL append)
     
    216218        PrfQueryProfileData(fmprof,
    217219                            appname, "SaveToListName", savename, &size);
    218         size = 81;
     220        size = MAX_PATTERN_BYTES + 1;
    219221        PrfQueryProfileData(fmprof,
    220222                            appname, "SaveToListPattern", pattern, &size);
     
    224226        strcpy(pattern, "%F  %s");
    225227      {
    226         CHAR temp[162];
     228        CHAR temp[MAX_PATTERN_BYTES * 4 + 1];
    227229
    228230        fixup(pattern, temp, sizeof(temp), strlen(pattern));
     
    574576        PrfQueryProfileData(fmprof,
    575577                            appname, "SaveToListName", savename, &size);
    576         size = 81;
     578        size = MAX_PATTERN_BYTES + 1;
    577579        PrfQueryProfileData(fmprof,
    578580                            appname, "SaveToListPattern", pattern, &size);
     
    582584        strcpy(pattern, "%F  %s");
    583585      {
    584         CHAR temp[162];
     586        CHAR temp[MAX_PATTERN_BYTES * 4 + 1];
    585587
    586588        fixup(pattern, temp, sizeof(temp), strlen(pattern));
Note: See TracChangeset for help on using the changeset viewer.