tomcrypt.h File Reference

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <basetsd.h>

Include dependency graph for tomcrypt.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	tag_rc2_key
struct	tag_des_key
struct	tag_des3_key
struct	tag_aes_key
struct	tag_md2_state
struct	rc4_prng
union	Prng_state
struct	mp_int
struct	Rsa_key

Macros
#define	CONST64(a, b)   ((((ULONG64)(a)) << 32) | (b))
#define	STORE32H(x, y)
#define	LOAD32H(x, y)
#define	ROR(x, y)
#define	MIN(x, y)   ( ((x)<(y))?(x):(y) )
#define	byte(x, n)   (((x) >> (8 * (n))) & 255)
#define	DIGIT_BIT   28
#define	MP_DIGIT_BIT   DIGIT_BIT
#define	MP_MASK   ((((mp_digit)1)<<((mp_digit)DIGIT_BIT))-((mp_digit)1))
#define	MP_DIGIT_MAX   MP_MASK
#define	MP_LT   -1 /* less than */
#define	MP_EQ   0 /* equal to */
#define	MP_GT   1 /* greater than */
#define	MP_ZPOS   0 /* positive integer */
#define	MP_NEG   1 /* negative */
#define	MP_OKAY   0 /* ok result */
#define	MP_MEM   -2 /* out of mem */
#define	MP_VAL   -3 /* invalid input */
#define	MP_RANGE   MP_VAL
#define	MP_YES   1 /* yes response */
#define	MP_NO   0 /* no response */
#define	LTM_PRIME_BBS   0x0001 /* BBS style prime */
#define	LTM_PRIME_SAFE   0x0002 /* Safe prime (p-1)/2 == prime */
#define	LTM_PRIME_2MSB_OFF   0x0004 /* force 2nd MSB to 0 */
#define	LTM_PRIME_2MSB_ON   0x0008 /* force 2nd MSB to 1 */
#define	MP_PREC   64 /* default digits of precision */
#define	MP_WARRAY   (1 << (sizeof(mp_word) * CHAR_BIT - 2 * DIGIT_BIT + 1))
#define	DIGIT(m, k)   ((m)->dp[(k)])
#define	mp_iszero(a)   (((a)->used == 0) ? MP_YES : MP_NO)
#define	mp_iseven(a)   (((a)->used > 0 && (((a)->dp[0] & 1) == 0)) ? MP_YES : MP_NO)
#define	mp_isodd(a)   (((a)->used > 0 && (((a)->dp[0] & 1) == 1)) ? MP_YES : MP_NO)
#define	PRIME_SIZE   256
#define	mp_prime_random(a, t, size, bbs, cb, dat)   mp_prime_random_ex(a, t, ((size) * 8) + 1, (bbs==1)?LTM_PRIME_BBS:0, cb, dat)
#define	mp_read_raw(mp, str, len)   mp_read_signed_bin((mp), (str), (len))
#define	mp_raw_size(mp)   mp_signed_bin_size(mp)
#define	mp_toraw(mp, str)   mp_to_signed_bin((mp), (str))
#define	mp_read_mag(mp, str, len)   mp_read_unsigned_bin((mp), (str), (len))
#define	mp_mag_size(mp)   mp_unsigned_bin_size(mp)
#define	mp_tomag(mp, str)   mp_to_unsigned_bin((mp), (str))
#define	mp_tobinary(M, S)   mp_toradix((M), (S), 2)
#define	mp_tooctal(M, S)   mp_toradix((M), (S), 8)
#define	mp_todecimal(M, S)   mp_toradix((M), (S), 10)
#define	mp_tohex(M, S)   mp_toradix((M), (S), 16)
#define	PK_PRIVATE   0 /* PK private keys */
#define	PK_PUBLIC   1 /* PK public keys */
#define	MIN_RSA_SIZE   384
#define	MAX_RSA_SIZE   16384

Typedefs
typedef ULONG64	ulong64
typedef ULONG32	ulong32
typedef struct tag_rc2_key	rc2_key
typedef struct tag_des_key	des_key
typedef struct tag_des3_key	des3_key
typedef struct tag_aes_key	aes_key
typedef struct tag_md2_state	md2_state
typedef union Prng_state	prng_state
typedef unsigned long	mp_digit
typedef ulong64	mp_word
typedef int	mp_err
typedef int	ltm_prime_callback(unsigned char *dst, int len, void *dat)
typedef struct Rsa_key	rsa_key

Enumerations
enum	{   CRYPT_OK =0 , CRYPT_ERROR , CRYPT_NOP , CRYPT_INVALID_KEYSIZE ,   CRYPT_INVALID_ROUNDS , CRYPT_FAIL_TESTVECTOR , CRYPT_BUFFER_OVERFLOW , CRYPT_INVALID_PACKET ,   CRYPT_INVALID_PRNGSIZE , CRYPT_ERROR_READPRNG , CRYPT_INVALID_CIPHER , CRYPT_INVALID_HASH ,   CRYPT_INVALID_PRNG , CRYPT_MEM , CRYPT_PK_TYPE_MISMATCH , CRYPT_PK_NOT_PRIVATE ,   CRYPT_INVALID_ARG , CRYPT_FILE_NOTFOUND , CRYPT_PK_INVALID_TYPE , CRYPT_PK_INVALID_SYSTEM ,   CRYPT_PK_DUP , CRYPT_PK_NOT_FOUND , CRYPT_PK_INVALID_SIZE , CRYPT_INVALID_PRIME_SIZE }

Functions
int	rc2_setup (const unsigned char *key, int keylen, int bits, int num_rounds, rc2_key *skey)
void	rc2_ecb_encrypt (const unsigned char *pt, unsigned char *ct, rc2_key *key)
void	rc2_ecb_decrypt (const unsigned char *ct, unsigned char *pt, rc2_key *key)
int	des_setup (const unsigned char *key, int keylen, int num_rounds, des_key *skey)
void	des_ecb_encrypt (const unsigned char *pt, unsigned char *ct, const des_key *key)
void	des_ecb_decrypt (const unsigned char *ct, unsigned char *pt, const des_key *key)
int	des3_setup (const unsigned char *key, int keylen, int num_rounds, des3_key *skey)
void	des3_ecb_encrypt (const unsigned char *pt, unsigned char *ct, const des3_key *key)
void	des3_ecb_decrypt (const unsigned char *ct, unsigned char *pt, const des3_key *key)
int	aes_setup (const unsigned char *key, int keylen, int rounds, aes_key *skey)
void	aes_ecb_encrypt (const unsigned char *pt, unsigned char *ct, aes_key *skey)
void	aes_ecb_decrypt (const unsigned char *ct, unsigned char *pt, aes_key *skey)
int	md2_init (md2_state *md)
int	md2_process (md2_state *md, const unsigned char *buf, unsigned long len)
int	md2_done (md2_state *md, unsigned char *hash)
int	rc4_start (prng_state *prng)
int	rc4_add_entropy (const unsigned char *buf, unsigned long len, prng_state *prng)
int	rc4_ready (prng_state *prng)
unsigned long	rc4_read (unsigned char *buf, unsigned long len, prng_state *prng)
char *	mp_error_to_string (int code)
int	mp_init_multi (mp_int *mp,...)
void	mp_clear_multi (mp_int *mp,...)
int	mp_shrink (mp_int *a)
int	mp_set_int (mp_int *a, unsigned long b)
unsigned long	mp_get_int (const mp_int *a)
int	mp_init_set (mp_int *a, mp_digit b)
int	mp_init_set_int (mp_int *a, unsigned long b)
int	mp_copy (const mp_int *a, mp_int *b)
int	mp_init_copy (mp_int *a, const mp_int *b)
int	mp_rand (mp_int *a, int digits)
int	mp_xor (mp_int *a, mp_int *b, mp_int *c)
int	mp_or (mp_int *a, mp_int *b, mp_int *c)
int	mp_and (mp_int *a, mp_int *b, mp_int *c)
int	mp_neg (mp_int *a, mp_int *b)
int	mp_cmp (const mp_int *a, const mp_int *b)
int	mp_add (mp_int *a, mp_int *b, mp_int *c)
int	mp_sub (mp_int *a, mp_int *b, mp_int *c)
int	mp_mul (const mp_int *a, const mp_int *b, mp_int *c)
int	mp_mod (const mp_int *a, mp_int *b, mp_int *c)
int	mp_cmp_d (const mp_int *a, mp_digit b)
int	mp_sub_d (mp_int *a, mp_digit b, mp_int *c)
int	mp_div_3 (mp_int *a, mp_int *c, mp_digit *d)
int	mp_expt_d (mp_int *a, mp_digit b, mp_int *c)
int	mp_addmod (mp_int *a, mp_int *b, mp_int *c, mp_int *d)
int	mp_submod (mp_int *a, mp_int *b, mp_int *c, mp_int *d)
int	mp_mulmod (const mp_int *a, const mp_int *b, mp_int *c, mp_int *d)
int	mp_invmod (const mp_int *a, mp_int *b, mp_int *c)
int	mp_gcd (const mp_int *a, const mp_int *b, mp_int *c)
int	mp_exteuclid (mp_int *a, mp_int *b, mp_int *U1, mp_int *U2, mp_int *U3)
int	mp_lcm (const mp_int *a, const mp_int *b, mp_int *c)
int	mp_n_root (mp_int *a, mp_digit b, mp_int *c)
int	mp_sqrt (mp_int *arg, mp_int *ret)
int	mp_is_square (mp_int *arg, int *ret)
int	mp_jacobi (mp_int *a, mp_int *n, int *c)
int	mp_dr_is_modulus (mp_int *a)
int	mp_reduce_is_2k (mp_int *a)
int	mp_exptmod (const mp_int *a, const mp_int *b, mp_int *c, mp_int *d)
int	mp_prime_fermat (mp_int *a, mp_int *b, int *result)
int	mp_prime_rabin_miller_trials (int size)
int	mp_prime_next_prime (mp_int *a, int t, int bbs_style)
int	mp_prime_random_ex (mp_int *a, int t, int size, int flags, ltm_prime_callback cb, void *dat)
int	mp_count_bits (const mp_int *a)
int	mp_unsigned_bin_size (const mp_int *a)
int	mp_read_unsigned_bin (mp_int *a, const unsigned char *b, int c)
int	mp_to_unsigned_bin (const mp_int *a, unsigned char *b)
int	mp_read_signed_bin (mp_int *a, unsigned char *b, int c)
int	mp_to_signed_bin (mp_int *a, unsigned char *b)
int	mp_read_radix (mp_int *a, char *str, int radix)
int	mp_toradix (mp_int *a, char *str, int radix)
int	mp_toradix_n (mp_int *a, char *str, int radix, int maxlen)
int	mp_radix_size (mp_int *a, int radix, int *size)
int	mp_fread (mp_int *a, int radix, FILE *stream)
int	mp_fwrite (mp_int *a, int radix, FILE *stream)
int	rsa_make_key (int size, long e, rsa_key *key)
int	rsa_exptmod (const unsigned char *in, unsigned long inlen, unsigned char *out, unsigned long *outlen, int which, rsa_key *key)
void	rsa_free (rsa_key *key)

