[linux-block.git] / include / uapi / linux / cryptouser.h

/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
/*
 * Crypto user configuration API.
 *
 * Copyright (C) 2011 secunet Security Networks AG
 * Copyright (C) 2011 Steffen Klassert <steffen.klassert@secunet.com>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef _UAPI_LINUX_CRYPTOUSER_H
#define _UAPI_LINUX_CRYPTOUSER_H

#include <linux/types.h>

/* Netlink configuration messages.  */
enum {
	CRYPTO_MSG_BASE = 0x10,
	CRYPTO_MSG_NEWALG = 0x10,
	CRYPTO_MSG_DELALG,
	CRYPTO_MSG_UPDATEALG,
	CRYPTO_MSG_GETALG,
	CRYPTO_MSG_DELRNG,
	CRYPTO_MSG_GETSTAT,
	__CRYPTO_MSG_MAX
};
#define CRYPTO_MSG_MAX (__CRYPTO_MSG_MAX - 1)
#define CRYPTO_NR_MSGTYPES (CRYPTO_MSG_MAX + 1 - CRYPTO_MSG_BASE)

#define CRYPTO_MAX_NAME 64

/* Netlink message attributes.  */
enum crypto_attr_type_t {
	CRYPTOCFGA_UNSPEC,
	CRYPTOCFGA_PRIORITY_VAL,	/* __u32 */
	CRYPTOCFGA_REPORT_LARVAL,	/* struct crypto_report_larval */
	CRYPTOCFGA_REPORT_HASH,		/* struct crypto_report_hash */
	CRYPTOCFGA_REPORT_BLKCIPHER,	/* struct crypto_report_blkcipher */
	CRYPTOCFGA_REPORT_AEAD,		/* struct crypto_report_aead */
	CRYPTOCFGA_REPORT_COMPRESS,	/* struct crypto_report_comp */
	CRYPTOCFGA_REPORT_RNG,		/* struct crypto_report_rng */
	CRYPTOCFGA_REPORT_CIPHER,	/* struct crypto_report_cipher */
	CRYPTOCFGA_REPORT_AKCIPHER,	/* struct crypto_report_akcipher */
	CRYPTOCFGA_REPORT_KPP,		/* struct crypto_report_kpp */
	CRYPTOCFGA_REPORT_ACOMP,	/* struct crypto_report_acomp */
	CRYPTOCFGA_STAT_LARVAL,		/* struct crypto_stat */
	CRYPTOCFGA_STAT_HASH,		/* struct crypto_stat */
	CRYPTOCFGA_STAT_BLKCIPHER,	/* struct crypto_stat */
	CRYPTOCFGA_STAT_AEAD,		/* struct crypto_stat */
	CRYPTOCFGA_STAT_COMPRESS,	/* struct crypto_stat */
	CRYPTOCFGA_STAT_RNG,		/* struct crypto_stat */
	CRYPTOCFGA_STAT_CIPHER,		/* struct crypto_stat */
	CRYPTOCFGA_STAT_AKCIPHER,	/* struct crypto_stat */
	CRYPTOCFGA_STAT_KPP,		/* struct crypto_stat */
	CRYPTOCFGA_STAT_ACOMP,		/* struct crypto_stat */
	__CRYPTOCFGA_MAX

#define CRYPTOCFGA_MAX (__CRYPTOCFGA_MAX - 1)
};

struct crypto_user_alg {
	char cru_name[CRYPTO_MAX_NAME];
	char cru_driver_name[CRYPTO_MAX_NAME];
	char cru_module_name[CRYPTO_MAX_NAME];
	__u32 cru_type;
	__u32 cru_mask;
	__u32 cru_refcnt;
	__u32 cru_flags;
};

struct crypto_stat_aead {
	char type[CRYPTO_MAX_NAME];
	__u64 stat_encrypt_cnt;
	__u64 stat_encrypt_tlen;
	__u64 stat_decrypt_cnt;
	__u64 stat_decrypt_tlen;
	__u64 stat_err_cnt;
};

struct crypto_stat_akcipher {
	char type[CRYPTO_MAX_NAME];
	__u64 stat_encrypt_cnt;
	__u64 stat_encrypt_tlen;
	__u64 stat_decrypt_cnt;
	__u64 stat_decrypt_tlen;
	__u64 stat_verify_cnt;
	__u64 stat_sign_cnt;
	__u64 stat_err_cnt;
};

