[deliverable/linux.git] / fs / f2fs / f2fs_crypto.h

/*
 * linux/fs/f2fs/f2fs_crypto.h
 *
 * Copied from linux/fs/ext4/ext4_crypto.h
 *
 * Copyright (C) 2015, Google, Inc.
 *
 * This contains encryption header content for f2fs
 *
 * Written by Michael Halcrow, 2015.
 * Modified by Jaegeuk Kim, 2015.
 */
#ifndef _F2FS_CRYPTO_H
#define _F2FS_CRYPTO_H

#include <linux/fs.h>

#define F2FS_KEY_DESCRIPTOR_SIZE	8

/* Policy provided via an ioctl on the topmost directory */
struct f2fs_encryption_policy {
	char version;
	char contents_encryption_mode;
	char filenames_encryption_mode;
	char flags;
	char master_key_descriptor[F2FS_KEY_DESCRIPTOR_SIZE];
} __attribute__((__packed__));

#define F2FS_ENCRYPTION_CONTEXT_FORMAT_V1	1
#define F2FS_KEY_DERIVATION_NONCE_SIZE		16

#define F2FS_POLICY_FLAGS_PAD_4		0x00
#define F2FS_POLICY_FLAGS_PAD_8		0x01
#define F2FS_POLICY_FLAGS_PAD_16	0x02
#define F2FS_POLICY_FLAGS_PAD_32	0x03
#define F2FS_POLICY_FLAGS_PAD_MASK	0x03
#define F2FS_POLICY_FLAGS_VALID		0x03

/**
 * Encryption context for inode
 *
 * Protector format:
 *  1 byte: Protector format (1 = this version)
 *  1 byte: File contents encryption mode
 *  1 byte: File names encryption mode
 *  1 byte: Flags
 *  8 bytes: Master Key descriptor
 *  16 bytes: Encryption Key derivation nonce
 */
struct f2fs_encryption_context {
	char format;
	char contents_encryption_mode;
	char filenames_encryption_mode;
	char flags;
	char master_key_descriptor[F2FS_KEY_DESCRIPTOR_SIZE];
	char nonce[F2FS_KEY_DERIVATION_NONCE_SIZE];
} __attribute__((__packed__));

/* Encryption parameters */
#define F2FS_XTS_TWEAK_SIZE 16
#define F2FS_AES_128_ECB_KEY_SIZE 16
#define F2FS_AES_256_GCM_KEY_SIZE 32
#define F2FS_AES_256_CBC_KEY_SIZE 32
#define F2FS_AES_256_CTS_KEY_SIZE 32
#define F2FS_AES_256_XTS_KEY_SIZE 64
#define F2FS_MAX_KEY_SIZE 64

#define F2FS_KEY_DESC_PREFIX "f2fs:"
#define F2FS_KEY_DESC_PREFIX_SIZE 5

struct f2fs_encryption_key {
	__u32 mode;
	char raw[F2FS_MAX_KEY_SIZE];
	__u32 size;
} __attribute__((__packed__));

struct f2fs_crypt_info {
	unsigned char	ci_mode;
	unsigned char	ci_size;
	char		ci_data_mode;
	char		ci_filename_mode;
	char		ci_flags;
	struct crypto_ablkcipher *ci_ctfm;
	struct key	*ci_keyring_key;
	char		ci_raw[F2FS_MAX_KEY_SIZE];
	char		ci_master_key[F2FS_KEY_DESCRIPTOR_SIZE];
};

#define F2FS_CTX_REQUIRES_FREE_ENCRYPT_FL             0x00000001
#define F2FS_BOUNCE_PAGE_REQUIRES_FREE_ENCRYPT_FL     0x00000002

struct f2fs_crypto_ctx {
	struct crypto_tfm *tfm;         /* Crypto API context */
	struct page *bounce_page;       /* Ciphertext page on write path */
	struct page *control_page;      /* Original page on write path */
	struct bio *bio;                /* The bio for this context */
	struct work_struct work;        /* Work queue for read complete path */
	struct list_head free_list;     /* Free list */
	int flags;                      /* Flags */
	int mode;                       /* Encryption mode for tfm */
};

struct f2fs_completion_result {
	struct completion completion;
	int res;
};

