2 * copied from linux/fs/ext4/crypto_policy.c
4 * Copyright (C) 2015, Google, Inc.
5 * Copyright (C) 2015, Motorola Mobility.
7 * This contains encryption policy functions for f2fs with some modifications
8 * to support f2fs-specific xattr APIs.
10 * Written by Michael Halcrow, 2015.
11 * Modified by Jaegeuk Kim, 2015.
13 #include <linux/random.h>
14 #include <linux/string.h>
15 #include <linux/types.h>
16 #include <linux/f2fs_fs.h>
21 static int f2fs_inode_has_encryption_context(struct inode
*inode
)
23 int res
= f2fs_getxattr(inode
, F2FS_XATTR_INDEX_ENCRYPTION
,
24 F2FS_XATTR_NAME_ENCRYPTION_CONTEXT
, NULL
, 0, NULL
);
29 * check whether the policy is consistent with the encryption context
32 static int f2fs_is_encryption_context_consistent_with_policy(
33 struct inode
*inode
, const struct f2fs_encryption_policy
*policy
)
35 struct f2fs_encryption_context ctx
;
36 int res
= f2fs_getxattr(inode
, F2FS_XATTR_INDEX_ENCRYPTION
,
37 F2FS_XATTR_NAME_ENCRYPTION_CONTEXT
, &ctx
,
40 if (res
!= sizeof(ctx
))
43 return (memcmp(ctx
.master_key_descriptor
, policy
->master_key_descriptor
,
44 F2FS_KEY_DESCRIPTOR_SIZE
) == 0 &&
45 (ctx
.flags
== policy
->flags
) &&
46 (ctx
.contents_encryption_mode
==
47 policy
->contents_encryption_mode
) &&
48 (ctx
.filenames_encryption_mode
==
49 policy
->filenames_encryption_mode
));
52 static int f2fs_create_encryption_context_from_policy(
53 struct inode
*inode
, const struct f2fs_encryption_policy
*policy
)
55 struct f2fs_encryption_context ctx
;
57 ctx
.format
= F2FS_ENCRYPTION_CONTEXT_FORMAT_V1
;
58 memcpy(ctx
.master_key_descriptor
, policy
->master_key_descriptor
,
59 F2FS_KEY_DESCRIPTOR_SIZE
);
61 if (!f2fs_valid_contents_enc_mode(policy
->contents_encryption_mode
)) {
63 "%s: Invalid contents encryption mode %d\n", __func__
,
64 policy
->contents_encryption_mode
);
68 if (!f2fs_valid_filenames_enc_mode(policy
->filenames_encryption_mode
)) {
70 "%s: Invalid filenames encryption mode %d\n", __func__
,
71 policy
->filenames_encryption_mode
);
75 if (policy
->flags
& ~F2FS_POLICY_FLAGS_VALID
)
78 ctx
.contents_encryption_mode
= policy
->contents_encryption_mode
;
79 ctx
.filenames_encryption_mode
= policy
->filenames_encryption_mode
;
80 ctx
.flags
= policy
->flags
;
81 BUILD_BUG_ON(sizeof(ctx
.nonce
) != F2FS_KEY_DERIVATION_NONCE_SIZE
);
82 get_random_bytes(ctx
.nonce
, F2FS_KEY_DERIVATION_NONCE_SIZE
);
84 return f2fs_setxattr(inode
, F2FS_XATTR_INDEX_ENCRYPTION
,
85 F2FS_XATTR_NAME_ENCRYPTION_CONTEXT
, &ctx
,
86 sizeof(ctx
), NULL
, XATTR_CREATE
);
89 int f2fs_process_policy(const struct f2fs_encryption_policy
*policy
,
92 if (!inode_owner_or_capable(inode
))
95 if (policy
->version
!= 0)
98 if (!S_ISDIR(inode
->i_mode
))
101 if (!f2fs_inode_has_encryption_context(inode
)) {
102 if (!f2fs_empty_dir(inode
))
104 return f2fs_create_encryption_context_from_policy(inode
,
108 if (f2fs_is_encryption_context_consistent_with_policy(inode
, policy
))
111 printk(KERN_WARNING
"%s: Policy inconsistent with encryption context\n",
116 int f2fs_get_policy(struct inode
*inode
, struct f2fs_encryption_policy
*policy
)
118 struct f2fs_encryption_context ctx
;
121 if (!f2fs_encrypted_inode(inode
))
124 res
= f2fs_getxattr(inode
, F2FS_XATTR_INDEX_ENCRYPTION
,
125 F2FS_XATTR_NAME_ENCRYPTION_CONTEXT
,
126 &ctx
, sizeof(ctx
), NULL
);
127 if (res
!= sizeof(ctx
))
129 if (ctx
.format
!= F2FS_ENCRYPTION_CONTEXT_FORMAT_V1
)
133 policy
->contents_encryption_mode
= ctx
.contents_encryption_mode
;
134 policy
->filenames_encryption_mode
= ctx
.filenames_encryption_mode
;
135 policy
->flags
= ctx
.flags
;
136 memcpy(&policy
->master_key_descriptor
, ctx
.master_key_descriptor
,
137 F2FS_KEY_DESCRIPTOR_SIZE
);
141 int f2fs_is_child_context_consistent_with_parent(struct inode
*parent
,
144 const struct f2fs_crypt_info
*parent_ci
, *child_ci
;
145 struct f2fs_encryption_context parent_ctx
, child_ctx
;
148 /* No restrictions on file types which are never encrypted */
149 if (!S_ISREG(child
->i_mode
) && !S_ISDIR(child
->i_mode
) &&
150 !S_ISLNK(child
->i_mode
))
153 /* No restrictions if the parent directory is unencrypted */
154 if (!f2fs_encrypted_inode(parent
))
157 /* Encrypted directories must not contain unencrypted files */
158 if (!f2fs_encrypted_inode(child
))
162 * Both parent and child are encrypted, so verify they use the same
163 * encryption policy. Compare the fscrypt_info structs if the keys are
164 * available, otherwise retrieve and compare the fscrypt_contexts.
166 * Note that the fscrypt_context retrieval will be required frequently
167 * when accessing an encrypted directory tree without the key.
168 * Performance-wise this is not a big deal because we already don't
169 * really optimize for file access without the key (to the extent that
170 * such access is even possible), given that any attempted access
171 * already causes a fscrypt_context retrieval and keyring search.
173 * In any case, if an unexpected error occurs, fall back to "forbidden".
176 res
= f2fs_get_encryption_info(parent
);
179 res
= f2fs_get_encryption_info(child
);
182 parent_ci
= F2FS_I(parent
)->i_crypt_info
;
183 child_ci
= F2FS_I(child
)->i_crypt_info
;
184 if (parent_ci
&& child_ci
) {
185 return memcmp(parent_ci
->ci_master_key
, child_ci
->ci_master_key
,
186 F2FS_KEY_DESCRIPTOR_SIZE
) == 0 &&
187 (parent_ci
->ci_data_mode
== child_ci
->ci_data_mode
) &&
188 (parent_ci
->ci_filename_mode
==
189 child_ci
->ci_filename_mode
) &&
190 (parent_ci
->ci_flags
== child_ci
->ci_flags
);
193 res
= f2fs_getxattr(parent
, F2FS_XATTR_INDEX_ENCRYPTION
,
194 F2FS_XATTR_NAME_ENCRYPTION_CONTEXT
,
195 &parent_ctx
, sizeof(parent_ctx
), NULL
);
196 if (res
!= sizeof(parent_ctx
))
199 res
= f2fs_getxattr(child
, F2FS_XATTR_INDEX_ENCRYPTION
,
200 F2FS_XATTR_NAME_ENCRYPTION_CONTEXT
,
201 &child_ctx
, sizeof(child_ctx
), NULL
);
202 if (res
!= sizeof(child_ctx
))
205 return memcmp(parent_ctx
.master_key_descriptor
,
206 child_ctx
.master_key_descriptor
,
207 F2FS_KEY_DESCRIPTOR_SIZE
) == 0 &&
208 (parent_ctx
.contents_encryption_mode
==
209 child_ctx
.contents_encryption_mode
) &&
210 (parent_ctx
.filenames_encryption_mode
==
211 child_ctx
.filenames_encryption_mode
) &&
212 (parent_ctx
.flags
== child_ctx
.flags
);
216 * f2fs_inherit_context() - Sets a child context from its parent
217 * @parent: Parent inode from which the context is inherited.
218 * @child: Child inode that inherits the context from @parent.
220 * Return: Zero on success, non-zero otherwise
222 int f2fs_inherit_context(struct inode
*parent
, struct inode
*child
,
225 struct f2fs_encryption_context ctx
;
226 struct f2fs_crypt_info
*ci
;
229 res
= f2fs_get_encryption_info(parent
);
233 ci
= F2FS_I(parent
)->i_crypt_info
;
236 ctx
.format
= F2FS_ENCRYPTION_CONTEXT_FORMAT_V1
;
238 ctx
.contents_encryption_mode
= ci
->ci_data_mode
;
239 ctx
.filenames_encryption_mode
= ci
->ci_filename_mode
;
240 ctx
.flags
= ci
->ci_flags
;
241 memcpy(ctx
.master_key_descriptor
, ci
->ci_master_key
,
242 F2FS_KEY_DESCRIPTOR_SIZE
);
244 get_random_bytes(ctx
.nonce
, F2FS_KEY_DERIVATION_NONCE_SIZE
);
245 return f2fs_setxattr(child
, F2FS_XATTR_INDEX_ENCRYPTION
,
246 F2FS_XATTR_NAME_ENCRYPTION_CONTEXT
, &ctx
,
247 sizeof(ctx
), ipage
, XATTR_CREATE
);