1 files changed, 234 insertions, 287 deletions

diff --git a/src/lib/libcrypto/bn/bn_exp.c b/src/lib/libcrypto/bn/bn_exp.c
index 0c11601675..d2c91628ac 100644
--- a/src/lib/libcrypto/bn/bn_exp.c
+++ b/src/lib/libcrypto/bn/bn_exp.c
@@ -55,18 +55,66 @@
  * copied and put under another distribution licence
  * [including the GNU Public Licence.]
  */
+/* ====================================================================
+ * Copyright (c) 1998-2000 The OpenSSL Project.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer. 
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ *    software must display the following acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    openssl-core@openssl.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ *    nor may "OpenSSL" appear in their names without prior written
+ *    permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com).  This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
+ */
+
 
 #include <stdio.h>
 #include "cryptlib.h"
 #include "bn_lcl.h"
-#ifdef ATALLA
-# include <alloca.h>
-# include <atasi.h>
-# include <assert.h>
-# include <dlfcn.h>
-#endif
 
-#define TABLE_SIZE      16
+#define TABLE_SIZE      32
 
 /* slow but works */
 int BN_mod_mul(BIGNUM *ret, BIGNUM *a, BIGNUM *b, const BIGNUM *m, BN_CTX *ctx)
@@ -91,42 +139,6 @@ err:
         return(r);
         }
 
-#if 0
-/* this one works - simple but works */
-int BN_mod_exp(BIGNUM *r, BIGNUM *a, BIGNUM *p, BIGNUM *m, BN_CTX *ctx)
-        {
-        int i,bits,ret=0;
-        BIGNUM *v,*tmp;
-
-        BN_CTX_start(ctx);
-        v = BN_CTX_get(ctx);
-        tmp = BN_CTX_get(ctx);
-        if (v == NULL || tmp == NULL) goto err;
-
-        if (BN_copy(v,a) == NULL) goto err;
-        bits=BN_num_bits(p);
-
-        if (BN_is_odd(p))
-                { if (BN_copy(r,a) == NULL) goto err; }
-        else    { if (!BN_one(r)) goto err; }
-
-        for (i=1; i<bits; i++)
-                {
-                if (!BN_sqr(tmp,v,ctx)) goto err;
-                if (!BN_mod(v,tmp,m,ctx)) goto err;
-                if (BN_is_bit_set(p,i))
-                        {
-                        if (!BN_mul(tmp,r,v,ctx)) goto err;
-                        if (!BN_mod(r,tmp,m,ctx)) goto err;
-                        }
-                }
-        ret=1;
-err:
-        BN_CTX_end(ctx);
-        return(ret);
-        }
-
-#endif
 
 /* this one works - simple but works */
 int BN_exp(BIGNUM *r, BIGNUM *a, BIGNUM *p, BN_CTX *ctx)
@@ -163,172 +175,6 @@ err:
         return(ret);
         }
 