#define DECLARE_F2FS_COMPLETION_RESULT(ecr) \
	struct f2fs_completion_result ecr = { \
		COMPLETION_INITIALIZER((ecr).completion), 0 }

static inline int f2fs_encryption_key_size(int mode)
{
	switch (mode) {
	case F2FS_ENCRYPTION_MODE_AES_256_XTS:
		return F2FS_AES_256_XTS_KEY_SIZE;
	case F2FS_ENCRYPTION_MODE_AES_256_GCM:
		return F2FS_AES_256_GCM_KEY_SIZE;
	case F2FS_ENCRYPTION_MODE_AES_256_CBC:
		return F2FS_AES_256_CBC_KEY_SIZE;
	case F2FS_ENCRYPTION_MODE_AES_256_CTS:
		return F2FS_AES_256_CTS_KEY_SIZE;
	default:
		BUG();
	}
	return 0;
}

#define F2FS_FNAME_NUM_SCATTER_ENTRIES	4
#define F2FS_CRYPTO_BLOCK_SIZE		16
#define F2FS_FNAME_CRYPTO_DIGEST_SIZE	32

/**
 * For encrypted symlinks, the ciphertext length is stored at the beginning
 * of the string in little-endian format.
 */
struct f2fs_encrypted_symlink_data {
	__le16 len;
	char encrypted_path[1];
} __attribute__((__packed__));

/**
 * This function is used to calculate the disk space required to
 * store a filename of length l in encrypted symlink format.
 */
static inline u32 encrypted_symlink_data_len(u32 l)
{
	return (l + sizeof(struct f2fs_encrypted_symlink_data) - 1);
}
#endif	/* _F2FS_CRYPTO_H */
Commit	Line	Data
cde4de12 JK	1	/*
	2	* linux/fs/f2fs/f2fs_crypto.h
	3	*
	4	* Copied from linux/fs/ext4/ext4_crypto.h
	5	*
	6	* Copyright (C) 2015, Google, Inc.
	7	*
	8	* This contains encryption header content for f2fs
	9	*
	10	* Written by Michael Halcrow, 2015.
	11	* Modified by Jaegeuk Kim, 2015.
	12	*/
	13	#ifndef _F2FS_CRYPTO_H
	14	#define _F2FS_CRYPTO_H
	15
	16	#include <linux/fs.h>
	17
	18	#define F2FS_KEY_DESCRIPTOR_SIZE 8
	19
	20	/* Policy provided via an ioctl on the topmost directory */
	21	struct f2fs_encryption_policy {
	22	char version;
	23	char contents_encryption_mode;
	24	char filenames_encryption_mode;
	25	char flags;
	26	char master_key_descriptor[F2FS_KEY_DESCRIPTOR_SIZE];
	27	} __attribute__((__packed__));
	28
	29	#define F2FS_ENCRYPTION_CONTEXT_FORMAT_V1 1
	30	#define F2FS_KEY_DERIVATION_NONCE_SIZE 16
	31
	32	#define F2FS_POLICY_FLAGS_PAD_4 0x00
	33	#define F2FS_POLICY_FLAGS_PAD_8 0x01
	34	#define F2FS_POLICY_FLAGS_PAD_16 0x02
	35	#define F2FS_POLICY_FLAGS_PAD_32 0x03
	36	#define F2FS_POLICY_FLAGS_PAD_MASK 0x03
	37	#define F2FS_POLICY_FLAGS_VALID 0x03
	38
	39	/**
	40	* Encryption context for inode
	41	*
	42	* Protector format:
	43	* 1 byte: Protector format (1 = this version)
	44	* 1 byte: File contents encryption mode
	45	* 1 byte: File names encryption mode
	46	* 1 byte: Flags
	47	* 8 bytes: Master Key descriptor
	48	* 16 bytes: Encryption Key derivation nonce
	49	*/
	50	struct f2fs_encryption_context {
	51	char format;
	52	char contents_encryption_mode;
	53	char filenames_encryption_mode;
	54	char flags;
	55	char master_key_descriptor[F2FS_KEY_DESCRIPTOR_SIZE];
	56	char nonce[F2FS_KEY_DERIVATION_NONCE_SIZE];
	57	} __attribute__((__packed__));
	58
	59	/* Encryption parameters */
	60	#define F2FS_XTS_TWEAK_SIZE 16
	61	#define F2FS_AES_128_ECB_KEY_SIZE 16
	62	#define F2FS_AES_256_GCM_KEY_SIZE 32
	63	#define F2FS_AES_256_CBC_KEY_SIZE 32
	64	#define F2FS_AES_256_CTS_KEY_SIZE 32