Variables
const char *	mp_s_rmap

Macro Definition Documentation

byte

#define byte	(		x,
			n
	)		(((x) >> (8 * (n))) & 255)

Definition at line 118 of file tomcrypt.h.

CONST64

#define CONST64	(		a,
			b
	)		((((ULONG64)(a)) << 32) | (b))

Definition at line 78 of file tomcrypt.h.

DIGIT

#define DIGIT	(		m,
			k
	)		((m)->dp[(k)])

Definition at line 233 of file tomcrypt.h.

DIGIT_BIT

#define DIGIT_BIT   28

Definition at line 186 of file tomcrypt.h.

LOAD32H

#define LOAD32H	(		x,
			y
	)

Value:

     { x = ((unsigned long)((y)[0] & 255)<<24) | \
           ((unsigned long)((y)[1] & 255)<<16) | \
           ((unsigned long)((y)[2] & 255)<<8)  | \
           ((unsigned long)((y)[3] & 255)); }

Definition at line 91 of file tomcrypt.h.

LTM_PRIME_2MSB_OFF

#define LTM_PRIME_2MSB_OFF   0x0004 /* force 2nd MSB to 0 */

Definition at line 211 of file tomcrypt.h.

LTM_PRIME_2MSB_ON

#define LTM_PRIME_2MSB_ON   0x0008 /* force 2nd MSB to 1 */

Definition at line 212 of file tomcrypt.h.

LTM_PRIME_BBS

#define LTM_PRIME_BBS   0x0001 /* BBS style prime */

Definition at line 209 of file tomcrypt.h.

LTM_PRIME_SAFE

#define LTM_PRIME_SAFE   0x0002 /* Safe prime (p-1)/2 == prime */

Definition at line 210 of file tomcrypt.h.

MAX_RSA_SIZE

#define MAX_RSA_SIZE   16384

Definition at line 454 of file tomcrypt.h.

MIN

#define MIN	(		x,
			y
	)		( ((x)<(y))?(x):(y) )

Definition at line 116 of file tomcrypt.h.

MIN_RSA_SIZE

#define MIN_RSA_SIZE   384

Definition at line 453 of file tomcrypt.h.

MP_DIGIT_BIT

#define MP_DIGIT_BIT   DIGIT_BIT

Definition at line 188 of file tomcrypt.h.

MP_DIGIT_MAX

#define MP_DIGIT_MAX   MP_MASK

Definition at line 190 of file tomcrypt.h.

MP_EQ

#define MP_EQ   0 /* equal to */

Definition at line 194 of file tomcrypt.h.

MP_GT

#define MP_GT   1 /* greater than */

Definition at line 195 of file tomcrypt.h.

mp_iseven

#define mp_iseven

(

a

)

(((a)->used > 0 && (((a)->dp[0] & 1) == 0)) ? MP_YES : MP_NO)

Definition at line 249 of file tomcrypt.h.

mp_isodd

#define mp_isodd

(

a

)

(((a)->used > 0 && (((a)->dp[0] & 1) == 1)) ? MP_YES : MP_NO)

Definition at line 250 of file tomcrypt.h.

mp_iszero

#define mp_iszero

(

a

)

(((a)->used == 0) ? MP_YES : MP_NO)

Definition at line 248 of file tomcrypt.h.

MP_LT

#define MP_LT   -1 /* less than */

Definition at line 193 of file tomcrypt.h.

mp_mag_size

#define mp_mag_size

(

mp

)

mp_unsigned_bin_size(mp)

Definition at line 439 of file tomcrypt.h.

MP_MASK

#define MP_MASK   ((((mp_digit)1)<<((mp_digit)DIGIT_BIT))-((mp_digit)1))

Definition at line 189 of file tomcrypt.h.

MP_MEM

#define MP_MEM   -2 /* out of mem */

Definition at line 201 of file tomcrypt.h.

MP_NEG

#define MP_NEG   1 /* negative */

Definition at line 198 of file tomcrypt.h.

MP_NO

#define MP_NO   0 /* no response */

Definition at line 206 of file tomcrypt.h.

MP_OKAY

#define MP_OKAY   0 /* ok result */

Definition at line 200 of file tomcrypt.h.

MP_PREC

#define MP_PREC   64 /* default digits of precision */

Definition at line 219 of file tomcrypt.h.

mp_prime_random

#define mp_prime_random	(		a,
			t,
			size,
			bbs,
			cb,
			dat
	)		mp_prime_random_ex(a, t, ((size) * 8) + 1, (bbs==1)?LTM_PRIME_BBS:0, cb, dat)

Definition at line 399 of file tomcrypt.h.

MP_RANGE

#define MP_RANGE   MP_VAL

Definition at line 203 of file tomcrypt.h.

mp_raw_size

#define mp_raw_size

(

mp

)

mp_signed_bin_size(mp)

Definition at line 436 of file tomcrypt.h.

mp_read_mag

#define mp_read_mag	(		mp,
			str,
			len
	)		mp_read_unsigned_bin((mp), (str), (len))

Definition at line 438 of file tomcrypt.h.

mp_read_raw

#define mp_read_raw	(		mp,
			str,
			len
	)		mp_read_signed_bin((mp), (str), (len))

Definition at line 435 of file tomcrypt.h.

mp_tobinary

#define mp_tobinary	(		M,
			S
	)		mp_toradix((M), (S), 2)

Definition at line 442 of file tomcrypt.h.

mp_todecimal

#define mp_todecimal	(		M,
			S
	)		mp_toradix((M), (S), 10)

Definition at line 444 of file tomcrypt.h.

mp_tohex

#define mp_tohex	(		M,
			S
	)		mp_toradix((M), (S), 16)

Definition at line 445 of file tomcrypt.h.

mp_tomag

#define mp_tomag	(		mp,
			str
	)		mp_to_unsigned_bin((mp), (str))

Definition at line 440 of file tomcrypt.h.

mp_tooctal

#define mp_tooctal	(		M,
			S
	)		mp_toradix((M), (S), 8)

Definition at line 443 of file tomcrypt.h.

mp_toraw

#define mp_toraw	(		mp,
			str
	)		mp_to_signed_bin((mp), (str))

Definition at line 437 of file tomcrypt.h.

MP_VAL

#define MP_VAL   -3 /* invalid input */

Definition at line 202 of file tomcrypt.h.

MP_WARRAY

#define MP_WARRAY   (1 << (sizeof(mp_word) * CHAR_BIT - 2 * DIGIT_BIT + 1))

Definition at line 222 of file tomcrypt.h.

MP_YES

#define MP_YES   1 /* yes response */

Definition at line 205 of file tomcrypt.h.

MP_ZPOS

#define MP_ZPOS   0 /* positive integer */

Definition at line 197 of file tomcrypt.h.

PK_PRIVATE

#define PK_PRIVATE   0 /* PK private keys */

Definition at line 449 of file tomcrypt.h.

PK_PUBLIC

#define PK_PUBLIC   1 /* PK public keys */

Definition at line 450 of file tomcrypt.h.

PRIME_SIZE

#define PRIME_SIZE   256

Definition at line 371 of file tomcrypt.h.

ROR

#define ROR	(		x,
			y
	)

Value:

                    ( ((((unsigned long)(x)&0xFFFFFFFFUL)>>(unsigned long)((y)&31)) | \
                    ((unsigned long)(x)<<(unsigned long)(32-((y)&31)))) & 0xFFFFFFFFUL)

Definition at line 110 of file tomcrypt.h.

STORE32H

#define STORE32H	(		x,
			y
	)

Value:

     { (y)[0] = (unsigned char)(((x)>>24)&255); (y)[1] = (unsigned char)(((x)>>16)&255);   \
       (y)[2] = (unsigned char)(((x)>>8)&255); (y)[3] = (unsigned char)((x)&255); }

Definition at line 87 of file tomcrypt.h.

Typedef Documentation

aes_key

typedef struct tag_aes_key aes_key

des3_key

typedef struct tag_des3_key des3_key

des_key

typedef struct tag_des_key des_key

ltm_prime_callback

typedef int ltm_prime_callback(unsigned char *dst, int len, void *dat)

Definition at line 231 of file tomcrypt.h.

md2_state

typedef struct tag_md2_state md2_state

mp_digit

typedef unsigned long mp_digit

Definition at line 184 of file tomcrypt.h.

mp_err

typedef int mp_err

Definition at line 214 of file tomcrypt.h.

mp_word

typedef ulong64 mp_word

Definition at line 185 of file tomcrypt.h.

prng_state

typedef union Prng_state prng_state

rc2_key

typedef struct tag_rc2_key rc2_key

rsa_key

typedef struct Rsa_key rsa_key

ulong32

typedef ULONG32 ulong32

Definition at line 84 of file tomcrypt.h.

ulong64

typedef ULONG64 ulong64

Definition at line 79 of file tomcrypt.h.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
CRYPT_OK
CRYPT_ERROR
CRYPT_NOP
CRYPT_INVALID_KEYSIZE
CRYPT_INVALID_ROUNDS
CRYPT_FAIL_TESTVECTOR
CRYPT_BUFFER_OVERFLOW
CRYPT_INVALID_PACKET
CRYPT_INVALID_PRNGSIZE
CRYPT_ERROR_READPRNG
CRYPT_INVALID_CIPHER
CRYPT_INVALID_HASH
CRYPT_INVALID_PRNG
CRYPT_MEM
CRYPT_PK_TYPE_MISMATCH
CRYPT_PK_NOT_PRIVATE
CRYPT_INVALID_ARG
CRYPT_FILE_NOTFOUND
CRYPT_PK_INVALID_TYPE
CRYPT_PK_INVALID_SYSTEM
CRYPT_PK_DUP
CRYPT_PK_NOT_FOUND
CRYPT_PK_INVALID_SIZE
CRYPT_INVALID_PRIME_SIZE