struct crypto_stat_cipher {
	char type[CRYPTO_MAX_NAME];
	__u64 stat_encrypt_cnt;
	__u64 stat_encrypt_tlen;
	__u64 stat_decrypt_cnt;
	__u64 stat_decrypt_tlen;
	__u64 stat_err_cnt;
};

struct crypto_stat_compress {
	char type[CRYPTO_MAX_NAME];
	__u64 stat_compress_cnt;
	__u64 stat_compress_tlen;
	__u64 stat_decompress_cnt;
	__u64 stat_decompress_tlen;
	__u64 stat_err_cnt;
};

struct crypto_stat_hash {
	char type[CRYPTO_MAX_NAME];
	__u64 stat_hash_cnt;
	__u64 stat_hash_tlen;
	__u64 stat_err_cnt;
};

struct crypto_stat_kpp {
	char type[CRYPTO_MAX_NAME];
	__u64 stat_setsecret_cnt;
	__u64 stat_generate_public_key_cnt;
	__u64 stat_compute_shared_secret_cnt;
	__u64 stat_err_cnt;
};

struct crypto_stat_rng {
	char type[CRYPTO_MAX_NAME];
	__u64 stat_generate_cnt;
	__u64 stat_generate_tlen;
	__u64 stat_seed_cnt;
	__u64 stat_err_cnt;
};

struct crypto_stat_larval {
	char type[CRYPTO_MAX_NAME];
};

struct crypto_report_larval {
	char type[CRYPTO_MAX_NAME];
};

struct crypto_report_hash {
	char type[CRYPTO_MAX_NAME];
	unsigned int blocksize;
	unsigned int digestsize;
};

struct crypto_report_cipher {
	char type[CRYPTO_MAX_NAME];
	unsigned int blocksize;
	unsigned int min_keysize;
	unsigned int max_keysize;
};

struct crypto_report_blkcipher {
	char type[CRYPTO_MAX_NAME];
	char geniv[CRYPTO_MAX_NAME];
	unsigned int blocksize;
	unsigned int min_keysize;
	unsigned int max_keysize;
	unsigned int ivsize;
};

struct crypto_report_aead {
	char type[CRYPTO_MAX_NAME];
	char geniv[CRYPTO_MAX_NAME];
	unsigned int blocksize;
	unsigned int maxauthsize;
	unsigned int ivsize;
};

struct crypto_report_comp {
	char type[CRYPTO_MAX_NAME];
};

struct crypto_report_rng {
	char type[CRYPTO_MAX_NAME];
	unsigned int seedsize;
};

struct crypto_report_akcipher {
	char type[CRYPTO_MAX_NAME];
};

struct crypto_report_kpp {
	char type[CRYPTO_MAX_NAME];
};

struct crypto_report_acomp {
	char type[CRYPTO_MAX_NAME];
};

#define CRYPTO_REPORT_MAXSIZE (sizeof(struct crypto_user_alg) + \
			       sizeof(struct crypto_report_blkcipher))

#endif /* _UAPI_LINUX_CRYPTOUSER_H */
Commit	Line	Data
e2be04c7	1	/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
a38f7907 SK	2	/*
	3	* Crypto user configuration API.
	4	*
	5	* Copyright (C) 2011 secunet Security Networks AG
	6	* Copyright (C) 2011 Steffen Klassert <steffen.klassert@secunet.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify it
	9	* under the terms and conditions of the GNU General Public License,
	10	* version 2, as published by the Free Software Foundation.
	11	*
	12	* This program is distributed in the hope it will be useful, but WITHOUT
	13	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	14	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	15	* more details.
	16	*
	17	* You should have received a copy of the GNU General Public License along with
	18	* this program; if not, write to the Free Software Foundation, Inc.,
	19	* 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
	20	*/
	21
68289c63 MY	22	#ifndef _UAPI_LINUX_CRYPTOUSER_H
	23	#define _UAPI_LINUX_CRYPTOUSER_H
	24