-#ifdef ATALLA
-
-/*
- * This routine will dynamically check for the existance of an Atalla AXL-200
- * SSL accelerator module.  If one is found, the variable
- * asi_accelerator_present is set to 1 and the function pointers
- * ptr_ASI_xxxxxx above will be initialized to corresponding ASI API calls.
- */
-typedef int tfnASI_GetPerformanceStatistics(int reset_flag,
-                                            unsigned int *ret_buf);
-typedef int tfnASI_GetHardwareConfig(long card_num, unsigned int *ret_buf);
-typedef int tfnASI_RSAPrivateKeyOpFn(RSAPrivateKey * rsaKey,
-                                     unsigned char *output,
-                                     unsigned char *input,
-                                     unsigned int modulus_len);
-
-static tfnASI_GetHardwareConfig *ptr_ASI_GetHardwareConfig;
-static tfnASI_RSAPrivateKeyOpFn *ptr_ASI_RSAPrivateKeyOpFn;
-static tfnASI_GetPerformanceStatistics *ptr_ASI_GetPerformanceStatistics;
-static int asi_accelerator_present;
-static int tried_atalla;
-
-void atalla_initialize_accelerator_handle(void)
-        {
-        void *dl_handle;
-        int status;
-        unsigned int config_buf[1024]; 
-        static int tested;
-
-        if(tested)
-                return;
-
-        tested=1;
-
-        bzero((void *)config_buf, 1024);
-
-        /*
-         * Check to see if the library is present on the system
-         */
-        dl_handle = dlopen("atasi.so", RTLD_NOW);
-        if (dl_handle == (void *) NULL)
-                {
-/*              printf("atasi.so library is not present on the system\n");
-                printf("No HW acceleration available\n");*/
-                return;
-                }
-
-        /*
-         * The library is present.  Now we'll check to insure that the
-         * LDM is up and running. First we'll get the address of the
-         * function in the atasi library that we need to see if the
-         * LDM is operating.
-         */
-
-        ptr_ASI_GetHardwareConfig =
-          (tfnASI_GetHardwareConfig *)dlsym(dl_handle,"ASI_GetHardwareConfig");
-
-        if (ptr_ASI_GetHardwareConfig)
-                {
-                /*
-                 * We found the call, now we'll get our config
-                 * status.  If we get a non 0 result, the LDM is not
-                 * running and we cannot use the Atalla ASI *
-                 * library.
-                 */
-                status = (*ptr_ASI_GetHardwareConfig)(0L, config_buf);
-                if (status != 0)
-                        {
-                        printf("atasi.so library is present but not initialized\n");
-                        printf("No HW acceleration available\n");
-                        return;
-                        }    
-                }
-        else
-                {
-/*              printf("We found the library, but not the function. Very Strange!\n");*/
-                return ;
-                }
-
-        /* 
-         * It looks like we have acceleration capabilities.  Load up the
-         * pointers to our ASI API calls.
-         */
-        ptr_ASI_RSAPrivateKeyOpFn=
-          (tfnASI_RSAPrivateKeyOpFn *)dlsym(dl_handle, "ASI_RSAPrivateKeyOpFn");
-        if (ptr_ASI_RSAPrivateKeyOpFn == NULL)
-                {
-/*              printf("We found the library, but no RSA function. Very Strange!\n");*/
-                return;
-                }
-
-        ptr_ASI_GetPerformanceStatistics =
-          (tfnASI_GetPerformanceStatistics *)dlsym(dl_handle, "ASI_GetPerformanceStatistics");
-        if (ptr_ASI_GetPerformanceStatistics == NULL)
-                {
-/*              printf("We found the library, but no stat function. Very Strange!\n");*/
-                return;
-              }
-
-        /*
-         * Indicate that acceleration is available
-         */
-        asi_accelerator_present = 1;
-
-/*      printf("This system has acceleration!\n");*/
-
-        return;
-        }
-
-/* make sure this only gets called once when bn_mod_exp calls bn_mod_exp_mont */
-int BN_mod_exp_atalla(BIGNUM *r, BIGNUM *a, const BIGNUM *p, const BIGNUM *m)
-        {
-        unsigned char *abin;
-        unsigned char *pbin;
-        unsigned char *mbin;
-        unsigned char *rbin;
-        int an,pn,mn,ret;
-        RSAPrivateKey keydata;
-
-        atalla_initialize_accelerator_handle();
-        if(!asi_accelerator_present)
-                return 0;
-
-
-/* We should be able to run without size testing */
-# define ASIZE  128
-        an=BN_num_bytes(a);
-        pn=BN_num_bytes(p);
-        mn=BN_num_bytes(m);
-
-        if(an <= ASIZE && pn <= ASIZE && mn <= ASIZE)
-            {
-            int size=mn;
-
-            assert(an <= mn);
-            abin=alloca(size);
-            memset(abin,'\0',mn);
-            BN_bn2bin(a,abin+size-an);
-
-            pbin=alloca(pn);
-            BN_bn2bin(p,pbin);
-
-            mbin=alloca(size);
-            memset(mbin,'\0',mn);
-            BN_bn2bin(m,mbin+size-mn);
-
-            rbin=alloca(size);
-
-            memset(&keydata,'\0',sizeof keydata);
-            keydata.privateExponent.data=pbin;
-            keydata.privateExponent.len=pn;
-            keydata.modulus.data=mbin;
-            keydata.modulus.len=size;
-
-            ret=(*ptr_ASI_RSAPrivateKeyOpFn)(&keydata,rbin,abin,keydata.modulus.len);
-/*fprintf(stderr,"!%s\n",BN_bn2hex(a));*/
-            if(!ret)
-                {
-                BN_bin2bn(rbin,keydata.modulus.len,r);
-/*fprintf(stderr,"?%s\n",BN_bn2hex(r));*/
-                return 1;
-                }
-            }
-        return 0;
-        }
-#endif /* def ATALLA */
 
 int BN_mod_exp(BIGNUM *r, BIGNUM *a, const BIGNUM *p, const BIGNUM *m,
                BN_CTX *ctx)
