1 #pragma lib "libsec.a" 2 #pragma src "/sys/src/libsec" 3 4 #ifndef _MPINT 5 typedef struct mpint mpint; 6 #endif 7 8 ///////////////////////////////////////////////////////// 9 // AES definitions 10 ///////////////////////////////////////////////////////// 11 12 enum 13 { 14 AESbsize= 16, 15 AESmaxkey= 32, 16 AESmaxrounds= 14 17 }; 18 19 typedef struct AESstate AESstate; 20 struct AESstate 21 { 22 ulong setup; 23 int rounds; 24 int keybytes; 25 uchar key[AESmaxkey]; /* unexpanded key */ 26 u32int ekey[4*(AESmaxrounds + 1)]; /* encryption key */ 27 u32int dkey[4*(AESmaxrounds + 1)]; /* decryption key */ 28 uchar ivec[AESbsize]; /* initialization vector */ 29 }; 30 31 void setupAESstate(AESstate *s, uchar key[], int keybytes, uchar *ivec); 32 void aesCBCencrypt(uchar *p, int len, AESstate *s); 33 void aesCBCdecrypt(uchar *p, int len, AESstate *s); 34 35 ///////////////////////////////////////////////////////// 36 // Blowfish Definitions 37 ///////////////////////////////////////////////////////// 38 39 enum 40 { 41 BFbsize = 8, 42 BFrounds = 16 43 }; 44 45 // 16-round Blowfish 46 typedef struct BFstate BFstate; 47 struct BFstate 48 { 49 ulong setup; 50 51 uchar key[56]; 52 uchar ivec[8]; 53 54 u32int pbox[BFrounds+2]; 55 u32int sbox[1024]; 56 }; 57 58 void setupBFstate(BFstate *s, uchar key[], int keybytes, uchar *ivec); 59 void bfCBCencrypt(uchar*, int, BFstate*); 60 void bfCBCdecrypt(uchar*, int, BFstate*); 61 void bfECBencrypt(uchar*, int, BFstate*); 62 void bfECBdecrypt(uchar*, int, BFstate*); 63 64 ///////////////////////////////////////////////////////// 65 // DES definitions 66 ///////////////////////////////////////////////////////// 67 68 enum 69 { 70 DESbsize= 8 71 }; 72 73 // single des 74 typedef struct DESstate DESstate; 75 struct DESstate 76 { 77 ulong setup; 78 uchar key[8]; /* unexpanded key */ 79 ulong expanded[32]; /* expanded key */ 80 uchar ivec[8]; /* initialization vector */ 81 }; 82 83 void setupDESstate(DESstate *s, uchar key[8], uchar *ivec); 84 void des_key_setup(uchar[8], ulong[32]); 85 void block_cipher(ulong*, uchar*, int); 86 void desCBCencrypt(uchar*, int, DESstate*); 87 void desCBCdecrypt(uchar*, int, DESstate*); 88 void desECBencrypt(uchar*, int, DESstate*); 89 void desECBdecrypt(uchar*, int, DESstate*); 90 91 // for backward compatibility with 7 byte DES key format 92 void des56to64(uchar *k56, uchar *k64); 93 void des64to56(uchar *k64, uchar *k56); 94 void key_setup(uchar[7], ulong[32]); 95 96 // triple des encrypt/decrypt orderings 97 enum { 98 DES3E= 0, 99 DES3D= 1, 100 DES3EEE= 0, 101 DES3EDE= 2, 102 DES3DED= 5, 103 DES3DDD= 7 104 }; 105 106 typedef struct DES3state DES3state; 107 struct DES3state 108 { 109 ulong setup; 110 uchar key[3][8]; /* unexpanded key */ 111 ulong expanded[3][32]; /* expanded key */ 112 uchar ivec[8]; /* initialization vector */ 113 }; 114 115 void setupDES3state(DES3state *s, uchar key[3][8], uchar *ivec); 116 void triple_block_cipher(ulong keys[3][32], uchar*, int); 117 void des3CBCencrypt(uchar*, int, DES3state*); 118 void des3CBCdecrypt(uchar*, int, DES3state*); 119 void des3ECBencrypt(uchar*, int, DES3state*); 120 void des3ECBdecrypt(uchar*, int, DES3state*); 121 122 ///////////////////////////////////////////////////////// 123 // digests 124 ///////////////////////////////////////////////////////// 125 126 enum 127 { 128 SHA1dlen= 20, /* SHA digest length */ 129 MD4dlen= 16, /* MD4 digest length */ 130 MD5dlen= 16 /* MD5 digest length */ 131 }; 132 133 typedef struct DigestState DigestState; 134 struct DigestState 135 { 136 uvlong len; 137 u32int state[5]; 138 uchar buf[128]; 139 int blen; 140 char malloced; 141 char seeded; 142 }; 143 typedef struct DigestState SHAstate; /* obsolete name */ 144 typedef struct DigestState SHA1state; 145 typedef struct DigestState MD5state; 146 typedef struct DigestState MD4state; 147 148 DigestState* md4(uchar*, ulong, uchar*, DigestState*); 149 DigestState* md5(uchar*, ulong, uchar*, DigestState*); 150 DigestState* sha1(uchar*, ulong, uchar*, DigestState*); 151 DigestState* hmac_md5(uchar*, ulong, uchar*, ulong, uchar*, DigestState*); 152 DigestState* hmac_sha1(uchar*, ulong, uchar*, ulong, uchar*, DigestState*); 153 char* md5pickle(MD5state*); 154 MD5state* md5unpickle(char*); 155 char* sha1pickle(SHA1state*); 156 SHA1state* sha1unpickle(char*); 157 158 ///////////////////////////////////////////////////////// 159 // random number generation 160 ///////////////////////////////////////////////////////// 161 void genrandom(uchar *buf, int nbytes); 162 void prng(uchar *buf, int nbytes); 163 ulong fastrand(void); 164 ulong nfastrand(ulong); 165 166 ///////////////////////////////////////////////////////// 167 // primes 168 ///////////////////////////////////////////////////////// 169 void genprime(mpint *p, int n, int accuracy); // generate an n bit probable prime 170 void gensafeprime(mpint *p, mpint *alpha, int n, int accuracy); // prime and generator 171 void genstrongprime(mpint *p, int n, int accuracy); // generate an n bit strong prime 172 void DSAprimes(mpint *q, mpint *p, uchar seed[SHA1dlen]); 173 int probably_prime(mpint *n, int nrep); // miller-rabin test 174 int smallprimetest(mpint *p); // returns -1 if not prime, 0 otherwise 175 176 ///////////////////////////////////////////////////////// 177 // rc4 178 ///////////////////////////////////////////////////////// 179 typedef struct RC4state RC4state; 180 struct RC4state 181 { 182 uchar state[256]; 183 uchar x; 184 uchar y; 185 }; 186 187 void setupRC4state(RC4state*, uchar*, int); 188 void rc4(RC4state*, uchar*, int); 189 void rc4skip(RC4state*, int); 190 void rc4back(RC4state*, int); 191 192 ///////////////////////////////////////////////////////// 193 // rsa 194 ///////////////////////////////////////////////////////// 195 typedef struct RSApub RSApub; 196 typedef struct RSApriv RSApriv; 197 198 // public/encryption key 199 struct RSApub 200 { 201 mpint *n; // modulus 202 mpint *ek; // exp (encryption key) 203 }; 204 205 // private/decryption key 206 struct RSApriv 207 { 208 RSApub pub; 209 210 mpint *dk; // exp (decryption key) 211 212 // precomputed values to help with chinese remainder theorem calc 213 mpint *p; 214 mpint *q; 215 mpint *kp; // dk mod p-1 216 mpint *kq; // dk mod q-1 217 mpint *c2; // (inv p) mod q 218 }; 219 220 RSApriv* rsagen(int nlen, int elen, int rounds); 221 RSApriv* rsafill(mpint *n, mpint *e, mpint *d, mpint *p, mpint *q); 222 mpint* rsaencrypt(RSApub *k, mpint *in, mpint *out); 223 mpint* rsadecrypt(RSApriv *k, mpint *in, mpint *out); 224 RSApub* rsapuballoc(void); 225 void rsapubfree(RSApub*); 226 RSApriv* rsaprivalloc(void); 227 void rsaprivfree(RSApriv*); 228 RSApub* rsaprivtopub(RSApriv*); 229 RSApub* X509toRSApub(uchar*, int, char*, int); 230 RSApriv* asn1toRSApriv(uchar*, int); 231 void asn1dump(uchar *der, int len); 232 uchar* decodepem(char *s, char *type, int *len); 233 uchar* X509gen(RSApriv *priv, char *subj, ulong valid[2], int *certlen); 234 uchar* X509req(RSApriv *priv, char *subj, int *certlen); 235 char* X509verify(uchar *cert, int ncert, RSApub *pk); 236 void X509dump(uchar *cert, int ncert); 237 ///////////////////////////////////////////////////////// 238 // elgamal 239 ///////////////////////////////////////////////////////// 240 typedef struct EGpub EGpub; 241 typedef struct EGpriv EGpriv; 242 typedef struct EGsig EGsig; 243 244 // public/encryption key 245 struct EGpub 246 { 247 mpint *p; // modulus 248 mpint *alpha; // generator 249 mpint *key; // (encryption key) alpha**secret mod p 250 }; 251 252 // private/decryption key 253 struct EGpriv 254 { 255 EGpub pub; 256 mpint *secret; // (decryption key) 257 }; 258 259 // signature 260 struct EGsig 261 { 262 mpint *r, *s; 263 }; 264 265 EGpriv* eggen(int nlen, int rounds); 266 mpint* egencrypt(EGpub *k, mpint *in, mpint *out); // deprecated 267 mpint* egdecrypt(EGpriv *k, mpint *in, mpint *out); 268 EGsig* egsign(EGpriv *k, mpint *m); 269 int egverify(EGpub *k, EGsig *sig, mpint *m); 270 EGpub* egpuballoc(void); 271 void egpubfree(EGpub*); 272 EGpriv* egprivalloc(void); 273 void egprivfree(EGpriv*); 274 EGsig* egsigalloc(void); 275 void egsigfree(EGsig*); 276 EGpub* egprivtopub(EGpriv*); 277 278 ///////////////////////////////////////////////////////// 279 // dsa 280 ///////////////////////////////////////////////////////// 281 typedef struct DSApub DSApub; 282 typedef struct DSApriv DSApriv; 283 typedef struct DSAsig DSAsig; 284 285 // public/encryption key 286 struct DSApub 287 { 288 mpint *p; // modulus 289 mpint *q; // group order, q divides p-1 290 mpint *alpha; // group generator 291 mpint *key; // (encryption key) alpha**secret mod p 292 }; 293 294 // private/decryption key 295 struct DSApriv 296 { 297 DSApub pub; 298 mpint *secret; // (decryption key) 299 }; 300 301 // signature 302 struct DSAsig 303 { 304 mpint *r, *s; 305 }; 306 307 DSApriv* dsagen(DSApub *opub); // opub not checked for consistency! 308 DSAsig* dsasign(DSApriv *k, mpint *m); 309 int dsaverify(DSApub *k, DSAsig *sig, mpint *m); 310 DSApub* dsapuballoc(void); 311 void dsapubfree(DSApub*); 312 DSApriv* dsaprivalloc(void); 313 void dsaprivfree(DSApriv*); 314 DSAsig* dsasigalloc(void); 315 void dsasigfree(DSAsig*); 316 DSApub* dsaprivtopub(DSApriv*); 317 318 ///////////////////////////////////////////////////////// 319 // TLS 320 ///////////////////////////////////////////////////////// 321 typedef struct Thumbprint{ 322 struct Thumbprint *next; 323 uchar sha1[SHA1dlen]; 324 } Thumbprint; 325 326 typedef struct TLSconn{ 327 char dir[40]; // connection directory 328 uchar *cert; // certificate (local on input, remote on output) 329 uchar *sessionID; 330 int certlen, sessionIDlen; 331 int (*trace)(char*fmt, ...); 332 } TLSconn; 333 334 // tlshand.c 335 extern int tlsClient(int fd, TLSconn *c); 336 extern int tlsServer(int fd, TLSconn *c); 337 338 // thumb.c 339 extern Thumbprint* initThumbprints(char *ok, char *crl); 340 extern void freeThumbprints(Thumbprint *ok); 341 extern int okThumbprint(uchar *sha1, Thumbprint *ok); 342 343 // readcert.c 344 extern uchar *readcert(char *filename, int *pcertlen); 345