GNU Linux-libre 4.19.211-gnu1
[releases.git] / fs / crypto / hooks.c
1 /*
2  * fs/crypto/hooks.c
3  *
4  * Encryption hooks for higher-level filesystem operations.
5  */
6
7 #include <linux/ratelimit.h>
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->i_sb,
43                              "inconsistent encryption contexts: %lu/%lu",
44                              d_inode(dir)->i_ino, inode->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         int err;
56
57         err = fscrypt_require_key(dir);
58         if (err)
59                 return err;
60
61         /* ... in case we looked up no-key name before key was added */
62         if (fscrypt_is_nokey_name(dentry))
63                 return -ENOKEY;
64
65         if (!fscrypt_has_permitted_context(dir, inode))
66                 return -EXDEV;
67
68         return 0;
69 }
70 EXPORT_SYMBOL_GPL(__fscrypt_prepare_link);
71
72 int __fscrypt_prepare_rename(struct inode *old_dir, struct dentry *old_dentry,
73                              struct inode *new_dir, struct dentry *new_dentry,
74                              unsigned int flags)
75 {
76         int err;
77
78         err = fscrypt_require_key(old_dir);
79         if (err)
80                 return err;
81
82         err = fscrypt_require_key(new_dir);
83         if (err)
84                 return err;
85
86         /* ... in case we looked up no-key name(s) before key was added */
87         if (fscrypt_is_nokey_name(old_dentry) ||
88             fscrypt_is_nokey_name(new_dentry))
89                 return -ENOKEY;
90
91         if (old_dir != new_dir) {
92                 if (IS_ENCRYPTED(new_dir) &&
93                     !fscrypt_has_permitted_context(new_dir,
94                                                    d_inode(old_dentry)))
95                         return -EXDEV;
96
97                 if ((flags & RENAME_EXCHANGE) &&
98                     IS_ENCRYPTED(old_dir) &&
99                     !fscrypt_has_permitted_context(old_dir,
100                                                    d_inode(new_dentry)))
101                         return -EXDEV;
102         }
103         return 0;
104 }
105 EXPORT_SYMBOL_GPL(__fscrypt_prepare_rename);
106
107 int __fscrypt_prepare_lookup(struct inode *dir, struct dentry *dentry,
108                              struct fscrypt_name *fname)
109 {
110         int err = fscrypt_setup_filename(dir, &dentry->d_name, 1, fname);
111
112         if (err && err != -ENOENT)
113                 return err;
114
115         if (fname->is_ciphertext_name) {
116                 spin_lock(&dentry->d_lock);
117                 dentry->d_flags |= DCACHE_ENCRYPTED_NAME;
118                 spin_unlock(&dentry->d_lock);
119                 d_set_d_op(dentry, &fscrypt_d_ops);
120         }
121         return err;
122 }
123 EXPORT_SYMBOL_GPL(__fscrypt_prepare_lookup);
124
125 int __fscrypt_prepare_symlink(struct inode *dir, unsigned int len,
126                               unsigned int max_len,
127                               struct fscrypt_str *disk_link)
128 {
129         int err;
130
131         /*
132          * To calculate the size of the encrypted symlink target we need to know
133          * the amount of NUL padding, which is determined by the flags set in
134          * the encryption policy which will be inherited from the directory.
135          * The easiest way to get access to this is to just load the directory's
136          * fscrypt_info, since we'll need it to create the dir_entry anyway.
137          *
138          * Note: in test_dummy_encryption mode, @dir may be unencrypted.
139          */
140         err = fscrypt_get_encryption_info(dir);
141         if (err)
142                 return err;
143         if (!fscrypt_has_encryption_key(dir))
144                 return -ENOKEY;
145
146         /*
147          * Calculate the size of the encrypted symlink and verify it won't
148          * exceed max_len.  Note that for historical reasons, encrypted symlink
149          * targets are prefixed with the ciphertext length, despite this
150          * actually being redundant with i_size.  This decreases by 2 bytes the
151          * longest symlink target we can accept.
152          *
153          * We could recover 1 byte by not counting a null terminator, but
154          * counting it (even though it is meaningless for ciphertext) is simpler
155          * for now since filesystems will assume it is there and subtract it.
156          */
157         if (!fscrypt_fname_encrypted_size(dir, len,
158                                           max_len - sizeof(struct fscrypt_symlink_data),
159                                           &disk_link->len))
160                 return -ENAMETOOLONG;
161         disk_link->len += sizeof(struct fscrypt_symlink_data);
162
163         disk_link->name = NULL;
164         return 0;
165 }
166 EXPORT_SYMBOL_GPL(__fscrypt_prepare_symlink);
167
168 int __fscrypt_encrypt_symlink(struct inode *inode, const char *target,
169                               unsigned int len, struct fscrypt_str *disk_link)
170 {
171         int err;
172         struct qstr iname = QSTR_INIT(target, len);
173         struct fscrypt_symlink_data *sd;
174         unsigned int ciphertext_len;
175
176         err = fscrypt_require_key(inode);
177         if (err)
178                 return err;
179
180         if (disk_link->name) {
181                 /* filesystem-provided buffer */
182                 sd = (struct fscrypt_symlink_data *)disk_link->name;
183         } else {
184                 sd = kmalloc(disk_link->len, GFP_NOFS);
185                 if (!sd)
186                         return -ENOMEM;
187         }
188         ciphertext_len = disk_link->len - sizeof(*sd);
189         sd->len = cpu_to_le16(ciphertext_len);
190
191         err = fname_encrypt(inode, &iname, sd->encrypted_path, ciphertext_len);
192         if (err) {
193                 if (!disk_link->name)
194                         kfree(sd);
195                 return err;
196         }
197         /*
198          * Null-terminating the ciphertext doesn't make sense, but we still
199          * count the null terminator in the length, so we might as well
200          * initialize it just in case the filesystem writes it out.
201          */
202         sd->encrypted_path[ciphertext_len] = '\0';
203
204         if (!disk_link->name)
205                 disk_link->name = (unsigned char *)sd;
206         return 0;
207 }
208 EXPORT_SYMBOL_GPL(__fscrypt_encrypt_symlink);
209
210 /**
211  * fscrypt_get_symlink - get the target of an encrypted symlink
212  * @inode: the symlink inode
213  * @caddr: the on-disk contents of the symlink
214  * @max_size: size of @caddr buffer
215  * @done: if successful, will be set up to free the returned target
216  *
217  * If the symlink's encryption key is available, we decrypt its target.
218  * Otherwise, we encode its target for presentation.
219  *
220  * This may sleep, so the filesystem must have dropped out of RCU mode already.
221  *
222  * Return: the presentable symlink target or an ERR_PTR()
223  */
224 const char *fscrypt_get_symlink(struct inode *inode, const void *caddr,
225                                 unsigned int max_size,
226                                 struct delayed_call *done)
227 {
228         const struct fscrypt_symlink_data *sd;
229         struct fscrypt_str cstr, pstr;
230         int err;
231
232         /* This is for encrypted symlinks only */
233         if (WARN_ON(!IS_ENCRYPTED(inode)))
234                 return ERR_PTR(-EINVAL);
235
236         /*
237          * Try to set up the symlink's encryption key, but we can continue
238          * regardless of whether the key is available or not.
239          */
240         err = fscrypt_get_encryption_info(inode);
241         if (err)
242                 return ERR_PTR(err);
243
244         /*
245          * For historical reasons, encrypted symlink targets are prefixed with
246          * the ciphertext length, even though this is redundant with i_size.
247          */
248
249         if (max_size < sizeof(*sd))
250                 return ERR_PTR(-EUCLEAN);
251         sd = caddr;
252         cstr.name = (unsigned char *)sd->encrypted_path;
253         cstr.len = le16_to_cpu(sd->len);
254
255         if (cstr.len == 0)
256                 return ERR_PTR(-EUCLEAN);
257
258         if (cstr.len + sizeof(*sd) - 1 > max_size)
259                 return ERR_PTR(-EUCLEAN);
260
261         err = fscrypt_fname_alloc_buffer(inode, cstr.len, &pstr);
262         if (err)
263                 return ERR_PTR(err);
264
265         err = fscrypt_fname_disk_to_usr(inode, 0, 0, &cstr, &pstr);
266         if (err)
267                 goto err_kfree;
268
269         err = -EUCLEAN;
270         if (pstr.name[0] == '\0')
271                 goto err_kfree;
272
273         pstr.name[pstr.len] = '\0';
274         set_delayed_call(done, kfree_link, pstr.name);
275         return pstr.name;
276
277 err_kfree:
278         kfree(pstr.name);
279         return ERR_PTR(err);
280 }
281 EXPORT_SYMBOL_GPL(fscrypt_get_symlink);
282
283 /**
284  * fscrypt_symlink_getattr() - set the correct st_size for encrypted symlinks
285  * @path: the path for the encrypted symlink being queried
286  * @stat: the struct being filled with the symlink's attributes
287  *
288  * Override st_size of encrypted symlinks to be the length of the decrypted
289  * symlink target (or the no-key encoded symlink target, if the key is
290  * unavailable) rather than the length of the encrypted symlink target.  This is
291  * necessary for st_size to match the symlink target that userspace actually
292  * sees.  POSIX requires this, and some userspace programs depend on it.
293  *
294  * This requires reading the symlink target from disk if needed, setting up the
295  * inode's encryption key if possible, and then decrypting or encoding the
296  * symlink target.  This makes lstat() more heavyweight than is normally the
297  * case.  However, decrypted symlink targets will be cached in ->i_link, so
298  * usually the symlink won't have to be read and decrypted again later if/when
299  * it is actually followed, readlink() is called, or lstat() is called again.
300  *
301  * Return: 0 on success, -errno on failure
302  */
303 int fscrypt_symlink_getattr(const struct path *path, struct kstat *stat)
304 {
305         struct dentry *dentry = path->dentry;
306         struct inode *inode = d_inode(dentry);
307         const char *link;
308         DEFINE_DELAYED_CALL(done);
309
310         /*
311          * To get the symlink target that userspace will see (whether it's the
312          * decrypted target or the no-key encoded target), we can just get it in
313          * the same way the VFS does during path resolution and readlink().
314          */
315         link = READ_ONCE(inode->i_link);
316         if (!link) {
317                 link = inode->i_op->get_link(dentry, inode, &done);
318                 if (IS_ERR(link))
319                         return PTR_ERR(link);
320         }
321         stat->size = strlen(link);
322         do_delayed_call(&done);
323         return 0;
324 }
325 EXPORT_SYMBOL_GPL(fscrypt_symlink_getattr);