9078b4ee ND	25	#include <linux/types.h>
9078b4ee ND	26
a38f7907 SK	27	/* Netlink configuration messages. */
	28	enum {
	29	CRYPTO_MSG_BASE = 0x10,
	30	CRYPTO_MSG_NEWALG = 0x10,
	31	CRYPTO_MSG_DELALG,
	32	CRYPTO_MSG_UPDATEALG,
	33	CRYPTO_MSG_GETALG,
9aa867e4	34	CRYPTO_MSG_DELRNG,
cac5818c	35	CRYPTO_MSG_GETSTAT,
a38f7907 SK	36	__CRYPTO_MSG_MAX
	37	};
	38	#define CRYPTO_MSG_MAX (__CRYPTO_MSG_MAX - 1)
	39	#define CRYPTO_NR_MSGTYPES (CRYPTO_MSG_MAX + 1 - CRYPTO_MSG_BASE)
	40
4473710d	41	#define CRYPTO_MAX_NAME 64
a38f7907 SK	42
	43	/* Netlink message attributes. */
	44	enum crypto_attr_type_t {
	45	CRYPTOCFGA_UNSPEC,
	46	CRYPTOCFGA_PRIORITY_VAL, /* __u32 */
6c5a86f5	47	CRYPTOCFGA_REPORT_LARVAL, /* struct crypto_report_larval */
f4d663ce	48	CRYPTOCFGA_REPORT_HASH, /* struct crypto_report_hash */
50496a1f	49	CRYPTOCFGA_REPORT_BLKCIPHER, /* struct crypto_report_blkcipher */
6ad414fe	50	CRYPTOCFGA_REPORT_AEAD, /* struct crypto_report_aead */
a55465dc	51	CRYPTOCFGA_REPORT_COMPRESS, /* struct crypto_report_comp */
792608e9	52	CRYPTOCFGA_REPORT_RNG, /* struct crypto_report_rng */
07a5fa4a	53	CRYPTOCFGA_REPORT_CIPHER, /* struct crypto_report_cipher */
3c339ab8	54	CRYPTOCFGA_REPORT_AKCIPHER, /* struct crypto_report_akcipher */
4e5f2c40	55	CRYPTOCFGA_REPORT_KPP, /* struct crypto_report_kpp */
2ebda74f	56	CRYPTOCFGA_REPORT_ACOMP, /* struct crypto_report_acomp */
cac5818c CL	57	CRYPTOCFGA_STAT_LARVAL, /* struct crypto_stat */
	58	CRYPTOCFGA_STAT_HASH, /* struct crypto_stat */
	59	CRYPTOCFGA_STAT_BLKCIPHER, /* struct crypto_stat */
	60	CRYPTOCFGA_STAT_AEAD, /* struct crypto_stat */
	61	CRYPTOCFGA_STAT_COMPRESS, /* struct crypto_stat */
	62	CRYPTOCFGA_STAT_RNG, /* struct crypto_stat */
	63	CRYPTOCFGA_STAT_CIPHER, /* struct crypto_stat */
	64	CRYPTOCFGA_STAT_AKCIPHER, /* struct crypto_stat */
	65	CRYPTOCFGA_STAT_KPP, /* struct crypto_stat */
	66	CRYPTOCFGA_STAT_ACOMP, /* struct crypto_stat */
a38f7907 SK	67	__CRYPTOCFGA_MAX
	68
	69	#define CRYPTOCFGA_MAX (__CRYPTOCFGA_MAX - 1)
	70	};
	71
	72	struct crypto_user_alg {
4473710d HX	73	char cru_name[CRYPTO_MAX_NAME];
	74	char cru_driver_name[CRYPTO_MAX_NAME];
	75	char cru_module_name[CRYPTO_MAX_NAME];
a38f7907 SK	76	__u32 cru_type;
	77	__u32 cru_mask;
	78	__u32 cru_refcnt;
	79	__u32 cru_flags;
	80	};