@@ -339,13 +185,6 @@ int BN_mod_exp(BIGNUM *r, BIGNUM *a, const BIGNUM *p, const BIGNUM *m,
         bn_check_top(p);
         bn_check_top(m);
 
-#ifdef ATALLA
-        if(BN_mod_exp_atalla(r,a,p,m))
-            return 1;
-/* If it fails, try the other methods (but don't try atalla again) */
-        tried_atalla=1;
-#endif
-
 #ifdef MONT_MUL_MOD
         /* I have finally been able to take out this pre-condition of
          * the top bit being set.  It was caused by an error in BN_div
@@ -354,7 +193,15 @@ int BN_mod_exp(BIGNUM *r, BIGNUM *a, const BIGNUM *p, const BIGNUM *m,
 /*      if ((m->d[m->top-1]&BN_TBIT) && BN_is_odd(m)) */
 
         if (BN_is_odd(m))
-                { ret=BN_mod_exp_mont(r,a,p,m,ctx,NULL); }
+                {
+                if (a->top == 1)
+                        {
+                        BN_ULONG A = a->d[0];
+                        ret=BN_mod_exp_mont_word(r,A,p,m,ctx,NULL);
+                        }
+                else
+                        ret=BN_mod_exp_mont(r,a,p,m,ctx,NULL);
+                }
         else
 #endif
 #ifdef RECP_MUL_MOD
@@ -363,14 +210,10 @@ int BN_mod_exp(BIGNUM *r, BIGNUM *a, const BIGNUM *p, const BIGNUM *m,
                 { ret=BN_mod_exp_simple(r,a,p,m,ctx); }
 #endif
 
-#ifdef ATALLA
-        tried_atalla=0;
-#endif
-
         return(ret);
         }
 
-/* #ifdef RECP_MUL_MOD */
+
 int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
                     const BIGNUM *m, BN_CTX *ctx)
         {
@@ -398,27 +241,22 @@ int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
         ts=1;
 
         if (!BN_mod(&(val[0]),a,m,ctx)) goto err;               /* 1 */
-        if (!BN_mod_mul_reciprocal(aa,&(val[0]),&(val[0]),&recp,ctx))
-                goto err;                               /* 2 */
-
-        if (bits <= 17) /* This is probably 3 or 0x10001, so just do singles */
-                window=1;
-        else if (bits >= 256)
-                window=5;       /* max size of window */
-        else if (bits >= 128)
-                window=4;
-        else
-                window=3;
 
-        j=1<<(window-1);
-        for (i=1; i<j; i++)
+        window = BN_window_bits_for_exponent_size(bits);
+        if (window > 1)
                 {
-                BN_init(&val[i]);
-                if (!BN_mod_mul_reciprocal(&(val[i]),&(val[i-1]),aa,&recp,ctx))
-                        goto err;
+                if (!BN_mod_mul_reciprocal(aa,&(val[0]),&(val[0]),&recp,ctx))
+                        goto err;                               /* 2 */
+                j=1<<(window-1);
+                for (i=1; i<j; i++)
+                        {
+                        BN_init(&val[i]);
+                        if (!BN_mod_mul_reciprocal(&(val[i]),&(val[i-1]),aa,&recp,ctx))
+                                goto err;
+                        }
+                ts=i;
                 }
-        ts=i;
-
+                
         start=1;        /* This is used to avoid multiplication etc
                          * when there is only the value '1' in the
                          * buffer. */
@@ -485,9 +323,8 @@ err:
         BN_RECP_CTX_free(&recp);
         return(ret);
         }
-/* #endif */
 
