source: svn/trunk/newcon3bcm2_21bu/dta/src/bootloader/rsa/mp2.h

/* 
 * Multiple-Precision Modular Arithmetic Routines
 *
 *
 * Change log: 07/17/02 - Created.
 */

#if !defined(__MP2_H__)
#define __MP2_H__

#if !defined(RSA_BITS)
#define RSA_BITS 1024
#endif
/* Data structure for big numbers */

typedef unsigned long * mp;                                     /* we represent each mp number as an array of 
                                                                 * 30-bit long numbers (each group of 30-bit 
                                                                 * will be called a 'chunk') */
/* Other types needed */
typedef unsigned char u8;
typedef unsigned long u32;
typedef signed char s8;
typedef signed long s32;

#define CHARL                   8                               /* number of bits in a byte */
#define SIZEOFLONG              4                               /* number of bytes in a long */
#define BITSOFLONG      (CHARL*SIZEOFLONG)              /* number of bits in a long */

#define NBITS                   30                              /* number of bits used per chunk, 
                                                                 * It must be even and <32      */
#define RADIX                   (1L << NBITS)                   /* this is 'b' in the algorithms */
#define UNUSEDBITS              (BITSOFLONG-NBITS)              /* no. bits unused in chunk */

#define NBITSH                  (NBITS >> 1L)                   /* half the number of bits/chunk */
#define RADIXM          (RADIX-1)                       /* RADIX mask */
#define RADIXROOT       (1L<<NBITSH)                    /* "RADIX" for half chunk */
#define RADIXROOTM      (RADIXROOT-1)                   /* RADIXROOT mask */
#define NBITSM1                 (NBITS-1)                                       
#define MSBMASK                 (1L << NBITSM1)                 /* most significant bit mask */
#define MASK                    RADIXM                          /* marks which bits are used in chunk */

#define MPSIZE                  RSA_BITS                        /* size in bits of mp numbers */
#define SIZE                    ((MPSIZE+NBITS-1)/NBITS)+1      /* size in chunks of mp numbers */
#define EXTSIZE                 (SIZE+2)                        /* include space to store actual size */
#define LONGEXTSIZE             ((EXTSIZE*2)+2)         /* for temp results in multiplications */

#define OK                              0xFE0AF2FAUL    /* RSA signature verifies OK */
#define BAD                             0x01                    /* RSA sig NOT ok. */
                                                                                /* (it must be != OK ) */

//#define CACHE_RSA_ADDRESS     0x800094

/* Layout of mp numbers:
   Consider 'a' is a mp number (eg. 'mp a;')
   - |a[0]| stores the actual size (in 32-bit words), say n.
   - a[1] ... a[n] stores the big number, a[1] is the least significant digit

   The absolute value of the number represented by 'a' is
   the sum over i=1..n of a[i]*2^((i-1)*NBITS).
   The sign of this number is the sign of a[0] [Note: most of the time, only
   positive numbers are used]

   Memory Allocation: 
   Numbers allocate either EXTSIZE  or LONGEXTSIZE 32-bit words.
   
   Zeroize at init: a[0]= 1; a[1] = 0;
 */

/* Arithmetic Operations */

/* Comparison of two numbers */
s32  mpcompare (mp a, mp b);

/*      Addition of mp numbers:                 
 *      c = a + b */
void mpadd (mp a, mp b, mp c);

/*      Substraction of mp numbers:     
 *      c = a - b     */
void mpsub (mp a, mp b, mp c); 

/*      Division (quotient, rest) of mp numbers:  
 *      q = a / b ; r = a % b */
int mpdiv (mp a, mp b, mp q, mp r);

/*      Multiplication of mp numbers:   
 *      c = a * b  */
void mpmul(mp a, mp b, mp c);

/*      Left shift a by k units of 30-bits.             
 *      b = a << 32*k */
void mpclshift (mp a, u32 k, mp b);

/*      RSA Signature Verification (RSA Encryption) */
int rsa (void *input, void *pubkey, void *digest);

/* Internal functions */

/* w = (w + c + x * y) / RADIX; 
 * c = (w + c + x * y) % RADIX;
 */
void addmul(u32 * w, u32* c, u32 x, u32 y);
/*      smalldiv returns 'q' and 'r' so
 *      q = (hi*RADIX + lo)/d;
 *      r = (hi*RADIX + lo)%d;
 *      Assumes 0 <= hi < d < RADIX and 0 <= lo < RADIX.
 */
