1 /* 2 * crypto.h - public data structures and prototypes for the crypto library 3 * 4 * ***** BEGIN LICENSE BLOCK ***** 5 * Version: MPL 1.1/GPL 2.0/LGPL 2.1 6 * 7 * The contents of this file are subject to the Mozilla Public License Version 8 * 1.1 (the "License"); you may not use this file except in compliance with 9 * the License. You may obtain a copy of the License at 10 * http://www.mozilla.org/MPL/ 11 * 12 * Software distributed under the License is distributed on an "AS IS" basis, 13 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License 14 * for the specific language governing rights and limitations under the 15 * License. 16 * 17 * The Original Code is the Netscape security libraries. 18 * 19 * The Initial Developer of the Original Code is 20 * Netscape Communications Corporation. 21 * Portions created by the Initial Developer are Copyright (C) 1994-2000 22 * the Initial Developer. All Rights Reserved. 23 * 24 * Contributor(s): 25 * Dr Vipul Gupta <vipul.gupta (at) sun.com>, Sun Microsystems Laboratories 26 * 27 * Alternatively, the contents of this file may be used under the terms of 28 * either the GNU General Public License Version 2 or later (the "GPL"), or 29 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), 30 * in which case the provisions of the GPL or the LGPL are applicable instead 31 * of those above. If you wish to allow use of your version of this file only 32 * under the terms of either the GPL or the LGPL, and not to allow others to 33 * use your version of this file under the terms of the MPL, indicate your 34 * decision by deleting the provisions above and replace them with the notice 35 * and other provisions required by the GPL or the LGPL. If you do not delete 36 * the provisions above, a recipient may use your version of this file under 37 * the terms of any one of the MPL, the GPL or the LGPL. 38 * 39 * ***** END LICENSE BLOCK ***** */ 40 /* $Id: blapi.h,v 1.33 2009/03/29 03:45:32 wtc%google.com Exp $ */ 41 42 #ifndef _BLAPI_H_ 43 #define _BLAPI_H_ 44 45 #include "blapit.h" 46 #include "hasht.h" 47 #include "alghmac.h" 48 49 SEC_BEGIN_PROTOS 50 51 /* 52 ** RSA encryption/decryption. When encrypting/decrypting the output 53 ** buffer must be at least the size of the public key modulus. 54 */ 55 56 extern SECStatus BL_Init(void); 57 58 /* 59 ** Generate and return a new RSA public and private key. 60 ** Both keys are encoded in a single RSAPrivateKey structure. 61 ** "cx" is the random number generator context 62 ** "keySizeInBits" is the size of the key to be generated, in bits. 63 ** 512, 1024, etc. 64 ** "publicExponent" when not NULL is a pointer to some data that 65 ** represents the public exponent to use. The data is a byte 66 ** encoded integer, in "big endian" order. 67 */ 68 extern RSAPrivateKey *RSA_NewKey(int keySizeInBits, 69 SECItem * publicExponent); 70 71 /* 72 ** Perform a raw public-key operation 73 ** Length of input and output buffers are equal to key's modulus len. 74 */ 75 extern SECStatus RSA_PublicKeyOp(RSAPublicKey * key, 76 unsigned char * output, 77 const unsigned char * input); 78 79 /* 80 ** Perform a raw private-key operation 81 ** Length of input and output buffers are equal to key's modulus len. 82 */ 83 extern SECStatus RSA_PrivateKeyOp(RSAPrivateKey * key, 84 unsigned char * output, 85 const unsigned char * input); 86 87 /* 88 ** Perform a raw private-key operation, and check the parameters used in 89 ** the operation for validity by performing a test operation first. 90 ** Length of input and output buffers are equal to key's modulus len. 91 */ 92 extern SECStatus RSA_PrivateKeyOpDoubleChecked(RSAPrivateKey * key, 93 unsigned char * output, 94 const unsigned char * input); 95 96 /* 97 ** Perform a check of private key parameters for consistency. 98 */ 99 extern SECStatus RSA_PrivateKeyCheck(RSAPrivateKey *key); 100 101 102 /******************************************************************** 103 ** DSA signing algorithm 104 */ 105 106 /* 107 ** Generate and return a new DSA public and private key pair, 108 ** both of which are encoded into a single DSAPrivateKey struct. 109 ** "params" is a pointer to the PQG parameters for the domain 110 ** Uses a random seed. 111 */ 112 extern SECStatus DSA_NewKey(const PQGParams * params, 113 DSAPrivateKey ** privKey); 114 115 /* signature is caller-supplied buffer of at least 20 bytes. 116 ** On input, signature->len == size of buffer to hold signature. 117 ** digest->len == size of digest. 118 ** On output, signature->len == size of signature in buffer. 119 ** Uses a random seed. 120 */ 121 extern SECStatus DSA_SignDigest(DSAPrivateKey * key, 122 SECItem * signature, 123 const SECItem * digest); 124 125 /* signature is caller-supplied buffer of at least 20 bytes. 126 ** On input, signature->len == size of buffer to hold signature. 127 ** digest->len == size of digest. 128 */ 129 extern SECStatus DSA_VerifyDigest(DSAPublicKey * key, 130 const SECItem * signature, 131 const SECItem * digest); 132 133 /* For FIPS compliance testing. Seed must be exactly 20 bytes long */ 134 extern SECStatus DSA_NewKeyFromSeed(const PQGParams *params, 135 const unsigned char * seed, 136 DSAPrivateKey **privKey); 137 138 /* For FIPS compliance testing. Seed must be exactly 20 bytes. */ 139 extern SECStatus DSA_SignDigestWithSeed(DSAPrivateKey * key, 140 SECItem * signature, 141 const SECItem * digest, 142 const unsigned char * seed); 143 144 /****************************************************** 145 ** Diffie Helman key exchange algorithm 146 */ 147 148 /* Generates parameters for Diffie-Helman key generation. 149 ** primeLen is the length in bytes of prime P to be generated. 150 */ 151 extern SECStatus DH_GenParam(int primeLen, DHParams ** params); 152 153 /* Generates a public and private key, both of which are encoded in a single 154 ** DHPrivateKey struct. Params is input, privKey are output. 155 ** This is Phase 1 of Diffie Hellman. 156 */ 157 extern SECStatus DH_NewKey(DHParams * params, 158 DHPrivateKey ** privKey); 159 160 /* 161 ** DH_Derive does the Diffie-Hellman phase 2 calculation, using the 162 ** other party's publicValue, and the prime and our privateValue. 163 ** maxOutBytes is the requested length of the generated secret in bytes. 164 ** A zero value means produce a value of any length up to the size of 165 ** the prime. If successful, derivedSecret->data is set 166 ** to the address of the newly allocated buffer containing the derived 167 ** secret, and derivedSecret->len is the size of the secret produced. 168 ** The size of the secret produced will never be larger than the length 169 ** of the prime, and it may be smaller than maxOutBytes. 170 ** It is the caller's responsibility to free the allocated buffer 171 ** containing the derived secret. 172 */ 173 extern SECStatus DH_Derive(SECItem * publicValue, 174 SECItem * prime, 175 SECItem * privateValue, 176 SECItem * derivedSecret, 177 unsigned int maxOutBytes); 178 179 /* 180 ** KEA_CalcKey returns octet string with the private key for a dual 181 ** Diffie-Helman key generation as specified for government key exchange. 182 */ 183 extern SECStatus KEA_Derive(SECItem *prime, 184 SECItem *public1, 185 SECItem *public2, 186 SECItem *private1, 187 SECItem *private2, 188 SECItem *derivedSecret); 189 190 /* 191 * verify that a KEA or DSA public key is a valid key for this prime and 192 * subprime domain. 193 */ 194 extern PRBool KEA_Verify(SECItem *Y, SECItem *prime, SECItem *subPrime); 195 196 /****************************************************** 197 ** Elliptic Curve algorithms 198 */ 199 200 /* Generates a public and private key, both of which are encoded 201 ** in a single ECPrivateKey struct. Params is input, privKey are 202 ** output. 203 */ 204 extern SECStatus EC_NewKey(ECParams * params, 205 ECPrivateKey ** privKey); 206 207 extern SECStatus EC_NewKeyFromSeed(ECParams * params, 208 ECPrivateKey ** privKey, 209 const unsigned char* seed, 210 int seedlen); 211 212 /* Validates an EC public key as described in Section 5.2.2 of 213 * X9.62. Such validation prevents against small subgroup attacks 214 * when the ECDH primitive is used with the cofactor. 215 */ 216 extern SECStatus EC_ValidatePublicKey(ECParams * params, 217 SECItem * publicValue); 218 219 /* 220 ** ECDH_Derive performs a scalar point multiplication of a point 221 ** representing a (peer's) public key and a large integer representing 222 ** a private key (its own). Both keys must use the same elliptic curve 223 ** parameters. If the withCofactor parameter is true, the 224 ** multiplication also uses the cofactor associated with the curve 225 ** parameters. The output of this scheme is the x-coordinate of the 226 ** resulting point. If successful, derivedSecret->data is set to the 227 ** address of the newly allocated buffer containing the derived 228 ** secret, and derivedSecret->len is the size of the secret 229 ** produced. It is the caller's responsibility to free the allocated 230 ** buffer containing the derived secret. 231 */ 232 extern SECStatus ECDH_Derive(SECItem * publicValue, 233 ECParams * params, 234 SECItem * privateValue, 235 PRBool withCofactor, 236 SECItem * derivedSecret); 237 238 /* On input, signature->len == size of buffer to hold signature. 239 ** digest->len == size of digest. 240 ** On output, signature->len == size of signature in buffer. 241 ** Uses a random seed. 242 */ 243 extern SECStatus ECDSA_SignDigest(ECPrivateKey *key, 244 SECItem *signature, 245 const SECItem *digest); 246 247 /* On input, signature->len == size of buffer to hold signature. 248 ** digest->len == size of digest. 249 */ 250 extern SECStatus ECDSA_VerifyDigest(ECPublicKey *key, 251 const SECItem *signature, 252 const SECItem *digest); 253 254 /* Uses the provided seed. */ 255 extern SECStatus ECDSA_SignDigestWithSeed(ECPrivateKey *key, 256 SECItem *signature, 257 const SECItem *digest, 258 const unsigned char *seed, 259 const int seedlen); 260 261 /******************************************/ 262 /* 263 ** RC4 symmetric stream cypher 264 */ 265 266 /* 267 ** Create a new RC4 context suitable for RC4 encryption/decryption. 268 ** "key" raw key data 269 ** "len" the number of bytes of key data 270 */ 271 extern RC4Context *RC4_CreateContext(const unsigned char *key, int len); 272 273 extern RC4Context *RC4_AllocateContext(void); 274 extern SECStatus RC4_InitContext(RC4Context *cx, 275 const unsigned char *key, 276 unsigned int keylen, 277 const unsigned char *, 278 int, 279 unsigned int , 280 unsigned int ); 281 282 /* 283 ** Destroy an RC4 encryption/decryption context. 284 ** "cx" the context 285 ** "freeit" if PR_TRUE then free the object as well as its sub-objects 286 */ 287 extern void RC4_DestroyContext(RC4Context *cx, PRBool freeit); 288 289 /* 290 ** Perform RC4 encryption. 291 ** "cx" the context 292 ** "output" the output buffer to store the encrypted data. 293 ** "outputLen" how much data is stored in "output". Set by the routine 294 ** after some data is stored in output. 295 ** "maxOutputLen" the maximum amount of data that can ever be 296 ** stored in "output" 297 ** "input" the input data 298 ** "inputLen" the amount of input data 299 */ 300 extern SECStatus RC4_Encrypt(RC4Context *cx, unsigned char *output, 301 unsigned int *outputLen, unsigned int maxOutputLen, 302 const unsigned char *input, unsigned int inputLen); 303 304 /* 305 ** Perform RC4 decryption. 306 ** "cx" the context 307 ** "output" the output buffer to store the decrypted data. 308 ** "outputLen" how much data is stored in "output". Set by the routine 309 ** after some data is stored in output. 310 ** "maxOutputLen" the maximum amount of data that can ever be 311 ** stored in "output" 312 ** "input" the input data 313 ** "inputLen" the amount of input data 314 */ 315 extern SECStatus RC4_Decrypt(RC4Context *cx, unsigned char *output, 316 unsigned int *outputLen, unsigned int maxOutputLen, 317 const unsigned char *input, unsigned int inputLen); 318 319 /******************************************/ 320 /* 321 ** RC2 symmetric block cypher 322 */ 323 324 /* 325 ** Create a new RC2 context suitable for RC2 encryption/decryption. 326 ** "key" raw key data 327 ** "len" the number of bytes of key data 328 ** "iv" is the CBC initialization vector (if mode is NSS_RC2_CBC) 329 ** "mode" one of NSS_RC2 or NSS_RC2_CBC 330 ** "effectiveKeyLen" is the effective key length (as specified in 331 ** RFC 2268) in bytes (not bits). 332 ** 333 ** When mode is set to NSS_RC2_CBC the RC2 cipher is run in "cipher block 334 ** chaining" mode. 335 */ 336 extern RC2Context *RC2_CreateContext(const unsigned char *key, unsigned int len, 337 const unsigned char *iv, int mode, 338 unsigned effectiveKeyLen); 339 extern RC2Context *RC2_AllocateContext(void); 340 extern SECStatus RC2_InitContext(RC2Context *cx, 341 const unsigned char *key, 342 unsigned int keylen, 343 const unsigned char *iv, 344 int mode, 345 unsigned int effectiveKeyLen, 346 unsigned int ); 347 348 /* 349 ** Destroy an RC2 encryption/decryption context. 350 ** "cx" the context 351 ** "freeit" if PR_TRUE then free the object as well as its sub-objects 352 */ 353 extern void RC2_DestroyContext(RC2Context *cx, PRBool freeit); 354 355 /* 356 ** Perform RC2 encryption. 357 ** "cx" the context 358 ** "output" the output buffer to store the encrypted data. 359 ** "outputLen" how much data is stored in "output". Set by the routine 360 ** after some data is stored in output. 361 ** "maxOutputLen" the maximum amount of data that can ever be 362 ** stored in "output" 363 ** "input" the input data 364 ** "inputLen" the amount of input data 365 */ 366 extern SECStatus RC2_Encrypt(RC2Context *cx, unsigned char *output, 367 unsigned int *outputLen, unsigned int maxOutputLen, 368 const unsigned char *input, unsigned int inputLen); 369 370 /* 371 ** Perform RC2 decryption. 372 ** "cx" the context 373 ** "output" the output buffer to store the decrypted data. 374 ** "outputLen" how much data is stored in "output". Set by the routine 375 ** after some data is stored in output. 376 ** "maxOutputLen" the maximum amount of data that can ever be 377 ** stored in "output" 378 ** "input" the input data 379 ** "inputLen" the amount of input data 380 */ 381 extern SECStatus RC2_Decrypt(RC2Context *cx, unsigned char *output, 382 unsigned int *outputLen, unsigned int maxOutputLen, 383 const unsigned char *input, unsigned int inputLen); 384 385 /******************************************/ 386 /* 387 ** RC5 symmetric block cypher -- 64-bit block size 388 */ 389 390 /* 391 ** Create a new RC5 context suitable for RC5 encryption/decryption. 392 ** "key" raw key data 393 ** "len" the number of bytes of key data 394 ** "iv" is the CBC initialization vector (if mode is NSS_RC5_CBC) 395 ** "mode" one of NSS_RC5 or NSS_RC5_CBC 396 ** 397 ** When mode is set to NSS_RC5_CBC the RC5 cipher is run in "cipher block 398 ** chaining" mode. 399 */ 400 extern RC5Context *RC5_CreateContext(const SECItem *key, unsigned int rounds, 401 unsigned int wordSize, const unsigned char *iv, int mode); 402 extern RC5Context *RC5_AllocateContext(void); 403 extern SECStatus RC5_InitContext(RC5Context *cx, 404 const unsigned char *key, 405 unsigned int keylen, 406 const unsigned char *iv, 407 int mode, 408 unsigned int rounds, 409 unsigned int wordSize); 410 411 /* 412 ** Destroy an RC5 encryption/decryption context. 413 ** "cx" the context 414 ** "freeit" if PR_TRUE then free the object as well as its sub-objects 415 */ 416 extern void RC5_DestroyContext(RC5Context *cx, PRBool freeit); 417 418 /* 419 ** Perform RC5 encryption. 420 ** "cx" the context 421 ** "output" the output buffer to store the encrypted data. 422 ** "outputLen" how much data is stored in "output". Set by the routine 423 ** after some data is stored in output. 424 ** "maxOutputLen" the maximum amount of data that can ever be 425 ** stored in "output" 426 ** "input" the input data 427 ** "inputLen" the amount of input data 428 */ 429 extern SECStatus RC5_Encrypt(RC5Context *cx, unsigned char *output, 430 unsigned int *outputLen, unsigned int maxOutputLen, 431 const unsigned char *input, unsigned int inputLen); 432 433 /* 434 ** Perform RC5 decryption. 435 ** "cx" the context 436 ** "output" the output buffer to store the decrypted data. 437 ** "outputLen" how much data is stored in "output". Set by the routine 438 ** after some data is stored in output. 439 ** "maxOutputLen" the maximum amount of data that can ever be 440 ** stored in "output" 441 ** "input" the input data 442 ** "inputLen" the amount of input data 443 */ 444 445 extern SECStatus RC5_Decrypt(RC5Context *cx, unsigned char *output, 446 unsigned int *outputLen, unsigned int maxOutputLen, 447 const unsigned char *input, unsigned int inputLen); 448 449 450 451 /******************************************/ 452 /* 453 ** DES symmetric block cypher 454 */ 455 456 /* 457 ** Create a new DES context suitable for DES encryption/decryption. 458 ** "key" raw key data 459 ** "len" the number of bytes of key data 460 ** "iv" is the CBC initialization vector (if mode is NSS_DES_CBC or 461 ** mode is DES_EDE3_CBC) 462 ** "mode" one of NSS_DES, NSS_DES_CBC, NSS_DES_EDE3 or NSS_DES_EDE3_CBC 463 ** "encrypt" is PR_TRUE if the context will be used for encryption 464 ** 465 ** When mode is set to NSS_DES_CBC or NSS_DES_EDE3_CBC then the DES 466 ** cipher is run in "cipher block chaining" mode. 467 */ 468 extern DESContext *DES_CreateContext(const unsigned char *key, 469 const unsigned char *iv, 470 int mode, PRBool encrypt); 471 extern DESContext *DES_AllocateContext(void); 472 extern SECStatus DES_InitContext(DESContext *cx, 473 const unsigned char *key, 474 unsigned int keylen, 475 const unsigned char *iv, 476 int mode, 477 unsigned int encrypt, 478 unsigned int ); 479 480 /* 481 ** Destroy an DES encryption/decryption context. 482 ** "cx" the context 483 ** "freeit" if PR_TRUE then free the object as well as its sub-objects 484 */ 485 extern void DES_DestroyContext(DESContext *cx, PRBool freeit); 486 487 /* 488 ** Perform DES encryption. 489 ** "cx" the context 490 ** "output" the output buffer to store the encrypted data. 491 ** "outputLen" how much data is stored in "output". Set by the routine 492 ** after some data is stored in output. 493 ** "maxOutputLen" the maximum amount of data that can ever be 494 ** stored in "output" 495 ** "input" the input data 496 ** "inputLen" the amount of input data 497 ** 498 ** NOTE: the inputLen must be a multiple of DES_KEY_LENGTH 499 */ 500 extern SECStatus DES_Encrypt(DESContext *cx, unsigned char *output, 501 unsigned int *outputLen, unsigned int maxOutputLen, 502 const unsigned char *input, unsigned int inputLen); 503 504 /* 505 ** Perform DES decryption. 506 ** "cx" the context 507 ** "output" the output buffer to store the decrypted data. 508 ** "outputLen" how much data is stored in "output". Set by the routine 509 ** after some data is stored in output. 510 ** "maxOutputLen" the maximum amount of data that can ever be 511 ** stored in "output" 512 ** "input" the input data 513 ** "inputLen" the amount of input data 514 ** 515 ** NOTE: the inputLen must be a multiple of DES_KEY_LENGTH 516 */ 517 extern SECStatus DES_Decrypt(DESContext *cx, unsigned char *output, 518 unsigned int *outputLen, unsigned int maxOutputLen, 519 const unsigned char *input, unsigned int inputLen); 520 521 /******************************************/ 522 /* 523 ** SEED symmetric block cypher 524 */ 525 extern SEEDContext * 526 SEED_CreateContext(const unsigned char *key, const unsigned char *iv, 527 int mode, PRBool encrypt); 528 extern SEEDContext *SEED_AllocateContext(void); 529 extern SECStatus SEED_InitContext(SEEDContext *cx, 530 const unsigned char *key, 531 unsigned int keylen, 532 const unsigned char *iv, 533 int mode, unsigned int encrypt, 534 unsigned int ); 535 extern void SEED_DestroyContext(SEEDContext *cx, PRBool freeit); 536 extern SECStatus 537 SEED_Encrypt(SEEDContext *cx, unsigned char *output, 538 unsigned int *outputLen, unsigned int maxOutputLen, 539 const unsigned char *input, unsigned int inputLen); 540 extern SECStatus 541 SEED_Decrypt(SEEDContext *cx, unsigned char *output, 542 unsigned int *outputLen, unsigned int maxOutputLen, 543 const unsigned char *input, unsigned int inputLen); 544 545 /******************************************/ 546 /* 547 ** AES symmetric block cypher (Rijndael) 548 */ 549 550 /* 551 ** Create a new AES context suitable for AES encryption/decryption. 552 ** "key" raw key data 553 ** "keylen" the number of bytes of key data (16, 24, or 32) 554 ** "blocklen" is the blocksize to use (16, 24, or 32) 555 ** XXX currently only blocksize==16 has been tested! 556 */ 557 extern AESContext * 558 AES_CreateContext(const unsigned char *key, const unsigned char *iv, 559 int mode, int encrypt, 560 unsigned int keylen, unsigned int blocklen); 561 extern AESContext *AES_AllocateContext(void); 562 extern SECStatus AES_InitContext(AESContext *cx, 563 const unsigned char *key, 564 unsigned int keylen, 565 const unsigned char *iv, 566 int mode, 567 unsigned int encrypt, 568 unsigned int blocklen); 569 570 /* 571 ** Destroy a AES encryption/decryption context. 572 ** "cx" the context 573 ** "freeit" if PR_TRUE then free the object as well as its sub-objects 574 */ 575 extern void 576 AES_DestroyContext(AESContext *cx, PRBool freeit); 577 578 /* 579 ** Perform AES encryption. 580 ** "cx" the context 581 ** "output" the output buffer to store the encrypted data. 582 ** "outputLen" how much data is stored in "output". Set by the routine 583 ** after some data is stored in output. 584 ** "maxOutputLen" the maximum amount of data that can ever be 585 ** stored in "output" 586 ** "input" the input data 587 ** "inputLen" the amount of input data 588 */ 589 extern SECStatus 590 AES_Encrypt(AESContext *cx, unsigned char *output, 591 unsigned int *outputLen, unsigned int maxOutputLen, 592 const unsigned char *input, unsigned int inputLen); 593 594 /* 595 ** Perform AES decryption. 596 ** "cx" the context 597 ** "output" the output buffer to store the decrypted data. 598 ** "outputLen" how much data is stored in "output". Set by the routine 599 ** after some data is stored in output. 600 ** "maxOutputLen" the maximum amount of data that can ever be 601 ** stored in "output" 602 ** "input" the input data 603 ** "inputLen" the amount of input data 604 */ 605 extern SECStatus 606 AES_Decrypt(AESContext *cx, unsigned char *output, 607 unsigned int *outputLen, unsigned int maxOutputLen, 608 const unsigned char *input, unsigned int inputLen); 609 610 /******************************************/ 611 /* 612 ** AES key wrap algorithm, RFC 3394 613 */ 614 615 /* 616 ** Create a new AES context suitable for AES encryption/decryption. 617 ** "key" raw key data 618 ** "iv" The 8 byte "initial value" 619 ** "encrypt", a boolean, true for key wrapping, false for unwrapping. 620 ** "keylen" the number of bytes of key data (16, 24, or 32) 621 */ 622 extern AESKeyWrapContext * 623 AESKeyWrap_CreateContext(const unsigned char *key, const unsigned char *iv, 624 int encrypt, unsigned int keylen); 625 extern AESKeyWrapContext * AESKeyWrap_AllocateContext(void); 626 extern SECStatus 627 AESKeyWrap_InitContext(AESKeyWrapContext *cx, 628 const unsigned char *key, 629 unsigned int keylen, 630 const unsigned char *iv, 631 int , 632 unsigned int encrypt, 633 unsigned int ); 634 635 /* 636 ** Destroy a AES KeyWrap context. 637 ** "cx" the context 638 ** "freeit" if PR_TRUE then free the object as well as its sub-objects 639 */ 640 extern void 641 AESKeyWrap_DestroyContext(AESKeyWrapContext *cx, PRBool freeit); 642 643 /* 644 ** Perform AES key wrap. 645 ** "cx" the context 646 ** "output" the output buffer to store the encrypted data. 647 ** "outputLen" how much data is stored in "output". Set by the routine 648 ** after some data is stored in output. 649 ** "maxOutputLen" the maximum amount of data that can ever be 650 ** stored in "output" 651 ** "input" the input data 652 ** "inputLen" the amount of input data 653 */ 654 extern SECStatus 655 AESKeyWrap_Encrypt(AESKeyWrapContext *cx, unsigned char *output, 656 unsigned int *outputLen, unsigned int maxOutputLen, 657 const unsigned char *input, unsigned int inputLen); 658 659 /* 660 ** Perform AES key unwrap. 661 ** "cx" the context 662 ** "output" the output buffer to store the decrypted data. 663 ** "outputLen" how much data is stored in "output". Set by the routine 664 ** after some data is stored in output. 665 ** "maxOutputLen" the maximum amount of data that can ever be 666 ** stored in "output" 667 ** "input" the input data 668 ** "inputLen" the amount of input data 669 */ 670 extern SECStatus 671 AESKeyWrap_Decrypt(AESKeyWrapContext *cx, unsigned char *output, 672 unsigned int *outputLen, unsigned int maxOutputLen, 673 const unsigned char *input, unsigned int inputLen); 674 675 /******************************************/ 676 /* 677 ** Camellia symmetric block cypher 678 */ 679 680 /* 681 ** Create a new Camellia context suitable for Camellia encryption/decryption. 682 ** "key" raw key data 683 ** "keylen" the number of bytes of key data (16, 24, or 32) 684 */ 685 extern CamelliaContext * 686 Camellia_CreateContext(const unsigned char *key, const unsigned char *iv, 687 int mode, int encrypt, unsigned int keylen); 688 689 extern CamelliaContext *Camellia_AllocateContext(void); 690 extern SECStatus Camellia_InitContext(CamelliaContext *cx, 691 const unsigned char *key, 692 unsigned int keylen, 693 const unsigned char *iv, 694 int mode, 695 unsigned int encrypt, 696 unsigned int unused); 697 /* 698 ** Destroy a Camellia encryption/decryption context. 699 ** "cx" the context 700 ** "freeit" if PR_TRUE then free the object as well as its sub-objects 701 */ 702 extern void 703 Camellia_DestroyContext(CamelliaContext *cx, PRBool freeit); 704 705 /* 706 ** Perform Camellia encryption. 707 ** "cx" the context 708 ** "output" the output buffer to store the encrypted data. 709 ** "outputLen" how much data is stored in "output". Set by the routine 710 ** after some data is stored in output. 711 ** "maxOutputLen" the maximum amount of data that can ever be 712 ** stored in "output" 713 ** "input" the input data 714 ** "inputLen" the amount of input data 715 */ 716 extern SECStatus 717 Camellia_Encrypt(CamelliaContext *cx, unsigned char *output, 718 unsigned int *outputLen, unsigned int maxOutputLen, 719 const unsigned char *input, unsigned int inputLen); 720 721 /* 722 ** Perform Camellia decryption. 723 ** "cx" the context 724 ** "output" the output buffer to store the decrypted data. 725 ** "outputLen" how much data is stored in "output". Set by the routine 726 ** after some data is stored in output. 727 ** "maxOutputLen" the maximum amount of data that can ever be 728 ** stored in "output" 729 ** "input" the input data 730 ** "inputLen" the amount of input data 731 */ 732 extern SECStatus 733 Camellia_Decrypt(CamelliaContext *cx, unsigned char *output, 734 unsigned int *outputLen, unsigned int maxOutputLen, 735 const unsigned char *input, unsigned int inputLen); 736 737 738 /******************************************/ 739 /* 740 ** MD5 secure hash function 741 */ 742 743 /* 744 ** Hash a null terminated string "src" into "dest" using MD5 745 */ 746 extern SECStatus MD5_Hash(unsigned char *dest, const char *src); 747 748 /* 749 ** Hash a non-null terminated string "src" into "dest" using MD5 750 */ 751 extern SECStatus MD5_HashBuf(unsigned char *dest, const unsigned char *src, 752 uint32 src_length); 753 754 /* 755 ** Create a new MD5 context 756 */ 757 extern MD5Context *MD5_NewContext(void); 758 759 760 /* 761 ** Destroy an MD5 secure hash context. 762 ** "cx" the context 763 ** "freeit" if PR_TRUE then free the object as well as its sub-objects 764 */ 765 extern void MD5_DestroyContext(MD5Context *cx, PRBool freeit); 766 767 /* 768 ** Reset an MD5 context, preparing it for a fresh round of hashing 769 */ 770 extern void MD5_Begin(MD5Context *cx); 771 772 /* 773 ** Update the MD5 hash function with more data. 774 ** "cx" the context 775 ** "input" the data to hash 776 ** "inputLen" the amount of data to hash 777 */ 778 extern void MD5_Update(MD5Context *cx, 779 const unsigned char *input, unsigned int inputLen); 780 781 /* 782 ** Finish the MD5 hash function. Produce the digested results in "digest" 783 ** "cx" the context 784 ** "digest" where the 16 bytes of digest data are stored 785 ** "digestLen" where the digest length (16) is stored 786 ** "maxDigestLen" the maximum amount of data that can ever be 787 ** stored in "digest" 788 */ 789 extern void MD5_End(MD5Context *cx, unsigned char *digest, 790 unsigned int *digestLen, unsigned int maxDigestLen); 791 792 /* 793 * Return the the size of a buffer needed to flatten the MD5 Context into 794 * "cx" the context 795 * returns size; 796 */ 797 extern unsigned int MD5_FlattenSize(MD5Context *cx); 798 799 /* 800 * Flatten the MD5 Context into a buffer: 801 * "cx" the context 802 * "space" the buffer to flatten to 803 * returns status; 804 */ 805 extern SECStatus MD5_Flatten(MD5Context *cx,unsigned char *space); 806 807 /* 808 * Resurrect a flattened context into a MD5 Context 809 * "space" the buffer of the flattend buffer 810 * "arg" ptr to void used by cryptographic resurrect 811 * returns resurected context; 812 */ 813 extern MD5Context * MD5_Resurrect(unsigned char *space, void *arg); 814 extern void MD5_Clone(MD5Context *dest, MD5Context *src); 815 816 /* 817 ** trace the intermediate state info of the MD5 hash. 818 */ 819 extern void MD5_TraceState(MD5Context *cx); 820 821 822 /******************************************/ 823 /* 824 ** MD2 secure hash function 825 */ 826 827 /* 828 ** Hash a null terminated string "src" into "dest" using MD2 829 */ 830 extern SECStatus MD2_Hash(unsigned char *dest, const char *src); 831 832 /* 833 ** Create a new MD2 context 834 */ 835 extern MD2Context *MD2_NewContext(void); 836 837 838 /* 839 ** Destroy an MD2 secure hash context. 840 ** "cx" the context 841 ** "freeit" if PR_TRUE then free the object as well as its sub-objects 842 */ 843 extern void MD2_DestroyContext(MD2Context *cx, PRBool freeit); 844 845 /* 846 ** Reset an MD2 context, preparing it for a fresh round of hashing 847 */ 848 extern void MD2_Begin(MD2Context *cx); 849 850 /* 851 ** Update the MD2 hash function with more data. 852 ** "cx" the context 853 ** "input" the data to hash 854 ** "inputLen" the amount of data to hash 855 */ 856 extern void MD2_Update(MD2Context *cx, 857 const unsigned char *input, unsigned int inputLen); 858 859 /* 860 ** Finish the MD2 hash function. Produce the digested results in "digest" 861 ** "cx" the context 862 ** "digest" where the 16 bytes of digest data are stored 863 ** "digestLen" where the digest length (16) is stored 864 ** "maxDigestLen" the maximum amount of data that can ever be 865 ** stored in "digest" 866 */ 867 extern void MD2_End(MD2Context *cx, unsigned char *digest, 868 unsigned int *digestLen, unsigned int maxDigestLen); 869 870 /* 871 * Return the the size of a buffer needed to flatten the MD2 Context into 872 * "cx" the context 873 * returns size; 874 */ 875 extern unsigned int MD2_FlattenSize(MD2Context *cx); 876 877 /* 878 * Flatten the MD2 Context into a buffer: 879 * "cx" the context 880 * "space" the buffer to flatten to 881 * returns status; 882 */ 883 extern SECStatus MD2_Flatten(MD2Context *cx,unsigned char *space); 884 885 /* 886 * Resurrect a flattened context into a MD2 Context 887 * "space" the buffer of the flattend buffer 888 * "arg" ptr to void used by cryptographic resurrect 889 * returns resurected context; 890 */ 891 extern MD2Context * MD2_Resurrect(unsigned char *space, void *arg); 892 extern void MD2_Clone(MD2Context *dest, MD2Context *src); 893 894 /******************************************/ 895 /* 896 ** SHA-1 secure hash function 897 */ 898 899 /* 900 ** Hash a null terminated string "src" into "dest" using SHA-1 901 */ 902 extern SECStatus SHA1_Hash(unsigned char *dest, const char *src); 903 904 /* 905 ** Hash a non-null terminated string "src" into "dest" using SHA-1 906 */ 907 extern SECStatus SHA1_HashBuf(unsigned char *dest, const unsigned char *src, 908 uint32 src_length); 909 910 /* 911 ** Create a new SHA-1 context 912 */ 913 extern SHA1Context *SHA1_NewContext(void); 914 915 916 /* 917 ** Destroy a SHA-1 secure hash context. 918 ** "cx" the context 919 ** "freeit" if PR_TRUE then free the object as well as its sub-objects 920 */ 921 extern void SHA1_DestroyContext(SHA1Context *cx, PRBool freeit); 922 923 /* 924 ** Reset a SHA-1 context, preparing it for a fresh round of hashing 925 */ 926 extern void SHA1_Begin(SHA1Context *cx); 927 928 /* 929 ** Update the SHA-1 hash function with more data. 930 ** "cx" the context 931 ** "input" the data to hash 932 ** "inputLen" the amount of data to hash 933 */ 934 extern void SHA1_Update(SHA1Context *cx, const unsigned char *input, 935 unsigned int inputLen); 936 937 /* 938 ** Finish the SHA-1 hash function. Produce the digested results in "digest" 939 ** "cx" the context 940 ** "digest" where the 16 bytes of digest data are stored 941 ** "digestLen" where the digest length (20) is stored 942 ** "maxDigestLen" the maximum amount of data that can ever be 943 ** stored in "digest" 944 */ 945 extern void SHA1_End(SHA1Context *cx, unsigned char *digest, 946 unsigned int *digestLen, unsigned int maxDigestLen); 947 948 /* 949 ** trace the intermediate state info of the SHA1 hash. 950 */ 951 extern void SHA1_TraceState(SHA1Context *cx); 952 953 /* 954 * Return the the size of a buffer needed to flatten the SHA-1 Context into 955 * "cx" the context 956 * returns size; 957 */ 958 extern unsigned int SHA1_FlattenSize(SHA1Context *cx); 959 960 /* 961 * Flatten the SHA-1 Context into a buffer: 962 * "cx" the context 963 * "space" the buffer to flatten to 964 * returns status; 965 */ 966 extern SECStatus SHA1_Flatten(SHA1Context *cx,unsigned char *space); 967 968 /* 969 * Resurrect a flattened context into a SHA-1 Context 970 * "space" the buffer of the flattend buffer 971 * "arg" ptr to void used by cryptographic resurrect 972 * returns resurected context; 973 */ 974 extern SHA1Context * SHA1_Resurrect(unsigned char *space, void *arg); 975 extern void SHA1_Clone(SHA1Context *dest, SHA1Context *src); 976 977 /******************************************/ 978 979 extern SHA256Context *SHA256_NewContext(void); 980 extern void SHA256_DestroyContext(SHA256Context *cx, PRBool freeit); 981 extern void SHA256_Begin(SHA256Context *cx); 982 extern void SHA256_Update(SHA256Context *cx, const unsigned char *input, 983 unsigned int inputLen); 984 extern void SHA256_End(SHA256Context *cx, unsigned char *digest, 985 unsigned int *digestLen, unsigned int maxDigestLen); 986 extern SECStatus SHA256_HashBuf(unsigned char *dest, const unsigned char *src, 987 uint32 src_length); 988 extern SECStatus SHA256_Hash(unsigned char *dest, const char *src); 989 extern void SHA256_TraceState(SHA256Context *cx); 990 extern unsigned int SHA256_FlattenSize(SHA256Context *cx); 991 extern SECStatus SHA256_Flatten(SHA256Context *cx,unsigned char *space); 992 extern SHA256Context * SHA256_Resurrect(unsigned char *space, void *arg); 993 extern void SHA256_Clone(SHA256Context *dest, SHA256Context *src); 994 995 /******************************************/ 996 997 extern SHA512Context *SHA512_NewContext(void); 998 extern void SHA512_DestroyContext(SHA512Context *cx, PRBool freeit); 999 extern void SHA512_Begin(SHA512Context *cx); 1000 extern void SHA512_Update(SHA512Context *cx, const unsigned char *input, 1001 unsigned int inputLen); 1002 extern void SHA512_End(SHA512Context *cx, unsigned char *digest, 1003 unsigned int *digestLen, unsigned int maxDigestLen); 1004 extern SECStatus SHA512_HashBuf(unsigned char *dest, const unsigned char *src, 1005 uint32 src_length); 1006 extern SECStatus SHA512_Hash(unsigned char *dest, const char *src); 1007 extern void SHA512_TraceState(SHA512Context *cx); 1008 extern unsigned int SHA512_FlattenSize(SHA512Context *cx); 1009 extern SECStatus SHA512_Flatten(SHA512Context *cx,unsigned char *space); 1010 extern SHA512Context * SHA512_Resurrect(unsigned char *space, void *arg); 1011 extern void SHA512_Clone(SHA512Context *dest, SHA512Context *src); 1012 1013 /******************************************/ 1014 1015 extern SHA384Context *SHA384_NewContext(void); 1016 extern void SHA384_DestroyContext(SHA384Context *cx, PRBool freeit); 1017 extern void SHA384_Begin(SHA384Context *cx); 1018 extern void SHA384_Update(SHA384Context *cx, const unsigned char *input, 1019 unsigned int inputLen); 1020 extern void SHA384_End(SHA384Context *cx, unsigned char *digest, 1021 unsigned int *digestLen, unsigned int maxDigestLen); 1022 extern SECStatus SHA384_HashBuf(unsigned char *dest, const unsigned char *src, 1023 uint32 src_length); 1024 extern SECStatus SHA384_Hash(unsigned char *dest, const char *src); 1025 extern void SHA384_TraceState(SHA384Context *cx); 1026 extern unsigned int SHA384_FlattenSize(SHA384Context *cx); 1027 extern SECStatus SHA384_Flatten(SHA384Context *cx,unsigned char *space); 1028 extern SHA384Context * SHA384_Resurrect(unsigned char *space, void *arg); 1029 extern void SHA384_Clone(SHA384Context *dest, SHA384Context *src); 1030 1031 /**************************************** 1032 * implement TLS Pseudo Random Function (PRF) 1033 */ 1034 1035 extern SECStatus 1036 TLS_PRF(const SECItem *secret, const char *label, SECItem *seed, 1037 SECItem *result, PRBool isFIPS); 1038 1039 /******************************************/ 1040 /* 1041 ** Pseudo Random Number Generation. FIPS compliance desirable. 1042 */ 1043 1044 /* 1045 ** Initialize the global RNG context and give it some seed input taken 1046 ** from the system. This function is thread-safe and will only allow 1047 ** the global context to be initialized once. The seed input is likely 1048 ** small, so it is imperative that RNG_RandomUpdate() be called with 1049 ** additional seed data before the generator is used. A good way to 1050 ** provide the generator with additional entropy is to call 1051 ** RNG_SystemInfoForRNG(). Note that NSS_Init() does exactly that. 1052 */ 1053 extern SECStatus RNG_RNGInit(void); 1054 1055 /* 1056 ** Update the global random number generator with more seeding 1057 ** material 1058 */ 1059 extern SECStatus RNG_RandomUpdate(const void *data, size_t bytes); 1060 1061 /* 1062 ** Generate some random bytes, using the global random number generator 1063 ** object. 1064 */ 1065 extern SECStatus RNG_GenerateGlobalRandomBytes(void *dest, size_t len); 1066 1067 /* Destroy the global RNG context. After a call to RNG_RNGShutdown() 1068 ** a call to RNG_RNGInit() is required in order to use the generator again, 1069 ** along with seed data (see the comment above RNG_RNGInit()). 1070 */ 1071 extern void RNG_RNGShutdown(void); 1072 1073 extern void RNG_SystemInfoForRNG(void); 1074 1075 /* 1076 * FIPS 186-2 Change Notice 1 RNG Algorithm 1, used both to 1077 * generate the DSA X parameter and as a generic purpose RNG. 1078 * 1079 * The following two FIPS186Change functions are needed for 1080 * NIST RNG Validation System. 1081 */ 1082 1083 /* 1084 * FIPS186Change_GenerateX is now deprecated. It will return SECFailure with 1085 * the error set to PR_NOT_IMPLEMENTED_ERROR. 1086 */ 1087 extern SECStatus 1088 FIPS186Change_GenerateX(unsigned char *XKEY, 1089 const unsigned char *XSEEDj, 1090 unsigned char *x_j); 1091 1092 /* 1093 * When generating the DSA X parameter, we generate 2*GSIZE bytes 1094 * of random output and reduce it mod q. 1095 * 1096 * Input: w, 2*GSIZE bytes 1097 * q, DSA_SUBPRIME_LEN bytes 1098 * Output: xj, DSA_SUBPRIME_LEN bytes 1099 */ 1100 extern SECStatus 1101 FIPS186Change_ReduceModQForDSA(const unsigned char *w, 1102 const unsigned char *q, 1103 unsigned char *xj); 1104 1105 /* 1106 * The following functions are for FIPS poweron self test and FIPS algorithm 1107 * testing. 1108 */ 1109 extern SECStatus 1110 PRNGTEST_Instantiate(const PRUint8 *entropy, unsigned int entropy_len, 1111 const PRUint8 *nonce, unsigned int nonce_len, 1112 const PRUint8 *personal_string, unsigned int ps_len); 1113 1114 extern SECStatus 1115 PRNGTEST_Reseed(const PRUint8 *entropy, unsigned int entropy_len, 1116 const PRUint8 *additional, unsigned int additional_len); 1117 1118 extern SECStatus 1119 PRNGTEST_Generate(PRUint8 *bytes, unsigned int bytes_len, 1120 const PRUint8 *additional, unsigned int additional_len); 1121 1122 extern SECStatus 1123 PRNGTEST_Uninstantiate(void); 1124 1125 1126 /* Generate PQGParams and PQGVerify structs. 1127 * Length of seed and length of h both equal length of P. 1128 * All lengths are specified by "j", according to the table above. 1129 */ 1130 extern SECStatus 1131 PQG_ParamGen(unsigned int j, /* input : determines length of P. */ 1132 PQGParams **pParams, /* output: P Q and G returned here */ 1133 PQGVerify **pVfy); /* output: counter and seed. */ 1134 1135 /* Generate PQGParams and PQGVerify structs. 1136 * Length of P specified by j. Length of h will match length of P. 1137 * Length of SEED in bytes specified in seedBytes. 1138 * seedBbytes must be in the range [20..255] or an error will result. 1139 */ 1140 extern SECStatus 1141 PQG_ParamGenSeedLen( 1142 unsigned int j, /* input : determines length of P. */ 1143 unsigned int seedBytes, /* input : length of seed in bytes.*/ 1144 PQGParams **pParams, /* output: P Q and G returned here */ 1145 PQGVerify **pVfy); /* output: counter and seed. */ 1146 1147 1148 /* Test PQGParams for validity as DSS PQG values. 1149 * If vfy is non-NULL, test PQGParams to make sure they were generated 1150 * using the specified seed, counter, and h values. 1151 * 1152 * Return value indicates whether Verification operation ran successfully 1153 * to completion, but does not indicate if PQGParams are valid or not. 1154 * If return value is SECSuccess, then *pResult has these meanings: 1155 * SECSuccess: PQGParams are valid. 1156 * SECFailure: PQGParams are invalid. 1157 * 1158 * Verify the following 12 facts about PQG counter SEED g and h 1159 * 1. Q is 160 bits long. 1160 * 2. P is one of the 9 valid lengths. 1161 * 3. G < P 1162 * 4. P % Q == 1 1163 * 5. Q is prime 1164 * 6. P is prime 1165 * Steps 7-12 are done only if the optional PQGVerify is supplied. 1166 * 7. counter < 4096 1167 * 8. g >= 160 and g < 2048 (g is length of seed in bits) 1168 * 9. Q generated from SEED matches Q in PQGParams. 1169 * 10. P generated from (L, counter, g, SEED, Q) matches P in PQGParams. 1170 * 11. 1 < h < P-1 1171 * 12. G generated from h matches G in PQGParams. 1172 */ 1173 1174 extern SECStatus PQG_VerifyParams(const PQGParams *params, 1175 const PQGVerify *vfy, SECStatus *result); 1176 1177 extern void PQG_DestroyParams(PQGParams *params); 1178 1179 extern void PQG_DestroyVerify(PQGVerify *vfy); 1180 1181 1182 /* 1183 * clean-up any global tables freebl may have allocated after it starts up. 1184 * This function is not thread safe and should be called only after the 1185 * library has been quiessed. 1186 */ 1187 extern void BL_Cleanup(void); 1188 1189 /* unload freebl shared library from memory */ 1190 extern void BL_Unload(void); 1191 1192 /************************************************************************** 1193 * Verify a given Shared library signature * 1194 **************************************************************************/ 1195 PRBool BLAPI_SHVerify(const char *name, PRFuncPtr addr); 1196 1197 /************************************************************************** 1198 * Verify Are Own Shared library signature * 1199 **************************************************************************/ 1200 PRBool BLAPI_VerifySelf(const char *name); 1201 1202 /*********************************************************************/ 1203 extern const SECHashObject * HASH_GetRawHashObject(HASH_HashType hashType); 1204 1205 extern void BL_SetForkState(PRBool forked); 1206 1207 SEC_END_PROTOS 1208 1209 #endif /* _BLAPI_H_ */ 1210