Definition at line 42 of file tomcrypt.h.

     {
   CRYPT_OK=0,             /* Result OK */
   CRYPT_ERROR,            /* Generic Error */
   CRYPT_NOP,              /* Not a failure but no operation was performed */
 
   CRYPT_INVALID_KEYSIZE,  /* Invalid key size given */
   CRYPT_INVALID_ROUNDS,   /* Invalid number of rounds */
   CRYPT_FAIL_TESTVECTOR,  /* Algorithm failed test vectors */
 
   CRYPT_BUFFER_OVERFLOW,  /* Not enough space for output */
   CRYPT_INVALID_PACKET,   /* Invalid input packet given */
 
   CRYPT_INVALID_PRNGSIZE, /* Invalid number of bits for a PRNG */
   CRYPT_ERROR_READPRNG,   /* Could not read enough from PRNG */
 
   CRYPT_INVALID_CIPHER,   /* Invalid cipher specified */
   CRYPT_INVALID_HASH,     /* Invalid hash specified */
   CRYPT_INVALID_PRNG,     /* Invalid PRNG specified */
 
   CRYPT_MEM,              /* Out of memory */
 
   CRYPT_PK_TYPE_MISMATCH, /* Not equivalent types of PK keys */
   CRYPT_PK_NOT_PRIVATE,   /* Requires a private PK key */
 
   CRYPT_INVALID_ARG,      /* Generic invalid argument */
   CRYPT_FILE_NOTFOUND,    /* File Not Found */
 
   CRYPT_PK_INVALID_TYPE,  /* Invalid type of PK key */
   CRYPT_PK_INVALID_SYSTEM,/* Invalid PK system specified */
   CRYPT_PK_DUP,           /* Duplicate key already in key ring */
   CRYPT_PK_NOT_FOUND,     /* Key not found in keyring */
   CRYPT_PK_INVALID_SIZE,  /* Invalid size input for PK parameters */
 
   CRYPT_INVALID_PRIME_SIZE/* Invalid size of prime requested */
};

Function Documentation

aes_ecb_decrypt()

void aes_ecb_decrypt	(	const unsigned char *	ct,
		unsigned char *	pt,
		aes_key *	skey
	)

Definition at line 1165 of file aes.c.

{
    ulong32 s0, s1, s2, s3, t0, t1, t2, t3, *rk;
    int Nr, r;
 
    Nr = skey->Nr;
    rk = skey->dK;
 
    LOAD32H(s0, ct      ); s0 ^= rk[0];
    LOAD32H(s1, ct  +  4); s1 ^= rk[1];
    LOAD32H(s2, ct  +  8); s2 ^= rk[2];
    LOAD32H(s3, ct  + 12); s3 ^= rk[3];
 
    r = Nr >> 1;
    for (;;) {
 
        t0 =
            Td0(byte(s0, 3)) ^
            Td1(byte(s3, 2)) ^
            Td2(byte(s2, 1)) ^
            Td3(byte(s1, 0)) ^
            rk[4];
        t1 =
            Td0(byte(s1, 3)) ^
            Td1(byte(s0, 2)) ^
            Td2(byte(s3, 1)) ^
            Td3(byte(s2, 0)) ^
            rk[5];
        t2 =
            Td0(byte(s2, 3)) ^
            Td1(byte(s1, 2)) ^
            Td2(byte(s0, 1)) ^
            Td3(byte(s3, 0)) ^
            rk[6];
        t3 =
            Td0(byte(s3, 3)) ^
            Td1(byte(s2, 2)) ^
            Td2(byte(s1, 1)) ^
            Td3(byte(s0, 0)) ^
            rk[7];
 
        rk += 8;
        if (--r == 0) {
            break;
        }
 
 
        s0 =
            Td0(byte(t0, 3)) ^
            Td1(byte(t3, 2)) ^
            Td2(byte(t2, 1)) ^
            Td3(byte(t1, 0)) ^
            rk[0];
        s1 =
            Td0(byte(t1, 3)) ^
            Td1(byte(t0, 2)) ^
            Td2(byte(t3, 1)) ^
            Td3(byte(t2, 0)) ^
            rk[1];
        s2 =
            Td0(byte(t2, 3)) ^
            Td1(byte(t1, 2)) ^
            Td2(byte(t0, 1)) ^
            Td3(byte(t3, 0)) ^
            rk[2];
        s3 =
            Td0(byte(t3, 3)) ^
            Td1(byte(t2, 2)) ^
            Td2(byte(t1, 1)) ^
            Td3(byte(t0, 0)) ^
            rk[3];
    }
 
    s0 =
        (Td4[byte(t0, 3)] & 0xff000000) ^
        (Td4[byte(t3, 2)] & 0x00ff0000) ^
        (Td4[byte(t2, 1)] & 0x0000ff00) ^
        (Td4[byte(t1, 0)] & 0x000000ff) ^
        rk[0];
    STORE32H(s0, pt);
    s1 =
        (Td4[byte(t1, 3)] & 0xff000000) ^
        (Td4[byte(t0, 2)] & 0x00ff0000) ^
        (Td4[byte(t3, 1)] & 0x0000ff00) ^
        (Td4[byte(t2, 0)] & 0x000000ff) ^
        rk[1];
    STORE32H(s1, pt+4);
    s2 =
        (Td4[byte(t2, 3)] & 0xff000000) ^
        (Td4[byte(t1, 2)] & 0x00ff0000) ^
        (Td4[byte(t0, 1)] & 0x0000ff00) ^
        (Td4[byte(t3, 0)] & 0x000000ff) ^
        rk[2];
    STORE32H(s2, pt+8);
    s3 =
        (Td4[byte(t3, 3)] & 0xff000000) ^
        (Td4[byte(t2, 2)] & 0x00ff0000) ^
        (Td4[byte(t1, 1)] & 0x0000ff00) ^
        (Td4[byte(t0, 0)] & 0x000000ff) ^
        rk[3];
    STORE32H(s3, pt+12);
}

aes_ecb_encrypt()

void aes_ecb_encrypt	(	const unsigned char *	pt,
		unsigned char *	ct,
		aes_key *	skey
	)

Definition at line 1064 of file aes.c.

{
    ulong32 s0, s1, s2, s3, t0, t1, t2, t3, *rk;
    int Nr, r;
 
    Nr = skey->Nr;
    rk = skey->eK;
 
    LOAD32H(s0, pt      ); s0 ^= rk[0];
    LOAD32H(s1, pt  +  4); s1 ^= rk[1];
    LOAD32H(s2, pt  +  8); s2 ^= rk[2];
    LOAD32H(s3, pt  + 12); s3 ^= rk[3];
 
    r = Nr >> 1;
    for (;;) {
        t0 =
            Te0(byte(s0, 3)) ^
            Te1(byte(s1, 2)) ^
            Te2(byte(s2, 1)) ^
            Te3(byte(s3, 0)) ^
            rk[4];
        t1 =
            Te0(byte(s1, 3)) ^
            Te1(byte(s2, 2)) ^
            Te2(byte(s3, 1)) ^
            Te3(byte(s0, 0)) ^
            rk[5];
        t2 =
            Te0(byte(s2, 3)) ^
            Te1(byte(s3, 2)) ^
            Te2(byte(s0, 1)) ^
            Te3(byte(s1, 0)) ^
            rk[6];
        t3 =
            Te0(byte(s3, 3)) ^
            Te1(byte(s0, 2)) ^
            Te2(byte(s1, 1)) ^
            Te3(byte(s2, 0)) ^
            rk[7];
 
        rk += 8;
        if (--r == 0) {
            break;
        }
 
        s0 =
            Te0(byte(t0, 3)) ^
            Te1(byte(t1, 2)) ^
            Te2(byte(t2, 1)) ^
            Te3(byte(t3, 0)) ^
            rk[0];
        s1 =
            Te0(byte(t1, 3)) ^
            Te1(byte(t2, 2)) ^
            Te2(byte(t3, 1)) ^
            Te3(byte(t0, 0)) ^
            rk[1];
        s2 =
            Te0(byte(t2, 3)) ^
            Te1(byte(t3, 2)) ^
            Te2(byte(t0, 1)) ^
            Te3(byte(t1, 0)) ^
            rk[2];
        s3 =
            Te0(byte(t3, 3)) ^
            Te1(byte(t0, 2)) ^
            Te2(byte(t1, 1)) ^
            Te3(byte(t2, 0)) ^
            rk[3];
    }
 
    s0 =
        (Te4_3[byte(t0, 3)]) ^
        (Te4_2[byte(t1, 2)]) ^
        (Te4_1[byte(t2, 1)]) ^
        (Te4_0[byte(t3, 0)]) ^
        rk[0];
    STORE32H(s0, ct);
    s1 =
        (Te4_3[byte(t1, 3)]) ^
        (Te4_2[byte(t2, 2)]) ^
        (Te4_1[byte(t3, 1)]) ^
        (Te4_0[byte(t0, 0)]) ^
        rk[1];
    STORE32H(s1, ct+4);
    s2 =
        (Te4_3[byte(t2, 3)]) ^
        (Te4_2[byte(t3, 2)]) ^
        (Te4_1[byte(t0, 1)]) ^
        (Te4_0[byte(t1, 0)]) ^
        rk[2];
    STORE32H(s2, ct+8);
    s3 =
        (Te4_3[byte(t3, 3)]) ^
        (Te4_2[byte(t0, 2)]) ^
        (Te4_1[byte(t1, 1)]) ^
        (Te4_0[byte(t2, 0)]) ^
        rk[3];
    STORE32H(s3, ct+12);
}

aes_setup()

int aes_setup	(	const unsigned char *	key,
		int	keylen,
		int	rounds,
		aes_key *	skey
	)

Definition at line 937 of file aes.c.

