shithub: 9ferno

ref: e16b4d85dd6b1cf14834387b765113114dabeae2

View raw version
#pragma	src	"/usr/inferno/libsec"

#ifndef _MPINT
typedef struct mpint mpint;
#endif

/*/////////////////////////////////////////////////////// */
/* AES definitions */
/*/////////////////////////////////////////////////////// */

enum
{
	AESbsize=	16,
	AESmaxkey=	32,
	AESmaxrounds=	14
};

typedef struct AESstate AESstate;
struct AESstate
{
	u32	setup;
	int	rounds;
	int	keybytes;
	uchar	key[AESmaxkey];		/* unexpanded key */
	u32	ekey[4*(AESmaxrounds + 1)];	/* encryption key */
	u32	dkey[4*(AESmaxrounds + 1)];	/* decryption key */
	uchar	ivec[AESbsize];	/* initialization vector */
};

void	setupAESstate(AESstate *s, uchar key[], int keybytes, uchar *ivec);
void	aesCBCencrypt(uchar *p, int len, AESstate *s);
void	aesCBCdecrypt(uchar *p, int len, AESstate *s);

/*/////////////////////////////////////////////////////// */
/* Blowfish Definitions */
/*/////////////////////////////////////////////////////// */

enum
{
	BFbsize	= 8,
	BFrounds	= 16
};

/* 16-round Blowfish */
typedef struct BFstate BFstate;
struct BFstate
{
	u32	setup;

	uchar	key[56];
	uchar	ivec[8];

	u32 	pbox[BFrounds+2];
	u32	sbox[1024];
};

void	setupBFstate(BFstate *s, uchar key[], int keybytes, uchar *ivec);
void	bfCBCencrypt(uchar*, int, BFstate*);
void	bfCBCdecrypt(uchar*, int, BFstate*);
void	bfECBencrypt(uchar*, int, BFstate*);
void	bfECBdecrypt(uchar*, int, BFstate*);

/*/////////////////////////////////////////////////////// */
/* DES definitions */
/*/////////////////////////////////////////////////////// */

enum
{
	DESbsize=	8
};

/* single des */
typedef struct DESstate DESstate;
struct DESstate
{
	u32	setup;
	uchar	key[8];		/* unexpanded key */
	u32	expanded[32];	/* expanded key */
	uchar	ivec[8];	/* initialization vector */
};

void	setupDESstate(DESstate *s, uchar key[8], uchar *ivec);
void	des_key_setup(uchar[8], u32[32]);
void	block_cipher(u32*, uchar*, int);
void	desCBCencrypt(uchar*, int, DESstate*);
void	desCBCdecrypt(uchar*, int, DESstate*);
void	desECBencrypt(uchar*, int, DESstate*);
void	desECBdecrypt(uchar*, int, DESstate*);

/* for backward compatibility with 7 byte DES key format */
void	des56to64(uchar *k56, uchar *k64);
void	des64to56(uchar *k64, uchar *k56);
void	key_setup(uchar[7], u32[32]);

/* triple des encrypt/decrypt orderings */
enum {
	DES3E=		0,
	DES3D=		1,
	DES3EEE=	0,
	DES3EDE=	2,
	DES3DED=	5,
	DES3DDD=	7
};

typedef struct DES3state DES3state;
struct DES3state
{
	u32	setup;
	uchar	key[3][8];		/* unexpanded key */
	u32	expanded[3][32];	/* expanded key */
	uchar	ivec[8];		/* initialization vector */
};

void	setupDES3state(DES3state *s, uchar key[3][8], uchar *ivec);
void	triple_block_cipher(u32 keys[3][32], uchar*, int);
void	des3CBCencrypt(uchar*, int, DES3state*);
void	des3CBCdecrypt(uchar*, int, DES3state*);
void	des3ECBencrypt(uchar*, int, DES3state*);
void	des3ECBdecrypt(uchar*, int, DES3state*);

/* IDEA */
typedef struct IDEAstate IDEAstate;
struct IDEAstate
{
	uchar	key[16];
	ushort	edkey[104];
	uchar	ivec[8];
};

void	setupIDEAstate(IDEAstate*, uchar*, uchar*);
void	idea_key_setup(uchar*, ushort*);
void	idea_cipher(ushort*, uchar*, int);


/*/////////////////////////////////////////////////////// */
/* digests */
/*/////////////////////////////////////////////////////// */

