Update NSPR to 4.12 and NSS to 3.23 on iOS

nss/lib/util/utf8.c

 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "seccomon.h"
 #include "secport.h"
 
 #ifdef TEST_UTF8
 #include <assert.h>
 #undef PORT_Assert
@@ skipping 301 matching lines @@
     return PR_TRUE;
   } else {
     unsigned int i, len = 0;
     PORT_Assert((inBufLen % 2) == 0);
     if ((inBufLen % 2) != 0) {
       *outBufLen = 0;
       return PR_FALSE;
     }
 
     for( i = 0; i < inBufLen; i += 2 ) {
-      if( (inBuf[i+H_0] == 0x00) && ((inBuf[i+H_0] & 0x80) == 0x00) ) len += 1;
+      if( (inBuf[i+H_0] == 0x00) && ((inBuf[i+H_1] & 0x80) == 0x00) ) len += 1;
       else if( inBuf[i+H_0] < 0x08 ) len += 2;
-      else if( ((inBuf[i+0+H_0] & 0xDC) == 0xD8) ) {
-        if( ((inBuf[i+2+H_0] & 0xDC) == 0xDC) && ((inBufLen - i) > 2) ) {
+      else if( ((inBuf[i+0+H_0] & 0xFC) == 0xD8) ) {
+        if( ((inBufLen - i) > 2) && ((inBuf[i+2+H_0] & 0xFC) == 0xDC) ) {
           i += 2;
           len += 4;
         } else {
           return PR_FALSE;
         }
       }
       else len += 3;
     }
 
     if( len > maxOutBufLen ) {
@@ skipping 13 matching lines @@
         len += 1;
       } else if( inBuf[i+H_0] < 0x08 ) {
         /* 0080-07FF -> 110xxxxx 10xxxxxx */
         /* 00000abc defghijk -> 110abcde 10fghijk */
 
         outBuf[len+0] = 0xC0 | ((inBuf[i+H_0] & 0x07) << 2) 
                              | ((inBuf[i+H_1] & 0xC0) >> 6);
         outBuf[len+1] = 0x80 | ((inBuf[i+H_1] & 0x3F) >> 0);
 
         len += 2;
-      } else if( (inBuf[i+H_0] & 0xDC) == 0xD8 ) {
+      } else if( (inBuf[i+H_0] & 0xFC) == 0xD8 ) {
         int abcde, BCDE;
 
-        PORT_Assert(((inBuf[i+2+H_0] & 0xDC) == 0xDC) && ((inBufLen - i) > 2));
+        PORT_Assert(((inBufLen - i) > 2) && ((inBuf[i+2+H_0] & 0xFC) == 0xDC) );
 
         /* D800-DBFF DC00-DFFF -> 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
         /* 110110BC DEfghijk 110111lm nopqrstu ->
            { Let abcde = BCDE + 1 }
            11110abc 10defghi 10jklmno 10pqrstu */
 
         BCDE = ((inBuf[i+H_0] & 0x03) << 2) | ((inBuf[i+H_1] & 0xC0) >> 6);
         abcde = BCDE + 1;
 
         outBuf[len+0] = 0xF0 | ((abcde & 0x1C) >> 2);
@@ skipping 472 matching lines @@
   { 0x8020, "\xE8\x80\xA0" },
   { 0x8040, "\xE8\x81\x80" },
   { 0x8080, "\xE8\x82\x80" },
   { 0x8100, "\xE8\x84\x80" },
   { 0x8200, "\xE8\x88\x80" },
   { 0x8400, "\xE8\x90\x80" },
   { 0x8800, "\xE8\xA0\x80" },
   { 0x9000, "\xE9\x80\x80" },
   { 0xA000, "\xEA\x80\x80" },
   { 0xC000, "\xEC\x80\x80" },
+  { 0xFB01, "\xEF\xAC\x81" },
   { 0xFFFF, "\xEF\xBF\xBF" }
 
 };
 
 /*
  * UTF-16 vectors
  */
 
 struct utf16 utf16[] = {
   { 0x00010000, { 0xD800, 0xDC00 } },
@@ skipping 281 matching lines @@
   "\xFD\xBF\xBF\xBF\xBF\xBF",
   "\x80",
   "\xC3",
   "\xC3\xC3\x80",
   "\xED\xA0\x80",
   "\xED\xBF\x80",
   "\xED\xBF\xBF",
   "\xED\xA0\x80\xE0\xBF\xBF",
 };
 
+/* illegal UTF-16 sequences, 0-terminated */
+uint16_t utf16_bad[][3] = {
+  /* leading surrogate not followed by trailing surrogate */
+  { 0xD800, 0, 0 },
+  { 0xD800, 0x41, 0 },
+  { 0xD800, 0xfe, 0 },
+  { 0xD800, 0x3bb, 0 },
+  { 0xD800, 0xD800, 0 },
+  { 0xD800, 0xFEFF, 0 },
+  { 0xD800, 0xFFFD, 0 },
+};
+
 static void
 dump_utf8
 (
   char *word,
   unsigned char *utf8,
   char *end
 )
 {
   fprintf(stdout, "%s ", word);
   for( ; *utf8; utf8++ ) {
@@ skipping 47 matching lines @@
       rv = PR_FALSE;
       continue;
     }
 
     if( (sizeof(back) != len) || (e->c != back) ) {
       dump_utf8("Wrong conversion of UTF-8", utf8, " to UCS-4:");
       fprintf(stdout, "expected 0x%08.8x, received 0x%08.8x\n", e->c, back);
       rv = PR_FALSE;
       continue;
     }
+
+    len = strlen(e->utf8) - 1;
+    result = sec_port_ucs4_utf8_conversion_function(PR_FALSE,
+      (unsigned char *)&e->c, sizeof(e->c), utf8 + sizeof(utf8) - len, len,
+      &len);
+
+    if( result || len != strlen(e->utf8) ) {
+      fprintf(stdout, "Length computation error converting UCS-4 0x%08.8x"
+        " to UTF-8\n", e->c);
+      rv = PR_FALSE;
+      continue;
+    }
   }
 
   return rv;
 }
 
 static PRBool
 test_ucs2_chars
 (
   void
 )
@@ skipping 37 matching lines @@
       rv = PR_FALSE;
       continue;
     }
 
     if( (sizeof(back) != len) || (e->c != back) ) {
       dump_utf8("Wrong conversion of UTF-8", utf8, "to UCS-2:");
       fprintf(stdout, "expected 0x%08.8x, received 0x%08.8x\n", e->c, back);
       rv = PR_FALSE;
       continue;
     }
+
+    len = strlen(e->utf8) - 1;
+    result = sec_port_ucs2_utf8_conversion_function(PR_FALSE,
+      (unsigned char *)&e->c, sizeof(e->c), utf8 + sizeof(utf8) - len, len,
+      &len);
+
+    if( result || len != strlen(e->utf8) ) {
+      fprintf(stdout, "Length computation error converting UCS-2 0x%04.4x"
+        " to UTF-8\n", e->c);
+      rv = PR_FALSE;
+      continue;
+    }
   }
 
   return rv;
 }
 
 static PRBool
 test_utf16_chars
 (
   void
 )
