sys/include/libsec.h

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