1 // SPDX-License-Identifier: GPL-2.0-only
5 * Encryption hooks for higher-level filesystem operations.
10 #include "fscrypt_private.h"
13 * fscrypt_file_open() - prepare to open a possibly-encrypted regular file
14 * @inode: the inode being opened
15 * @filp: the struct file being set up
17 * Currently, an encrypted regular file can only be opened if its encryption key
18 * is available; access to the raw encrypted contents is not supported.
19 * Therefore, we first set up the inode's encryption key (if not already done)
20 * and return an error if it's unavailable.
22 * We also verify that if the parent directory (from the path via which the file
23 * is being opened) is encrypted, then the inode being opened uses the same
24 * encryption policy. This is needed as part of the enforcement that all files
25 * in an encrypted directory tree use the same encryption policy, as a
26 * protection against certain types of offline attacks. Note that this check is
27 * needed even when opening an *unencrypted* file, since it's forbidden to have
28 * an unencrypted file in an encrypted directory.
30 * Return: 0 on success, -ENOKEY if the key is missing, or another -errno code
32 int fscrypt_file_open(struct inode
*inode
, struct file
*filp
)
37 err
= fscrypt_require_key(inode
);
41 dir
= dget_parent(file_dentry(filp
));
42 if (IS_ENCRYPTED(d_inode(dir
)) &&
43 !fscrypt_has_permitted_context(d_inode(dir
), inode
)) {
45 "Inconsistent encryption context (parent directory: %lu)",
52 EXPORT_SYMBOL_GPL(fscrypt_file_open
);
54 int __fscrypt_prepare_link(struct inode
*inode
, struct inode
*dir
,
55 struct dentry
*dentry
)
59 err
= fscrypt_require_key(dir
);
63 /* ... in case we looked up no-key name before key was added */
64 if (fscrypt_is_nokey_name(dentry
))
67 if (!fscrypt_has_permitted_context(dir
, inode
))
72 EXPORT_SYMBOL_GPL(__fscrypt_prepare_link
);
74 int __fscrypt_prepare_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
75 struct inode
*new_dir
, struct dentry
*new_dentry
,
80 err
= fscrypt_require_key(old_dir
);
84 err
= fscrypt_require_key(new_dir
);
88 /* ... in case we looked up no-key name(s) before key was added */
89 if (fscrypt_is_nokey_name(old_dentry
) ||
90 fscrypt_is_nokey_name(new_dentry
))
93 if (old_dir
!= new_dir
) {
94 if (IS_ENCRYPTED(new_dir
) &&
95 !fscrypt_has_permitted_context(new_dir
,
99 if ((flags
& RENAME_EXCHANGE
) &&
100 IS_ENCRYPTED(old_dir
) &&
101 !fscrypt_has_permitted_context(old_dir
,
102 d_inode(new_dentry
)))
107 EXPORT_SYMBOL_GPL(__fscrypt_prepare_rename
);
109 int __fscrypt_prepare_lookup(struct inode
*dir
, struct dentry
*dentry
,
110 struct fscrypt_name
*fname
)
112 int err
= fscrypt_setup_filename(dir
, &dentry
->d_name
, 1, fname
);
114 if (err
&& err
!= -ENOENT
)
117 if (fname
->is_nokey_name
) {
118 spin_lock(&dentry
->d_lock
);
119 dentry
->d_flags
|= DCACHE_NOKEY_NAME
;
120 spin_unlock(&dentry
->d_lock
);
121 d_set_d_op(dentry
, &fscrypt_d_ops
);
125 EXPORT_SYMBOL_GPL(__fscrypt_prepare_lookup
);
128 * fscrypt_prepare_setflags() - prepare to change flags with FS_IOC_SETFLAGS
129 * @inode: the inode on which flags are being changed
130 * @oldflags: the old flags
131 * @flags: the new flags
133 * The caller should be holding i_rwsem for write.
135 * Return: 0 on success; -errno if the flags change isn't allowed or if
136 * another error occurs.
138 int fscrypt_prepare_setflags(struct inode
*inode
,
139 unsigned int oldflags
, unsigned int flags
)
141 struct fscrypt_info
*ci
;
142 struct fscrypt_master_key
*mk
;
146 * When the CASEFOLD flag is set on an encrypted directory, we must
147 * derive the secret key needed for the dirhash. This is only possible
148 * if the directory uses a v2 encryption policy.
150 if (IS_ENCRYPTED(inode
) && (flags
& ~oldflags
& FS_CASEFOLD_FL
)) {
151 err
= fscrypt_require_key(inode
);
154 ci
= inode
->i_crypt_info
;
155 if (ci
->ci_policy
.version
!= FSCRYPT_POLICY_V2
)
157 mk
= ci
->ci_master_key
->payload
.data
[0];
158 down_read(&mk
->mk_secret_sem
);
159 if (is_master_key_secret_present(&mk
->mk_secret
))
160 err
= fscrypt_derive_dirhash_key(ci
, mk
);
163 up_read(&mk
->mk_secret_sem
);
170 * fscrypt_prepare_symlink() - prepare to create a possibly-encrypted symlink
171 * @dir: directory in which the symlink is being created
172 * @target: plaintext symlink target
173 * @len: length of @target excluding null terminator
174 * @max_len: space the filesystem has available to store the symlink target
175 * @disk_link: (out) the on-disk symlink target being prepared
177 * This function computes the size the symlink target will require on-disk,
178 * stores it in @disk_link->len, and validates it against @max_len. An
179 * encrypted symlink may be longer than the original.
181 * Additionally, @disk_link->name is set to @target if the symlink will be
182 * unencrypted, but left NULL if the symlink will be encrypted. For encrypted
183 * symlinks, the filesystem must call fscrypt_encrypt_symlink() to create the
184 * on-disk target later. (The reason for the two-step process is that some
185 * filesystems need to know the size of the symlink target before creating the
186 * inode, e.g. to determine whether it will be a "fast" or "slow" symlink.)
188 * Return: 0 on success, -ENAMETOOLONG if the symlink target is too long,
189 * -ENOKEY if the encryption key is missing, or another -errno code if a problem
190 * occurred while setting up the encryption key.
192 int fscrypt_prepare_symlink(struct inode
*dir
, const char *target
,
193 unsigned int len
, unsigned int max_len
,
194 struct fscrypt_str
*disk_link
)
196 const union fscrypt_policy
*policy
;
199 * To calculate the size of the encrypted symlink target we need to know
200 * the amount of NUL padding, which is determined by the flags set in
201 * the encryption policy which will be inherited from the directory.
203 policy
= fscrypt_policy_to_inherit(dir
);
204 if (policy
== NULL
) {
206 disk_link
->name
= (unsigned char *)target
;
207 disk_link
->len
= len
+ 1;
208 if (disk_link
->len
> max_len
)
209 return -ENAMETOOLONG
;
213 return PTR_ERR(policy
);
216 * Calculate the size of the encrypted symlink and verify it won't
217 * exceed max_len. Note that for historical reasons, encrypted symlink
218 * targets are prefixed with the ciphertext length, despite this
219 * actually being redundant with i_size. This decreases by 2 bytes the
220 * longest symlink target we can accept.
222 * We could recover 1 byte by not counting a null terminator, but
223 * counting it (even though it is meaningless for ciphertext) is simpler
224 * for now since filesystems will assume it is there and subtract it.
226 if (!fscrypt_fname_encrypted_size(policy
, len
,
227 max_len
- sizeof(struct fscrypt_symlink_data
),
229 return -ENAMETOOLONG
;
230 disk_link
->len
+= sizeof(struct fscrypt_symlink_data
);
232 disk_link
->name
= NULL
;
235 EXPORT_SYMBOL_GPL(fscrypt_prepare_symlink
);
237 int __fscrypt_encrypt_symlink(struct inode
*inode
, const char *target
,
238 unsigned int len
, struct fscrypt_str
*disk_link
)
241 struct qstr iname
= QSTR_INIT(target
, len
);
242 struct fscrypt_symlink_data
*sd
;
243 unsigned int ciphertext_len
;
246 * fscrypt_prepare_new_inode() should have already set up the new
247 * symlink inode's encryption key. We don't wait until now to do it,
248 * since we may be in a filesystem transaction now.
250 if (WARN_ON_ONCE(!fscrypt_has_encryption_key(inode
)))
253 if (disk_link
->name
) {
254 /* filesystem-provided buffer */
255 sd
= (struct fscrypt_symlink_data
*)disk_link
->name
;
257 sd
= kmalloc(disk_link
->len
, GFP_NOFS
);
261 ciphertext_len
= disk_link
->len
- sizeof(*sd
);
262 sd
->len
= cpu_to_le16(ciphertext_len
);
264 err
= fscrypt_fname_encrypt(inode
, &iname
, sd
->encrypted_path
,
270 * Null-terminating the ciphertext doesn't make sense, but we still
271 * count the null terminator in the length, so we might as well
272 * initialize it just in case the filesystem writes it out.
274 sd
->encrypted_path
[ciphertext_len
] = '\0';
276 /* Cache the plaintext symlink target for later use by get_link() */
278 inode
->i_link
= kmemdup(target
, len
+ 1, GFP_NOFS
);
282 if (!disk_link
->name
)
283 disk_link
->name
= (unsigned char *)sd
;
287 if (!disk_link
->name
)
291 EXPORT_SYMBOL_GPL(__fscrypt_encrypt_symlink
);
294 * fscrypt_get_symlink() - get the target of an encrypted symlink
295 * @inode: the symlink inode
296 * @caddr: the on-disk contents of the symlink
297 * @max_size: size of @caddr buffer
298 * @done: if successful, will be set up to free the returned target if needed
300 * If the symlink's encryption key is available, we decrypt its target.
301 * Otherwise, we encode its target for presentation.
303 * This may sleep, so the filesystem must have dropped out of RCU mode already.
305 * Return: the presentable symlink target or an ERR_PTR()
307 const char *fscrypt_get_symlink(struct inode
*inode
, const void *caddr
,
308 unsigned int max_size
,
309 struct delayed_call
*done
)
311 const struct fscrypt_symlink_data
*sd
;
312 struct fscrypt_str cstr
, pstr
;
316 /* This is for encrypted symlinks only */
317 if (WARN_ON(!IS_ENCRYPTED(inode
)))
318 return ERR_PTR(-EINVAL
);
320 /* If the decrypted target is already cached, just return it. */
321 pstr
.name
= READ_ONCE(inode
->i_link
);
326 * Try to set up the symlink's encryption key, but we can continue
327 * regardless of whether the key is available or not.
329 err
= fscrypt_get_encryption_info(inode
);
332 has_key
= fscrypt_has_encryption_key(inode
);
335 * For historical reasons, encrypted symlink targets are prefixed with
336 * the ciphertext length, even though this is redundant with i_size.
339 if (max_size
< sizeof(*sd
))
340 return ERR_PTR(-EUCLEAN
);
342 cstr
.name
= (unsigned char *)sd
->encrypted_path
;
343 cstr
.len
= le16_to_cpu(sd
->len
);
346 return ERR_PTR(-EUCLEAN
);
348 if (cstr
.len
+ sizeof(*sd
) - 1 > max_size
)
349 return ERR_PTR(-EUCLEAN
);
351 err
= fscrypt_fname_alloc_buffer(cstr
.len
, &pstr
);
355 err
= fscrypt_fname_disk_to_usr(inode
, 0, 0, &cstr
, &pstr
);
360 if (pstr
.name
[0] == '\0')
363 pstr
.name
[pstr
.len
] = '\0';
366 * Cache decrypted symlink targets in i_link for later use. Don't cache
367 * symlink targets encoded without the key, since those become outdated
368 * once the key is added. This pairs with the READ_ONCE() above and in
369 * the VFS path lookup code.
372 cmpxchg_release(&inode
->i_link
, NULL
, pstr
.name
) != NULL
)
373 set_delayed_call(done
, kfree_link
, pstr
.name
);
381 EXPORT_SYMBOL_GPL(fscrypt_get_symlink
);