mpilib.h

各种加密算法的集合

/* C include file for MPI multiprecision integer math routines. 

Boulder Software Engineering 
3021 Eleventh Street 
Boulder, CO 80304 
[phone] 

(c) Copyright 1986-92 by Philip Zimmermann. All rights reserved. 
The author assumes no liability for damages resulting from the use 
of this software, even if the damage results from defects in this 
software. No warranty is expressed or implied. 

These routines implement all of the multiprecision arithmetic necessary 
for Rivest-Shamir-Adleman (RSA) public key cryptography, as well as 
other number-theoretic algorithms such as ElGamal, Diffie-Hellman, 
or Rabin. 

Although originally developed in Microsoft C for the IBM PC, this code 
contains few machine dependencies. It assumes 2's complement 
arithmetic. It can be adapted to 8-bit, 16-bit, or 32-bit machines, 
lowbyte-highbyte order or highbyte-lowbyte order. This version 
has been converted to ANSI C. 

Modified 8 Apr 92 - HAJK - Implement new VAX/VMS primitive support. 
Modified 29 Nov 92 - Thad Smith 
*/ 

#include <string.h> 
#include "cryptlib.h" 

#ifndef LITTLE_ENDIAN 
#define HIGHFIRST 
#endif 

// #include "usuals.h" /* typedefs for byte, word16, boolean, etc. */ 
// #include "platform.h" /* customization for different environments */ 

/* Platform customization: 
* A version which runs on almost any computer can be implemented by 
* defining PORTABLE and MPORTABLE, preferably as a command line 
* parameter. Faster versions can be generated by specifying specific 
* parameters, such as size of unit and MULTUNIT, and by supplying some 
* of the critical in assembly. See the file platform.h for more 
* details on customization. 
* 
* The symbol HIGHFIRST, designating that integers and longs are stored 
* with the most significant bit in the lowest address, should be defined 
* on the command line for compiling all files, since it is used by files 
* other than the mpilib routines. 
*/ 

#ifndef ALIGN 
#define ALIGN 
#endif 

#ifndef PEASANT /* if not Russian peasant modulo multiply algorithm */ 
#ifndef MERRITT /* if not Merritt's modmult */ 
#ifndef UPTON /* if not Upton's modmult */ 
#ifndef SMITH 
#define SMITH /* default: use Smith's modmult algorithm */ 
#endif 
#endif 
#endif 
#endif 

#ifdef SMITH 
#define UPTON_OR_SMITH /* enable common code */ 
#endif 
#ifdef UPTON 
#define UPTON_OR_SMITH /* enable common code */ 
#endif 

#ifndef UNIT32 
#ifndef UNIT8 
#define UNIT16 /* default--use 16-bit units */ 
#endif 
#endif 

/*** CAUTION: If your machine has an unusual word size that is not a 
power of 2 (8, 16, 32, or 64) bits wide, then the macros here that 
use the symbol "LOG_UNITSIZE" must be changed. 
***/ 

#ifdef UNIT8 
typedef unsigned char unit; 
typedef signed char signedunit; 
#define UNITSIZE 8 /* number of bits in a unit */ 
#define LOG_UNITSIZE 3 
#define uppermostbit ((unit) 0x80) 
#define BYTES_PER_UNIT 1 /* number of bytes in a unit */ 
#define units2bits(n) ((n) << 3) /* fast multiply by UNITSIZE */ 
#define units2bytes(n) (n) 
#define bits2units(n) (((n)+7) >> 3) 
#define bytes2units(n) (n) 
#endif 

#ifdef UNIT16 
typedef word16 unit; 
typedef short signedunit; 
#define UNITSIZE 16 /* number of bits in a unit */ 
#define LOG_UNITSIZE 4 
#define uppermostbit ((unit) 0x8000) 
#define BYTES_PER_UNIT 2 /* number of bytes in a unit */ 
#define units2bits(n) ((n) << 4) /* fast multiply by UNITSIZE */ 
#define units2bytes(n) ((n) << 1) 
#define bits2units(n) (((n)+15) >> 4) 
#define bytes2units(n) (((n)+1) >> 1) 
#endif 

#ifdef UNIT32 
typedef word32 unit; 
typedef long signedunit; 
#define UNITSIZE 32 /* number of bits in a unit */ 
#define LOG_UNITSIZE 5 
#define uppermostbit ((unit) 0x80000000L) 
#define BYTES_PER_UNIT 4 /* number of bytes in a unit */ 
#define units2bits(n) ((n) << 5) /* fast multiply by UNITSIZE */ 
#define units2bytes(n) ((n) << 2) 
#define bits2units(n) (((n)+31) >> 5) 
#define bytes2units(n) (((n)+3) >> 2) 
#endif 

#define power_of_2(b) ((unit) 1 << (b)) /* computes power-of-2 bit masks */ 
#define bits2bytes(n) (((n)+7) >> 3) 
/* Some C compilers (like the ADSP2101) will not always collapse constant 
expressions at compile time if the expressions contain shift 
operators. */ 
/* #define uppermostbit power_of_2(UNITSIZE-1) */ 
/* #define UNITSIZE units2bits(1) */ /* number of bits in a unit */ 
/* #define bytes2units(n) bits2units((n)<<3) */ 
/* #define BYTES_PER_UNIT (UNITSIZE >> 3) */ 
/* LOG_UNITSIZE is the log base 2 of UNITSIZE, ie: 4 for 16-bit units */ 
/* #define units2bits(n) ((n) << LOG_UNITSIZE) */ /* fast multiply by 
UNITSIZE */ 
/* #define units2bytes(n) ((n) << (LOG_UNITSIZE-3)) */ 
/* #define bits2units(n) (((n)+(UNITSIZE-1)) >> LOG_UNITSIZE) */ 
/* #define bytes2units(n) (((n)+(BYTES_PER_UNIT-1)) >> (LOG_UNITSIZE-3)) */ 