{
    int i, j;
    ulong32 temp, *rk;
    ulong32 *rrk;
 
    if (keylen != 16 && keylen != 24 && keylen != 32) {
       return CRYPT_INVALID_KEYSIZE;
    }
 
    if (rounds != 0 && rounds != (10 + ((keylen/8)-2)*2)) {
       return CRYPT_INVALID_ROUNDS;
    }
 
    skey->Nr = 10 + ((keylen/8)-2)*2;
 
    /* setup the forward key */
    i                 = 0;
    rk                = skey->eK;
    LOAD32H(rk[0], key     );
    LOAD32H(rk[1], key +  4);
    LOAD32H(rk[2], key +  8);
    LOAD32H(rk[3], key + 12);
    if (keylen == 16) {
        j = 44;
        for (;;) {
            temp  = rk[3];
            rk[4] = rk[0] ^ setup_mix(temp) ^ rcon[i];
            rk[5] = rk[1] ^ rk[4];
            rk[6] = rk[2] ^ rk[5];
            rk[7] = rk[3] ^ rk[6];
            if (++i == 10) {
               break;
            }
            rk += 4;
        }
    } else if (keylen == 24) {
        j = 52;
        LOAD32H(rk[4], key + 16);
        LOAD32H(rk[5], key + 20);
        for (;;) {
            temp = rk[5];
            rk[ 6] = rk[ 0] ^ setup_mix(temp) ^ rcon[i];
            rk[ 7] = rk[ 1] ^ rk[ 6];
            rk[ 8] = rk[ 2] ^ rk[ 7];
            rk[ 9] = rk[ 3] ^ rk[ 8];
            if (++i == 8) {
                break;
            }
            rk[10] = rk[ 4] ^ rk[ 9];
            rk[11] = rk[ 5] ^ rk[10];
            rk += 6;
        }
    } else if (keylen == 32) {
        j = 60;
        LOAD32H(rk[4], key + 16);
        LOAD32H(rk[5], key + 20);
        LOAD32H(rk[6], key + 24);
        LOAD32H(rk[7], key + 28);
        for (;;) {
            temp = rk[7];
            rk[ 8] = rk[ 0] ^ setup_mix(temp) ^ rcon[i];
            rk[ 9] = rk[ 1] ^ rk[ 8];
            rk[10] = rk[ 2] ^ rk[ 9];
            rk[11] = rk[ 3] ^ rk[10];
            if (++i == 7) {
                break;
            }
            temp = rk[11];
            rk[12] = rk[ 4] ^ setup_mix(ROR(temp, 8));
            rk[13] = rk[ 5] ^ rk[12];
            rk[14] = rk[ 6] ^ rk[13];
            rk[15] = rk[ 7] ^ rk[14];
            rk += 8;
        }
    } else {
       j = 4;
    }
 
    rk   = skey->dK;
    rrk  = skey->eK + j - 4;
 
    *rk++ = *rrk++;
    *rk++ = *rrk++;
    *rk++ = *rrk++;
    *rk   = *rrk;
    rk -= 3; rrk -= 3;
 
    for (i = 1; i < skey->Nr; i++) {
        rrk -= 4;
        rk  += 4;
        temp = rrk[0];
        rk[0] =
            Tks0[byte(temp, 3)] ^
            Tks1[byte(temp, 2)] ^
            Tks2[byte(temp, 1)] ^
            Tks3[byte(temp, 0)];
        temp = rrk[1];
        rk[1] =
            Tks0[byte(temp, 3)] ^
            Tks1[byte(temp, 2)] ^
            Tks2[byte(temp, 1)] ^
            Tks3[byte(temp, 0)];
        temp = rrk[2];
        rk[2] =
            Tks0[byte(temp, 3)] ^
            Tks1[byte(temp, 2)] ^
            Tks2[byte(temp, 1)] ^
            Tks3[byte(temp, 0)];
        temp = rrk[3];
        rk[3] =
            Tks0[byte(temp, 3)] ^
            Tks1[byte(temp, 2)] ^
            Tks2[byte(temp, 1)] ^
            Tks3[byte(temp, 0)];
    }
 
    rrk -= 4;
    rk  += 4;
    *rk++ = *rrk++;
    *rk++ = *rrk++;
    *rk++ = *rrk++;
    *rk   = *rrk;
 
    return CRYPT_OK;
}

des3_ecb_decrypt()

void des3_ecb_decrypt	(	const unsigned char *	ct,
		unsigned char *	pt,
		const des3_key *	key
	)

Definition at line 1485 of file des.c.

{
    ulong32 work[2];
    LOAD32H(work[0], ct+0);
    LOAD32H(work[1], ct+4);
    desfunc(work, des3->dk[0]);
    desfunc(work, des3->dk[1]);
    desfunc(work, des3->dk[2]);
    STORE32H(work[0],pt+0);
    STORE32H(work[1],pt+4);
}

des3_ecb_encrypt()

void des3_ecb_encrypt	(	const unsigned char *	pt,
		unsigned char *	ct,
		const des3_key *	key
	)

Definition at line 1473 of file des.c.

{
    ulong32 work[2];
    LOAD32H(work[0], pt+0);
    LOAD32H(work[1], pt+4);
    desfunc(work, des3->ek[0]);
    desfunc(work, des3->ek[1]);
    desfunc(work, des3->ek[2]);
    STORE32H(work[0],ct+0);
    STORE32H(work[1],ct+4);
}

des3_setup()

int des3_setup	(	const unsigned char *	key,
		int	keylen,
		int	num_rounds,
		des3_key *	skey
	)

Definition at line 1432 of file des.c.

{
    if(num_rounds != 0 && num_rounds != 16) {
        return CRYPT_INVALID_ROUNDS;
    }
 
    if (keylen != 24) {
        return CRYPT_INVALID_KEYSIZE;
    }
 
    deskey(key,    EN0, des3->ek[0]);
    deskey(key+8,  DE1, des3->ek[1]);
    deskey(key+16, EN0, des3->ek[2]);
 
    deskey(key,    DE1, des3->dk[2]);
    deskey(key+8,  EN0, des3->dk[1]);
    deskey(key+16, DE1, des3->dk[0]);
 
    return CRYPT_OK;
}

des_ecb_decrypt()

void des_ecb_decrypt	(	const unsigned char *	ct,
		unsigned char *	pt,
		const des_key *	key
	)

Definition at line 1463 of file des.c.

{
    ulong32 work[2];
    LOAD32H(work[0], ct+0);
    LOAD32H(work[1], ct+4);
    desfunc(work, des->dk);
    STORE32H(work[0],pt+0);
    STORE32H(work[1],pt+4);
}

des_ecb_encrypt()

void des_ecb_encrypt	(	const unsigned char *	pt,
		unsigned char *	ct,
		const des_key *	key
	)

Definition at line 1453 of file des.c.

{
    ulong32 work[2];
    LOAD32H(work[0], pt+0);
    LOAD32H(work[1], pt+4);
    desfunc(work, des->ek);
    STORE32H(work[0],ct+0);
    STORE32H(work[1],ct+4);
}

des_setup()

int des_setup	(	const unsigned char *	key,
		int	keylen,
		int	num_rounds,
		des_key *	skey
	)

Definition at line 1416 of file des.c.

{
    if (num_rounds != 0 && num_rounds != 16) {
        return CRYPT_INVALID_ROUNDS;
    }
 
    if (keylen != 8) {
        return CRYPT_INVALID_KEYSIZE;
    }
 
    deskey(key, EN0, des->ek);
    deskey(key, DE1, des->dk);
 
    return CRYPT_OK;
}

md2_done()

int md2_done	(	md2_state *	md,
		unsigned char *	hash
	)

Definition at line 125 of file md2.c.

{
    unsigned long i, k;
 
    if (md2->curlen >= sizeof(md2->buf)) {
       return CRYPT_INVALID_ARG;
    }
 
    /* pad the message */
    k = 16 - md2->curlen;
    for (i = md2->curlen; i < 16; i++) {
        md2->buf[i] = (unsigned char)k;
    }
 
    /* hash and update */
    md2_compress(md2);
    md2_update_chksum(md2);
 
    /* hash checksum */
    memcpy(md2->buf, md2->chksum, 16);
    md2_compress(md2);
 
    /* output is lower 16 bytes of X */
    memcpy(hash, md2->X, 16);
 
    return CRYPT_OK;
}

md2_init()

int md2_init

(

md2_state *

md

)

Definition at line 91 of file md2.c.

{
   /* MD2 uses a zero'ed state... */
   memset(md2->X, 0, sizeof(md2->X));
   memset(md2->chksum, 0, sizeof(md2->chksum));
   memset(md2->buf, 0, sizeof(md2->buf));
   md2->curlen = 0;
   return CRYPT_OK;
}

md2_process()

int md2_process	(	md2_state *	md,
		const unsigned char *	buf,
		unsigned long	len
	)

Definition at line 101 of file md2.c.

{
    unsigned long n;
    
    if (md2->curlen > sizeof(md2->buf)) {                            
       return CRYPT_INVALID_ARG;                                                           
    }                                                                                       
    while (len > 0) {
        n = MIN(len, (16 - md2->curlen));
        memcpy(md2->buf + md2->curlen, buf, (size_t)n);
        md2->curlen += n;
        buf         += n;
        len         -= n;
 
        /* is 16 bytes full? */
        if (md2->curlen == 16) {
            md2_compress(md2);
            md2_update_chksum(md2);
            md2->curlen = 0;
        }
    }
    return CRYPT_OK;
}

mp_add()

int mp_add	(	mp_int *	a,
		mp_int *	b,
		mp_int *	c
	)

Definition at line 891 of file mpi.c.

{
  int     sa, sb, res;
 
  /* get sign of both inputs */
  sa = a->sign;
  sb = b->sign;
 
  /* handle two cases, not four */
  if (sa == sb) {
    /* both positive or both negative */
    /* add their magnitudes, copy the sign */
    c->sign = sa;
    res = s_mp_add (a, b, c);
  } else {
    /* one positive, the other negative */
    /* subtract the one with the greater magnitude from */
    /* the one of the lesser magnitude.  The result gets */
    /* the sign of the one with the greater magnitude. */
    if (mp_cmp_mag (a, b) == MP_LT) {
      c->sign = sb;
      res = s_mp_sub (b, a, c);
    } else {
      c->sign = sa;
      res = s_mp_sub (a, b, c);
    }
  }
  return res;
}

mp_addmod()

int mp_addmod	(	mp_int *	a,
		mp_int *	b,
		mp_int *	c,
		mp_int *	d
	)

mp_and()

int mp_and	(	mp_int *	a,
		mp_int *	b,
		mp_int *	c
	)

mp_clear_multi()

void mp_clear_multi	(	mp_int *	mp,
			...
	)

Definition at line 1032 of file mpi.c.

{
    mp_int* next_mp = mp;
    va_list args;
    va_start(args, mp);
    while (next_mp != NULL) {
        mp_clear(next_mp);
        next_mp = va_arg(args, mp_int*);
    }
    va_end(args);
}

mp_cmp()

int mp_cmp	(	const mp_int *	a,
		const mp_int *	b
	)

Definition at line 1046 of file mpi.c.

{
  /* compare based on sign */
  if (a->sign != b->sign) {
     if (a->sign == MP_NEG) {
        return MP_LT;
     } else {
        return MP_GT;
     }
  }
  
  /* compare digits */
  if (a->sign == MP_NEG) {
     /* if negative compare opposite direction */
     return mp_cmp_mag(b, a);
  } else {
     return mp_cmp_mag(a, b);
  }
}

mp_cmp_d()

int mp_cmp_d	(	const mp_int *	a,
		mp_digit	b
	)

Definition at line 1067 of file mpi.c.

{
  /* compare based on sign */
  if (a->sign == MP_NEG) {
    return MP_LT;
  }
 
  /* compare based on magnitude */
  if (a->used > 1) {
    return MP_GT;
  }
 
  /* compare the only digit of a to b */
  if (a->dp[0] > b) {
    return MP_GT;
  } else if (a->dp[0] < b) {
    return MP_LT;
  } else {
    return MP_EQ;
  }
}

mp_copy()

int mp_copy	(	const mp_int *	a,
		mp_int *	b
	)

Definition at line 1156 of file mpi.c.