-/* #ifdef MONT_MUL_MOD */
+
 int BN_mod_exp_mont(BIGNUM *rr, BIGNUM *a, const BIGNUM *p,
                     const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *in_mont)
         {
@@ -502,12 +339,6 @@ int BN_mod_exp_mont(BIGNUM *rr, BIGNUM *a, const BIGNUM *p,
         bn_check_top(p);
         bn_check_top(m);
 
-#ifdef ATALLA
-        if(!tried_atalla && BN_mod_exp_atalla(rr,a,p,m))
-            return 1;
-/* If it fails, try the other methods */
-#endif
-
         if (!(m->d[0] & 1))
                 {
                 BNerr(BN_F_BN_MOD_EXP_MONT,BN_R_CALLED_WITH_EVEN_MODULUS);
@@ -527,11 +358,9 @@ int BN_mod_exp_mont(BIGNUM *rr, BIGNUM *a, const BIGNUM *p,
         /* If this is not done, things will break in the montgomery
          * part */
 
-#if 1
         if (in_mont != NULL)
                 mont=in_mont;
         else
-#endif
                 {
                 if ((mont=BN_MONT_CTX_new()) == NULL) goto err;
                 if (!BN_MONT_CTX_set(mont,m,ctx)) goto err;
@@ -541,31 +370,27 @@ int BN_mod_exp_mont(BIGNUM *rr, BIGNUM *a, const BIGNUM *p,
         ts=1;
         if (BN_ucmp(a,m) >= 0)
                 {
-                BN_mod(&(val[0]),a,m,ctx);
+                if (!BN_mod(&(val[0]),a,m,ctx))
+                        goto err;
                 aa= &(val[0]);
                 }
         else
                 aa=a;
         if (!BN_to_montgomery(&(val[0]),aa,mont,ctx)) goto err; /* 1 */
-        if (!BN_mod_mul_montgomery(d,&(val[0]),&(val[0]),mont,ctx)) goto err; /* 2 */
-
-        if (bits <= 20) /* This is probably 3 or 0x10001, so just do singles */
-                window=1;
-        else if (bits >= 256)
-                window=5;       /* max size of window */
-        else if (bits >= 128)
-                window=4;
-        else
-                window=3;
 
-        j=1<<(window-1);
-        for (i=1; i<j; i++)
+        window = BN_window_bits_for_exponent_size(bits);
+        if (window > 1)
                 {
-                BN_init(&(val[i]));
-                if (!BN_mod_mul_montgomery(&(val[i]),&(val[i-1]),d,mont,ctx))
-                        goto err;
+                if (!BN_mod_mul_montgomery(d,&(val[0]),&(val[0]),mont,ctx)) goto err; /* 2 */
+                j=1<<(window-1);
+                for (i=1; i<j; i++)
+                        {
+                        BN_init(&(val[i]));
+                        if (!BN_mod_mul_montgomery(&(val[i]),&(val[i-1]),d,mont,ctx))
+                                goto err;
+                        }
+                ts=i;
                 }
-        ts=i;
 
         start=1;        /* This is used to avoid multiplication etc
                          * when there is only the value '1' in the
@@ -574,7 +399,7 @@ int BN_mod_exp_mont(BIGNUM *rr, BIGNUM *a, const BIGNUM *p,
         wstart=bits-1;  /* The top bit of the window */
         wend=0;         /* The bottom bit of the window */
 
-        if (!BN_to_montgomery(r,BN_value_one(),mont,ctx)) goto err;
+        if (!BN_to_montgomery(r,BN_value_one(),mont,ctx)) goto err;
         for (;;)
                 {
                 if (BN_is_bit_set(p,wstart) == 0)
@@ -626,7 +451,7 @@ int BN_mod_exp_mont(BIGNUM *rr, BIGNUM *a, const BIGNUM *p,
                 start=0;
                 if (wstart < 0) break;
                 }
-        BN_from_montgomery(rr,r,mont,ctx);
+        if (!BN_from_montgomery(rr,r,mont,ctx)) goto err;
         ret=1;
 err:
         if ((in_mont == NULL) && (mont != NULL)) BN_MONT_CTX_free(mont);
@@ -635,7 +460,134 @@ err:
                 BN_clear_free(&(val[i]));
         return(ret);
         }
-/* #endif */
+
+int BN_mod_exp_mont_word(BIGNUM *rr, BN_ULONG a, const BIGNUM *p,
+                         const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *in_mont)
+        {
+        BN_MONT_CTX *mont = NULL;
+        int b, bits, ret=0;
+        int r_is_one;
+        BN_ULONG w, next_w;
+        BIGNUM *d, *r, *t;
+        BIGNUM *swap_tmp;
+#define BN_MOD_MUL_WORD(r, w, m) \
+                (BN_mul_word(r, (w)) && \
+                (/* BN_ucmp(r, (m)) < 0 ? 1 :*/  \
+                        (BN_mod(t, r, m, ctx) && (swap_tmp = r, r = t, t = swap_tmp, 1))))
+                /* BN_MOD_MUL_WORD is only used with 'w' large,
+                  * so the BN_ucmp test is probably more overhead
+                  * than always using BN_mod (which uses BN_copy if
+                  * a similar test returns true). */
+#define BN_TO_MONTGOMERY_WORD(r, w, mont) \
+                (BN_set_word(r, (w)) && BN_to_montgomery(r, r, (mont), ctx))
+
+        bn_check_top(p);
+        bn_check_top(m);
+
+        if (!(m->d[0] & 1))
+                {
+                BNerr(BN_F_BN_MOD_EXP_MONT_WORD,BN_R_CALLED_WITH_EVEN_MODULUS);
+                return(0);
+                }
+        bits = BN_num_bits(p);
+        if (bits == 0)
+                {
+                BN_one(rr);
+                return(1);
+                }
+        BN_CTX_start(ctx);
+        d = BN_CTX_get(ctx);
+        r = BN_CTX_get(ctx);
+        t = BN_CTX_get(ctx);
+        if (d == NULL || r == NULL || t == NULL) goto err;
+
+        if (in_mont != NULL)
+                mont=in_mont;
+        else
+                {
+                if ((mont = BN_MONT_CTX_new()) == NULL) goto err;
+                if (!BN_MONT_CTX_set(mont, m, ctx)) goto err;
+                }
+
+        r_is_one = 1; /* except for Montgomery factor */
+
+        /* bits-1 >= 0 */
+
+        /* The result is accumulated in the product r*w. */
+        w = a; /* bit 'bits-1' of 'p' is always set */
+        for (b = bits-2; b >= 0; b--)
+                {
+                /* First, square r*w. */
+                next_w = w*w;
+                if ((next_w/w) != w) /* overflow */
+                        {
+                        if (r_is_one)
+                                {
+                                if (!BN_TO_MONTGOMERY_WORD(r, w, mont)) goto err;
+                                r_is_one = 0;
+                                }
+                        else
+                                {
+                                if (!BN_MOD_MUL_WORD(r, w, m)) goto err;
+                                }
+                        next_w = 1;
+                        }
+                w = next_w;
+                if (!r_is_one)
+                        {
+                        if (!BN_mod_mul_montgomery(r, r, r, mont, ctx)) goto err;
+                        }
+
+                /* Second, multiply r*w by 'a' if exponent bit is set. */
+                if (BN_is_bit_set(p, b))
+                        {
+                        next_w = w*a;
+                        if ((next_w/a) != w) /* overflow */
+                                {
+                                if (r_is_one)
+                                        {
+                                        if (!BN_TO_MONTGOMERY_WORD(r, w, mont)) goto err;
+                                        r_is_one = 0;
+                                        }
+                                else
+                                        {
+                                        if (!BN_MOD_MUL_WORD(r, w, m)) goto err;
+                                        }
+                                next_w = a;
+                                }
+                        w = next_w;
+                        }
+                }
+
+        /* Finally, set r:=r*w. */
+        if (w != 1)
+                {
+                if (r_is_one)
+                        {
+                        if (!BN_TO_MONTGOMERY_WORD(r, w, mont)) goto err;
+                        r_is_one = 0;
+                        }
+                else
+                        {
+                        if (!BN_MOD_MUL_WORD(r, w, m)) goto err;
+                        }
+                }
+
+        if (r_is_one) /* can happen only if a == 1*/
+                {
+                if (!BN_one(rr)) goto err;
+                }
+        else
+                {
+                if (!BN_from_montgomery(rr, r, mont, ctx)) goto err;
+                }
+        ret = 1;
+err:
+        if ((in_mont == NULL) && (mont != NULL)) BN_MONT_CTX_free(mont);
+        BN_CTX_end(ctx);
+        return(ret);
+        }
+
 
 /* The old fallback, simple version :-) */
 int BN_mod_exp_simple(BIGNUM *r, BIGNUM *a, BIGNUM *p, BIGNUM *m,
@@ -660,26 +612,21 @@ int BN_mod_exp_simple(BIGNUM *r, BIGNUM *a, BIGNUM *p, BIGNUM *m,
         BN_init(&(val[0]));
         ts=1;
         if (!BN_mod(&(val[0]),a,m,ctx)) goto err;               /* 1 */
-        if (!BN_mod_mul(d,&(val[0]),&(val[0]),m,ctx))
-                goto err;                               /* 2 */
-
-        if (bits <= 17) /* This is probably 3 or 0x10001, so just do singles */
-                window=1;
-        else if (bits >= 256)
-                window=5;       /* max size of window */
-        else if (bits >= 128)
-                window=4;
-        else
-                window=3;
 
-        j=1<<(window-1);
-        for (i=1; i<j; i++)
+        window = BN_window_bits_for_exponent_size(bits);
+        if (window > 1)
                 {
-                BN_init(&(val[i]));
-                if (!BN_mod_mul(&(val[i]),&(val[i-1]),d,m,ctx))
-                        goto err;
+                if (!BN_mod_mul(d,&(val[0]),&(val[0]),m,ctx))
+                        goto err;                               /* 2 */
+                j=1<<(window-1);
+                for (i=1; i<j; i++)
+                        {
+                        BN_init(&(val[i]));
+                        if (!BN_mod_mul(&(val[i]),&(val[i-1]),d,m,ctx))
+                                goto err;
+                        }
+                ts=i;
                 }
-        ts=i;
 
         start=1;        /* This is used to avoid multiplication etc
                          * when there is only the value '1' in the