65	#define F2FS_AES_256_XTS_KEY_SIZE 64
66	#define F2FS_MAX_KEY_SIZE 64
67
0adda907 JK	68	#define F2FS_KEY_DESC_PREFIX "f2fs:"
	69	#define F2FS_KEY_DESC_PREFIX_SIZE 5
	70
cde4de12 JK	71	struct f2fs_encryption_key {
	72	__u32 mode;
	73	char raw[F2FS_MAX_KEY_SIZE];
	74	__u32 size;
	75	} __attribute__((__packed__));
	76
	77	struct f2fs_crypt_info {
	78	unsigned char ci_mode;
	79	unsigned char ci_size;
	80	char ci_data_mode;
	81	char ci_filename_mode;
	82	char ci_flags;
	83	struct crypto_ablkcipher *ci_ctfm;
	84	struct key *ci_keyring_key;
	85	char ci_raw[F2FS_MAX_KEY_SIZE];
	86	char ci_master_key[F2FS_KEY_DESCRIPTOR_SIZE];
	87	};
	88
	89	#define F2FS_CTX_REQUIRES_FREE_ENCRYPT_FL 0x00000001
	90	#define F2FS_BOUNCE_PAGE_REQUIRES_FREE_ENCRYPT_FL 0x00000002
	91
	92	struct f2fs_crypto_ctx {
	93	struct crypto_tfm tfm; / Crypto API context */
	94	struct page bounce_page; / Ciphertext page on write path */
	95	struct page control_page; / Original page on write path */
	96	struct bio bio; / The bio for this context */
	97	struct work_struct work; /* Work queue for read complete path */
	98	struct list_head free_list; /* Free list */
	99	int flags; /* Flags */
	100	int mode; /* Encryption mode for tfm */
	101	};
	102
	103	struct f2fs_completion_result {
	104	struct completion completion;
	105	int res;
	106	};
	107
	108	#define DECLARE_F2FS_COMPLETION_RESULT(ecr) \
	109	struct f2fs_completion_result ecr = { \
	110	COMPLETION_INITIALIZER((ecr).completion), 0 }
	111
	112	static inline int f2fs_encryption_key_size(int mode)
	113	{
	114	switch (mode) {
	115	case F2FS_ENCRYPTION_MODE_AES_256_XTS:
	116	return F2FS_AES_256_XTS_KEY_SIZE;
	117	case F2FS_ENCRYPTION_MODE_AES_256_GCM:
	118	return F2FS_AES_256_GCM_KEY_SIZE;
	119	case F2FS_ENCRYPTION_MODE_AES_256_CBC:
	120	return F2FS_AES_256_CBC_KEY_SIZE;
	121	case F2FS_ENCRYPTION_MODE_AES_256_CTS:
	122	return F2FS_AES_256_CTS_KEY_SIZE;
	123	default:
	124	BUG();
	125	}
	126	return 0;
	127	}
	128
	129	#define F2FS_FNAME_NUM_SCATTER_ENTRIES 4
	130	#define F2FS_CRYPTO_BLOCK_SIZE 16
	131	#define F2FS_FNAME_CRYPTO_DIGEST_SIZE 32
	132
	133	/**
	134	* For encrypted symlinks, the ciphertext length is stored at the beginning
135	* of the string in little-endian format.
136	*/
137	struct f2fs_encrypted_symlink_data {
138	__le16 len;
139	char encrypted_path[1];
140	} __attribute__((__packed__));
141
142	/**
143	* This function is used to calculate the disk space required to
144	* store a filename of length l in encrypted symlink format.
145	*/
146	static inline u32 encrypted_symlink_data_len(u32 l)
147	{
148	return (l + sizeof(struct f2fs_encrypted_symlink_data) - 1);
149	}
150	#endif /* _F2FS_CRYPTO_H */