{
  int     res, n;
 
  /* if dst == src do nothing */
  if (a == b) {
    return MP_OKAY;
  }
 
  /* grow dest */
  if (b->alloc < a->used) {
     if ((res = mp_grow (b, a->used)) != MP_OKAY) {
        return res;
     }
  }
 
  /* zero b and copy the parameters over */
  {
    register mp_digit *tmpa, *tmpb;
 
    /* pointer aliases */
 
    /* source */
    tmpa = a->dp;
 
    /* destination */
    tmpb = b->dp;
 
    /* copy all the digits */
    for (n = 0; n < a->used; n++) {
      *tmpb++ = *tmpa++;
    }
 
    /* clear high digits */
    for (; n < b->used; n++) {
      *tmpb++ = 0;
    }
  }
 
  /* copy used count and sign */
  b->used = a->used;
  b->sign = a->sign;
  return MP_OKAY;
}

mp_count_bits()

int mp_count_bits

(

const mp_int *

a

)

Definition at line 1203 of file mpi.c.

{
  int     r;
  mp_digit q;
 
  /* shortcut */
  if (a->used == 0) {
    return 0;
  }
 
  /* get number of digits and add that */
  r = (a->used - 1) * DIGIT_BIT;
  
  /* take the last digit and count the bits in it */
  q = a->dp[a->used - 1];
  while (q > 0) {
    ++r;
    q >>= ((mp_digit) 1);
  }
  return r;
}

mp_div_3()

int mp_div_3	(	mp_int *	a,
		mp_int *	c,
		mp_digit *	d
	)

mp_dr_is_modulus()

int mp_dr_is_modulus

(

mp_int *

a

)

mp_error_to_string()

char * mp_error_to_string

(

int

code

)

mp_expt_d()

int mp_expt_d	(	mp_int *	a,
		mp_digit	b,
		mp_int *	c
	)

mp_exptmod()

int mp_exptmod	(	const mp_int *	a,
		const mp_int *	b,
		mp_int *	c,
		mp_int *	d
	)

Definition at line 1917 of file mpi.c.

{
  int dr;
 
  /* modulus P must be positive */
  if (P->sign == MP_NEG) {
     return MP_VAL;
  }
 
  /* if exponent X is negative we have to recurse */
  if (X->sign == MP_NEG) {
     mp_int tmpG, tmpX;
     int err;
 
     /* first compute 1/G mod P */
     if ((err = mp_init(&tmpG)) != MP_OKAY) {
        return err;
     }
     if ((err = mp_invmod(G, P, &tmpG)) != MP_OKAY) {
        mp_clear(&tmpG);
        return err;
     }
 
     /* now get |X| */
     if ((err = mp_init(&tmpX)) != MP_OKAY) {
        mp_clear(&tmpG);
        return err;
     }
     if ((err = mp_abs(X, &tmpX)) != MP_OKAY) {
        mp_clear_multi(&tmpG, &tmpX, NULL);
        return err;
     }
 
     /* and now compute (1/G)**|X| instead of G**X [X < 0] */
     err = mp_exptmod(&tmpG, &tmpX, P, Y);
     mp_clear_multi(&tmpG, &tmpX, NULL);
     return err;
  }
 
  dr = 0;
 
  /* if the modulus is odd use the fast method */
  if (mp_isodd (P) == 1) {
    return mp_exptmod_fast (G, X, P, Y, dr);
  } else {
    /* otherwise use the generic Barrett reduction technique */
    return s_mp_exptmod (G, X, P, Y);
  }
}

mp_exteuclid()

int mp_exteuclid	(	mp_int *	a,
		mp_int *	b,
		mp_int *	U1,
		mp_int *	U2,
		mp_int *	U3
	)

mp_fread()

int mp_fread	(	mp_int *	a,
		int	radix,
		FILE *	stream
	)

mp_fwrite()

int mp_fwrite	(	mp_int *	a,
		int	radix,
		FILE *	stream
	)

mp_gcd()

int mp_gcd	(	const mp_int *	a,
		const mp_int *	b,
		mp_int *	c
	)

Definition at line 2228 of file mpi.c.

{
  mp_int  u, v;
  int     k, u_lsb, v_lsb, res;
 
  /* either zero than gcd is the largest */
  if (mp_iszero (a) == 1 && mp_iszero (b) == 0) {
    return mp_abs (b, c);
  }
  if (mp_iszero (a) == 0 && mp_iszero (b) == 1) {
    return mp_abs (a, c);
  }
 
  /* optimized.  At this point if a == 0 then
   * b must equal zero too
   */
  if (mp_iszero (a) == 1) {
    mp_zero(c);
    return MP_OKAY;
  }
 
  /* get copies of a and b we can modify */
  if ((res = mp_init_copy (&u, a)) != MP_OKAY) {
    return res;
  }
 
  if ((res = mp_init_copy (&v, b)) != MP_OKAY) {
    goto __U;
  }
 
  /* must be positive for the remainder of the algorithm */
  u.sign = v.sign = MP_ZPOS;
 
  /* B1.  Find the common power of two for u and v */
  u_lsb = mp_cnt_lsb(&u);
  v_lsb = mp_cnt_lsb(&v);
  k     = MIN(u_lsb, v_lsb);
 
  if (k > 0) {
     /* divide the power of two out */
     if ((res = mp_div_2d(&u, k, &u, NULL)) != MP_OKAY) {
        goto __V;
     }
 
     if ((res = mp_div_2d(&v, k, &v, NULL)) != MP_OKAY) {
        goto __V;
     }
  }
 
  /* divide any remaining factors of two out */
  if (u_lsb != k) {
     if ((res = mp_div_2d(&u, u_lsb - k, &u, NULL)) != MP_OKAY) {
        goto __V;
     }
  }
 
  if (v_lsb != k) {
     if ((res = mp_div_2d(&v, v_lsb - k, &v, NULL)) != MP_OKAY) {
        goto __V;
     }
  }
 
  while (mp_iszero(&v) == 0) {
     /* make sure v is the largest */
     if (mp_cmp_mag(&u, &v) == MP_GT) {
        /* swap u and v to make sure v is >= u */
        mp_exch(&u, &v);
     }
     
     /* subtract smallest from largest */
     if ((res = s_mp_sub(&v, &u, &v)) != MP_OKAY) {
        goto __V;
     }
     
     /* Divide out all factors of two */
     if ((res = mp_div_2d(&v, mp_cnt_lsb(&v), &v, NULL)) != MP_OKAY) {
        goto __V;
     } 
  } 
 
  /* multiply by 2**k which we divided out at the beginning */
  if ((res = mp_mul_2d (&u, k, c)) != MP_OKAY) {
     goto __V;
  }
  c->sign = MP_ZPOS;
  res = MP_OKAY;
__V:mp_clear (&u);
__U:mp_clear (&v);
  return res;
}

mp_get_int()

unsigned long mp_get_int

(

const mp_int *

a

)

Definition at line 2320 of file mpi.c.

{
  int i;
  unsigned long res;
 
  if (a->used == 0) {
     return 0;
  }
 
  /* get number of digits of the lsb we have to read */
  i = MIN(a->used,(int)((sizeof(unsigned long)*CHAR_BIT+DIGIT_BIT-1)/DIGIT_BIT))-1;
 
  /* get most significant digit of result */
  res = DIGIT(a,i);
   
  while (--i >= 0) {
    res = (res << DIGIT_BIT) | DIGIT(a,i);
  }
 
  /* force result to 32-bits always so it is consistent on non 32-bit platforms */
  return res & 0xFFFFFFFFUL;
}

mp_init_copy()

int mp_init_copy	(	mp_int *	a,
		const mp_int *	b
	)

Definition at line 2344 of file mpi.c.

{
  int     res;
 
  if ((res = mp_init (a)) != MP_OKAY) {
    return res;
  }
  return mp_copy (b, a);
}

mp_init_multi()

int mp_init_multi	(	mp_int *	mp,
			...
	)

Definition at line 2354 of file mpi.c.

{
    mp_err res = MP_OKAY;      /* Assume ok until proven otherwise */
    int n = 0;                 /* Number of ok inits */
    mp_int* cur_arg = mp;
    va_list args;
 
    va_start(args, mp);        /* init args to next argument from caller */
    while (cur_arg != NULL) {
        if (mp_init(cur_arg) != MP_OKAY) {
            /* Oops - error! Back-track and mp_clear what we already
               succeeded in init-ing, then return error.
            */
            va_list clean_args;
            
            /* end the current list */
            va_end(args);
            
            /* now start cleaning up */            
            cur_arg = mp;
            va_start(clean_args, mp);
            while (n--) {
                mp_clear(cur_arg);
                cur_arg = va_arg(clean_args, mp_int*);
            }
            va_end(clean_args);
            res = MP_MEM;
            break;
        }
        n++;
        cur_arg = va_arg(args, mp_int*);
    }
    va_end(args);
    return res;                /* Assumed ok, if error flagged above. */
}

mp_init_set()

int mp_init_set	(	mp_int *	a,
		mp_digit	b
	)

mp_init_set_int()

int mp_init_set_int	(	mp_int *	a,
		unsigned long	b
	)

mp_invmod()

int mp_invmod	(	const mp_int *	a,
		mp_int *	b,
		mp_int *	c
	)

Definition at line 2391 of file mpi.c.

{
  /* b cannot be negative */
  if (b->sign == MP_NEG || mp_iszero(b) == 1) {
    return MP_VAL;
  }
 
  /* if the modulus is odd we can use a faster routine instead */
  if (mp_isodd (b) == 1) {
    return fast_mp_invmod (a, b, c);
  }
  
  return mp_invmod_slow(a, b, c);
}

mp_is_square()

int mp_is_square	(	mp_int *	arg,
		int *	ret
	)

mp_jacobi()

int mp_jacobi	(	mp_int *	a,
		mp_int *	n,
		int *	c
	)

mp_lcm()

int mp_lcm	(	const mp_int *	a,
		const mp_int *	b,
		mp_int *	c
	)

Definition at line 2807 of file mpi.c.

{
  int     res;
  mp_int  t1, t2;
 
 
  if ((res = mp_init_multi (&t1, &t2, NULL)) != MP_OKAY) {
    return res;
  }
 
  /* t1 = get the GCD of the two inputs */
  if ((res = mp_gcd (a, b, &t1)) != MP_OKAY) {
    goto __T;
  }
 
  /* divide the smallest by the GCD */
  if (mp_cmp_mag(a, b) == MP_LT) {
     /* store quotient in t2 so that t2 * b is the LCM */
     if ((res = mp_div(a, &t1, &t2, NULL)) != MP_OKAY) {
        goto __T;
     }
     res = mp_mul(b, &t2, c);
  } else {
     /* store quotient in t2 so that t2 * a is the LCM */
     if ((res = mp_div(b, &t1, &t2, NULL)) != MP_OKAY) {
        goto __T;
     }
     res = mp_mul(a, &t2, c);
  }
 
  /* fix the sign to positive */
  c->sign = MP_ZPOS;
 
__T:
  mp_clear_multi (&t1, &t2, NULL);
  return res;
}

