1 /* $FreeBSD: src/sys/opencrypto/xform.c,v 1.10 2008/10/23 15:53:51 des Exp $ */ 2 /* $OpenBSD: xform.c,v 1.16 2001/08/28 12:20:43 ben Exp $ */ 3 /*- 4 * The authors of this code are John Ioannidis (ji@tla.org), 5 * Angelos D. Keromytis (kermit@csd.uch.gr) and 6 * Niels Provos (provos@physnet.uni-hamburg.de). 7 * 8 * This code was written by John Ioannidis for BSD/OS in Athens, Greece, 9 * in November 1995. 10 * 11 * Ported to OpenBSD and NetBSD, with additional transforms, in December 1996, 12 * by Angelos D. Keromytis. 13 * 14 * Additional transforms and features in 1997 and 1998 by Angelos D. Keromytis 15 * and Niels Provos. 16 * 17 * Additional features in 1999 by Angelos D. Keromytis. 18 * 19 * Copyright (C) 1995, 1996, 1997, 1998, 1999 by John Ioannidis, 20 * Angelos D. Keromytis and Niels Provos. 21 * 22 * Copyright (C) 2001, Angelos D. Keromytis. 23 * 24 * Permission to use, copy, and modify this software with or without fee 25 * is hereby granted, provided that this entire notice is included in 26 * all copies of any software which is or includes a copy or 27 * modification of this software. 28 * You may use this code under the GNU public license if you so wish. Please 29 * contribute changes back to the authors under this freer than GPL license 30 * so that we may further the use of strong encryption without limitations to 31 * all. 32 * 33 * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR 34 * IMPLIED WARRANTY. IN PARTICULAR, NONE OF THE AUTHORS MAKES ANY 35 * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE 36 * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR 37 * PURPOSE. 38 */ 39 40 #include <sys/param.h> 41 #include <sys/systm.h> 42 #include <sys/malloc.h> 43 #include <sys/sysctl.h> 44 #include <sys/errno.h> 45 #include <sys/time.h> 46 #include <sys/kernel.h> 47 #include <machine/cpu.h> 48 49 #include <crypto/blowfish/blowfish.h> 50 #include <crypto/des/des.h> 51 #include <crypto/rijndael/rijndael.h> 52 #include <crypto/camellia/camellia.h> 53 #include <crypto/twofish/twofish.h> 54 #include <crypto/serpent/serpent.h> 55 #include <crypto/sha1.h> 56 57 #include <opencrypto/cast.h> 58 #include <opencrypto/deflate.h> 59 #include <opencrypto/rmd160.h> 60 #include <opencrypto/skipjack.h> 61 #include <opencrypto/gmac.h> 62 63 #include <sys/md5.h> 64 65 #include <opencrypto/cryptodev.h> 66 #include <opencrypto/xform.h> 67 68 static void null_encrypt(caddr_t, u_int8_t *, u_int8_t *); 69 static void null_decrypt(caddr_t, u_int8_t *, u_int8_t *); 70 static int null_setkey(u_int8_t **, u_int8_t *, int); 71 static void null_zerokey(u_int8_t **); 72 73 static int des1_setkey(u_int8_t **, u_int8_t *, int); 74 static int des3_setkey(u_int8_t **, u_int8_t *, int); 75 static int blf_setkey(u_int8_t **, u_int8_t *, int); 76 static int cast5_setkey(u_int8_t **, u_int8_t *, int); 77 static int skipjack_setkey(u_int8_t **, u_int8_t *, int); 78 static int rijndael128_setkey(u_int8_t **, u_int8_t *, int); 79 static int aes_xts_setkey(u_int8_t **, u_int8_t *, int); 80 static int aes_ctr_setkey(u_int8_t **, u_int8_t *, int); 81 static int cml_setkey(u_int8_t **, u_int8_t *, int); 82 static int twofish128_setkey(u_int8_t **, u_int8_t *, int); 83 static int serpent128_setkey(u_int8_t **, u_int8_t *, int); 84 static int twofish_xts_setkey(u_int8_t **, u_int8_t *, int); 85 static int serpent_xts_setkey(u_int8_t **, u_int8_t *, int); 86 static void des1_encrypt(caddr_t, u_int8_t *, u_int8_t *); 87 static void des3_encrypt(caddr_t, u_int8_t *, u_int8_t *); 88 static void blf_encrypt(caddr_t, u_int8_t *, u_int8_t *); 89 static void cast5_encrypt(caddr_t, u_int8_t *, u_int8_t *); 90 static void skipjack_encrypt(caddr_t, u_int8_t *, u_int8_t *); 91 static void rijndael128_encrypt(caddr_t, u_int8_t *, u_int8_t *); 92 static void aes_xts_encrypt(caddr_t, u_int8_t *, u_int8_t *); 93 static void cml_encrypt(caddr_t, u_int8_t *, u_int8_t *); 94 static void twofish128_encrypt(caddr_t, u_int8_t *, u_int8_t *); 95 static void serpent128_encrypt(caddr_t, u_int8_t *, u_int8_t *); 96 static void twofish_xts_encrypt(caddr_t, u_int8_t *, u_int8_t *); 97 static void serpent_xts_encrypt(caddr_t, u_int8_t *, u_int8_t *); 98 static void des1_decrypt(caddr_t, u_int8_t *, u_int8_t *); 99 static void des3_decrypt(caddr_t, u_int8_t *, u_int8_t *); 100 static void blf_decrypt(caddr_t, u_int8_t *, u_int8_t *); 101 static void cast5_decrypt(caddr_t, u_int8_t *, u_int8_t *); 102 static void skipjack_decrypt(caddr_t, u_int8_t *, u_int8_t *); 103 static void rijndael128_decrypt(caddr_t, u_int8_t *, u_int8_t *); 104 static void aes_xts_decrypt(caddr_t, u_int8_t *, u_int8_t *); 105 static void cml_decrypt(caddr_t, u_int8_t *, u_int8_t *); 106 static void twofish128_decrypt(caddr_t, u_int8_t *, u_int8_t *); 107 static void serpent128_decrypt(caddr_t, u_int8_t *, u_int8_t *); 108 static void twofish_xts_decrypt(caddr_t, u_int8_t *, u_int8_t *); 109 static void serpent_xts_decrypt(caddr_t, u_int8_t *, u_int8_t *); 110 static void des1_zerokey(u_int8_t **); 111 static void des3_zerokey(u_int8_t **); 112 static void blf_zerokey(u_int8_t **); 113 static void cast5_zerokey(u_int8_t **); 114 static void skipjack_zerokey(u_int8_t **); 115 static void rijndael128_zerokey(u_int8_t **); 116 static void aes_xts_zerokey(u_int8_t **); 117 static void aes_ctr_zerokey(u_int8_t **); 118 static void cml_zerokey(u_int8_t **); 119 static void twofish128_zerokey(u_int8_t **); 120 static void serpent128_zerokey(u_int8_t **); 121 static void twofish_xts_zerokey(u_int8_t **); 122 static void serpent_xts_zerokey(u_int8_t **); 123 124 static void aes_ctr_crypt(caddr_t, u_int8_t *, u_int8_t *); 125 126 static void aes_ctr_reinit(caddr_t, u_int8_t *); 127 static void aes_xts_reinit(caddr_t, u_int8_t *); 128 static void aes_gcm_reinit(caddr_t, u_int8_t *); 129 static void twofish_xts_reinit(caddr_t, u_int8_t *); 130 static void serpent_xts_reinit(caddr_t, u_int8_t *); 131 132 static void null_init(void *); 133 static int null_update(void *, u_int8_t *, u_int16_t); 134 static void null_final(u_int8_t *, void *); 135 static int MD5Update_int(void *, u_int8_t *, u_int16_t); 136 static void SHA1Init_int(void *); 137 static int SHA1Update_int(void *, u_int8_t *, u_int16_t); 138 static void SHA1Final_int(u_int8_t *, void *); 139 static int RMD160Update_int(void *, u_int8_t *, u_int16_t); 140 static int SHA256Update_int(void *, u_int8_t *, u_int16_t); 141 static int SHA384Update_int(void *, u_int8_t *, u_int16_t); 142 static int SHA512Update_int(void *, u_int8_t *, u_int16_t); 143 144 static u_int32_t deflate_compress(u_int8_t *, u_int32_t, u_int8_t **); 145 static u_int32_t deflate_decompress(u_int8_t *, u_int32_t, u_int8_t **); 146 147 /* Helper */ 148 struct aes_xts_ctx; 149 struct twofish_xts_ctx; 150 struct serpent_xts_ctx; 151 static void aes_xts_crypt(struct aes_xts_ctx *, u_int8_t *, u_int8_t *, u_int); 152 static void twofish_xts_crypt(struct twofish_xts_ctx *, u_int8_t *, u_int8_t *, 153 u_int); 154 static void serpent_xts_crypt(struct serpent_xts_ctx *, u_int8_t *, u_int8_t *, 155 u_int); 156 157 MALLOC_DEFINE(M_XDATA, "xform", "xform data buffers"); 158 159 /* Encryption instances */ 160 struct enc_xform enc_xform_null = { 161 CRYPTO_NULL_CBC, "NULL", 162 /* NB: blocksize of 4 is to generate a properly aligned ESP header */ 163 NULL_BLOCK_LEN, NULL_BLOCK_LEN, 0, 256, /* 2048 bits, max key */ 164 null_encrypt, 165 null_decrypt, 166 null_setkey, 167 null_zerokey, 168 NULL 169 }; 170 171 struct enc_xform enc_xform_des = { 172 CRYPTO_DES_CBC, "DES", 173 DES_BLOCK_LEN, DES_BLOCK_LEN, 8, 8, 174 des1_encrypt, 175 des1_decrypt, 176 des1_setkey, 177 des1_zerokey, 178 NULL 179 }; 180 181 struct enc_xform enc_xform_3des = { 182 CRYPTO_3DES_CBC, "3DES", 183 DES3_BLOCK_LEN, DES3_BLOCK_LEN, 24, 24, 184 des3_encrypt, 185 des3_decrypt, 186 des3_setkey, 187 des3_zerokey, 188 NULL 189 }; 190 191 struct enc_xform enc_xform_blf = { 192 CRYPTO_BLF_CBC, "Blowfish", 193 BLOWFISH_BLOCK_LEN, BLOWFISH_BLOCK_LEN, 5, 56 /* 448 bits, max key */, 194 blf_encrypt, 195 blf_decrypt, 196 blf_setkey, 197 blf_zerokey, 198 NULL 199 }; 200 201 struct enc_xform enc_xform_cast5 = { 202 CRYPTO_CAST_CBC, "CAST-128", 203 CAST128_BLOCK_LEN, CAST128_BLOCK_LEN, 5, 16, 204 cast5_encrypt, 205 cast5_decrypt, 206 cast5_setkey, 207 cast5_zerokey, 208 NULL 209 }; 210 211 struct enc_xform enc_xform_skipjack = { 212 CRYPTO_SKIPJACK_CBC, "Skipjack", 213 SKIPJACK_BLOCK_LEN, SKIPJACK_BLOCK_LEN, 10, 10, 214 skipjack_encrypt, 215 skipjack_decrypt, 216 skipjack_setkey, 217 skipjack_zerokey, 218 NULL 219 }; 220 221 struct enc_xform enc_xform_rijndael128 = { 222 CRYPTO_RIJNDAEL128_CBC, "Rijndael-128/AES", 223 RIJNDAEL128_BLOCK_LEN, RIJNDAEL128_BLOCK_LEN, 8, 32, 224 rijndael128_encrypt, 225 rijndael128_decrypt, 226 rijndael128_setkey, 227 rijndael128_zerokey, 228 NULL 229 }; 230 231 struct enc_xform enc_xform_aes_xts = { 232 CRYPTO_AES_XTS, "AES-XTS", 233 AES_XTS_BLOCK_LEN, AES_XTS_IV_LEN, 32, 64, 234 aes_xts_encrypt, 235 aes_xts_decrypt, 236 aes_xts_setkey, 237 aes_xts_zerokey, 238 aes_xts_reinit 239 }; 240 241 struct enc_xform enc_xform_aes_ctr = { 242 CRYPTO_AES_CTR, "AES-CTR", 243 AESCTR_BLOCK_LEN, AESCTR_IV_LEN, 16+4, 32+4, 244 aes_ctr_crypt, 245 aes_ctr_crypt, 246 aes_ctr_setkey, 247 aes_ctr_zerokey, 248 aes_ctr_reinit 249 }; 250 251 struct enc_xform enc_xform_aes_gcm = { 252 CRYPTO_AES_GCM_16, "AES-GCM", 253 AESGCM_BLOCK_LEN, AESGCM_IV_LEN, 16+4, 32+4, 254 aes_ctr_crypt, 255 aes_ctr_crypt, 256 aes_ctr_setkey, 257 aes_ctr_zerokey, 258 aes_gcm_reinit 259 }; 260 261 struct enc_xform enc_xform_aes_gmac = { 262 CRYPTO_AES_GMAC, "AES-GMAC", 263 AESGMAC_BLOCK_LEN, AESGMAC_IV_LEN, 16+4, 32+4, 264 NULL, 265 NULL, 266 NULL, 267 NULL, 268 NULL 269 }; 270 271 struct enc_xform enc_xform_arc4 = { 272 CRYPTO_ARC4, "ARC4", 273 1, 1, 1, 32, 274 NULL, 275 NULL, 276 NULL, 277 NULL, 278 NULL 279 }; 280 281 struct enc_xform enc_xform_camellia = { 282 CRYPTO_CAMELLIA_CBC, "Camellia", 283 CAMELLIA_BLOCK_LEN, CAMELLIA_BLOCK_LEN, 8, 32, 284 cml_encrypt, 285 cml_decrypt, 286 cml_setkey, 287 cml_zerokey, 288 NULL 289 }; 290 291 struct enc_xform enc_xform_twofish = { 292 CRYPTO_TWOFISH_CBC, "Twofish", 293 TWOFISH_BLOCK_LEN, TWOFISH_BLOCK_LEN, 8, 32, 294 twofish128_encrypt, 295 twofish128_decrypt, 296 twofish128_setkey, 297 twofish128_zerokey, 298 NULL 299 }; 300 301 struct enc_xform enc_xform_serpent = { 302 CRYPTO_SERPENT_CBC, "Serpent", 303 SERPENT_BLOCK_LEN, SERPENT_BLOCK_LEN, 8, 32, 304 serpent128_encrypt, 305 serpent128_decrypt, 306 serpent128_setkey, 307 serpent128_zerokey, 308 NULL 309 }; 310 311 struct enc_xform enc_xform_twofish_xts = { 312 CRYPTO_TWOFISH_XTS, "TWOFISH-XTS", 313 TWOFISH_XTS_BLOCK_LEN, TWOFISH_XTS_IV_LEN, 32, 64, 314 twofish_xts_encrypt, 315 twofish_xts_decrypt, 316 twofish_xts_setkey, 317 twofish_xts_zerokey, 318 twofish_xts_reinit 319 }; 320 321 struct enc_xform enc_xform_serpent_xts = { 322 CRYPTO_SERPENT_XTS, "SERPENT-XTS", 323 SERPENT_XTS_BLOCK_LEN, SERPENT_XTS_IV_LEN, 32, 64, 324 serpent_xts_encrypt, 325 serpent_xts_decrypt, 326 serpent_xts_setkey, 327 serpent_xts_zerokey, 328 serpent_xts_reinit 329 }; 330 331 332 /* Authentication instances */ 333 struct auth_hash auth_hash_null = { 334 CRYPTO_NULL_HMAC, "NULL-HMAC", 335 0, NULL_HASH_LEN, NULL_HMAC_BLOCK_LEN, sizeof(int), /* NB: context isn't used */ 336 null_init, NULL, NULL, null_update, null_final 337 }; 338 339 struct auth_hash auth_hash_hmac_md5 = { 340 CRYPTO_MD5_HMAC, "HMAC-MD5", 341 16, MD5_HASH_LEN, MD5_HMAC_BLOCK_LEN, sizeof(MD5_CTX), 342 (void (*) (void *)) MD5Init, NULL, NULL, 343 MD5Update_int, 344 (void (*) (u_int8_t *, void *)) MD5Final 345 }; 346 347 struct auth_hash auth_hash_hmac_sha1 = { 348 CRYPTO_SHA1_HMAC, "HMAC-SHA1", 349 20, SHA1_HASH_LEN, SHA1_HMAC_BLOCK_LEN, sizeof(SHA1_CTX), 350 SHA1Init_int, NULL, NULL, 351 SHA1Update_int, SHA1Final_int 352 }; 353 354 struct auth_hash auth_hash_hmac_ripemd_160 = { 355 CRYPTO_RIPEMD160_HMAC, "HMAC-RIPEMD-160", 356 20, RIPEMD160_HASH_LEN, RIPEMD160_HMAC_BLOCK_LEN, sizeof(RMD160_CTX), 357 (void (*)(void *)) RMD160Init, NULL, NULL, 358 RMD160Update_int, 359 (void (*)(u_int8_t *, void *)) RMD160Final 360 }; 361 362 struct auth_hash auth_hash_key_md5 = { 363 CRYPTO_MD5_KPDK, "Keyed MD5", 364 0, MD5_KPDK_HASH_LEN, 0, sizeof(MD5_CTX), 365 (void (*)(void *)) MD5Init, NULL, NULL, 366 MD5Update_int, 367 (void (*)(u_int8_t *, void *)) MD5Final 368 }; 369 370 struct auth_hash auth_hash_key_sha1 = { 371 CRYPTO_SHA1_KPDK, "Keyed SHA1", 372 0, SHA1_KPDK_HASH_LEN, 0, sizeof(SHA1_CTX), 373 SHA1Init_int, NULL, NULL, 374 SHA1Update_int, SHA1Final_int 375 }; 376 377 struct auth_hash auth_hash_hmac_sha2_256 = { 378 CRYPTO_SHA2_256_HMAC, "HMAC-SHA2-256", 379 32, SHA2_256_HASH_LEN, SHA2_256_HMAC_BLOCK_LEN, sizeof(SHA256_CTX), 380 (void (*)(void *)) SHA256_Init, NULL, NULL, 381 SHA256Update_int, 382 (void (*)(u_int8_t *, void *)) SHA256_Final 383 }; 384 385 struct auth_hash auth_hash_hmac_sha2_384 = { 386 CRYPTO_SHA2_384_HMAC, "HMAC-SHA2-384", 387 48, SHA2_384_HASH_LEN, SHA2_384_HMAC_BLOCK_LEN, sizeof(SHA384_CTX), 388 (void (*)(void *)) SHA384_Init, NULL, NULL, 389 SHA384Update_int, 390 (void (*)(u_int8_t *, void *)) SHA384_Final 391 }; 392 393 struct auth_hash auth_hash_hmac_sha2_512 = { 394 CRYPTO_SHA2_512_HMAC, "HMAC-SHA2-512", 395 64, SHA2_512_HASH_LEN, SHA2_512_HMAC_BLOCK_LEN, sizeof(SHA512_CTX), 396 (void (*)(void *)) SHA512_Init, NULL, NULL, 397 SHA512Update_int, 398 (void (*)(u_int8_t *, void *)) SHA512_Final 399 }; 400 401 struct auth_hash auth_hash_gmac_aes_128 = { 402 CRYPTO_AES_128_GMAC, "GMAC-AES-128", 403 16+4, 16, 16, sizeof(AES_GMAC_CTX), 404 (void (*)(void *)) AES_GMAC_Init, 405 (void (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Setkey, 406 (void (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Reinit, 407 (int (*)(void *, u_int8_t *, u_int16_t)) AES_GMAC_Update, 408 (void (*)(u_int8_t *, void *)) AES_GMAC_Final 409 }; 410 411 struct auth_hash auth_hash_gmac_aes_192 = { 412 CRYPTO_AES_192_GMAC, "GMAC-AES-192", 413 24+4, 16, 16, sizeof(AES_GMAC_CTX), 414 (void (*)(void *)) AES_GMAC_Init, 415 (void (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Setkey, 416 (void (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Reinit, 417 (int (*)(void *, u_int8_t *, u_int16_t)) AES_GMAC_Update, 418 (void (*)(u_int8_t *, void *)) AES_GMAC_Final 419 }; 420 421 struct auth_hash auth_hash_gmac_aes_256 = { 422 CRYPTO_AES_256_GMAC, "GMAC-AES-256", 423 32+4, 16, 16, sizeof(AES_GMAC_CTX), 424 (void (*)(void *)) AES_GMAC_Init, 425 (void (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Setkey, 426 (void (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Reinit, 427 (int (*)(void *, u_int8_t *, u_int16_t)) AES_GMAC_Update, 428 (void (*)(u_int8_t *, void *)) AES_GMAC_Final 429 }; 430 431 /* Compression instance */ 432 struct comp_algo comp_algo_deflate = { 433 CRYPTO_DEFLATE_COMP, "Deflate", 434 90, deflate_compress, 435 deflate_decompress 436 }; 437 438 /* 439 * Encryption wrapper routines. 440 */ 441 static void 442 null_encrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv) 443 { 444 } 445 static void 446 null_decrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv) 447 { 448 } 449 static int 450 null_setkey(u_int8_t **sched, u_int8_t *key, int len) 451 { 452 *sched = NULL; 453 return 0; 454 } 455 static void 456 null_zerokey(u_int8_t **sched) 457 { 458 *sched = NULL; 459 } 460 461 static void 462 des1_encrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv) 463 { 464 des_cblock *cb = (des_cblock *) blk; 465 des_key_schedule *p = (des_key_schedule *) key; 466 467 des_ecb_encrypt(cb, cb, p[0], DES_ENCRYPT); 468 } 469 470 static void 471 des1_decrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv) 472 { 473 des_cblock *cb = (des_cblock *) blk; 474 des_key_schedule *p = (des_key_schedule *) key; 475 476 des_ecb_encrypt(cb, cb, p[0], DES_DECRYPT); 477 } 478 479 static int 480 des1_setkey(u_int8_t **sched, u_int8_t *key, int len) 481 { 482 des_key_schedule *p; 483 int err; 484 485 p = kmalloc(sizeof (des_key_schedule), 486 M_CRYPTO_DATA, M_INTWAIT | M_ZERO); 487 if (p != NULL) { 488 des_set_key((des_cblock *) key, p[0]); 489 err = 0; 490 } else 491 err = ENOMEM; 492 *sched = (u_int8_t *) p; 493 return err; 494 } 495 496 static void 497 des1_zerokey(u_int8_t **sched) 498 { 499 bzero(*sched, sizeof (des_key_schedule)); 500 kfree(*sched, M_CRYPTO_DATA); 501 *sched = NULL; 502 } 503 504 static void 505 des3_encrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv) 506 { 507 des_cblock *cb = (des_cblock *) blk; 508 des_key_schedule *p = (des_key_schedule *) key; 509 510 des_ecb3_encrypt(cb, cb, p[0], p[1], p[2], DES_ENCRYPT); 511 } 512 513 static void 514 des3_decrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv) 515 { 516 des_cblock *cb = (des_cblock *) blk; 517 des_key_schedule *p = (des_key_schedule *) key; 518 519 des_ecb3_encrypt(cb, cb, p[0], p[1], p[2], DES_DECRYPT); 520 } 521 522 static int 523 des3_setkey(u_int8_t **sched, u_int8_t *key, int len) 524 { 525 des_key_schedule *p; 526 int err; 527 528 p = kmalloc(3 * sizeof(des_key_schedule), 529 M_CRYPTO_DATA, M_INTWAIT | M_ZERO); 530 if (p != NULL) { 531 des_set_key((des_cblock *)(key + 0), p[0]); 532 des_set_key((des_cblock *)(key + 8), p[1]); 533 des_set_key((des_cblock *)(key + 16), p[2]); 534 err = 0; 535 } else 536 err = ENOMEM; 537 *sched = (u_int8_t *) p; 538 return err; 539 } 540 541 static void 542 des3_zerokey(u_int8_t **sched) 543 { 544 bzero(*sched, 3*sizeof (des_key_schedule)); 545 kfree(*sched, M_CRYPTO_DATA); 546 *sched = NULL; 547 } 548 549 static void 550 blf_encrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv) 551 { 552 BF_LONG t[2]; 553 554 memcpy(t, blk, sizeof (t)); 555 t[0] = ntohl(t[0]); 556 t[1] = ntohl(t[1]); 557 /* NB: BF_encrypt expects the block in host order! */ 558 BF_encrypt(t, (BF_KEY *) key); 559 t[0] = htonl(t[0]); 560 t[1] = htonl(t[1]); 561 memcpy(blk, t, sizeof (t)); 562 } 563 564 static void 565 blf_decrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv) 566 { 567 BF_LONG t[2]; 568 569 memcpy(t, blk, sizeof (t)); 570 t[0] = ntohl(t[0]); 571 t[1] = ntohl(t[1]); 572 /* NB: BF_decrypt expects the block in host order! */ 573 BF_decrypt(t, (BF_KEY *) key); 574 t[0] = htonl(t[0]); 575 t[1] = htonl(t[1]); 576 memcpy(blk, t, sizeof (t)); 577 } 578 579 static int 580 blf_setkey(u_int8_t **sched, u_int8_t *key, int len) 581 { 582 int err; 583 584 *sched = kmalloc(sizeof(BF_KEY), M_CRYPTO_DATA, M_INTWAIT | M_ZERO); 585 if (*sched != NULL) { 586 BF_set_key((BF_KEY *) *sched, len, key); 587 err = 0; 588 } else 589 err = ENOMEM; 590 return err; 591 } 592 593 static void 594 blf_zerokey(u_int8_t **sched) 595 { 596 bzero(*sched, sizeof(BF_KEY)); 597 kfree(*sched, M_CRYPTO_DATA); 598 *sched = NULL; 599 } 600 601 static void 602 cast5_encrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv) 603 { 604 cast_encrypt((cast_key *) key, blk, blk); 605 } 606 607 static void 608 cast5_decrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv) 609 { 610 cast_decrypt((cast_key *) key, blk, blk); 611 } 612 613 static int 614 cast5_setkey(u_int8_t **sched, u_int8_t *key, int len) 615 { 616 int err; 617 618 *sched = kmalloc(sizeof(cast_key), M_CRYPTO_DATA, M_INTWAIT | M_ZERO); 619 if (*sched != NULL) { 620 cast_setkey((cast_key *)*sched, key, len); 621 err = 0; 622 } else 623 err = ENOMEM; 624 return err; 625 } 626 627 static void 628 cast5_zerokey(u_int8_t **sched) 629 { 630 bzero(*sched, sizeof(cast_key)); 631 kfree(*sched, M_CRYPTO_DATA); 632 *sched = NULL; 633 } 634 635 static void 636 skipjack_encrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv) 637 { 638 skipjack_forwards(blk, blk, (u_int8_t **) key); 639 } 640 641 static void 642 skipjack_decrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv) 643 { 644 skipjack_backwards(blk, blk, (u_int8_t **) key); 645 } 646 647 static int 648 skipjack_setkey(u_int8_t **sched, u_int8_t *key, int len) 649 { 650 int err; 651 652 /* NB: allocate all the memory that's needed at once */ 653 *sched = kmalloc(10 * (sizeof(u_int8_t *) + 0x100), 654 M_CRYPTO_DATA, M_INTWAIT | M_ZERO); 655 if (*sched != NULL) { 656 u_int8_t** key_tables = (u_int8_t**) *sched; 657 u_int8_t* table = (u_int8_t*) &key_tables[10]; 658 int k; 659 660 for (k = 0; k < 10; k++) { 661 key_tables[k] = table; 662 table += 0x100; 663 } 664 subkey_table_gen(key, (u_int8_t **) *sched); 665 err = 0; 666 } else 667 err = ENOMEM; 668 return err; 669 } 670 671 static void 672 skipjack_zerokey(u_int8_t **sched) 673 { 674 bzero(*sched, 10 * (sizeof(u_int8_t *) + 0x100)); 675 kfree(*sched, M_CRYPTO_DATA); 676 *sched = NULL; 677 } 678 679 static void 680 rijndael128_encrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv) 681 { 682 rijndael_encrypt((rijndael_ctx *) key, (u_char *) blk, (u_char *) blk); 683 } 684 685 static void 686 rijndael128_decrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv) 687 { 688 rijndael_decrypt(((rijndael_ctx *) key), (u_char *) blk, 689 (u_char *) blk); 690 } 691 692 static int 693 rijndael128_setkey(u_int8_t **sched, u_int8_t *key, int len) 694 { 695 int err; 696 697 if (len != 16 && len != 24 && len != 32) 698 return (EINVAL); 699 *sched = kmalloc(sizeof(rijndael_ctx), M_CRYPTO_DATA, 700 M_INTWAIT | M_ZERO); 701 if (*sched != NULL) { 702 rijndael_set_key((rijndael_ctx *) *sched, (u_char *) key, 703 len * 8); 704 err = 0; 705 } else 706 err = ENOMEM; 707 return err; 708 } 709 710 static void 711 rijndael128_zerokey(u_int8_t **sched) 712 { 713 bzero(*sched, sizeof(rijndael_ctx)); 714 kfree(*sched, M_CRYPTO_DATA); 715 *sched = NULL; 716 } 717 718 #define AES_XTS_ALPHA 0x87 /* GF(2^128) generator polynomial */ 719 720 struct aes_xts_ctx { 721 rijndael_ctx key1; 722 rijndael_ctx key2; 723 }; 724 725 void 726 aes_xts_reinit(caddr_t key, u_int8_t *iv) 727 { 728 struct aes_xts_ctx *ctx = (struct aes_xts_ctx *)key; 729 #if 0 730 u_int64_t blocknum; 731 u_int i; 732 #endif 733 734 #if 0 735 /* 736 * Prepare tweak as E_k2(IV). IV is specified as LE representation 737 * of a 64-bit block number which we allow to be passed in directly. 738 */ 739 /* XXX: possibly use htole64? */ 740 #endif 741 /* Last 64 bits of IV are always zero */ 742 bzero(iv + AES_XTS_IV_LEN, AES_XTS_IV_LEN); 743 744 rijndael_encrypt(&ctx->key2, iv, iv); 745 } 746 747 void 748 aes_xts_crypt(struct aes_xts_ctx *ctx, u_int8_t *data, u_int8_t *iv, u_int do_encrypt) 749 { 750 u_int8_t block[AES_XTS_BLOCK_LEN]; 751 u_int i, carry_in, carry_out; 752 753 for (i = 0; i < AES_XTS_BLOCK_LEN; i++) 754 block[i] = data[i] ^ iv[i]; 755 756 if (do_encrypt) 757 rijndael_encrypt(&ctx->key1, block, data); 758 else 759 rijndael_decrypt(&ctx->key1, block, data); 760 761 for (i = 0; i < AES_XTS_BLOCK_LEN; i++) 762 data[i] ^= iv[i]; 763 764 /* Exponentiate tweak */ 765 carry_in = 0; 766 for (i = 0; i < AES_XTS_BLOCK_LEN; i++) { 767 carry_out = iv[i] & 0x80; 768 iv[i] = (iv[i] << 1) | (carry_in ? 1 : 0); 769 carry_in = carry_out; 770 } 771 if (carry_in) 772 iv[0] ^= AES_XTS_ALPHA; 773 bzero(block, sizeof(block)); 774 } 775 776 void 777 aes_xts_encrypt(caddr_t key, u_int8_t *data, u_int8_t *iv) 778 { 779 aes_xts_crypt((struct aes_xts_ctx *)key, data, iv, 1); 780 } 781 782 void 783 aes_xts_decrypt(caddr_t key, u_int8_t *data, u_int8_t *iv) 784 { 785 aes_xts_crypt((struct aes_xts_ctx *)key, data, iv, 0); 786 } 787 788 int 789 aes_xts_setkey(u_int8_t **sched, u_int8_t *key, int len) 790 { 791 struct aes_xts_ctx *ctx; 792 793 if (len != 32 && len != 64) 794 return -1; 795 796 *sched = kmalloc(sizeof(struct aes_xts_ctx), M_CRYPTO_DATA, 797 M_WAITOK | M_ZERO); 798 ctx = (struct aes_xts_ctx *)*sched; 799 800 rijndael_set_key(&ctx->key1, key, len * 4); 801 rijndael_set_key(&ctx->key2, key + (len / 2), len * 4); 802 803 return 0; 804 } 805 806 void 807 aes_xts_zerokey(u_int8_t **sched) 808 { 809 bzero(*sched, sizeof(struct aes_xts_ctx)); 810 kfree(*sched, M_CRYPTO_DATA); 811 *sched = NULL; 812 } 813 814 #define AESCTR_NONCESIZE 4 815 816 struct aes_ctr_ctx { 817 u_int32_t ac_ek[4*(14 + 1)]; 818 u_int8_t ac_block[AESCTR_BLOCK_LEN]; 819 int ac_nr; 820 }; 821 822 void 823 aes_ctr_reinit(caddr_t key, u_int8_t *iv) 824 { 825 struct aes_ctr_ctx *ctx; 826 827 ctx = (struct aes_ctr_ctx *)key; 828 bcopy(iv, iv + AESCTR_NONCESIZE, AESCTR_IV_LEN); 829 bcopy(ctx->ac_block, iv, AESCTR_NONCESIZE); 830 831 /* reset counter */ 832 bzero(iv + AESCTR_NONCESIZE + AESCTR_IV_LEN, 4); 833 } 834 835 void 836 aes_ctr_crypt(caddr_t key, u_int8_t *data, u_int8_t *iv) 837 { 838 struct aes_ctr_ctx *ctx; 839 u_int8_t keystream[AESCTR_BLOCK_LEN]; 840 int i; 841 842 ctx = (struct aes_ctr_ctx *)key; 843 /* increment counter */ 844 for (i = AESCTR_BLOCK_LEN - 1; 845 i >= AESCTR_NONCESIZE + AESCTR_IV_LEN; i--) 846 if (++iv[i]) /* continue on overflow */ 847 break; 848 rijndaelEncrypt(ctx->ac_ek, ctx->ac_nr, iv, keystream); 849 for (i = 0; i < AESCTR_BLOCK_LEN; i++) 850 data[i] ^= keystream[i]; 851 bzero(keystream, sizeof(keystream)); 852 } 853 854 int 855 aes_ctr_setkey(u_int8_t **sched, u_int8_t *key, int len) 856 { 857 struct aes_ctr_ctx *ctx; 858 859 if (len < AESCTR_NONCESIZE) 860 return -1; 861 862 *sched = kmalloc(sizeof(struct aes_ctr_ctx), M_CRYPTO_DATA, 863 M_WAITOK | M_ZERO); 864 ctx = (struct aes_ctr_ctx *)*sched; 865 ctx->ac_nr = rijndaelKeySetupEnc(ctx->ac_ek, (u_char *)key, 866 (len - AESCTR_NONCESIZE) * 8); 867 if (ctx->ac_nr == 0) { 868 aes_ctr_zerokey(sched); 869 return -1; 870 } 871 bcopy(key + len - AESCTR_NONCESIZE, ctx->ac_block, AESCTR_NONCESIZE); 872 return 0; 873 } 874 875 void 876 aes_ctr_zerokey(u_int8_t **sched) 877 { 878 bzero(*sched, sizeof(struct aes_ctr_ctx)); 879 kfree(*sched, M_CRYPTO_DATA); 880 *sched = NULL; 881 } 882 883 static void 884 aes_gcm_reinit(caddr_t key, u_int8_t *iv) 885 { 886 struct aes_ctr_ctx *ctx; 887 888 ctx = (struct aes_ctr_ctx *)key; 889 bcopy(iv, ctx->ac_block + AESCTR_NONCESIZE, AESCTR_IV_LEN); 890 891 /* reset counter */ 892 bzero(ctx->ac_block + AESCTR_NONCESIZE + AESCTR_IV_LEN, 4); 893 ctx->ac_block[AESCTR_BLOCK_LEN - 1] = 1; /* GCM starts with 1 */ 894 } 895 896 static void 897 cml_encrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv) 898 { 899 camellia_encrypt((camellia_ctx *) key, (u_char *) blk, (u_char *) blk); 900 } 901 902 static void 903 cml_decrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv) 904 { 905 camellia_decrypt(((camellia_ctx *) key), (u_char *) blk, 906 (u_char *) blk); 907 } 908 909 static int 910 cml_setkey(u_int8_t **sched, u_int8_t *key, int len) 911 { 912 int err; 913 914 if (len != 16 && len != 24 && len != 32) 915 return (EINVAL); 916 *sched = kmalloc(sizeof(camellia_ctx), M_CRYPTO_DATA, 917 M_INTWAIT | M_ZERO); 918 if (*sched != NULL) { 919 camellia_set_key((camellia_ctx *) *sched, (u_char *) key, 920 len * 8); 921 err = 0; 922 } else 923 err = ENOMEM; 924 return err; 925 } 926 927 static void 928 cml_zerokey(u_int8_t **sched) 929 { 930 bzero(*sched, sizeof(camellia_ctx)); 931 kfree(*sched, M_CRYPTO_DATA); 932 *sched = NULL; 933 } 934 935 static void 936 twofish128_encrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv) 937 { 938 twofish_encrypt((twofish_ctx *) key, (u_int8_t *) blk, 939 (u_int8_t *) blk); 940 } 941 942 static void 943 twofish128_decrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv) 944 { 945 twofish_decrypt(((twofish_ctx *) key), (u_int8_t *) blk, 946 (u_int8_t *) blk); 947 } 948 949 static int 950 twofish128_setkey(u_int8_t **sched, u_int8_t *key, int len) 951 { 952 int err; 953 954 if (len != 16 && len != 24 && len != 32) 955 return (EINVAL); 956 *sched = kmalloc(sizeof(twofish_ctx), M_CRYPTO_DATA, 957 M_INTWAIT | M_ZERO); 958 if (*sched != NULL) { 959 twofish_set_key((twofish_ctx *) *sched, (u_int8_t *) key, 960 len * 8); 961 err = 0; 962 } else 963 err = ENOMEM; 964 return err; 965 } 966 967 static void 968 twofish128_zerokey(u_int8_t **sched) 969 { 970 bzero(*sched, sizeof(twofish_ctx)); 971 kfree(*sched, M_CRYPTO_DATA); 972 *sched = NULL; 973 } 974 975 static void 976 serpent128_encrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv) 977 { 978 serpent_encrypt((serpent_ctx *) key, (u_int8_t *) blk, 979 (u_int8_t *) blk); 980 } 981 982 static void 983 serpent128_decrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv) 984 { 985 serpent_decrypt(((serpent_ctx *) key), (u_int8_t *) blk, 986 (u_int8_t *) blk); 987 } 988 989 static int 990 serpent128_setkey(u_int8_t **sched, u_int8_t *key, int len) 991 { 992 int err; 993 994 if (len != 16 && len != 24 && len != 32) 995 return (EINVAL); 996 *sched = kmalloc(sizeof(serpent_ctx), M_CRYPTO_DATA, 997 M_INTWAIT | M_ZERO); 998 if (*sched != NULL) { 999 serpent_set_key((serpent_ctx *) *sched, (u_int8_t *) key, 1000 len * 8); 1001 err = 0; 1002 } else 1003 err = ENOMEM; 1004 return err; 1005 } 1006 1007 static void 1008 serpent128_zerokey(u_int8_t **sched) 1009 { 1010 bzero(*sched, sizeof(serpent_ctx)); 1011 kfree(*sched, M_CRYPTO_DATA); 1012 *sched = NULL; 1013 } 1014 1015 1016 struct twofish_xts_ctx { 1017 twofish_ctx key1; 1018 twofish_ctx key2; 1019 }; 1020 1021 void 1022 twofish_xts_reinit(caddr_t key, u_int8_t *iv) 1023 { 1024 struct twofish_xts_ctx *ctx = (struct twofish_xts_ctx *)key; 1025 #if 0 1026 u_int64_t blocknum; 1027 #endif 1028 1029 #if 0 1030 /* 1031 * Prepare tweak as E_k2(IV). IV is specified as LE representation 1032 * of a 64-bit block number which we allow to be passed in directly. 1033 */ 1034 /* XXX: possibly use htole64? */ 1035 #endif 1036 /* Last 64 bits of IV are always zero */ 1037 bzero(iv + TWOFISH_XTS_IV_LEN, TWOFISH_XTS_IV_LEN); 1038 1039 twofish_encrypt(&ctx->key2, iv, iv); 1040 } 1041 1042 void 1043 twofish_xts_crypt(struct twofish_xts_ctx *ctx, u_int8_t *data, u_int8_t *iv, 1044 u_int do_encrypt) 1045 { 1046 u_int8_t block[TWOFISH_XTS_BLOCK_LEN]; 1047 u_int i, carry_in, carry_out; 1048 1049 for (i = 0; i < TWOFISH_XTS_BLOCK_LEN; i++) 1050 block[i] = data[i] ^ iv[i]; 1051 1052 if (do_encrypt) 1053 twofish_encrypt(&ctx->key1, block, data); 1054 else 1055 twofish_decrypt(&ctx->key1, block, data); 1056 1057 for (i = 0; i < TWOFISH_XTS_BLOCK_LEN; i++) 1058 data[i] ^= iv[i]; 1059 1060 /* Exponentiate tweak */ 1061 carry_in = 0; 1062 for (i = 0; i < TWOFISH_XTS_BLOCK_LEN; i++) { 1063 carry_out = iv[i] & 0x80; 1064 iv[i] = (iv[i] << 1) | (carry_in ? 1 : 0); 1065 carry_in = carry_out; 1066 } 1067 if (carry_in) 1068 iv[0] ^= AES_XTS_ALPHA; 1069 bzero(block, sizeof(block)); 1070 } 1071 1072 void 1073 twofish_xts_encrypt(caddr_t key, u_int8_t *data, u_int8_t *iv) 1074 { 1075 twofish_xts_crypt((struct twofish_xts_ctx *)key, data, iv, 1); 1076 } 1077 1078 void 1079 twofish_xts_decrypt(caddr_t key, u_int8_t *data, u_int8_t *iv) 1080 { 1081 twofish_xts_crypt((struct twofish_xts_ctx *)key, data, iv, 0); 1082 } 1083 1084 int 1085 twofish_xts_setkey(u_int8_t **sched, u_int8_t *key, int len) 1086 { 1087 struct twofish_xts_ctx *ctx; 1088 1089 if (len != 32 && len != 64) 1090 return -1; 1091 1092 *sched = kmalloc(sizeof(struct twofish_xts_ctx), M_CRYPTO_DATA, 1093 M_WAITOK | M_ZERO); 1094 ctx = (struct twofish_xts_ctx *)*sched; 1095 1096 twofish_set_key(&ctx->key1, key, len * 4); 1097 twofish_set_key(&ctx->key2, key + (len / 2), len * 4); 1098 1099 return 0; 1100 } 1101 1102 void 1103 twofish_xts_zerokey(u_int8_t **sched) 1104 { 1105 bzero(*sched, sizeof(struct twofish_xts_ctx)); 1106 kfree(*sched, M_CRYPTO_DATA); 1107 *sched = NULL; 1108 } 1109 1110 struct serpent_xts_ctx { 1111 serpent_ctx key1; 1112 serpent_ctx key2; 1113 }; 1114 1115 void 1116 serpent_xts_reinit(caddr_t key, u_int8_t *iv) 1117 { 1118 struct serpent_xts_ctx *ctx = (struct serpent_xts_ctx *)key; 1119 #if 0 1120 u_int64_t blocknum; 1121 u_int i; 1122 #endif 1123 1124 #if 0 1125 /* 1126 * Prepare tweak as E_k2(IV). IV is specified as LE representation 1127 * of a 64-bit block number which we allow to be passed in directly. 1128 */ 1129 /* XXX: possibly use htole64? */ 1130 #endif 1131 /* Last 64 bits of IV are always zero */ 1132 bzero(iv + SERPENT_XTS_IV_LEN, SERPENT_XTS_IV_LEN); 1133 1134 serpent_encrypt(&ctx->key2, iv, iv); 1135 } 1136 1137 void 1138 serpent_xts_crypt(struct serpent_xts_ctx *ctx, u_int8_t *data, u_int8_t *iv, 1139 u_int do_encrypt) 1140 { 1141 u_int8_t block[SERPENT_XTS_BLOCK_LEN]; 1142 u_int i, carry_in, carry_out; 1143 1144 for (i = 0; i < SERPENT_XTS_BLOCK_LEN; i++) 1145 block[i] = data[i] ^ iv[i]; 1146 1147 if (do_encrypt) 1148 serpent_encrypt(&ctx->key1, block, data); 1149 else 1150 serpent_decrypt(&ctx->key1, block, data); 1151 1152 for (i = 0; i < SERPENT_XTS_BLOCK_LEN; i++) 1153 data[i] ^= iv[i]; 1154 1155 /* Exponentiate tweak */ 1156 carry_in = 0; 1157 for (i = 0; i < SERPENT_XTS_BLOCK_LEN; i++) { 1158 carry_out = iv[i] & 0x80; 1159 iv[i] = (iv[i] << 1) | (carry_in ? 1 : 0); 1160 carry_in = carry_out; 1161 } 1162 if (carry_in) 1163 iv[0] ^= AES_XTS_ALPHA; 1164 bzero(block, sizeof(block)); 1165 } 1166 1167 void 1168 serpent_xts_encrypt(caddr_t key, u_int8_t *data, u_int8_t *iv) 1169 { 1170 serpent_xts_crypt((struct serpent_xts_ctx *)key, data, iv, 1); 1171 } 1172 1173 void 1174 serpent_xts_decrypt(caddr_t key, u_int8_t *data, u_int8_t *iv) 1175 { 1176 serpent_xts_crypt((struct serpent_xts_ctx *)key, data, iv, 0); 1177 } 1178 1179 int 1180 serpent_xts_setkey(u_int8_t **sched, u_int8_t *key, int len) 1181 { 1182 struct serpent_xts_ctx *ctx; 1183 1184 if (len != 32 && len != 64) 1185 return -1; 1186 1187 *sched = kmalloc(sizeof(struct serpent_xts_ctx), M_CRYPTO_DATA, 1188 M_WAITOK | M_ZERO); 1189 ctx = (struct serpent_xts_ctx *)*sched; 1190 1191 serpent_set_key(&ctx->key1, key, len * 4); 1192 serpent_set_key(&ctx->key2, key + (len / 2), len * 4); 1193 1194 return 0; 1195 } 1196 1197 void 1198 serpent_xts_zerokey(u_int8_t **sched) 1199 { 1200 bzero(*sched, sizeof(struct serpent_xts_ctx)); 1201 kfree(*sched, M_CRYPTO_DATA); 1202 *sched = NULL; 1203 } 1204 1205 1206 /* 1207 * And now for auth. 1208 */ 1209 1210 static void 1211 null_init(void *ctx) 1212 { 1213 } 1214 1215 static int 1216 null_update(void *ctx, u_int8_t *buf, u_int16_t len) 1217 { 1218 return 0; 1219 } 1220 1221 static void 1222 null_final(u_int8_t *buf, void *ctx) 1223 { 1224 if (buf != NULL) 1225 bzero(buf, 12); 1226 } 1227 1228 static int 1229 RMD160Update_int(void *ctx, u_int8_t *buf, u_int16_t len) 1230 { 1231 RMD160Update(ctx, buf, len); 1232 return 0; 1233 } 1234 1235 static int 1236 MD5Update_int(void *ctx, u_int8_t *buf, u_int16_t len) 1237 { 1238 MD5Update(ctx, buf, len); 1239 return 0; 1240 } 1241 1242 static void 1243 SHA1Init_int(void *ctx) 1244 { 1245 SHA1Init(ctx); 1246 } 1247 1248 static int 1249 SHA1Update_int(void *ctx, u_int8_t *buf, u_int16_t len) 1250 { 1251 SHA1Update(ctx, buf, len); 1252 return 0; 1253 } 1254 1255 static void 1256 SHA1Final_int(u_int8_t *blk, void *ctx) 1257 { 1258 SHA1Final(blk, ctx); 1259 } 1260 1261 static int 1262 SHA256Update_int(void *ctx, u_int8_t *buf, u_int16_t len) 1263 { 1264 SHA256_Update(ctx, buf, len); 1265 return 0; 1266 } 1267 1268 static int 1269 SHA384Update_int(void *ctx, u_int8_t *buf, u_int16_t len) 1270 { 1271 SHA384_Update(ctx, buf, len); 1272 return 0; 1273 } 1274 1275 static int 1276 SHA512Update_int(void *ctx, u_int8_t *buf, u_int16_t len) 1277 { 1278 SHA512_Update(ctx, buf, len); 1279 return 0; 1280 } 1281 1282 /* 1283 * And compression 1284 */ 1285 1286 static u_int32_t 1287 deflate_compress(u_int8_t *data, u_int32_t size, u_int8_t **out) 1288 { 1289 return deflate_global(data, size, 0, out); 1290 } 1291 1292 static u_int32_t 1293 deflate_decompress(u_int8_t *data, u_int32_t size, u_int8_t **out) 1294 { 1295 return deflate_global(data, size, 1, out); 1296 } 1297