int smalldiv (u32 hi, u32 lo, u32 d, u32 *q, u32 *r);

void mpcopy (mp a, mp b);
void mpzero (mp a);

/* Macros */

#define MAX(a,b)                                ((a>b)? a: b)

/* Swaps two mp numbers */
#define mpswap(a,b)                     \
{                                                       \
        mp tmp = a;     \
        a = b;          \
        b = tmp;        \
}

#if 0
/* May use BCM-MIPS32-01 CTZ instruction instead */
#define CLZ(rd, rs)                     \
{                                                       \
        s32 _i=0;                               \
        rd = 32;                                \
        for (_i=31; _i>=0; _i--)\
                if (rs & (1L << _i))    \
                {                                       \
                        rd = 31-_i;             \
                        break;                  \
                }                                       \
}
#else
#define CLZ(rd, rs) __asm__("clz %0,%1":"=r"(rd):"r"(rs))
#endif

#define iszero(a)                               ( *(a)==1L && (a)[1] == 0L )
#define sign(a)                                 ( ((a)>0)? 1: ((a)<0)? -1: 0 )

#define ROTL32(a,n)                             (((a) << (n)) \
                                                                        | ((a) >> (32 - (n))))
#define ROTR32(a,n)                             (((a) << (32-(n))) | (((unsigned long)(a)) >> (n)))


/* Endianness Conversion (taken from nessie.h) */


#define BIG_ENDIAN

#define ONE8    0xffU
#define T8(x)   ((x) & ONE8)

#ifdef BIG_ENDIAN
/*
 * U8TO32_BIG(c) returns the 32-bit value stored in big-endian convention
 * in the unsigned char array pointed to by c.
 */

/* TODO: Replace with BCM-MIPS32-01 big-endian load instructions */
#define U8TO32_BIG(c)  (((u32)T8(*((c) + 3 )) << 24) | ((u32)T8(*((c) + 2)) << 16) | \
                        ((u32)T8(*((c) + 1)) << 8) | ((u32)T8(*((c)))))

#define CONVERT(c)  (((u32)T8(*(c)) << 24) | ((u32)T8(*((c) + 1)) << 16) | \
                        ((u32)T8(*((c) + 2)) << 8) | ((u32)T8(*((c) + 3))))
/*
 * U32TO8_BIG(c, v) stores the 32-bit-value v in big-endian convention
 * into the unsigned char array pointed to by c.
 */
/* TODO: Replace with BCM-MIPS32-01 big-endian store instruction */
#define U32TO8_BIG(c, v)    do { \
                u32 x = (v); \
                u8 *d = (c); \
                d[3] = T8(x >> 24); \
                d[2] = T8(x >> 16); \
                d[1] = T8(x >> 8); \
                d[0] = T8(x); \
        } while (0)

#else

#define U8TO32_BIG(c)  (((u32)T8(*(c)) << 24) | ((u32)T8(*((c) + 1)) << 16) | \
                        ((u32)T8(*((c) + 2)) << 8) | ((u32)T8(*((c) + 3))))
#define U32TO8_BIG(c, v)    do { \
                u32 x = (v); \
                u8 *d = (c); \
                d[0] = T8(x >> 24); \
                d[1] = T8(x >> 16); \
                d[2] = T8(x >> 8); \
                d[3] = T8(x); \
        } while (0)
#endif

void mpclshift (mp a, u32 k, mp b);
void mplshift (mp a, u32 k, mp b);
void mprshift (mp a, u32 k, mp b);
void unpack (mp src30, u32 *dest32, u32 n);
void pack (u32 *src32, mp dest30, u32 n);

/* 
   RSA 1024 decryption function.
   All pointers must be 4 bytes aligned as this function will access data as
   unsigned int type. Failure to align data will result in unaligned access
   exception.
 */
int rsa_decrypt (unsigned long * in, unsigned long * pubkey, unsigned long * decrypted_digest);

/*
   RSA 1024 RAW decryption function. Does not check padding.
   All pointers must be 4 bytes aligned as this function will access data as
   unsigned int type. Failure to align data will result in unaligned access
   exception.
*/
int rsa_decrypt_raw (unsigned long * in, unsigned long * pubkey, unsigned long * out);

#endif

/* Please do not remove! */
/* Local Variables: */
/* mode: C */
/* indent-tabs-mode: nil */
/* End: */