1 files changed, 397 insertions, 203 deletions

diff --git a/src/lib/libcrypto/bn/bn_exp.c b/src/lib/libcrypto/bn/bn_exp.c
index c056a5083f..afdfd580fb 100644
--- a/src/lib/libcrypto/bn/bn_exp.c
+++ b/src/lib/libcrypto/bn/bn_exp.c
@@ -55,112 +55,145 @@
  * 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"
 
-/* slow but works */
-int BN_mod_mul(ret, a, b, m, ctx)
-BIGNUM *ret;
-BIGNUM *a;
-BIGNUM *b;
-BIGNUM *m;
-BN_CTX *ctx;
-        {
-        BIGNUM *t;
-        int r=0;
-
-        t=ctx->bn[ctx->tos++];
-        if (a == b)
-                { if (!BN_sqr(t,a,ctx)) goto err; }
-        else
-                { if (!BN_mul(t,a,b)) goto err; }
-        if (!BN_mod(ret,t,m,ctx)) goto err;
-        r=1;
-err:
-        ctx->tos--;
-        return(r);
-        }
+#define TABLE_SIZE      32
 
-#if 0
 /* this one works - simple but works */
-int BN_mod_exp(r,a,p,m,ctx)
-BIGNUM *r,*a,*p,*m;
-BN_CTX *ctx;
+int BN_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx)
         {
         int i,bits,ret=0;
-        BIGNUM *v,*tmp;
+        BIGNUM *v,*rr;
 
-        v=ctx->bn[ctx->tos++];
-        tmp=ctx->bn[ctx->tos++];
+        BN_CTX_start(ctx);
+        if ((r == a) || (r == p))
+                rr = BN_CTX_get(ctx);
+        else
+                rr = r;
+        if ((v = BN_CTX_get(ctx)) == 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; }
+                { if (BN_copy(rr,a) == NULL) goto err; }
+        else    { if (!BN_one(rr)) 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_sqr(v,v,ctx)) goto err;
                 if (BN_is_bit_set(p,i))
                         {
-                        if (!BN_mul(tmp,r,v)) goto err;
-                        if (!BN_mod(r,tmp,m,ctx)) goto err;
+                        if (!BN_mul(rr,rr,v,ctx)) goto err;
                         }
                 }
         ret=1;
 err:
-        ctx->tos-=2;
+        if (r != rr) BN_copy(r,rr);
+        BN_CTX_end(ctx);
         return(ret);
         }
 
-#endif
-
-/* this one works - simple but works */
-int BN_exp(r,a,p,ctx)
-BIGNUM *r,*a,*p;
-BN_CTX *ctx;
-        {
-        int i,bits,ret=0;
-        BIGNUM *v,*tmp;
-
-        v=ctx->bn[ctx->tos++];
-        tmp=ctx->bn[ctx->tos++];
-
-        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_is_bit_set(p,i))
-                        {
-                        if (!BN_mul(tmp,r,v)) goto err;
-                        }
-                }
-        ret=1;
-err:
-        ctx->tos-=2;
-        return(ret);
-        }
 