enum
{
	/* digest lengths */
	SHA1dlen=	20,
	MD4dlen=	16,
	MD5dlen=	16,

	SHA224dlen=	28,
	SHA256dlen=	32,

	SHA384dlen=	48,
	SHA512dlen=	64,

	/* block sizes */
	SHA256bsize=	64,
	SHA512bsize=	128,
	Digestbsize=	128,		/* maximum */
};

typedef struct DigestState DigestState;
struct DigestState
{
	u64 len;
	u32 state[5];
	uchar buf[Digestbsize];
	int blen;
	u64 nb128[2];
	u64 h64[8];
	u32 h32[8];
	char malloced;
	char seeded;
};
typedef struct DigestState SHAstate;	/* obsolete name */
typedef struct DigestState SHA1state;
typedef struct DigestState MD5state;
typedef struct DigestState MD4state;
typedef struct DigestState SHA256state;
typedef struct DigestState SHA512state;

DigestState* md4(uchar*, u32, uchar*, DigestState*);
DigestState* md5(uchar*, u32, uchar*, DigestState*);
DigestState* sha1(uchar*, u32, uchar*, DigestState*);
DigestState* sha224(uchar*, u32, uchar*, DigestState*);
DigestState* sha256(uchar*, u32, uchar*, DigestState*);
DigestState* sha384(uchar*, u32, uchar*, DigestState*);
DigestState* sha512(uchar*, u32, uchar*, DigestState*);
DigestState* hmac_md5(uchar*, u32, uchar*, u32, uchar*, DigestState*);
DigestState* hmac_sha1(uchar*, u32, uchar*, u32, uchar*, DigestState*);
char* md5pickle(MD5state*);
MD5state* md5unpickle(char*);
char* sha1pickle(SHA1state*);
SHA1state* sha1unpickle(char*);

/*/////////////////////////////////////////////////////// */
/* random number generation */
/*/////////////////////////////////////////////////////// */
void	genrandom(uchar *buf, int nbytes);
void	_genrandomqlock(void);
void	_genrandomqunlock(void);
void	prng(uchar *buf, int nbytes);
u32	fastrand(void);
u32	nfastrand(u32);

/*/////////////////////////////////////////////////////// */
/* primes */
/*/////////////////////////////////////////////////////// */
void	genprime(mpint *p, int n, int accuracy); /* generate an n bit probable prime */
void	gensafeprime(mpint *p, mpint *alpha, int n, int accuracy);	/* prime and generator */
void	genstrongprime(mpint *p, int n, int accuracy);	/* generate an n bit strong prime */
void	DSAprimes(mpint *q, mpint *p, uchar seed[SHA1dlen]);
int	probably_prime(mpint *n, int nrep);	/* miller-rabin test */
int	smallprimetest(mpint *p);		/* returns -1 if not prime, 0 otherwise */

/*/////////////////////////////////////////////////////// */
/* rc4 */
/*/////////////////////////////////////////////////////// */
typedef struct RC4state RC4state;
struct RC4state
{
	 uchar state[256];
	 uchar x;
	 uchar y;
};

void	setupRC4state(RC4state*, uchar*, int);
void	rc4(RC4state*, uchar*, int);
void	rc4skip(RC4state*, int);
void	rc4back(RC4state*, int);

/*/////////////////////////////////////////////////////// */
/* rsa */
/*/////////////////////////////////////////////////////// */
typedef struct RSApub RSApub;
typedef struct RSApriv RSApriv;
typedef struct PEMChain PEMChain;

/* public/encryption key */
struct RSApub
{
	mpint	*n;	/* modulus */
	mpint	*ek;	/* exp (encryption key) */
};

/* private/decryption key */
struct RSApriv
{
	RSApub	pub;

	mpint	*dk;	/* exp (decryption key) */

	/* precomputed values to help with chinese remainder theorem calc */
	mpint	*p;
	mpint	*q;
	mpint	*kp;	/* dk mod p-1 */
	mpint	*kq;	/* dk mod q-1 */
	mpint	*c2;	/* (inv p) mod q */
};

struct PEMChain{
	PEMChain *next;
	uchar *pem;
	int pemlen;
};

