diff --git a/sys/opencrypto/cryptodev.h b/sys/opencrypto/cryptodev.h --- a/sys/opencrypto/cryptodev.h +++ b/sys/opencrypto/cryptodev.h @@ -68,138 +68,139 @@ #include #ifdef _KERNEL -#include #include #include #include + +#include #endif /* Some initial values */ -#define CRYPTO_DRIVERS_INITIAL 4 +#define CRYPTO_DRIVERS_INITIAL 4 /* Hash values */ -#define NULL_HASH_LEN 16 -#define SHA1_HASH_LEN 20 -#define RIPEMD160_HASH_LEN 20 -#define SHA2_224_HASH_LEN 28 -#define SHA2_256_HASH_LEN 32 -#define SHA2_384_HASH_LEN 48 -#define SHA2_512_HASH_LEN 64 -#define AES_GMAC_HASH_LEN 16 -#define POLY1305_HASH_LEN 16 -#define AES_CBC_MAC_HASH_LEN 16 +#define NULL_HASH_LEN 16 +#define SHA1_HASH_LEN 20 +#define RIPEMD160_HASH_LEN 20 +#define SHA2_224_HASH_LEN 28 +#define SHA2_256_HASH_LEN 32 +#define SHA2_384_HASH_LEN 48 +#define SHA2_512_HASH_LEN 64 +#define AES_GMAC_HASH_LEN 16 +#define POLY1305_HASH_LEN 16 +#define AES_CBC_MAC_HASH_LEN 16 /* Maximum hash algorithm result length */ -#define HASH_MAX_LEN SHA2_512_HASH_LEN /* Keep this updated */ +#define HASH_MAX_LEN SHA2_512_HASH_LEN /* Keep this updated */ -#define SHA1_BLOCK_LEN 64 -#define RIPEMD160_BLOCK_LEN 64 -#define SHA2_224_BLOCK_LEN 64 -#define SHA2_256_BLOCK_LEN 64 -#define SHA2_384_BLOCK_LEN 128 -#define SHA2_512_BLOCK_LEN 128 -#define POLY1305_BLOCK_LEN 16 +#define SHA1_BLOCK_LEN 64 +#define RIPEMD160_BLOCK_LEN 64 +#define SHA2_224_BLOCK_LEN 64 +#define SHA2_256_BLOCK_LEN 64 +#define SHA2_384_BLOCK_LEN 128 +#define SHA2_512_BLOCK_LEN 128 +#define POLY1305_BLOCK_LEN 16 /* HMAC values */ -#define NULL_HMAC_BLOCK_LEN 64 +#define NULL_HMAC_BLOCK_LEN 64 /* Maximum HMAC block length */ -#define HMAC_MAX_BLOCK_LEN SHA2_512_BLOCK_LEN /* Keep this updated */ -#define HMAC_IPAD_VAL 0x36 -#define HMAC_OPAD_VAL 0x5C +#define HMAC_MAX_BLOCK_LEN SHA2_512_BLOCK_LEN /* Keep this updated */ +#define HMAC_IPAD_VAL 0x36 +#define HMAC_OPAD_VAL 0x5C /* HMAC Key Length */ -#define AES_128_GMAC_KEY_LEN 16 -#define AES_192_GMAC_KEY_LEN 24 -#define AES_256_GMAC_KEY_LEN 32 -#define AES_128_CBC_MAC_KEY_LEN 16 -#define AES_192_CBC_MAC_KEY_LEN 24 -#define AES_256_CBC_MAC_KEY_LEN 32 +#define AES_128_GMAC_KEY_LEN 16 +#define AES_192_GMAC_KEY_LEN 24 +#define AES_256_GMAC_KEY_LEN 32 +#define AES_128_CBC_MAC_KEY_LEN 16 +#define AES_192_CBC_MAC_KEY_LEN 24 +#define AES_256_CBC_MAC_KEY_LEN 32 -#define POLY1305_KEY_LEN 32 +#define POLY1305_KEY_LEN 32 /* Encryption algorithm block sizes */ -#define NULL_BLOCK_LEN 4 /* IPsec to maintain alignment */ -#define RIJNDAEL128_BLOCK_LEN 16 -#define AES_BLOCK_LEN 16 -#define AES_ICM_BLOCK_LEN 1 -#define CAMELLIA_BLOCK_LEN 16 -#define CHACHA20_NATIVE_BLOCK_LEN 64 -#define EALG_MAX_BLOCK_LEN CHACHA20_NATIVE_BLOCK_LEN /* Keep this updated */ +#define NULL_BLOCK_LEN 4 /* IPsec to maintain alignment */ +#define RIJNDAEL128_BLOCK_LEN 16 +#define AES_BLOCK_LEN 16 +#define AES_ICM_BLOCK_LEN 1 +#define CAMELLIA_BLOCK_LEN 16 +#define CHACHA20_NATIVE_BLOCK_LEN 64 +#define EALG_MAX_BLOCK_LEN CHACHA20_NATIVE_BLOCK_LEN /* Keep this updated */ /* IV Lengths */ -#define AES_GCM_IV_LEN 12 -#define AES_CCM_IV_LEN 12 -#define AES_XTS_IV_LEN 8 -#define AES_XTS_ALPHA 0x87 /* GF(2^128) generator polynomial */ -#define CHACHA20_POLY1305_IV_LEN 12 -#define XCHACHA20_POLY1305_IV_LEN 24 +#define AES_GCM_IV_LEN 12 +#define AES_CCM_IV_LEN 12 +#define AES_XTS_IV_LEN 8 +#define AES_XTS_ALPHA 0x87 /* GF(2^128) generator polynomial */ +#define CHACHA20_POLY1305_IV_LEN 12 +#define XCHACHA20_POLY1305_IV_LEN 24 /* Min and Max Encryption Key Sizes */ -#define NULL_MIN_KEY 0 -#define NULL_MAX_KEY 256 /* 2048 bits, max key */ -#define RIJNDAEL_MIN_KEY 16 -#define RIJNDAEL_MAX_KEY 32 -#define AES_MIN_KEY RIJNDAEL_MIN_KEY -#define AES_MAX_KEY RIJNDAEL_MAX_KEY -#define AES_XTS_MIN_KEY (2 * AES_MIN_KEY) -#define AES_XTS_MAX_KEY (2 * AES_MAX_KEY) -#define CAMELLIA_MIN_KEY 16 -#define CAMELLIA_MAX_KEY 32 -#define CHACHA20_POLY1305_KEY 32 -#define XCHACHA20_POLY1305_KEY 32 +#define NULL_MIN_KEY 0 +#define NULL_MAX_KEY 256 /* 2048 bits, max key */ +#define RIJNDAEL_MIN_KEY 16 +#define RIJNDAEL_MAX_KEY 32 +#define AES_MIN_KEY RIJNDAEL_MIN_KEY +#define AES_MAX_KEY RIJNDAEL_MAX_KEY +#define AES_XTS_MIN_KEY (2 * AES_MIN_KEY) +#define AES_XTS_MAX_KEY (2 * AES_MAX_KEY) +#define CAMELLIA_MIN_KEY 16 +#define CAMELLIA_MAX_KEY 32 +#define CHACHA20_POLY1305_KEY 32 +#define XCHACHA20_POLY1305_KEY 32 /* Maximum hash algorithm result length */ -#define AALG_MAX_RESULT_LEN 64 /* Keep this updated */ - -#define CRYPTO_ALGORITHM_MIN 1 -#define CRYPTO_DES_CBC 1 -#define CRYPTO_3DES_CBC 2 -#define CRYPTO_BLF_CBC 3 -#define CRYPTO_CAST_CBC 4 -#define CRYPTO_SKIPJACK_CBC 5 -#define CRYPTO_MD5_HMAC 6 -#define CRYPTO_SHA1_HMAC 7 -#define CRYPTO_RIPEMD160_HMAC 8 -#define CRYPTO_MD5_KPDK 9 -#define CRYPTO_SHA1_KPDK 10 -#define CRYPTO_RIJNDAEL128_CBC 11 /* 128 bit blocksize */ -#define CRYPTO_AES_CBC 11 /* 128 bit blocksize -- the same as above */ -#define CRYPTO_ARC4 12 -#define CRYPTO_MD5 13 -#define CRYPTO_SHA1 14 -#define CRYPTO_NULL_HMAC 15 -#define CRYPTO_NULL_CBC 16 -#define CRYPTO_DEFLATE_COMP 17 /* Deflate compression algorithm */ -#define CRYPTO_SHA2_256_HMAC 18 -#define CRYPTO_SHA2_384_HMAC 19 -#define CRYPTO_SHA2_512_HMAC 20 -#define CRYPTO_CAMELLIA_CBC 21 -#define CRYPTO_AES_XTS 22 -#define CRYPTO_AES_ICM 23 /* commonly known as CTR mode */ -#define CRYPTO_AES_NIST_GMAC 24 /* GMAC only */ -#define CRYPTO_AES_NIST_GCM_16 25 /* 16 byte ICV */ +#define AALG_MAX_RESULT_LEN 64 /* Keep this updated */ + +#define CRYPTO_ALGORITHM_MIN 1 +#define CRYPTO_DES_CBC 1 +#define CRYPTO_3DES_CBC 2 +#define CRYPTO_BLF_CBC 3 +#define CRYPTO_CAST_CBC 4 +#define CRYPTO_SKIPJACK_CBC 5 +#define CRYPTO_MD5_HMAC 6 +#define CRYPTO_SHA1_HMAC 7 +#define CRYPTO_RIPEMD160_HMAC 8 +#define CRYPTO_MD5_KPDK 9 +#define CRYPTO_SHA1_KPDK 10 +#define CRYPTO_RIJNDAEL128_CBC 11 /* 128 bit blocksize */ +#define CRYPTO_AES_CBC 11 /* 128 bit blocksize -- the same as above */ +#define CRYPTO_ARC4 12 +#define CRYPTO_MD5 13 +#define CRYPTO_SHA1 14 +#define CRYPTO_NULL_HMAC 15 +#define CRYPTO_NULL_CBC 16 +#define CRYPTO_DEFLATE_COMP 17 /* Deflate compression algorithm */ +#define CRYPTO_SHA2_256_HMAC 18 +#define CRYPTO_SHA2_384_HMAC 19 +#define CRYPTO_SHA2_512_HMAC 20 +#define CRYPTO_CAMELLIA_CBC 21 +#define CRYPTO_AES_XTS 22 +#define CRYPTO_AES_ICM 23 /* commonly known as CTR mode */ +#define CRYPTO_AES_NIST_GMAC 24 /* GMAC only */ +#define CRYPTO_AES_NIST_GCM_16 25 /* 16 byte ICV */ #ifdef _KERNEL -#define CRYPTO_AES_128_NIST_GMAC 26 /* auth side */ -#define CRYPTO_AES_192_NIST_GMAC 27 /* auth side */ -#define CRYPTO_AES_256_NIST_GMAC 28 /* auth side */ +#define CRYPTO_AES_128_NIST_GMAC 26 /* auth side */ +#define CRYPTO_AES_192_NIST_GMAC 27 /* auth side */ +#define CRYPTO_AES_256_NIST_GMAC 28 /* auth side */ #endif -#define CRYPTO_BLAKE2B 29 /* Blake2b hash */ -#define CRYPTO_BLAKE2S 30 /* Blake2s hash */ -#define CRYPTO_CHACHA20 31 /* Chacha20 stream cipher */ -#define CRYPTO_SHA2_224_HMAC 32 -#define CRYPTO_RIPEMD160 33 -#define CRYPTO_SHA2_224 34 -#define CRYPTO_SHA2_256 35 -#define CRYPTO_SHA2_384 36 -#define CRYPTO_SHA2_512 37 -#define CRYPTO_POLY1305 38 -#define CRYPTO_AES_CCM_CBC_MAC 39 /* auth side */ -#define CRYPTO_AES_CCM_16 40 /* cipher side */ -#define CRYPTO_CHACHA20_POLY1305 41 /* combined AEAD cipher per RFC 8439 */ -#define CRYPTO_XCHACHA20_POLY1305 42 -#define CRYPTO_ALGORITHM_MAX 42 /* Keep updated - see below */ - -#define CRYPTO_ALGO_VALID(x) ((x) >= CRYPTO_ALGORITHM_MIN && \ - (x) <= CRYPTO_ALGORITHM_MAX) +#define CRYPTO_BLAKE2B 29 /* Blake2b hash */ +#define CRYPTO_BLAKE2S 30 /* Blake2s hash */ +#define CRYPTO_CHACHA20 31 /* Chacha20 stream cipher */ +#define CRYPTO_SHA2_224_HMAC 32 +#define CRYPTO_RIPEMD160 33 +#define CRYPTO_SHA2_224 34 +#define CRYPTO_SHA2_256 35 +#define CRYPTO_SHA2_384 36 +#define CRYPTO_SHA2_512 37 +#define CRYPTO_POLY1305 38 +#define CRYPTO_AES_CCM_CBC_MAC 39 /* auth side */ +#define CRYPTO_AES_CCM_16 40 /* cipher side */ +#define CRYPTO_CHACHA20_POLY1305 41 /* combined AEAD cipher per RFC 8439 */ +#define CRYPTO_XCHACHA20_POLY1305 42 +#define CRYPTO_ALGORITHM_MAX 42 /* Keep updated - see below */ + +#define CRYPTO_ALGO_VALID(x) \ + ((x) >= CRYPTO_ALGORITHM_MIN && (x) <= CRYPTO_ALGORITHM_MAX) /* * Crypto driver/device flags. They can set in the crid @@ -209,29 +210,29 @@ * the driver id of an existing (and suitable) device that * must be used to satisfy the request. */ -#define CRYPTO_FLAG_HARDWARE 0x01000000 /* hardware accelerated */ -#define CRYPTO_FLAG_SOFTWARE 0x02000000 /* software implementation */ +#define CRYPTO_FLAG_HARDWARE 0x01000000 /* hardware accelerated */ +#define CRYPTO_FLAG_SOFTWARE 0x02000000 /* software implementation */ /* Does the kernel support vmpage buffers on this platform? */ #ifdef __powerpc__ -#define CRYPTO_MAY_HAVE_VMPAGE 1 +#define CRYPTO_MAY_HAVE_VMPAGE 1 #else -#define CRYPTO_MAY_HAVE_VMPAGE ( PMAP_HAS_DMAP ) +#define CRYPTO_MAY_HAVE_VMPAGE (PMAP_HAS_DMAP) #endif /* Does the currently running system support vmpage buffers on this platform? */ -#define CRYPTO_HAS_VMPAGE ( PMAP_HAS_DMAP ) +#define CRYPTO_HAS_VMPAGE (PMAP_HAS_DMAP) /* NB: deprecated */ struct session_op { - uint32_t cipher; /* ie. CRYPTO_AES_CBC */ - uint32_t mac; /* ie. CRYPTO_SHA2_256_HMAC */ + uint32_t cipher; /* ie. CRYPTO_AES_CBC */ + uint32_t mac; /* ie. CRYPTO_SHA2_256_HMAC */ - uint32_t keylen; /* cipher key */ - const void *key; - int mackeylen; /* mac key */ - const void *mackey; + uint32_t keylen; /* cipher key */ + const void *key; + int mackeylen; /* mac key */ + const void *mackey; - uint32_t ses; /* returns: session # */ + uint32_t ses; /* returns: session # */ }; /* @@ -240,49 +241,49 @@ * "cryptop" (no underscore). */ struct session2_op { - uint32_t cipher; /* ie. CRYPTO_AES_CBC */ - uint32_t mac; /* ie. CRYPTO_SHA2_256_HMAC */ - - uint32_t keylen; /* cipher key */ - const void *key; - int mackeylen; /* mac key */ - const void *mackey; - - uint32_t ses; /* returns: session # */ - int crid; /* driver id + flags (rw) */ - int ivlen; /* length of nonce/IV */ - int maclen; /* length of MAC/tag */ - int pad[2]; /* for future expansion */ + uint32_t cipher; /* ie. CRYPTO_AES_CBC */ + uint32_t mac; /* ie. CRYPTO_SHA2_256_HMAC */ + + uint32_t keylen; /* cipher key */ + const void *key; + int mackeylen; /* mac key */ + const void *mackey; + + uint32_t ses; /* returns: session # */ + int crid; /* driver id + flags (rw) */ + int ivlen; /* length of nonce/IV */ + int maclen; /* length of MAC/tag */ + int pad[2]; /* for future expansion */ }; struct crypt_op { - uint32_t ses; - uint16_t op; /* i.e. COP_ENCRYPT */ -#define COP_ENCRYPT 1 -#define COP_DECRYPT 2 - uint16_t flags; -#define COP_F_CIPHER_FIRST 0x0001 /* Cipher before MAC. */ -#define COP_F_BATCH 0x0008 /* Batch op if possible */ - u_int len; - const void *src; /* become iov[] inside kernel */ - void *dst; - void *mac; /* must be big enough for chosen MAC */ - const void *iv; + uint32_t ses; + uint16_t op; /* i.e. COP_ENCRYPT */ +#define COP_ENCRYPT 1 +#define COP_DECRYPT 2 + uint16_t flags; +#define COP_F_CIPHER_FIRST 0x0001 /* Cipher before MAC. */ +#define COP_F_BATCH 0x0008 /* Batch op if possible */ + u_int len; + const void *src; /* become iov[] inside kernel */ + void *dst; + void *mac; /* must be big enough for chosen MAC */ + const void *iv; }; /* op and flags the same as crypt_op */ struct crypt_aead { - uint32_t ses; - uint16_t op; /* i.e. COP_ENCRYPT */ - uint16_t flags; - u_int len; - u_int aadlen; - u_int ivlen; - const void *src; /* become iov[] inside kernel */ - void *dst; - const void *aad; /* additional authenticated data */ - void *tag; /* must fit for chosen TAG length */ - const void *iv; + uint32_t ses; + uint16_t op; /* i.e. COP_ENCRYPT */ + uint16_t flags; + u_int len; + u_int aadlen; + u_int ivlen; + const void *src; /* become iov[] inside kernel */ + void *dst; + const void *aad; /* additional authenticated data */ + void *tag; /* must fit for chosen TAG length */ + const void *iv; }; /* @@ -291,26 +292,39 @@ * created sessions (crid) and completed key operations. */ struct crypt_find_op { - int crid; /* driver id + flags */ - char name[32]; /* device/driver name */ + int crid; /* driver id + flags */ + char name[32]; /* device/driver name */ }; -#define CIOCGSESSION _IOWR('c', 101, struct session_op) -#define CIOCFSESSION _IOW('c', 102, uint32_t) -#define CIOCCRYPT _IOWR('c', 103, struct crypt_op) -#define CIOCGSESSION2 _IOWR('c', 106, struct session2_op) -#define CIOCFINDDEV _IOWR('c', 108, struct crypt_find_op) -#define CIOCCRYPTAEAD _IOWR('c', 109, struct crypt_aead) +#define CIOCGSESSION _IOWR('c', 101, struct session_op) +#define CIOCFSESSION _IOW('c', 102, uint32_t) +#define CIOCCRYPT _IOWR('c', 103, struct crypt_op) +#define CIOCGSESSION2 _IOWR('c', 106, struct session2_op) +#define CIOCFINDDEV _IOWR('c', 108, struct crypt_find_op) +#define CIOCCRYPTAEAD _IOWR('c', 109, struct crypt_aead) + +struct cryptotstat { + struct timespec acc; /* total accumulated time */ + struct timespec min; /* min time */ + struct timespec max; /* max time */ + uint32_t count; /* number of observations */ +}; struct cryptostats { - uint64_t cs_ops; /* symmetric crypto ops submitted */ - uint64_t cs_errs; /* symmetric crypto ops that failed */ - uint64_t cs_kops; /* asymetric/key ops submitted */ - uint64_t cs_kerrs; /* asymetric/key ops that failed */ - uint64_t cs_intrs; /* crypto swi thread activations */ - uint64_t cs_rets; /* crypto return thread activations */ - uint64_t cs_blocks; /* symmetric op driver block */ - uint64_t cs_kblocks; /* symmetric op driver block */ + uint64_t cs_ops; /* symmetric crypto ops submitted */ + uint64_t cs_errs; /* symmetric crypto ops that failed */ + uint64_t cs_kops; /* asymetric/key ops submitted */ + uint64_t cs_kerrs; /* asymetric/key ops that failed */ + uint64_t cs_intrs; /* crypto swi thread activations */ + uint64_t cs_rets; /* crypto return thread activations */ + uint64_t cs_blocks; /* symmetric op driver block */ + uint64_t cs_kblocks; /* symmetric op driver block */ + uint32_t cs_drops; /* crypto ops dropped due to congestion */ + + struct cryptotstat cs_invoke; /* crypto_dipsatch -> crypto_invoke */ + struct cryptotstat cs_done; /* crypto_invoke -> crypto_done */ + struct cryptotstat cs_cb; /* crypto_done -> callback */ + struct cryptotstat cs_finis; /* callback -> callback return */ }; #ifdef _KERNEL @@ -318,45 +332,48 @@ /* * Return values for cryptodev_probesession methods. */ -#define CRYPTODEV_PROBE_HARDWARE (-100) -#define CRYPTODEV_PROBE_ACCEL_SOFTWARE (-200) -#define CRYPTODEV_PROBE_SOFTWARE (-500) +#define CRYPTODEV_PROBE_HARDWARE (-100) +#define CRYPTODEV_PROBE_ACCEL_SOFTWARE (-200) +#define CRYPTODEV_PROBE_SOFTWARE (-500) #if 0 -#define CRYPTDEB(s, ...) do { \ - printf("%s:%d: " s "\n", __FILE__, __LINE__, ## __VA_ARGS__); \ -} while (0) +#define CRYPTDEB(s, ...) \ + do { \ + printf("%s:%d: " s "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ + } while (0) #else -#define CRYPTDEB(...) do { } while (0) +#define CRYPTDEB(...) \ + do { \ + } while (0) #endif struct crypto_session_params { - int csp_mode; /* Type of operations to perform. */ + int csp_mode; /* Type of operations to perform. */ -#define CSP_MODE_NONE 0 -#define CSP_MODE_COMPRESS 1 /* Compression/decompression. */ -#define CSP_MODE_CIPHER 2 /* Encrypt/decrypt. */ -#define CSP_MODE_DIGEST 3 /* Compute/verify digest. */ -#define CSP_MODE_AEAD 4 /* Combined auth/encryption. */ -#define CSP_MODE_ETA 5 /* IPsec style encrypt-then-auth */ +#define CSP_MODE_NONE 0 +#define CSP_MODE_COMPRESS 1 /* Compression/decompression. */ +#define CSP_MODE_CIPHER 2 /* Encrypt/decrypt. */ +#define CSP_MODE_DIGEST 3 /* Compute/verify digest. */ +#define CSP_MODE_AEAD 4 /* Combined auth/encryption. */ +#define CSP_MODE_ETA 5 /* IPsec style encrypt-then-auth */ - int csp_flags; + int csp_flags; -#define CSP_F_SEPARATE_OUTPUT 0x0001 /* Requests can use separate output */ -#define CSP_F_SEPARATE_AAD 0x0002 /* Requests can use separate AAD */ -#define CSP_F_ESN 0x0004 /* Requests can use seperate ESN field */ +#define CSP_F_SEPARATE_OUTPUT 0x0001 /* Requests can use separate output */ +#define CSP_F_SEPARATE_AAD 0x0002 /* Requests can use separate AAD */ +#define CSP_F_ESN 0x0004 /* Requests can use seperate ESN field */ - int csp_ivlen; /* IV length in bytes. */ + int csp_ivlen; /* IV length in bytes. */ - int csp_cipher_alg; - int csp_cipher_klen; /* Key length in bytes. */ - const void *csp_cipher_key; + int csp_cipher_alg; + int csp_cipher_klen; /* Key length in bytes. */ + const void *csp_cipher_key; - int csp_auth_alg; - int csp_auth_klen; /* Key length in bytes. */ - const void *csp_auth_key; - int csp_auth_mlen; /* Number of digest bytes to use. - 0 means all. */ + int csp_auth_alg; + int csp_auth_klen; /* Key length in bytes. */ + const void *csp_auth_key; + int csp_auth_mlen; /* Number of digest bytes to use. + 0 means all. */ }; enum crypto_buffer_type { @@ -377,8 +394,8 @@ struct crypto_buffer { union { struct { - char *cb_buf; - int cb_buf_len; + char *cb_buf; + int cb_buf_len; }; struct mbuf *cb_mbuf; struct { @@ -403,7 +420,7 @@ }; /* Optional bytes of valid data remaining */ int cc_buf_len; - /* + /* * Optional offset within the current buffer segment where * valid data begins */ @@ -415,66 +432,66 @@ struct cryptop { TAILQ_ENTRY(cryptop) crp_next; - struct task crp_task; + struct task crp_task; - crypto_session_t crp_session; /* Session */ - int crp_olen; /* Result total length */ + crypto_session_t crp_session; /* Session */ + int crp_olen; /* Result total length */ - int crp_etype; /* - * Error type (zero means no error). - * All error codes except EAGAIN - * indicate possible data corruption (as in, - * the data have been touched). On all - * errors, the crp_session may have changed - * (reset to a new one), so the caller - * should always check and use the new - * value on future requests. - */ -#define crp_startcopy crp_flags - int crp_flags; + int crp_etype; /* + * Error type (zero means no error). + * All error codes except EAGAIN + * indicate possible data corruption (as in, + * the data have been touched). On all + * errors, the crp_session may have changed + * (reset to a new one), so the caller + * should always check and use the new + * value on future requests. + */ +#define crp_startcopy crp_flags + int crp_flags; -#define CRYPTO_F_CBIMM 0x0010 /* Do callback immediately */ -#define CRYPTO_F_DONE 0x0020 /* Operation completed */ -#define CRYPTO_F_CBIFSYNC 0x0040 /* Do CBIMM if op is synchronous */ -#define CRYPTO_F_ASYNC_ORDERED 0x0100 /* Completions must happen in order */ -#define CRYPTO_F_IV_SEPARATE 0x0200 /* Use crp_iv[] as IV. */ +#define CRYPTO_F_CBIMM 0x0010 /* Do callback immediately */ +#define CRYPTO_F_DONE 0x0020 /* Operation completed */ +#define CRYPTO_F_CBIFSYNC 0x0040 /* Do CBIMM if op is synchronous */ +#define CRYPTO_F_ASYNC_ORDERED 0x0100 /* Completions must happen in order */ +#define CRYPTO_F_IV_SEPARATE 0x0200 /* Use crp_iv[] as IV. */ - int crp_op; + int crp_op; struct crypto_buffer crp_buf; struct crypto_buffer crp_obuf; - void *crp_aad; /* AAD buffer. */ - int crp_aad_start; /* Location of AAD. */ - int crp_aad_length; /* 0 => no AAD. */ - uint8_t crp_esn[4]; /* high-order ESN */ + void *crp_aad; /* AAD buffer. */ + int crp_aad_start; /* Location of AAD. */ + int crp_aad_length; /* 0 => no AAD. */ + uint8_t crp_esn[4]; /* high-order ESN */ - int crp_iv_start; /* Location of IV. IV length is from - * the session. - */ - int crp_payload_start; /* Location of ciphertext. */ - int crp_payload_output_start; - int crp_payload_length; - int crp_digest_start; /* Location of MAC/tag. Length is - * from the session. - */ + int crp_iv_start; /* Location of IV. IV length is from + * the session. + */ + int crp_payload_start; /* Location of ciphertext. */ + int crp_payload_output_start; + int crp_payload_length; + int crp_digest_start; /* Location of MAC/tag. Length is + * from the session. + */ - uint8_t crp_iv[EALG_MAX_BLOCK_LEN]; /* IV if IV_SEPARATE. */ + uint8_t crp_iv[EALG_MAX_BLOCK_LEN]; /* IV if IV_SEPARATE. */ - const void *crp_cipher_key; /* New cipher key if non-NULL. */ - const void *crp_auth_key; /* New auth key if non-NULL. */ -#define crp_endcopy crp_opaque + const void *crp_cipher_key; /* New cipher key if non-NULL. */ + const void *crp_auth_key; /* New auth key if non-NULL. */ +#define crp_endcopy crp_opaque - void *crp_opaque; /* Opaque pointer, passed along */ + void *crp_opaque; /* Opaque pointer, passed along */ int (*crp_callback)(struct cryptop *); /* Callback function */ - struct bintime crp_tstamp; /* performance time stamp */ - uint32_t crp_seq; /* used for ordered dispatch */ - uint32_t crp_retw_id; /* - * the return worker to be used, - * used for ordered dispatch - */ + struct bintime crp_tstamp; /* performance time stamp */ + uint32_t crp_seq; /* used for ordered dispatch */ + uint32_t crp_retw_id; /* + * the return worker to be used, + * used for ordered dispatch + */ }; TAILQ_HEAD(cryptopq, cryptop); @@ -579,67 +596,67 @@ _crypto_use_uio(&crp->crp_obuf, uio); } -#define CRYPTO_HAS_OUTPUT_BUFFER(crp) \ +#define CRYPTO_HAS_OUTPUT_BUFFER(crp) \ ((crp)->crp_obuf.cb_type != CRYPTO_BUF_NONE) /* Flags in crp_op. */ -#define CRYPTO_OP_DECRYPT 0x0 -#define CRYPTO_OP_ENCRYPT 0x1 -#define CRYPTO_OP_IS_ENCRYPT(op) ((op) & CRYPTO_OP_ENCRYPT) -#define CRYPTO_OP_COMPUTE_DIGEST 0x0 -#define CRYPTO_OP_VERIFY_DIGEST 0x2 -#define CRYPTO_OP_DECOMPRESS CRYPTO_OP_DECRYPT -#define CRYPTO_OP_COMPRESS CRYPTO_OP_ENCRYPT -#define CRYPTO_OP_IS_COMPRESS(op) ((op) & CRYPTO_OP_COMPRESS) +#define CRYPTO_OP_DECRYPT 0x0 +#define CRYPTO_OP_ENCRYPT 0x1 +#define CRYPTO_OP_IS_ENCRYPT(op) ((op)&CRYPTO_OP_ENCRYPT) +#define CRYPTO_OP_COMPUTE_DIGEST 0x0 +#define CRYPTO_OP_VERIFY_DIGEST 0x2 +#define CRYPTO_OP_DECOMPRESS CRYPTO_OP_DECRYPT +#define CRYPTO_OP_COMPRESS CRYPTO_OP_ENCRYPT +#define CRYPTO_OP_IS_COMPRESS(op) ((op)&CRYPTO_OP_COMPRESS) /* * Hints passed to process methods. */ -#define CRYPTO_HINT_MORE 0x1 /* more ops coming shortly */ +#define CRYPTO_HINT_MORE 0x1 /* more ops coming shortly */ uint32_t crypto_ses2hid(crypto_session_t crypto_session); uint32_t crypto_ses2caps(crypto_session_t crypto_session); -void *crypto_get_driver_session(crypto_session_t crypto_session); +void *crypto_get_driver_session(crypto_session_t crypto_session); const struct crypto_session_params *crypto_get_params( crypto_session_t crypto_session); -const struct auth_hash *crypto_auth_hash(const struct crypto_session_params *csp); +const struct auth_hash *crypto_auth_hash( + const struct crypto_session_params *csp); const struct enc_xform *crypto_cipher(const struct crypto_session_params *csp); #ifdef MALLOC_DECLARE MALLOC_DECLARE(M_CRYPTO_DATA); #endif -int crypto_newsession(crypto_session_t *cses, +int crypto_newsession(crypto_session_t *cses, const struct crypto_session_params *params, int crid); -void crypto_freesession(crypto_session_t cses); -#define CRYPTOCAP_F_HARDWARE CRYPTO_FLAG_HARDWARE -#define CRYPTOCAP_F_SOFTWARE CRYPTO_FLAG_SOFTWARE -#define CRYPTOCAP_F_SYNC 0x04000000 /* operates synchronously */ -#define CRYPTOCAP_F_ACCEL_SOFTWARE 0x08000000 -#define CRYPTO_SESS_SYNC(sess) \ - ((crypto_ses2caps(sess) & CRYPTOCAP_F_SYNC) != 0) -int32_t crypto_get_driverid(device_t dev, size_t session_size, int flags); -int crypto_find_driver(const char *); +void crypto_freesession(crypto_session_t cses); +#define CRYPTOCAP_F_HARDWARE CRYPTO_FLAG_HARDWARE +#define CRYPTOCAP_F_SOFTWARE CRYPTO_FLAG_SOFTWARE +#define CRYPTOCAP_F_SYNC 0x04000000 /* operates synchronously */ +#define CRYPTOCAP_F_ACCEL_SOFTWARE 0x08000000 +#define CRYPTO_SESS_SYNC(sess) ((crypto_ses2caps(sess) & CRYPTOCAP_F_SYNC) != 0) +int32_t crypto_get_driverid(device_t dev, size_t session_size, int flags); +int crypto_find_driver(const char *); device_t crypto_find_device_byhid(int hid); -int crypto_getcaps(int hid); -int crypto_unregister_all(uint32_t driverid); -int crypto_dispatch(struct cryptop *crp); -#define CRYPTO_ASYNC_ORDERED 0x1 /* complete in order dispatched */ -int crypto_dispatch_async(struct cryptop *crp, int flags); -void crypto_dispatch_batch(struct cryptopq *crpq, int flags); -#define CRYPTO_SYMQ 0x1 -int crypto_unblock(uint32_t, int); -void crypto_done(struct cryptop *crp); +int crypto_getcaps(int hid); +int crypto_unregister_all(uint32_t driverid); +int crypto_dispatch(struct cryptop *crp); +#define CRYPTO_ASYNC_ORDERED 0x1 /* complete in order dispatched */ +int crypto_dispatch_async(struct cryptop *crp, int flags); +void crypto_dispatch_batch(struct cryptopq *crpq, int flags); +#define CRYPTO_SYMQ 0x1 +int crypto_unblock(uint32_t, int); +void crypto_done(struct cryptop *crp); struct cryptop *crypto_clonereq(struct cryptop *crp, crypto_session_t cses, int how); -void crypto_destroyreq(struct cryptop *crp); -void crypto_initreq(struct cryptop *crp, crypto_session_t cses); -void crypto_freereq(struct cryptop *crp); +void crypto_destroyreq(struct cryptop *crp); +void crypto_initreq(struct cryptop *crp, crypto_session_t cses); +void crypto_freereq(struct cryptop *crp); struct cryptop *crypto_getreq(crypto_session_t cses, int how); -extern int crypto_usercrypto; /* userland may do crypto requests */ -extern int crypto_devallowsoft; /* only use hardware crypto */ +extern int crypto_usercrypto; /* userland may do crypto requests */ +extern int crypto_devallowsoft; /* only use hardware crypto */ #ifdef SYSCTL_DECL SYSCTL_DECL(_kern_crypto); @@ -648,9 +665,9 @@ /* Helper routines for drivers to initialize auth contexts for HMAC. */ struct auth_hash; -void hmac_init_ipad(const struct auth_hash *axf, const char *key, int klen, +void hmac_init_ipad(const struct auth_hash *axf, const char *key, int klen, void *auth_ctx); -void hmac_init_opad(const struct auth_hash *axf, const char *key, int klen, +void hmac_init_opad(const struct auth_hash *axf, const char *key, int klen, void *auth_ctx); /* @@ -661,29 +678,28 @@ * data from the crypto request's data buffer into the the 'dst' * buffer. */ -void crypto_copyback(struct cryptop *crp, int off, int size, - const void *src); -void crypto_copydata(struct cryptop *crp, int off, int size, void *dst); -int crypto_apply(struct cryptop *crp, int off, int len, - int (*f)(void *, const void *, u_int), void *arg); -void *crypto_contiguous_subsegment(struct cryptop *crp, size_t skip, - size_t len); - -int crypto_apply_buf(struct crypto_buffer *cb, int off, int len, - int (*f)(void *, const void *, u_int), void *arg); -void *crypto_buffer_contiguous_subsegment(struct crypto_buffer *cb, - size_t skip, size_t len); -size_t crypto_buffer_len(struct crypto_buffer *cb); -void crypto_cursor_init(struct crypto_buffer_cursor *cc, - const struct crypto_buffer *cb); -void crypto_cursor_advance(struct crypto_buffer_cursor *cc, size_t amount); -void *crypto_cursor_segment(struct crypto_buffer_cursor *cc, size_t *len); -void crypto_cursor_copyback(struct crypto_buffer_cursor *cc, int size, - const void *vsrc); -void crypto_cursor_copydata(struct crypto_buffer_cursor *cc, int size, - void *vdst); -void crypto_cursor_copydata_noadv(struct crypto_buffer_cursor *cc, int size, - void *vdst); +void crypto_copyback(struct cryptop *crp, int off, int size, const void *src); +void crypto_copydata(struct cryptop *crp, int off, int size, void *dst); +int crypto_apply(struct cryptop *crp, int off, int len, + int (*f)(void *, const void *, u_int), void *arg); +void *crypto_contiguous_subsegment(struct cryptop *crp, size_t skip, + size_t len); + +int crypto_apply_buf(struct crypto_buffer *cb, int off, int len, + int (*f)(void *, const void *, u_int), void *arg); +void *crypto_buffer_contiguous_subsegment(struct crypto_buffer *cb, size_t skip, + size_t len); +size_t crypto_buffer_len(struct crypto_buffer *cb); +void crypto_cursor_init(struct crypto_buffer_cursor *cc, + const struct crypto_buffer *cb); +void crypto_cursor_advance(struct crypto_buffer_cursor *cc, size_t amount); +void *crypto_cursor_segment(struct crypto_buffer_cursor *cc, size_t *len); +void crypto_cursor_copyback(struct crypto_buffer_cursor *cc, int size, + const void *vsrc); +void crypto_cursor_copydata(struct crypto_buffer_cursor *cc, int size, + void *vdst); +void crypto_cursor_copydata_noadv(struct crypto_buffer_cursor *cc, int size, + void *vdst); static __inline void crypto_cursor_copy(const struct crypto_buffer_cursor *fromc, diff --git a/tools/tools/crypto/cryptocheck.c b/tools/tools/crypto/cryptocheck.c --- a/tools/tools/crypto/cryptocheck.c +++ b/tools/tools/crypto/cryptocheck.c @@ -143,20 +143,19 @@ #include #include + #include +#include #include #include #include +#include +#include #include #include #include #include -#include -#include - -#include - struct ocf_session { int fd; int ses; @@ -175,88 +174,172 @@ const EVP_MD *(*evp_md)(void); int pkey; } algs[] = { - { .name = "ripemd160", .mac = CRYPTO_RIPEMD160, .type = T_HASH, - .evp_md = EVP_ripemd160 }, - { .name = "sha1", .mac = CRYPTO_SHA1, .type = T_HASH, - .evp_md = EVP_sha1 }, - { .name = "sha224", .mac = CRYPTO_SHA2_224, .type = T_HASH, - .evp_md = EVP_sha224 }, - { .name = "sha256", .mac = CRYPTO_SHA2_256, .type = T_HASH, - .evp_md = EVP_sha256 }, - { .name = "sha384", .mac = CRYPTO_SHA2_384, .type = T_HASH, - .evp_md = EVP_sha384 }, - { .name = "sha512", .mac = CRYPTO_SHA2_512, .type = T_HASH, - .evp_md = EVP_sha512 }, - { .name = "ripemd160hmac", .mac = CRYPTO_RIPEMD160_HMAC, .type = T_HMAC, - .evp_md = EVP_ripemd160 }, - { .name = "sha1hmac", .mac = CRYPTO_SHA1_HMAC, .type = T_HMAC, - .evp_md = EVP_sha1 }, - { .name = "sha224hmac", .mac = CRYPTO_SHA2_224_HMAC, .type = T_HMAC, - .evp_md = EVP_sha224 }, - { .name = "sha256hmac", .mac = CRYPTO_SHA2_256_HMAC, .type = T_HMAC, - .evp_md = EVP_sha256 }, - { .name = "sha384hmac", .mac = CRYPTO_SHA2_384_HMAC, .type = T_HMAC, - .evp_md = EVP_sha384 }, - { .name = "sha512hmac", .mac = CRYPTO_SHA2_512_HMAC, .type = T_HMAC, - .evp_md = EVP_sha512 }, - { .name = "blake2b", .mac = CRYPTO_BLAKE2B, .type = T_HASH, - .evp_md = EVP_blake2b512 }, - { .name = "blake2s", .mac = CRYPTO_BLAKE2S, .type = T_HASH, - .evp_md = EVP_blake2s256 }, - { .name = "gmac128", .mac = CRYPTO_AES_NIST_GMAC, .type = T_GMAC, - .tag_len = AES_GMAC_HASH_LEN, .evp_cipher = EVP_aes_128_gcm }, - { .name = "gmac192", .mac = CRYPTO_AES_NIST_GMAC, .type = T_GMAC, - .tag_len = AES_GMAC_HASH_LEN, .evp_cipher = EVP_aes_192_gcm }, - { .name = "gmac256", .mac = CRYPTO_AES_NIST_GMAC, .type = T_GMAC, - .tag_len = AES_GMAC_HASH_LEN, .evp_cipher = EVP_aes_256_gcm }, - { .name = "poly1305", .mac = CRYPTO_POLY1305, .type = T_DIGEST, - .key_len = POLY1305_KEY_LEN, .pkey = EVP_PKEY_POLY1305 }, - { .name = "aes-cbc128", .cipher = CRYPTO_AES_CBC, .type = T_CIPHER, - .evp_cipher = EVP_aes_128_cbc }, - { .name = "aes-cbc192", .cipher = CRYPTO_AES_CBC, .type = T_CIPHER, - .evp_cipher = EVP_aes_192_cbc }, - { .name = "aes-cbc256", .cipher = CRYPTO_AES_CBC, .type = T_CIPHER, - .evp_cipher = EVP_aes_256_cbc }, - { .name = "aes-ctr128", .cipher = CRYPTO_AES_ICM, .type = T_CIPHER, - .evp_cipher = EVP_aes_128_ctr }, - { .name = "aes-ctr192", .cipher = CRYPTO_AES_ICM, .type = T_CIPHER, - .evp_cipher = EVP_aes_192_ctr }, - { .name = "aes-ctr256", .cipher = CRYPTO_AES_ICM, .type = T_CIPHER, - .evp_cipher = EVP_aes_256_ctr }, - { .name = "aes-xts128", .cipher = CRYPTO_AES_XTS, .type = T_CIPHER, - .evp_cipher = EVP_aes_128_xts }, - { .name = "aes-xts256", .cipher = CRYPTO_AES_XTS, .type = T_CIPHER, - .evp_cipher = EVP_aes_256_xts }, - { .name = "camellia-cbc128", .cipher = CRYPTO_CAMELLIA_CBC, - .type = T_CIPHER, .evp_cipher = EVP_camellia_128_cbc }, - { .name = "camellia-cbc192", .cipher = CRYPTO_CAMELLIA_CBC, - .type = T_CIPHER, .evp_cipher = EVP_camellia_192_cbc }, - { .name = "camellia-cbc256", .cipher = CRYPTO_CAMELLIA_CBC, - .type = T_CIPHER, .evp_cipher = EVP_camellia_256_cbc }, - { .name = "chacha20", .cipher = CRYPTO_CHACHA20, .type = T_CIPHER, - .evp_cipher = EVP_chacha20 }, - { .name = "aes-gcm128", .cipher = CRYPTO_AES_NIST_GCM_16, - .type = T_AEAD, .tag_len = AES_GMAC_HASH_LEN, - .iv_sizes = { AES_GCM_IV_LEN }, .evp_cipher = EVP_aes_128_gcm }, - { .name = "aes-gcm192", .cipher = CRYPTO_AES_NIST_GCM_16, - .type = T_AEAD, .tag_len = AES_GMAC_HASH_LEN, - .iv_sizes = { AES_GCM_IV_LEN }, .evp_cipher = EVP_aes_192_gcm }, - { .name = "aes-gcm256", .cipher = CRYPTO_AES_NIST_GCM_16, - .type = T_AEAD, .tag_len = AES_GMAC_HASH_LEN, - .iv_sizes = { AES_GCM_IV_LEN }, .evp_cipher = EVP_aes_256_gcm }, - { .name = "aes-ccm128", .cipher = CRYPTO_AES_CCM_16, .type = T_AEAD, - .tag_len = AES_CBC_MAC_HASH_LEN, .iv_sizes = { 12, 7, 8, 9, 10, 11, 13 }, - .evp_cipher = EVP_aes_128_ccm }, - { .name = "aes-ccm192", .cipher = CRYPTO_AES_CCM_16, .type = T_AEAD, - .tag_len = AES_CBC_MAC_HASH_LEN, .iv_sizes = { 12, 7, 8, 9, 10, 11, 13 }, - .evp_cipher = EVP_aes_192_ccm }, - { .name = "aes-ccm256", .cipher = CRYPTO_AES_CCM_16, .type = T_AEAD, - .tag_len = AES_CBC_MAC_HASH_LEN, .iv_sizes = { 12, 7, 8, 9, 10, 11, 13 }, - .evp_cipher = EVP_aes_256_ccm }, - { .name = "chacha20-poly1305", .cipher = CRYPTO_CHACHA20_POLY1305, - .type = T_AEAD, .tag_len = POLY1305_HASH_LEN, - .iv_sizes = { CHACHA20_POLY1305_IV_LEN, 8 }, - .evp_cipher = EVP_chacha20_poly1305 }, + { .name = "ripemd160", + .mac = CRYPTO_RIPEMD160, + .type = T_HASH, + .evp_md = EVP_ripemd160 }, + { .name = "sha1", + .mac = CRYPTO_SHA1, + .type = T_HASH, + .evp_md = EVP_sha1 }, + { .name = "sha224", + .mac = CRYPTO_SHA2_224, + .type = T_HASH, + .evp_md = EVP_sha224 }, + { .name = "sha256", + .mac = CRYPTO_SHA2_256, + .type = T_HASH, + .evp_md = EVP_sha256 }, + { .name = "sha384", + .mac = CRYPTO_SHA2_384, + .type = T_HASH, + .evp_md = EVP_sha384 }, + { .name = "sha512", + .mac = CRYPTO_SHA2_512, + .type = T_HASH, + .evp_md = EVP_sha512 }, + { .name = "ripemd160hmac", + .mac = CRYPTO_RIPEMD160_HMAC, + .type = T_HMAC, + .evp_md = EVP_ripemd160 }, + { .name = "sha1hmac", + .mac = CRYPTO_SHA1_HMAC, + .type = T_HMAC, + .evp_md = EVP_sha1 }, + { .name = "sha224hmac", + .mac = CRYPTO_SHA2_224_HMAC, + .type = T_HMAC, + .evp_md = EVP_sha224 }, + { .name = "sha256hmac", + .mac = CRYPTO_SHA2_256_HMAC, + .type = T_HMAC, + .evp_md = EVP_sha256 }, + { .name = "sha384hmac", + .mac = CRYPTO_SHA2_384_HMAC, + .type = T_HMAC, + .evp_md = EVP_sha384 }, + { .name = "sha512hmac", + .mac = CRYPTO_SHA2_512_HMAC, + .type = T_HMAC, + .evp_md = EVP_sha512 }, + { .name = "blake2b", + .mac = CRYPTO_BLAKE2B, + .type = T_HASH, + .evp_md = EVP_blake2b512 }, + { .name = "blake2s", + .mac = CRYPTO_BLAKE2S, + .type = T_HASH, + .evp_md = EVP_blake2s256 }, + { .name = "gmac128", + .mac = CRYPTO_AES_NIST_GMAC, + .type = T_GMAC, + .tag_len = AES_GMAC_HASH_LEN, + .evp_cipher = EVP_aes_128_gcm }, + { .name = "gmac192", + .mac = CRYPTO_AES_NIST_GMAC, + .type = T_GMAC, + .tag_len = AES_GMAC_HASH_LEN, + .evp_cipher = EVP_aes_192_gcm }, + { .name = "gmac256", + .mac = CRYPTO_AES_NIST_GMAC, + .type = T_GMAC, + .tag_len = AES_GMAC_HASH_LEN, + .evp_cipher = EVP_aes_256_gcm }, + { .name = "poly1305", + .mac = CRYPTO_POLY1305, + .type = T_DIGEST, + .key_len = POLY1305_KEY_LEN, + .pkey = EVP_PKEY_POLY1305 }, + { .name = "aes-cbc128", + .cipher = CRYPTO_AES_CBC, + .type = T_CIPHER, + .evp_cipher = EVP_aes_128_cbc }, + { .name = "aes-cbc192", + .cipher = CRYPTO_AES_CBC, + .type = T_CIPHER, + .evp_cipher = EVP_aes_192_cbc }, + { .name = "aes-cbc256", + .cipher = CRYPTO_AES_CBC, + .type = T_CIPHER, + .evp_cipher = EVP_aes_256_cbc }, + { .name = "aes-ctr128", + .cipher = CRYPTO_AES_ICM, + .type = T_CIPHER, + .evp_cipher = EVP_aes_128_ctr }, + { .name = "aes-ctr192", + .cipher = CRYPTO_AES_ICM, + .type = T_CIPHER, + .evp_cipher = EVP_aes_192_ctr }, + { .name = "aes-ctr256", + .cipher = CRYPTO_AES_ICM, + .type = T_CIPHER, + .evp_cipher = EVP_aes_256_ctr }, + { .name = "aes-xts128", + .cipher = CRYPTO_AES_XTS, + .type = T_CIPHER, + .evp_cipher = EVP_aes_128_xts }, + { .name = "aes-xts256", + .cipher = CRYPTO_AES_XTS, + .type = T_CIPHER, + .evp_cipher = EVP_aes_256_xts }, + { .name = "camellia-cbc128", + .cipher = CRYPTO_CAMELLIA_CBC, + .type = T_CIPHER, + .evp_cipher = EVP_camellia_128_cbc }, + { .name = "camellia-cbc192", + .cipher = CRYPTO_CAMELLIA_CBC, + .type = T_CIPHER, + .evp_cipher = EVP_camellia_192_cbc }, + { .name = "camellia-cbc256", + .cipher = CRYPTO_CAMELLIA_CBC, + .type = T_CIPHER, + .evp_cipher = EVP_camellia_256_cbc }, + { .name = "chacha20", + .cipher = CRYPTO_CHACHA20, + .type = T_CIPHER, + .evp_cipher = EVP_chacha20 }, + { .name = "aes-gcm128", + .cipher = CRYPTO_AES_NIST_GCM_16, + .type = T_AEAD, + .tag_len = AES_GMAC_HASH_LEN, + .iv_sizes = { AES_GCM_IV_LEN }, + .evp_cipher = EVP_aes_128_gcm }, + { .name = "aes-gcm192", + .cipher = CRYPTO_AES_NIST_GCM_16, + .type = T_AEAD, + .tag_len = AES_GMAC_HASH_LEN, + .iv_sizes = { AES_GCM_IV_LEN }, + .evp_cipher = EVP_aes_192_gcm }, + { .name = "aes-gcm256", + .cipher = CRYPTO_AES_NIST_GCM_16, + .type = T_AEAD, + .tag_len = AES_GMAC_HASH_LEN, + .iv_sizes = { AES_GCM_IV_LEN }, + .evp_cipher = EVP_aes_256_gcm }, + { .name = "aes-ccm128", + .cipher = CRYPTO_AES_CCM_16, + .type = T_AEAD, + .tag_len = AES_CBC_MAC_HASH_LEN, + .iv_sizes = { 12, 7, 8, 9, 10, 11, 13 }, + .evp_cipher = EVP_aes_128_ccm }, + { .name = "aes-ccm192", + .cipher = CRYPTO_AES_CCM_16, + .type = T_AEAD, + .tag_len = AES_CBC_MAC_HASH_LEN, + .iv_sizes = { 12, 7, 8, 9, 10, 11, 13 }, + .evp_cipher = EVP_aes_192_ccm }, + { .name = "aes-ccm256", + .cipher = CRYPTO_AES_CCM_16, + .type = T_AEAD, + .tag_len = AES_CBC_MAC_HASH_LEN, + .iv_sizes = { 12, 7, 8, 9, 10, 11, 13 }, + .evp_cipher = EVP_aes_256_ccm }, + { .name = "chacha20-poly1305", + .cipher = CRYPTO_CHACHA20_POLY1305, + .type = T_AEAD, + .tag_len = POLY1305_HASH_LEN, + .iv_sizes = { CHACHA20_POLY1305_IV_LEN, 8 }, + .evp_cipher = EVP_chacha20_poly1305 }, }; static bool testall, verbose; @@ -347,7 +430,7 @@ /* * Called on exit to change kern.cryptodevallowsoft back to 0 */ -#define CRYPT_SOFT_ALLOW "kern.cryptodevallowsoft" +#define CRYPT_SOFT_ALLOW "kern.cryptodevallowsoft" static void reset_user_soft(void) @@ -363,8 +446,8 @@ int on = 1; size_t cursize = sizeof(curstate); - if (sysctlbyname(CRYPT_SOFT_ALLOW, &curstate, &cursize, - &on, sizeof(on)) == 0) { + if (sysctlbyname(CRYPT_SOFT_ALLOW, &curstate, &cursize, &on, + sizeof(on)) == 0) { if (curstate == 0) atexit(reset_user_soft); } @@ -407,11 +490,10 @@ static char rdigit(void) { - const char a[] = { - 0x10,0x54,0x11,0x48,0x45,0x12,0x4f,0x13,0x49,0x53,0x14,0x41, - 0x15,0x16,0x4e,0x55,0x54,0x17,0x18,0x4a,0x4f,0x42,0x19,0x01 - }; - return 0x20+a[random()%nitems(a)]; + const char a[] = { 0x10, 0x54, 0x11, 0x48, 0x45, 0x12, 0x4f, 0x13, 0x49, + 0x53, 0x14, 0x41, 0x15, 0x16, 0x4e, 0x55, 0x54, 0x17, 0x18, + 0x4a, 0x4f, 0x42, 0x19, 0x01 }; + return 0x20 + a[random() % nitems(a)]; } static char * @@ -473,8 +555,8 @@ fd = devcrypto(); if (ioctl(fd, CIOCGSESSION2, sop) < 0) { - warn("cryptodev %s %s not supported for device %s", - type, name, crfind(sop->crid)); + warn("cryptodev %s %s not supported for device %s", type, name, + crfind(sop->crid)); ses->fd = -1; return (false); } @@ -599,8 +681,8 @@ goto out; if (memcmp(control_digest, test_digest, sizeof(control_digest)) != 0) { if (memcmp(control_digest, test_digest, EVP_MD_size(md)) == 0) - printf("%s (%zu) mismatch in trailer:\n", - alg->name, size); + printf("%s (%zu) mismatch in trailer:\n", alg->name, + size); else printf("%s (%zu) mismatch:\n", alg->name, size); printf("control:\n"); @@ -611,8 +693,8 @@ } if (verbose) - printf("%s (%zu) matched (cryptodev device %s)\n", - alg->name, size, crfind(crid)); + printf("%s (%zu) matched (cryptodev device %s)\n", alg->name, + size, crfind(crid)); out: free(buffer); @@ -673,17 +755,17 @@ /* OpenSSL HMAC. */ digest_len = sizeof(control_digest); if (HMAC(md, key, key_len, (u_char *)buffer, size, - (u_char *)control_digest, &digest_len) == NULL) - errx(1, "OpenSSL %s (%zu) HMAC failed: %s", alg->name, - size, ERR_error_string(ERR_get_error(), NULL)); + (u_char *)control_digest, &digest_len) == NULL) + errx(1, "OpenSSL %s (%zu) HMAC failed: %s", alg->name, size, + ERR_error_string(ERR_get_error(), NULL)); /* cryptodev HMAC. */ if (!ocf_hmac(alg, buffer, size, key, key_len, test_digest, &crid)) goto out; if (memcmp(control_digest, test_digest, sizeof(control_digest)) != 0) { if (memcmp(control_digest, test_digest, EVP_MD_size(md)) == 0) - printf("%s (%zu) mismatch in trailer:\n", - alg->name, size); + printf("%s (%zu) mismatch in trailer:\n", alg->name, + size); else printf("%s (%zu) mismatch:\n", alg->name, size); printf("control:\n"); @@ -694,8 +776,8 @@ } if (verbose) - printf("%s (%zu) matched (cryptodev device %s)\n", - alg->name, size, crfind(crid)); + printf("%s (%zu) matched (cryptodev device %s)\n", alg->name, + size, crfind(crid)); out: free(buffer); @@ -711,15 +793,15 @@ ctx = EVP_CIPHER_CTX_new(); if (ctx == NULL) - errx(1, "OpenSSL %s (%zu) ctx new failed: %s", alg->name, - size, ERR_error_string(ERR_get_error(), NULL)); + errx(1, "OpenSSL %s (%zu) ctx new failed: %s", alg->name, size, + ERR_error_string(ERR_get_error(), NULL)); if (EVP_CipherInit_ex(ctx, cipher, NULL, (const u_char *)key, - (const u_char *)iv, enc) != 1) - errx(1, "OpenSSL %s (%zu) ctx init failed: %s", alg->name, - size, ERR_error_string(ERR_get_error(), NULL)); + (const u_char *)iv, enc) != 1) + errx(1, "OpenSSL %s (%zu) ctx init failed: %s", alg->name, size, + ERR_error_string(ERR_get_error(), NULL)); EVP_CIPHER_CTX_set_padding(ctx, 0); if (EVP_CipherUpdate(ctx, (u_char *)output, &outl, - (const u_char *)input, size) != 1) + (const u_char *)input, size) != 1) errx(1, "OpenSSL %s (%zu) cipher update failed: %s", alg->name, size, ERR_error_string(ERR_get_error(), NULL)); total = outl; @@ -852,8 +934,8 @@ } if (verbose) - printf("%s (%zu) matched (cryptodev device %s)\n", - alg->name, size, crfind(ses.crid)); + printf("%s (%zu) matched (cryptodev device %s)\n", alg->name, + size, crfind(ses.crid)); out: ocf_destroy_session(&ses); @@ -938,7 +1020,7 @@ if (size % EVP_CIPHER_block_size(cipher) != 0) { if (verbose) printf( - "%s (%zu, %zu): invalid buffer size (block size %d)\n", + "%s (%zu, %zu): invalid buffer size (block size %d)\n", alg->name, aad_len, size, EVP_CIPHER_block_size(cipher)); return; @@ -974,18 +1056,18 @@ memcpy(ciphertext, cleartext, aad_len); openssl_cipher(alg, cipher, cipher_key, iv, cleartext + aad_len, ciphertext + aad_len, size, 1); - if (size > 0 && memcmp(cleartext + aad_len, ciphertext + aad_len, - size) == 0) - warnx("OpenSSL %s (%zu, %zu): cipher text unchanged", - alg->name, aad_len, size); + if (size > 0 && + memcmp(cleartext + aad_len, ciphertext + aad_len, size) == 0) + warnx("OpenSSL %s (%zu, %zu): cipher text unchanged", alg->name, + aad_len, size); digest_len = sizeof(control_digest); if (HMAC(md, auth_key, auth_key_len, (u_char *)ciphertext, - aad_len + size, (u_char *)control_digest, &digest_len) == NULL) + aad_len + size, (u_char *)control_digest, &digest_len) == NULL) errx(1, "OpenSSL %s (%zu, %zu) HMAC failed: %s", alg->name, aad_len, size, ERR_error_string(ERR_get_error(), NULL)); if (!ocf_init_eta_session(alg, cipher_key, cipher_key_len, auth_key, - auth_key_len, &ses)) + auth_key_len, &ses)) goto out; /* OCF encrypt + HMAC. */ @@ -1047,11 +1129,11 @@ if (error != EBADMSG) { if (error != 0) warnc(error, - "cryptodev %s (%zu, %zu) corrupt tag failed for device %s", + "cryptodev %s (%zu, %zu) corrupt tag failed for device %s", alg->name, aad_len, size, crfind(ses.crid)); else warnx( - "cryptodev %s (%zu, %zu) corrupt tag didn't fail for device %s", + "cryptodev %s (%zu, %zu) corrupt tag didn't fail for device %s", alg->name, aad_len, size, crfind(ses.crid)); goto out; } @@ -1079,24 +1161,24 @@ ctx = EVP_CIPHER_CTX_new(); if (ctx == NULL) - errx(1, "OpenSSL %s (%zu) ctx new failed: %s", alg->name, - size, ERR_error_string(ERR_get_error(), NULL)); + errx(1, "OpenSSL %s (%zu) ctx new failed: %s", alg->name, size, + ERR_error_string(ERR_get_error(), NULL)); if (EVP_EncryptInit_ex(ctx, cipher, NULL, (const u_char *)key, - (const u_char *)iv) != 1) - errx(1, "OpenSSL %s (%zu) ctx init failed: %s", alg->name, - size, ERR_error_string(ERR_get_error(), NULL)); + (const u_char *)iv) != 1) + errx(1, "OpenSSL %s (%zu) ctx init failed: %s", alg->name, size, + ERR_error_string(ERR_get_error(), NULL)); EVP_CIPHER_CTX_set_padding(ctx, 0); - if (EVP_EncryptUpdate(ctx, NULL, &outl, (const u_char *)input, - size) != 1) - errx(1, "OpenSSL %s (%zu) update failed: %s", - alg->name, size, ERR_error_string(ERR_get_error(), NULL)); + if (EVP_EncryptUpdate(ctx, NULL, &outl, (const u_char *)input, size) != + 1) + errx(1, "OpenSSL %s (%zu) update failed: %s", alg->name, size, + ERR_error_string(ERR_get_error(), NULL)); if (EVP_EncryptFinal_ex(ctx, NULL, &outl) != 1) - errx(1, "OpenSSL %s (%zu) final failed: %s", alg->name, - size, ERR_error_string(ERR_get_error(), NULL)); + errx(1, "OpenSSL %s (%zu) final failed: %s", alg->name, size, + ERR_error_string(ERR_get_error(), NULL)); if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, alg->tag_len, - tag) != 1) - errx(1, "OpenSSL %s (%zu) get tag failed: %s", alg->name, - size, ERR_error_string(ERR_get_error(), NULL)); + tag) != 1) + errx(1, "OpenSSL %s (%zu) get tag failed: %s", alg->name, size, + ERR_error_string(ERR_get_error(), NULL)); EVP_CIPHER_CTX_free(ctx); } @@ -1123,8 +1205,8 @@ cop.iv = iv; if (ioctl(ses.fd, CIOCCRYPT, &cop) < 0) { - warn("cryptodev %s (%zu) failed for device %s", alg->name, - size, crfind(ses.crid)); + warn("cryptodev %s (%zu) failed for device %s", alg->name, size, + crfind(ses.crid)); ocf_destroy_session(&ses); return (false); } @@ -1171,8 +1253,8 @@ } if (verbose) - printf("%s (%zu) matched (cryptodev device %s)\n", - alg->name, size, crfind(crid)); + printf("%s (%zu) matched (cryptodev device %s)\n", alg->name, + size, crfind(crid)); out: free(buffer); @@ -1190,12 +1272,12 @@ pkey = EVP_PKEY_new_raw_private_key(alg->pkey, NULL, key, key_len); if (pkey == NULL) - errx(1, "OpenSSL %s (%zu) pkey new failed: %s", alg->name, - size, ERR_error_string(ERR_get_error(), NULL)); + errx(1, "OpenSSL %s (%zu) pkey new failed: %s", alg->name, size, + ERR_error_string(ERR_get_error(), NULL)); mdctx = EVP_MD_CTX_new(); if (mdctx == NULL) - errx(1, "OpenSSL %s (%zu) ctx new failed: %s", alg->name, - size, ERR_error_string(ERR_get_error(), NULL)); + errx(1, "OpenSSL %s (%zu) ctx new failed: %s", alg->name, size, + ERR_error_string(ERR_get_error(), NULL)); if (EVP_DigestSignInit(mdctx, NULL, NULL, NULL, pkey) != 1) errx(1, "OpenSSL %s (%zu) digest sign init failed: %s", alg->name, size, ERR_error_string(ERR_get_error(), NULL)); @@ -1243,8 +1325,8 @@ } if (verbose) - printf("%s (%zu) matched (cryptodev device %s)\n", - alg->name, size, crfind(crid)); + printf("%s (%zu) matched (cryptodev device %s)\n", alg->name, + size, crfind(crid)); out: free(buffer); @@ -1261,28 +1343,29 @@ ctx = EVP_CIPHER_CTX_new(); if (ctx == NULL) - errx(1, "OpenSSL %s (%zu) ctx new failed: %s", alg->name, - size, ERR_error_string(ERR_get_error(), NULL)); + errx(1, "OpenSSL %s (%zu) ctx new failed: %s", alg->name, size, + ERR_error_string(ERR_get_error(), NULL)); if (EVP_EncryptInit_ex(ctx, cipher, NULL, NULL, NULL) != 1) - errx(1, "OpenSSL %s (%zu) ctx init failed: %s", alg->name, - size, ERR_error_string(ERR_get_error(), NULL)); - if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, iv_len, NULL) != 1) - errx(1, "OpenSSL %s (%zu) setting iv length failed: %s", alg->name, - size, ERR_error_string(ERR_get_error(), NULL)); + errx(1, "OpenSSL %s (%zu) ctx init failed: %s", alg->name, size, + ERR_error_string(ERR_get_error(), NULL)); + if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, iv_len, NULL) != + 1) + errx(1, "OpenSSL %s (%zu) setting iv length failed: %s", + alg->name, size, ERR_error_string(ERR_get_error(), NULL)); if (EVP_EncryptInit_ex(ctx, NULL, NULL, (const u_char *)key, - (const u_char *)iv) != 1) - errx(1, "OpenSSL %s (%zu) ctx init failed: %s", alg->name, - size, ERR_error_string(ERR_get_error(), NULL)); + (const u_char *)iv) != 1) + errx(1, "OpenSSL %s (%zu) ctx init failed: %s", alg->name, size, + ERR_error_string(ERR_get_error(), NULL)); EVP_CIPHER_CTX_set_padding(ctx, 0); if (aad != NULL) { if (EVP_EncryptUpdate(ctx, NULL, &outl, (const u_char *)aad, - aad_len) != 1) + aad_len) != 1) errx(1, "OpenSSL %s (%zu) aad update failed: %s", alg->name, size, ERR_error_string(ERR_get_error(), NULL)); } if (EVP_EncryptUpdate(ctx, (u_char *)output, &outl, - (const u_char *)input, size) != 1) + (const u_char *)input, size) != 1) errx(1, "OpenSSL %s (%zu) encrypt update failed: %s", alg->name, size, ERR_error_string(ERR_get_error(), NULL)); total = outl; @@ -1294,9 +1377,9 @@ errx(1, "OpenSSL %s (%zu) encrypt size mismatch: %d", alg->name, size, total); if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, alg->tag_len, - tag) != 1) - errx(1, "OpenSSL %s (%zu) get tag failed: %s", alg->name, - size, ERR_error_string(ERR_get_error(), NULL)); + tag) != 1) + errx(1, "OpenSSL %s (%zu) get tag failed: %s", alg->name, size, + ERR_error_string(ERR_get_error(), NULL)); EVP_CIPHER_CTX_free(ctx); } @@ -1312,29 +1395,29 @@ ctx = EVP_CIPHER_CTX_new(); if (ctx == NULL) - errx(1, "OpenSSL %s (%zu) ctx new failed: %s", alg->name, - size, ERR_error_string(ERR_get_error(), NULL)); + errx(1, "OpenSSL %s (%zu) ctx new failed: %s", alg->name, size, + ERR_error_string(ERR_get_error(), NULL)); if (EVP_DecryptInit_ex(ctx, cipher, NULL, (const u_char *)key, - (const u_char *)iv) != 1) - errx(1, "OpenSSL %s (%zu) ctx init failed: %s", alg->name, - size, ERR_error_string(ERR_get_error(), NULL)); + (const u_char *)iv) != 1) + errx(1, "OpenSSL %s (%zu) ctx init failed: %s", alg->name, size, + ERR_error_string(ERR_get_error(), NULL)); EVP_CIPHER_CTX_set_padding(ctx, 0); if (aad != NULL) { if (EVP_DecryptUpdate(ctx, NULL, &outl, (const u_char *)aad, - aad_len) != 1) + aad_len) != 1) errx(1, "OpenSSL %s (%zu) aad update failed: %s", alg->name, size, ERR_error_string(ERR_get_error(), NULL)); } if (EVP_DecryptUpdate(ctx, (u_char *)output, &outl, - (const u_char *)input, size) != 1) + (const u_char *)input, size) != 1) errx(1, "OpenSSL %s (%zu) decrypt update failed: %s", alg->name, size, ERR_error_string(ERR_get_error(), NULL)); total = outl; if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, alg->tag_len, - tag) != 1) - errx(1, "OpenSSL %s (%zu) get tag failed: %s", alg->name, - size, ERR_error_string(ERR_get_error(), NULL)); + tag) != 1) + errx(1, "OpenSSL %s (%zu) get tag failed: %s", alg->name, size, + ERR_error_string(ERR_get_error(), NULL)); valid = (EVP_DecryptFinal_ex(ctx, (u_char *)output + outl, &outl) != 1); total += outl; if (total != size) @@ -1362,18 +1445,20 @@ errx(1, "OpenSSL %s/%zu (%zu, %zu) ctx init failed: %s", alg->name, iv_len, aad_len, size, ERR_error_string(ERR_get_error(), NULL)); - if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, iv_len, NULL) != 1) + if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, iv_len, NULL) != + 1) errx(1, "OpenSSL %s/%zu (%zu, %zu) setting iv length failed: %s", alg->name, iv_len, aad_len, size, ERR_error_string(ERR_get_error(), NULL)); - if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, AES_CBC_MAC_HASH_LEN, NULL) != 1) + if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, + AES_CBC_MAC_HASH_LEN, NULL) != 1) errx(1, "OpenSSL %s/%zu (%zu, %zu) setting tag length failed: %s", alg->name, iv_len, aad_len, size, ERR_error_string(ERR_get_error(), NULL)); if (EVP_EncryptInit_ex(ctx, NULL, NULL, (const u_char *)key, - (const u_char *)iv) != 1) + (const u_char *)iv) != 1) errx(1, "OpenSSL %s/%zu (%zu, %zu) ctx init failed: %s", alg->name, iv_len, aad_len, size, ERR_error_string(ERR_get_error(), NULL)); @@ -1385,14 +1470,14 @@ if (aad != NULL) { if (EVP_EncryptUpdate(ctx, NULL, &outl, (const u_char *)aad, - aad_len) != 1) + aad_len) != 1) errx(1, "OpenSSL %s/%zu (%zu, %zu) aad update failed: %s", alg->name, iv_len, aad_len, size, ERR_error_string(ERR_get_error(), NULL)); } if (EVP_EncryptUpdate(ctx, (u_char *)output, &outl, - (const u_char *)input, size) != 1) + (const u_char *)input, size) != 1) errx(1, "OpenSSL %s/%zu (%zu, %zu) encrypt update failed: %s", alg->name, iv_len, aad_len, size, ERR_error_string(ERR_get_error(), NULL)); @@ -1405,8 +1490,8 @@ if ((size_t)total != size) errx(1, "OpenSSL %s/%zu (%zu, %zu) encrypt size mismatch: %d", alg->name, iv_len, aad_len, size, total); - if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, AES_CBC_MAC_HASH_LEN, - tag) != 1) + if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, + AES_CBC_MAC_HASH_LEN, tag) != 1) errx(1, "OpenSSL %s/%zu (%zu, %zu) get tag failed: %s", alg->name, iv_len, aad_len, size, ERR_error_string(ERR_get_error(), NULL)); @@ -1450,7 +1535,7 @@ return (0); } -#define AEAD_MAX_TAG_LEN \ +#define AEAD_MAX_TAG_LEN \ MAX(MAX(AES_GMAC_HASH_LEN, AES_CBC_MAC_HASH_LEN), POLY1305_HASH_LEN) static size_t @@ -1482,8 +1567,7 @@ } static void -run_aead_test(const struct alg *alg, size_t aad_len, size_t size, - size_t iv_len) +run_aead_test(const struct alg *alg, size_t aad_len, size_t size, size_t iv_len) { struct ocf_session ses; const EVP_CIPHER *cipher; @@ -1497,7 +1581,7 @@ if (size % EVP_CIPHER_block_size(cipher) != 0) { if (verbose) printf( - "%s/%zu (%zu, %zu): invalid buffer size (block size %d)\n", + "%s/%zu (%zu, %zu): invalid buffer size (block size %d)\n", alg->name, iv_len, aad_len, size, EVP_CIPHER_block_size(cipher)); return; @@ -1528,11 +1612,11 @@ /* OpenSSL encrypt */ if (EVP_CIPHER_mode(cipher) == EVP_CIPH_CCM_MODE) - openssl_ccm_encrypt(alg, cipher, key, iv, iv_len, aad, - aad_len, cleartext, ciphertext, size, control_tag); + openssl_ccm_encrypt(alg, cipher, key, iv, iv_len, aad, aad_len, + cleartext, ciphertext, size, control_tag); else - openssl_aead_encrypt(alg, cipher, key, iv, iv_len, aad, - aad_len, cleartext, ciphertext, size, control_tag); + openssl_aead_encrypt(alg, cipher, key, iv, iv_len, aad, aad_len, + cleartext, ciphertext, size, control_tag); if (!ocf_init_aead_session(alg, key, key_len, iv_len, &ses)) goto out; @@ -1565,8 +1649,8 @@ } /* OCF decrypt */ - error = ocf_aead(&ses, iv, iv_len, aad, aad_len, ciphertext, - buffer, size, control_tag, COP_DECRYPT); + error = ocf_aead(&ses, iv, iv_len, aad, aad_len, ciphertext, buffer, + size, control_tag, COP_DECRYPT); if (error != 0) { warnc(error, "cryptodev %s/%zu (%zu, %zu) failed for device %s", alg->name, iv_len, aad_len, size, crfind(ses.crid)); @@ -1584,16 +1668,16 @@ /* Verify OCF decrypt fails with busted tag. */ test_tag[0] ^= 0x1; - error = ocf_aead(&ses, iv, iv_len, aad, aad_len, ciphertext, - buffer, size, test_tag, COP_DECRYPT); + error = ocf_aead(&ses, iv, iv_len, aad, aad_len, ciphertext, buffer, + size, test_tag, COP_DECRYPT); if (error != EBADMSG) { if (error != 0) warnc(error, - "cryptodev %s/%zu (%zu, %zu) corrupt tag failed for device %s", + "cryptodev %s/%zu (%zu, %zu) corrupt tag failed for device %s", alg->name, iv_len, aad_len, size, crfind(ses.crid)); else warnx( - "cryptodev %s/%zu (%zu, %zu) corrupt tag didn't fail for device %s", + "cryptodev %s/%zu (%zu, %zu) corrupt tag didn't fail for device %s", alg->name, iv_len, aad_len, size, crfind(ses.crid)); goto out; } diff --git a/tools/tools/crypto/cryptostats.c b/tools/tools/crypto/cryptostats.c --- a/tools/tools/crypto/cryptostats.c +++ b/tools/tools/crypto/cryptostats.c @@ -36,7 +36,6 @@ #include #include - #include #include #include @@ -44,17 +43,18 @@ #include static void -printt(const char* tag, struct cryptotstat *ts) +printt(const char *tag, struct cryptotstat *ts) { - uint64_t avg, min, max; + unsigned long long avg, min, max; if (ts->count == 0) return; - avg = (1000000000LL*ts->acc.tv_sec + ts->acc.tv_nsec) / ts->count; - min = 1000000000LL*ts->min.tv_sec + ts->min.tv_nsec; - max = 1000000000LL*ts->max.tv_sec + ts->max.tv_nsec; - printf("%16.16s: avg %6llu ns : min %6llu ns : max %7llu ns [%u samps]\n", - tag, avg, min, max, ts->count); + avg = (1000000000LL * ts->acc.tv_sec + ts->acc.tv_nsec) / ts->count; + min = 1000000000LL * ts->min.tv_sec + ts->min.tv_nsec; + max = 1000000000LL * ts->max.tv_sec + ts->max.tv_nsec; + printf( + "%16.16s: avg %6llu ns : min %6llu ns : max %7llu ns [%u samps]\n", + tag, avg, min, max, ts->count); } int @@ -63,41 +63,43 @@ struct cryptostats stats; size_t slen; - slen = sizeof (stats); + slen = sizeof(stats); if (sysctlbyname("kern.crypto_stats", &stats, &slen, NULL, 0) < 0) err(1, "kern.cryptostats"); if (argc > 1 && strcmp(argv[1], "-z") == 0) { - bzero(&stats.cs_invoke, sizeof (stats.cs_invoke)); - bzero(&stats.cs_done, sizeof (stats.cs_done)); - bzero(&stats.cs_cb, sizeof (stats.cs_cb)); - bzero(&stats.cs_finis, sizeof (stats.cs_finis)); + bzero(&stats.cs_invoke, sizeof(stats.cs_invoke)); + bzero(&stats.cs_done, sizeof(stats.cs_done)); + bzero(&stats.cs_cb, sizeof(stats.cs_cb)); + bzero(&stats.cs_finis, sizeof(stats.cs_finis)); stats.cs_invoke.min.tv_sec = 10000; stats.cs_done.min.tv_sec = 10000; stats.cs_cb.min.tv_sec = 10000; stats.cs_finis.min.tv_sec = 10000; - if (sysctlbyname("kern.crypto_stats", NULL, NULL, &stats, sizeof (stats)) < 0) + if (sysctlbyname("kern.crypto_stats", NULL, NULL, &stats, + sizeof(stats)) < 0) err(1, "kern.cryptostats"); exit(0); } if (argc > 1 && strcmp(argv[1], "-Z") == 0) { - bzero(&stats, sizeof (stats)); + bzero(&stats, sizeof(stats)); stats.cs_invoke.min.tv_sec = 10000; stats.cs_done.min.tv_sec = 10000; stats.cs_cb.min.tv_sec = 10000; stats.cs_finis.min.tv_sec = 10000; - if (sysctlbyname("kern.crypto_stats", NULL, NULL, &stats, sizeof (stats)) < 0) + if (sysctlbyname("kern.crypto_stats", NULL, NULL, &stats, + sizeof(stats)) < 0) err(1, "kern.cryptostats"); exit(0); } - - printf("%u symmetric crypto ops (%u errors, %u times driver blocked)\n" - , stats.cs_ops, stats.cs_errs, stats.cs_blocks); - printf("%u key ops (%u errors, %u times driver blocked)\n" - , stats.cs_kops, stats.cs_kerrs, stats.cs_kblocks); - printf("%u crypto dispatch thread activations\n", stats.cs_intrs); - printf("%u crypto return thread activations\n", stats.cs_rets); + printf( + "%lu symmetric crypto ops (%lu errors, %lu times driver blocked)\n", + stats.cs_ops, stats.cs_errs, stats.cs_blocks); + printf("%lu key ops (%lu errors, %lu times driver blocked)\n", + stats.cs_kops, stats.cs_kerrs, stats.cs_kblocks); + printf("%lu crypto dispatch thread activations\n", stats.cs_intrs); + printf("%lu crypto return thread activations\n", stats.cs_rets); if (stats.cs_invoke.count) { printf("\n"); printt("dispatch->invoke", &stats.cs_invoke); diff --git a/tools/tools/crypto/cryptotest.c b/tools/tools/crypto/cryptotest.c --- a/tools/tools/crypto/cryptotest.c +++ b/tools/tools/crypto/cryptotest.c @@ -94,6 +94,7 @@ #include #include +#include #include #include #include @@ -103,56 +104,68 @@ #include #include -#include - -#define CHUNK 64 /* how much to display */ -#define streq(a,b) (strcasecmp(a,b) == 0) - -void hexdump(char *, int); - -int verbose = 0; -int opflags = 0; -int verify = 0; -int crid = CRYPTO_FLAG_HARDWARE; - -struct alg { - const char* name; - int ishash; - int blocksize; - int minkeylen; - int maxkeylen; - int code; +#define CHUNK 64 /* how much to display */ +#define streq(a, b) (strcasecmp(a, b) == 0) + +static int verbose = 0; +static int opflags = 0; +static int verify = 0; +static int crid = CRYPTO_FLAG_HARDWARE; + +static struct alg { + const char *name; + int ishash; + int blocksize; + int minkeylen; + int maxkeylen; + int code; } algorithms[] = { #ifdef CRYPTO_NULL_CBC - { "null", 0, 8, 1, 256, CRYPTO_NULL_CBC }, + { "null", 0, 8, 1, 256, CRYPTO_NULL_CBC }, #endif - { "des", 0, 8, 8, 8, CRYPTO_DES_CBC }, - { "3des", 0, 8, 24, 24, CRYPTO_3DES_CBC }, - { "blf", 0, 8, 5, 56, CRYPTO_BLF_CBC }, - { "cast", 0, 8, 5, 16, CRYPTO_CAST_CBC }, - { "skj", 0, 8, 10, 10, CRYPTO_SKIPJACK_CBC }, - { "rij", 0, 16, 16, 16, CRYPTO_RIJNDAEL128_CBC}, - { "aes", 0, 16, 16, 16, CRYPTO_AES_CBC}, - { "aes192", 0, 16, 24, 24, CRYPTO_AES_CBC}, - { "aes256", 0, 16, 32, 32, CRYPTO_AES_CBC}, - { "chacha20", 0, 1, 32, 32, CRYPTO_CHACHA20}, - { "blake2b", 1, 128, 64, 64, CRYPTO_BLAKE2B }, - { "blake2s", 1, 64, 32, 32, CRYPTO_BLAKE2S }, - { "md5", 1, 8, 16, 16, CRYPTO_MD5_HMAC }, - { "sha1", 1, 8, 20, 20, CRYPTO_SHA1_HMAC }, - { "sha256", 1, 8, 32, 32, CRYPTO_SHA2_256_HMAC }, - { "sha384", 1, 8, 48, 48, CRYPTO_SHA2_384_HMAC }, - { "sha512", 1, 8, 64, 64, CRYPTO_SHA2_512_HMAC }, + { "des", 0, 8, 8, 8, CRYPTO_DES_CBC }, + { "3des", 0, 8, 24, 24, CRYPTO_3DES_CBC }, + { "blf", 0, 8, 5, 56, CRYPTO_BLF_CBC }, + { "cast", 0, 8, 5, 16, CRYPTO_CAST_CBC }, + { "skj", 0, 8, 10, 10, CRYPTO_SKIPJACK_CBC }, + { "rij", 0, 16, 16, 16, CRYPTO_RIJNDAEL128_CBC }, + { "aes", 0, 16, 16, 16, CRYPTO_AES_CBC }, + { "aes192", 0, 16, 24, 24, CRYPTO_AES_CBC }, + { "aes256", 0, 16, 32, 32, CRYPTO_AES_CBC }, + { "chacha20", 0, 1, 32, 32, CRYPTO_CHACHA20 }, + { "blake2b", 1, 128, 64, 64, CRYPTO_BLAKE2B }, + { "blake2s", 1, 64, 32, 32, CRYPTO_BLAKE2S }, + { "md5", 1, 8, 16, 16, CRYPTO_MD5_HMAC }, + { "sha1", 1, 8, 20, 20, CRYPTO_SHA1_HMAC }, + { "sha256", 1, 8, 32, 32, CRYPTO_SHA2_256_HMAC }, + { "sha384", 1, 8, 48, 48, CRYPTO_SHA2_384_HMAC }, + { "sha512", 1, 8, 64, 64, CRYPTO_SHA2_512_HMAC }, }; +struct alg *getalgbycode(int); +static void usage(const char *); +static struct alg *getalgbyname(const char *); +static int devcrypto(void); +static int crlookup(const char *); +static const char *crfind(int); +static char rdigit(void); +static void runtest(struct alg *, struct alg *, int, int, u_long, + struct timeval *); +static void printt(const char *, struct cryptotstat *); +static void runtests(struct alg *, struct alg *, int, int, u_long, int, int); +static void resetstats(void); +static void hexdump(char *, int); + void -usage(const char* cmd) +usage(const char *cmd) { - printf("usage: %s [-czsbv] [-d dev] [-a algorithm] [count] [size ...]\n", - cmd); + printf( + "usage: %s [-czsbv] [-d dev] [-a algorithm] [count] [size ...]\n", + cmd); printf("where algorithm is one of:\n"); printf(" null des 3des (default) blowfish cast skipjack rij\n"); - printf(" aes aes192 aes256 chacha20 md5 sha1 sha256 sha384 sha512\n"); + printf( + " aes aes192 aes256 chacha20 md5 sha1 sha256 sha384 sha512\n"); printf(" blake2b blake2s\n"); printf(" or an encryption algorithm concatented with authentication\n"); printf(" algorithm with '+' in the middle, e.g., aes+sha1.\n"); @@ -160,8 +173,10 @@ printf("size is the number of bytes of text to encrypt+decrypt\n"); printf("\n"); printf("-c check the results (slows timing)\n"); - printf("-d use specific device, specify 'soft' for testing software implementations\n"); - printf("\tNOTE: to use software you must set:\n\t sysctl kern.cryptodevallowsoft=1\n"); + printf( + "-d use specific device, specify 'soft' for testing software implementations\n"); + printf( + "\tNOTE: to use software you must set:\n\t sysctl kern.cryptodevallowsoft=1\n"); printf("-z run all available algorithms on a variety of sizes\n"); printf("-v be verbose\n"); printf("-b mark operations for batching\n"); @@ -170,10 +185,10 @@ exit(-1); } -struct alg* +struct alg * getalgbycode(int cipher) { - int i; + uint64_t i; for (i = 0; i < nitems(algorithms); i++) if (cipher == algorithms[i].code) @@ -181,10 +196,10 @@ return NULL; } -struct alg* -getalgbyname(const char* name) +struct alg * +getalgbyname(const char *name) { - int i; + uint64_t i; for (i = 0; i < nitems(algorithms); i++) if (streq(name, algorithms[i].name)) @@ -223,12 +238,12 @@ } const char * -crfind(int crid) +crfind(int id) { static struct crypt_find_op find; bzero(&find, sizeof(find)); - find.crid = crid; + find.crid = id; if (ioctl(devcrypto(), CIOCFINDDEV, &find) == -1) err(1, "ioctl(CIOCFINDDEV): crid %d", crid); return find.name; @@ -237,23 +252,25 @@ char rdigit(void) { - const char a[] = { - 0x10,0x54,0x11,0x48,0x45,0x12,0x4f,0x13,0x49,0x53,0x14,0x41, - 0x15,0x16,0x4e,0x55,0x54,0x17,0x18,0x4a,0x4f,0x42,0x19,0x01 - }; - return 0x20+a[random()%nitems(a)]; + const char a[] = { 0x10, 0x54, 0x11, 0x48, 0x45, 0x12, 0x4f, 0x13, 0x49, + 0x53, 0x14, 0x41, 0x15, 0x16, 0x4e, 0x55, 0x54, 0x17, 0x18, + 0x4a, 0x4f, 0x42, 0x19, 0x01 }; + return 0x20 + a[random() % nitems(a)]; } void -runtest(struct alg *ealg, struct alg *alg, int count, int size, u_long cmd, struct timeval *tv) +runtest(struct alg *ealg, struct alg *alg, int count, int size, u_long cmd, + struct timeval *tv) { + uint32_t j; + uint64_t k; int i, fd = devcrypto(); - struct timeval start, stop, dt; + struct timeval start, stop; char *cleartext, *ciphertext, *originaltext, *key; struct session2_op sop; struct crypt_op cop; char iv[EALG_MAX_BLOCK_LEN]; - char digest[512/8]; + char digest[512 / 8]; /* Canonicalize 'ealg' to crypt alg and 'alg' to authentication alg. */ if (ealg == NULL && !alg->ishash) { @@ -263,18 +280,18 @@ bzero(&sop, sizeof(sop)); if (ealg != NULL) { - sop.keylen = (ealg->minkeylen + ealg->maxkeylen)/2; - key = (char *) malloc(sop.keylen); + sop.keylen = (ealg->minkeylen + ealg->maxkeylen) / 2; + key = (char *)malloc(sop.keylen); if (key == NULL) err(1, "malloc (key)"); - for (i = 0; i < sop.keylen; i++) - key[i] = rdigit(); + for (j = 0; j < sop.keylen; j++) + key[j] = rdigit(); sop.key = key; sop.cipher = ealg->code; } if (alg != NULL) { - sop.mackeylen = (alg->minkeylen + alg->maxkeylen)/2; - key = (char *) malloc(sop.mackeylen); + sop.mackeylen = (alg->minkeylen + alg->maxkeylen) / 2; + key = (char *)malloc(sop.mackeylen); if (key == NULL) err(1, "malloc (mac)"); for (i = 0; i < sop.mackeylen; i++) @@ -288,12 +305,13 @@ if (cmd == CIOCGSESSION || cmd == CIOCGSESSION2) { close(fd); if (verbose) { - printf("cipher %s%s%s", ealg? ealg->name : "", + printf("cipher %s%s%s", ealg ? ealg->name : "", (ealg && alg) ? "+" : "", - alg? alg->name : ""); + alg ? alg->name : ""); if (alg->ishash) - printf(" mackeylen %u\n", sop.mackeylen); + printf(" mackeylen %u\n", + sop.mackeylen); else printf(" keylen %u\n", sop.keylen); perror("CIOCGSESSION"); @@ -302,21 +320,21 @@ return; } printf("cipher %s%s%s keylen %u mackeylen %u\n", - ealg? ealg->name : "", (ealg && alg) ? "+" : "", - alg? alg->name : "", sop.keylen, sop.mackeylen); + ealg ? ealg->name : "", (ealg && alg) ? "+" : "", + alg ? alg->name : "", sop.keylen, sop.mackeylen); err(1, "CIOCGSESSION"); } - originaltext = malloc(3*size); + originaltext = malloc(3 * size); if (originaltext == NULL) err(1, "malloc (text)"); - cleartext = originaltext+size; - ciphertext = cleartext+size; + cleartext = originaltext + size; + ciphertext = cleartext + size; for (i = 0; i < size; i++) cleartext[i] = rdigit(); memcpy(originaltext, cleartext, size); - for (i = 0; i < nitems(iv); i++) - iv[i] = rdigit(); + for (k = 0; k < nitems(iv); k++) + iv[k] = rdigit(); if (verbose) { printf("session = 0x%x\n", sop.ses); @@ -369,7 +387,8 @@ if (ioctl(fd, CIOCCRYPT, &cop) < 0) err(1, "ioctl(CIOCCRYPT)"); - if (verify && bcmp(cleartext, originaltext, size) != 0) { + if (verify && + bcmp(cleartext, originaltext, size) != 0) { printf("decrypt mismatch:\n"); printf("original:"); hexdump(originaltext, size); @@ -393,7 +412,7 @@ } } gettimeofday(&stop, NULL); - + if (ioctl(fd, CIOCFSESSION, &sop.ses) < 0) perror("ioctl(CIOCFSESSION)"); @@ -410,78 +429,80 @@ #ifdef __FreeBSD__ void -resetstats() +resetstats(void) { struct cryptostats stats; size_t slen; - slen = sizeof (stats); + slen = sizeof(stats); if (sysctlbyname("kern.crypto_stats", &stats, &slen, NULL, 0) < 0) { perror("kern.crypto_stats"); return; } - bzero(&stats.cs_invoke, sizeof (stats.cs_invoke)); - bzero(&stats.cs_done, sizeof (stats.cs_done)); - bzero(&stats.cs_cb, sizeof (stats.cs_cb)); - bzero(&stats.cs_finis, sizeof (stats.cs_finis)); + bzero(&stats.cs_invoke, sizeof(stats.cs_invoke)); + bzero(&stats.cs_done, sizeof(stats.cs_done)); + bzero(&stats.cs_cb, sizeof(stats.cs_cb)); + bzero(&stats.cs_finis, sizeof(stats.cs_finis)); stats.cs_invoke.min.tv_sec = 10000; stats.cs_done.min.tv_sec = 10000; stats.cs_cb.min.tv_sec = 10000; stats.cs_finis.min.tv_sec = 10000; - if (sysctlbyname("kern.crypto_stats", NULL, NULL, &stats, sizeof (stats)) < 0) + if (sysctlbyname("kern.crypto_stats", NULL, NULL, &stats, + sizeof(stats)) < 0) perror("kern.cryptostats"); } void -printt(const char* tag, struct cryptotstat *ts) +printt(const char *tag, struct cryptotstat *ts) { - uint64_t avg, min, max; + unsigned long long avg, min, max; if (ts->count == 0) return; - avg = (1000000000LL*ts->acc.tv_sec + ts->acc.tv_nsec) / ts->count; - min = 1000000000LL*ts->min.tv_sec + ts->min.tv_nsec; - max = 1000000000LL*ts->max.tv_sec + ts->max.tv_nsec; - printf("%16.16s: avg %6llu ns : min %6llu ns : max %7llu ns [%u samps]\n", - tag, avg, min, max, ts->count); + avg = (1000000000LL * ts->acc.tv_sec + ts->acc.tv_nsec) / ts->count; + min = 1000000000LL * ts->min.tv_sec + ts->min.tv_nsec; + max = 1000000000LL * ts->max.tv_sec + ts->max.tv_nsec; + printf( + "%16.16s: avg %6llu ns : min %6llu ns : max %7llu ns [%u samps]\n", + tag, avg, min, max, ts->count); } #endif void -runtests(struct alg *ealg, struct alg *alg, int count, int size, u_long cmd, int threads, int profile) +runtests(struct alg *ealg, struct alg *alg, int count, int size, u_long cmd, + int threads, int profile) { int i, status; double t; void *region; struct timeval *tvp; - struct timeval total; int otiming; if (size % alg->blocksize || (ealg && size % ealg->blocksize)) { if (verbose) printf("skipping blocksize %u 'cuz not a multiple of " - "%s blocksize %u (or %s blocksize %u)\n", - size, alg->name, alg->blocksize, - ealg ? ealg->name : "n/a", - ealg ? ealg->blocksize : 0); + "%s blocksize %u (or %s blocksize %u)\n", + size, alg->name, alg->blocksize, + ealg ? ealg->name : "n/a", + ealg ? ealg->blocksize : 0); return; } - region = mmap(NULL, threads * sizeof (struct timeval), - PROT_READ|PROT_WRITE, MAP_ANON|MAP_SHARED, -1, 0); + region = mmap(NULL, threads * sizeof(struct timeval), + PROT_READ | PROT_WRITE, MAP_ANON | MAP_SHARED, -1, 0); if (region == MAP_FAILED) { perror("mmap"); return; } - tvp = (struct timeval *) region; + tvp = (struct timeval *)region; #ifdef __FreeBSD__ if (profile) { - size_t tlen = sizeof (otiming); + size_t tlen = sizeof(otiming); int timing = 1; resetstats(); if (sysctlbyname("debug.crypto_timing", &otiming, &tlen, - &timing, sizeof (timing)) < 0) + &timing, sizeof(timing)) < 0) perror("debug.crypto_timing"); } #endif @@ -492,8 +513,8 @@ cpuset_t mask; CPU_ZERO(&mask); CPU_SET(i, &mask); - cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, - -1, sizeof(mask), &mask); + cpuset_setaffinity(CPU_LEVEL_WHICH, + CPU_WHICH_PID, -1, sizeof(mask), &mask); runtest(ealg, alg, count, size, cmd, &tvp[i]); exit(0); } @@ -504,25 +525,28 @@ t = 0; for (i = 0; i < threads; i++) - t += (((double)tvp[i].tv_sec * 1000000 + tvp[i].tv_usec) / 1000000); + t += (((double)tvp[i].tv_sec * 1000000 + tvp[i].tv_usec) / + 1000000); if (t) { - int nops = alg->ishash ? count : 2*count; + int nops = alg->ishash ? count : 2 * count; nops *= threads; - printf("%8.3lf sec, %7d %6s%s%6s crypts, %7d bytes, %8.0lf byte/sec, %7.1lf Mb/sec\n", - t, nops, alg->name, ealg? "+" : "", ealg? ealg->name : "", - size, (double)nops*size / t, - (double)nops*size / t * 8 / 1024 / 1024); + printf( + "%8.3lf sec, %7d %6s%s%6s crypts, %7d bytes, %8.0lf byte/sec, %7.1lf Mb/sec\n", + t, nops, alg->name, ealg ? "+" : "", ealg ? ealg->name : "", + size, (double)nops * size / t, + (double)nops * size / t * 8 / 1024 / 1024); } #ifdef __FreeBSD__ if (profile) { struct cryptostats stats; - size_t slen = sizeof (stats); + size_t slen = sizeof(stats); - if (sysctlbyname("debug.crypto_timing", NULL, NULL, - &otiming, sizeof (otiming)) < 0) + if (sysctlbyname("debug.crypto_timing", NULL, NULL, &otiming, + sizeof(otiming)) < 0) perror("debug.crypto_timing"); - if (sysctlbyname("kern.crypto_stats", &stats, &slen, NULL, 0) < 0) + if (sysctlbyname("kern.crypto_stats", &stats, &slen, NULL, 0) < + 0) perror("kern.cryptostats"); if (stats.cs_invoke.count) { printt("dispatch->invoke", &stats.cs_invoke); @@ -541,12 +565,14 @@ struct alg *alg = NULL, *ealg = NULL; char *tmp; int count = 1; - int sizes[128], nsizes = 0; + int sizes[128]; + uint64_t nsizes = 0; u_long cmd = CIOCGSESSION2; int testall = 0; int maxthreads = 1; int profile = 0; - int i, ch; + int ch; + uint64_t i; while ((ch = getopt(argc, argv, "cpzsva:bd:t:")) != -1) { switch (ch) { @@ -612,16 +638,17 @@ argc--, argv++; } if (maxthreads > CPU_SETSIZE) - errx(EX_USAGE, "Too many threads, %d, choose fewer.", maxthreads); - + errx(EX_USAGE, "Too many threads, %d, choose fewer.", + maxthreads); + if (nsizes == 0) { if (alg) sizes[nsizes++] = alg->blocksize; else sizes[nsizes++] = 8; if (testall) { - while (sizes[nsizes-1] < 8*1024) { - sizes[nsizes] = sizes[nsizes-1]<<1; + while (sizes[nsizes - 1] < 8 * 1024) { + sizes[nsizes] = sizes[nsizes - 1] << 1; nsizes++; } } @@ -629,16 +656,18 @@ if (testall) { for (i = 0; i < nitems(algorithms); i++) { - int j; + uint64_t j; alg = &algorithms[i]; for (j = 0; j < nsizes; j++) - runtests(ealg, alg, count, sizes[j], cmd, maxthreads, profile); + runtests(ealg, alg, count, sizes[j], cmd, + maxthreads, profile); } } else { if (alg == NULL) alg = getalgbycode(CRYPTO_3DES_CBC); for (i = 0; i < nsizes; i++) - runtests(ealg, alg, count, sizes[i], cmd, maxthreads, profile); + runtests(ealg, alg, count, sizes[i], cmd, maxthreads, + profile); } return (0); diff --git a/tools/tools/crypto/hifnstats.c b/tools/tools/crypto/hifnstats.c --- a/tools/tools/crypto/hifnstats.c +++ b/tools/tools/crypto/hifnstats.c @@ -38,28 +38,26 @@ * Little program to dump the statistics block for the hifn driver. */ int -main(int argc, char *argv[]) +main(void) { struct hifn_stats stats; size_t slen; - slen = sizeof (stats); + slen = sizeof(stats); if (sysctlbyname("hw.hifn.stats", &stats, &slen, NULL, 0) < 0) err(1, "kern.hifn.stats"); - printf("input %llu bytes %u packets\n", - stats.hst_ibytes, stats.hst_ipackets); - printf("output %llu bytes %u packets\n", - stats.hst_obytes, stats.hst_opackets); - printf("invalid %u nomem %u abort %u\n", - stats.hst_invalid, stats.hst_nomem, stats.hst_abort); - printf("noirq %u unaligned %u\n", - stats.hst_noirq, stats.hst_unaligned); - printf("totbatch %u maxbatch %u\n", - stats.hst_totbatch, stats.hst_maxbatch); + printf("input %lu bytes %u packets\n", stats.hst_ibytes, + stats.hst_ipackets); + printf("output %lu bytes %u packets\n", stats.hst_obytes, + stats.hst_opackets); + printf("invalid %u nomem %u abort %u\n", stats.hst_invalid, + stats.hst_nomem, stats.hst_abort); + printf("noirq %u unaligned %u\n", stats.hst_noirq, stats.hst_unaligned); + printf("totbatch %u maxbatch %u\n", stats.hst_totbatch, + stats.hst_maxbatch); printf("nomem: map %u load %u mbuf %u mcl %u cr %u sd %u\n", - stats.hst_nomem_map, stats.hst_nomem_load, - stats.hst_nomem_mbuf, stats.hst_nomem_mcl, - stats.hst_nomem_cr, stats.hst_nomem_sd); + stats.hst_nomem_map, stats.hst_nomem_load, stats.hst_nomem_mbuf, + stats.hst_nomem_mcl, stats.hst_nomem_cr, stats.hst_nomem_sd); return 0; } diff --git a/tools/tools/crypto/ipsecstats.c b/tools/tools/crypto/ipsecstats.c --- a/tools/tools/crypto/ipsecstats.c +++ b/tools/tools/crypto/ipsecstats.c @@ -29,46 +29,106 @@ #include #include -#include #include #include +#include #include #include #include struct alg { - int a; - const char *name; + int a; + const char *name; }; static const struct alg aalgs[] = { - { SADB_AALG_NONE, "none", }, - { SADB_AALG_MD5HMAC, "hmac-md5", }, - { SADB_AALG_SHA1HMAC, "hmac-sha1", }, - { SADB_X_AALG_MD5, "md5", }, - { SADB_X_AALG_SHA, "sha", }, - { SADB_X_AALG_NULL, "null", }, - { SADB_X_AALG_SHA2_256, "hmac-sha2-256", }, - { SADB_X_AALG_SHA2_384, "hmac-sha2-384", }, - { SADB_X_AALG_SHA2_512, "hmac-sha2-512", }, + { + SADB_AALG_NONE, + "none", + }, + { + SADB_AALG_MD5HMAC, + "hmac-md5", + }, + { + SADB_AALG_SHA1HMAC, + "hmac-sha1", + }, + { + SADB_X_AALG_MD5, + "md5", + }, + { + SADB_X_AALG_SHA, + "sha", + }, + { + SADB_X_AALG_NULL, + "null", + }, + { + SADB_X_AALG_SHA2_256, + "hmac-sha2-256", + }, + { + SADB_X_AALG_SHA2_384, + "hmac-sha2-384", + }, + { + SADB_X_AALG_SHA2_512, + "hmac-sha2-512", + }, }; static const struct alg espalgs[] = { - { SADB_EALG_NONE, "none", }, - { SADB_EALG_DESCBC, "des-cbc", }, - { SADB_EALG_3DESCBC, "3des-cbc", }, - { SADB_EALG_NULL, "null", }, - { SADB_X_EALG_CAST128CBC, "cast128-cbc", }, - { SADB_X_EALG_BLOWFISHCBC, "blowfish-cbc", }, - { SADB_X_EALG_RIJNDAELCBC, "rijndael-cbc", }, + { + SADB_EALG_NONE, + "none", + }, + { + SADB_EALG_DESCBC, + "des-cbc", + }, + { + SADB_EALG_3DESCBC, + "3des-cbc", + }, + { + SADB_EALG_NULL, + "null", + }, + { + SADB_X_EALG_CAST128CBC, + "cast128-cbc", + }, + { + SADB_X_EALG_BLOWFISHCBC, + "blowfish-cbc", + }, + { + SADB_X_EALG_RIJNDAELCBC, + "rijndael-cbc", + }, }; static const struct alg ipcompalgs[] = { - { SADB_X_CALG_NONE, "none", }, - { SADB_X_CALG_OUI, "oui", }, - { SADB_X_CALG_DEFLATE, "deflate", }, - { SADB_X_CALG_LZS, "lzs", }, + { + SADB_X_CALG_NONE, + "none", + }, + { + SADB_X_CALG_OUI, + "oui", + }, + { + SADB_X_CALG_DEFLATE, + "deflate", + }, + { + SADB_X_CALG_LZS, + "lzs", + }, }; -static const char* +static const char * algname(int a, const struct alg algs[], int nalgs) { static char buf[80]; @@ -85,26 +145,30 @@ * Little program to dump the statistics block for fast ipsec. */ int -main(int argc, char *argv[]) +main(void) { -#define STAT(x,fmt) if (x) printf(fmt "\n", (uintmax_t)x) +#define STAT(x, fmt) \ + if (x) \ + printf(fmt "\n", (uintmax_t)x) struct ipsecstat ips; struct ahstat ahs; struct espstat esps; size_t slen; int i; - slen = sizeof (ips); + slen = sizeof(ips); if (sysctlbyname("net.inet.ipsec.ipsecstats", &ips, &slen, NULL, 0) < 0) err(1, "net.inet.ipsec.ipsecstats"); - slen = sizeof (ahs); + slen = sizeof(ahs); if (sysctlbyname("net.inet.ah.stats", &ahs, &slen, NULL, 0) < 0) err(1, "net.inet.ah.stats"); - slen = sizeof (esps); + slen = sizeof(esps); if (sysctlbyname("net.inet.esp.stats", &esps, &slen, NULL, 0) < 0) err(1, "net.inet.esp.stats"); -#define AHSTAT(x,fmt) if (x) printf("ah " fmt ": %ju\n", (uintmax_t)x) +#define AHSTAT(x, fmt) \ + if (x) \ + printf("ah " fmt ": %ju\n", (uintmax_t)x) AHSTAT(ahs.ahs_input, "input packets processed"); AHSTAT(ahs.ahs_output, "output packets processed"); AHSTAT(ahs.ahs_hdrops, "headers too short"); @@ -116,7 +180,8 @@ AHSTAT(ahs.ahs_qfull, "packets dropped packet 'cuz queue full"); AHSTAT(ahs.ahs_wrap, "packets dropped for replace counter wrap"); AHSTAT(ahs.ahs_replay, "packets dropped for possible replay"); - AHSTAT(ahs.ahs_badauthl, "packets dropped for bad authenticator length"); + AHSTAT(ahs.ahs_badauthl, + "packets dropped for bad authenticator length"); AHSTAT(ahs.ahs_invalid, "packets with an invalid SA"); AHSTAT(ahs.ahs_toobig, "packets too big"); AHSTAT(ahs.ahs_pdrops, "packets dropped due to policy"); @@ -124,15 +189,16 @@ AHSTAT(ahs.ahs_tunnel, "tunnel sanity check failures"); for (i = 0; i < AH_ALG_MAX; i++) if (ahs.ahs_hist[i]) - printf("ah packets with %s: %ju\n" - , algname(i, aalgs, nitems(aalgs)) - , (uintmax_t)ahs.ahs_hist[i] - ); + printf("ah packets with %s: %ju\n", + algname(i, aalgs, nitems(aalgs)), + (uintmax_t)ahs.ahs_hist[i]); AHSTAT(ahs.ahs_ibytes, "bytes received"); AHSTAT(ahs.ahs_obytes, "bytes transmitted"); #undef AHSTAT -#define ESPSTAT(x,fmt) if (x) printf("esp " fmt ": %ju\n", (uintmax_t)x) +#define ESPSTAT(x, fmt) \ + if (x) \ + printf("esp " fmt ": %ju\n", (uintmax_t)x) ESPSTAT(esps.esps_input, "input packets processed"); ESPSTAT(esps.esps_output, "output packets processed"); ESPSTAT(esps.esps_hdrops, "headers too short"); @@ -153,16 +219,15 @@ ESPSTAT(esps.esps_tunnel, "tunnel sanity check failures"); for (i = 0; i < ESP_ALG_MAX; i++) if (esps.esps_hist[i]) - printf("esp packets with %s: %ju\n" - , algname(i, espalgs, nitems(espalgs)) - , (uintmax_t)esps.esps_hist[i] - ); + printf("esp packets with %s: %ju\n", + algname(i, espalgs, nitems(espalgs)), + (uintmax_t)esps.esps_hist[i]); ESPSTAT(esps.esps_ibytes, "bytes received"); ESPSTAT(esps.esps_obytes, "bytes transmitted"); #undef ESPSTAT printf("\n"); - if (ips.ips_in_polvio+ips.ips_out_polvio) + if (ips.ips_in_polvio + ips.ips_out_polvio) printf("policy violations: input %ju output %ju\n", (uintmax_t)ips.ips_in_polvio, (uintmax_t)ips.ips_out_polvio); diff --git a/tools/tools/crypto/safestats.c b/tools/tools/crypto/safestats.c --- a/tools/tools/crypto/safestats.c +++ b/tools/tools/crypto/safestats.c @@ -38,37 +38,36 @@ * Little program to dump the statistics block for the safe driver. */ int -main(int argc, char *argv[]) +main(void) { struct safe_stats stats; size_t slen; - slen = sizeof (stats); + slen = sizeof(stats); if (sysctlbyname("hw.safe.stats", &stats, &slen, NULL, 0) < 0) err(1, "hw.safe.stats"); - printf("input %llu bytes %u packets\n", - stats.st_ibytes, stats.st_ipackets); - printf("output %llu bytes %u packets\n", - stats.st_obytes, stats.st_opackets); - printf("invalid %u badsession %u badflags %u\n", - stats.st_invalid, stats.st_badsession, stats.st_badflags); - printf("nodesc %u badalg %u ringfull %u\n", - stats.st_nodesc, stats.st_badalg, stats.st_ringfull); - printf("peoperr %u dmaerr %u bypasstoobig %u\n", - stats.st_peoperr, stats.st_dmaerr, stats.st_bypasstoobig); - printf("skipmismatch %u lenmismatch %u coffmisaligned %u cofftoobig %u\n", - stats.st_skipmismatch, stats.st_lenmismatch, - stats.st_coffmisaligned, stats.st_cofftoobig); + printf("input %lu bytes %u packets\n", stats.st_ibytes, + stats.st_ipackets); + printf("output %lu bytes %u packets\n", stats.st_obytes, + stats.st_opackets); + printf("invalid %u badsession %u badflags %u\n", stats.st_invalid, + stats.st_badsession, stats.st_badflags); + printf("nodesc %u badalg %u ringfull %u\n", stats.st_nodesc, + stats.st_badalg, stats.st_ringfull); + printf("peoperr %u dmaerr %u bypasstoobig %u\n", stats.st_peoperr, + stats.st_dmaerr, stats.st_bypasstoobig); + printf( + "skipmismatch %u lenmismatch %u coffmisaligned %u cofftoobig %u\n", + stats.st_skipmismatch, stats.st_lenmismatch, + stats.st_coffmisaligned, stats.st_cofftoobig); printf("iovmisaligned %u iovnotuniform %u noicvcopy %u\n", - stats.st_iovmisaligned, stats.st_iovnotuniform, - stats.st_noicvcopy); + stats.st_iovmisaligned, stats.st_iovnotuniform, stats.st_noicvcopy); printf("unaligned %u notuniform %u nomap %u noload %u\n", - stats.st_unaligned, stats.st_notuniform, stats.st_nomap, - stats.st_noload); - printf("nomcl %u mbuf %u maxqchip %u\n", - stats.st_nomcl, stats.st_nombuf, stats.st_maxqchip); - printf("rng %u rngalarm %u\n", - stats.st_rng, stats.st_rngalarm); + stats.st_unaligned, stats.st_notuniform, stats.st_nomap, + stats.st_noload); + printf("nomcl %u mbuf %u maxqchip %u\n", stats.st_nomcl, + stats.st_nombuf, stats.st_maxqchip); + printf("rng %u rngalarm %u\n", stats.st_rng, stats.st_rngalarm); return 0; }