xform_gmac.c revision 286292
1283514Sarybchik/* $OpenBSD: xform.c,v 1.16 2001/08/28 12:20:43 ben Exp $ */ 2283514Sarybchik/*- 3283514Sarybchik * The authors of this code are John Ioannidis (ji@tla.org), 4283514Sarybchik * Angelos D. Keromytis (kermit@csd.uch.gr), 5283514Sarybchik * Niels Provos (provos@physnet.uni-hamburg.de) and 6283514Sarybchik * Damien Miller (djm@mindrot.org). 7283514Sarybchik * 8283514Sarybchik * This code was written by John Ioannidis for BSD/OS in Athens, Greece, 9283514Sarybchik * in November 1995. 10283514Sarybchik * 11283514Sarybchik * Ported to OpenBSD and NetBSD, with additional transforms, in December 1996, 12283514Sarybchik * by Angelos D. Keromytis. 13283514Sarybchik * 14283514Sarybchik * Additional transforms and features in 1997 and 1998 by Angelos D. Keromytis 15283514Sarybchik * and Niels Provos. 16283514Sarybchik * 17283514Sarybchik * Additional features in 1999 by Angelos D. Keromytis. 18283514Sarybchik * 19283514Sarybchik * AES XTS implementation in 2008 by Damien Miller 20283514Sarybchik * 21283514Sarybchik * Copyright (C) 1995, 1996, 1997, 1998, 1999 by John Ioannidis, 22283514Sarybchik * Angelos D. Keromytis and Niels Provos. 23283514Sarybchik * 24283514Sarybchik * Copyright (C) 2001, Angelos D. Keromytis. 25283514Sarybchik * 26283514Sarybchik * Copyright (C) 2008, Damien Miller 27283514Sarybchik * Copyright (c) 2014 The FreeBSD Foundation 28283514Sarybchik * All rights reserved. 29283514Sarybchik * 30283514Sarybchik * Portions of this software were developed by John-Mark Gurney 31283514Sarybchik * under sponsorship of the FreeBSD Foundation and 32283514Sarybchik * Rubicon Communications, LLC (Netgate). 33283514Sarybchik * 34283514Sarybchik * Permission to use, copy, and modify this software with or without fee 35283514Sarybchik * is hereby granted, provided that this entire notice is included in 36283514Sarybchik * all copies of any software which is or includes a copy or 37283514Sarybchik * modification of this software. 38283514Sarybchik * You may use this code under the GNU public license if you so wish. Please 39283514Sarybchik * contribute changes back to the authors under this freer than GPL license 40283514Sarybchik * so that we may further the use of strong encryption without limitations to 41283514Sarybchik * all. 42283514Sarybchik * 43283514Sarybchik * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR 44283514Sarybchik * IMPLIED WARRANTY. IN PARTICULAR, NONE OF THE AUTHORS MAKES ANY 45283514Sarybchik * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE 46283514Sarybchik * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR 47283514Sarybchik * PURPOSE. 48283514Sarybchik */ 49283514Sarybchik 50283514Sarybchik#include <sys/cdefs.h> 51283514Sarybchik__FBSDID("$FreeBSD: head/sys/opencrypto/xform.c 286292 2015-08-04 17:47:11Z jmg $"); 52283514Sarybchik 53283514Sarybchik#include <sys/param.h> 54283514Sarybchik#include <sys/systm.h> 55283514Sarybchik#include <sys/malloc.h> 56283514Sarybchik#include <sys/sysctl.h> 57283514Sarybchik#include <sys/errno.h> 58283514Sarybchik#include <sys/time.h> 59283514Sarybchik#include <sys/kernel.h> 60283514Sarybchik#include <machine/cpu.h> 61283514Sarybchik 62283514Sarybchik#include <crypto/blowfish/blowfish.h> 63283514Sarybchik#include <crypto/des/des.h> 64283514Sarybchik#include <crypto/rijndael/rijndael.h> 65283514Sarybchik#include <crypto/camellia/camellia.h> 66283514Sarybchik#include <crypto/sha1.h> 67283514Sarybchik 68283514Sarybchik#include <opencrypto/cast.h> 69283514Sarybchik#include <opencrypto/deflate.h> 70283514Sarybchik#include <opencrypto/rmd160.h> 71283514Sarybchik#include <opencrypto/skipjack.h> 72283514Sarybchik 73283514Sarybchik#include <sys/md5.h> 74283514Sarybchik 75283514Sarybchik#include <opencrypto/cryptodev.h> 76283514Sarybchik#include <opencrypto/xform.h> 77283514Sarybchik 78283514Sarybchikstatic int null_setkey(u_int8_t **, u_int8_t *, int); 79283514Sarybchikstatic int des1_setkey(u_int8_t **, u_int8_t *, int); 80283514Sarybchikstatic int des3_setkey(u_int8_t **, u_int8_t *, int); 81283514Sarybchikstatic int blf_setkey(u_int8_t **, u_int8_t *, int); 82283514Sarybchikstatic int cast5_setkey(u_int8_t **, u_int8_t *, int); 83283514Sarybchikstatic int skipjack_setkey(u_int8_t **, u_int8_t *, int); 84283514Sarybchikstatic int rijndael128_setkey(u_int8_t **, u_int8_t *, int); 85283514Sarybchikstatic int aes_icm_setkey(u_int8_t **, u_int8_t *, int); 86283514Sarybchikstatic int aes_xts_setkey(u_int8_t **, u_int8_t *, int); 87283514Sarybchikstatic int cml_setkey(u_int8_t **, u_int8_t *, int); 88283514Sarybchik 89283514Sarybchikstatic void null_encrypt(caddr_t, u_int8_t *); 90283514Sarybchikstatic void des1_encrypt(caddr_t, u_int8_t *); 91283514Sarybchikstatic void des3_encrypt(caddr_t, u_int8_t *); 92283514Sarybchikstatic void blf_encrypt(caddr_t, u_int8_t *); 93283514Sarybchikstatic void cast5_encrypt(caddr_t, u_int8_t *); 94283514Sarybchikstatic void skipjack_encrypt(caddr_t, u_int8_t *); 95283514Sarybchikstatic void rijndael128_encrypt(caddr_t, u_int8_t *); 96283514Sarybchikstatic void aes_xts_encrypt(caddr_t, u_int8_t *); 97283514Sarybchikstatic void cml_encrypt(caddr_t, u_int8_t *); 98283514Sarybchik 99283514Sarybchikstatic void null_decrypt(caddr_t, u_int8_t *); 100283514Sarybchikstatic void des1_decrypt(caddr_t, u_int8_t *); 101283514Sarybchikstatic void des3_decrypt(caddr_t, u_int8_t *); 102283514Sarybchikstatic void blf_decrypt(caddr_t, u_int8_t *); 103283514Sarybchikstatic void cast5_decrypt(caddr_t, u_int8_t *); 104283514Sarybchikstatic void skipjack_decrypt(caddr_t, u_int8_t *); 105283514Sarybchikstatic void rijndael128_decrypt(caddr_t, u_int8_t *); 106283514Sarybchikstatic void aes_xts_decrypt(caddr_t, u_int8_t *); 107283514Sarybchikstatic void cml_decrypt(caddr_t, u_int8_t *); 108283514Sarybchik 109283514Sarybchikstatic void aes_icm_crypt(caddr_t, u_int8_t *); 110283514Sarybchik 111283514Sarybchikstatic void null_zerokey(u_int8_t **); 112283514Sarybchikstatic void des1_zerokey(u_int8_t **); 113283514Sarybchikstatic void des3_zerokey(u_int8_t **); 114283514Sarybchikstatic void blf_zerokey(u_int8_t **); 115283514Sarybchikstatic void cast5_zerokey(u_int8_t **); 116283514Sarybchikstatic void skipjack_zerokey(u_int8_t **); 117283514Sarybchikstatic void rijndael128_zerokey(u_int8_t **); 118283514Sarybchikstatic void aes_icm_zerokey(u_int8_t **); 119283514Sarybchikstatic void aes_xts_zerokey(u_int8_t **); 120283514Sarybchikstatic void cml_zerokey(u_int8_t **); 121283514Sarybchik 122283514Sarybchikstatic void aes_icm_reinit(caddr_t, u_int8_t *); 123283514Sarybchikstatic void aes_xts_reinit(caddr_t, u_int8_t *); 124283514Sarybchikstatic void aes_gcm_reinit(caddr_t, u_int8_t *); 125283514Sarybchik 126283514Sarybchikstatic void null_init(void *); 127283514Sarybchikstatic void null_reinit(void *ctx, const u_int8_t *buf, u_int16_t len); 128283514Sarybchikstatic int null_update(void *, const u_int8_t *, u_int16_t); 129283514Sarybchikstatic void null_final(u_int8_t *, void *); 130283514Sarybchikstatic int MD5Update_int(void *, const u_int8_t *, u_int16_t); 131283514Sarybchikstatic void SHA1Init_int(void *); 132283514Sarybchikstatic int SHA1Update_int(void *, const u_int8_t *, u_int16_t); 133283514Sarybchikstatic void SHA1Final_int(u_int8_t *, void *); 134283514Sarybchikstatic int RMD160Update_int(void *, const u_int8_t *, u_int16_t); 135283514Sarybchikstatic int SHA256Update_int(void *, const u_int8_t *, u_int16_t); 136283514Sarybchikstatic int SHA384Update_int(void *, const u_int8_t *, u_int16_t); 137283514Sarybchikstatic int SHA512Update_int(void *, const u_int8_t *, u_int16_t); 138283514Sarybchik 139283514Sarybchikstatic u_int32_t deflate_compress(u_int8_t *, u_int32_t, u_int8_t **); 140283514Sarybchikstatic u_int32_t deflate_decompress(u_int8_t *, u_int32_t, u_int8_t **); 141283514Sarybchik 142283514Sarybchik#define AESICM_BLOCKSIZE AES_BLOCK_LEN 143283514Sarybchik 144283514Sarybchikstruct aes_icm_ctx { 145283514Sarybchik u_int32_t ac_ek[4*(RIJNDAEL_MAXNR + 1)]; 146283514Sarybchik /* ac_block is initalized to IV */ 147283514Sarybchik u_int8_t ac_block[AESICM_BLOCKSIZE]; 148283514Sarybchik int ac_nr; 149283514Sarybchik}; 150283514Sarybchik 151283514SarybchikMALLOC_DEFINE(M_XDATA, "xform", "xform data buffers"); 152283514Sarybchik 153283514Sarybchik/* Encryption instances */ 154283514Sarybchikstruct enc_xform enc_xform_null = { 155283514Sarybchik CRYPTO_NULL_CBC, "NULL", 156283514Sarybchik /* NB: blocksize of 4 is to generate a properly aligned ESP header */ 157283514Sarybchik NULL_BLOCK_LEN, NULL_BLOCK_LEN, NULL_MIN_KEY, NULL_MAX_KEY, 158283514Sarybchik null_encrypt, 159283514Sarybchik null_decrypt, 160283514Sarybchik null_setkey, 161283514Sarybchik null_zerokey, 162283514Sarybchik NULL, 163283514Sarybchik}; 164283514Sarybchik 165283514Sarybchikstruct enc_xform enc_xform_des = { 166283514Sarybchik CRYPTO_DES_CBC, "DES", 167283514Sarybchik DES_BLOCK_LEN, DES_BLOCK_LEN, DES_MIN_KEY, DES_MAX_KEY, 168283514Sarybchik des1_encrypt, 169283514Sarybchik des1_decrypt, 170283514Sarybchik des1_setkey, 171283514Sarybchik des1_zerokey, 172283514Sarybchik NULL, 173283514Sarybchik}; 174283514Sarybchik 175283514Sarybchikstruct enc_xform enc_xform_3des = { 176283514Sarybchik CRYPTO_3DES_CBC, "3DES", 177283514Sarybchik DES3_BLOCK_LEN, DES3_BLOCK_LEN, TRIPLE_DES_MIN_KEY, 178283514Sarybchik TRIPLE_DES_MAX_KEY, 179283514Sarybchik des3_encrypt, 180283514Sarybchik des3_decrypt, 181283514Sarybchik des3_setkey, 182283514Sarybchik des3_zerokey, 183283514Sarybchik NULL, 184283514Sarybchik}; 185283514Sarybchik 186283514Sarybchikstruct enc_xform enc_xform_blf = { 187283514Sarybchik CRYPTO_BLF_CBC, "Blowfish", 188283514Sarybchik BLOWFISH_BLOCK_LEN, BLOWFISH_BLOCK_LEN, BLOWFISH_MIN_KEY, 189283514Sarybchik BLOWFISH_MAX_KEY, 190283514Sarybchik blf_encrypt, 191283514Sarybchik blf_decrypt, 192283514Sarybchik blf_setkey, 193283514Sarybchik blf_zerokey, 194283514Sarybchik NULL, 195283514Sarybchik}; 196283514Sarybchik 197283514Sarybchikstruct enc_xform enc_xform_cast5 = { 198283514Sarybchik CRYPTO_CAST_CBC, "CAST-128", 199283514Sarybchik CAST128_BLOCK_LEN, CAST128_BLOCK_LEN, CAST_MIN_KEY, CAST_MAX_KEY, 200283514Sarybchik cast5_encrypt, 201283514Sarybchik cast5_decrypt, 202283514Sarybchik cast5_setkey, 203283514Sarybchik cast5_zerokey, 204283514Sarybchik NULL, 205283514Sarybchik}; 206283514Sarybchik 207283514Sarybchikstruct enc_xform enc_xform_skipjack = { 208283514Sarybchik CRYPTO_SKIPJACK_CBC, "Skipjack", 209283514Sarybchik SKIPJACK_BLOCK_LEN, SKIPJACK_BLOCK_LEN, SKIPJACK_MIN_KEY, 210283514Sarybchik SKIPJACK_MAX_KEY, 211283514Sarybchik skipjack_encrypt, 212283514Sarybchik skipjack_decrypt, skipjack_setkey, 213283514Sarybchik skipjack_zerokey, 214283514Sarybchik NULL, 215283514Sarybchik}; 216283514Sarybchik 217283514Sarybchikstruct enc_xform enc_xform_rijndael128 = { 218283514Sarybchik CRYPTO_RIJNDAEL128_CBC, "Rijndael-128/AES", 219283514Sarybchik RIJNDAEL128_BLOCK_LEN, RIJNDAEL128_BLOCK_LEN, RIJNDAEL_MIN_KEY, 220283514Sarybchik RIJNDAEL_MAX_KEY, 221283514Sarybchik rijndael128_encrypt, 222283514Sarybchik rijndael128_decrypt, 223283514Sarybchik rijndael128_setkey, 224283514Sarybchik rijndael128_zerokey, 225283514Sarybchik NULL, 226283514Sarybchik}; 227283514Sarybchik 228283514Sarybchikstruct enc_xform enc_xform_aes_icm = { 229283514Sarybchik CRYPTO_AES_ICM, "AES-ICM", 230283514Sarybchik AES_BLOCK_LEN, AES_BLOCK_LEN, AES_MIN_KEY, AES_MAX_KEY, 231283514Sarybchik aes_icm_crypt, 232283514Sarybchik aes_icm_crypt, 233283514Sarybchik aes_icm_setkey, 234283514Sarybchik rijndael128_zerokey, 235283514Sarybchik aes_icm_reinit, 236283514Sarybchik}; 237283514Sarybchik 238283514Sarybchikstruct enc_xform enc_xform_aes_nist_gcm = { 239283514Sarybchik CRYPTO_AES_NIST_GCM_16, "AES-GCM", 240283514Sarybchik AES_ICM_BLOCK_LEN, AES_GCM_IV_LEN, AES_MIN_KEY, AES_MAX_KEY, 241283514Sarybchik aes_icm_crypt, 242283514Sarybchik aes_icm_crypt, 243283514Sarybchik aes_icm_setkey, 244283514Sarybchik aes_icm_zerokey, 245283514Sarybchik aes_gcm_reinit, 246283514Sarybchik}; 247283514Sarybchik 248283514Sarybchikstruct enc_xform enc_xform_aes_nist_gmac = { 249283514Sarybchik CRYPTO_AES_NIST_GMAC, "AES-GMAC", 250283514Sarybchik AES_ICM_BLOCK_LEN, AES_GCM_IV_LEN, AES_MIN_KEY, AES_MAX_KEY, 251283514Sarybchik NULL, 252283514Sarybchik NULL, 253283514Sarybchik NULL, 254283514Sarybchik NULL, 255283514Sarybchik NULL, 256283514Sarybchik}; 257283514Sarybchik 258283514Sarybchikstruct enc_xform enc_xform_aes_xts = { 259283514Sarybchik CRYPTO_AES_XTS, "AES-XTS", 260283514Sarybchik AES_BLOCK_LEN, AES_XTS_IV_LEN, AES_XTS_MIN_KEY, AES_XTS_MAX_KEY, 261283514Sarybchik aes_xts_encrypt, 262283514Sarybchik aes_xts_decrypt, 263283514Sarybchik aes_xts_setkey, 264283514Sarybchik aes_xts_zerokey, 265283514Sarybchik aes_xts_reinit 266283514Sarybchik}; 267283514Sarybchik 268283514Sarybchikstruct enc_xform enc_xform_arc4 = { 269283514Sarybchik CRYPTO_ARC4, "ARC4", 270283514Sarybchik ARC4_BLOCK_LEN, ARC4_IV_LEN, ARC4_MIN_KEY, ARC4_MAX_KEY, 271283514Sarybchik NULL, 272283514Sarybchik NULL, 273283514Sarybchik NULL, 274283514Sarybchik NULL, 275283514Sarybchik NULL, 276283514Sarybchik}; 277283514Sarybchik 278283514Sarybchikstruct enc_xform enc_xform_camellia = { 279283514Sarybchik CRYPTO_CAMELLIA_CBC, "Camellia", 280283514Sarybchik CAMELLIA_BLOCK_LEN, CAMELLIA_BLOCK_LEN, CAMELLIA_MIN_KEY, 281283514Sarybchik CAMELLIA_MAX_KEY, 282283514Sarybchik cml_encrypt, 283283514Sarybchik cml_decrypt, 284283514Sarybchik cml_setkey, 285283514Sarybchik cml_zerokey, 286283514Sarybchik NULL, 287283514Sarybchik}; 288283514Sarybchik 289283514Sarybchik/* Authentication instances */ 290283514Sarybchikstruct auth_hash auth_hash_null = { /* NB: context isn't used */ 291283514Sarybchik CRYPTO_NULL_HMAC, "NULL-HMAC", 292283514Sarybchik NULL_HMAC_KEY_LEN, NULL_HASH_LEN, sizeof(int), NULL_HMAC_BLOCK_LEN, 293283514Sarybchik null_init, null_reinit, null_reinit, null_update, null_final 294283514Sarybchik}; 295283514Sarybchik 296283514Sarybchikstruct auth_hash auth_hash_hmac_md5 = { 297283514Sarybchik CRYPTO_MD5_HMAC, "HMAC-MD5", 298283514Sarybchik MD5_HMAC_KEY_LEN, MD5_HASH_LEN, sizeof(MD5_CTX), MD5_HMAC_BLOCK_LEN, 299283514Sarybchik (void (*) (void *)) MD5Init, NULL, NULL, MD5Update_int, 300283514Sarybchik (void (*) (u_int8_t *, void *)) MD5Final 301283514Sarybchik}; 302283514Sarybchik 303283514Sarybchikstruct auth_hash auth_hash_hmac_sha1 = { 304283514Sarybchik CRYPTO_SHA1_HMAC, "HMAC-SHA1", 305283514Sarybchik SHA1_HMAC_KEY_LEN, SHA1_HASH_LEN, sizeof(SHA1_CTX), SHA1_HMAC_BLOCK_LEN, 306283514Sarybchik SHA1Init_int, NULL, NULL, SHA1Update_int, SHA1Final_int 307283514Sarybchik}; 308283514Sarybchik 309283514Sarybchikstruct auth_hash auth_hash_hmac_ripemd_160 = { 310283514Sarybchik CRYPTO_RIPEMD160_HMAC, "HMAC-RIPEMD-160", 311283514Sarybchik RIPEMD160_HMAC_KEY_LEN, RIPEMD160_HASH_LEN, sizeof(RMD160_CTX), 312283514Sarybchik RIPEMD160_HMAC_BLOCK_LEN, 313283514Sarybchik (void (*)(void *)) RMD160Init, NULL, NULL, RMD160Update_int, 314283514Sarybchik (void (*)(u_int8_t *, void *)) RMD160Final 315283514Sarybchik}; 316283514Sarybchik 317283514Sarybchikstruct auth_hash auth_hash_key_md5 = { 318283514Sarybchik CRYPTO_MD5_KPDK, "Keyed MD5", 319283514Sarybchik NULL_HMAC_KEY_LEN, MD5_KPDK_HASH_LEN, sizeof(MD5_CTX), 0, 320283514Sarybchik (void (*)(void *)) MD5Init, NULL, NULL, MD5Update_int, 321283514Sarybchik (void (*)(u_int8_t *, void *)) MD5Final 322283514Sarybchik}; 323283514Sarybchik 324283514Sarybchikstruct auth_hash auth_hash_key_sha1 = { 325283514Sarybchik CRYPTO_SHA1_KPDK, "Keyed SHA1", 326283514Sarybchik NULL_HMAC_KEY_LEN, SHA1_KPDK_HASH_LEN, sizeof(SHA1_CTX), 0, 327283514Sarybchik SHA1Init_int, NULL, NULL, SHA1Update_int, SHA1Final_int 328283514Sarybchik}; 329283514Sarybchik 330283514Sarybchikstruct auth_hash auth_hash_hmac_sha2_256 = { 331283514Sarybchik CRYPTO_SHA2_256_HMAC, "HMAC-SHA2-256", 332283514Sarybchik SHA2_256_HMAC_KEY_LEN, SHA2_256_HASH_LEN, sizeof(SHA256_CTX), 333283514Sarybchik SHA2_256_HMAC_BLOCK_LEN, 334283514Sarybchik (void (*)(void *)) SHA256_Init, NULL, NULL, SHA256Update_int, 335283514Sarybchik (void (*)(u_int8_t *, void *)) SHA256_Final 336283514Sarybchik}; 337283514Sarybchik 338283514Sarybchikstruct auth_hash auth_hash_hmac_sha2_384 = { 339283514Sarybchik CRYPTO_SHA2_384_HMAC, "HMAC-SHA2-384", 340283514Sarybchik SHA2_384_HMAC_KEY_LEN, SHA2_384_HASH_LEN, sizeof(SHA384_CTX), 341283514Sarybchik SHA2_384_HMAC_BLOCK_LEN, 342283514Sarybchik (void (*)(void *)) SHA384_Init, NULL, NULL, SHA384Update_int, 343283514Sarybchik (void (*)(u_int8_t *, void *)) SHA384_Final 344283514Sarybchik}; 345283514Sarybchik 346283514Sarybchikstruct auth_hash auth_hash_hmac_sha2_512 = { 347283514Sarybchik CRYPTO_SHA2_512_HMAC, "HMAC-SHA2-512", 348283514Sarybchik SHA2_512_HMAC_KEY_LEN, SHA2_512_HASH_LEN, sizeof(SHA512_CTX), 349283514Sarybchik SHA2_512_HMAC_BLOCK_LEN, 350283514Sarybchik (void (*)(void *)) SHA512_Init, NULL, NULL, SHA512Update_int, 351283514Sarybchik (void (*)(u_int8_t *, void *)) SHA512_Final 352283514Sarybchik}; 353283514Sarybchik 354283514Sarybchikstruct auth_hash auth_hash_nist_gmac_aes_128 = { 355283514Sarybchik CRYPTO_AES_128_NIST_GMAC, "GMAC-AES-128", 356283514Sarybchik AES_128_GMAC_KEY_LEN, AES_GMAC_HASH_LEN, sizeof(struct aes_gmac_ctx), 357283514Sarybchik GMAC_BLOCK_LEN, 358283514Sarybchik (void (*)(void *)) AES_GMAC_Init, 359283514Sarybchik (void (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Setkey, 360283514Sarybchik (void (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Reinit, 361283514Sarybchik (int (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Update, 362283514Sarybchik (void (*)(u_int8_t *, void *)) AES_GMAC_Final 363283514Sarybchik}; 364283514Sarybchik 365283514Sarybchikstruct auth_hash auth_hash_nist_gmac_aes_192 = { 366283514Sarybchik CRYPTO_AES_192_NIST_GMAC, "GMAC-AES-192", 367283514Sarybchik AES_192_GMAC_KEY_LEN, AES_GMAC_HASH_LEN, sizeof(struct aes_gmac_ctx), 368283514Sarybchik GMAC_BLOCK_LEN, 369283514Sarybchik (void (*)(void *)) AES_GMAC_Init, 370283514Sarybchik (void (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Setkey, 371283514Sarybchik (void (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Reinit, 372283514Sarybchik (int (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Update, 373283514Sarybchik (void (*)(u_int8_t *, void *)) AES_GMAC_Final 374283514Sarybchik}; 375283514Sarybchik 376283514Sarybchikstruct auth_hash auth_hash_nist_gmac_aes_256 = { 377283514Sarybchik CRYPTO_AES_256_NIST_GMAC, "GMAC-AES-256", 378283514Sarybchik AES_256_GMAC_KEY_LEN, AES_GMAC_HASH_LEN, sizeof(struct aes_gmac_ctx), 379283514Sarybchik GMAC_BLOCK_LEN, 380283514Sarybchik (void (*)(void *)) AES_GMAC_Init, 381283514Sarybchik (void (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Setkey, 382283514Sarybchik (void (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Reinit, 383283514Sarybchik (int (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Update, 384283514Sarybchik (void (*)(u_int8_t *, void *)) AES_GMAC_Final 385283514Sarybchik}; 386283514Sarybchik 387283514Sarybchik/* Compression instance */ 388283514Sarybchikstruct comp_algo comp_algo_deflate = { 389283514Sarybchik CRYPTO_DEFLATE_COMP, "Deflate", 390283514Sarybchik 90, deflate_compress, 391283514Sarybchik deflate_decompress 392283514Sarybchik}; 393283514Sarybchik 394283514Sarybchik/* 395283514Sarybchik * Encryption wrapper routines. 396283514Sarybchik */ 397283514Sarybchikstatic void 398283514Sarybchiknull_encrypt(caddr_t key, u_int8_t *blk) 399283514Sarybchik{ 400283514Sarybchik} 401283514Sarybchikstatic void 402283514Sarybchiknull_decrypt(caddr_t key, u_int8_t *blk) 403283514Sarybchik{ 404283514Sarybchik} 405283514Sarybchikstatic int 406283514Sarybchiknull_setkey(u_int8_t **sched, u_int8_t *key, int len) 407283514Sarybchik{ 408283514Sarybchik *sched = NULL; 409283514Sarybchik return 0; 410283514Sarybchik} 411283514Sarybchikstatic void 412283514Sarybchiknull_zerokey(u_int8_t **sched) 413283514Sarybchik{ 414283514Sarybchik *sched = NULL; 415283514Sarybchik} 416283514Sarybchik 417283514Sarybchikstatic void 418283514Sarybchikdes1_encrypt(caddr_t key, u_int8_t *blk) 419283514Sarybchik{ 420283514Sarybchik des_cblock *cb = (des_cblock *) blk; 421283514Sarybchik des_key_schedule *p = (des_key_schedule *) key; 422283514Sarybchik 423283514Sarybchik des_ecb_encrypt(cb, cb, p[0], DES_ENCRYPT); 424283514Sarybchik} 425283514Sarybchik 426283514Sarybchikstatic void 427283514Sarybchikdes1_decrypt(caddr_t key, u_int8_t *blk) 428283514Sarybchik{ 429283514Sarybchik des_cblock *cb = (des_cblock *) blk; 430283514Sarybchik des_key_schedule *p = (des_key_schedule *) key; 431283514Sarybchik 432283514Sarybchik des_ecb_encrypt(cb, cb, p[0], DES_DECRYPT); 433283514Sarybchik} 434283514Sarybchik 435283514Sarybchikstatic int 436283514Sarybchikdes1_setkey(u_int8_t **sched, u_int8_t *key, int len) 437283514Sarybchik{ 438283514Sarybchik des_key_schedule *p; 439283514Sarybchik int err; 440283514Sarybchik 441283514Sarybchik p = malloc(sizeof (des_key_schedule), 442283514Sarybchik M_CRYPTO_DATA, M_NOWAIT|M_ZERO); 443283514Sarybchik if (p != NULL) { 444283514Sarybchik des_set_key((des_cblock *) key, p[0]); 445283514Sarybchik err = 0; 446283514Sarybchik } else 447283514Sarybchik err = ENOMEM; 448283514Sarybchik *sched = (u_int8_t *) p; 449283514Sarybchik return err; 450283514Sarybchik} 451283514Sarybchik 452283514Sarybchikstatic void 453283514Sarybchikdes1_zerokey(u_int8_t **sched) 454283514Sarybchik{ 455283514Sarybchik bzero(*sched, sizeof (des_key_schedule)); 456283514Sarybchik free(*sched, M_CRYPTO_DATA); 457283514Sarybchik *sched = NULL; 458283514Sarybchik} 459283514Sarybchik 460283514Sarybchikstatic void 461283514Sarybchikdes3_encrypt(caddr_t key, u_int8_t *blk) 462283514Sarybchik{ 463283514Sarybchik des_cblock *cb = (des_cblock *) blk; 464283514Sarybchik des_key_schedule *p = (des_key_schedule *) key; 465283514Sarybchik 466283514Sarybchik des_ecb3_encrypt(cb, cb, p[0], p[1], p[2], DES_ENCRYPT); 467283514Sarybchik} 468283514Sarybchik 469283514Sarybchikstatic void 470283514Sarybchikdes3_decrypt(caddr_t key, u_int8_t *blk) 471283514Sarybchik{ 472283514Sarybchik des_cblock *cb = (des_cblock *) blk; 473283514Sarybchik des_key_schedule *p = (des_key_schedule *) key; 474283514Sarybchik 475283514Sarybchik des_ecb3_encrypt(cb, cb, p[0], p[1], p[2], DES_DECRYPT); 476283514Sarybchik} 477283514Sarybchik 478283514Sarybchikstatic int 479283514Sarybchikdes3_setkey(u_int8_t **sched, u_int8_t *key, int len) 480283514Sarybchik{ 481283514Sarybchik des_key_schedule *p; 482283514Sarybchik int err; 483283514Sarybchik 484283514Sarybchik p = malloc(3*sizeof (des_key_schedule), 485283514Sarybchik M_CRYPTO_DATA, M_NOWAIT|M_ZERO); 486283514Sarybchik if (p != NULL) { 487283514Sarybchik des_set_key((des_cblock *)(key + 0), p[0]); 488283514Sarybchik des_set_key((des_cblock *)(key + 8), p[1]); 489283514Sarybchik des_set_key((des_cblock *)(key + 16), p[2]); 490283514Sarybchik err = 0; 491283514Sarybchik } else 492283514Sarybchik err = ENOMEM; 493283514Sarybchik *sched = (u_int8_t *) p; 494283514Sarybchik return err; 495283514Sarybchik} 496283514Sarybchik 497283514Sarybchikstatic void 498283514Sarybchikdes3_zerokey(u_int8_t **sched) 499283514Sarybchik{ 500283514Sarybchik bzero(*sched, 3*sizeof (des_key_schedule)); 501283514Sarybchik free(*sched, M_CRYPTO_DATA); 502283514Sarybchik *sched = NULL; 503283514Sarybchik} 504283514Sarybchik 505283514Sarybchikstatic void 506283514Sarybchikblf_encrypt(caddr_t key, u_int8_t *blk) 507283514Sarybchik{ 508283514Sarybchik BF_LONG t[2]; 509283514Sarybchik 510283514Sarybchik memcpy(t, blk, sizeof (t)); 511283514Sarybchik t[0] = ntohl(t[0]); 512283514Sarybchik t[1] = ntohl(t[1]); 513283514Sarybchik /* NB: BF_encrypt expects the block in host order! */ 514283514Sarybchik BF_encrypt(t, (BF_KEY *) key); 515283514Sarybchik t[0] = htonl(t[0]); 516283514Sarybchik t[1] = htonl(t[1]); 517283514Sarybchik memcpy(blk, t, sizeof (t)); 518283514Sarybchik} 519283514Sarybchik 520283514Sarybchikstatic void 521283514Sarybchikblf_decrypt(caddr_t key, u_int8_t *blk) 522283514Sarybchik{ 523283514Sarybchik BF_LONG t[2]; 524283514Sarybchik 525283514Sarybchik memcpy(t, blk, sizeof (t)); 526283514Sarybchik t[0] = ntohl(t[0]); 527283514Sarybchik t[1] = ntohl(t[1]); 528283514Sarybchik /* NB: BF_decrypt expects the block in host order! */ 529283514Sarybchik BF_decrypt(t, (BF_KEY *) key); 530283514Sarybchik t[0] = htonl(t[0]); 531283514Sarybchik t[1] = htonl(t[1]); 532283514Sarybchik memcpy(blk, t, sizeof (t)); 533283514Sarybchik} 534283514Sarybchik 535283514Sarybchikstatic int 536283514Sarybchikblf_setkey(u_int8_t **sched, u_int8_t *key, int len) 537283514Sarybchik{ 538283514Sarybchik int err; 539283514Sarybchik 540283514Sarybchik *sched = malloc(sizeof(BF_KEY), 541283514Sarybchik M_CRYPTO_DATA, M_NOWAIT|M_ZERO); 542283514Sarybchik if (*sched != NULL) { 543283514Sarybchik BF_set_key((BF_KEY *) *sched, len, key); 544283514Sarybchik err = 0; 545283514Sarybchik } else 546283514Sarybchik err = ENOMEM; 547283514Sarybchik return err; 548283514Sarybchik} 549283514Sarybchik 550283514Sarybchikstatic void 551283514Sarybchikblf_zerokey(u_int8_t **sched) 552283514Sarybchik{ 553283514Sarybchik bzero(*sched, sizeof(BF_KEY)); 554283514Sarybchik free(*sched, M_CRYPTO_DATA); 555283514Sarybchik *sched = NULL; 556283514Sarybchik} 557283514Sarybchik 558283514Sarybchikstatic void 559283514Sarybchikcast5_encrypt(caddr_t key, u_int8_t *blk) 560283514Sarybchik{ 561283514Sarybchik cast_encrypt((cast_key *) key, blk, blk); 562283514Sarybchik} 563283514Sarybchik 564283514Sarybchikstatic void 565283514Sarybchikcast5_decrypt(caddr_t key, u_int8_t *blk) 566283514Sarybchik{ 567283514Sarybchik cast_decrypt((cast_key *) key, blk, blk); 568283514Sarybchik} 569283514Sarybchik 570283514Sarybchikstatic int 571283514Sarybchikcast5_setkey(u_int8_t **sched, u_int8_t *key, int len) 572283514Sarybchik{ 573283514Sarybchik int err; 574283514Sarybchik 575283514Sarybchik *sched = malloc(sizeof(cast_key), M_CRYPTO_DATA, M_NOWAIT|M_ZERO); 576283514Sarybchik if (*sched != NULL) { 577283514Sarybchik cast_setkey((cast_key *)*sched, key, len); 578283514Sarybchik err = 0; 579283514Sarybchik } else 580283514Sarybchik err = ENOMEM; 581283514Sarybchik return err; 582283514Sarybchik} 583283514Sarybchik 584283514Sarybchikstatic void 585283514Sarybchikcast5_zerokey(u_int8_t **sched) 586283514Sarybchik{ 587283514Sarybchik bzero(*sched, sizeof(cast_key)); 588283514Sarybchik free(*sched, M_CRYPTO_DATA); 589283514Sarybchik *sched = NULL; 590283514Sarybchik} 591283514Sarybchik 592283514Sarybchikstatic void 593283514Sarybchikskipjack_encrypt(caddr_t key, u_int8_t *blk) 594283514Sarybchik{ 595283514Sarybchik skipjack_forwards(blk, blk, (u_int8_t **) key); 596283514Sarybchik} 597283514Sarybchik 598283514Sarybchikstatic void 599283514Sarybchikskipjack_decrypt(caddr_t key, u_int8_t *blk) 600283514Sarybchik{ 601283514Sarybchik skipjack_backwards(blk, blk, (u_int8_t **) key); 602283514Sarybchik} 603283514Sarybchik 604283514Sarybchikstatic int 605283514Sarybchikskipjack_setkey(u_int8_t **sched, u_int8_t *key, int len) 606283514Sarybchik{ 607283514Sarybchik int err; 608283514Sarybchik 609283514Sarybchik /* NB: allocate all the memory that's needed at once */ 610283514Sarybchik *sched = malloc(10 * (sizeof(u_int8_t *) + 0x100), 611283514Sarybchik M_CRYPTO_DATA, M_NOWAIT|M_ZERO); 612283514Sarybchik if (*sched != NULL) { 613283514Sarybchik u_int8_t** key_tables = (u_int8_t**) *sched; 614283514Sarybchik u_int8_t* table = (u_int8_t*) &key_tables[10]; 615283514Sarybchik int k; 616283514Sarybchik 617283514Sarybchik for (k = 0; k < 10; k++) { 618283514Sarybchik key_tables[k] = table; 619283514Sarybchik table += 0x100; 620283514Sarybchik } 621283514Sarybchik subkey_table_gen(key, (u_int8_t **) *sched); 622283514Sarybchik err = 0; 623283514Sarybchik } else 624283514Sarybchik err = ENOMEM; 625283514Sarybchik return err; 626283514Sarybchik} 627283514Sarybchik 628283514Sarybchikstatic void 629283514Sarybchikskipjack_zerokey(u_int8_t **sched) 630283514Sarybchik{ 631283514Sarybchik bzero(*sched, 10 * (sizeof(u_int8_t *) + 0x100)); 632283514Sarybchik free(*sched, M_CRYPTO_DATA); 633283514Sarybchik *sched = NULL; 634283514Sarybchik} 635283514Sarybchik 636283514Sarybchikstatic void 637283514Sarybchikrijndael128_encrypt(caddr_t key, u_int8_t *blk) 638283514Sarybchik{ 639283514Sarybchik rijndael_encrypt((rijndael_ctx *) key, (u_char *) blk, (u_char *) blk); 640283514Sarybchik} 641283514Sarybchik 642283514Sarybchikstatic void 643283514Sarybchikrijndael128_decrypt(caddr_t key, u_int8_t *blk) 644283514Sarybchik{ 645283514Sarybchik rijndael_decrypt(((rijndael_ctx *) key), (u_char *) blk, 646283514Sarybchik (u_char *) blk); 647283514Sarybchik} 648283514Sarybchik 649283514Sarybchikstatic int 650283514Sarybchikrijndael128_setkey(u_int8_t **sched, u_int8_t *key, int len) 651283514Sarybchik{ 652283514Sarybchik int err; 653283514Sarybchik 654283514Sarybchik if (len != 16 && len != 24 && len != 32) 655283514Sarybchik return (EINVAL); 656283514Sarybchik *sched = malloc(sizeof(rijndael_ctx), M_CRYPTO_DATA, 657283514Sarybchik M_NOWAIT|M_ZERO); 658283514Sarybchik if (*sched != NULL) { 659283514Sarybchik rijndael_set_key((rijndael_ctx *) *sched, (u_char *) key, 660283514Sarybchik len * 8); 661283514Sarybchik err = 0; 662283514Sarybchik } else 663283514Sarybchik err = ENOMEM; 664283514Sarybchik return err; 665283514Sarybchik} 666283514Sarybchik 667283514Sarybchikstatic void 668283514Sarybchikrijndael128_zerokey(u_int8_t **sched) 669283514Sarybchik{ 670283514Sarybchik bzero(*sched, sizeof(rijndael_ctx)); 671283514Sarybchik free(*sched, M_CRYPTO_DATA); 672283514Sarybchik *sched = NULL; 673283514Sarybchik} 674283514Sarybchik 675283514Sarybchikvoid 676283514Sarybchikaes_icm_reinit(caddr_t key, u_int8_t *iv) 677283514Sarybchik{ 678283514Sarybchik struct aes_icm_ctx *ctx; 679283514Sarybchik 680283514Sarybchik ctx = (struct aes_icm_ctx *)key; 681283514Sarybchik bcopy(iv, ctx->ac_block, AESICM_BLOCKSIZE); 682283514Sarybchik} 683283514Sarybchik 684283514Sarybchikvoid 685283514Sarybchikaes_gcm_reinit(caddr_t key, u_int8_t *iv) 686283514Sarybchik{ 687283514Sarybchik struct aes_icm_ctx *ctx; 688283514Sarybchik 689283514Sarybchik aes_icm_reinit(key, iv); 690283514Sarybchik 691283514Sarybchik ctx = (struct aes_icm_ctx *)key; 692283514Sarybchik /* GCM starts with 2 as counter 1 is used for final xor of tag. */ 693283514Sarybchik bzero(&ctx->ac_block[AESICM_BLOCKSIZE - 4], 4); 694283514Sarybchik ctx->ac_block[AESICM_BLOCKSIZE - 1] = 2; 695283514Sarybchik} 696283514Sarybchik 697283514Sarybchikvoid 698283514Sarybchikaes_icm_crypt(caddr_t key, u_int8_t *data) 699283514Sarybchik{ 700283514Sarybchik struct aes_icm_ctx *ctx; 701283514Sarybchik u_int8_t keystream[AESICM_BLOCKSIZE]; 702 int i; 703 704 ctx = (struct aes_icm_ctx *)key; 705 rijndaelEncrypt(ctx->ac_ek, ctx->ac_nr, ctx->ac_block, keystream); 706 for (i = 0; i < AESICM_BLOCKSIZE; i++) 707 data[i] ^= keystream[i]; 708 explicit_bzero(keystream, sizeof(keystream)); 709 710 /* increment counter */ 711 for (i = AESICM_BLOCKSIZE - 1; 712 i >= 0; i--) 713 if (++ctx->ac_block[i]) /* continue on overflow */ 714 break; 715} 716 717int 718aes_icm_setkey(u_int8_t **sched, u_int8_t *key, int len) 719{ 720 struct aes_icm_ctx *ctx; 721 722 if (len != 16 && len != 24 && len != 32) 723 return EINVAL; 724 725 *sched = malloc(sizeof(struct aes_icm_ctx), M_CRYPTO_DATA, 726 M_NOWAIT | M_ZERO); 727 if (*sched == NULL) 728 return ENOMEM; 729 730 ctx = (struct aes_icm_ctx *)*sched; 731 ctx->ac_nr = rijndaelKeySetupEnc(ctx->ac_ek, (u_char *)key, len * 8); 732 return 0; 733} 734 735void 736aes_icm_zerokey(u_int8_t **sched) 737{ 738 739 bzero(*sched, sizeof(struct aes_icm_ctx)); 740 free(*sched, M_CRYPTO_DATA); 741 *sched = NULL; 742} 743 744#define AES_XTS_BLOCKSIZE 16 745#define AES_XTS_IVSIZE 8 746#define AES_XTS_ALPHA 0x87 /* GF(2^128) generator polynomial */ 747 748struct aes_xts_ctx { 749 rijndael_ctx key1; 750 rijndael_ctx key2; 751 u_int8_t tweak[AES_XTS_BLOCKSIZE]; 752}; 753 754void 755aes_xts_reinit(caddr_t key, u_int8_t *iv) 756{ 757 struct aes_xts_ctx *ctx = (struct aes_xts_ctx *)key; 758 u_int64_t blocknum; 759 u_int i; 760 761 /* 762 * Prepare tweak as E_k2(IV). IV is specified as LE representation 763 * of a 64-bit block number which we allow to be passed in directly. 764 */ 765 bcopy(iv, &blocknum, AES_XTS_IVSIZE); 766 for (i = 0; i < AES_XTS_IVSIZE; i++) { 767 ctx->tweak[i] = blocknum & 0xff; 768 blocknum >>= 8; 769 } 770 /* Last 64 bits of IV are always zero */ 771 bzero(ctx->tweak + AES_XTS_IVSIZE, AES_XTS_IVSIZE); 772 773 rijndael_encrypt(&ctx->key2, ctx->tweak, ctx->tweak); 774} 775 776static void 777aes_xts_crypt(struct aes_xts_ctx *ctx, u_int8_t *data, u_int do_encrypt) 778{ 779 u_int8_t block[AES_XTS_BLOCKSIZE]; 780 u_int i, carry_in, carry_out; 781 782 for (i = 0; i < AES_XTS_BLOCKSIZE; i++) 783 block[i] = data[i] ^ ctx->tweak[i]; 784 785 if (do_encrypt) 786 rijndael_encrypt(&ctx->key1, block, data); 787 else 788 rijndael_decrypt(&ctx->key1, block, data); 789 790 for (i = 0; i < AES_XTS_BLOCKSIZE; i++) 791 data[i] ^= ctx->tweak[i]; 792 793 /* Exponentiate tweak */ 794 carry_in = 0; 795 for (i = 0; i < AES_XTS_BLOCKSIZE; i++) { 796 carry_out = ctx->tweak[i] & 0x80; 797 ctx->tweak[i] = (ctx->tweak[i] << 1) | (carry_in ? 1 : 0); 798 carry_in = carry_out; 799 } 800 if (carry_in) 801 ctx->tweak[0] ^= AES_XTS_ALPHA; 802 bzero(block, sizeof(block)); 803} 804 805void 806aes_xts_encrypt(caddr_t key, u_int8_t *data) 807{ 808 aes_xts_crypt((struct aes_xts_ctx *)key, data, 1); 809} 810 811void 812aes_xts_decrypt(caddr_t key, u_int8_t *data) 813{ 814 aes_xts_crypt((struct aes_xts_ctx *)key, data, 0); 815} 816 817int 818aes_xts_setkey(u_int8_t **sched, u_int8_t *key, int len) 819{ 820 struct aes_xts_ctx *ctx; 821 822 if (len != 32 && len != 64) 823 return EINVAL; 824 825 *sched = malloc(sizeof(struct aes_xts_ctx), M_CRYPTO_DATA, 826 M_NOWAIT | M_ZERO); 827 if (*sched == NULL) 828 return ENOMEM; 829 ctx = (struct aes_xts_ctx *)*sched; 830 831 rijndael_set_key(&ctx->key1, key, len * 4); 832 rijndael_set_key(&ctx->key2, key + (len / 2), len * 4); 833 834 return 0; 835} 836 837void 838aes_xts_zerokey(u_int8_t **sched) 839{ 840 bzero(*sched, sizeof(struct aes_xts_ctx)); 841 free(*sched, M_CRYPTO_DATA); 842 *sched = NULL; 843} 844 845static void 846cml_encrypt(caddr_t key, u_int8_t *blk) 847{ 848 camellia_encrypt((camellia_ctx *) key, (u_char *) blk, (u_char *) blk); 849} 850 851static void 852cml_decrypt(caddr_t key, u_int8_t *blk) 853{ 854 camellia_decrypt(((camellia_ctx *) key), (u_char *) blk, 855 (u_char *) blk); 856} 857 858static int 859cml_setkey(u_int8_t **sched, u_int8_t *key, int len) 860{ 861 int err; 862 863 if (len != 16 && len != 24 && len != 32) 864 return (EINVAL); 865 *sched = malloc(sizeof(camellia_ctx), M_CRYPTO_DATA, 866 M_NOWAIT|M_ZERO); 867 if (*sched != NULL) { 868 camellia_set_key((camellia_ctx *) *sched, (u_char *) key, 869 len * 8); 870 err = 0; 871 } else 872 err = ENOMEM; 873 return err; 874} 875 876static void 877cml_zerokey(u_int8_t **sched) 878{ 879 bzero(*sched, sizeof(camellia_ctx)); 880 free(*sched, M_CRYPTO_DATA); 881 *sched = NULL; 882} 883 884/* 885 * And now for auth. 886 */ 887 888static void 889null_init(void *ctx) 890{ 891} 892 893static void 894null_reinit(void *ctx, const u_int8_t *buf, u_int16_t len) 895{ 896} 897 898static int 899null_update(void *ctx, const u_int8_t *buf, u_int16_t len) 900{ 901 return 0; 902} 903 904static void 905null_final(u_int8_t *buf, void *ctx) 906{ 907 if (buf != (u_int8_t *) 0) 908 bzero(buf, 12); 909} 910 911static int 912RMD160Update_int(void *ctx, const u_int8_t *buf, u_int16_t len) 913{ 914 RMD160Update(ctx, buf, len); 915 return 0; 916} 917 918static int 919MD5Update_int(void *ctx, const u_int8_t *buf, u_int16_t len) 920{ 921 MD5Update(ctx, buf, len); 922 return 0; 923} 924 925static void 926SHA1Init_int(void *ctx) 927{ 928 SHA1Init(ctx); 929} 930 931static int 932SHA1Update_int(void *ctx, const u_int8_t *buf, u_int16_t len) 933{ 934 SHA1Update(ctx, buf, len); 935 return 0; 936} 937 938static void 939SHA1Final_int(u_int8_t *blk, void *ctx) 940{ 941 SHA1Final(blk, ctx); 942} 943 944static int 945SHA256Update_int(void *ctx, const u_int8_t *buf, u_int16_t len) 946{ 947 SHA256_Update(ctx, buf, len); 948 return 0; 949} 950 951static int 952SHA384Update_int(void *ctx, const u_int8_t *buf, u_int16_t len) 953{ 954 SHA384_Update(ctx, buf, len); 955 return 0; 956} 957 958static int 959SHA512Update_int(void *ctx, const u_int8_t *buf, u_int16_t len) 960{ 961 SHA512_Update(ctx, buf, len); 962 return 0; 963} 964 965/* 966 * And compression 967 */ 968 969static u_int32_t 970deflate_compress(data, size, out) 971 u_int8_t *data; 972 u_int32_t size; 973 u_int8_t **out; 974{ 975 return deflate_global(data, size, 0, out); 976} 977 978static u_int32_t 979deflate_decompress(data, size, out) 980 u_int8_t *data; 981 u_int32_t size; 982 u_int8_t **out; 983{ 984 return deflate_global(data, size, 1, out); 985} 986