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