6c5a86f5	81
7f0a9d5c	82	struct crypto_stat_aead {
cac5818c	83	char type[CRYPTO_MAX_NAME];
7f0a9d5c CL	84	__u64 stat_encrypt_cnt;
	85	__u64 stat_encrypt_tlen;
	86	__u64 stat_decrypt_cnt;
	87	__u64 stat_decrypt_tlen;
44f13133	88	__u64 stat_err_cnt;
7f0a9d5c CL	89	};
	90
	91	struct crypto_stat_akcipher {
	92	char type[CRYPTO_MAX_NAME];
	93	__u64 stat_encrypt_cnt;
	94	__u64 stat_encrypt_tlen;
	95	__u64 stat_decrypt_cnt;
	96	__u64 stat_decrypt_tlen;
	97	__u64 stat_verify_cnt;
6e8e72cd	98	__u64 stat_sign_cnt;
44f13133	99	__u64 stat_err_cnt;
7f0a9d5c CL	100	};
	101
	102	struct crypto_stat_cipher {
	103	char type[CRYPTO_MAX_NAME];
	104	__u64 stat_encrypt_cnt;
	105	__u64 stat_encrypt_tlen;
	106	__u64 stat_decrypt_cnt;
	107	__u64 stat_decrypt_tlen;
44f13133	108	__u64 stat_err_cnt;
7f0a9d5c CL	109	};
	110
	111	struct crypto_stat_compress {
	112	char type[CRYPTO_MAX_NAME];
	113	__u64 stat_compress_cnt;
	114	__u64 stat_compress_tlen;
	115	__u64 stat_decompress_cnt;
	116	__u64 stat_decompress_tlen;
44f13133	117	__u64 stat_err_cnt;
7f0a9d5c CL	118	};
	119
	120	struct crypto_stat_hash {
	121	char type[CRYPTO_MAX_NAME];
	122	__u64 stat_hash_cnt;
	123	__u64 stat_hash_tlen;
44f13133	124	__u64 stat_err_cnt;
7f0a9d5c CL	125	};
	126
	127	struct crypto_stat_kpp {
	128	char type[CRYPTO_MAX_NAME];
	129	__u64 stat_setsecret_cnt;
	130	__u64 stat_generate_public_key_cnt;
	131	__u64 stat_compute_shared_secret_cnt;
44f13133	132	__u64 stat_err_cnt;
7f0a9d5c CL	133	};
	134
	135	struct crypto_stat_rng {
	136	char type[CRYPTO_MAX_NAME];
	137	__u64 stat_generate_cnt;
	138	__u64 stat_generate_tlen;
	139	__u64 stat_seed_cnt;
44f13133	140	__u64 stat_err_cnt;
7f0a9d5c CL	141	};
	142
	143	struct crypto_stat_larval {
	144	char type[CRYPTO_MAX_NAME];
cac5818c CL	145	};
cac5818c CL	146
6c5a86f5 SK	147	struct crypto_report_larval {
	148	char type[CRYPTO_MAX_NAME];
	149	};
f4d663ce SK	150
	151	struct crypto_report_hash {
	152	char type[CRYPTO_MAX_NAME];
	153	unsigned int blocksize;
	154	unsigned int digestsize;
	155	};
50496a1f	156
07a5fa4a	157	struct crypto_report_cipher {
4473710d	158	char type[CRYPTO_MAX_NAME];
07a5fa4a SK	159	unsigned int blocksize;
	160	unsigned int min_keysize;
	161	unsigned int max_keysize;
	162	};
	163
50496a1f SK	164	struct crypto_report_blkcipher {
	165	char type[CRYPTO_MAX_NAME];
	166	char geniv[CRYPTO_MAX_NAME];
	167	unsigned int blocksize;
	168	unsigned int min_keysize;
	169	unsigned int max_keysize;
	170	unsigned int ivsize;
	171	};
6ad414fe SK	172
	173	struct crypto_report_aead {
	174	char type[CRYPTO_MAX_NAME];
	175	char geniv[CRYPTO_MAX_NAME];
	176	unsigned int blocksize;
	177	unsigned int maxauthsize;
	178	unsigned int ivsize;
	179	};
a55465dc SK	180
	181	struct crypto_report_comp {
	182	char type[CRYPTO_MAX_NAME];
	183	};
792608e9 SK	184
	185	struct crypto_report_rng {
	186	char type[CRYPTO_MAX_NAME];
	187	unsigned int seedsize;
	188	};
5219a534	189
3c339ab8 TS	190	struct crypto_report_akcipher {
	191	char type[CRYPTO_MAX_NAME];
	192	};
	193
4e5f2c40 SB	194	struct crypto_report_kpp {
	195	char type[CRYPTO_MAX_NAME];
	196	};
	197
2ebda74f GC	198	struct crypto_report_acomp {
	199	char type[CRYPTO_MAX_NAME];
	200	};
	201
5219a534 SK	202	#define CRYPTO_REPORT_MAXSIZE (sizeof(struct crypto_user_alg) + \
5219a534 SK	203	sizeof(struct crypto_report_blkcipher))
68289c63 MY	204
68289c63 MY	205	#endif /* _UAPI_LINUX_CRYPTOUSER_H */