sys/include/ape/libsec.h

   1 #ifndef _PLAN9_SOURCE
   2   This header file is an extension to ANSI/POSIX
   3 #endif
   4
   5 #ifndef __LIBSEC_H_
   6 #define __LIBSEC_H_
   7
   8 #pragma src     "/sys/src/ape/lib/sec"
   9 #pragma lib     "/$M/lib/ape/libsec.a"
  10
  11 #include <u.h>
  12
  13 #ifndef _MPINT
  14 typedef struct mpint mpint;
  15 #endif
  16
  17 /*
  18  * AES definitions
  19  */
  20
  21 enum
  22 {
  23         AESbsize=       16,
  24         AESmaxkey=      32,
  25         AESmaxrounds=   14
  26 };
  27
  28 typedef struct AESstate AESstate;
  29 struct AESstate
  30 {
  31         ulong   setup;
  32         int     rounds;
  33         int     keybytes;
  34         uchar   key[AESmaxkey];                 /* unexpanded key */
  35         ulong   ekey[4*(AESmaxrounds + 1)];     /* encryption key */
  36         ulong   dkey[4*(AESmaxrounds + 1)];     /* decryption key */
  37         uchar   ivec[AESbsize];                 /* initialization vector */
  38         uchar   mackey[3 * AESbsize];   /* 3 XCBC mac 96 keys */
  39 };
  40
  41 /* block ciphers */
  42 void    aes_encrypt(ulong rk[], int Nr, uchar pt[16], uchar ct[16]);
  43 void    aes_decrypt(ulong rk[], int Nr, uchar ct[16], uchar pt[16]);
  44
  45 void    setupAESstate(AESstate *s, uchar key[], int keybytes, uchar *ivec);
  46 void    aesCBCencrypt(uchar *p, int len, AESstate *s);
  47 void    aesCBCdecrypt(uchar *p, int len, AESstate *s);
  48
  49 void    setupAESXCBCstate(AESstate *s);
  50 uchar*  aesXCBCmac(uchar *p, int len, AESstate *s);
  51
  52 typedef struct AESGCMstate AESGCMstate;
  53 struct AESGCMstate
  54 {
  55         AESstate;
  56
  57         ulong   H[4];
  58         ulong   M[16][256][4];
  59 };
  60
  61 void    setupAESGCMstate(AESGCMstate *s, uchar *key, int keylen, uchar *iv, int ivlen);
  62 void    aesgcm_setiv(AESGCMstate *s, uchar *iv, int ivlen);
  63 void    aesgcm_encrypt(uchar *dat, ulong ndat, uchar *aad, ulong naad, uchar tag[16], AESGCMstate *s);
  64 int     aesgcm_decrypt(uchar *dat, ulong ndat, uchar *aad, ulong naad, uchar tag[16], AESGCMstate *s);
  65
  66 /*
  67  * Blowfish Definitions
  68  */
  69
  70 enum
  71 {
  72         BFbsize = 8,
  73         BFrounds= 16
  74 };
  75
  76 /* 16-round Blowfish */
  77 typedef struct BFstate BFstate;
  78 struct BFstate
  79 {
  80         ulong   setup;
  81
  82         uchar   key[56];
  83         uchar   ivec[8];
  84
  85         u32int  pbox[BFrounds+2];
  86         u32int  sbox[1024];
  87 };
  88
  89 void    setupBFstate(BFstate *s, uchar key[], int keybytes, uchar *ivec);
  90 void    bfCBCencrypt(uchar*, int, BFstate*);
  91 void    bfCBCdecrypt(uchar*, int, BFstate*);
  92 void    bfECBencrypt(uchar*, int, BFstate*);
  93 void    bfECBdecrypt(uchar*, int, BFstate*);
  94
  95 /*
  96  * Chacha definitions
  97  */
  98
  99 enum
 100 {
 101         ChachaBsize=    64,
 102         ChachaKeylen=   256/8,
 103         ChachaIVlen=    96/8,
 104 };
 105
 106 typedef struct Chachastate Chachastate;
 107 struct Chachastate
 108 {
 109         union{
 110                 u32int  input[16];
 111                 struct {
 112                         u32int  constant[4];
 113                         u32int  key[8];
 114                         u32int  counter;
 115                         u32int  iv[3];
 116                 };
 117         };
 118         int     rounds;
 119         int     ivwords;
 120 };
 121
 122 void    setupChachastate(Chachastate*, uchar*, ulong, uchar*, ulong, int);
 123 void    chacha_setiv(Chachastate *, uchar*);
 124 void    chacha_setblock(Chachastate*, u64int);
 125 void    chacha_encrypt(uchar*, ulong, Chachastate*);
 126 void    chacha_encrypt2(uchar*, uchar*, ulong, Chachastate*);
 127
 128 void    ccpoly_encrypt(uchar *dat, ulong ndat, uchar *aad, ulong naad, uchar tag[16], Chachastate *cs);
 129 int     ccpoly_decrypt(uchar *dat, ulong ndat, uchar *aad, ulong naad, uchar tag[16], Chachastate *cs);
 130
 131 /*
 132  * Salsa definitions
 133  */
 134 enum
 135 {
 136         SalsaBsize=     64,
 137         SalsaKeylen=    256/8,
 138         SalsaIVlen=     64/8,
 139         XSalsaIVlen=    192/8,
 140 };
 141
 142 typedef struct Salsastate Salsastate;
 143 struct Salsastate
 144 {
 145         u32int  input[16];
 146         u32int  key[8];
 147         int     rounds;
 148         int     ivwords;
 149 };
 150
 151 void    setupSalsastate(Salsastate*, uchar*, ulong, uchar*, ulong, int);
 152 void    salsa_setiv(Salsastate*, uchar*);
 153 void    salsa_setblock(Salsastate*, u64int);
 154 void    salsa_encrypt(uchar*, ulong, Salsastate*);
 155 void    salsa_encrypt2(uchar*, uchar*, ulong, Salsastate*);
 156
 157 void    hsalsa(uchar h[32], uchar *key, ulong keylen, uchar nonce[16], int rounds);
 158
 159 /*
 160  * DES definitions
 161  */
 162
 163 enum
 164 {
 165         DESbsize=       8
 166 };
 167
 168 /* single des */
 169 typedef struct DESstate DESstate;
 170 struct DESstate
 171 {
 172         ulong   setup;
 173         uchar   key[8];         /* unexpanded key */
 174         ulong   expanded[32];   /* expanded key */
 175         uchar   ivec[8];        /* initialization vector */
 176 };
 177
 178 void    setupDESstate(DESstate *s, uchar key[8], uchar *ivec);
 179 void    des_key_setup(uchar[8], ulong[32]);
 180 void    block_cipher(ulong*, uchar*, int);
 181 void    desCBCencrypt(uchar*, int, DESstate*);
 182 void    desCBCdecrypt(uchar*, int, DESstate*);
 183 void    desECBencrypt(uchar*, int, DESstate*);
 184 void    desECBdecrypt(uchar*, int, DESstate*);
 185
 186 /* for backward compatibility with 7-byte DES key format */
 187 void    des56to64(uchar *k56, uchar *k64);
 188 void    des64to56(uchar *k64, uchar *k56);
 189 void    key_setup(uchar[7], ulong[32]);
 190
 191 /* triple des encrypt/decrypt orderings */
 192 enum {
 193         DES3E=          0,
 194         DES3D=          1,
 195         DES3EEE=        0,
 196         DES3EDE=        2,
 197         DES3DED=        5,
 198         DES3DDD=        7
 199 };
 200
 201 typedef struct DES3state DES3state;
 202 struct DES3state
 203 {
 204         ulong   setup;
 205         uchar   key[3][8];              /* unexpanded key */
 206         ulong   expanded[3][32];        /* expanded key */
 207         uchar   ivec[8];                /* initialization vector */
 208 };
 209
 210 void    setupDES3state(DES3state *s, uchar key[3][8], uchar *ivec);
 211 void    triple_block_cipher(ulong keys[3][32], uchar*, int);
 212 void    des3CBCencrypt(uchar*, int, DES3state*);
 213 void    des3CBCdecrypt(uchar*, int, DES3state*);
 214 void    des3ECBencrypt(uchar*, int, DES3state*);
 215 void    des3ECBdecrypt(uchar*, int, DES3state*);
 216
 217 /*
 218  * digests
 219  */
 220
 221 enum
 222 {
 223         SHA1dlen=       20,     /* SHA digest length */
 224         SHA2_224dlen=   28,     /* SHA-224 digest length */
 225         SHA2_256dlen=   32,     /* SHA-256 digest length */
 226         SHA2_384dlen=   48,     /* SHA-384 digest length */
 227         SHA2_512dlen=   64,     /* SHA-512 digest length */
 228         MD4dlen=        16,     /* MD4 digest length */
 229         MD5dlen=        16,     /* MD5 digest length */
 230         Poly1305dlen=   16,     /* Poly1305 digest length */
 231
 232         Hmacblksz       = 64,   /* in bytes; from rfc2104 */
 233 };
 234
 235 typedef struct DigestState DigestState;
 236 struct DigestState
 237 {
 238         uvlong  len;
 239         union {
 240                 u32int  state[16];
 241                 u64int  bstate[8];
 242         };
 243         uchar   buf[256];
 244         int     blen;
 245         char    malloced;
 246         char    seeded;
 247 };
 248 typedef struct DigestState SHAstate;    /* obsolete name */
 249 typedef struct DigestState SHA1state;
 250 typedef struct DigestState SHA2_224state;
 251 typedef struct DigestState SHA2_256state;
 252 typedef struct DigestState SHA2_384state;
 253 typedef struct DigestState SHA2_512state;
 254 typedef struct DigestState MD5state;
 255 typedef struct DigestState MD4state;
 256
 257 DigestState*    md4(uchar*, ulong, uchar*, DigestState*);
 258 DigestState*    md5(uchar*, ulong, uchar*, DigestState*);
 259 DigestState*    sha1(uchar*, ulong, uchar*, DigestState*);
 260 DigestState*    sha2_224(uchar*, ulong, uchar*, DigestState*);
 261 DigestState*    sha2_256(uchar*, ulong, uchar*, DigestState*);
 262 DigestState*    sha2_384(uchar*, ulong, uchar*, DigestState*);
 263 DigestState*    sha2_512(uchar*, ulong, uchar*, DigestState*);
 264 DigestState*    hmac_x(uchar *p, ulong len, uchar *key, ulong klen,
 265                         uchar *digest, DigestState *s,
 266                         DigestState*(*x)(uchar*, ulong, uchar*, DigestState*),
 267                         int xlen);
 268 DigestState*    hmac_md5(uchar*, ulong, uchar*, ulong, uchar*, DigestState*);
 269 DigestState*    hmac_sha1(uchar*, ulong, uchar*, ulong, uchar*, DigestState*);
 270 DigestState*    hmac_sha2_224(uchar*, ulong, uchar*, ulong, uchar*, DigestState*);
 271 DigestState*    hmac_sha2_256(uchar*, ulong, uchar*, ulong, uchar*, DigestState*);
 272 DigestState*    hmac_sha2_384(uchar*, ulong, uchar*, ulong, uchar*, DigestState*);
 273 DigestState*    hmac_sha2_512(uchar*, ulong, uchar*, ulong, uchar*, DigestState*);
 274 char*           md5pickle(MD5state*);
 275 MD5state*       md5unpickle(char*);
 276 char*           sha1pickle(SHA1state*);
 277 SHA1state*      sha1unpickle(char*);
 278
 279 DigestState*    poly1305(uchar*, ulong, uchar*, ulong, uchar*, DigestState*);
 280
 281 /*
 282  * random number generation
 283  */
 284 void    genrandom(uchar *buf, int nbytes);
 285 void    prng(uchar *buf, int nbytes);
 286 ulong   fastrand(void);
 287 ulong   nfastrand(ulong);
 288
 289 /*
 290  * primes
 291  */
 292 void    genprime(mpint *p, int n, int accuracy); /* generate n-bit probable prime */
 293 void    gensafeprime(mpint *p, mpint *alpha, int n, int accuracy); /* prime & generator */
 294 void    genstrongprime(mpint *p, int n, int accuracy); /* generate n-bit strong prime */
 295 void    DSAprimes(mpint *q, mpint *p, uchar seed[SHA1dlen]);
 296 int     probably_prime(mpint *n, int nrep);     /* miller-rabin test */
 297 int     smallprimetest(mpint *p);  /* returns -1 if not prime, 0 otherwise */
 298
 299 /*
 300  * rc4
 301  */
 302 typedef struct RC4state RC4state;
 303 struct RC4state
 304 {
 305          uchar  state[256];
 306          uchar  x;
 307          uchar  y;
 308 };
 309
 310 void    setupRC4state(RC4state*, uchar*, int);
 311 void    rc4(RC4state*, uchar*, int);
 312 void    rc4skip(RC4state*, int);
 313 void    rc4back(RC4state*, int);
 314
 315 /*
 316  * rsa
 317  */
 318 typedef struct RSApub RSApub;
 319 typedef struct RSApriv RSApriv;
 320 typedef struct PEMChain PEMChain;
 321
 322 /* public/encryption key */
 323 struct RSApub
 324 {
 325         mpint   *n;     /* modulus */
 326         mpint   *ek;    /* exp (encryption key) */
 327 };
 328
 329 /* private/decryption key */
 330 struct RSApriv
 331 {
 332         RSApub  pub;
 333
 334         mpint   *dk;    /* exp (decryption key) */
 335
 336         /* precomputed values to help with chinese remainder theorem calc */
 337         mpint   *p;
 338         mpint   *q;
 339         mpint   *kp;    /* dk mod p-1 */
 340         mpint   *kq;    /* dk mod q-1 */
 341         mpint   *c2;    /* (inv p) mod q */
 342 };
 343
 344 struct PEMChain{
 345         PEMChain*next;
 346         uchar   *pem;
 347         int     pemlen;
 348 };
 349
 350 RSApriv*        rsagen(int nlen, int elen, int rounds);
 351 RSApriv*        rsafill(mpint *n, mpint *e, mpint *d, mpint *p, mpint *q);
 352 mpint*          rsaencrypt(RSApub *k, mpint *in, mpint *out);
 353 mpint*          rsadecrypt(RSApriv *k, mpint *in, mpint *out);
 354 RSApub*         rsapuballoc(void);
 355 void            rsapubfree(RSApub*);
 356 RSApriv*        rsaprivalloc(void);
 357 void            rsaprivfree(RSApriv*);
 358 RSApub*         rsaprivtopub(RSApriv*);
 359 RSApub*         X509toRSApub(uchar*, int, char*, int);
 360 RSApriv*        asn1toRSApriv(uchar*, int);
 361 void            asn1dump(uchar *der, int len);
 362 uchar*          decodePEM(char *s, char *type, int *len, char **new_s);
 363 PEMChain*       decodepemchain(char *s, char *type);
 364 uchar*          X509rsagen(RSApriv *priv, char *subj, ulong valid[2], int *certlen);
 365 uchar*          X509rsareq(RSApriv *priv, char *subj, int *certlen);
 366 char*           X509rsaverifydigest(uchar *sig, int siglen, uchar *edigest, int edigestlen, RSApub *pk);
 367 char*           X509rsaverify(uchar *cert, int ncert, RSApub *pk);
 368
 369 void            X509dump(uchar *cert, int ncert);
 370
 371 /*
 372  * elgamal
 373  */
 374 typedef struct EGpub EGpub;
 375 typedef struct EGpriv EGpriv;
 376 typedef struct EGsig EGsig;
 377
 378 /* public/encryption key */
 379 struct EGpub
 380 {
 381         mpint   *p;     /* modulus */
 382         mpint   *alpha; /* generator */
 383         mpint   *key;   /* (encryption key) alpha**secret mod p */
 384 };
 385
 386 /* private/decryption key */
 387 struct EGpriv
 388 {
 389         EGpub   pub;
 390         mpint   *secret;        /* (decryption key) */
 391 };
 392
 393 /* signature */
 394 struct EGsig
 395 {
 396         mpint   *r, *s;
 397 };
 398
 399 EGpriv*         eggen(int nlen, int rounds);
 400 mpint*          egencrypt(EGpub *k, mpint *in, mpint *out);     /* deprecated */
 401 mpint*          egdecrypt(EGpriv *k, mpint *in, mpint *out);
 402 EGsig*          egsign(EGpriv *k, mpint *m);
 403 int             egverify(EGpub *k, EGsig *sig, mpint *m);
 404 EGpub*          egpuballoc(void);
 405 void            egpubfree(EGpub*);
 406 EGpriv*         egprivalloc(void);
 407 void            egprivfree(EGpriv*);
 408 EGsig*          egsigalloc(void);
 409 void            egsigfree(EGsig*);
 410 EGpub*          egprivtopub(EGpriv*);
 411
 412 /*
 413  * dsa
 414  */
 415 typedef struct DSApub DSApub;
 416 typedef struct DSApriv DSApriv;
 417 typedef struct DSAsig DSAsig;
 418
 419 /* public/encryption key */
 420 struct DSApub
 421 {
 422         mpint   *p;     /* modulus */
 423         mpint   *q;     /* group order, q divides p-1 */
 424         mpint   *alpha; /* group generator */
 425         mpint   *key;   /* (encryption key) alpha**secret mod p */
 426 };
 427
 428 /* private/decryption key */
 429 struct DSApriv
 430 {
 431         DSApub  pub;
 432         mpint   *secret;        /* (decryption key) */
 433 };
 434
 435 /* signature */
 436 struct DSAsig
 437 {
 438         mpint   *r, *s;
 439 };
 440
 441 DSApriv*        dsagen(DSApub *opub);   /* opub not checked for consistency! */
 442 DSAsig*         dsasign(DSApriv *k, mpint *m);
 443 int             dsaverify(DSApub *k, DSAsig *sig, mpint *m);
 444 DSApub*         dsapuballoc(void);
 445 void            dsapubfree(DSApub*);
 446 DSApriv*        dsaprivalloc(void);
 447 void            dsaprivfree(DSApriv*);
 448 DSAsig*         dsasigalloc(void);
 449 void            dsasigfree(DSAsig*);
 450 DSApub*         dsaprivtopub(DSApriv*);
 451 DSApriv*        asn1toDSApriv(uchar*, int);
 452
 453 /*
 454  * TLS
 455  */
 456 typedef struct Thumbprint{
 457         struct Thumbprint *next;
 458         uchar   sha1[SHA1dlen];
 459 } Thumbprint;
 460
 461 typedef struct TLSconn{
 462         char    dir[40];        /* connection directory */
 463         uchar   *cert;  /* certificate (local on input, remote on output) */
 464         uchar   *sessionID;
 465         uchar   *psk;
 466         int     certlen;
 467         int     sessionIDlen;
 468         int     psklen;
 469         int     (*trace)(char*fmt, ...);
 470         PEMChain*chain; /* optional extra certificate evidence for servers to present */
 471         char    *sessionType;
 472         uchar   *sessionKey;
 473         int     sessionKeylen;
 474         char    *sessionConst;
 475         char    *serverName;
 476         char    *pskID;
 477 } TLSconn;
 478
 479 /* tlshand.c */
 480 int tlsClient(int fd, TLSconn *c);
 481 int tlsServer(int fd, TLSconn *c);
 482
 483 /* thumb.c */
 484 Thumbprint* initThumbprints(char *ok, char *crl);
 485 void    freeThumbprints(Thumbprint *ok);
 486 int     okThumbprint(uchar *sha1, Thumbprint *ok);
 487
 488 /* readcert.c */
 489 uchar   *readcert(char *filename, int *pcertlen);
 490 PEMChain*readcertchain(char *filename);
 491
 492 /* aes_xts.c */
 493 int aes_xts_encrypt(ulong tweak[], ulong ecb[],  vlong sectorNumber, uchar *input, uchar *output, ulong len) ;
 494 int aes_xts_decrypt(ulong tweak[], ulong ecb[], vlong sectorNumber, uchar *input, uchar *output, ulong len);
 495
 496 typedef struct ECpoint{
 497         int inf;
 498         mpint *x;
 499         mpint *y;
 500         mpint *z;       /* nil when using affine coordinates */
 501 } ECpoint;
 502
 503 typedef ECpoint ECpub;
 504 typedef struct ECpriv{
 505         ECpoint;
 506         mpint *d;
 507 } ECpriv;
 508
 509 typedef struct ECdomain{
 510         mpint *p;
 511         mpint *a;
 512         mpint *b;
 513         ECpoint G;
 514         mpint *n;
 515         mpint *h;
 516 } ECdomain;
 517
 518 void    ecdominit(ECdomain *, void (*init)(mpint *p, mpint *a, mpint *b, mpint *x, mpint *y, mpint *n, mpint *h));
 519 void    ecdomfree(ECdomain *);
 520
 521 void    ecassign(ECdomain *, ECpoint *old, ECpoint *new);
 522 void    ecadd(ECdomain *, ECpoint *a, ECpoint *b, ECpoint *s);
 523 void    ecmul(ECdomain *, ECpoint *a, mpint *k, ECpoint *s);
 524 ECpoint*        strtoec(ECdomain *, char *, char **, ECpoint *);
 525 ECpriv* ecgen(ECdomain *, ECpriv*);
 526 int     ecverify(ECdomain *, ECpoint *);
 527 int     ecpubverify(ECdomain *, ECpub *);
 528 void    ecdsasign(ECdomain *, ECpriv *, uchar *, int, mpint *, mpint *);
 529 int     ecdsaverify(ECdomain *, ECpub *, uchar *, int, mpint *, mpint *);
 530 void    base58enc(uchar *, char *, int);
 531 int     base58dec(char *, uchar *, int);
 532
 533 ECpub*  ecdecodepub(ECdomain *dom, uchar *, int);
 534 int     ecencodepub(ECdomain *dom, ECpub *, uchar *, int);
 535 void    ecpubfree(ECpub *);
 536
 537 ECpub*  X509toECpub(uchar *cert, int ncert, ECdomain *dom);
 538 char*   X509ecdsaverifydigest(uchar *sig, int siglen, uchar *edigest, int edigestlen, ECdomain *dom, ECpub *pub);
 539 char*   X509ecdsaverify(uchar *sig, int siglen, ECdomain *dom, ECpub *pub);
 540
 541 /* curves */
 542 void    secp256r1(mpint *p, mpint *a, mpint *b, mpint *x, mpint *y, mpint *n, mpint *h);
 543 void    secp256k1(mpint *p, mpint *a, mpint *b, mpint *x, mpint *y, mpint *n, mpint *h);
 544
 545 DigestState*    ripemd160(uchar *, ulong, uchar *, DigestState *);
 546
 547 /*
 548  * Diffie-Hellman key exchange
 549  */
 550
 551 typedef struct DHstate DHstate;
 552 struct DHstate
 553 {
 554         mpint   *g;     /* base g */
 555         mpint   *p;     /* large prime */
 556         mpint   *q;     /* subgroup prime */
 557         mpint   *x;     /* random secret */
 558         mpint   *y;     /* public key y = g**x % p */
 559 };
 560
 561 /* generate new public key: y = g**x % p */
 562 mpint* dh_new(DHstate *dh, mpint *p, mpint *q, mpint *g);
 563
 564 /* calculate shared key: k = y**x % p */
 565 mpint* dh_finish(DHstate *dh, mpint *y);
 566
 567 /* Curve25519 elliptic curve, public key function */
 568 void curve25519(uchar mypublic[32], uchar secret[32], uchar basepoint[32]);
 569
 570 /* Curve25519 diffie hellman */
 571 void curve25519_dh_new(uchar x[32], uchar y[32]);
 572 void curve25519_dh_finish(uchar x[32], uchar y[32], uchar z[32]);
 573
 574 /* password-based key derivation function 2 (rfc2898) */
 575 void pbkdf2_x(uchar *p, ulong plen, uchar *s, ulong slen, ulong rounds, uchar *d, ulong dlen,
 576         DigestState* (*x)(uchar*, ulong, uchar*, ulong, uchar*, DigestState*), int xlen);
 577
 578 /* hmac-based key derivation function (rfc5869) */
 579 void hkdf_x(uchar *salt, ulong nsalt, uchar *info, ulong ninfo, uchar *key, ulong nkey, uchar *d, ulong dlen,
 580         DigestState* (*x)(uchar*, ulong, uchar*, ulong, uchar*, DigestState*), int xlen);
 581
 582 /* timing safe memcmp() */
 583 int tsmemcmp(void*, void*, ulong);
 584
 585 #endif