Changes to address issues brought up by the security review.
This commit is contained in:
		@@ -62,9 +62,9 @@ static const uint8_t g_Expand64[256] =
 | 
			
		||||
CasaStatus
 | 
			
		||||
EncodeData(
 | 
			
		||||
   IN    const void *pData,
 | 
			
		||||
   IN    const int32_t dataLen,
 | 
			
		||||
   IN    const uint32_t dataLen,
 | 
			
		||||
   INOUT char **ppEncodedData,
 | 
			
		||||
   INOUT int32_t *pEncodedDataLen)
 | 
			
		||||
   INOUT uint32_t *pEncodedDataLen)
 | 
			
		||||
//
 | 
			
		||||
//  Arguments: 
 | 
			
		||||
//
 | 
			
		||||
@@ -88,7 +88,7 @@ EncodeData(
 | 
			
		||||
   if (*ppEncodedData)
 | 
			
		||||
   {
 | 
			
		||||
      uint8_t  *pOut, *pIn;
 | 
			
		||||
      int      i;
 | 
			
		||||
      uint32_t i;
 | 
			
		||||
 | 
			
		||||
      // Setup pointers to move through the buffers
 | 
			
		||||
      pIn = (uint8_t*) pData;
 | 
			
		||||
@@ -147,9 +147,9 @@ EncodeData(
 | 
			
		||||
CasaStatus
 | 
			
		||||
DecodeData(
 | 
			
		||||
   IN    const char *pEncodedData,
 | 
			
		||||
   IN    const int32_t encodedDataLen, // Does not include NULL terminator
 | 
			
		||||
   IN    const uint32_t encodedDataLen, // Does not include NULL terminator
 | 
			
		||||
   INOUT void **ppData,
 | 
			
		||||
   INOUT int32_t *pDataLen)
 | 
			
		||||
   INOUT uint32_t *pDataLen)
 | 
			
		||||
//
 | 
			
		||||
//  Arguments: 
 | 
			
		||||
//
 | 
			
		||||
@@ -161,8 +161,8 @@ DecodeData(
 | 
			
		||||
//=======================================================================--
 | 
			
		||||
{
 | 
			
		||||
   CasaStatus  retStatus;
 | 
			
		||||
   int         i, j;
 | 
			
		||||
   int         decodedSize;
 | 
			
		||||
   uint32_t    i, j;
 | 
			
		||||
   size_t      decodedSize;
 | 
			
		||||
 | 
			
		||||
   DbgTrace(3, "-DecodeData- Start\n", 0);
 | 
			
		||||
 | 
			
		||||
@@ -172,98 +172,110 @@ DecodeData(
 | 
			
		||||
           j++;
 | 
			
		||||
   decodedSize = (j * 3 + 3) / 4;
 | 
			
		||||
 | 
			
		||||
   // Allocate buffer to hold the decoded data
 | 
			
		||||
   *ppData = malloc(decodedSize);
 | 
			
		||||
   if (*ppData)
 | 
			
		||||
   // Verify that we are not going to overflow the uint32
 | 
			
		||||
   if (decodedSize <= UINT32_MAX)
 | 
			
		||||
   {
 | 
			
		||||
      bool  endReached = false;
 | 
			
		||||
      uint8_t  c0, c1, c2, c3;
 | 
			
		||||
      uint8_t  *p, *q;
 | 
			
		||||
 | 
			
		||||
      // Initialize parameters that will be used during the decode operation
 | 
			
		||||
      c0 = c1 = c2 = c3 = 0;
 | 
			
		||||
      p = (uint8_t*) pEncodedData;
 | 
			
		||||
      q = (uint8_t*) *ppData;
 | 
			
		||||
 | 
			
		||||
      // Decode the data
 | 
			
		||||
      //
 | 
			
		||||
      // Loop through the data, piecing back information. Any newlines, and/or
 | 
			
		||||
      // carriage returns need to be skipped.
 | 
			
		||||
      while (j > 4)
 | 
			
		||||
      // Allocate buffer to hold the decoded data
 | 
			
		||||
      *ppData = malloc(decodedSize);
 | 
			
		||||
      if (*ppData)
 | 
			
		||||
      {
 | 
			
		||||
          while ((64 == g_Expand64[*p]) && (('\n' == *p) || ('\r' == *p)))
 | 
			
		||||
              p++;
 | 
			
		||||
          if (64 == g_Expand64[*p])
 | 
			
		||||
          {
 | 
			
		||||
              endReached = true;
 | 
			
		||||
              break;
 | 
			
		||||
          }
 | 
			
		||||
          c0 = *(p++);
 | 
			
		||||
         bool  endReached = false;
 | 
			
		||||
         uint8_t  c0, c1, c2, c3;
 | 
			
		||||
         uint8_t  *p, *q;
 | 
			
		||||
 | 
			
		||||
          while ((64 == g_Expand64[*p]) && (('\n' == *p) || ('\r' == *p)))
 | 
			
		||||
              p++;
 | 
			
		||||
          if (64 == g_Expand64[*p])
 | 
			
		||||
          {
 | 
			
		||||
              *(q++) = (uint8_t)(g_Expand64[c0] << 2);
 | 
			
		||||
              j--;
 | 
			
		||||
              endReached = true;
 | 
			
		||||
              break;
 | 
			
		||||
          }
 | 
			
		||||
          c1 = *(p++);
 | 
			
		||||
         // Initialize parameters that will be used during the decode operation
 | 
			
		||||
         c0 = c1 = c2 = c3 = 0;
 | 
			
		||||
         p = (uint8_t*) pEncodedData;
 | 
			
		||||
         q = (uint8_t*) *ppData;
 | 
			
		||||
 | 
			
		||||
          while ((64 == g_Expand64[*p]) && (('\n' == *p) || ('\r' == *p)))
 | 
			
		||||
              p++;
 | 
			
		||||
          if (64 == g_Expand64[*p])
 | 
			
		||||
          {
 | 
			
		||||
              *(q++) = (uint8_t)(g_Expand64[c0] << 2 | g_Expand64[c1] >> 4);
 | 
			
		||||
              *(q++) = (uint8_t)(g_Expand64[c1] << 4);
 | 
			
		||||
              j -= 2;
 | 
			
		||||
              endReached = true;
 | 
			
		||||
              break;
 | 
			
		||||
          }
 | 
			
		||||
          c2 = *(p++);
 | 
			
		||||
         // Decode the data
 | 
			
		||||
         //
 | 
			
		||||
         // Loop through the data, piecing back information. Any newlines, and/or
 | 
			
		||||
         // carriage returns need to be skipped.
 | 
			
		||||
         while (j > 4)
 | 
			
		||||
         {
 | 
			
		||||
             while ((64 == g_Expand64[*p]) && (('\n' == *p) || ('\r' == *p)))
 | 
			
		||||
                 p++;
 | 
			
		||||
             if (64 == g_Expand64[*p])
 | 
			
		||||
             {
 | 
			
		||||
                 endReached = true;
 | 
			
		||||
                 break;
 | 
			
		||||
             }
 | 
			
		||||
             c0 = *(p++);
 | 
			
		||||
 | 
			
		||||
          while ((64 == g_Expand64[*p]) && (('\n' == *p) || ('\r' == *p)))
 | 
			
		||||
              p++;
 | 
			
		||||
          if (64 == g_Expand64[*p])
 | 
			
		||||
          {
 | 
			
		||||
              *(q++) = (uint8_t)(g_Expand64[c0] << 2 | g_Expand64[c1] >> 4);
 | 
			
		||||
              *(q++) = (uint8_t)(g_Expand64[c1] << 4 | g_Expand64[c2] >> 2);
 | 
			
		||||
              *(q++) = (uint8_t)(g_Expand64[c2] << 6);
 | 
			
		||||
              j -= 3;
 | 
			
		||||
              endReached = true;
 | 
			
		||||
              break;
 | 
			
		||||
          }
 | 
			
		||||
          c3 = *(p++);
 | 
			
		||||
             while ((64 == g_Expand64[*p]) && (('\n' == *p) || ('\r' == *p)))
 | 
			
		||||
                 p++;
 | 
			
		||||
             if (64 == g_Expand64[*p])
 | 
			
		||||
             {
 | 
			
		||||
                 *(q++) = (uint8_t)(g_Expand64[c0] << 2);
 | 
			
		||||
                 j--;
 | 
			
		||||
                 endReached = true;
 | 
			
		||||
                 break;
 | 
			
		||||
             }
 | 
			
		||||
             c1 = *(p++);
 | 
			
		||||
 | 
			
		||||
          *(q++) = (uint8_t)(g_Expand64[c0] << 2 | g_Expand64[c1] >> 4);
 | 
			
		||||
          *(q++) = (uint8_t)(g_Expand64[c1] << 4 | g_Expand64[c2] >> 2);
 | 
			
		||||
          *(q++) = (uint8_t)(g_Expand64[c2] << 6 | g_Expand64[c3]);
 | 
			
		||||
          j -= 4;
 | 
			
		||||
             while ((64 == g_Expand64[*p]) && (('\n' == *p) || ('\r' == *p)))
 | 
			
		||||
                 p++;
 | 
			
		||||
             if (64 == g_Expand64[*p])
 | 
			
		||||
             {
 | 
			
		||||
                 *(q++) = (uint8_t)(g_Expand64[c0] << 2 | g_Expand64[c1] >> 4);
 | 
			
		||||
                 *(q++) = (uint8_t)(g_Expand64[c1] << 4);
 | 
			
		||||
                 j -= 2;
 | 
			
		||||
                 endReached = true;
 | 
			
		||||
                 break;
 | 
			
		||||
             }
 | 
			
		||||
             c2 = *(p++);
 | 
			
		||||
 | 
			
		||||
             while ((64 == g_Expand64[*p]) && (('\n' == *p) || ('\r' == *p)))
 | 
			
		||||
                 p++;
 | 
			
		||||
             if (64 == g_Expand64[*p])
 | 
			
		||||
             {
 | 
			
		||||
                 *(q++) = (uint8_t)(g_Expand64[c0] << 2 | g_Expand64[c1] >> 4);
 | 
			
		||||
                 *(q++) = (uint8_t)(g_Expand64[c1] << 4 | g_Expand64[c2] >> 2);
 | 
			
		||||
                 *(q++) = (uint8_t)(g_Expand64[c2] << 6);
 | 
			
		||||
                 j -= 3;
 | 
			
		||||
                 endReached = true;
 | 
			
		||||
                 break;
 | 
			
		||||
             }
 | 
			
		||||
             c3 = *(p++);
 | 
			
		||||
 | 
			
		||||
             *(q++) = (uint8_t)(g_Expand64[c0] << 2 | g_Expand64[c1] >> 4);
 | 
			
		||||
             *(q++) = (uint8_t)(g_Expand64[c1] << 4 | g_Expand64[c2] >> 2);
 | 
			
		||||
             *(q++) = (uint8_t)(g_Expand64[c2] << 6 | g_Expand64[c3]);
 | 
			
		||||
             j -= 4;
 | 
			
		||||
         }
 | 
			
		||||
         if (!endReached)
 | 
			
		||||
         {
 | 
			
		||||
             if (j > 1)
 | 
			
		||||
                 *(q++) = (uint8_t)(g_Expand64[*p] << 2 | g_Expand64[p[1]] >> 4);
 | 
			
		||||
             if (j > 2)
 | 
			
		||||
                 *(q++) = (uint8_t)(g_Expand64[p[1]] << 4 | g_Expand64[p[2]] >> 2);
 | 
			
		||||
             if (j > 3)
 | 
			
		||||
                 *(q++) = (uint8_t)(g_Expand64[p[2]] << 6 | g_Expand64[p[3]]);
 | 
			
		||||
         }
 | 
			
		||||
 | 
			
		||||
         // Return the length of the decoded data
 | 
			
		||||
         *pDataLen = (int32_t)(q - (uint8_t*)*ppData);
 | 
			
		||||
 | 
			
		||||
         // Success
 | 
			
		||||
         retStatus = CASA_STATUS_SUCCESS;
 | 
			
		||||
      }
 | 
			
		||||
      if (!endReached)
 | 
			
		||||
      else
 | 
			
		||||
      {
 | 
			
		||||
          if (j > 1)
 | 
			
		||||
              *(q++) = (uint8_t)(g_Expand64[*p] << 2 | g_Expand64[p[1]] >> 4);
 | 
			
		||||
          if (j > 2)
 | 
			
		||||
              *(q++) = (uint8_t)(g_Expand64[p[1]] << 4 | g_Expand64[p[2]] >> 2);
 | 
			
		||||
          if (j > 3)
 | 
			
		||||
              *(q++) = (uint8_t)(g_Expand64[p[2]] << 6 | g_Expand64[p[3]]);
 | 
			
		||||
         DbgTrace(0, "-DecodeData- Buffer allocation failure\n", 0);
 | 
			
		||||
 | 
			
		||||
         retStatus = CasaStatusBuild(CASA_SEVERITY_ERROR,
 | 
			
		||||
                                     CASA_FACILITY_AUTHTOKEN,
 | 
			
		||||
                                     CASA_STATUS_INSUFFICIENT_RESOURCES);
 | 
			
		||||
      }
 | 
			
		||||
 | 
			
		||||
      // Return the length of the decoded data
 | 
			
		||||
      *pDataLen = (int32_t)(q - (uint8_t*)*ppData);
 | 
			
		||||
 | 
			
		||||
      // Success
 | 
			
		||||
      retStatus = CASA_STATUS_SUCCESS;
 | 
			
		||||
   }
 | 
			
		||||
   else
 | 
			
		||||
   {
 | 
			
		||||
      DbgTrace(0, "-DecodeData- Buffer allocation failure\n", 0);
 | 
			
		||||
      DbgTrace(0, "-DecodeData- Prevented uint32 overflow\n", 0);
 | 
			
		||||
 | 
			
		||||
      retStatus = CasaStatusBuild(CASA_SEVERITY_ERROR,
 | 
			
		||||
                                  CASA_FACILITY_AUTHTOKEN,
 | 
			
		||||
                                  CASA_STATUS_INSUFFICIENT_RESOURCES);
 | 
			
		||||
                                  CASA_STATUS_UNSUCCESSFUL);
 | 
			
		||||
   }
 | 
			
		||||
 | 
			
		||||
   DbgTrace(3, "-DecodeData- End, retStatus = %0X\n", retStatus);
 | 
			
		||||
 
 | 
			
		||||
		Reference in New Issue
	
	Block a user