Allow NSS to be built with NO_NSPR_10_SUPPORT.

nss/lib/freebl/pqg.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/. */
 
 /*
  * PQG parameter generation/verification.  Based on FIPS 186-3.
  */
 #ifdef FREEBL_NO_DEPEND
 #include "stubs.h"
 #endif
@@ skipping 210 matching lines @@
 PQG_Check(const PQGParams *params)
 {
     unsigned int L,N;
     SECStatus rv = SECSuccess;
 
     if (params == NULL) {
         PORT_SetError(SEC_ERROR_INVALID_ARGS);
         return SECFailure;
     }
 
-    L = PQG_GetLength(&params->prime)*BITS_PER_BYTE;
-    N = PQG_GetLength(&params->subPrime)*BITS_PER_BYTE;
+    L = PQG_GetLength(&params->prime)*PR_BITS_PER_BYTE;
+    N = PQG_GetLength(&params->subPrime)*PR_BITS_PER_BYTE;
 
     if (L < 1024) {
         int j;
 
         /* handle DSA1 pqg parameters with less thatn 1024 bits*/
         if ( N != DSA1_Q_BITS ) {
             PORT_SetError(SEC_ERROR_INVALID_ARGS);
             return SECFailure;
         }
         j = PQG_PBITS_TO_INDEX(L);
@@ skipping 11 matching lines @@
 HASH_HashType
 PQG_GetHashType(const PQGParams *params)
 {
     unsigned int L,N;
 
     if (params == NULL) {
         PORT_SetError(SEC_ERROR_INVALID_ARGS);
         return HASH_AlgNULL;
     }
 
-    L = PQG_GetLength(&params->prime)*BITS_PER_BYTE;
-    N = PQG_GetLength(&params->subPrime)*BITS_PER_BYTE;
+    L = PQG_GetLength(&params->prime)*PR_BITS_PER_BYTE;
+    N = PQG_GetLength(&params->subPrime)*PR_BITS_PER_BYTE;
     return getFirstHash(L, N);
 }
 
 /* Get a seed for generating P and Q.  If in testing mode, copy in the
 ** seed from FIPS 186-1 appendix 5.  Otherwise, obtain bytes from the
 ** global random number generator.
 */
 static SECStatus
-getPQseed(SECItem *seed, PRArenaPool* arena)
+getPQseed(SECItem *seed, PLArenaPool* arena)
 {
     SECStatus rv;
 
     if (!seed->data) {
         seed->data = (unsigned char*)PORT_ArenaZAlloc(arena, seed->len);
     }
     if (!seed->data) {
         PORT_SetError(SEC_ERROR_NO_MEMORY);
         return SECFailure;
     }
@@ skipping 151 matching lines @@
 static SECStatus
 makeQ2fromSeed(
       HASH_HashType hashtype,   /* selected Hashing algorithm */
       unsigned int  N,          /* input.  Length of q in bits. */
 const SECItem   *   seed,       /* input.  */
       mp_int    *   Q)          /* output. */
 {
     unsigned char U[HASH_LENGTH_MAX];
     SECStatus rv  = SECSuccess;
     mp_err    err = MP_OKAY;
-    int N_bytes = N/BITS_PER_BYTE; /* length of N in bytes rather than bits */
+    int N_bytes = N/PR_BITS_PER_BYTE; /* length of N in bytes rather than bits */
     int hashLen = HASH_ResultLen(hashtype);
     int offset = 0;
 
     /* ******************************************************************
     ** Step 6.
     ** "Compute U = hash[SEED] mod 2**N-1]."
     **/
     CHECK_SEC_OK( HASH_HashBuf(hashtype, U, seed->data, seed->len) );
     /* mod 2**N . Step 7 will explicitly set the top bit to 1, so no need
      * to handle mod 2**N-1 */
@@ skipping 21 matching lines @@
 
 /*
 **  Perform steps from  FIPS 186-3, Appendix A.1.2.1 and Appendix C.6
 **
 **  This generates a provable prime from two smaller prime. The resulting
 **  prime p will have q0 as a multiple of p-1. q0 can be 1.
 **
 ** This implments steps 4 thorough 22 of FIPS 186-3 A.1.2.1 and
 **                steps 16 through 34 of FIPS 186-2 C.6
 */
-#define MAX_ST_SEED_BITS HASH_LENGTH_MAX*BITS_PER_BYTE
+#define MAX_ST_SEED_BITS (HASH_LENGTH_MAX*PR_BITS_PER_BYTE)
 SECStatus
 makePrimefromPrimesShaweTaylor(
       HASH_HashType hashtype,   /* selected Hashing algorithm */
       unsigned int  length,     /* input. Length of prime in bits. */
       mp_int    *   c0,         /* seed prime */
       mp_int    *   q,          /* sub prime, can be 1 */
       mp_int    *   prime,      /* output.  */
       SECItem   *   prime_seed, /* input/output.  */
       int       *   prime_gen_counter) /* input/output.  */
 {
     mp_int c;
     mp_int c0_2;
     mp_int t;
     mp_int a;
     mp_int z;
     mp_int two_length_minus_1;
     SECStatus rv = SECFailure;
     int hashlen = HASH_ResultLen(hashtype);
-    int outlen = hashlen*BITS_PER_BYTE;
+    int outlen = hashlen*PR_BITS_PER_BYTE;
     int offset;
     unsigned char bit, mask;
     /* x needs to hold roundup(L/outlen)*outlen.
      * This can be no larger than L+outlen-1, So we set it's size to
      * our max L + max outlen and know we are safe */
     unsigned char x[DSA_MAX_P_BITS/8+HASH_LENGTH_MAX];
     mp_err err = MP_OKAY;
     int i;
     int iterations;
     int old_counter;
@@ skipping 55 matching lines @@
     ** Step 9/21 x = 2 ** (length-1) + x mod 2 ** (length-1) 
     **
     **   This step mathematically sets the high bit and clears out
     **  all the other bits higher than length. 'x' is stored
     **  in the x array, MSB first. The above formula gives us an 'x' 
     **  which is length bytes long and has the high bit set. We also know 
     **  that length <= iterations*outlen since 
     **  iterations=ceiling(length/outlen). First we find the offset in 
     **  bytes into the array where the high bit is.
     */
-    offset = (outlen*iterations - length)/BITS_PER_BYTE;
+    offset = (outlen*iterations - length)/PR_BITS_PER_BYTE;
     /* now we want to set the 'high bit', since length may not be a 
      * multiple of 8,*/
     bit = 1 << ((length-1) & 0x7); /* select the proper bit in the byte */
     /* we need to zero out the rest of the bits in the byte above */
     mask = (bit-1);
     /* now we set it */
     x[offset] = (mask & x[offset]) | bit;
     /*
     ** Comment: Generate a candidate prime c in the interval
     ** [2**(lenght-1), 2**length].
@@ skipping 133 matching lines @@
 const SECItem   *   input_seed,       /* input.  */
       mp_int    *   prime,      /* output.  */
       SECItem   *   prime_seed, /* output.  */
       int       *   prime_gen_counter) /* output.  */
 {
     mp_int c;
     mp_int c0;
     mp_int one;
     SECStatus rv = SECFailure;
     int hashlen = HASH_ResultLen(hashtype);
-    int outlen = hashlen*BITS_PER_BYTE;
+    int outlen = hashlen*PR_BITS_PER_BYTE;
     int offset;
     unsigned char bit, mask;
     unsigned char x[HASH_LENGTH_MAX*2];
     mp_digit dummy;
     mp_err err = MP_OKAY;
     int i;
 
     MP_DIGITS(&c) = 0;
     MP_DIGITS(&c0) = 0;
     MP_DIGITS(&one) = 0;
@@ skipping 40 matching lines @@
     }
     /* Step 6 c = 2**length-1 + c mod 2**length-1 */
     /*   This step mathematically sets the high bit and clears out
     **  all the other bits higher than length. Right now c is stored
     **  in the x array, MSB first. The above formula gives us a c which
     **  is length bytes long and has the high bit set. We also know that
     **  length < outlen since the smallest outlen is 160 bits and the largest
     **  length at this point is 32 bits. So first we find the offset in bytes
     **  into the array where the high bit is.
     */
-    offset = (outlen - length)/BITS_PER_BYTE;
+    offset = (outlen - length)/PR_BITS_PER_BYTE;
     /* now we want to set the 'high bit'. We have to calculate this since 
      * length may not be a multiple of 8.*/
     bit = 1 << ((length-1) & 0x7); /* select the proper bit in the byte */
     /* we need to zero out the rest of the bits  in the byte above */
     mask = (bit-1);
     /* now we set it */
     x[offset] = (mask & x[offset]) | bit;
     /* Step 7 c = c*floor(c/2) + 1 */
     /* set the low bit. much easier to find (the end of the array) */
     x[hashlen-1] |= 1;
@@ skipping 193 matching lines @@
     MP_DIGITS(&V_n)   = 0;
     MP_DIGITS(&tmp)   = 0;
     CHECK_MPI_OK( mp_init(&W)    );
     CHECK_MPI_OK( mp_init(&X)    );
     CHECK_MPI_OK( mp_init(&c)    );
     CHECK_MPI_OK( mp_init(&twoQ) );
     CHECK_MPI_OK( mp_init(&tmp)  );
     CHECK_MPI_OK( mp_init(&V_n)  );
 
     hashlen = HASH_ResultLen(hashtype);
-    outlen = hashlen*BITS_PER_BYTE; 
+    outlen = hashlen*PR_BITS_PER_BYTE;
 
     /* L - 1 = n*outlen + b */
     n = (L - 1) / outlen;
     b = (L - 1) % outlen;
 
     /* ******************************************************************
     ** Step 11.1 (Step 7 in 186-1)
     **  "for j = 0 ... n let
     **           V_j = SHA[(SEED + offset + j) mod 2**seedlen]."
     **
@@ skipping 207 matching lines @@
 {
     unsigned int  n;        /* Per FIPS 186, app 2.2. 186-3 app A.1.1.2 */
     unsigned int  b;        /* Per FIPS 186, app 2.2. 186-3 app A.1.1.2 */
     unsigned int  seedlen;  /* Per FIPS 186-3 app A.1.1.2  (was 'g' 186-1)*/
     unsigned int  counter;  /* Per FIPS 186, app 2.2. 186-3 app A.1.1.2 */
     unsigned int  offset;   /* Per FIPS 186, app 2.2. 186-3 app A.1.1.2 */
     unsigned int  outlen;   /* Per FIPS 186-3, appendix A.1.1.2. */
     unsigned int  maxCount;
     HASH_HashType hashtype;
     SECItem      *seed;     /* Per FIPS 186, app 2.2. 186-3 app A.1.1.2 */
-    PRArenaPool  *arena  = NULL;
+    PLArenaPool  *arena  = NULL;
     PQGParams    *params = NULL;
     PQGVerify    *verify = NULL;
     PRBool passed;
     SECItem hit = { 0, 0, 0 };
     SECItem firstseed = { 0, 0, 0 };
     SECItem qseed = { 0, 0, 0 };
     SECItem pseed = { 0, 0, 0 };
     mp_int P, Q, G, H, l, p0;
     mp_err    err = MP_OKAY;
     SECStatus rv  = SECFailure;
     int iterations = 0;
 
 
     /* Step 1. L and N already checked by caller*/
     /* Step 2. if (seedlen < N) return INVALID; */
-    if (seedBytes < N/BITS_PER_BYTE || !pParams || !pVfy) {
+    if (seedBytes < N/PR_BITS_PER_BYTE || !pParams || !pVfy) {
         PORT_SetError(SEC_ERROR_INVALID_ARGS);
         return SECFailure;
     }
     /* Initialize an arena for the params. */
     arena = PORT_NewArena(NSS_FREEBL_DEFAULT_CHUNKSIZE);
     if (!arena) {
         PORT_SetError(SEC_ERROR_NO_MEMORY);
         return SECFailure;
     }
     params = (PQGParams *)PORT_ArenaZAlloc(arena, sizeof(PQGParams));
@@ skipping 31 matching lines @@
     CHECK_MPI_OK( mp_init(&Q) );
     CHECK_MPI_OK( mp_init(&G) );
     CHECK_MPI_OK( mp_init(&H) );
     CHECK_MPI_OK( mp_init(&l) );
     CHECK_MPI_OK( mp_init(&p0) );
 
     /* Select Hash and Compute lengths. */
     /* getFirstHash gives us the smallest acceptable hash for this key
      * strength */
     hashtype = getFirstHash(L,N);
-    outlen = HASH_ResultLen(hashtype)*BITS_PER_BYTE;
+    outlen = HASH_ResultLen(hashtype)*PR_BITS_PER_BYTE;
 
     /* Step 3: n = Ceil(L/outlen)-1; (same as n = Floor((L-1)/outlen)) */
     n = (L - 1) / outlen; 
     /* Step 4: b = L -1 - (n*outlen); (same as n = (L-1) mod outlen) */
     b = (L - 1) % outlen;
-    seedlen = seedBytes * BITS_PER_BYTE;    /* bits in seed */
+    seedlen = seedBytes * PR_BITS_PER_BYTE;    /* bits in seed */
 step_5:
     /* ******************************************************************
     ** Step 5. (Step 1 in 186-1)
     ** "Choose an abitrary sequence of at least N bits and call it SEED.
     **  Let g be the length of SEED in bits."
     */
     if (++iterations > MAX_ITERATIONS) {        /* give up after a while */
         PORT_SetError(SEC_ERROR_NEED_RANDOM);
         goto cleanup;
     }
@@ skipping 405 matching lines @@
         /* make sure pseed wasn't tampered with (since it is part of 
          * calculating G) */
         CHECKPARAM( SECITEM_CompareItem(&pseed, &pseed_) == SECEqual );
     } else if (vfy->counter == -1) {
         /* If counter is set to -1, we are really only verifying G, skip
          * the remainder of the checks for P */
         CHECKPARAM(type != FIPS186_1_TYPE); /* we only do this for DSA2 */
     } else {
         /* 10. P generated from (L, counter, g, SEED, Q) matches P 
          * in PQGParams. */
-        outlen = HASH_ResultLen(hashtype)*BITS_PER_BYTE;
+        outlen = HASH_ResultLen(hashtype)*PR_BITS_PER_BYTE;
         n = (L - 1) / outlen;
         offset = vfy->counter * (n + 1) + ((type == FIPS186_1_TYPE) ? 2 : 1);
         CHECK_SEC_OK( makePfromQandSeed(hashtype, L, N, offset, g, &vfy->seed, 
                                         &Q, &P_) );
         CHECKPARAM( mp_cmp(&P, &P_) == 0 );
     }
 
     /* now check G, skip if don't have a g */
     if (params->base.len == 0) goto cleanup;
 
@@ skipping 87 matching lines @@
     if (vfy == NULL) 
         return;
     if (vfy->arena != NULL) {
         PORT_FreeArena(vfy->arena, PR_FALSE);   /* don't zero it */
     } else {
         SECITEM_FreeItem(&vfy->seed,   PR_FALSE); /* don't free seed */
         SECITEM_FreeItem(&vfy->h,      PR_FALSE); /* don't free h */
         PORT_Free(vfy);
     }
 }