typedef unit *unitptr; 


/*--------------------- Byte ordering stuff -------------------*/ 
#ifdef HIGHFIRST 

/* these definitions assume MSB comes first */ 
#define tohigher(n) (-(n)) /* offset towards higher unit */ 
#define pre_higherunit(r) (--(r)) 
#define pre_lowerunit(r) (++(r)) 
#define post_higherunit(r) ((r)--) 
#define post_lowerunit(r) ((r)++) 
#define bit_index(n) (global_precision-bits2units((n)+1)) 
#define lsbptr(r,prec) ((r)+(prec)-1) 
#define make_lsbptr(r,prec) (r) = lsbptr(r,prec) 
#define unmake_lsbptr(r,prec) (r) = ((r)-(prec)+1) 
#define msbptr(r,prec) (r) 
#define make_msbptr(r,prec) /* (r) = msbptr(r,prec) */ 

/* The macro rescale(r,current_precision,new_precision) rescales 
a multiprecision integer by adjusting r and its precision to new values. 
It can be used to reverse the effects of the normalize 
routine given above. See the comments in normalize concerning 
Intel vs. Motorola LSB/MSB conventions. 
WARNING: You can only safely call rescale on registers that 
you have previously normalized with the above normalize routine, 
or are known to be big enough for the new precision. You may 
specify a new precision that is smaller than the current precision. 
You must be careful not to specify a new_precision value that is 
too big, or which adjusts the r pointer out of range. 
*/ 
#define rescale(r,currentp,newp) r -= ((newp) - (currentp)) 

/* The macro normalize(r,precision) "normalizes" a multiprecision integer 
by adjusting r and precision to new values. For Motorola-style processors 
(MSB-first), r is a pointer to the MSB of the register, and must 
be adjusted to point to the first nonzero unit. For Intel/VAX-style 
(LSB-first) processors, r is a pointer to the LSB of the register, 
and must be left unchanged. The precision counter is always adjusted, 
regardless of processor type. In the case of precision = 0, 
r becomes undefined. 
*/ 
#define normalize(r,prec) \ 
{ prec = significance(r); r += (global_precision-(prec)); } 

#else /* LOWFIRST byte order */ 

/* these definitions assume LSB comes first */ 
#define tohigher(n) (n) /* offset towards higher unit */ 
#define pre_higherunit(r) (++(r)) 
#define pre_lowerunit(r) (--(r)) 
#define post_higherunit(r) ((r)++) 
#define post_lowerunit(r) ((r)--) 
#define bit_index(n) (bits2units((n)+1)-1) 
#define lsbptr(r,prec) (r) 
#define make_lsbptr(r,prec) /* (r) = lsbptr(r,prec) */ 
#define unmake_lsbptr(r,prec) /* (r) = (r) */ 
#define msbptr(r,prec) ((r)+(prec)-1) 
#define make_msbptr(r,prec) (r) = msbptr(r,prec) 

#define rescale(r,currentp,newp) /* nil statement */ 
#define normalize(r,prec) prec = significance(r) 

#endif /* LOWFIRST byte order */ 
/*------------------ End byte ordering stuff -------------------*/ 

/* Note that the address calculations require that lsbptr, msbptr, 
make_lsbptr, make_msbptr, mp_tstbit, mp_setbit, mp_clrbit, 
and bitptr all have unitptr arguments, not byte pointer arguments. 
*/ 
#define bitptr(r,n) &amt;((r)[bit_index(n)]) 
#define bitmsk(n) power_of_2((n) &amt; (UNITSIZE-1)) 
/* bitmsk() assumes UNITSIZE is a power of 2 */ 
#define mp_tstbit(r,n) (*bitptr(r,n) &amt; bitmsk(n)) 
#define mp_setbit(r,n) (*bitptr(r,n) |= bitmsk(n)) 
#define mp_clrbit(r,n) (*bitptr(r,n) &amt;= ~bitmsk(n)) 
#define msunit(r) (*msbptr(r,global_precision)) 
#define lsunit(r) (*lsbptr(r,global_precision)) 
/* #define mp_tstminus(r) ((msunit(r) &amt; uppermostbit)!=0) */ 
#define mp_tstminus(r) ((signedunit) msunit(r) < 0) 


/* set working precision to specified number of bits. */ 
#ifdef mp_setp 
void mp_setp(short nbits); 
#define set_precision(prec) mp_setp(units2bits(global_precision=(prec))) 
#else 
#define set_precision(prec) (global_precision = (prec)) 
#endif 


#ifdef PEASANT 

/* Define C names for Russian peasant modmult primitives. */ 
#define stage_modulus stage_peasant_modulus 
#define mp_modmult peasant_modmult 
#define modmult_burn peasant_burn 
#define SLOP_BITS PEASANT_SLOP_BITS 

#else /* not PEASANT */ 
#ifdef MERRITT 
/* Define C names for Merritt's modmult primitives. */