policy.c (1bdd3e05a0a3b4a97ea88bc46fef8fb265c8b94c) | policy.c (6e1918cfb263acacd3fc9239127732b69de64695) |
---|---|
1// SPDX-License-Identifier: GPL-2.0 2/* 3 * Encryption policy functions for per-file encryption support. 4 * 5 * Copyright (C) 2015, Google, Inc. 6 * Copyright (C) 2015, Motorola Mobility. 7 * 8 * Originally written by Michael Halcrow, 2015. 9 * Modified by Jaegeuk Kim, 2015. 10 * Modified by Eric Biggers, 2019 for v2 policy support. 11 */ 12 13#include <linux/random.h> 14#include <linux/string.h> 15#include <linux/mount.h> 16#include "fscrypt_private.h" 17 18/** 19 * fscrypt_policies_equal - check whether two encryption policies are the same 20 * 21 * Return: %true if equal, else %false 22 */ 23bool fscrypt_policies_equal(const union fscrypt_policy *policy1, 24 const union fscrypt_policy *policy2) 25{ 26 if (policy1->version != policy2->version) 27 return false; 28 29 return !memcmp(policy1, policy2, fscrypt_policy_size(policy1)); 30} 31 | 1// SPDX-License-Identifier: GPL-2.0 2/* 3 * Encryption policy functions for per-file encryption support. 4 * 5 * Copyright (C) 2015, Google, Inc. 6 * Copyright (C) 2015, Motorola Mobility. 7 * 8 * Originally written by Michael Halcrow, 2015. 9 * Modified by Jaegeuk Kim, 2015. 10 * Modified by Eric Biggers, 2019 for v2 policy support. 11 */ 12 13#include <linux/random.h> 14#include <linux/string.h> 15#include <linux/mount.h> 16#include "fscrypt_private.h" 17 18/** 19 * fscrypt_policies_equal - check whether two encryption policies are the same 20 * 21 * Return: %true if equal, else %false 22 */ 23bool fscrypt_policies_equal(const union fscrypt_policy *policy1, 24 const union fscrypt_policy *policy2) 25{ 26 if (policy1->version != policy2->version) 27 return false; 28 29 return !memcmp(policy1, policy2, fscrypt_policy_size(policy1)); 30} 31 |
32static bool fscrypt_valid_enc_modes(u32 contents_mode, u32 filenames_mode) 33{ 34 if (contents_mode == FSCRYPT_MODE_AES_256_XTS && 35 filenames_mode == FSCRYPT_MODE_AES_256_CTS) 36 return true; 37 38 if (contents_mode == FSCRYPT_MODE_AES_128_CBC && 39 filenames_mode == FSCRYPT_MODE_AES_128_CTS) 40 return true; 41 42 if (contents_mode == FSCRYPT_MODE_ADIANTUM && 43 filenames_mode == FSCRYPT_MODE_ADIANTUM) 44 return true; 45 46 return false; 47} 48 49static bool supported_direct_key_modes(const struct inode *inode, 50 u32 contents_mode, u32 filenames_mode) 51{ 52 const struct fscrypt_mode *mode; 53 54 if (contents_mode != filenames_mode) { 55 fscrypt_warn(inode, 56 "Direct key flag not allowed with different contents and filenames modes"); 57 return false; 58 } 59 mode = &fscrypt_modes[contents_mode]; 60 61 if (mode->ivsize < offsetofend(union fscrypt_iv, nonce)) { 62 fscrypt_warn(inode, "Direct key flag not allowed with %s", 63 mode->friendly_name); 64 return false; 65 } 66 return true; 67} 68 |
|
32static bool supported_iv_ino_lblk_64_policy( 33 const struct fscrypt_policy_v2 *policy, 34 const struct inode *inode) 35{ 36 struct super_block *sb = inode->i_sb; 37 int ino_bits = 64, lblk_bits = 64; 38 39 if (policy->flags & FSCRYPT_POLICY_FLAG_DIRECT_KEY) { 40 fscrypt_warn(inode, 41 "The DIRECT_KEY and IV_INO_LBLK_64 flags are mutually exclusive"); 42 return false; 43 } 44 /* 45 * It's unsafe to include inode numbers in the IVs if the filesystem can 46 * potentially renumber inodes, e.g. via filesystem shrinking. 47 */ 48 if (!sb->s_cop->has_stable_inodes || 49 !sb->s_cop->has_stable_inodes(sb)) { 50 fscrypt_warn(inode, 51 "Can't use IV_INO_LBLK_64 policy on filesystem '%s' because it doesn't have stable inode numbers", 52 sb->s_id); 53 return false; 54 } 55 if (sb->s_cop->get_ino_and_lblk_bits) 56 sb->s_cop->get_ino_and_lblk_bits(sb, &ino_bits, &lblk_bits); 57 if (ino_bits > 32 || lblk_bits > 32) { 58 fscrypt_warn(inode, 59 "Can't use IV_INO_LBLK_64 policy on filesystem '%s' because it doesn't use 32-bit inode and block numbers", 60 sb->s_id); 61 return false; 62 } 63 return true; 64} 65 | 69static bool supported_iv_ino_lblk_64_policy( 70 const struct fscrypt_policy_v2 *policy, 71 const struct inode *inode) 72{ 73 struct super_block *sb = inode->i_sb; 74 int ino_bits = 64, lblk_bits = 64; 75 76 if (policy->flags & FSCRYPT_POLICY_FLAG_DIRECT_KEY) { 77 fscrypt_warn(inode, 78 "The DIRECT_KEY and IV_INO_LBLK_64 flags are mutually exclusive"); 79 return false; 80 } 81 /* 82 * It's unsafe to include inode numbers in the IVs if the filesystem can 83 * potentially renumber inodes, e.g. via filesystem shrinking. 84 */ 85 if (!sb->s_cop->has_stable_inodes || 86 !sb->s_cop->has_stable_inodes(sb)) { 87 fscrypt_warn(inode, 88 "Can't use IV_INO_LBLK_64 policy on filesystem '%s' because it doesn't have stable inode numbers", 89 sb->s_id); 90 return false; 91 } 92 if (sb->s_cop->get_ino_and_lblk_bits) 93 sb->s_cop->get_ino_and_lblk_bits(sb, &ino_bits, &lblk_bits); 94 if (ino_bits > 32 || lblk_bits > 32) { 95 fscrypt_warn(inode, 96 "Can't use IV_INO_LBLK_64 policy on filesystem '%s' because it doesn't use 32-bit inode and block numbers", 97 sb->s_id); 98 return false; 99 } 100 return true; 101} 102 |
103static bool fscrypt_supported_v1_policy(const struct fscrypt_policy_v1 *policy, 104 const struct inode *inode) 105{ 106 if (!fscrypt_valid_enc_modes(policy->contents_encryption_mode, 107 policy->filenames_encryption_mode)) { 108 fscrypt_warn(inode, 109 "Unsupported encryption modes (contents %d, filenames %d)", 110 policy->contents_encryption_mode, 111 policy->filenames_encryption_mode); 112 return false; 113 } 114 115 if (policy->flags & ~(FSCRYPT_POLICY_FLAGS_PAD_MASK | 116 FSCRYPT_POLICY_FLAG_DIRECT_KEY)) { 117 fscrypt_warn(inode, "Unsupported encryption flags (0x%02x)", 118 policy->flags); 119 return false; 120 } 121 122 if ((policy->flags & FSCRYPT_POLICY_FLAG_DIRECT_KEY) && 123 !supported_direct_key_modes(inode, policy->contents_encryption_mode, 124 policy->filenames_encryption_mode)) 125 return false; 126 127 if (IS_CASEFOLDED(inode)) { 128 /* With v1, there's no way to derive dirhash keys. */ 129 fscrypt_warn(inode, 130 "v1 policies can't be used on casefolded directories"); 131 return false; 132 } 133 134 return true; 135} 136 137static bool fscrypt_supported_v2_policy(const struct fscrypt_policy_v2 *policy, 138 const struct inode *inode) 139{ 140 if (!fscrypt_valid_enc_modes(policy->contents_encryption_mode, 141 policy->filenames_encryption_mode)) { 142 fscrypt_warn(inode, 143 "Unsupported encryption modes (contents %d, filenames %d)", 144 policy->contents_encryption_mode, 145 policy->filenames_encryption_mode); 146 return false; 147 } 148 149 if (policy->flags & ~FSCRYPT_POLICY_FLAGS_VALID) { 150 fscrypt_warn(inode, "Unsupported encryption flags (0x%02x)", 151 policy->flags); 152 return false; 153 } 154 155 if ((policy->flags & FSCRYPT_POLICY_FLAG_DIRECT_KEY) && 156 !supported_direct_key_modes(inode, policy->contents_encryption_mode, 157 policy->filenames_encryption_mode)) 158 return false; 159 160 if ((policy->flags & FSCRYPT_POLICY_FLAG_IV_INO_LBLK_64) && 161 !supported_iv_ino_lblk_64_policy(policy, inode)) 162 return false; 163 164 if (memchr_inv(policy->__reserved, 0, sizeof(policy->__reserved))) { 165 fscrypt_warn(inode, "Reserved bits set in encryption policy"); 166 return false; 167 } 168 169 return true; 170} 171 |
|
66/** 67 * fscrypt_supported_policy - check whether an encryption policy is supported 68 * 69 * Given an encryption policy, check whether all its encryption modes and other | 172/** 173 * fscrypt_supported_policy - check whether an encryption policy is supported 174 * 175 * Given an encryption policy, check whether all its encryption modes and other |
70 * settings are supported by this kernel. (But we don't currently don't check 71 * for crypto API support here, so attempting to use an algorithm not configured 72 * into the crypto API will still fail later.) | 176 * settings are supported by this kernel on the given inode. (But we don't 177 * currently don't check for crypto API support here, so attempting to use an 178 * algorithm not configured into the crypto API will still fail later.) |
73 * 74 * Return: %true if supported, else %false 75 */ 76bool fscrypt_supported_policy(const union fscrypt_policy *policy_u, 77 const struct inode *inode) 78{ 79 switch (policy_u->version) { | 179 * 180 * Return: %true if supported, else %false 181 */ 182bool fscrypt_supported_policy(const union fscrypt_policy *policy_u, 183 const struct inode *inode) 184{ 185 switch (policy_u->version) { |
80 case FSCRYPT_POLICY_V1: { 81 const struct fscrypt_policy_v1 *policy = &policy_u->v1; 82 83 if (!fscrypt_valid_enc_modes(policy->contents_encryption_mode, 84 policy->filenames_encryption_mode)) { 85 fscrypt_warn(inode, 86 "Unsupported encryption modes (contents %d, filenames %d)", 87 policy->contents_encryption_mode, 88 policy->filenames_encryption_mode); 89 return false; 90 } 91 92 if (policy->flags & ~(FSCRYPT_POLICY_FLAGS_PAD_MASK | 93 FSCRYPT_POLICY_FLAG_DIRECT_KEY)) { 94 fscrypt_warn(inode, 95 "Unsupported encryption flags (0x%02x)", 96 policy->flags); 97 return false; 98 } 99 100 return true; | 186 case FSCRYPT_POLICY_V1: 187 return fscrypt_supported_v1_policy(&policy_u->v1, inode); 188 case FSCRYPT_POLICY_V2: 189 return fscrypt_supported_v2_policy(&policy_u->v2, inode); |
101 } | 190 } |
102 case FSCRYPT_POLICY_V2: { 103 const struct fscrypt_policy_v2 *policy = &policy_u->v2; 104 105 if (!fscrypt_valid_enc_modes(policy->contents_encryption_mode, 106 policy->filenames_encryption_mode)) { 107 fscrypt_warn(inode, 108 "Unsupported encryption modes (contents %d, filenames %d)", 109 policy->contents_encryption_mode, 110 policy->filenames_encryption_mode); 111 return false; 112 } 113 114 if (policy->flags & ~FSCRYPT_POLICY_FLAGS_VALID) { 115 fscrypt_warn(inode, 116 "Unsupported encryption flags (0x%02x)", 117 policy->flags); 118 return false; 119 } 120 121 if ((policy->flags & FSCRYPT_POLICY_FLAG_IV_INO_LBLK_64) && 122 !supported_iv_ino_lblk_64_policy(policy, inode)) 123 return false; 124 125 if (memchr_inv(policy->__reserved, 0, 126 sizeof(policy->__reserved))) { 127 fscrypt_warn(inode, 128 "Reserved bits set in encryption policy"); 129 return false; 130 } 131 132 return true; 133 } 134 } | |
135 return false; 136} 137 138/** 139 * fscrypt_new_context_from_policy - create a new fscrypt_context from a policy 140 * 141 * Create an fscrypt_context for an inode that is being assigned the given 142 * encryption policy. A new nonce is randomly generated. 143 * 144 * Return: the size of the new context in bytes. 145 */ 146static int fscrypt_new_context_from_policy(union fscrypt_context *ctx_u, 147 const union fscrypt_policy *policy_u) 148{ 149 memset(ctx_u, 0, sizeof(*ctx_u)); 150 151 switch (policy_u->version) { 152 case FSCRYPT_POLICY_V1: { 153 const struct fscrypt_policy_v1 *policy = &policy_u->v1; 154 struct fscrypt_context_v1 *ctx = &ctx_u->v1; 155 156 ctx->version = FSCRYPT_CONTEXT_V1; 157 ctx->contents_encryption_mode = 158 policy->contents_encryption_mode; 159 ctx->filenames_encryption_mode = 160 policy->filenames_encryption_mode; 161 ctx->flags = policy->flags; 162 memcpy(ctx->master_key_descriptor, 163 policy->master_key_descriptor, 164 sizeof(ctx->master_key_descriptor)); 165 get_random_bytes(ctx->nonce, sizeof(ctx->nonce)); 166 return sizeof(*ctx); 167 } 168 case FSCRYPT_POLICY_V2: { 169 const struct fscrypt_policy_v2 *policy = &policy_u->v2; 170 struct fscrypt_context_v2 *ctx = &ctx_u->v2; 171 172 ctx->version = FSCRYPT_CONTEXT_V2; 173 ctx->contents_encryption_mode = 174 policy->contents_encryption_mode; 175 ctx->filenames_encryption_mode = 176 policy->filenames_encryption_mode; 177 ctx->flags = policy->flags; 178 memcpy(ctx->master_key_identifier, 179 policy->master_key_identifier, 180 sizeof(ctx->master_key_identifier)); 181 get_random_bytes(ctx->nonce, sizeof(ctx->nonce)); 182 return sizeof(*ctx); 183 } 184 } 185 BUG(); 186} 187 188/** 189 * fscrypt_policy_from_context - convert an fscrypt_context to an fscrypt_policy 190 * 191 * Given an fscrypt_context, build the corresponding fscrypt_policy. 192 * 193 * Return: 0 on success, or -EINVAL if the fscrypt_context has an unrecognized 194 * version number or size. 195 * 196 * This does *not* validate the settings within the policy itself, e.g. the 197 * modes, flags, and reserved bits. Use fscrypt_supported_policy() for that. 198 */ 199int fscrypt_policy_from_context(union fscrypt_policy *policy_u, 200 const union fscrypt_context *ctx_u, 201 int ctx_size) 202{ 203 memset(policy_u, 0, sizeof(*policy_u)); 204 205 if (ctx_size <= 0 || ctx_size != fscrypt_context_size(ctx_u)) 206 return -EINVAL; 207 208 switch (ctx_u->version) { 209 case FSCRYPT_CONTEXT_V1: { 210 const struct fscrypt_context_v1 *ctx = &ctx_u->v1; 211 struct fscrypt_policy_v1 *policy = &policy_u->v1; 212 213 policy->version = FSCRYPT_POLICY_V1; 214 policy->contents_encryption_mode = 215 ctx->contents_encryption_mode; 216 policy->filenames_encryption_mode = 217 ctx->filenames_encryption_mode; 218 policy->flags = ctx->flags; 219 memcpy(policy->master_key_descriptor, 220 ctx->master_key_descriptor, 221 sizeof(policy->master_key_descriptor)); 222 return 0; 223 } 224 case FSCRYPT_CONTEXT_V2: { 225 const struct fscrypt_context_v2 *ctx = &ctx_u->v2; 226 struct fscrypt_policy_v2 *policy = &policy_u->v2; 227 228 policy->version = FSCRYPT_POLICY_V2; 229 policy->contents_encryption_mode = 230 ctx->contents_encryption_mode; 231 policy->filenames_encryption_mode = 232 ctx->filenames_encryption_mode; 233 policy->flags = ctx->flags; 234 memcpy(policy->__reserved, ctx->__reserved, 235 sizeof(policy->__reserved)); 236 memcpy(policy->master_key_identifier, 237 ctx->master_key_identifier, 238 sizeof(policy->master_key_identifier)); 239 return 0; 240 } 241 } 242 /* unreachable */ 243 return -EINVAL; 244} 245 246/* Retrieve an inode's encryption policy */ 247static int fscrypt_get_policy(struct inode *inode, union fscrypt_policy *policy) 248{ 249 const struct fscrypt_info *ci; 250 union fscrypt_context ctx; 251 int ret; 252 253 ci = READ_ONCE(inode->i_crypt_info); 254 if (ci) { 255 /* key available, use the cached policy */ 256 *policy = ci->ci_policy; 257 return 0; 258 } 259 260 if (!IS_ENCRYPTED(inode)) 261 return -ENODATA; 262 263 ret = inode->i_sb->s_cop->get_context(inode, &ctx, sizeof(ctx)); 264 if (ret < 0) 265 return (ret == -ERANGE) ? -EINVAL : ret; 266 267 return fscrypt_policy_from_context(policy, &ctx, ret); 268} 269 270static int set_encryption_policy(struct inode *inode, 271 const union fscrypt_policy *policy) 272{ 273 union fscrypt_context ctx; 274 int ctxsize; 275 int err; 276 277 if (!fscrypt_supported_policy(policy, inode)) 278 return -EINVAL; 279 280 switch (policy->version) { 281 case FSCRYPT_POLICY_V1: 282 /* 283 * The original encryption policy version provided no way of 284 * verifying that the correct master key was supplied, which was 285 * insecure in scenarios where multiple users have access to the 286 * same encrypted files (even just read-only access). The new 287 * encryption policy version fixes this and also implies use of 288 * an improved key derivation function and allows non-root users 289 * to securely remove keys. So as long as compatibility with 290 * old kernels isn't required, it is recommended to use the new 291 * policy version for all new encrypted directories. 292 */ 293 pr_warn_once("%s (pid %d) is setting deprecated v1 encryption policy; recommend upgrading to v2.\n", 294 current->comm, current->pid); 295 break; 296 case FSCRYPT_POLICY_V2: 297 err = fscrypt_verify_key_added(inode->i_sb, 298 policy->v2.master_key_identifier); 299 if (err) 300 return err; 301 break; 302 default: 303 WARN_ON(1); 304 return -EINVAL; 305 } 306 307 ctxsize = fscrypt_new_context_from_policy(&ctx, policy); 308 309 return inode->i_sb->s_cop->set_context(inode, &ctx, ctxsize, NULL); 310} 311 312int fscrypt_ioctl_set_policy(struct file *filp, const void __user *arg) 313{ 314 union fscrypt_policy policy; 315 union fscrypt_policy existing_policy; 316 struct inode *inode = file_inode(filp); 317 u8 version; 318 int size; 319 int ret; 320 321 if (get_user(policy.version, (const u8 __user *)arg)) 322 return -EFAULT; 323 324 size = fscrypt_policy_size(&policy); 325 if (size <= 0) 326 return -EINVAL; 327 328 /* 329 * We should just copy the remaining 'size - 1' bytes here, but a 330 * bizarre bug in gcc 7 and earlier (fixed by gcc r255731) causes gcc to 331 * think that size can be 0 here (despite the check above!) *and* that 332 * it's a compile-time constant. Thus it would think copy_from_user() 333 * is passed compile-time constant ULONG_MAX, causing the compile-time 334 * buffer overflow check to fail, breaking the build. This only occurred 335 * when building an i386 kernel with -Os and branch profiling enabled. 336 * 337 * Work around it by just copying the first byte again... 338 */ 339 version = policy.version; 340 if (copy_from_user(&policy, arg, size)) 341 return -EFAULT; 342 policy.version = version; 343 344 if (!inode_owner_or_capable(inode)) 345 return -EACCES; 346 347 ret = mnt_want_write_file(filp); 348 if (ret) 349 return ret; 350 351 inode_lock(inode); 352 353 ret = fscrypt_get_policy(inode, &existing_policy); 354 if (ret == -ENODATA) { 355 if (!S_ISDIR(inode->i_mode)) 356 ret = -ENOTDIR; 357 else if (IS_DEADDIR(inode)) 358 ret = -ENOENT; 359 else if (!inode->i_sb->s_cop->empty_dir(inode)) 360 ret = -ENOTEMPTY; 361 else 362 ret = set_encryption_policy(inode, &policy); 363 } else if (ret == -EINVAL || 364 (ret == 0 && !fscrypt_policies_equal(&policy, 365 &existing_policy))) { 366 /* The file already uses a different encryption policy. */ 367 ret = -EEXIST; 368 } 369 370 inode_unlock(inode); 371 372 mnt_drop_write_file(filp); 373 return ret; 374} 375EXPORT_SYMBOL(fscrypt_ioctl_set_policy); 376 377/* Original ioctl version; can only get the original policy version */ 378int fscrypt_ioctl_get_policy(struct file *filp, void __user *arg) 379{ 380 union fscrypt_policy policy; 381 int err; 382 383 err = fscrypt_get_policy(file_inode(filp), &policy); 384 if (err) 385 return err; 386 387 if (policy.version != FSCRYPT_POLICY_V1) 388 return -EINVAL; 389 390 if (copy_to_user(arg, &policy, sizeof(policy.v1))) 391 return -EFAULT; 392 return 0; 393} 394EXPORT_SYMBOL(fscrypt_ioctl_get_policy); 395 396/* Extended ioctl version; can get policies of any version */ 397int fscrypt_ioctl_get_policy_ex(struct file *filp, void __user *uarg) 398{ 399 struct fscrypt_get_policy_ex_arg arg; 400 union fscrypt_policy *policy = (union fscrypt_policy *)&arg.policy; 401 size_t policy_size; 402 int err; 403 404 /* arg is policy_size, then policy */ 405 BUILD_BUG_ON(offsetof(typeof(arg), policy_size) != 0); 406 BUILD_BUG_ON(offsetofend(typeof(arg), policy_size) != 407 offsetof(typeof(arg), policy)); 408 BUILD_BUG_ON(sizeof(arg.policy) != sizeof(*policy)); 409 410 err = fscrypt_get_policy(file_inode(filp), policy); 411 if (err) 412 return err; 413 policy_size = fscrypt_policy_size(policy); 414 415 if (copy_from_user(&arg, uarg, sizeof(arg.policy_size))) 416 return -EFAULT; 417 418 if (policy_size > arg.policy_size) 419 return -EOVERFLOW; 420 arg.policy_size = policy_size; 421 422 if (copy_to_user(uarg, &arg, sizeof(arg.policy_size) + policy_size)) 423 return -EFAULT; 424 return 0; 425} 426EXPORT_SYMBOL_GPL(fscrypt_ioctl_get_policy_ex); 427 428/** 429 * fscrypt_has_permitted_context() - is a file's encryption policy permitted 430 * within its directory? 431 * 432 * @parent: inode for parent directory 433 * @child: inode for file being looked up, opened, or linked into @parent 434 * 435 * Filesystems must call this before permitting access to an inode in a 436 * situation where the parent directory is encrypted (either before allowing 437 * ->lookup() to succeed, or for a regular file before allowing it to be opened) 438 * and before any operation that involves linking an inode into an encrypted 439 * directory, including link, rename, and cross rename. It enforces the 440 * constraint that within a given encrypted directory tree, all files use the 441 * same encryption policy. The pre-access check is needed to detect potentially 442 * malicious offline violations of this constraint, while the link and rename 443 * checks are needed to prevent online violations of this constraint. 444 * 445 * Return: 1 if permitted, 0 if forbidden. 446 */ 447int fscrypt_has_permitted_context(struct inode *parent, struct inode *child) 448{ 449 union fscrypt_policy parent_policy, child_policy; 450 int err; 451 452 /* No restrictions on file types which are never encrypted */ 453 if (!S_ISREG(child->i_mode) && !S_ISDIR(child->i_mode) && 454 !S_ISLNK(child->i_mode)) 455 return 1; 456 457 /* No restrictions if the parent directory is unencrypted */ 458 if (!IS_ENCRYPTED(parent)) 459 return 1; 460 461 /* Encrypted directories must not contain unencrypted files */ 462 if (!IS_ENCRYPTED(child)) 463 return 0; 464 465 /* 466 * Both parent and child are encrypted, so verify they use the same 467 * encryption policy. Compare the fscrypt_info structs if the keys are 468 * available, otherwise retrieve and compare the fscrypt_contexts. 469 * 470 * Note that the fscrypt_context retrieval will be required frequently 471 * when accessing an encrypted directory tree without the key. 472 * Performance-wise this is not a big deal because we already don't 473 * really optimize for file access without the key (to the extent that 474 * such access is even possible), given that any attempted access 475 * already causes a fscrypt_context retrieval and keyring search. 476 * 477 * In any case, if an unexpected error occurs, fall back to "forbidden". 478 */ 479 480 err = fscrypt_get_encryption_info(parent); 481 if (err) 482 return 0; 483 err = fscrypt_get_encryption_info(child); 484 if (err) 485 return 0; 486 487 err = fscrypt_get_policy(parent, &parent_policy); 488 if (err) 489 return 0; 490 491 err = fscrypt_get_policy(child, &child_policy); 492 if (err) 493 return 0; 494 495 return fscrypt_policies_equal(&parent_policy, &child_policy); 496} 497EXPORT_SYMBOL(fscrypt_has_permitted_context); 498 499/** 500 * fscrypt_inherit_context() - Sets a child context from its parent 501 * @parent: Parent inode from which the context is inherited. 502 * @child: Child inode that inherits the context from @parent. 503 * @fs_data: private data given by FS. 504 * @preload: preload child i_crypt_info if true 505 * 506 * Return: 0 on success, -errno on failure 507 */ 508int fscrypt_inherit_context(struct inode *parent, struct inode *child, 509 void *fs_data, bool preload) 510{ 511 union fscrypt_context ctx; 512 int ctxsize; 513 struct fscrypt_info *ci; 514 int res; 515 516 res = fscrypt_get_encryption_info(parent); 517 if (res < 0) 518 return res; 519 520 ci = READ_ONCE(parent->i_crypt_info); 521 if (ci == NULL) 522 return -ENOKEY; 523 524 ctxsize = fscrypt_new_context_from_policy(&ctx, &ci->ci_policy); 525 526 BUILD_BUG_ON(sizeof(ctx) != FSCRYPT_SET_CONTEXT_MAX_SIZE); 527 res = parent->i_sb->s_cop->set_context(child, &ctx, ctxsize, fs_data); 528 if (res) 529 return res; 530 return preload ? fscrypt_get_encryption_info(child): 0; 531} 532EXPORT_SYMBOL(fscrypt_inherit_context); | 191 return false; 192} 193 194/** 195 * fscrypt_new_context_from_policy - create a new fscrypt_context from a policy 196 * 197 * Create an fscrypt_context for an inode that is being assigned the given 198 * encryption policy. A new nonce is randomly generated. 199 * 200 * Return: the size of the new context in bytes. 201 */ 202static int fscrypt_new_context_from_policy(union fscrypt_context *ctx_u, 203 const union fscrypt_policy *policy_u) 204{ 205 memset(ctx_u, 0, sizeof(*ctx_u)); 206 207 switch (policy_u->version) { 208 case FSCRYPT_POLICY_V1: { 209 const struct fscrypt_policy_v1 *policy = &policy_u->v1; 210 struct fscrypt_context_v1 *ctx = &ctx_u->v1; 211 212 ctx->version = FSCRYPT_CONTEXT_V1; 213 ctx->contents_encryption_mode = 214 policy->contents_encryption_mode; 215 ctx->filenames_encryption_mode = 216 policy->filenames_encryption_mode; 217 ctx->flags = policy->flags; 218 memcpy(ctx->master_key_descriptor, 219 policy->master_key_descriptor, 220 sizeof(ctx->master_key_descriptor)); 221 get_random_bytes(ctx->nonce, sizeof(ctx->nonce)); 222 return sizeof(*ctx); 223 } 224 case FSCRYPT_POLICY_V2: { 225 const struct fscrypt_policy_v2 *policy = &policy_u->v2; 226 struct fscrypt_context_v2 *ctx = &ctx_u->v2; 227 228 ctx->version = FSCRYPT_CONTEXT_V2; 229 ctx->contents_encryption_mode = 230 policy->contents_encryption_mode; 231 ctx->filenames_encryption_mode = 232 policy->filenames_encryption_mode; 233 ctx->flags = policy->flags; 234 memcpy(ctx->master_key_identifier, 235 policy->master_key_identifier, 236 sizeof(ctx->master_key_identifier)); 237 get_random_bytes(ctx->nonce, sizeof(ctx->nonce)); 238 return sizeof(*ctx); 239 } 240 } 241 BUG(); 242} 243 244/** 245 * fscrypt_policy_from_context - convert an fscrypt_context to an fscrypt_policy 246 * 247 * Given an fscrypt_context, build the corresponding fscrypt_policy. 248 * 249 * Return: 0 on success, or -EINVAL if the fscrypt_context has an unrecognized 250 * version number or size. 251 * 252 * This does *not* validate the settings within the policy itself, e.g. the 253 * modes, flags, and reserved bits. Use fscrypt_supported_policy() for that. 254 */ 255int fscrypt_policy_from_context(union fscrypt_policy *policy_u, 256 const union fscrypt_context *ctx_u, 257 int ctx_size) 258{ 259 memset(policy_u, 0, sizeof(*policy_u)); 260 261 if (ctx_size <= 0 || ctx_size != fscrypt_context_size(ctx_u)) 262 return -EINVAL; 263 264 switch (ctx_u->version) { 265 case FSCRYPT_CONTEXT_V1: { 266 const struct fscrypt_context_v1 *ctx = &ctx_u->v1; 267 struct fscrypt_policy_v1 *policy = &policy_u->v1; 268 269 policy->version = FSCRYPT_POLICY_V1; 270 policy->contents_encryption_mode = 271 ctx->contents_encryption_mode; 272 policy->filenames_encryption_mode = 273 ctx->filenames_encryption_mode; 274 policy->flags = ctx->flags; 275 memcpy(policy->master_key_descriptor, 276 ctx->master_key_descriptor, 277 sizeof(policy->master_key_descriptor)); 278 return 0; 279 } 280 case FSCRYPT_CONTEXT_V2: { 281 const struct fscrypt_context_v2 *ctx = &ctx_u->v2; 282 struct fscrypt_policy_v2 *policy = &policy_u->v2; 283 284 policy->version = FSCRYPT_POLICY_V2; 285 policy->contents_encryption_mode = 286 ctx->contents_encryption_mode; 287 policy->filenames_encryption_mode = 288 ctx->filenames_encryption_mode; 289 policy->flags = ctx->flags; 290 memcpy(policy->__reserved, ctx->__reserved, 291 sizeof(policy->__reserved)); 292 memcpy(policy->master_key_identifier, 293 ctx->master_key_identifier, 294 sizeof(policy->master_key_identifier)); 295 return 0; 296 } 297 } 298 /* unreachable */ 299 return -EINVAL; 300} 301 302/* Retrieve an inode's encryption policy */ 303static int fscrypt_get_policy(struct inode *inode, union fscrypt_policy *policy) 304{ 305 const struct fscrypt_info *ci; 306 union fscrypt_context ctx; 307 int ret; 308 309 ci = READ_ONCE(inode->i_crypt_info); 310 if (ci) { 311 /* key available, use the cached policy */ 312 *policy = ci->ci_policy; 313 return 0; 314 } 315 316 if (!IS_ENCRYPTED(inode)) 317 return -ENODATA; 318 319 ret = inode->i_sb->s_cop->get_context(inode, &ctx, sizeof(ctx)); 320 if (ret < 0) 321 return (ret == -ERANGE) ? -EINVAL : ret; 322 323 return fscrypt_policy_from_context(policy, &ctx, ret); 324} 325 326static int set_encryption_policy(struct inode *inode, 327 const union fscrypt_policy *policy) 328{ 329 union fscrypt_context ctx; 330 int ctxsize; 331 int err; 332 333 if (!fscrypt_supported_policy(policy, inode)) 334 return -EINVAL; 335 336 switch (policy->version) { 337 case FSCRYPT_POLICY_V1: 338 /* 339 * The original encryption policy version provided no way of 340 * verifying that the correct master key was supplied, which was 341 * insecure in scenarios where multiple users have access to the 342 * same encrypted files (even just read-only access). The new 343 * encryption policy version fixes this and also implies use of 344 * an improved key derivation function and allows non-root users 345 * to securely remove keys. So as long as compatibility with 346 * old kernels isn't required, it is recommended to use the new 347 * policy version for all new encrypted directories. 348 */ 349 pr_warn_once("%s (pid %d) is setting deprecated v1 encryption policy; recommend upgrading to v2.\n", 350 current->comm, current->pid); 351 break; 352 case FSCRYPT_POLICY_V2: 353 err = fscrypt_verify_key_added(inode->i_sb, 354 policy->v2.master_key_identifier); 355 if (err) 356 return err; 357 break; 358 default: 359 WARN_ON(1); 360 return -EINVAL; 361 } 362 363 ctxsize = fscrypt_new_context_from_policy(&ctx, policy); 364 365 return inode->i_sb->s_cop->set_context(inode, &ctx, ctxsize, NULL); 366} 367 368int fscrypt_ioctl_set_policy(struct file *filp, const void __user *arg) 369{ 370 union fscrypt_policy policy; 371 union fscrypt_policy existing_policy; 372 struct inode *inode = file_inode(filp); 373 u8 version; 374 int size; 375 int ret; 376 377 if (get_user(policy.version, (const u8 __user *)arg)) 378 return -EFAULT; 379 380 size = fscrypt_policy_size(&policy); 381 if (size <= 0) 382 return -EINVAL; 383 384 /* 385 * We should just copy the remaining 'size - 1' bytes here, but a 386 * bizarre bug in gcc 7 and earlier (fixed by gcc r255731) causes gcc to 387 * think that size can be 0 here (despite the check above!) *and* that 388 * it's a compile-time constant. Thus it would think copy_from_user() 389 * is passed compile-time constant ULONG_MAX, causing the compile-time 390 * buffer overflow check to fail, breaking the build. This only occurred 391 * when building an i386 kernel with -Os and branch profiling enabled. 392 * 393 * Work around it by just copying the first byte again... 394 */ 395 version = policy.version; 396 if (copy_from_user(&policy, arg, size)) 397 return -EFAULT; 398 policy.version = version; 399 400 if (!inode_owner_or_capable(inode)) 401 return -EACCES; 402 403 ret = mnt_want_write_file(filp); 404 if (ret) 405 return ret; 406 407 inode_lock(inode); 408 409 ret = fscrypt_get_policy(inode, &existing_policy); 410 if (ret == -ENODATA) { 411 if (!S_ISDIR(inode->i_mode)) 412 ret = -ENOTDIR; 413 else if (IS_DEADDIR(inode)) 414 ret = -ENOENT; 415 else if (!inode->i_sb->s_cop->empty_dir(inode)) 416 ret = -ENOTEMPTY; 417 else 418 ret = set_encryption_policy(inode, &policy); 419 } else if (ret == -EINVAL || 420 (ret == 0 && !fscrypt_policies_equal(&policy, 421 &existing_policy))) { 422 /* The file already uses a different encryption policy. */ 423 ret = -EEXIST; 424 } 425 426 inode_unlock(inode); 427 428 mnt_drop_write_file(filp); 429 return ret; 430} 431EXPORT_SYMBOL(fscrypt_ioctl_set_policy); 432 433/* Original ioctl version; can only get the original policy version */ 434int fscrypt_ioctl_get_policy(struct file *filp, void __user *arg) 435{ 436 union fscrypt_policy policy; 437 int err; 438 439 err = fscrypt_get_policy(file_inode(filp), &policy); 440 if (err) 441 return err; 442 443 if (policy.version != FSCRYPT_POLICY_V1) 444 return -EINVAL; 445 446 if (copy_to_user(arg, &policy, sizeof(policy.v1))) 447 return -EFAULT; 448 return 0; 449} 450EXPORT_SYMBOL(fscrypt_ioctl_get_policy); 451 452/* Extended ioctl version; can get policies of any version */ 453int fscrypt_ioctl_get_policy_ex(struct file *filp, void __user *uarg) 454{ 455 struct fscrypt_get_policy_ex_arg arg; 456 union fscrypt_policy *policy = (union fscrypt_policy *)&arg.policy; 457 size_t policy_size; 458 int err; 459 460 /* arg is policy_size, then policy */ 461 BUILD_BUG_ON(offsetof(typeof(arg), policy_size) != 0); 462 BUILD_BUG_ON(offsetofend(typeof(arg), policy_size) != 463 offsetof(typeof(arg), policy)); 464 BUILD_BUG_ON(sizeof(arg.policy) != sizeof(*policy)); 465 466 err = fscrypt_get_policy(file_inode(filp), policy); 467 if (err) 468 return err; 469 policy_size = fscrypt_policy_size(policy); 470 471 if (copy_from_user(&arg, uarg, sizeof(arg.policy_size))) 472 return -EFAULT; 473 474 if (policy_size > arg.policy_size) 475 return -EOVERFLOW; 476 arg.policy_size = policy_size; 477 478 if (copy_to_user(uarg, &arg, sizeof(arg.policy_size) + policy_size)) 479 return -EFAULT; 480 return 0; 481} 482EXPORT_SYMBOL_GPL(fscrypt_ioctl_get_policy_ex); 483 484/** 485 * fscrypt_has_permitted_context() - is a file's encryption policy permitted 486 * within its directory? 487 * 488 * @parent: inode for parent directory 489 * @child: inode for file being looked up, opened, or linked into @parent 490 * 491 * Filesystems must call this before permitting access to an inode in a 492 * situation where the parent directory is encrypted (either before allowing 493 * ->lookup() to succeed, or for a regular file before allowing it to be opened) 494 * and before any operation that involves linking an inode into an encrypted 495 * directory, including link, rename, and cross rename. It enforces the 496 * constraint that within a given encrypted directory tree, all files use the 497 * same encryption policy. The pre-access check is needed to detect potentially 498 * malicious offline violations of this constraint, while the link and rename 499 * checks are needed to prevent online violations of this constraint. 500 * 501 * Return: 1 if permitted, 0 if forbidden. 502 */ 503int fscrypt_has_permitted_context(struct inode *parent, struct inode *child) 504{ 505 union fscrypt_policy parent_policy, child_policy; 506 int err; 507 508 /* No restrictions on file types which are never encrypted */ 509 if (!S_ISREG(child->i_mode) && !S_ISDIR(child->i_mode) && 510 !S_ISLNK(child->i_mode)) 511 return 1; 512 513 /* No restrictions if the parent directory is unencrypted */ 514 if (!IS_ENCRYPTED(parent)) 515 return 1; 516 517 /* Encrypted directories must not contain unencrypted files */ 518 if (!IS_ENCRYPTED(child)) 519 return 0; 520 521 /* 522 * Both parent and child are encrypted, so verify they use the same 523 * encryption policy. Compare the fscrypt_info structs if the keys are 524 * available, otherwise retrieve and compare the fscrypt_contexts. 525 * 526 * Note that the fscrypt_context retrieval will be required frequently 527 * when accessing an encrypted directory tree without the key. 528 * Performance-wise this is not a big deal because we already don't 529 * really optimize for file access without the key (to the extent that 530 * such access is even possible), given that any attempted access 531 * already causes a fscrypt_context retrieval and keyring search. 532 * 533 * In any case, if an unexpected error occurs, fall back to "forbidden". 534 */ 535 536 err = fscrypt_get_encryption_info(parent); 537 if (err) 538 return 0; 539 err = fscrypt_get_encryption_info(child); 540 if (err) 541 return 0; 542 543 err = fscrypt_get_policy(parent, &parent_policy); 544 if (err) 545 return 0; 546 547 err = fscrypt_get_policy(child, &child_policy); 548 if (err) 549 return 0; 550 551 return fscrypt_policies_equal(&parent_policy, &child_policy); 552} 553EXPORT_SYMBOL(fscrypt_has_permitted_context); 554 555/** 556 * fscrypt_inherit_context() - Sets a child context from its parent 557 * @parent: Parent inode from which the context is inherited. 558 * @child: Child inode that inherits the context from @parent. 559 * @fs_data: private data given by FS. 560 * @preload: preload child i_crypt_info if true 561 * 562 * Return: 0 on success, -errno on failure 563 */ 564int fscrypt_inherit_context(struct inode *parent, struct inode *child, 565 void *fs_data, bool preload) 566{ 567 union fscrypt_context ctx; 568 int ctxsize; 569 struct fscrypt_info *ci; 570 int res; 571 572 res = fscrypt_get_encryption_info(parent); 573 if (res < 0) 574 return res; 575 576 ci = READ_ONCE(parent->i_crypt_info); 577 if (ci == NULL) 578 return -ENOKEY; 579 580 ctxsize = fscrypt_new_context_from_policy(&ctx, &ci->ci_policy); 581 582 BUILD_BUG_ON(sizeof(ctx) != FSCRYPT_SET_CONTEXT_MAX_SIZE); 583 res = parent->i_sb->s_cop->set_context(child, &ctx, ctxsize, fs_data); 584 if (res) 585 return res; 586 return preload ? fscrypt_get_encryption_info(child): 0; 587} 588EXPORT_SYMBOL(fscrypt_inherit_context); |