#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
bn_check_top(b);
bn_check_top(m);
- t= &(ctx->bn[ctx->tos++]);
+ BN_CTX_start(ctx);
+ if ((t = BN_CTX_get(ctx)) == NULL) goto err;
if (a == b)
{ if (!BN_sqr(t,a,ctx)) goto err; }
else
if (!BN_mod(ret,t,m,ctx)) goto err;
r=1;
err:
- ctx->tos--;
+ BN_CTX_end(ctx);
return(r);
}
int i,bits,ret=0;
BIGNUM *v,*tmp;
- v= &(ctx->bn[ctx->tos++]);
- tmp= &(ctx->bn[ctx->tos++]);
+ 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);
}
ret=1;
err:
- ctx->tos-=2;
+ BN_CTX_end(ctx);
return(ret);
}
/* this one works - simple but works */
int BN_exp(BIGNUM *r, BIGNUM *a, BIGNUM *p, BN_CTX *ctx)
{
- int i,bits,ret=0,tos;
+ int i,bits,ret=0;
BIGNUM *v,*rr;
- tos=ctx->tos;
- v= &(ctx->bn[ctx->tos++]);
+ BN_CTX_start(ctx);
if ((r == a) || (r == p))
- rr= &(ctx->bn[ctx->tos++]);
+ rr = BN_CTX_get(ctx);
else
- rr=r;
+ rr = r;
+ if ((v = BN_CTX_get(ctx)) == NULL) goto err;
if (BN_copy(v,a) == NULL) goto err;
bits=BN_num_bits(p);
}
ret=1;
err:
- ctx->tos=tos;
if (r != rr) BN_copy(r,rr);
+ BN_CTX_end(ctx);
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)
{
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
{ ret=BN_mod_exp_simple(r,a,p,m,ctx); }
#endif
+#ifdef ATALLA
+ tried_atalla=0;
+#endif
+
return(ret);
}
BIGNUM val[TABLE_SIZE];
BN_RECP_CTX recp;
- aa= &(ctx->bn[ctx->tos++]);
bits=BN_num_bits(p);
if (bits == 0)
BN_one(r);
return(1);
}
+
+ BN_CTX_start(ctx);
+ if ((aa = BN_CTX_get(ctx)) == NULL) goto err;
+
BN_RECP_CTX_init(&recp);
if (BN_RECP_CTX_set(&recp,m,ctx) <= 0) goto err;
}
ret=1;
err:
- ctx->tos--;
+ BN_CTX_end(ctx);
for (i=0; i<ts; i++)
BN_clear_free(&(val[i]));
BN_RECP_CTX_free(&recp);
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);
return(0);
}
- d= &(ctx->bn[ctx->tos++]);
- r= &(ctx->bn[ctx->tos++]);
bits=BN_num_bits(p);
if (bits == 0)
{
- BN_one(r);
+ BN_one(rr);
return(1);
}
+ 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 */
ret=1;
err:
if ((in_mont == NULL) && (mont != NULL)) BN_MONT_CTX_free(mont);
- ctx->tos-=2;
+ BN_CTX_end(ctx);
for (i=0; i<ts; i++)
BN_clear_free(&(val[i]));
return(ret);
BIGNUM *d;
BIGNUM val[TABLE_SIZE];
- d= &(ctx->bn[ctx->tos++]);
bits=BN_num_bits(p);
if (bits == 0)
return(1);
}
+ BN_CTX_start(ctx);
+ if ((d = BN_CTX_get(ctx)) == NULL) goto err;
+
BN_init(&(val[0]));
ts=1;
if (!BN_mod(&(val[0]),a,m,ctx)) goto err; /* 1 */
}
ret=1;
err:
- ctx->tos--;
+ BN_CTX_end(ctx);
for (i=0; i<ts; i++)
BN_clear_free(&(val[i]));
return(ret);
projects / openssl.git / blobdiff