Re: [PATCH 1/1] f2fs-tools: Introduce metadata encryption support

[jaegeuk@kernel.org]

Hi Satya,

On 10/05, Satya Tangirala wrote:
> Introduce native metadata encryption support for F2FS. All blocks
> other than the super block are encrypted with the specified metadata
> encryption key and algorithm. The data unit number for each block is its
> block number in the filesystem.
> 
> This patch introduces two new options '-A' and '-M' for specifying metadata
> crypt options. '-A' takes the desired metadata encryption algorithm as
> argument. '-M' takes the linux key_serial of the metadata encryption key as
> the argument. The keyring key provided must be of a key type that supports
> reading the payload from userspace.

Could you please update manpages as well?

> 
> mkfs.f2fs takes both these arguments, and stores the encryption algorithm
> in the superblock of the FS.
> 
> The rest of the programs only take '-M', and use the encryption algorithm
> stored in the superblock of the FS.
> 
> Signed-off-by: Satya Tangirala <satyat@google.com>
> ---
>  fsck/main.c                   |  47 ++++++-
>  fsck/mount.c                  |  33 ++++-
>  include/f2fs_fs.h             |  10 +-
>  include/f2fs_metadata_crypt.h |  21 ++++
>  lib/Makefile.am               |   4 +-
>  lib/f2fs_metadata_crypt.c     | 226 ++++++++++++++++++++++++++++++++++
>  lib/libf2fs_io.c              |  87 +++++++++++--
>  mkfs/f2fs_format.c            |   5 +-
>  mkfs/f2fs_format_main.c       |  33 ++++-
>  9 files changed, 446 insertions(+), 20 deletions(-)
>  create mode 100644 include/f2fs_metadata_crypt.h
>  create mode 100644 lib/f2fs_metadata_crypt.c
> 
> diff --git a/fsck/main.c b/fsck/main.c
> index 32559f1..6a4d867 100644
> --- a/fsck/main.c
> +++ b/fsck/main.c
> @@ -26,6 +26,8 @@
>  #include <stdbool.h>
>  #include "quotaio.h"
>  
> +#include "f2fs_metadata_crypt.h"
> +
>  struct f2fs_fsck gfsck;
>  
>  #ifdef WITH_ANDROID
> @@ -62,6 +64,7 @@ void fsck_usage()
>  			" (default 0)\n");
>  	MSG(0, "  -m <max-hash-collision>  set max cache hash collision"
>  			" (default 16)\n");
> +	MSG(0, "  -M Metadata encryption key_serial in keyring\n");
>  	MSG(0, "  -C encoding[:flag1,flag2] Set options for enabling"
>  			" casefolding\n");
>  	MSG(0, "  -d debug level [default:0]\n");
> @@ -92,6 +95,7 @@ void dump_usage()
>  	MSG(0, "  -S sparse_mode\n");
>  	MSG(0, "  -a [SSA dump segno from #1~#2 (decimal), for all 0~-1]\n");
>  	MSG(0, "  -b blk_addr (in 4KB)\n");
> +	MSG(0, "  -M Metadata encryption key_serial in keyring\n");
>  	MSG(0, "  -V print the version number and exit\n");
>  
>  	exit(1);
> @@ -107,6 +111,7 @@ void defrag_usage()
>  	MSG(0, "  -l length [default:512 (2MB)]\n");
>  	MSG(0, "  -t target block address [default: main_blkaddr + 2MB]\n");
>  	MSG(0, "  -i set direction as shrink [default: expand]\n");
> +	MSG(0, "  -M Metadata encryption key_serial in keyring\n");
>  	MSG(0, "  -V print the version number and exit\n");
>  	exit(1);
>  }
> @@ -119,6 +124,7 @@ void resize_usage()
>  	MSG(0, "  -i extended node bitmap, node ratio is 20%% by default\n");
>  	MSG(0, "  -s safe resize (Does not resize metadata)");
>  	MSG(0, "  -t target sectors [default: device size]\n");
> +	MSG(0, "  -M Metadata encryption key_serial in keyring\n");
>  	MSG(0, "  -V print the version number and exit\n");
>  	exit(1);
>  }
> @@ -129,6 +135,7 @@ void sload_usage()
>  	MSG(0, "[options]:\n");
>  	MSG(0, "  -C fs_config\n");
>  	MSG(0, "  -f source directory [path of the source directory]\n");
> +	MSG(0, "  -M Metadata encryption key_serial in keyring\n");
>  	MSG(0, "  -p product out directory\n");
>  	MSG(0, "  -s file_contexts\n");
>  	MSG(0, "  -S sparse_mode\n");
> @@ -200,7 +207,7 @@ void f2fs_parse_options(int argc, char *argv[])
>  	}
>  
>  	if (!strcmp("fsck.f2fs", prog)) {
> -		const char *option_string = ":aC:c:m:d:fg:O:p:q:StyV";
> +		const char *option_string = ":aC:c:m:M:d:fg:O:p:q:StyV";
>  		int opt = 0, val;
>  		char *token;
>  		struct option long_opt[] = {
> @@ -243,6 +250,12 @@ void f2fs_parse_options(int argc, char *argv[])
>  				c.cache_config.max_hash_collision =
>  						atoi(optarg);
>  				break;
> +			case 'M':
> +				if (f2fs_metadata_process_key(optarg)) {
> +					MSG(0, "Error: Invalid metadata key\n");
> +					fsck_usage();
> +				}
> +				break;
>  			case 'g':
>  				if (!strcmp(optarg, "android"))
>  					c.defset = CONF_ANDROID;
> @@ -345,7 +358,7 @@ void f2fs_parse_options(int argc, char *argv[])
>  				break;
>  		}
>  	} else if (!strcmp("dump.f2fs", prog)) {
> -		const char *option_string = "d:i:n:s:Sa:b:V";
> +		const char *option_string = "d:i:n:s:Sa:b:M:V";
>  		static struct dump_option dump_opt = {
>  			.nid = 0,	/* default root ino */
>  			.start_nat = -1,
> @@ -413,6 +426,12 @@ void f2fs_parse_options(int argc, char *argv[])
>  					ret = sscanf(optarg, "%x",
>  							&dump_opt.blk_addr);
>  				break;
> +			case 'M':
> +				if (f2fs_metadata_process_key(optarg)) {
> +					MSG(0, "Error: Invalid metadata key\n");
> +					dump_usage();
> +				}
> +				break;
>  			case 'V':
>  				show_version(prog);
>  				exit(0);
> @@ -427,7 +446,7 @@ void f2fs_parse_options(int argc, char *argv[])
>  
>  		c.private = &dump_opt;
>  	} else if (!strcmp("defrag.f2fs", prog)) {
> -		const char *option_string = "d:s:Sl:t:iV";
> +		const char *option_string = "d:M:s:Sl:t:iV";
>  
>  		c.func = DEFRAG;
>  		while ((option = getopt(argc, argv, option_string)) != EOF) {
> @@ -473,6 +492,12 @@ void f2fs_parse_options(int argc, char *argv[])
>  			case 'i':
>  				c.defrag_shrink = 1;
>  				break;
> +			case 'M':
> +				if (f2fs_metadata_process_key(optarg)) {
> +					MSG(0, "Error: Invalid metadata key\n");
> +					defrag_usage();
> +				}
> +				break;
>  			case 'V':
>  				show_version(prog);
>  				exit(0);
> @@ -485,7 +510,7 @@ void f2fs_parse_options(int argc, char *argv[])
>  				break;
>  		}
>  	} else if (!strcmp("resize.f2fs", prog)) {
> -		const char *option_string = "d:st:iV";
> +		const char *option_string = "d:M:st:iV";
>  
>  		c.func = RESIZE;
>  		while ((option = getopt(argc, argv, option_string)) != EOF) {
> @@ -515,6 +540,12 @@ void f2fs_parse_options(int argc, char *argv[])
>  			case 'i':
>  				c.large_nat_bitmap = 1;
>  				break;
> +			case 'M':
> +				if (f2fs_metadata_process_key(optarg)) {
> +					MSG(0, "Error: Invalid metadata key\n");
> +					resize_usage();
> +				}
> +				break;
>  			case 'V':
>  				show_version(prog);
>  				exit(0);
> @@ -527,7 +558,7 @@ void f2fs_parse_options(int argc, char *argv[])
>  				break;
>  		}
>  	} else if (!strcmp("sload.f2fs", prog)) {
> -		const char *option_string = "C:d:f:p:s:St:T:V";
> +		const char *option_string = "C:d:f:M:p:s:St:T:V";
>  #ifdef HAVE_LIBSELINUX
>  		int max_nr_opt = (int)sizeof(c.seopt_file) /
>  			sizeof(c.seopt_file[0]);
> @@ -553,6 +584,12 @@ void f2fs_parse_options(int argc, char *argv[])
>  			case 'f':
>  				c.from_dir = absolute_path(optarg);
>  				break;
> +			case 'M':
> +				if (f2fs_metadata_process_key(optarg)) {
> +					MSG(0, "Error: Invalid metadata key\n");
> +					sload_usage();
> +				}
> +				break;
>  			case 'p':
>  				c.target_out_dir = absolute_path(optarg);
>  				break;
> diff --git a/fsck/mount.c b/fsck/mount.c
> index 8ebc5b0..7520a8a 100644
> --- a/fsck/mount.c
> +++ b/fsck/mount.c
> @@ -11,6 +11,7 @@
>  #include "fsck.h"
>  #include "node.h"
>  #include "xattr.h"
> +#include "f2fs_metadata_crypt.h"
>  #include <locale.h>
>  #include <stdbool.h>
>  #ifdef HAVE_LINUX_POSIX_ACL_H
> @@ -561,6 +562,10 @@ void print_sb_state(struct f2fs_super_block *sb)
>  	if (f & cpu_to_le32(F2FS_FEATURE_COMPRESSION)) {
>  		MSG(0, "%s", " compression");
>  	}
> +	if (sb->metadata_crypt_alg) {
> +		MSG(0, "%s", " metadata_crypt");
> +	}
> +
>  	MSG(0, "\n");
>  	MSG(0, "Info: superblock encrypt level = %d, salt = ",
>  					sb->encryption_level);
> @@ -686,7 +691,7 @@ void update_superblock(struct f2fs_super_block *sb, int sb_mask)
>  	memcpy(buf + F2FS_SUPER_OFFSET, sb, sizeof(*sb));
>  	for (addr = SB0_ADDR; addr < SB_MAX_ADDR; addr++) {
>  		if (SB_MASK(addr) & sb_mask) {
> -			ret = dev_write_block(buf, addr);
> +			ret = dev_write_block_unencrypted(buf, addr);
>  			ASSERT(ret >= 0);
>  		}
>  	}
> @@ -927,6 +932,24 @@ int sanity_check_raw_super(struct f2fs_super_block *sb, enum SB_ADDR sb_addr)
>  		return -1;
>  	}
>  
> +	/*
> +	 * Check that metadata encryption is enabled on superblock when metadata
> +	 * crypt key is specified
> +	 */
> +	if (get_sb(metadata_crypt_alg) && !c.metadata_crypt_key) {
> +		MSG(0, "\tFilesystem has metadata encryption, but we're missing the metadata encryption key.\n");
> +		return -1;
> +	}
> +
> +	/*
> +	 * Check that metadata encryption is disabled on superblock when metadata
> +	 * crypt key is not specified
> +	 */
> +	if (!get_sb(metadata_crypt_alg) && c.metadata_crypt_key) {
> +		MSG(0, "\tFilesystem has does not have metadata encryption, but a metadata encryption key was specified.\n");
> +		return -1;
> +	}
> +
>  	if (sanity_check_area_boundary(sb, sb_addr))
>  		return -1;
>  	return 0;
> @@ -940,7 +963,7 @@ int validate_super_block(struct f2fs_sb_info *sbi, enum SB_ADDR sb_addr)
>  	if (!sbi->raw_super)
>  		return -ENOMEM;
>  
> -	if (dev_read_block(buf, sb_addr))
> +	if (dev_read_block_unencrypted(buf, sb_addr))
>  		return -1;
>  
>  	memcpy(sbi->raw_super, buf + F2FS_SUPER_OFFSET,
> @@ -3499,6 +3522,12 @@ int f2fs_do_mount(struct f2fs_sb_info *sbi)
>  	}
>  	sb = F2FS_RAW_SUPER(sbi);
>  
> +	/* Get metadata encryption algorithm */
> +	c.metadata_crypt_alg = get_sb(metadata_crypt_alg);
> +
> +	if (f2fs_metadata_verify_args())
> +		exit(1);
> +
>  	ret = check_sector_size(sb);
>  	if (ret)
>  		return -1;
> diff --git a/include/f2fs_fs.h b/include/f2fs_fs.h
> index b5bda13..6b1912d 100644
> --- a/include/f2fs_fs.h
> +++ b/include/f2fs_fs.h
> @@ -441,6 +441,11 @@ struct f2fs_configuration {
>  
>  	/* cache parameters */
>  	dev_cache_config_t cache_config;
> +
> +	/* metadata encryption */
> +	__u8 *metadata_crypt_key;
> +	int metadata_crypt_key_len;
> +	int metadata_crypt_alg;
>  };
>  
>  #ifdef CONFIG_64BIT
> @@ -675,7 +680,8 @@ struct f2fs_super_block {
>  	__u8 hot_ext_count;		/* # of hot file extension */
>  	__le16  s_encoding;		/* Filename charset encoding */
>  	__le16  s_encoding_flags;	/* Filename charset encoding flags */
> -	__u8 reserved[306];		/* valid reserved region */
> +	__le32	metadata_crypt_alg;	/* The metadata encryption algorithm (FSCRYPT_MODE_*) */
> +	__u8 reserved[302];		/* valid reserved region */
>  	__le32 crc;			/* checksum of superblock */
>  } __attribute__((packed));
>  
> @@ -1237,12 +1243,14 @@ extern int dev_readahead(__u64, size_t UNUSED(len));
>  #endif
>  extern int dev_write(void *, __u64, size_t);
>  extern int dev_write_block(void *, __u64);
> +extern int dev_write_block_unencrypted(void *, __u64);
>  extern int dev_write_dump(void *, __u64, size_t);
>  /* All bytes in the buffer must be 0 use dev_fill(). */
>  extern int dev_fill(void *, __u64, size_t);
>  extern int dev_fill_block(void *, __u64);
>  
>  extern int dev_read_block(void *, __u64);
> +extern int dev_read_block_unencrypted(void *, __u64);
>  extern int dev_reada_block(__u64);
>  
>  extern int dev_read_version(void *, __u64, size_t);
> diff --git a/include/f2fs_metadata_crypt.h b/include/f2fs_metadata_crypt.h
> new file mode 100644
> index 0000000..d15873d
> --- /dev/null
> +++ b/include/f2fs_metadata_crypt.h
> @@ -0,0 +1,21 @@
> +/**
> + * f2fs_metadata_crypt.h
> + *
> + * Copyright (c) 2020 Google LLC
> + *
> + * Dual licensed under the GPL or LGPL version 2 licenses.
> + */
> +
> +#include <inttypes.h>
> +#include <linux/fscrypt.h>
> +
> +int f2fs_get_crypt_alg(const char *optarg);
> +
> +void f2fs_print_crypt_algs(void);
> +
> +int f2fs_metadata_process_key(const char *key_serial);
> +
> +int f2fs_metadata_verify_args(void);
> +
> +void *f2fs_metadata_crypt_blocks(void *src_buf, size_t len, __u64 blk_addr,
> +	bool encrypt);
> diff --git a/lib/Makefile.am b/lib/Makefile.am
> index 871d773..a82d753 100644
> --- a/lib/Makefile.am
> +++ b/lib/Makefile.am
> @@ -2,10 +2,10 @@
>  
>  lib_LTLIBRARIES = libf2fs.la
>  
> -libf2fs_la_SOURCES = libf2fs.c libf2fs_io.c libf2fs_zoned.c nls_utf8.c
> +libf2fs_la_SOURCES = libf2fs.c libf2fs_io.c libf2fs_zoned.c nls_utf8.c f2fs_metadata_crypt.c
>  libf2fs_la_CFLAGS = -Wall
>  libf2fs_la_CPPFLAGS = -I$(top_srcdir)/include
> -libf2fs_la_LDFLAGS = -version-info $(LIBF2FS_CURRENT):$(LIBF2FS_REVISION):$(LIBF2FS_AGE)
> +libf2fs_la_LDFLAGS = -lkeyutils -version-info $(LIBF2FS_CURRENT):$(LIBF2FS_REVISION):$(LIBF2FS_AGE)
>  
>  root_libdir=@root_libdir@
>  
> diff --git a/lib/f2fs_metadata_crypt.c b/lib/f2fs_metadata_crypt.c
> new file mode 100644
> index 0000000..faf399a
> --- /dev/null
> +++ b/lib/f2fs_metadata_crypt.c
> @@ -0,0 +1,226 @@
> +/**
> + * f2fs_metadata_crypt.c
> + *
> + * Copyright (c) 2020 Google LLC
> + *
> + * Dual licensed under the GPL or LGPL version 2 licenses.
> + */
> +#include <string.h>
> +#include <stdio.h>
> +#include <stdlib.h>
> +#include <unistd.h>
> +#include <sys/socket.h>
> +#include <linux/if_alg.h>
> +#include <linux/socket.h>
> +#include <assert.h>
> +#include <errno.h>
> +#include <keyutils.h>
> +
> +#include "f2fs_fs.h"
> +#include "f2fs_metadata_crypt.h"
> +
> +extern struct f2fs_configuration c;
> +struct f2fs_crypt_mode {
> +	const char *friendly_name;
> +	const char *cipher_str;
> +	unsigned int keysize;
> +	unsigned int ivlen;
> +} f2fs_crypt_modes[] = {
> +	[FSCRYPT_MODE_AES_256_XTS] = {
> +		.friendly_name = "AES-256-XTS",
> +		.cipher_str = "xts(aes)",
> +		.keysize = 64,
> +		.ivlen = 16,
> +	},
> +	[FSCRYPT_MODE_ADIANTUM] = {
> +		.friendly_name = "Adiantum",
> +		.cipher_str = "adiantum(xchacha12,aes)",
> +		.keysize = 32,
> +		.ivlen = 32,
> +	},
> +};
> +#define MAX_IV_LEN 32
> +
> +void f2fs_print_crypt_algs(void)
> +{
> +	int i;
> +
> +	for (i = 1; i <= __FSCRYPT_MODE_MAX; i++) {
> +		if (!f2fs_crypt_modes[i].friendly_name)
> +			continue;
> +		MSG(0, "\t%s\n", f2fs_crypt_modes[i].friendly_name);
> +	}
> +}
> +
> +int f2fs_get_crypt_alg(const char *optarg)
> +{
> +	int i;
> +
> +	for (i = 1; i <= __FSCRYPT_MODE_MAX; i++) {
> +		if (f2fs_crypt_modes[i].friendly_name &&
> +		    !strcmp(f2fs_crypt_modes[i].friendly_name, optarg)) {
> +			return i;
> +		}
> +	}
> +
> +	return 0;
> +}
> +
> +int f2fs_metadata_process_key(const char *key_serial_str)
> +{
> +	key_serial_t key_serial = strtol(key_serial_str, NULL, 10);
> +
> +	c.metadata_crypt_key_len =
> +		keyctl_read_alloc(key_serial, (void **)&c.metadata_crypt_key);
> +
> +	if (c.metadata_crypt_key_len < 0)
> +		return errno;
> +
> +	return 0;
> +}
> +
> +int f2fs_metadata_verify_args(void)
> +{
> +	/* If neither specified, nothing to do */
> +	if (!c.metadata_crypt_key && !c.metadata_crypt_alg)
> +		return 0;
> +
> +	/* We need both specified */
> +	if (!c.metadata_crypt_key || !c.metadata_crypt_alg)
> +		return -EINVAL;
> +
> +	if (c.metadata_crypt_key_len !=
> +	    f2fs_crypt_modes[c.metadata_crypt_alg].keysize) {
> +		MSG(0, "\tMetadata encryption key length %d didn't match required size %d\n",
> +		    c.metadata_crypt_key_len,
> +		    f2fs_crypt_modes[c.metadata_crypt_alg].keysize);
> +
> +		return -EINVAL;
> +	}

Need to check sparse mode here?

And, what about multiple partition case?

> +
> +	return 0;
> +}
> +
> +void f2fs_metadata_crypt_gen_iv(struct af_alg_iv *iv, __u64 blk_addr)
> +{
> +	int i = 0;
> +
> +	memset(iv->iv, 0, iv->ivlen);
> +
> +	while (blk_addr > 0) {
> +		iv->iv[i] = blk_addr & 0xFF;
> +		blk_addr >>= 8;
> +		i++;
> +	}
> +}
> +
> +int f2fs_metadata_crypt_block(void *buf, size_t len, __u64 blk_addr,
> +			      bool encrypt)
> +{
> +	struct f2fs_crypt_mode *crypt_mode;
> +	int sockfd, fd;
> +	struct sockaddr_alg sa = {
> +		.salg_family = AF_ALG,
> +		.salg_type = "skcipher",
> +	};
> +	struct msghdr msg = {};
> +	struct cmsghdr *cmsg;
> +	char cbuf[CMSG_SPACE(4) + CMSG_SPACE(4 + MAX_IV_LEN)] = {0};
> +	int blk_offset;
> +	struct af_alg_iv *iv;
> +	struct iovec iov;
> +	int err;
> +
> +	crypt_mode = &f2fs_crypt_modes[c.metadata_crypt_alg];
> +	memcpy(sa.salg_name, crypt_mode->cipher_str,
> +	       strlen(crypt_mode->cipher_str));
> +
> +	sockfd = socket(AF_ALG, SOCK_SEQPACKET, 0);
> +	if (sockfd < 0)
> +		return errno;
> +	err = bind(sockfd, (struct sockaddr *)&sa, sizeof(sa));
> +	if (err) {
> +		MSG(0, "\tCouldn't bind crypto socket. Maybe support for the crypto algorithm isn't enabled?\n");
> +		close(sockfd);
> +		return errno;
> +	}
> +	err = setsockopt(sockfd, SOL_ALG, ALG_SET_KEY, c.metadata_crypt_key,
> +			 crypt_mode->keysize);
> +	if (err) {
> +		MSG(0, "\tCouldn't set crypto socket options.\n");
> +		close(sockfd);
> +		return errno;
> +	}
> +	fd = accept(sockfd, NULL, 0);
> +	if (fd < 0)
> +		goto err_out;
> +
> +	msg.msg_control = cbuf;
> +	msg.msg_controllen = sizeof(cbuf);
> +
> +	cmsg = CMSG_FIRSTHDR(&msg);
> +	cmsg->cmsg_level = SOL_ALG;
> +	cmsg->cmsg_type = ALG_SET_OP;
> +	cmsg->cmsg_len = CMSG_LEN(4);
> +	*(__u32 *)CMSG_DATA(cmsg) = encrypt ? ALG_OP_ENCRYPT : ALG_OP_DECRYPT;
> +
> +	cmsg = CMSG_NXTHDR(&msg, cmsg);
> +	cmsg->cmsg_level = SOL_ALG;
> +	cmsg->cmsg_type = ALG_SET_IV;
> +	cmsg->cmsg_len = CMSG_LEN(4 + MAX_IV_LEN);
> +	iv = (void *)CMSG_DATA(cmsg);
> +	iv->ivlen = crypt_mode->ivlen;
> +
> +	iov.iov_len = F2FS_BLKSIZE;
> +
> +	msg.msg_iov = &iov;
> +	msg.msg_iovlen = 1;
> +
> +	for (blk_offset = 0; blk_offset < len / F2FS_BLKSIZE; blk_offset++) {
> +		f2fs_metadata_crypt_gen_iv(iv, blk_addr + blk_offset);
> +
> +		iov.iov_base = (char *)buf + blk_offset * F2FS_BLKSIZE;
> +
> +		err = sendmsg(fd, &msg, 0);
> +		if (err < 0)
> +			goto err_out;
> +		err = read(fd, (char *)buf + blk_offset * F2FS_BLKSIZE,
> +			   F2FS_BLKSIZE);
> +		if (err < 0)
> +			goto err_out;
> +	}
> +
> +	close(fd);
> +	close(sockfd);
> +
> +	return 0;
> +
> +err_out:
> +	err = errno;
> +	close(fd);
> +	close(sockfd);
> +
> +	return err;
> +}
> +
> +void *f2fs_metadata_crypt_blocks(void *buf, size_t len, __u64 blk_addr,
> +	bool encrypt)
> +{
> +	int err = 0;
> +	void *enc_buf;
> +
> +	if (!c.metadata_crypt_key)
> +		return buf;
> +
> +	enc_buf = malloc(len);
> +	memcpy(enc_buf, buf, len);
> +
> +	err = f2fs_metadata_crypt_block(enc_buf, len, blk_addr, encrypt);
> +	if (err) {
> +		MSG(0, "\tFailed to en/decrypt blocks. Errno %d\n", err);
> +		free(enc_buf);
> +		return NULL;
> +	}
> +
> +	return enc_buf;
> +}
> diff --git a/lib/libf2fs_io.c b/lib/libf2fs_io.c
> index 138285d..f117e1e 100644
> --- a/lib/libf2fs_io.c
> +++ b/lib/libf2fs_io.c
> @@ -33,6 +33,7 @@
>  #include <assert.h>
>  #include <inttypes.h>
>  #include "f2fs_fs.h"
> +#include "f2fs_metadata_crypt.h"
>  
>  struct f2fs_configuration c;
>  
> @@ -499,10 +500,12 @@ static int sparse_write_blk(__u64 block, int count, const void *buf) { return 0;
>  static int sparse_write_zeroed_blk(__u64 block, int count) { return 0; }
>  #endif
>  
> -int dev_read(void *buf, __u64 offset, size_t len)
> +int __dev_read(void *buf, __u64 offset, size_t len, bool unencrypted)
>  {
>  	int fd;
> +	__u64 blk_addr = offset >> F2FS_BLKSIZE_BITS;
>  	int err;
> +	void *new_buf = NULL;
>  
>  	if (c.sparse_mode)
>  		return sparse_read_blk(offset / F2FS_BLKSIZE,
> @@ -521,9 +524,29 @@ int dev_read(void *buf, __u64 offset, size_t len)
>  		return -1;
>  	if (read(fd, buf, len) < 0)
>  		return -1;
> +	if (!unencrypted) {
> +		new_buf = f2fs_metadata_crypt_blocks(buf, len, blk_addr, false);
> +		if (!new_buf)
> +			return -1;
> +		if (new_buf != buf) {
> +			memcpy(buf, new_buf, len);
> +			free(new_buf);
> +		}
> +	}
> +
>  	return 0;
>  }
>  
> +int dev_read(void *buf, __u64 offset, size_t len)
> +{
> +	return __dev_read(buf, offset, len, false);
> +}
> +
> +int dev_read_unencrypted(void *buf, __u64 offset, size_t len)
> +{
> +	return __dev_read(buf, offset, len, true);
> +}
> +
>  #ifdef POSIX_FADV_WILLNEED
>  int dev_readahead(__u64 offset, size_t len)
>  #else
> @@ -541,13 +564,17 @@ int dev_readahead(__u64 offset, size_t UNUSED(len))
>  #endif
>  }
>  
> -int dev_write(void *buf, __u64 offset, size_t len)
> +int __dev_write(void *buf, __u64 offset, size_t len, bool unencrypted)
>  {
>  	int fd;
> +	__u64 blk_addr = offset >> F2FS_BLKSIZE_BITS;
> +	void *src_buf = buf;
> +	int err = -1;
>  
>  	if (c.dry_run)
>  		return 0;
>  
> +	/* TODO: handle sparse mode with metadata encryption */
>  	if (c.sparse_mode)
>  		return sparse_write_blk(offset / F2FS_BLKSIZE,
>  					len / F2FS_BLKSIZE, buf);
> @@ -562,11 +589,26 @@ int dev_write(void *buf, __u64 offset, size_t len)
>  	 */
>  	if (dcache_update_cache(fd, buf, (off64_t)offset, len) < 0)
>  		return -1;
> +	if (!unencrypted) {
> +		buf = f2fs_metadata_crypt_blocks(buf, len, blk_addr, true);
> +		if (!buf)
> +			return -1;
> +	}
>  	if (lseek64(fd, (off64_t)offset, SEEK_SET) < 0)
> -		return -1;
> +		goto out;
>  	if (write(fd, buf, len) < 0)
> -		return -1;
> -	return 0;
> +		goto out;
> +
> +	err = 0;
> +out:
> +	if (buf != src_buf)
> +		free(buf);
> +	return err;
> +}
> +
> +int dev_write(void *buf, __u64 offset, size_t len)
> +{
> +	return __dev_write(buf, offset, len, false);
>  }
>  
>  int dev_write_block(void *buf, __u64 blk_addr)
> @@ -574,6 +616,16 @@ int dev_write_block(void *buf, __u64 blk_addr)
>  	return dev_write(buf, blk_addr << F2FS_BLKSIZE_BITS, F2FS_BLKSIZE);
>  }
>  
> +static int dev_write_unencrypted(void *buf, __u64 offset, size_t len)
> +{
> +	return __dev_write(buf, offset, len, true);
> +}
> +
> +int dev_write_block_unencrypted(void *buf, __u64 blk_addr)
> +{
> +	return dev_write_unencrypted(buf, blk_addr << F2FS_BLKSIZE_BITS, F2FS_BLKSIZE);
> +}
> +
>  int dev_write_dump(void *buf, __u64 offset, size_t len)
>  {
>  	if (lseek64(c.dump_fd, (off64_t)offset, SEEK_SET) < 0)
> @@ -586,7 +638,11 @@ int dev_write_dump(void *buf, __u64 offset, size_t len)
>  int dev_fill(void *buf, __u64 offset, size_t len)
>  {
>  	int fd;
> +	__u64 blk_addr = offset >> F2FS_BLKSIZE_BITS;
> +	void *src_buf = buf;
> +	int err = -1;
>  
> +	/* TODO: handle sparse mode with metadata encryption */
>  	if (c.sparse_mode)
>  		return sparse_write_zeroed_blk(offset / F2FS_BLKSIZE,
>  						len / F2FS_BLKSIZE);
> @@ -598,11 +654,21 @@ int dev_fill(void *buf, __u64 offset, size_t len)
>  	/* Only allow fill to zero */
>  	if (*((__u8*)buf))
>  		return -1;
> -	if (lseek64(fd, (off64_t)offset, SEEK_SET) < 0)
> +
> +	buf = f2fs_metadata_crypt_blocks(buf, len, blk_addr, true);
> +	if (!buf)
>  		return -1;
> +
> +	if (lseek64(fd, (off64_t)offset, SEEK_SET) < 0)
> +		goto out;
>  	if (write(fd, buf, len) < 0)
> -		return -1;
> -	return 0;
> +		goto out;
> +
> +	err = 0;
> +out:
> +	if (buf != src_buf)
> +		free(buf);
> +	return err;
>  }
>  
>  int dev_fill_block(void *buf, __u64 blk_addr)
> @@ -615,6 +681,11 @@ int dev_read_block(void *buf, __u64 blk_addr)
>  	return dev_read(buf, blk_addr << F2FS_BLKSIZE_BITS, F2FS_BLKSIZE);
>  }
>  
> +int dev_read_block_unencrypted(void *buf, __u64 blk_addr)
> +{
> +	return dev_read_unencrypted(buf, blk_addr << F2FS_BLKSIZE_BITS, F2FS_BLKSIZE);
> +}
> +
>  int dev_reada_block(__u64 blk_addr)
>  {
>  	return dev_readahead(blk_addr << F2FS_BLKSIZE_BITS, F2FS_BLKSIZE);
> diff --git a/mkfs/f2fs_format.c b/mkfs/f2fs_format.c
> index a6c542e..bf587bf 100644
> --- a/mkfs/f2fs_format.c
> +++ b/mkfs/f2fs_format.c
> @@ -537,6 +537,9 @@ static int f2fs_prepare_super_block(void)
>  		set_sb(s_encoding_flags, c.s_encoding_flags);
>  	}
>  
> +	if (c.metadata_crypt_key)
> +		set_sb(metadata_crypt_alg, c.metadata_crypt_alg);
> +
>  	sb->feature = c.feature;
>  
>  	if (get_sb(feature) & F2FS_FEATURE_SB_CHKSUM) {
> @@ -1046,7 +1049,7 @@ static int f2fs_write_super_block(void)
>  	memcpy(zero_buff + F2FS_SUPER_OFFSET, sb, sizeof(*sb));
>  	DBG(1, "\tWriting super block, at offset 0x%08x\n", 0);
>  	for (index = 0; index < 2; index++) {
> -		if (dev_write_block(zero_buff, index)) {
> +		if (dev_write_block_unencrypted(zero_buff, index)) {
>  			MSG(1, "\tError: While while writing super_blk "
>  					"on disk!!! index : %d\n", index);
>  			free(zero_buff);
> diff --git a/mkfs/f2fs_format_main.c b/mkfs/f2fs_format_main.c
> index f2f0a80..8856850 100644
> --- a/mkfs/f2fs_format_main.c
> +++ b/mkfs/f2fs_format_main.c
> @@ -28,6 +28,7 @@
>  
>  #include "f2fs_fs.h"
>  #include "f2fs_format_utils.h"
> +#include "f2fs_metadata_crypt.h"
>  
>  #ifdef WITH_ANDROID
>  #include <sparse/sparse.h>
> @@ -44,6 +45,7 @@ static void mkfs_usage()
>  	MSG(0, "\nUsage: mkfs.f2fs [options] device [sectors]\n");
>  	MSG(0, "[options]:\n");
>  	MSG(0, "  -a heap-based allocation [default:0]\n");
> +	MSG(0, "  -A Metadata encryption algorithm\n");
>  	MSG(0, "  -c device1[,device2,...] up to 7 additional devices, except meta device\n");
>  	MSG(0, "  -d debug level [default:0]\n");
>  	MSG(0, "  -e [cold file ext list] e.g. \"mp3,gif,mov\"\n");
> @@ -54,6 +56,7 @@ static void mkfs_usage()
>  	MSG(0, "  -l label\n");
>  	MSG(0, "  -U uuid\n");
>  	MSG(0, "  -m support zoned block device [default:0]\n");
> +	MSG(0, "  -M Metadata encryption key_serial in keyring\n");
>  	MSG(0, "  -o overprovision percentage [default:auto]\n");
>  	MSG(0, "  -O feature1[,feature2,...] e.g. \"encrypt\"\n");
>  	MSG(0, "  -C [encoding[:flag1,...]] Support casefolding with optional flags\n");
> @@ -97,6 +100,12 @@ static void f2fs_show_info()
>  					f2fs_encoding2str(c.s_encoding));
>  	if (c.feature & le32_to_cpu(F2FS_FEATURE_PRJQUOTA))
>  		MSG(0, "Info: Enable Project quota\n");
> +
> +	if (c.metadata_crypt_key)
> +		MSG(0, "Info: Metadata key is %s\n", c.metadata_crypt_key);
> +
> +	if (c.metadata_crypt_alg)
> +		MSG(0, "Info: Metadata alg is %d\n", c.metadata_crypt_alg);
>  }
>  
>  static void add_default_options(void)
> @@ -125,7 +134,7 @@ static void add_default_options(void)
>  
>  static void f2fs_parse_options(int argc, char *argv[])
>  {
> -	static const char *option_string = "qa:c:C:d:e:E:g:il:mo:O:rR:s:S:z:t:T:U:Vfw:";
> +	static const char *option_string = "qa:A:c:C:d:e:E:g:il:mM:o:O:rR:s:S:z:t:T:U:Vfw:";
>  	int32_t option=0;
>  	int val;
>  	char *token;
> @@ -138,6 +147,14 @@ static void f2fs_parse_options(int argc, char *argv[])
>  		case 'a':
>  			c.heap = atoi(optarg);
>  			break;
> +		case 'A':
> +			c.metadata_crypt_alg = f2fs_get_crypt_alg(optarg);
> +			if (c.metadata_crypt_alg < 0) {
> +				MSG(0, "Error: invalid crypt algorithm specified. The choices are:");
> +				f2fs_print_crypt_algs();
> +				exit(1);
> +			}
> +			break;
>  		case 'c':
>  			if (c.ndevs >= MAX_DEVICES) {
>  				MSG(0, "Error: Too many devices\n");
> @@ -178,6 +195,12 @@ static void f2fs_parse_options(int argc, char *argv[])
>  		case 'm':
>  			c.zoned_mode = 1;
>  			break;
> +		case 'M':
> +			if (f2fs_metadata_process_key(optarg)) {
> +				MSG(0, "Error: Invalid metadata key\n");
> +				mkfs_usage();
> +			}
> +			break;
>  		case 'o':
>  			c.overprovision = atof(optarg);
>  			break;
> @@ -244,6 +267,14 @@ static void f2fs_parse_options(int argc, char *argv[])
>  		}
>  	}
>  
> +	if ((!!c.metadata_crypt_key) != (!!c.metadata_crypt_alg)) {
> +		MSG(0, "\tError: Both the metadata crypt key and crypt algorithm must be specified!");
> +		exit(1);
> +	}
> +
> +	if (f2fs_metadata_verify_args())
> +		exit(1);
> +
>  	add_default_options();

Need to check options after add_default_options()?

Thanks,

>  
>  	if (!(c.feature & cpu_to_le32(F2FS_FEATURE_EXTRA_ATTR))) {
> -- 
> 2.28.0.806.g8561365e88-goog