-int BN_mod_exp(r,a,p,m,ctx)
-BIGNUM *r;
-BIGNUM *a;
-BIGNUM *p;
-BIGNUM *m;
-BN_CTX *ctx;
+int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, const BIGNUM *m,
+               BN_CTX *ctx)
         {
         int ret;
 
+        bn_check_top(a);
+        bn_check_top(p);
+        bn_check_top(m);
+
+        /* For even modulus  m = 2^k*m_odd,  it might make sense to compute
+         * a^p mod m_odd  and  a^p mod 2^k  separately (with Montgomery
+         * exponentiation for the odd part), using appropriate exponent
+         * reductions, and combine the results using the CRT.
+         *
+         * For now, we use Montgomery only if the modulus is odd; otherwise,
+         * exponentiation using the reciprocal-based quick remaindering
+         * algorithm is used.
+         *
+         * (Timing obtained with expspeed.c [computations  a^p mod m
+         * where  a, p, m  are of the same length: 256, 512, 1024, 2048,
+         * 4096, 8192 bits], compared to the running time of the
+         * standard algorithm:
+         *
+         *   BN_mod_exp_mont   33 .. 40 %  [AMD K6-2, Linux, debug configuration]
+         *                     55 .. 77 %  [UltraSparc processor, but
+         *                                  debug-solaris-sparcv8-gcc conf.]
+         * 
+         *   BN_mod_exp_recp   50 .. 70 %  [AMD K6-2, Linux, debug configuration]
+         *                     62 .. 118 % [UltraSparc, debug-solaris-sparcv8-gcc]
+         *
+         * On the Sparc, BN_mod_exp_recp was faster than BN_mod_exp_mont
+         * at 2048 and more bits, but at 512 and 1024 bits, it was
+         * slower even than the standard algorithm!
+         *
+         * "Real" timings [linux-elf, solaris-sparcv9-gcc configurations]
+         * should be obtained when the new Montgomery reduction code
+         * has been integrated into OpenSSL.)
+         */
+
+#define MONT_MUL_MOD
+#define MONT_EXP_WORD
+#define RECP_MUL_MOD
+
 #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
@@ -169,7 +202,17 @@ BN_CTX *ctx;
 /*      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); }
+                {
+#  ifdef MONT_EXP_WORD
+                if (a->top == 1 && !a->neg)
+                        {
+                        BN_ULONG A = a->d[0];
+                        ret=BN_mod_exp_mont_word(r,A,p,m,ctx,NULL);
+                        }
+                else
+#  endif
+                        ret=BN_mod_exp_mont(r,a,p,m,ctx,NULL);
+                }
         else
 #endif
 #ifdef RECP_MUL_MOD
@@ -181,55 +224,65 @@ BN_CTX *ctx;
         return(ret);
         }
 
-/* #ifdef RECP_MUL_MOD */
-int BN_mod_exp_recp(r,a,p,m,ctx)
-BIGNUM *r;
-BIGNUM *a;
-BIGNUM *p;
-BIGNUM *m;
-BN_CTX *ctx;
+
+int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
+                    const BIGNUM *m, BN_CTX *ctx)
         {
-        int nb,i,j,bits,ret=0,wstart,wend,window,wvalue;
-        int start=1;
-        BIGNUM *d,*aa;
-        BIGNUM *val[16];
+        int i,j,bits,ret=0,wstart,wend,window,wvalue;
+        int start=1,ts=0;
+        BIGNUM *aa;
+        BIGNUM val[TABLE_SIZE];
+        BN_RECP_CTX recp;
 
-        d=ctx->bn[ctx->tos++];
-        aa=ctx->bn[ctx->tos++];
         bits=BN_num_bits(p);
 
         if (bits == 0)
                 {
-                BN_one(r);
-                return(1);
+                ret = BN_one(r);
+                return ret;
+                }
+
+        BN_CTX_start(ctx);
+        if ((aa = BN_CTX_get(ctx)) == NULL) goto err;
+
+        BN_RECP_CTX_init(&recp);
+        if (m->neg)
+                {
+                /* ignore sign of 'm' */
+                if (!BN_copy(aa, m)) goto err;
+                aa->neg = 0;
+                if (BN_RECP_CTX_set(&recp,aa,ctx) <= 0) goto err;
                 }
-        nb=BN_reciprocal(d,m,ctx);
-        if (nb == -1) goto err;
-
-        val[0]=BN_new();
-        if (!BN_mod(val[0],a,m,ctx)) goto err;          /* 1 */
-        if (!BN_mod_mul_reciprocal(aa,val[0],val[0],m,d,nb,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;
+                {
+                if (BN_RECP_CTX_set(&recp,m,ctx) <= 0) goto err;
+                }
+
+        BN_init(&(val[0]));
+        ts=1;
 
-        j=1<<(window-1);
-        for (i=1; i<j; i++)
+        if (!BN_nnmod(&(val[0]),a,m,ctx)) goto err;             /* 1 */
+        if (BN_is_zero(&(val[0])))
                 {
-                val[i]=BN_new();
-                if (!BN_mod_mul_reciprocal(val[i],val[i-1],aa,m,d,nb,ctx))
-                        goto err;
+                ret = BN_zero(r);
+                goto err;
                 }
-        for (; i<16; i++)
-                val[i]=NULL;
 
+        window = BN_window_bits_for_exponent_size(bits);
+        if (window > 1)
+                {
+                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;
+                }
+                
         start=1;        /* This is used to avoid multiplication etc
                          * when there is only the value '1' in the
                          * buffer. */
@@ -244,7 +297,7 @@ BN_CTX *ctx;
                 if (BN_is_bit_set(p,wstart) == 0)
                         {
                         if (!start)
-                                if (!BN_mod_mul_reciprocal(r,r,r,m,d,nb,ctx))
+                                if (!BN_mod_mul_reciprocal(r,r,r,&recp,ctx))
                                 goto err;
                         if (wstart == 0) break;
                         wstart--;
@@ -274,12 +327,12 @@ BN_CTX *ctx;
                 if (!start)
                         for (i=0; i<j; i++)
                                 {
-                                if (!BN_mod_mul_reciprocal(r,r,r,m,d,nb,ctx))
+                                if (!BN_mod_mul_reciprocal(r,r,r,&recp,ctx))
                                         goto err;
                                 }
                 
                 /* wvalue will be an odd number < 2^window */
-                if (!BN_mod_mul_reciprocal(r,r,val[wvalue>>1],m,d,nb,ctx))
+                if (!BN_mod_mul_reciprocal(r,r,&(val[wvalue>>1]),&recp,ctx))
                         goto err;
 
                 /* move the 'window' down further */
@@ -290,84 +343,86 @@ BN_CTX *ctx;
                 }
         ret=1;
 err:
-        ctx->tos-=2;
-        for (i=0; i<16; i++)
-                if (val[i] != NULL) BN_clear_free(val[i]);
+        BN_CTX_end(ctx);
+        for (i=0; i<ts; i++)
+                BN_clear_free(&(val[i]));
+        BN_RECP_CTX_free(&recp);
         return(ret);
         }
-/* #endif */
-
-/* #ifdef MONT_MUL_MOD */
-int BN_mod_exp_mont(r,a,p,m,ctx,in_mont)
-BIGNUM *r;
-BIGNUM *a;
-BIGNUM *p;
-BIGNUM *m;
-BN_CTX *ctx;
-BN_MONT_CTX *in_mont;
+
+
+int BN_mod_exp_mont(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
+                    const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *in_mont)
         {
-#define TABLE_SIZE      16
         int i,j,bits,ret=0,wstart,wend,window,wvalue;
-        int start=1;
-        BIGNUM *d,*aa;
-        BIGNUM *val[TABLE_SIZE];
+        int start=1,ts=0;
+        BIGNUM *d,*r;
+        const BIGNUM *aa;
+        BIGNUM val[TABLE_SIZE];
         BN_MONT_CTX *mont=NULL;
 
+        bn_check_top(a);
+        bn_check_top(p);
+        bn_check_top(m);
+
         if (!(m->d[0] & 1))
                 {
                 BNerr(BN_F_BN_MOD_EXP_MONT,BN_R_CALLED_WITH_EVEN_MODULUS);
                 return(0);
                 }
-        d=ctx->bn[ctx->tos++];
         bits=BN_num_bits(p);
         if (bits == 0)
                 {
-                BN_one(r);
-                return(1);
+                ret = BN_one(rr);
+                return ret;
                 }
 
+        BN_CTX_start(ctx);
+        d = BN_CTX_get(ctx);
+        r = BN_CTX_get(ctx);
+        if (d == NULL || r == NULL) goto err;
+
         /* 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;
                 }
 
-        val[0]=BN_new();
-        if (BN_ucmp(a,m) >= 0)
+        BN_init(&val[0]);
+        ts=1;
+        if (a->neg || BN_ucmp(a,m) >= 0)
                 {
-                BN_mod(val[0],a,m,ctx);
-                aa=val[0];
+                if (!BN_nnmod(&(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 > 250)
-                window=5;       /* max size of window */
-        else if (bits >= 120)
-                window=4;
-        else
-                window=3;
+        if (BN_is_zero(aa))
+                {
+                ret = BN_zero(rr);
+                goto err;
+                }
+        if (!BN_to_montgomery(&(val[0]),aa,mont,ctx)) goto err; /* 1 */
 
-        j=1<<(window-1);
-        for (i=1; i<j; i++)
+        window = BN_window_bits_for_exponent_size(bits);
+        if (window > 1)
                 {
-                val[i]=BN_new();
-                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;
                 }
-        for (; i<TABLE_SIZE; i++)
-                val[i]=NULL;
 
         start=1;        /* This is used to avoid multiplication etc
                          * when there is only the value '1' in the
@@ -376,7 +431,7 @@ BN_MONT_CTX *in_mont;
         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)
@@ -419,7 +474,7 @@ BN_MONT_CTX *in_mont;
                                 }
                 
                 /* wvalue will be an odd number < 2^window */
-                if (!BN_mod_mul_montgomery(r,r,val[wvalue>>1],mont,ctx))
+                if (!BN_mod_mul_montgomery(r,r,&(val[wvalue>>1]),mont,ctx))
                         goto err;
 
                 /* move the 'window' down further */
@@ -428,62 +483,201 @@ BN_MONT_CTX *in_mont;
                 start=0;
                 if (wstart < 0) break;
                 }
-        BN_from_montgomery(r,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);
-        ctx->tos--;
-        for (i=0; i<TABLE_SIZE; i++)
-                if (val[i] != NULL) BN_clear_free(val[i]);
+        BN_CTX_end(ctx);
+        for (i=0; i<ts; i++)
+                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). */
+                /* We can use BN_mod and do not need BN_nnmod because our
+                 * accumulator is never negative (the result of BN_mod does
+                 * not depend on the sign of the modulus).
+                 */
+#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->top == 0 || !(m->d[0] & 1))
+                {
+                BNerr(BN_F_BN_MOD_EXP_MONT_WORD,BN_R_CALLED_WITH_EVEN_MODULUS);
+                return(0);
+                }
+        if (m->top == 1)
+                a %= m->d[0]; /* make sure that 'a' is reduced */
+
+        bits = BN_num_bits(p);
+        if (bits == 0)
+                {
+                ret = BN_one(rr);
+                return ret;
+                }
+        if (a == 0)
+                {
+                ret = BN_zero(rr);
+                return ret;
+                }
+
+        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(r,a,p,m,ctx)
-BIGNUM *r;
-BIGNUM *a;
-BIGNUM *p;
-BIGNUM *m;
-BN_CTX *ctx;
+int BN_mod_exp_simple(BIGNUM *r,
+        const BIGNUM *a, const BIGNUM *p, const BIGNUM *m,
+        BN_CTX *ctx)
         {
-        int i,j,bits,ret=0,wstart,wend,window,wvalue;
+        int i,j,bits,ret=0,wstart,wend,window,wvalue,ts=0;
         int start=1;
         BIGNUM *d;
-        BIGNUM *val[16];
+        BIGNUM val[TABLE_SIZE];
 
-        d=ctx->bn[ctx->tos++];
         bits=BN_num_bits(p);
 
         if (bits == 0)
                 {
-                BN_one(r);
-                return(1);
+                ret = BN_one(r);
+                return ret;
                 }
 
-        val[0]=BN_new();
-        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;
+        BN_CTX_start(ctx);
+        if ((d = BN_CTX_get(ctx)) == NULL) goto err;
 
-        j=1<<(window-1);
-        for (i=1; i<j; i++)
+        BN_init(&(val[0]));
+        ts=1;
+        if (!BN_nnmod(&(val[0]),a,m,ctx)) goto err;             /* 1 */
+        if (BN_is_zero(&(val[0])))
                 {
-                val[i]=BN_new();
-                if (!BN_mod_mul(val[i],val[i-1],d,m,ctx))
-                        goto err;
+                ret = BN_zero(r);
+                goto err;
+                }
+
+        window = BN_window_bits_for_exponent_size(bits);
+        if (window > 1)
+                {
+                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;
                 }
-        for (; i<16; i++)
-                val[i]=NULL;
 
         start=1;        /* This is used to avoid multiplication etc
                          * when there is only the value '1' in the
@@ -534,7 +728,7 @@ BN_CTX *ctx;
                                 }
                 
                 /* wvalue will be an odd number < 2^window */
-                if (!BN_mod_mul(r,r,val[wvalue>>1],m,ctx))
+                if (!BN_mod_mul(r,r,&(val[wvalue>>1]),m,ctx))
                         goto err;
 
                 /* move the 'window' down further */
@@ -545,9 +739,9 @@ BN_CTX *ctx;
                 }
         ret=1;
 err:
-        ctx->tos--;
-        for (i=0; i<16; i++)
-                if (val[i] != NULL) BN_clear_free(val[i]);
+        BN_CTX_end(ctx);
+        for (i=0; i<ts; i++)
+                BN_clear_free(&(val[i]));
         return(ret);
         }