@@ skipping 130 matching lines @@
       rv = PR_FALSE;
       continue;
     }
 
   }
 
   return rv;
 }
 
 static PRBool
+test_utf16_bad_chars(void)
+{
+  PRBool rv = PR_TRUE;
+  int i;
+
+  for( i = 0; i < sizeof(utf16_bad)/sizeof(utf16_bad[0]); ++i ) {
+    PRBool result;
+    unsigned char destbuf[18];
+    unsigned int j, len, destlen;
+    uint16_t *buf;
+
+    for( len = 0; utf16_bad[i][len] != 0; ++len )
+      /* nothing */;
+
+    buf = malloc(sizeof(uint16_t) * len);
+    for( j = 0; j < len; ++j )
+      buf[j] = htons(utf16_bad[i][j]);
+
+    result = sec_port_ucs2_utf8_conversion_function(PR_FALSE,
+        (unsigned char *)buf, sizeof(uint16_t) * len, destbuf, sizeof(destbuf),
+        &destlen);
+    if( result ) {
+      fprintf(stdout, "Failed to detect bad UTF-16 string conversion for "
+          "{0x%x,0x%x} (UTF-8 len = %u)\n", utf16_bad[i][0], utf16_bad[i][1],
+          destlen);
+      rv = PR_FALSE;
+    }
+    free(buf);
+  }
+}
+
+static PRBool
 test_iso88591_chars
 (
   void
 )
 {
   PRBool rv = PR_TRUE;
   int i;
 
   for( i = 0; i < sizeof(ucs2)/sizeof(ucs2[0]); i++ ) {
     struct ucs2 *e = &ucs2[i];
@@ skipping 129 matching lines @@
   PRBool result;
 
   ucs4s = (PRUint32 *)calloc(sizeof(ucs4)/sizeof(ucs4[0]), sizeof(PRUint32));
   ucs2s = (PRUint16 *)calloc(sizeof(ucs2)/sizeof(ucs2[0]), sizeof(PRUint16));
 
   if( ((PRUint32 *)NULL == ucs4s) || ((PRUint16 *)NULL == ucs2s) ) {
     fprintf(stderr, "out of memory\n");
     exit(1);
   }
 
-  len = 0;
+  len = 1;
   for( i = 0; i < sizeof(ucs4)/sizeof(ucs4[0]); i++ ) {
     ucs4s[i] = ucs4[i].c;
     len += strlen(ucs4[i].utf8);
   }
 
   ucs4_utf8 = (char *)malloc(len);
 
-  len = 0;
+  len = 1;
   for( i = 0; i < sizeof(ucs2)/sizeof(ucs2[0]); i++ ) {
     ucs2s[i] = ucs2[i].c;
     len += strlen(ucs2[i].utf8);
   }
 
   ucs2_utf8 = (char *)malloc(len);
 
   if( ((char *)NULL == ucs4_utf8) || ((char *)NULL == ucs2_utf8) ) {
     fprintf(stderr, "out of memory\n");
     exit(1);
@@ skipping 176 matching lines @@
   int argc,
   char *argv[]
 )
 {
   byte_order();
 
   if( test_ucs4_chars() &&
       test_ucs2_chars() &&
       test_utf16_chars() &&
       test_utf8_bad_chars() &&
+      test_utf16_bad_chars() &&
       test_iso88591_chars() &&
       test_zeroes() &&
       test_multichars() &&
       PR_TRUE ) {
     fprintf(stderr, "PASS\n");
     return 1;
   } else {
     fprintf(stderr, "FAIL\n");
     return 0;
   }
 }
 
 #endif /* TEST_UTF8 */