ref: a069ed018555d165681cf3f02a2f00f565d9150f
dir: /include/libsec.h/
#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);