Update NSPR to 4.12 and NSS to 3.23 on iOS

nss/lib/cryptohi/dsautil.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 "cryptohi.h"
 #include "secasn1.h"
 #include "secitem.h"
 #include "prerr.h"
 
 #ifndef DSA1_SUBPRIME_LEN
-#define DSA1_SUBPRIME_LEN 20    /* bytes */
+#define DSA1_SUBPRIME_LEN 20 /* bytes */
 #endif
 
 typedef struct {
     SECItem r;
     SECItem s;
 } DSA_ASN1Signature;
 
 const SEC_ASN1Template DSA_SignatureTemplate[] =
-{
-    { SEC_ASN1_SEQUENCE, 0, NULL, sizeof(DSA_ASN1Signature) },
-    { SEC_ASN1_INTEGER, offsetof(DSA_ASN1Signature,r) },
-    { SEC_ASN1_INTEGER, offsetof(DSA_ASN1Signature,s) },
-    { 0, }
-};
+    {
+      { SEC_ASN1_SEQUENCE, 0, NULL, sizeof(DSA_ASN1Signature) },
+      { SEC_ASN1_INTEGER, offsetof(DSA_ASN1Signature, r) },
+      { SEC_ASN1_INTEGER, offsetof(DSA_ASN1Signature, s) },
+      { 0 }
+    };
 
 /* Input is variable length multi-byte integer, MSB first (big endian).
-** Most signficant bit of first byte is NOT treated as a sign bit. 
-** May be one or more leading bytes of zeros. 
+** Most signficant bit of first byte is NOT treated as a sign bit.
+** May be one or more leading bytes of zeros.
 ** Output is variable length multi-byte integer, MSB first (big endian).
 ** Most significant bit of first byte will be zero (positive sign bit)
 ** No more than one leading zero byte.
 ** Caller supplies dest buffer, and assures that it is long enough,
 ** e.g. at least one byte longer that src's buffer.
 */
 void
 DSAU_ConvertUnsignedToSigned(SECItem *dest, SECItem *src)
 {
     unsigned char *pSrc = src->data;
     unsigned char *pDst = dest->data;
-    unsigned int   cntSrc = src->len;
+    unsigned int cntSrc = src->len;
 
     /* skip any leading zeros. */
-    while (cntSrc && !(*pSrc)) { 
-        pSrc++; 
-        cntSrc--;
+    while (cntSrc && !(*pSrc)) {
+        pSrc++;
+        cntSrc--;
     }
     if (!cntSrc) {
-        *pDst = 0; 
-        dest->len = 1; 
-        return; 
+        *pDst = 0;
+        dest->len = 1;
+        return;
     }
 
     if (*pSrc & 0x80)
-        *pDst++ = 0;
+        *pDst++ = 0;
 
     PORT_Memcpy(pDst, pSrc, cntSrc);
     dest->len = (pDst - dest->data) + cntSrc;
 }
 
 /*
 ** src is a buffer holding a signed variable length integer.
 ** dest is a buffer which will be filled with an unsigned integer,
 ** MSB first (big endian) with leading zeros, so that the last byte
 ** of src will be the LSB of the integer.  The result will be exactly
 ** the length specified by the caller in dest->len.
 ** src can be shorter than dest.  src can be longer than dst, but only
 ** if the extra leading bytes are zeros.
 */
 SECStatus
 DSAU_ConvertSignedToFixedUnsigned(SECItem *dest, SECItem *src)
 {
     unsigned char *pSrc = src->data;
     unsigned char *pDst = dest->data;
-    unsigned int   cntSrc = src->len;
-    unsigned int   cntDst = dest->len;
-    int            zCount = cntDst - cntSrc;
+    unsigned int cntSrc = src->len;
+    unsigned int cntDst = dest->len;
+    int zCount = cntDst - cntSrc;
 
     if (zCount > 0) {
-        PORT_Memset(pDst, 0, zCount);
-        PORT_Memcpy(pDst + zCount, pSrc, cntSrc);
-        return SECSuccess;
+        PORT_Memset(pDst, 0, zCount);
+        PORT_Memcpy(pDst + zCount, pSrc, cntSrc);
+        return SECSuccess;
     }
     if (zCount <= 0) {
-        /* Source is longer than destination.  Check for leading zeros. */
-        while (zCount++ < 0) {
-            if (*pSrc++ != 0)
-                goto loser;
-        }
+        /* Source is longer than destination.  Check for leading zeros. */
+        while (zCount++ < 0) {
+            if (*pSrc++ != 0)
+                goto loser;
+        }
     }
     PORT_Memcpy(pDst, pSrc, cntDst);
     return SECSuccess;
 
 loser:
-    PORT_SetError( PR_INVALID_ARGUMENT_ERROR );
+    PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
     return SECFailure;
 }
 
 /* src is a "raw" ECDSA or DSA signature, the first half contains r
  * and the second half contains s. dest is the DER encoded signature.
 */
 static SECStatus
 common_EncodeDerSig(SECItem *dest, SECItem *src)
 {
-    SECItem *         item;
-    SECItem           srcItem;
+    SECItem *item;
+    SECItem srcItem;
     DSA_ASN1Signature sig;
-    unsigned char     *signedR;
-    unsigned char     *signedS;
+    unsigned char *signedR;
+    unsigned char *signedS;
     unsigned int len;
 
     /* Allocate memory with room for an extra byte that
      * may be required if the top bit in the first byte
      * is already set.
      */
-    len = src->len/2;
-    signedR = (unsigned char *) PORT_Alloc(len + 1);
-    if (!signedR) return SECFailure;
-    signedS = (unsigned char *) PORT_ZAlloc(len + 1);
+    len = src->len / 2;
+    signedR = (unsigned char *)PORT_Alloc(len + 1);
+    if (!signedR)
+        return SECFailure;
+    signedS = (unsigned char *)PORT_ZAlloc(len + 1);
     if (!signedS) {
-        if (signedR) PORT_Free(signedR);
-        return SECFailure;
+        if (signedR)
+            PORT_Free(signedR);
+        return SECFailure;
     }
 
     PORT_Memset(&sig, 0, sizeof(sig));
 
     /* Must convert r and s from "unsigned" integers to "signed" integers.
     ** If the high order bit of the first byte (MSB) is 1, then must
-    ** prepend with leading zero.  
+    ** prepend with leading zero.
     ** Must remove all but one leading zero byte from numbers.
     */
     sig.r.type = siUnsignedInteger;
     sig.r.data = signedR;
-    sig.r.len  = sizeof signedR;
+    sig.r.len = sizeof signedR;
     sig.s.type = siUnsignedInteger;
     sig.s.data = signedS;
-    sig.s.len  = sizeof signedR;
+    sig.s.len = sizeof signedR;
 
     srcItem.data = src->data;
-    srcItem.len  = len;
+    srcItem.len = len;
 
     DSAU_ConvertUnsignedToSigned(&sig.r, &srcItem);
     srcItem.data += len;
     DSAU_ConvertUnsignedToSigned(&sig.s, &srcItem);
 
     item = SEC_ASN1EncodeItem(NULL, dest, &sig, DSA_SignatureTemplate);
-    if (signedR) PORT_Free(signedR);
-    if (signedS) PORT_Free(signedS);
+    if (signedR)
+        PORT_Free(signedR);
+    if (signedS)
+        PORT_Free(signedS);
     if (item == NULL)
-        return SECFailure;
+        return SECFailure;
 
     /* XXX leak item? */
     return SECSuccess;
 }
 
 /* src is a DER-encoded ECDSA or DSA signature.
 ** Returns a newly-allocated SECItem structure, pointing at a newly allocated
 ** buffer containing the "raw" signature, which is len bytes of r,
 ** followed by len bytes of s. For DSA, len is the length of q.
 ** For ECDSA, len depends on the key size used to create the signature.
 */
 static SECItem *
 common_DecodeDerSig(const SECItem *item, unsigned int len)
 {
-    SECItem *         result = NULL;
-    SECStatus         status;
+    SECItem *result = NULL;
+    SECStatus status;
     DSA_ASN1Signature sig;
-    SECItem           dst;
+    SECItem dst;
 
     PORT_Memset(&sig, 0, sizeof(sig));
 
     result = PORT_ZNew(SECItem);
     if (result == NULL)
-        goto loser;
+        goto loser;
 
-    result->len  = 2 * len;
-    result->data = (unsigned char*)PORT_Alloc(2 * len);
+    result->len = 2 * len;
+    result->data = (unsigned char *)PORT_Alloc(2 * len);
     if (result->data == NULL)
-        goto loser;
+        goto loser;
 
     sig.r.type = siUnsignedInteger;
     sig.s.type = siUnsignedInteger;
     status = SEC_ASN1DecodeItem(NULL, &sig, DSA_SignatureTemplate, item);
     if (status != SECSuccess)
-        goto loser;
+        goto loser;
 
-    /* Convert sig.r and sig.s from variable  length signed integers to 
+    /* Convert sig.r and sig.s from variable  length signed integers to
     ** fixed length unsigned integers.
     */
     dst.data = result->data;
-    dst.len  = len;
+    dst.len = len;
     status = DSAU_ConvertSignedToFixedUnsigned(&dst, &sig.r);
     if (status != SECSuccess)
-        goto loser;
+        goto loser;
 
     dst.data += len;
     status = DSAU_ConvertSignedToFixedUnsigned(&dst, &sig.s);
     if (status != SECSuccess)
-        goto loser;
+        goto loser;
 
 done:
     if (sig.r.data != NULL)
-        PORT_Free(sig.r.data);
+        PORT_Free(sig.r.data);
     if (sig.s.data != NULL)
-        PORT_Free(sig.s.data);
+        PORT_Free(sig.s.data);
 
     return result;
 
 loser:
     if (result != NULL) {
-        SECITEM_FreeItem(result, PR_TRUE);
-        result = NULL;
+        SECITEM_FreeItem(result, PR_TRUE);
+        result = NULL;
     }
     goto done;
 }
 
 /* src is a "raw" DSA1 signature, 20 bytes of r followed by 20 bytes of s.
 ** dest is the signature DER encoded. ?
 */
 SECStatus
 DSAU_EncodeDerSig(SECItem *dest, SECItem *src)
 {
     PORT_Assert(src->len == 2 * DSA1_SUBPRIME_LEN);
     if (src->len != 2 * DSA1_SUBPRIME_LEN) {
-        PORT_SetError( PR_INVALID_ARGUMENT_ERROR );
-        return SECFailure;
+        PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
+        return SECFailure;
     }
 
     return common_EncodeDerSig(dest, src);
 }
 
 /* src is a "raw" DSA signature of length len (len/2 bytes of r followed
 ** by len/2 bytes of s). dest is the signature DER encoded.
 */
 SECStatus
 DSAU_EncodeDerSigWithLen(SECItem *dest, SECItem *src, unsigned int len)
 {
 
     PORT_Assert((src->len == len) && (len % 2 == 0));
     if ((src->len != len) || (src->len % 2 != 0)) {
-        PORT_SetError( PR_INVALID_ARGUMENT_ERROR );
-        return SECFailure;
+        PORT_SetError(PR_INVALID_ARGUMENT_ERROR);
+        return SECFailure;
     }
 
     return common_EncodeDerSig(dest, src);
 }
 
 /* src is a DER-encoded DSA signature.
 ** Returns a newly-allocated SECItem structure, pointing at a newly allocated
 ** buffer containing the "raw" DSA1 signature, which is 20 bytes of r,
 ** followed by 20 bytes of s.
 */
 SECItem *
 DSAU_DecodeDerSig(const SECItem *item)
 {
     return common_DecodeDerSig(item, DSA1_SUBPRIME_LEN);
 }
 
 /* src is a DER-encoded ECDSA signature.
 ** Returns a newly-allocated SECItem structure, pointing at a newly allocated
 ** buffer containing the "raw" ECDSA signature of length len containing
 ** r followed by s (both padded to take up exactly len/2 bytes).
 */
 SECItem *
 DSAU_DecodeDerSigToLen(const SECItem *item, unsigned int len)
 {
-    return common_DecodeDerSig(item, len/2);
+    return common_DecodeDerSig(item, len / 2);
 }