1 // SPDX-License-Identifier: GPL-2.0
3 * The base64 encode/decode code was copied from fscrypt:
4 * Copyright (C) 2015, Google, Inc.
5 * Copyright (C) 2015, Motorola Mobility
6 * Written by Uday Savagaonkar, 2014.
7 * Modified by Jaegeuk Kim, 2015.
9 #include <linux/ceph/ceph_debug.h>
10 #include <linux/xattr.h>
11 #include <linux/fscrypt.h>
12 #include <linux/ceph/striper.h>
15 #include "mds_client.h"
19 * The base64url encoding used by fscrypt includes the '_' character, which may
20 * cause problems in snapshot names (which can not start with '_'). Thus, we
21 * used the base64 encoding defined for IMAP mailbox names (RFC 3501) instead,
22 * which replaces '-' and '_' by '+' and ','.
24 static const char base64_table[65] =
25 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+,";
27 int ceph_base64_encode(const u8 *src, int srclen, char *dst)
34 for (i = 0; i < srclen; i++) {
35 ac = (ac << 8) | src[i];
39 *cp++ = base64_table[(ac >> bits) & 0x3f];
43 *cp++ = base64_table[(ac << (6 - bits)) & 0x3f];
47 int ceph_base64_decode(const char *src, int srclen, u8 *dst)
54 for (i = 0; i < srclen; i++) {
55 const char *p = strchr(base64_table, src[i]);
57 if (p == NULL || src[i] == 0)
59 ac = (ac << 6) | (p - base64_table);
63 *bp++ = (u8)(ac >> bits);
66 if (ac & ((1 << bits) - 1))
71 static int ceph_crypt_get_context(struct inode *inode, void *ctx, size_t len)
73 struct ceph_inode_info *ci = ceph_inode(inode);
74 struct ceph_fscrypt_auth *cfa = (struct ceph_fscrypt_auth *)ci->fscrypt_auth;
77 /* Non existent or too short? */
78 if (!cfa || (ci->fscrypt_auth_len < (offsetof(struct ceph_fscrypt_auth, cfa_blob) + 1)))
81 /* Some format we don't recognize? */
82 if (le32_to_cpu(cfa->cfa_version) != CEPH_FSCRYPT_AUTH_VERSION)
85 ctxlen = le32_to_cpu(cfa->cfa_blob_len);
89 memcpy(ctx, cfa->cfa_blob, ctxlen);
93 static int ceph_crypt_set_context(struct inode *inode, const void *ctx,
94 size_t len, void *fs_data)
97 struct iattr attr = { };
98 struct ceph_iattr cia = { };
99 struct ceph_fscrypt_auth *cfa;
101 WARN_ON_ONCE(fs_data);
103 if (len > FSCRYPT_SET_CONTEXT_MAX_SIZE)
106 cfa = kzalloc(sizeof(*cfa), GFP_KERNEL);
110 cfa->cfa_version = cpu_to_le32(CEPH_FSCRYPT_AUTH_VERSION);
111 cfa->cfa_blob_len = cpu_to_le32(len);
112 memcpy(cfa->cfa_blob, ctx, len);
114 cia.fscrypt_auth = cfa;
116 ret = __ceph_setattr(inode, &attr, &cia);
118 inode_set_flags(inode, S_ENCRYPTED, S_ENCRYPTED);
119 kfree(cia.fscrypt_auth);
123 static bool ceph_crypt_empty_dir(struct inode *inode)
125 struct ceph_inode_info *ci = ceph_inode(inode);
127 return ci->i_rsubdirs + ci->i_rfiles == 1;
130 static const union fscrypt_policy *ceph_get_dummy_policy(struct super_block *sb)
132 return ceph_sb_to_client(sb)->fsc_dummy_enc_policy.policy;
135 static struct fscrypt_operations ceph_fscrypt_ops = {
136 .needs_bounce_pages = 1,
137 .get_context = ceph_crypt_get_context,
138 .set_context = ceph_crypt_set_context,
139 .get_dummy_policy = ceph_get_dummy_policy,
140 .empty_dir = ceph_crypt_empty_dir,
143 void ceph_fscrypt_set_ops(struct super_block *sb)
145 fscrypt_set_ops(sb, &ceph_fscrypt_ops);
148 void ceph_fscrypt_free_dummy_policy(struct ceph_fs_client *fsc)
150 fscrypt_free_dummy_policy(&fsc->fsc_dummy_enc_policy);
153 int ceph_fscrypt_prepare_context(struct inode *dir, struct inode *inode,
154 struct ceph_acl_sec_ctx *as)
157 bool encrypted = false;
158 struct ceph_inode_info *ci = ceph_inode(inode);
160 ret = fscrypt_prepare_new_inode(dir, inode, &encrypted);
166 as->fscrypt_auth = kzalloc(sizeof(*as->fscrypt_auth), GFP_KERNEL);
167 if (!as->fscrypt_auth)
170 ctxsize = fscrypt_context_for_new_inode(as->fscrypt_auth->cfa_blob,
175 as->fscrypt_auth->cfa_version = cpu_to_le32(CEPH_FSCRYPT_AUTH_VERSION);
176 as->fscrypt_auth->cfa_blob_len = cpu_to_le32(ctxsize);
178 WARN_ON_ONCE(ci->fscrypt_auth);
179 kfree(ci->fscrypt_auth);
180 ci->fscrypt_auth_len = ceph_fscrypt_auth_len(as->fscrypt_auth);
181 ci->fscrypt_auth = kmemdup(as->fscrypt_auth, ci->fscrypt_auth_len,
183 if (!ci->fscrypt_auth)
186 inode->i_flags |= S_ENCRYPTED;
191 void ceph_fscrypt_as_ctx_to_req(struct ceph_mds_request *req,
192 struct ceph_acl_sec_ctx *as)
194 swap(req->r_fscrypt_auth, as->fscrypt_auth);
198 * User-created snapshots can't start with '_'. Snapshots that start with this
199 * character are special (hint: there aren't real snapshots) and use the
202 * _<SNAPSHOT-NAME>_<INODE-NUMBER>
205 * - <SNAPSHOT-NAME> - the real snapshot name that may need to be decrypted,
206 * - <INODE-NUMBER> - the inode number (in decimal) for the actual snapshot
208 * This function parses these snapshot names and returns the inode
209 * <INODE-NUMBER>. 'name_len' will also bet set with the <SNAPSHOT-NAME>
212 static struct inode *parse_longname(const struct inode *parent,
213 const char *name, int *name_len)
215 struct inode *dir = NULL;
216 struct ceph_vino vino = { .snap = CEPH_NOSNAP };
219 int orig_len = *name_len;
222 /* Skip initial '_' */
224 name_end = strrchr(name, '_');
226 dout("Failed to parse long snapshot name: %s\n", name);
227 return ERR_PTR(-EIO);
229 *name_len = (name_end - name);
230 if (*name_len <= 0) {
231 pr_err("Failed to parse long snapshot name\n");
232 return ERR_PTR(-EIO);
235 /* Get the inode number */
236 inode_number = kmemdup_nul(name_end + 1,
237 orig_len - *name_len - 2,
240 return ERR_PTR(-ENOMEM);
241 ret = kstrtou64(inode_number, 10, &vino.ino);
243 dout("Failed to parse inode number: %s\n", name);
248 /* And finally the inode */
249 dir = ceph_find_inode(parent->i_sb, vino);
251 /* This can happen if we're not mounting cephfs on the root */
252 dir = ceph_get_inode(parent->i_sb, vino, NULL);
254 dout("Can't find inode %s (%s)\n", inode_number, name);
262 int ceph_encode_encrypted_dname(struct inode *parent, struct qstr *d_name,
265 struct inode *dir = parent;
273 iname.name = d_name->name;
274 name_len = d_name->len;
276 /* Handle the special case of snapshot names that start with '_' */
277 if ((ceph_snap(dir) == CEPH_SNAPDIR) && (name_len > 0) &&
278 (iname.name[0] == '_')) {
279 dir = parse_longname(parent, iname.name, &name_len);
282 iname.name++; /* skip initial '_' */
284 iname.len = name_len;
286 if (!fscrypt_has_encryption_key(dir)) {
287 memcpy(buf, d_name->name, d_name->len);
293 * Convert cleartext d_name to ciphertext. If result is longer than
294 * CEPH_NOHASH_NAME_MAX, sha256 the remaining bytes
296 * See: fscrypt_setup_filename
298 if (!fscrypt_fname_encrypted_size(dir, iname.len, NAME_MAX, &len)) {
299 elen = -ENAMETOOLONG;
303 /* Allocate a buffer appropriate to hold the result */
304 cryptbuf = kmalloc(len > CEPH_NOHASH_NAME_MAX ? NAME_MAX : len,
311 ret = fscrypt_fname_encrypt(dir, &iname, cryptbuf, len);
317 /* hash the end if the name is long enough */
318 if (len > CEPH_NOHASH_NAME_MAX) {
319 u8 hash[SHA256_DIGEST_SIZE];
320 u8 *extra = cryptbuf + CEPH_NOHASH_NAME_MAX;
323 * hash the extra bytes and overwrite crypttext beyond that
326 sha256(extra, len - CEPH_NOHASH_NAME_MAX, hash);
327 memcpy(extra, hash, SHA256_DIGEST_SIZE);
328 len = CEPH_NOHASH_NAME_MAX + SHA256_DIGEST_SIZE;
331 /* base64 encode the encrypted name */
332 elen = ceph_base64_encode(cryptbuf, len, buf);
333 dout("base64-encoded ciphertext name = %.*s\n", elen, buf);
335 /* To understand the 240 limit, see CEPH_NOHASH_NAME_MAX comments */
337 if ((elen > 0) && (dir != parent)) {
338 char tmp_buf[NAME_MAX];
340 elen = snprintf(tmp_buf, sizeof(tmp_buf), "_%.*s_%ld",
341 elen, buf, dir->i_ino);
342 memcpy(buf, tmp_buf, elen);
348 if ((dir->i_state & I_NEW))
349 discard_new_inode(dir);
356 int ceph_encode_encrypted_fname(struct inode *parent, struct dentry *dentry,
359 WARN_ON_ONCE(!fscrypt_has_encryption_key(parent));
361 return ceph_encode_encrypted_dname(parent, &dentry->d_name, buf);
365 * ceph_fname_to_usr - convert a filename for userland presentation
366 * @fname: ceph_fname to be converted
367 * @tname: temporary name buffer to use for conversion (may be NULL)
368 * @oname: where converted name should be placed
369 * @is_nokey: set to true if key wasn't available during conversion (may be NULL)
371 * Given a filename (usually from the MDS), format it for presentation to
372 * userland. If @parent is not encrypted, just pass it back as-is.
374 * Otherwise, base64 decode the string, and then ask fscrypt to format it
375 * for userland presentation.
377 * Returns 0 on success or negative error code on error.
379 int ceph_fname_to_usr(const struct ceph_fname *fname, struct fscrypt_str *tname,
380 struct fscrypt_str *oname, bool *is_nokey)
382 struct inode *dir = fname->dir;
383 struct fscrypt_str _tname = FSTR_INIT(NULL, 0);
384 struct fscrypt_str iname;
385 char *name = fname->name;
386 int name_len = fname->name_len;
389 /* Sanity check that the resulting name will fit in the buffer */
390 if (fname->name_len > NAME_MAX || fname->ctext_len > NAME_MAX)
393 /* Handle the special case of snapshot names that start with '_' */
394 if ((ceph_snap(dir) == CEPH_SNAPDIR) && (name_len > 0) &&
396 dir = parse_longname(dir, name, &name_len);
399 name++; /* skip initial '_' */
402 if (!IS_ENCRYPTED(dir)) {
403 oname->name = fname->name;
404 oname->len = fname->name_len;
409 ret = ceph_fscrypt_prepare_readdir(dir);
414 * Use the raw dentry name as sent by the MDS instead of
415 * generating a nokey name via fscrypt.
417 if (!fscrypt_has_encryption_key(dir)) {
419 oname->name = fname->name;
421 memcpy(oname->name, fname->name, fname->name_len);
422 oname->len = fname->name_len;
429 if (fname->ctext_len == 0) {
433 ret = fscrypt_fname_alloc_buffer(NAME_MAX, &_tname);
439 declen = ceph_base64_decode(name, name_len, tname->name);
444 iname.name = tname->name;
447 iname.name = fname->ctext;
448 iname.len = fname->ctext_len;
451 ret = fscrypt_fname_disk_to_usr(dir, 0, 0, &iname, oname);
452 if (!ret && (dir != fname->dir)) {
453 char tmp_buf[CEPH_BASE64_CHARS(NAME_MAX)];
455 name_len = snprintf(tmp_buf, sizeof(tmp_buf), "_%.*s_%ld",
456 oname->len, oname->name, dir->i_ino);
457 memcpy(oname->name, tmp_buf, name_len);
458 oname->len = name_len;
462 fscrypt_fname_free_buffer(&_tname);
464 if (dir != fname->dir) {
465 if ((dir->i_state & I_NEW))
466 discard_new_inode(dir);
474 * ceph_fscrypt_prepare_readdir - simple __fscrypt_prepare_readdir() wrapper
475 * @dir: directory inode for readdir prep
477 * Simple wrapper around __fscrypt_prepare_readdir() that will mark directory as
478 * non-complete if this call results in having the directory unlocked.
481 * 1 - if directory was locked and key is now loaded (i.e. dir is unlocked)
482 * 0 - if directory is still locked
483 * < 0 - if __fscrypt_prepare_readdir() fails
485 int ceph_fscrypt_prepare_readdir(struct inode *dir)
487 bool had_key = fscrypt_has_encryption_key(dir);
490 if (!IS_ENCRYPTED(dir))
493 err = __fscrypt_prepare_readdir(dir);
496 if (!had_key && fscrypt_has_encryption_key(dir)) {
497 /* directory just got unlocked, mark it as not complete */
498 ceph_dir_clear_complete(dir);
504 int ceph_fscrypt_decrypt_block_inplace(const struct inode *inode,
505 struct page *page, unsigned int len,
506 unsigned int offs, u64 lblk_num)
508 dout("%s: len %u offs %u blk %llu\n", __func__, len, offs, lblk_num);
509 return fscrypt_decrypt_block_inplace(inode, page, len, offs, lblk_num);
512 int ceph_fscrypt_encrypt_block_inplace(const struct inode *inode,
513 struct page *page, unsigned int len,
514 unsigned int offs, u64 lblk_num,
517 dout("%s: len %u offs %u blk %llu\n", __func__, len, offs, lblk_num);
518 return fscrypt_encrypt_block_inplace(inode, page, len, offs, lblk_num,
523 * ceph_fscrypt_decrypt_pages - decrypt an array of pages
524 * @inode: pointer to inode associated with these pages
525 * @page: pointer to page array
526 * @off: offset into the file that the read data starts
527 * @len: max length to decrypt
529 * Decrypt an array of fscrypt'ed pages and return the amount of
530 * data decrypted. Any data in the page prior to the start of the
531 * first complete block in the read is ignored. Any incomplete
532 * crypto blocks at the end of the array are ignored (and should
533 * probably be zeroed by the caller).
535 * Returns the length of the decrypted data or a negative errno.
537 int ceph_fscrypt_decrypt_pages(struct inode *inode, struct page **page,
541 u64 baseblk = off >> CEPH_FSCRYPT_BLOCK_SHIFT;
545 * We can't deal with partial blocks on an encrypted file, so mask off
548 num_blocks = ceph_fscrypt_blocks(off, len & CEPH_FSCRYPT_BLOCK_MASK);
550 /* Decrypt each block */
551 for (i = 0; i < num_blocks; ++i) {
552 int blkoff = i << CEPH_FSCRYPT_BLOCK_SHIFT;
553 int pgidx = blkoff >> PAGE_SHIFT;
554 unsigned int pgoffs = offset_in_page(blkoff);
557 fret = ceph_fscrypt_decrypt_block_inplace(inode, page[pgidx],
558 CEPH_FSCRYPT_BLOCK_SIZE, pgoffs,
565 ret += CEPH_FSCRYPT_BLOCK_SIZE;
571 * ceph_fscrypt_decrypt_extents: decrypt received extents in given buffer
572 * @inode: inode associated with pages being decrypted
573 * @page: pointer to page array
574 * @off: offset into the file that the data in page[0] starts
575 * @map: pointer to extent array
576 * @ext_cnt: length of extent array
578 * Given an extent map and a page array, decrypt the received data in-place,
579 * skipping holes. Returns the offset into buffer of end of last decrypted
582 int ceph_fscrypt_decrypt_extents(struct inode *inode, struct page **page,
583 u64 off, struct ceph_sparse_extent *map,
587 struct ceph_inode_info *ci = ceph_inode(inode);
591 /* Nothing to do for empty array */
593 dout("%s: empty array, ret 0\n", __func__);
597 ceph_calc_file_object_mapping(&ci->i_layout, off, map[0].len,
598 &objno, &objoff, &xlen);
600 for (i = 0; i < ext_cnt; ++i) {
601 struct ceph_sparse_extent *ext = &map[i];
602 int pgsoff = ext->off - objoff;
603 int pgidx = pgsoff >> PAGE_SHIFT;
606 if ((ext->off | ext->len) & ~CEPH_FSCRYPT_BLOCK_MASK) {
607 pr_warn("%s: bad encrypted sparse extent idx %d off %llx len %llx\n",
608 __func__, i, ext->off, ext->len);
611 fret = ceph_fscrypt_decrypt_pages(inode, &page[pgidx],
612 off + pgsoff, ext->len);
613 dout("%s: [%d] 0x%llx~0x%llx fret %d\n", __func__, i,
614 ext->off, ext->len, fret);
622 dout("%s: ret %d\n", __func__, ret);
627 * ceph_fscrypt_encrypt_pages - encrypt an array of pages
628 * @inode: pointer to inode associated with these pages
629 * @page: pointer to page array
630 * @off: offset into the file that the data starts
631 * @len: max length to encrypt
632 * @gfp: gfp flags to use for allocation
634 * Decrypt an array of cleartext pages and return the amount of
635 * data encrypted. Any data in the page prior to the start of the
636 * first complete block in the read is ignored. Any incomplete
637 * crypto blocks at the end of the array are ignored.
639 * Returns the length of the encrypted data or a negative errno.
641 int ceph_fscrypt_encrypt_pages(struct inode *inode, struct page **page, u64 off,
645 u64 baseblk = off >> CEPH_FSCRYPT_BLOCK_SHIFT;
649 * We can't deal with partial blocks on an encrypted file, so mask off
652 num_blocks = ceph_fscrypt_blocks(off, len & CEPH_FSCRYPT_BLOCK_MASK);
654 /* Encrypt each block */
655 for (i = 0; i < num_blocks; ++i) {
656 int blkoff = i << CEPH_FSCRYPT_BLOCK_SHIFT;
657 int pgidx = blkoff >> PAGE_SHIFT;
658 unsigned int pgoffs = offset_in_page(blkoff);
661 fret = ceph_fscrypt_encrypt_block_inplace(inode, page[pgidx],
662 CEPH_FSCRYPT_BLOCK_SIZE, pgoffs,
669 ret += CEPH_FSCRYPT_BLOCK_SIZE;