Merge tag 'pinctrl-v6.1-1' of git://git.kernel.org/pub/scm/linux/kernel/git/linusw...
[platform/kernel/linux-starfive.git] / fs / crypto / hooks.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * fs/crypto/hooks.c
4  *
5  * Encryption hooks for higher-level filesystem operations.
6  */
7
8 #include "fscrypt_private.h"
9
10 /**
11  * fscrypt_file_open() - prepare to open a possibly-encrypted regular file
12  * @inode: the inode being opened
13  * @filp: the struct file being set up
14  *
15  * Currently, an encrypted regular file can only be opened if its encryption key
16  * is available; access to the raw encrypted contents is not supported.
17  * Therefore, we first set up the inode's encryption key (if not already done)
18  * and return an error if it's unavailable.
19  *
20  * We also verify that if the parent directory (from the path via which the file
21  * is being opened) is encrypted, then the inode being opened uses the same
22  * encryption policy.  This is needed as part of the enforcement that all files
23  * in an encrypted directory tree use the same encryption policy, as a
24  * protection against certain types of offline attacks.  Note that this check is
25  * needed even when opening an *unencrypted* file, since it's forbidden to have
26  * an unencrypted file in an encrypted directory.
27  *
28  * Return: 0 on success, -ENOKEY if the key is missing, or another -errno code
29  */
30 int fscrypt_file_open(struct inode *inode, struct file *filp)
31 {
32         int err;
33         struct dentry *dir;
34
35         err = fscrypt_require_key(inode);
36         if (err)
37                 return err;
38
39         dir = dget_parent(file_dentry(filp));
40         if (IS_ENCRYPTED(d_inode(dir)) &&
41             !fscrypt_has_permitted_context(d_inode(dir), inode)) {
42                 fscrypt_warn(inode,
43                              "Inconsistent encryption context (parent directory: %lu)",
44                              d_inode(dir)->i_ino);
45                 err = -EPERM;
46         }
47         dput(dir);
48         return err;
49 }
50 EXPORT_SYMBOL_GPL(fscrypt_file_open);
51
52 int __fscrypt_prepare_link(struct inode *inode, struct inode *dir,
53                            struct dentry *dentry)
54 {
55         if (fscrypt_is_nokey_name(dentry))
56                 return -ENOKEY;
57         /*
58          * We don't need to separately check that the directory inode's key is
59          * available, as it's implied by the dentry not being a no-key name.
60          */
61
62         if (!fscrypt_has_permitted_context(dir, inode))
63                 return -EXDEV;
64
65         return 0;
66 }
67 EXPORT_SYMBOL_GPL(__fscrypt_prepare_link);
68
69 int __fscrypt_prepare_rename(struct inode *old_dir, struct dentry *old_dentry,
70                              struct inode *new_dir, struct dentry *new_dentry,
71                              unsigned int flags)
72 {
73         if (fscrypt_is_nokey_name(old_dentry) ||
74             fscrypt_is_nokey_name(new_dentry))
75                 return -ENOKEY;
76         /*
77          * We don't need to separately check that the directory inodes' keys are
78          * available, as it's implied by the dentries not being no-key names.
79          */
80
81         if (old_dir != new_dir) {
82                 if (IS_ENCRYPTED(new_dir) &&
83                     !fscrypt_has_permitted_context(new_dir,
84                                                    d_inode(old_dentry)))
85                         return -EXDEV;
86
87                 if ((flags & RENAME_EXCHANGE) &&
88                     IS_ENCRYPTED(old_dir) &&
89                     !fscrypt_has_permitted_context(old_dir,
90                                                    d_inode(new_dentry)))
91                         return -EXDEV;
92         }
93         return 0;
94 }
95 EXPORT_SYMBOL_GPL(__fscrypt_prepare_rename);
96
97 int __fscrypt_prepare_lookup(struct inode *dir, struct dentry *dentry,
98                              struct fscrypt_name *fname)
99 {
100         int err = fscrypt_setup_filename(dir, &dentry->d_name, 1, fname);
101
102         if (err && err != -ENOENT)
103                 return err;
104
105         if (fname->is_nokey_name) {
106                 spin_lock(&dentry->d_lock);
107                 dentry->d_flags |= DCACHE_NOKEY_NAME;
108                 spin_unlock(&dentry->d_lock);
109         }
110         return err;
111 }
112 EXPORT_SYMBOL_GPL(__fscrypt_prepare_lookup);
113
114 int __fscrypt_prepare_readdir(struct inode *dir)
115 {
116         return fscrypt_get_encryption_info(dir, true);
117 }
118 EXPORT_SYMBOL_GPL(__fscrypt_prepare_readdir);
119
120 int __fscrypt_prepare_setattr(struct dentry *dentry, struct iattr *attr)
121 {
122         if (attr->ia_valid & ATTR_SIZE)
123                 return fscrypt_require_key(d_inode(dentry));
124         return 0;
125 }
126 EXPORT_SYMBOL_GPL(__fscrypt_prepare_setattr);
127
128 /**
129  * fscrypt_prepare_setflags() - prepare to change flags with FS_IOC_SETFLAGS
130  * @inode: the inode on which flags are being changed
131  * @oldflags: the old flags
132  * @flags: the new flags
133  *
134  * The caller should be holding i_rwsem for write.
135  *
136  * Return: 0 on success; -errno if the flags change isn't allowed or if
137  *         another error occurs.
138  */
139 int fscrypt_prepare_setflags(struct inode *inode,
140                              unsigned int oldflags, unsigned int flags)
141 {
142         struct fscrypt_info *ci;
143         struct fscrypt_master_key *mk;
144         int err;
145
146         /*
147          * When the CASEFOLD flag is set on an encrypted directory, we must
148          * derive the secret key needed for the dirhash.  This is only possible
149          * if the directory uses a v2 encryption policy.
150          */
151         if (IS_ENCRYPTED(inode) && (flags & ~oldflags & FS_CASEFOLD_FL)) {
152                 err = fscrypt_require_key(inode);
153                 if (err)
154                         return err;
155                 ci = inode->i_crypt_info;
156                 if (ci->ci_policy.version != FSCRYPT_POLICY_V2)
157                         return -EINVAL;
158                 mk = ci->ci_master_key;
159                 down_read(&mk->mk_sem);
160                 if (is_master_key_secret_present(&mk->mk_secret))
161                         err = fscrypt_derive_dirhash_key(ci, mk);
162                 else
163                         err = -ENOKEY;
164                 up_read(&mk->mk_sem);
165                 return err;
166         }
167         return 0;
168 }
169
170 /**
171  * fscrypt_prepare_symlink() - prepare to create a possibly-encrypted symlink
172  * @dir: directory in which the symlink is being created
173  * @target: plaintext symlink target
174  * @len: length of @target excluding null terminator
175  * @max_len: space the filesystem has available to store the symlink target
176  * @disk_link: (out) the on-disk symlink target being prepared
177  *
178  * This function computes the size the symlink target will require on-disk,
179  * stores it in @disk_link->len, and validates it against @max_len.  An
180  * encrypted symlink may be longer than the original.
181  *
182  * Additionally, @disk_link->name is set to @target if the symlink will be
183  * unencrypted, but left NULL if the symlink will be encrypted.  For encrypted
184  * symlinks, the filesystem must call fscrypt_encrypt_symlink() to create the
185  * on-disk target later.  (The reason for the two-step process is that some
186  * filesystems need to know the size of the symlink target before creating the
187  * inode, e.g. to determine whether it will be a "fast" or "slow" symlink.)
188  *
189  * Return: 0 on success, -ENAMETOOLONG if the symlink target is too long,
190  * -ENOKEY if the encryption key is missing, or another -errno code if a problem
191  * occurred while setting up the encryption key.
192  */
193 int fscrypt_prepare_symlink(struct inode *dir, const char *target,
194                             unsigned int len, unsigned int max_len,
195                             struct fscrypt_str *disk_link)
196 {
197         const union fscrypt_policy *policy;
198
199         /*
200          * To calculate the size of the encrypted symlink target we need to know
201          * the amount of NUL padding, which is determined by the flags set in
202          * the encryption policy which will be inherited from the directory.
203          */
204         policy = fscrypt_policy_to_inherit(dir);
205         if (policy == NULL) {
206                 /* Not encrypted */
207                 disk_link->name = (unsigned char *)target;
208                 disk_link->len = len + 1;
209                 if (disk_link->len > max_len)
210                         return -ENAMETOOLONG;
211                 return 0;
212         }
213         if (IS_ERR(policy))
214                 return PTR_ERR(policy);
215
216         /*
217          * Calculate the size of the encrypted symlink and verify it won't
218          * exceed max_len.  Note that for historical reasons, encrypted symlink
219          * targets are prefixed with the ciphertext length, despite this
220          * actually being redundant with i_size.  This decreases by 2 bytes the
221          * longest symlink target we can accept.
222          *
223          * We could recover 1 byte by not counting a null terminator, but
224          * counting it (even though it is meaningless for ciphertext) is simpler
225          * for now since filesystems will assume it is there and subtract it.
226          */
227         if (!__fscrypt_fname_encrypted_size(policy, len,
228                                             max_len - sizeof(struct fscrypt_symlink_data),
229                                             &disk_link->len))
230                 return -ENAMETOOLONG;
231         disk_link->len += sizeof(struct fscrypt_symlink_data);
232
233         disk_link->name = NULL;
234         return 0;
235 }
236 EXPORT_SYMBOL_GPL(fscrypt_prepare_symlink);
237
238 int __fscrypt_encrypt_symlink(struct inode *inode, const char *target,
239                               unsigned int len, struct fscrypt_str *disk_link)
240 {
241         int err;
242         struct qstr iname = QSTR_INIT(target, len);
243         struct fscrypt_symlink_data *sd;
244         unsigned int ciphertext_len;
245
246         /*
247          * fscrypt_prepare_new_inode() should have already set up the new
248          * symlink inode's encryption key.  We don't wait until now to do it,
249          * since we may be in a filesystem transaction now.
250          */
251         if (WARN_ON_ONCE(!fscrypt_has_encryption_key(inode)))
252                 return -ENOKEY;
253
254         if (disk_link->name) {
255                 /* filesystem-provided buffer */
256                 sd = (struct fscrypt_symlink_data *)disk_link->name;
257         } else {
258                 sd = kmalloc(disk_link->len, GFP_NOFS);
259                 if (!sd)
260                         return -ENOMEM;
261         }
262         ciphertext_len = disk_link->len - sizeof(*sd);
263         sd->len = cpu_to_le16(ciphertext_len);
264
265         err = fscrypt_fname_encrypt(inode, &iname, sd->encrypted_path,
266                                     ciphertext_len);
267         if (err)
268                 goto err_free_sd;
269
270         /*
271          * Null-terminating the ciphertext doesn't make sense, but we still
272          * count the null terminator in the length, so we might as well
273          * initialize it just in case the filesystem writes it out.
274          */
275         sd->encrypted_path[ciphertext_len] = '\0';
276
277         /* Cache the plaintext symlink target for later use by get_link() */
278         err = -ENOMEM;
279         inode->i_link = kmemdup(target, len + 1, GFP_NOFS);
280         if (!inode->i_link)
281                 goto err_free_sd;
282
283         if (!disk_link->name)
284                 disk_link->name = (unsigned char *)sd;
285         return 0;
286
287 err_free_sd:
288         if (!disk_link->name)
289                 kfree(sd);
290         return err;
291 }
292 EXPORT_SYMBOL_GPL(__fscrypt_encrypt_symlink);
293
294 /**
295  * fscrypt_get_symlink() - get the target of an encrypted symlink
296  * @inode: the symlink inode
297  * @caddr: the on-disk contents of the symlink
298  * @max_size: size of @caddr buffer
299  * @done: if successful, will be set up to free the returned target if needed
300  *
301  * If the symlink's encryption key is available, we decrypt its target.
302  * Otherwise, we encode its target for presentation.
303  *
304  * This may sleep, so the filesystem must have dropped out of RCU mode already.
305  *
306  * Return: the presentable symlink target or an ERR_PTR()
307  */
308 const char *fscrypt_get_symlink(struct inode *inode, const void *caddr,
309                                 unsigned int max_size,
310                                 struct delayed_call *done)
311 {
312         const struct fscrypt_symlink_data *sd;
313         struct fscrypt_str cstr, pstr;
314         bool has_key;
315         int err;
316
317         /* This is for encrypted symlinks only */
318         if (WARN_ON(!IS_ENCRYPTED(inode)))
319                 return ERR_PTR(-EINVAL);
320
321         /* If the decrypted target is already cached, just return it. */
322         pstr.name = READ_ONCE(inode->i_link);
323         if (pstr.name)
324                 return pstr.name;
325
326         /*
327          * Try to set up the symlink's encryption key, but we can continue
328          * regardless of whether the key is available or not.
329          */
330         err = fscrypt_get_encryption_info(inode, false);
331         if (err)
332                 return ERR_PTR(err);
333         has_key = fscrypt_has_encryption_key(inode);
334
335         /*
336          * For historical reasons, encrypted symlink targets are prefixed with
337          * the ciphertext length, even though this is redundant with i_size.
338          */
339
340         if (max_size < sizeof(*sd))
341                 return ERR_PTR(-EUCLEAN);
342         sd = caddr;
343         cstr.name = (unsigned char *)sd->encrypted_path;
344         cstr.len = le16_to_cpu(sd->len);
345
346         if (cstr.len == 0)
347                 return ERR_PTR(-EUCLEAN);
348
349         if (cstr.len + sizeof(*sd) - 1 > max_size)
350                 return ERR_PTR(-EUCLEAN);
351
352         err = fscrypt_fname_alloc_buffer(cstr.len, &pstr);
353         if (err)
354                 return ERR_PTR(err);
355
356         err = fscrypt_fname_disk_to_usr(inode, 0, 0, &cstr, &pstr);
357         if (err)
358                 goto err_kfree;
359
360         err = -EUCLEAN;
361         if (pstr.name[0] == '\0')
362                 goto err_kfree;
363
364         pstr.name[pstr.len] = '\0';
365
366         /*
367          * Cache decrypted symlink targets in i_link for later use.  Don't cache
368          * symlink targets encoded without the key, since those become outdated
369          * once the key is added.  This pairs with the READ_ONCE() above and in
370          * the VFS path lookup code.
371          */
372         if (!has_key ||
373             cmpxchg_release(&inode->i_link, NULL, pstr.name) != NULL)
374                 set_delayed_call(done, kfree_link, pstr.name);
375
376         return pstr.name;
377
378 err_kfree:
379         kfree(pstr.name);
380         return ERR_PTR(err);
381 }
382 EXPORT_SYMBOL_GPL(fscrypt_get_symlink);
383
384 /**
385  * fscrypt_symlink_getattr() - set the correct st_size for encrypted symlinks
386  * @path: the path for the encrypted symlink being queried
387  * @stat: the struct being filled with the symlink's attributes
388  *
389  * Override st_size of encrypted symlinks to be the length of the decrypted
390  * symlink target (or the no-key encoded symlink target, if the key is
391  * unavailable) rather than the length of the encrypted symlink target.  This is
392  * necessary for st_size to match the symlink target that userspace actually
393  * sees.  POSIX requires this, and some userspace programs depend on it.
394  *
395  * This requires reading the symlink target from disk if needed, setting up the
396  * inode's encryption key if possible, and then decrypting or encoding the
397  * symlink target.  This makes lstat() more heavyweight than is normally the
398  * case.  However, decrypted symlink targets will be cached in ->i_link, so
399  * usually the symlink won't have to be read and decrypted again later if/when
400  * it is actually followed, readlink() is called, or lstat() is called again.
401  *
402  * Return: 0 on success, -errno on failure
403  */
404 int fscrypt_symlink_getattr(const struct path *path, struct kstat *stat)
405 {
406         struct dentry *dentry = path->dentry;
407         struct inode *inode = d_inode(dentry);
408         const char *link;
409         DEFINE_DELAYED_CALL(done);
410
411         /*
412          * To get the symlink target that userspace will see (whether it's the
413          * decrypted target or the no-key encoded target), we can just get it in
414          * the same way the VFS does during path resolution and readlink().
415          */
416         link = READ_ONCE(inode->i_link);
417         if (!link) {
418                 link = inode->i_op->get_link(dentry, inode, &done);
419                 if (IS_ERR(link))
420                         return PTR_ERR(link);
421         }
422         stat->size = strlen(link);
423         do_delayed_call(&done);
424         return 0;
425 }
426 EXPORT_SYMBOL_GPL(fscrypt_symlink_getattr);