RSApriv*	rsagen(int nlen, int elen, int rounds);
RSApriv*	rsafill(mpint *n, mpint *e, mpint *d, mpint *p, mpint *q);
mpint*		rsaencrypt(RSApub *k, mpint *in, mpint *out);
mpint*		rsadecrypt(RSApriv *k, mpint *in, mpint *out);
RSApub*		rsapuballoc(void);
void		rsapubfree(RSApub*);
RSApriv*	rsaprivalloc(void);
void		rsaprivfree(RSApriv*);
RSApub*		rsaprivtopub(RSApriv*);
RSApub*		X509toRSApub(uchar*, int, char*, int);
RSApriv*	asn1toRSApriv(uchar*, int);
void		asn1dump(uchar *der, int len);
uchar*		decodePEM(char *s, char *type, int *len, char **new_s);
PEMChain*	decodepemchain(char *s, char *type);
uchar*		X509gen(RSApriv *priv, char *subj, u32 valid[2], int *certlen);
uchar*		X509req(RSApriv *priv, char *subj, int *certlen);
char*		X509verify(uchar *cert, int ncert, RSApub *pk);
void		X509dump(uchar *cert, int ncert);

/*/////////////////////////////////////////////////////// */
/* elgamal */
/*/////////////////////////////////////////////////////// */
typedef struct EGpub EGpub;
typedef struct EGpriv EGpriv;
typedef struct EGsig EGsig;

/* public/encryption key */
struct EGpub
{
	mpint	*p;	/* modulus */
	mpint	*alpha;	/* generator */
	mpint	*key;	/* (encryption key) alpha**secret mod p */
};

/* private/decryption key */
struct EGpriv
{
	EGpub	pub;
	mpint	*secret; /* (decryption key) */
};

/* signature */
struct EGsig
{
	mpint	*r, *s;
};

EGpriv*		eggen(int nlen, int rounds);
mpint*		egencrypt(EGpub *k, mpint *in, mpint *out);	/* deprecated */
mpint*		egdecrypt(EGpriv *k, mpint *in, mpint *out);
EGsig*		egsign(EGpriv *k, mpint *m);
int		egverify(EGpub *k, EGsig *sig, mpint *m);
EGpub*		egpuballoc(void);
void		egpubfree(EGpub*);
EGpriv*		egprivalloc(void);
void		egprivfree(EGpriv*);
EGsig*		egsigalloc(void);
void		egsigfree(EGsig*);
EGpub*		egprivtopub(EGpriv*);

/*/////////////////////////////////////////////////////// */
/* dsa */
/*/////////////////////////////////////////////////////// */
typedef struct DSApub DSApub;
typedef struct DSApriv DSApriv;
typedef struct DSAsig DSAsig;

/* public/encryption key */
struct DSApub
{
	mpint	*p;	/* modulus */
	mpint	*q;	/* group order, q divides p-1 */
	mpint	*alpha;	/* group generator */
	mpint	*key;	/* (encryption key) alpha**secret mod p */
};

/* private/decryption key */
struct DSApriv
{
	DSApub	pub;
	mpint	*secret; /* (decryption key) */
};

/* signature */
struct DSAsig
{
	mpint	*r, *s;
};

DSApriv*	dsagen(DSApub *opub);	/* opub not checked for consistency! */
DSAsig*		dsasign(DSApriv *k, mpint *m);
int		dsaverify(DSApub *k, DSAsig *sig, mpint *m);
DSApub*		dsapuballoc(void);
void		dsapubfree(DSApub*);
DSApriv*	dsaprivalloc(void);
void		dsaprivfree(DSApriv*);
DSAsig*		dsasigalloc(void);
void		dsasigfree(DSAsig*);
DSApub*		dsaprivtopub(DSApriv*);

/*/////////////////////////////////////////////////////// */
/* TLS */
/*/////////////////////////////////////////////////////// */
typedef struct Thumbprint{
	struct Thumbprint *next;
	uchar sha1[SHA1dlen];
} Thumbprint;

typedef struct TLSconn{
	char dir[40];  /* connection directory */
	uchar *cert;   /* certificate (local on input, remote on output) */
	uchar *sessionID;
	int certlen, sessionIDlen;
	int (*trace)(char*fmt, ...);
	PEMChain *chain; /* optional extra certificate evidence for servers to present */
} TLSconn;

/* tlshand.c */
int tlsClient(int fd, TLSconn *c);
int tlsServer(int fd, TLSconn *c);

/* thumb.c */
Thumbprint* initThumbprints(char *ok, char *crl);
void	freeThumbprints(Thumbprint *ok);
int		okThumbprint(uchar *sha1, Thumbprint *ok);

/* readcert.c */
uchar	*readcert(char *filename, int *pcertlen);
PEMChain *readcertchain(char *filename);