mirror of
https://github.com/rvtr/TwlIPL.git
synced 2025-10-31 06:01:12 -04:00
60f18e5554
git-svn-id: file:///Users/lillianskinner/Downloads/platinum/twl/TwlIPL/trunk@1 b08762b0-b915-fc4b-9d8c-17b2551a87ff
325 lines
8.7 KiB
C
325 lines
8.7 KiB
C
/* $Id$ */
|
|
/*
|
|
* Copyright (C) 1998-2002 RSA Security Inc. All rights reserved.
|
|
*
|
|
* This work contains proprietary information of RSA Security.
|
|
* Distribution is limited to authorized licensees of RSA
|
|
* Security. Any unauthorized reproduction, distribution or
|
|
* modification of this work is strictly prohibited.
|
|
*
|
|
*/
|
|
|
|
#ifndef HEADER_COMMON_BN_LCL_H
|
|
#define HEADER_COMMON_BN_LCL_H
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
//#include "r_error.h"
|
|
//#include "err.h"
|
|
#include <string.h>
|
|
|
|
#ifndef STANDALONE
|
|
#include "r_com.h"
|
|
#else
|
|
#define NO_STDLIB_MAPPING
|
|
#define Malloc(a) malloc(a)
|
|
#define Free(a) free(a)
|
|
#define Memset(a,b,c) memset(a,b,c)
|
|
#define Memcpy(a,b,c) memcpy(a,b,c)
|
|
#endif
|
|
|
|
/* TEMP FIX */
|
|
#undef BNerr
|
|
#define BNerr(a,b)
|
|
#include "bn.h"
|
|
|
|
#define BN_EXP_TABLE_SIZE 16
|
|
|
|
/* see the bn_limit_ fields which are the start of a runtime
|
|
* tunable set of values to match these fixed compile-time constants
|
|
*/
|
|
/* Pentium pro 16,16,16,32,64 */
|
|
/* Alpha 16,16,16,16.64 */
|
|
/* StrongARM */
|
|
#define BN_MULL_SIZE_NORMAL (16) /* 32 */
|
|
#define BN_MUL_RECURSIVE_SIZE_NORMAL (16) /* 32 */ /* less than */
|
|
#define BN_SQR_RECURSIVE_SIZE_NORMAL (16) /* 32 */
|
|
#define BN_MUL_LOW_RECURSIVE_SIZE_NORMAL (32) /* 32 */
|
|
#define BN_MONT_CTX_SET_SIZE_WORD (64) /* 32 */
|
|
|
|
/*************************************************************
|
|
* Using the long long type
|
|
*/
|
|
#define Lw(t) (((BN_ULONG)(t))&BN_MASK2)
|
|
#define Hw(t) (((BN_ULONG)((t)>>BN_BITS2))&BN_MASK2)
|
|
|
|
/* These are used for internal error checking and are not normally used */
|
|
#ifdef BN_DEBUG
|
|
#define bn_check_top(a) \
|
|
{ if ( ((a)->top < 0) || \
|
|
((a)->top > (a)->max) || \
|
|
(((a)->top == 0) && (a)->neg) || \
|
|
(((a)->top == 1) && (a->d[0] == 0))) \
|
|
{ char *nullp=NULL; *nullp='z'; } }
|
|
#define bn_check_num(a) if ((a) < 0) { char *nullp=NULL; *nullp='z'; }
|
|
#define bn_assert(a) if (!(a)) { char *nullp=NULL; *nullp='z'; }
|
|
#define bn_set_used_check(l,size,num) bn_su_check(l,size,num)
|
|
#ifdef BN_DEBUG2
|
|
#define bn_do_used_check(fp,str,l,size,num) bn_du_check(fp,str,l,size,num)
|
|
#else
|
|
#define bn_do_used_check(fp,str,l,size,num)
|
|
#endif
|
|
#else
|
|
#define bn_assert(a)
|
|
#define bn_check_top(a)
|
|
#define bn_check_num(a)
|
|
#define bn_set_used_check(l,size,num)
|
|
#define bn_do_used_check(fp,str,l,size,num)
|
|
#endif
|
|
|
|
|
|
/***********************************************
|
|
* IA64 32 bit build SWIZZLE code
|
|
* This essentially casts our points which are
|
|
* 32bits under abi32 to 64bit unsigned long
|
|
* longs and then grabs the top two bits of the
|
|
* pointer and places it in the 2nd and 3rd bits
|
|
* of the unsigned long long.
|
|
**********************************************/
|
|
#ifdef HPUX_IA64_32
|
|
#define SWIZLLE(VALUE) ((((unsigned long long)(VALUE) & 0xc0000000LL) <<31)\
|
|
|((unsigned long long)(VALUE)))
|
|
#else
|
|
#define SWIZZLE(VALUE) (VALUE)
|
|
#endif
|
|
|
|
#define bn_neg_words(a,n) \
|
|
{ \
|
|
int iii; \
|
|
\
|
|
for (iii=0; iii<n; iii++) \
|
|
{ \
|
|
a[iii]= (-a[iii])&BN_MASK2; \
|
|
} \
|
|
for (;;) \
|
|
if ((++a[iii])&BN_MASK2) break; \
|
|
}
|
|
|
|
/* This macro is to add extra stuff for development checking */
|
|
#ifdef BN_DEBUG
|
|
#define bn_set_max(r) ((r)->max=(r)->top,BN_set_flags((r),BN_FLG_STATIC_DATA))
|
|
#else
|
|
#define bn_set_max(r)
|
|
#endif
|
|
|
|
/* These macros are used to 'take' a section of a bignum for read only use */
|
|
#define bn_set_low(r,a,n) \
|
|
{ \
|
|
(r)->top=((a)->top > (n))?(n):(a)->top; \
|
|
(r)->d=(a)->d; \
|
|
(r)->neg=(a)->neg; \
|
|
(r)->flags|=BN_FLG_STATIC_DATA; \
|
|
bn_set_max(r); \
|
|
}
|
|
|
|
#define bn_set_high(r,a,n) \
|
|
{ \
|
|
if ((a)->top > (n)) \
|
|
{ \
|
|
(r)->top=(a)->top-n; \
|
|
(r)->d= &((a)->d[n]); \
|
|
} \
|
|
else \
|
|
(r)->top=0; \
|
|
(r)->neg=(a)->neg; \
|
|
(r)->flags|=BN_FLG_STATIC_DATA; \
|
|
bn_set_max(r); \
|
|
}
|
|
|
|
/* #define bn_expand(n,b) ((((b)/BN_BITS2) <= (n)->max)?(n):bn_expand2((n),(b))) */
|
|
|
|
#ifdef BN_LLONG
|
|
#define mul_add(r,a,w,c) { \
|
|
BN_ULLONG t; \
|
|
t=(BN_ULLONG)w * (a) + (r) + (c); \
|
|
(r)= Lw(t); \
|
|
(c)= Hw(t); \
|
|
}
|
|
|
|
#define mul(r,a,w,c) { \
|
|
BN_ULLONG t; \
|
|
t=(BN_ULLONG)w * (a) + (c); \
|
|
(r)= Lw(t); \
|
|
(c)= Hw(t); \
|
|
}
|
|
|
|
#else
|
|
/*************************************************************
|
|
* No long long type
|
|
*/
|
|
|
|
#define LBITS(a) ((a)&BN_MASK2l)
|
|
#define HBITS(a) (((a)>>BN_BITS4)&BN_MASK2lh)
|
|
#define L2HBITS(a) ((BN_ULONG)((a)&BN_MASK2lh)<<BN_BITS4)
|
|
|
|
#define mul64(l,h,bl,bh) \
|
|
{ \
|
|
BN_ULONG m,m1,lt,ht; \
|
|
\
|
|
lt=l; \
|
|
ht=h; \
|
|
m =(bh)*(lt); \
|
|
lt=(bl)*(lt); \
|
|
m1=(bl)*(ht); \
|
|
ht =(bh)*(ht); \
|
|
m=(m+m1)&BN_MASK2; if (m < m1) ht+=L2HBITS(1L); \
|
|
ht+=HBITS(m); \
|
|
m1=L2HBITS(m); \
|
|
lt=(lt+m1)&BN_MASK2; if (lt < m1) ht++; \
|
|
(l)=lt; \
|
|
(h)=ht; \
|
|
}
|
|
|
|
#define sqr64(lo,ho,in) \
|
|
{ \
|
|
BN_ULONG l,h,m; \
|
|
\
|
|
h=(in); \
|
|
l=LBITS(h); \
|
|
h=HBITS(h); \
|
|
m =(l)*(h); \
|
|
l*=l; \
|
|
h*=h; \
|
|
h+=(m&BN_MASK2h1)>>(BN_BITS4-1); \
|
|
m =((m&BN_MASK2l)<<(BN_BITS4+1))&BN_MASK2; \
|
|
l=(l+m)&BN_MASK2; if (l < m) h++; \
|
|
(lo)=l; \
|
|
(ho)=h; \
|
|
}
|
|
|
|
#if 0
|
|
#define mul_add(r,a,bl,bh,b_hl,c) { \
|
|
BN_ULONG l,h; \
|
|
BN_ULONG lt,mt; \
|
|
\
|
|
h= (a); \
|
|
l=LBITS(h); \
|
|
h=HBITS(h); \
|
|
mt=bl*l; \
|
|
lt=mt+c+(r); \
|
|
c=bh*h; \
|
|
mt+=c+(l-h)*b_hl; \
|
|
mt+=(lt>>BN_BITS4); \
|
|
(r)=(lt&BN_MASK2l)|((mt&BN_MASK2l)<<BN_BITS4); \
|
|
c+=(mt>>BN_BITS4); \
|
|
}
|
|
#else /* Normal version */
|
|
#define mul_add(r,a,bl,bh,b_hl,c) { \
|
|
BN_ULONG l,h; \
|
|
\
|
|
h= (a); \
|
|
l=LBITS(h); \
|
|
h=HBITS(h); \
|
|
mul64(l,h,(bl),(bh)); \
|
|
\
|
|
/* non-multiply part */ \
|
|
l=(l+(c))&BN_MASK2; if (l < (c)) h++; \
|
|
(c)=(r); \
|
|
l=(l+(c))&BN_MASK2; if (l < (c)) h++; \
|
|
(c)=h&BN_MASK2; \
|
|
(r)=l; \
|
|
}
|
|
#endif
|
|
|
|
#define mul(r,a,bl,bh,c) { \
|
|
BN_ULONG l,h; \
|
|
\
|
|
h= (a); \
|
|
l=LBITS(h); \
|
|
h=HBITS(h); \
|
|
mul64(l,h,(bl),(bh)); \
|
|
\
|
|
/* non-multiply part */ \
|
|
l+=(c); if ((l&BN_MASK2) < (c)) h++; \
|
|
(c)=h&BN_MASK2; \
|
|
(r)=l&BN_MASK2; \
|
|
}
|
|
|
|
#endif
|
|
|
|
#ifndef BN_MUL_COMBA
|
|
#define bn_mul_comba4(r,a,b) bn_mul_normal(r,a,4,b,4)
|
|
#define bn_mul_comba5(r,a,b) bn_mul_normal(r,a,5,b,5)
|
|
#define bn_mul_comba6(r,a,b) bn_mul_normal(r,a,6,b,6)
|
|
#define bn_mul_comba8(r,a,b) bn_mul_normal(r,a,8,b,8)
|
|
#define bn_mul_comba11(r,a,b) bn_mul_normal(r,a,11,b,11)
|
|
#define bn_mul_comba12(r,a,b) bn_mul_normal(r,a,12,b,12)
|
|
#define bn_mul_comba16(r,a,b) bn_mul_normal(r,a,16,b,16)
|
|
#endif
|
|
#if 1
|
|
#ifndef BN_SQR_COMBA
|
|
#define bn_sqr_comba4(r,a) bn_mul_normal(r,a,4,a,4)
|
|
#define bn_sqr_comba5(r,a) bn_mul_normal(r,a,5,a,5)
|
|
#define bn_sqr_comba6(r,a) bn_mul_normal(r,a,6,a,6)
|
|
#define bn_sqr_comba8(r,a) bn_mul_normal(r,a,8,a,8)
|
|
#define bn_sqr_comba11(r,a) bn_mul_normal(r,a,11,a,11)
|
|
#define bn_sqr_comba12(r,a) bn_mul_normal(r,a,12,a,12)
|
|
#define bn_sqr_comba16(r,a) bn_mul_normal(r,a,16,a,16)
|
|
#endif
|
|
#else
|
|
#ifndef BN_SQR_COMBA
|
|
#define bn_sqr_comba4(r,a) bn_mul_comba4(r,a,a)
|
|
#define bn_sqr_comba5(r,a) bn_mul_comba5(r,a,a)
|
|
#define bn_sqr_comba6(r,a) bn_mul_comba6(r,a,a)
|
|
#define bn_sqr_comba8(r,a) bn_mul_comba8(r,a,a)
|
|
#define bn_sqr_comba11(r,a) bn_mul_comba11(r,a,a)
|
|
#define bn_sqr_comba12(r,a) bn_mul_comba12(r,a,a)
|
|
#define bn_sqr_comba16(r,a) bn_mul_comba16(r,a,a)
|
|
#endif
|
|
#endif
|
|
#ifndef BN_REDUCE_COMBA
|
|
#define r0_bn_mont_comba4(r,a,n,num,n0) bn_from_montgomery_words(r,a,n,num,n0)
|
|
#define r0_bn_mont_comba5(r,a,n,num,n0) bn_from_montgomery_words(r,a,n,num,n0)
|
|
#define r0_bn_mont_comba6(r,a,n,num,n0) bn_from_montgomery_words(r,a,n,num,n0)
|
|
#define r0_bn_mont_comba8(r,a,n,num,n0) bn_from_montgomery_words(r,a,n,num,n0)
|
|
#define r0_bn_mont_comba11(r,a,n,num,n0) bn_from_montgomery_words(r,a,n,num,n0)
|
|
#define r0_bn_mont_comba12(r,a,n,num,n0) bn_from_montgomery_words(r,a,n,num,n0)
|
|
#define r0_bn_mont_comba16(r,a,n,num,n0) bn_from_montgomery_words(r,a,n,num,n0)
|
|
#endif
|
|
|
|
#ifndef NOPROTO
|
|
|
|
BIGNUM *bn_expand2(BIGNUM *b, int bits);
|
|
|
|
#ifdef X86_ASM
|
|
void bn_add_words(BN_ULONG *r,BN_ULONG *a,int num);
|
|
#endif
|
|
|
|
#else
|
|
|
|
BIGNUM *bn_expand2();
|
|
#ifdef X86_ASM
|
|
BN_ULONG bn_add_words();
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* HEADER_COMMON_BN_LCL_H */
|
|
|
|
void bn_mul_low_recursive(BN_ULONG *r,BN_ULONG *a,BN_ULONG *b,int n2,BN_ULONG *t);
|
|
void bn_mul_high(BN_ULONG *r,BN_ULONG *a,BN_ULONG *b,BN_ULONG *l,int n2, BN_ULONG *t);
|
|
int BN_gen_exp_string(unsigned char *str, BIGNUM *p, int bits);
|
|
void bn_from_montgomery_rec_full(BN_ULONG *rp, BN_ULONG *ap,
|
|
BN_ULONG *np, BN_ULONG *nip, BN_ULONG *tmp,BN_REC *rec);
|
|
|
|
int bn_mont_ctx_new_word(const BN_ME_METH *meth, BN_ME_CTX **retp);
|
|
|