Add unit tests for ascii85 and hex decoders.

core/src/fpdfapi/fpdf_parser/fpdf_parser_decode.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include <limits.h>
 
 #include "core/include/fpdfapi/fpdf_module.h"
 #include "core/include/fpdfapi/fpdf_parser.h"
@@ skipping 31 matching lines @@
     0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7, 0x00e8, 0x00e9,
     0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef, 0x00f0, 0x00f1, 0x00f2,
     0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7, 0x00f8, 0x00f9, 0x00fa, 0x00fb,
     0x00fc, 0x00fd, 0x00fe, 0x00ff};
 
 FX_DWORD A85Decode(const uint8_t* src_buf,
                    FX_DWORD src_size,
                    uint8_t*& dest_buf,
                    FX_DWORD& dest_size) {
   dest_size = 0;
-  dest_buf = NULL;
-  if (src_size == 0) {
+  dest_buf = nullptr;
+  if (src_size == 0)
     return 0;
-  }
+
+  // Count legal characters and zeros.
   FX_DWORD zcount = 0;
   FX_DWORD pos = 0;
   while (pos < src_size) {
     uint8_t ch = src_buf[pos];
-    if (ch < '!' && ch != '\n' && ch != '\r' && ch != ' ' && ch != '\t') {
-      break;
-    }
     if (ch == 'z') {
       zcount++;
-    } else if (ch > 'u') {
+    } else if ((ch < '!' || ch > 'u') && !PDFCharIsLineEnding(ch) &&
+               ch != ' ' && ch != '\t') {
       break;
     }
     pos++;
   }
-  if (pos == 0) {
+  // No content to decode.
+  if (pos == 0)
     return 0;
-  }
-  if (zcount > UINT_MAX / 4) {
-    return (FX_DWORD)-1;
-  }
-  if (zcount * 4 > UINT_MAX - (pos - zcount)) {
+
+  if (zcount > (UINT_MAX - (pos - zcount)) / 4) {
     return (FX_DWORD)-1;
   }
   dest_buf = FX_Alloc(uint8_t, zcount * 4 + (pos - zcount));

[Lei Zhang, 2016/02/06 01:22:02]

I looked at this just now - isn't this just: zcount * 3 + pos? In which case,
the overflow check can be simplified to:

zcount > (UINT_MAX - pos) / 3

[Wei Li, 2016/02/06 02:18:59]

Now let's make it right :)

-  int state = 0;
+  size_t state = 0;
   uint32_t res = 0;
   pos = dest_size = 0;
   while (pos < src_size) {
     uint8_t ch = src_buf[pos++];
     if (PDFCharIsLineEnding(ch) || ch == ' ' || ch == '\t')
       continue;
 
     if (ch == 'z') {
       FXSYS_memset(dest_buf + dest_size, 0, 4);
       state = 0;
       res = 0;
       dest_size += 4;
-    } else {
-      if (ch < '!' || ch > 'u') {
-        break;
-      }
+    } else if (ch >= '!' && ch <= 'u') {
       res = res * 85 + ch - 33;
       state++;
       if (state == 5) {
-        for (int i = 0; i < 4; i++) {
+        for (size_t i = 0; i < 4; i++) {
           dest_buf[dest_size++] = (uint8_t)(res >> (3 - i) * 8);
         }
         state = 0;
         res = 0;
       }
+    } else {
+      // The end or illegal character.
+      break;
     }
   }
+  // Handle partial group.
   if (state) {
-    int i;
-    for (i = state; i < 5; i++) {
+    for (size_t i = state; i < 5; i++)
       res = res * 85 + 84;
-    }
-    for (i = 0; i < state - 1; i++) {
+    for (size_t i = 0; i < state - 1; i++)
       dest_buf[dest_size++] = (uint8_t)(res >> (3 - i) * 8);
-    }
   }
-  if (pos < src_size && src_buf[pos] == '>') {
+  if (pos < src_size && src_buf[pos] == '>')
     pos++;
-  }
   return pos;
 }
+
 FX_DWORD HexDecode(const uint8_t* src_buf,
                    FX_DWORD src_size,
                    uint8_t*& dest_buf,
                    FX_DWORD& dest_size) {
-  FX_DWORD i;
-  for (i = 0; i < src_size; i++)
-    if (src_buf[i] == '>') {
-      break;
-    }
+  dest_size = 0;
+  if (src_size == 0) {
+    dest_buf = nullptr;
+    return 0;
+  }
+
+  FX_DWORD i = 0;
+  // Find the end of data.
+  while (i < src_size && src_buf[i] != '>')
+    i++;
+
   dest_buf = FX_Alloc(uint8_t, i / 2 + 1);
-  dest_size = 0;
   bool bFirst = true;
   for (i = 0; i < src_size; i++) {
     uint8_t ch = src_buf[i];
     if (PDFCharIsLineEnding(ch) || ch == ' ' || ch == '\t')
       continue;
 
     if (ch == '>') {
       ++i;
       break;
     }
@@ skipping 68 matching lines @@
     } else {
       break;
     }
   }
   FX_DWORD ret = i + 1;
   if (ret > src_size) {
     ret = src_size;
   }
   return ret;
 }
+
 ICodec_ScanlineDecoder* FPDFAPI_CreateFaxDecoder(
     const uint8_t* src_buf,
     FX_DWORD src_size,
     int width,
     int height,
     const CPDF_Dictionary* pParams) {
   int K = 0;
   FX_BOOL EndOfLine = FALSE;
   FX_BOOL ByteAlign = FALSE;
   FX_BOOL BlackIs1 = FALSE;
   int Columns = 1728;
   int Rows = 0;
   if (pParams) {
     K = pParams->GetIntegerBy("K");
     EndOfLine = pParams->GetIntegerBy("EndOfLine");
     ByteAlign = pParams->GetIntegerBy("EncodedByteAlign");
     BlackIs1 = pParams->GetIntegerBy("BlackIs1");
     Columns = pParams->GetIntegerBy("Columns", 1728);
     Rows = pParams->GetIntegerBy("Rows");
     if (Rows > USHRT_MAX) {
       Rows = 0;
     }
     if (Columns <= 0 || Rows < 0 || Columns > USHRT_MAX || Rows > USHRT_MAX) {
-      return NULL;
+      return nullptr;
     }
   }
   return CPDF_ModuleMgr::Get()->GetFaxModule()->CreateDecoder(
       src_buf, src_size, width, height, K, EndOfLine, ByteAlign, BlackIs1,
       Columns, Rows);
 }
+
 static FX_BOOL CheckFlateDecodeParams(int Colors,
                                       int BitsPerComponent,
                                       int Columns) {
   if (Columns < 0) {
     return FALSE;
   }
   int check = Columns;
   if (Colors < 0 || (check > 0 && Colors > INT_MAX / check)) {
     return FALSE;
   }
   check *= Colors;
   if (BitsPerComponent < 0 ||
       (check > 0 && BitsPerComponent > INT_MAX / check)) {
     return FALSE;
   }
   check *= BitsPerComponent;
   if (check > INT_MAX - 7) {
     return FALSE;
   }
   return TRUE;
 }
+
 ICodec_ScanlineDecoder* FPDFAPI_CreateFlateDecoder(
     const uint8_t* src_buf,
     FX_DWORD src_size,
     int width,
     int height,
     int nComps,
     int bpc,
     const CPDF_Dictionary* pParams) {
   int predictor = 0;
   int Colors = 0, BitsPerComponent = 0, Columns = 0;
   if (pParams) {
     predictor = pParams->GetIntegerBy("Predictor");
     Colors = pParams->GetIntegerBy("Colors", 1);
     BitsPerComponent = pParams->GetIntegerBy("BitsPerComponent", 8);
     Columns = pParams->GetIntegerBy("Columns", 1);
     if (!CheckFlateDecodeParams(Colors, BitsPerComponent, Columns)) {
-      return NULL;
+      return nullptr;
     }
   }
   return CPDF_ModuleMgr::Get()->GetFlateModule()->CreateDecoder(
       src_buf, src_size, width, height, nComps, bpc, predictor, Colors,
       BitsPerComponent, Columns);
 }
+
 FX_DWORD FPDFAPI_FlateOrLZWDecode(FX_BOOL bLZW,
                                   const uint8_t* src_buf,
                                   FX_DWORD src_size,
                                   CPDF_Dictionary* pParams,
                                   FX_DWORD estimated_size,
                                   uint8_t*& dest_buf,
                                   FX_DWORD& dest_size) {
   int predictor = 0;
   FX_BOOL bEarlyChange = TRUE;
   int Colors = 0, BitsPerComponent = 0, Columns = 0;
   if (pParams) {
     predictor = pParams->GetIntegerBy("Predictor");
     bEarlyChange = pParams->GetIntegerBy("EarlyChange", 1);
     Colors = pParams->GetIntegerBy("Colors", 1);
     BitsPerComponent = pParams->GetIntegerBy("BitsPerComponent", 8);
     Columns = pParams->GetIntegerBy("Columns", 1);
     if (!CheckFlateDecodeParams(Colors, BitsPerComponent, Columns)) {
       return (FX_DWORD)-1;
     }
   }
   return CPDF_ModuleMgr::Get()->GetFlateModule()->FlateOrLZWDecode(
       bLZW, src_buf, src_size, bEarlyChange, predictor, Colors,
       BitsPerComponent, Columns, estimated_size, dest_buf, dest_size);
 }
+
 FX_BOOL PDF_DataDecode(const uint8_t* src_buf,
                        FX_DWORD src_size,
                        const CPDF_Dictionary* pDict,
                        uint8_t*& dest_buf,
                        FX_DWORD& dest_size,
                        CFX_ByteString& ImageEncoding,
                        CPDF_Dictionary*& pImageParms,
                        FX_DWORD last_estimated_size,
                        FX_BOOL bImageAcc) {
   CPDF_Object* pDecoder = pDict ? pDict->GetElementValue("Filter") : nullptr;
@@ skipping 17 matching lines @@
   } else {
     DecoderList.Add(pDecoder->GetConstString());
     ParamList.Add(pParams ? pParams->GetDict() : nullptr);
   }
   uint8_t* last_buf = (uint8_t*)src_buf;
   FX_DWORD last_size = src_size;
   for (int i = 0; i < DecoderList.GetSize(); i++) {
     int estimated_size =
         i == DecoderList.GetSize() - 1 ? last_estimated_size : 0;
     CFX_ByteString decoder = DecoderList[i];
-    // Use ToDictionary here because we can push NULL into the ParamList.
+    // Use ToDictionary here because we can push nullptr into the ParamList.
     CPDF_Dictionary* pParam = ToDictionary(ParamList[i]);
     uint8_t* new_buf = nullptr;
     FX_DWORD new_size = (FX_DWORD)-1;
     int offset = -1;
     if (decoder == "FlateDecode" || decoder == "Fl") {
       if (bImageAcc && i == DecoderList.GetSize() - 1) {
         ImageEncoding = "FlateDecode";
         dest_buf = (uint8_t*)last_buf;
         dest_size = last_size;
         pImageParms = pParam;
@@ skipping 43 matching lines @@
     }
     last_buf = new_buf;
     last_size = new_size;
   }
   ImageEncoding = "";
   pImageParms = nullptr;
   dest_buf = last_buf;
   dest_size = last_size;
   return TRUE;
 }
+
 CFX_WideString PDF_DecodeText(const uint8_t* src_data,
                               FX_DWORD src_len,
                               CFX_CharMap* pCharMap) {
   CFX_WideString result;
   if (src_len >= 2 && ((src_data[0] == 0xfe && src_data[1] == 0xff) ||
                        (src_data[0] == 0xff && src_data[1] == 0xfe))) {
     FX_BOOL bBE = src_data[0] == 0xfe;
     FX_DWORD max_chars = (src_len - 2) / 2;
     if (!max_chars) {
       return result;
@@ skipping 27 matching lines @@
     for (FX_DWORD i = 0; i < src_len; i++) {
       dest_buf[i] = PDFDocEncoding[src_data[i]];
     }
     result.ReleaseBuffer(src_len);
   } else {
     return (*pCharMap->m_GetWideString)(
         pCharMap, CFX_ByteString((const FX_CHAR*)src_data, src_len));
   }
   return result;
 }
+
 CFX_ByteString PDF_EncodeText(const FX_WCHAR* pString,
                               int len,
                               CFX_CharMap* pCharMap) {
   if (len == -1) {
     len = FXSYS_wcslen(pString);
   }
   CFX_ByteString result;
   if (!pCharMap) {
     FX_CHAR* dest_buf1 = result.GetBuffer(len);
     int i;
@@ skipping 25 matching lines @@
   dest_buf2[0] = 0xfe;
   dest_buf2[1] = 0xff;
   dest_buf2 += 2;
   for (int i = 0; i < len; i++) {
     *dest_buf2++ = pString[i] >> 8;
     *dest_buf2++ = (uint8_t)pString[i];
   }
   result.ReleaseBuffer(encLen);
   return result;
 }
+
 CFX_ByteString PDF_EncodeString(const CFX_ByteString& src, FX_BOOL bHex) {
   CFX_ByteTextBuf result;
   int srclen = src.GetLength();
   if (bHex) {
     result.AppendChar('<');
     for (int i = 0; i < srclen; i++) {
       result.AppendChar("0123456789ABCDEF"[src[i] / 16]);
       result.AppendChar("0123456789ABCDEF"[src[i] % 16]);
     }
     result.AppendChar('>');
     return result.GetByteString();
   }
   result.AppendChar('(');
   for (int i = 0; i < srclen; i++) {
     uint8_t ch = src[i];
     if (ch == ')' || ch == '\\' || ch == '(') {
       result.AppendChar('\\');
     } else if (ch == 0x0a) {
       result << "\\n";
       continue;
     } else if (ch == 0x0d) {
       result << "\\r";
       continue;
     }
     result.AppendChar(ch);
   }
   result.AppendChar(')');
   return result.GetByteString();
 }
+
 void FlateEncode(const uint8_t* src_buf,
                  FX_DWORD src_size,
                  uint8_t*& dest_buf,
                  FX_DWORD& dest_size) {
   CCodec_ModuleMgr* pEncoders = CPDF_ModuleMgr::Get()->GetCodecModule();
   if (pEncoders) {
     pEncoders->GetFlateModule()->Encode(src_buf, src_size, dest_buf, dest_size);
   }
 }
+
 void FlateEncode(const uint8_t* src_buf,
                  FX_DWORD src_size,
                  int predictor,
                  int Colors,
                  int BitsPerComponent,
                  int Columns,
                  uint8_t*& dest_buf,
                  FX_DWORD& dest_size) {
   CCodec_ModuleMgr* pEncoders = CPDF_ModuleMgr::Get()->GetCodecModule();
   if (pEncoders) {
     pEncoders->GetFlateModule()->Encode(src_buf, src_size, predictor, Colors,
                                         BitsPerComponent, Columns, dest_buf,
                                         dest_size);
   }
 }
+
 FX_DWORD FlateDecode(const uint8_t* src_buf,
                      FX_DWORD src_size,
                      uint8_t*& dest_buf,
                      FX_DWORD& dest_size) {
   CCodec_ModuleMgr* pEncoders = CPDF_ModuleMgr::Get()->GetCodecModule();
   if (pEncoders) {
     return pEncoders->GetFlateModule()->FlateOrLZWDecode(
         FALSE, src_buf, src_size, FALSE, 0, 0, 0, 0, 0, dest_buf, dest_size);
   }
   return 0;
 }