mp_mod()

int mp_mod	(	const mp_int *	a,
		mp_int *	b,
		mp_int *	c
	)

Definition at line 2847 of file mpi.c.

{
  mp_int  t;
  int     res;
 
  if ((res = mp_init (&t)) != MP_OKAY) {
    return res;
  }
 
  if ((res = mp_div (a, b, NULL, &t)) != MP_OKAY) {
    mp_clear (&t);
    return res;
  }
 
  if (t.sign != b->sign) {
    res = mp_add (b, &t, c);
  } else {
    res = MP_OKAY;
    mp_exch (&t, c);
  }
 
  mp_clear (&t);
  return res;
}

mp_mul()

int mp_mul	(	const mp_int *	a,
		const mp_int *	b,
		mp_int *	c
	)

Definition at line 3107 of file mpi.c.

{
  int     res, neg;
  neg = (a->sign == b->sign) ? MP_ZPOS : MP_NEG;
 
  /* use Karatsuba? */
  if (MIN (a->used, b->used) >= KARATSUBA_MUL_CUTOFF) {
    res = mp_karatsuba_mul (a, b, c);
  } else 
  {
    /* can we use the fast multiplier?
     *
     * The fast multiplier can be used if the output will 
     * have less than MP_WARRAY digits and the number of 
     * digits won't affect carry propagation
     */
    int     digs = a->used + b->used + 1;
 
    if ((digs < MP_WARRAY) &&
        MIN(a->used, b->used) <= 
        (1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) {
      res = fast_s_mp_mul_digs (a, b, c, digs);
    } else 
      res = s_mp_mul (a, b, c); /* uses s_mp_mul_digs */
  }
  c->sign = (c->used > 0) ? neg : MP_ZPOS;
  return res;
}

mp_mulmod()

int mp_mulmod	(	const mp_int *	a,
		const mp_int *	b,
		mp_int *	c,
		mp_int *	d
	)

Definition at line 3138 of file mpi.c.

{
  int     res;
  mp_int  t;
 
  if ((res = mp_init (&t)) != MP_OKAY) {
    return res;
  }
 
  if ((res = mp_mul (a, b, &t)) != MP_OKAY) {
    mp_clear (&t);
    return res;
  }
  res = mp_mod (&t, c, d);
  mp_clear (&t);
  return res;
}

mp_n_root()

int mp_n_root	(	mp_int *	a,
		mp_digit	b,
		mp_int *	c
	)

mp_neg()

int mp_neg	(	mp_int *	a,
		mp_int *	b
	)

mp_or()

int mp_or	(	mp_int *	a,
		mp_int *	b,
		mp_int *	c
	)

mp_prime_fermat()

int mp_prime_fermat	(	mp_int *	a,
		mp_int *	b,
		int *	result
	)

mp_prime_next_prime()

int mp_prime_next_prime	(	mp_int *	a,
		int	t,
		int	bbs_style
	)

mp_prime_rabin_miller_trials()

int mp_prime_rabin_miller_trials

(

int

size

)

Definition at line 3382 of file mpi.c.

{
   int x;
 
   for (x = 0; x < (int)(sizeof(sizes)/(sizeof(sizes[0]))); x++) {
       if (sizes[x].k == size) {
          return sizes[x].t;
       } else if (sizes[x].k > size) {
          return (x == 0) ? sizes[0].t : sizes[x - 1].t;
       }
   }
   return sizes[x-1].t + 1;
}

mp_prime_random_ex()

int mp_prime_random_ex	(	mp_int *	a,
		int	t,
		int	size,
		int	flags,
		ltm_prime_callback	cb,
		void *	dat
	)

Definition at line 3412 of file mpi.c.

{
   unsigned char *tmp, maskAND, maskOR_msb, maskOR_lsb;
   int res, err, bsize, maskOR_msb_offset;
 
   /* sanity check the input */
   if (size <= 1 || t <= 0) {
      return MP_VAL;
   }
 
   /* LTM_PRIME_SAFE implies LTM_PRIME_BBS */
   if (flags & LTM_PRIME_SAFE) {
      flags |= LTM_PRIME_BBS;
   }
 
   /* calc the byte size */
   bsize = (size>>3)+((size&7)?1:0);
 
   /* we need a buffer of bsize bytes */
   tmp = HeapAlloc(GetProcessHeap(), 0, bsize);
   if (tmp == NULL) {
      return MP_MEM;
   }
 
   /* calc the maskAND value for the MSbyte*/
   maskAND = ((size&7) == 0) ? 0xFF : (0xFF >> (8 - (size & 7))); 
 
   /* calc the maskOR_msb */
   maskOR_msb        = 0;
   maskOR_msb_offset = ((size & 7) == 1) ? 1 : 0;
   if (flags & LTM_PRIME_2MSB_ON) {
      maskOR_msb     |= 1 << ((size - 2) & 7);
   } else if (flags & LTM_PRIME_2MSB_OFF) {
      maskAND        &= ~(1 << ((size - 2) & 7));
   }
 
   /* get the maskOR_lsb */
   maskOR_lsb         = 0;
   if (flags & LTM_PRIME_BBS) {
      maskOR_lsb     |= 3;
   }
 
   do {
      /* read the bytes */
      if (cb(tmp, bsize, dat) != bsize) {
         err = MP_VAL;
         goto error;
      }
 
      /* work over the MSbyte */
      tmp[0]    &= maskAND;
      tmp[0]    |= 1 << ((size - 1) & 7);
 
      /* mix in the maskORs */
      tmp[maskOR_msb_offset]   |= maskOR_msb;
      tmp[bsize-1]             |= maskOR_lsb;
 
      /* read it in */
      if ((err = mp_read_unsigned_bin(a, tmp, bsize)) != MP_OKAY)     { goto error; }
 
      /* is it prime? */
      if ((err = mp_prime_is_prime(a, t, &res)) != MP_OKAY)           { goto error; }
      if (res == MP_NO) {  
         continue;
      }
 
      if (flags & LTM_PRIME_SAFE) {
         /* see if (a-1)/2 is prime */
         if ((err = mp_sub_d(a, 1, a)) != MP_OKAY)                    { goto error; }
         if ((err = mp_div_2(a, a)) != MP_OKAY)                       { goto error; }
 
         /* is it prime? */
         if ((err = mp_prime_is_prime(a, t, &res)) != MP_OKAY)        { goto error; }
      }
   } while (res == MP_NO);
 
   if (flags & LTM_PRIME_SAFE) {
      /* restore a to the original value */
      if ((err = mp_mul_2(a, a)) != MP_OKAY)                          { goto error; }
      if ((err = mp_add_d(a, 1, a)) != MP_OKAY)                       { goto error; }
   }
 
   err = MP_OKAY;
error:
   HeapFree(GetProcessHeap(), 0, tmp);
   return err;
}

mp_radix_size()

int mp_radix_size	(	mp_int *	a,
		int	radix,
		int *	size
	)

mp_rand()

int mp_rand	(	mp_int *	a,
		int	digits
	)

mp_read_radix()

int mp_read_radix	(	mp_int *	a,
		char *	str,
		int	radix
	)

mp_read_signed_bin()

int mp_read_signed_bin	(	mp_int *	a,
		unsigned char *	b,
		int	c
	)

mp_read_unsigned_bin()

int mp_read_unsigned_bin	(	mp_int *	a,
		const unsigned char *	b,
		int	c
	)

Definition at line 3502 of file mpi.c.

{
  int     res;
 
  /* make sure there are at least two digits */
  if (a->alloc < 2) {
     if ((res = mp_grow(a, 2)) != MP_OKAY) {
        return res;
     }
  }
 
  /* zero the int */
  mp_zero (a);
 
  /* read the bytes in */
  while (c-- > 0) {
    if ((res = mp_mul_2d (a, 8, a)) != MP_OKAY) {
      return res;
    }
 
    a->dp[0] |= *b++;
    a->used += 1;
  }
  mp_clamp (a);
  return MP_OKAY;
}

mp_reduce_is_2k()

int mp_reduce_is_2k

(

mp_int *

a

)

mp_set_int()

int mp_set_int	(	mp_int *	a,
		unsigned long	b
	)

Definition at line 3687 of file mpi.c.

{
  int     x, res;
 
  mp_zero (a);
  
  /* set four bits at a time */
  for (x = 0; x < 8; x++) {
    /* shift the number up four bits */
    if ((res = mp_mul_2d (a, 4, a)) != MP_OKAY) {
      return res;
    }
 
    /* OR in the top four bits of the source */
    a->dp[0] |= (b >> 28) & 15;
 
    /* shift the source up to the next four bits */
    b <<= 4;
 
    /* ensure that digits are not clamped off */
    a->used += 1;
  }
  mp_clamp (a);
  return MP_OKAY;
}

mp_shrink()

int mp_shrink

(

mp_int *

a

)

Definition at line 3714 of file mpi.c.

{
  mp_digit *tmp;
  if (a->alloc != a->used && a->used > 0) {
    if ((tmp = HeapReAlloc(GetProcessHeap(), 0, a->dp, sizeof (mp_digit) * a->used)) == NULL) {
      return MP_MEM;
    }
    a->dp    = tmp;
    a->alloc = a->used;
  }
  return MP_OKAY;
}

mp_sqrt()

int mp_sqrt	(	mp_int *	arg,
		mp_int *	ret
	)

mp_sub()

int mp_sub	(	mp_int *	a,
		mp_int *	b,
		mp_int *	c
	)

Definition at line 3771 of file mpi.c.

{
  int     sa, sb, res;
 
  sa = a->sign;
  sb = b->sign;
 
  if (sa != sb) {
    /* subtract a negative from a positive, OR */
    /* subtract a positive from a negative. */
    /* In either case, ADD their magnitudes, */
    /* and use the sign of the first number. */
    c->sign = sa;
    res = s_mp_add (a, b, c);
  } else {
    /* subtract a positive from a positive, OR */
    /* subtract a negative from a negative. */
    /* First, take the difference between their */
    /* magnitudes, then... */
    if (mp_cmp_mag (a, b) != MP_LT) {
      /* Copy the sign from the first */
      c->sign = sa;
      /* The first has a larger or equal magnitude */
      res = s_mp_sub (a, b, c);
    } else {
      /* The result has the *opposite* sign from */
      /* the first number. */
      c->sign = (sa == MP_ZPOS) ? MP_NEG : MP_ZPOS;
      /* The second has a larger magnitude */
      res = s_mp_sub (b, a, c);
    }
  }
  return res;
}

mp_sub_d()

int mp_sub_d	(	mp_int *	a,
		mp_digit	b,
		mp_int *	c
	)

Definition at line 3808 of file mpi.c.

{
  mp_digit *tmpa, *tmpc, mu;
  int       res, ix, oldused;
 
  /* grow c as required */
  if (c->alloc < a->used + 1) {
     if ((res = mp_grow(c, a->used + 1)) != MP_OKAY) {
        return res;
     }
  }
 
  /* if a is negative just do an unsigned
   * addition [with fudged signs]
   */
  if (a->sign == MP_NEG) {
     a->sign = MP_ZPOS;
     res     = mp_add_d(a, b, c);
     a->sign = c->sign = MP_NEG;
     return res;
  }
 
  /* setup regs */
  oldused = c->used;
  tmpa    = a->dp;
  tmpc    = c->dp;
 
  /* if a <= b simply fix the single digit */
  if ((a->used == 1 && a->dp[0] <= b) || a->used == 0) {
     if (a->used == 1) {
        *tmpc++ = b - *tmpa;
     } else {
        *tmpc++ = b;
     }
     ix      = 1;
 
     /* negative/1digit */
     c->sign = MP_NEG;
     c->used = 1;
  } else {
     /* positive/size */
     c->sign = MP_ZPOS;
     c->used = a->used;
 
     /* subtract first digit */
     *tmpc    = *tmpa++ - b;
     mu       = *tmpc >> (sizeof(mp_digit) * CHAR_BIT - 1);
     *tmpc++ &= MP_MASK;
 
     /* handle rest of the digits */
     for (ix = 1; ix < a->used; ix++) {
        *tmpc    = *tmpa++ - mu;
        mu       = *tmpc >> (sizeof(mp_digit) * CHAR_BIT - 1);
        *tmpc++ &= MP_MASK;
     }
  }
 
  /* zero excess digits */
  while (ix++ < oldused) {
     *tmpc++ = 0;
  }
  mp_clamp(c);
  return MP_OKAY;
}

mp_submod()

int mp_submod	(	mp_int *	a,
		mp_int *	b,
		mp_int *	c,
		mp_int *	d
	)

mp_to_signed_bin()

int mp_to_signed_bin	(	mp_int *	a,
		unsigned char *	b
	)

mp_to_unsigned_bin()

int mp_to_unsigned_bin	(	const mp_int *	a,
		unsigned char *	b
	)

Definition at line 3875 of file mpi.c.

{
  int     x, res;
  mp_int  t;
 
  if ((res = mp_init_copy (&t, a)) != MP_OKAY) {
    return res;
  }
 
  x = 0;
  while (mp_iszero (&t) == 0) {
    b[x++] = (unsigned char) (t.dp[0] & 255);
    if ((res = mp_div_2d (&t, 8, &t, NULL)) != MP_OKAY) {
      mp_clear (&t);
      return res;
    }
  }
  bn_reverse (b, x);
  mp_clear (&t);
  return MP_OKAY;
}

mp_toradix()

int mp_toradix	(	mp_int *	a,
		char *	str,
		int	radix
	)

mp_toradix_n()

int mp_toradix_n	(	mp_int *	a,
		char *	str,
		int	radix,
		int	maxlen
	)

mp_unsigned_bin_size()

int mp_unsigned_bin_size

(

const mp_int *

a

)

Definition at line 3899 of file mpi.c.

{
  int     size = mp_count_bits (a);
  return (size / 8 + ((size & 7) != 0 ? 1 : 0));
}

mp_xor()

int mp_xor	(	mp_int *	a,
		mp_int *	b,
		mp_int *	c
	)

rc2_ecb_decrypt()

void rc2_ecb_decrypt	(	const unsigned char *	ct,
		unsigned char *	pt,
		rc2_key *	key
	)

Definition at line 159 of file rc2.c.

{
    unsigned x76, x54, x32, x10;
    unsigned *xkey;
    int i;
 
    xkey = rc2->xkey;
 
    x76 = ((unsigned)cipher[7] << 8) + (unsigned)cipher[6];
    x54 = ((unsigned)cipher[5] << 8) + (unsigned)cipher[4];
    x32 = ((unsigned)cipher[3] << 8) + (unsigned)cipher[2];
    x10 = ((unsigned)cipher[1] << 8) + (unsigned)cipher[0];
 
    for (i = 15; i >= 0; i--) {
        if (i == 4 || i == 10) {
            x76 = (x76 - xkey[x54 & 63]) & 0xFFFF;
            x54 = (x54 - xkey[x32 & 63]) & 0xFFFF;
            x32 = (x32 - xkey[x10 & 63]) & 0xFFFF;
            x10 = (x10 - xkey[x76 & 63]) & 0xFFFF;
        }
 
        x76 = ((x76 << 11) | (x76 >> 5));
        x76 = (x76 - ((x10 & ~x54) + (x32 & x54) + xkey[4*i+3])) & 0xFFFF;
 
        x54 = ((x54 << 13) | (x54 >> 3));
        x54 = (x54 - ((x76 & ~x32) + (x10 & x32) + xkey[4*i+2])) & 0xFFFF;
 
        x32 = ((x32 << 14) | (x32 >> 2));
        x32 = (x32 - ((x54 & ~x10) + (x76 & x10) + xkey[4*i+1])) & 0xFFFF;
 
        x10 = ((x10 << 15) | (x10 >> 1));
        x10 = (x10 - ((x32 & ~x76) + (x54 & x76) + xkey[4*i+0])) & 0xFFFF;
    }
 
    plain[0] = (unsigned char)x10;
    plain[1] = (unsigned char)(x10 >> 8);
    plain[2] = (unsigned char)x32;
    plain[3] = (unsigned char)(x32 >> 8);
    plain[4] = (unsigned char)x54;
    plain[5] = (unsigned char)(x54 >> 8);
    plain[6] = (unsigned char)x76;
    plain[7] = (unsigned char)(x76 >> 8);
}

rc2_ecb_encrypt()

void rc2_ecb_encrypt	(	const unsigned char *	pt,
		unsigned char *	ct,
		rc2_key *	key
	)

Definition at line 111 of file rc2.c.

{
    unsigned *xkey;
    unsigned x76, x54, x32, x10, i;
 
    xkey = rc2->xkey;
 
    x76 = ((unsigned)plain[7] << 8) + (unsigned)plain[6];
    x54 = ((unsigned)plain[5] << 8) + (unsigned)plain[4];
    x32 = ((unsigned)plain[3] << 8) + (unsigned)plain[2];
    x10 = ((unsigned)plain[1] << 8) + (unsigned)plain[0];
 
    for (i = 0; i < 16; i++) {
        x10 = (x10 + (x32 & ~x76) + (x54 & x76) + xkey[4*i+0]) & 0xFFFF;
        x10 = ((x10 << 1) | (x10 >> 15));
 
        x32 = (x32 + (x54 & ~x10) + (x76 & x10) + xkey[4*i+1]) & 0xFFFF;
        x32 = ((x32 << 2) | (x32 >> 14));
 
        x54 = (x54 + (x76 & ~x32) + (x10 & x32) + xkey[4*i+2]) & 0xFFFF;
        x54 = ((x54 << 3) | (x54 >> 13));
 
        x76 = (x76 + (x10 & ~x54) + (x32 & x54) + xkey[4*i+3]) & 0xFFFF;
        x76 = ((x76 << 5) | (x76 >> 11));
 
        if (i == 4 || i == 10) {
            x10 = (x10 + xkey[x76 & 63]) & 0xFFFF;
            x32 = (x32 + xkey[x10 & 63]) & 0xFFFF;
            x54 = (x54 + xkey[x32 & 63]) & 0xFFFF;
            x76 = (x76 + xkey[x54 & 63]) & 0xFFFF;
        }
    }
 
    cipher[0] = (unsigned char)x10;
    cipher[1] = (unsigned char)(x10 >> 8);
    cipher[2] = (unsigned char)x32;
    cipher[3] = (unsigned char)(x32 >> 8);
    cipher[4] = (unsigned char)x54;
    cipher[5] = (unsigned char)(x54 >> 8);
    cipher[6] = (unsigned char)x76;
    cipher[7] = (unsigned char)(x76 >> 8);
}

rc2_setup()

int rc2_setup	(	const unsigned char *	key,
		int	keylen,
		int	bits,
		int	num_rounds,
		rc2_key *	skey
	)

Definition at line 53 of file rc2.c.

{
   unsigned *xkey = rc2->xkey;
   unsigned char tmp[128];
   unsigned T8, TM;
   int i;
 
   if (keylen < 5 || keylen > 128) {
      return CRYPT_INVALID_KEYSIZE;
   }
 
   if (rounds != 0 && rounds != 16) {
      return CRYPT_INVALID_ROUNDS;
   }
 
    /* Following comment is from Eric Young's rc2 code: */
    /* It has come to my attention that there are 2 versions of the RC2
     * key schedule.  One which is normal, and anther which has a hook to
     * use a reduced key length.
     * BSAFE uses the 'retarded' version.  What I previously shipped is
     * the same as specifying 1024 for the 'bits' parameter.  BSAFE uses
     * a version where the bits parameter is the same as len*8 */
    /* Seems like MS uses the 'retarded' version, too.
     * Adjust effective keylen bits */
   if (bits <= 0) bits = keylen << 3;
   if (bits > 1024) bits = 1024;
   
   for (i = 0; i < keylen; i++) {
       tmp[i] = key[i] & 255;
   }
 
    /* Phase 1: Expand input key to 128 bytes */
    if (keylen < 128) {
        for (i = keylen; i < 128; i++) {
            tmp[i] = permute[(tmp[i - 1] + tmp[i - keylen]) & 255];
        }
    }
    
    /* Phase 2 - reduce effective key size to "bits" */
    /*bits = keylen<<3; */
    T8   = (unsigned)(bits+7)>>3;
    TM   = (255 >> (unsigned)(7 & -bits));
    tmp[128 - T8] = permute[tmp[128 - T8] & TM];
    for (i = 127 - T8; i >= 0; i--) {
        tmp[i] = permute[tmp[i + 1] ^ tmp[i + T8]];
    }
 
    /* Phase 3 - copy to xkey in little-endian order */
    for (i = 0; i < 64; i++) {
        xkey[i] =  (unsigned)tmp[2*i] + ((unsigned)tmp[2*i+1] << 8);
    }        
 
    return CRYPT_OK;
}

rc4_add_entropy()

int rc4_add_entropy	(	const unsigned char *	buf,
		unsigned long	len,
		prng_state *	prng
	)

Definition at line 41 of file rc4.c.

{
    /* trim as required */
    if (prng->rc4.x + len > 256) {
       if (prng->rc4.x == 256) {
          /* I can't possibly accept another byte, ok maybe a mint wafer... */
          return CRYPT_OK;
       } else {
          /* only accept part of it */
          len = 256 - prng->rc4.x;
       }       
    }
 
    while (len--) {
       prng->rc4.buf[prng->rc4.x++] = *buf++;
    }
 
    return CRYPT_OK;
}

rc4_read()

unsigned long rc4_read	(	unsigned char *	buf,
		unsigned long	len,
		prng_state *	prng
	)

Definition at line 89 of file rc4.c.

{
   unsigned char x, y, *s, tmp;
   unsigned long n;
 
   n = len;
   x = prng->rc4.x;
   y = prng->rc4.y;
   s = prng->rc4.buf;
   while (len--) {
      x = (x + 1) & 255;
      y = (y + s[x]) & 255;
      tmp = s[x]; s[x] = s[y]; s[y] = tmp;
      tmp = (s[x] + s[y]) & 255;
      *buf++ ^= s[tmp];
   }
   prng->rc4.x = x;
   prng->rc4.y = y;
   return n;
}

rc4_ready()

int rc4_ready

(

prng_state *

prng

)

Definition at line 61 of file rc4.c.

{
    unsigned char key[256], tmp, *s;
    int keylen, x, y, j;
 
    /* extract the key */
    s = prng->rc4.buf;
    memcpy(key, s, 256);
    keylen = prng->rc4.x;
 
    /* make RC4 perm and shuffle */
    for (x = 0; x < 256; x++) {
        s[x] = x;
    }
 
    for (j = x = y = 0; x < 256; x++) {
        y = (y + prng->rc4.buf[x] + key[j++]) & 255;
        if (j == keylen) {
           j = 0; 
        }
        tmp = s[x]; s[x] = s[y]; s[y] = tmp;
    }
    prng->rc4.x = 0;
    prng->rc4.y = 0;
 
    return CRYPT_OK;
}

rc4_start()

int rc4_start

(

prng_state *

prng

)

Definition at line 33 of file rc4.c.

{
    /* set keysize to zero */
    prng->rc4.x = 0;
    
    return CRYPT_OK;
}

rsa_exptmod()

int rsa_exptmod	(	const unsigned char *	in,
		unsigned long	inlen,
		unsigned char *	out,
		unsigned long *	outlen,
		int	which,
		rsa_key *	key
	)

Definition at line 180 of file rsa.c.

{
   mp_int        tmp, tmpa, tmpb;
   unsigned long x;
   int           err;
 
   /* is the key of the right type for the operation? */
   if (which == PK_PRIVATE && (key->type != PK_PRIVATE)) {
      return CRYPT_PK_NOT_PRIVATE;
   }
 
   /* must be a private or public operation */
   if (which != PK_PRIVATE && which != PK_PUBLIC) {
      return CRYPT_PK_INVALID_TYPE;
   }
 
   /* init and copy into tmp */
   if ((err = mp_init_multi(&tmp, &tmpa, &tmpb, NULL)) != MP_OKAY)    { return mpi_to_ltc_error(err); }
   if ((err = mp_read_unsigned_bin(&tmp, in, (int)inlen)) != MP_OKAY) { goto error; }
 
   /* sanity check on the input */
   if (mp_cmp(&key->N, &tmp) == MP_LT) {
      err = CRYPT_PK_INVALID_SIZE;
      goto done;
   }
 
   /* are we using the private exponent and is the key optimized? */
   if (which == PK_PRIVATE) {
      /* tmpa = tmp^dP mod p */
      if ((err = mpi_to_ltc_error(mp_exptmod(&tmp, &key->dP, &key->p, &tmpa))) != MP_OKAY)    { goto error; }
      
      /* tmpb = tmp^dQ mod q */
      if ((err = mpi_to_ltc_error(mp_exptmod(&tmp, &key->dQ, &key->q, &tmpb))) != MP_OKAY)    { goto error; }
 
      /* tmp = (tmpa - tmpb) * qInv (mod p) */
      if ((err = mp_sub(&tmpa, &tmpb, &tmp)) != MP_OKAY)                    { goto error; }
      if ((err = mp_mulmod(&tmp, &key->qP, &key->p, &tmp)) != MP_OKAY)      { goto error; }
 
      /* tmp = tmpb + q * tmp */
      if ((err = mp_mul(&tmp, &key->q, &tmp)) != MP_OKAY)                   { goto error; }
      if ((err = mp_add(&tmp, &tmpb, &tmp)) != MP_OKAY)                     { goto error; }
   } else {
      /* exptmod it */
      if ((err = mp_exptmod(&tmp, &key->e, &key->N, &tmp)) != MP_OKAY) { goto error; }
   }
 
   /* read it back */
   x = (unsigned long)mp_unsigned_bin_size(&key->N);
   if (x > *outlen) {
      err = CRYPT_BUFFER_OVERFLOW;
      goto done;
   }
   *outlen = x;
 
   /* convert it */
   memset(out, 0, x);
   if ((err = mp_to_unsigned_bin(&tmp, out+(x-mp_unsigned_bin_size(&tmp)))) != MP_OKAY) { goto error; }
 
   /* clean up and return */
   err = CRYPT_OK;
   goto done;
error:
   err = mpi_to_ltc_error(err);
done:
   mp_clear_multi(&tmp, &tmpa, &tmpb, NULL);
   return err;
}

rsa_free()

void rsa_free

(

rsa_key *

key

)

Definition at line 173 of file rsa.c.

{
   mp_clear_multi(&key->e, &key->d, &key->N, &key->dQ, &key->dP,
                  &key->qP, &key->p, &key->q, NULL);
}

rsa_make_key()

int rsa_make_key	(	int	size,
		long	e,
		rsa_key *	key
	)

Definition at line 87 of file rsa.c.

{
   mp_int p, q, tmp1, tmp2, tmp3;
   int    err;
 
   if ((size < (MIN_RSA_SIZE/8)) || (size > (MAX_RSA_SIZE/8))) {
      return CRYPT_INVALID_KEYSIZE;
   }
 
   if ((e < 3) || ((e & 1) == 0)) {
      return CRYPT_INVALID_ARG;
   }
 
   if ((err = mp_init_multi(&p, &q, &tmp1, &tmp2, &tmp3, NULL)) != MP_OKAY) {
      return mpi_to_ltc_error(err);
   }
 
    /* make primes p and q (optimization provided by Wayne Scott) */
   if ((err = mp_set_int(&tmp3, e)) != MP_OKAY) { goto error; }            /* tmp3 = e */
 
    /* make prime "p" */
   do {
       if ((err = rand_prime(&p, size*4)) != CRYPT_OK) { goto done; }
       if ((err = mp_sub_d(&p, 1, &tmp1)) != MP_OKAY)               { goto error; }  /* tmp1 = p-1 */
       if ((err = mp_gcd(&tmp1, &tmp3, &tmp2)) != MP_OKAY)          { goto error; }  /* tmp2 = gcd(p-1, e) */
   } while (mp_cmp_d(&tmp2, 1) != 0);                                                /* while e divides p-1 */
 
   /* make prime "q" */
   do {
       if ((err = rand_prime(&q, size*4)) != CRYPT_OK) { goto done; }
       if ((err = mp_sub_d(&q, 1, &tmp1)) != MP_OKAY)               { goto error; } /* tmp1 = q-1 */
       if ((err = mp_gcd(&tmp1, &tmp3, &tmp2)) != MP_OKAY)          { goto error; } /* tmp2 = gcd(q-1, e) */
   } while (mp_cmp_d(&tmp2, 1) != 0);                                               /* while e divides q-1 */
 
   /* tmp1 = lcm(p-1, q-1) */
   if ((err = mp_sub_d(&p, 1, &tmp2)) != MP_OKAY)                  { goto error; } /* tmp2 = p-1 */
                                                                   /* tmp1 = q-1 (previous do/while loop) */
   if ((err = mp_lcm(&tmp1, &tmp2, &tmp1)) != MP_OKAY)             { goto error; } /* tmp1 = lcm(p-1, q-1) */
 
   /* make key */
   if ((err = mp_init_multi(&key->e, &key->d, &key->N, &key->dQ, &key->dP,
                     &key->qP, &key->p, &key->q, NULL)) != MP_OKAY) {
      goto error;
   }
 
   if ((err = mp_set_int(&key->e, e)) != MP_OKAY)                     { goto error2; } /* key->e =  e */
   if ((err = mp_invmod(&key->e, &tmp1, &key->d)) != MP_OKAY)         { goto error2; } /* key->d = 1/e mod lcm(p-1,q-1) */
   if ((err = mp_mul(&p, &q, &key->N)) != MP_OKAY)                    { goto error2; } /* key->N = pq */
 
   /* optimize for CRT now */
   /* find d mod q-1 and d mod p-1 */
   if ((err = mp_sub_d(&p, 1, &tmp1)) != MP_OKAY)                     { goto error2; } /* tmp1 = q-1 */
   if ((err = mp_sub_d(&q, 1, &tmp2)) != MP_OKAY)                     { goto error2; } /* tmp2 = p-1 */
   if ((err = mp_mod(&key->d, &tmp1, &key->dP)) != MP_OKAY)           { goto error2; } /* dP = d mod p-1 */
   if ((err = mp_mod(&key->d, &tmp2, &key->dQ)) != MP_OKAY)           { goto error2; } /* dQ = d mod q-1 */
   if ((err = mp_invmod(&q, &p, &key->qP)) != MP_OKAY)                { goto error2; } /* qP = 1/q mod p */
 
   if ((err = mp_copy(&p, &key->p)) != MP_OKAY)                       { goto error2; }
   if ((err = mp_copy(&q, &key->q)) != MP_OKAY)                       { goto error2; }
 
   /* shrink ram required  */
   if ((err = mp_shrink(&key->e)) != MP_OKAY)                         { goto error2; }
   if ((err = mp_shrink(&key->d)) != MP_OKAY)                         { goto error2; }
   if ((err = mp_shrink(&key->N)) != MP_OKAY)                         { goto error2; }
   if ((err = mp_shrink(&key->dQ)) != MP_OKAY)                        { goto error2; }
   if ((err = mp_shrink(&key->dP)) != MP_OKAY)                        { goto error2; }
   if ((err = mp_shrink(&key->qP)) != MP_OKAY)                        { goto error2; }
   if ((err = mp_shrink(&key->p)) != MP_OKAY)                         { goto error2; }
   if ((err = mp_shrink(&key->q)) != MP_OKAY)                         { goto error2; }
 
   /* set key type (in this case it's CRT optimized) */
   key->type = PK_PRIVATE;
 
   /* return ok and free temps */
   err       = CRYPT_OK;
   goto done;
error2:
   mp_clear_multi(&key->d, &key->e, &key->N, &key->dQ, &key->dP,
                  &key->qP, &key->p, &key->q, NULL);
error:
   err = mpi_to_ltc_error(err);
done:
   mp_clear_multi(&tmp3, &tmp2, &tmp1, &p, &q, NULL);
   return err;
}

Variable Documentation

mp_s_rmap

const char* mp_s_rmap

extern