fs/ceph/crypto.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * Ceph fscrypt functionality
   4  */
   5
   6 #ifndef _CEPH_CRYPTO_H
   7 #define _CEPH_CRYPTO_H
   8
   9 #include <crypto/sha2.h>
  10 #include <linux/fscrypt.h>
  11
  12 #define CEPH_FSCRYPT_BLOCK_SHIFT   12
  13 #define CEPH_FSCRYPT_BLOCK_SIZE    (_AC(1, UL) << CEPH_FSCRYPT_BLOCK_SHIFT)
  14 #define CEPH_FSCRYPT_BLOCK_MASK    (~(CEPH_FSCRYPT_BLOCK_SIZE-1))
  15
  16 struct ceph_fs_client;
  17 struct ceph_acl_sec_ctx;
  18 struct ceph_mds_request;
  19
  20 struct ceph_fname {
  21         struct inode    *dir;
  22         char            *name;          // b64 encoded, possibly hashed
  23         unsigned char   *ctext;         // binary crypttext (if any)
  24         u32             name_len;       // length of name buffer
  25         u32             ctext_len;      // length of crypttext
  26         bool            no_copy;
  27 };
  28
  29 /*
  30  * Header for the crypted file when truncating the size, this
  31  * will be sent to MDS, and the MDS will update the encrypted
  32  * last block and then truncate the size.
  33  */
  34 struct ceph_fscrypt_truncate_size_header {
  35         __u8  ver;
  36         __u8  compat;
  37
  38         /*
  39          * It will be sizeof(assert_ver + file_offset + block_size)
  40          * if the last block is empty when it's located in a file
  41          * hole. Or the data_len will plus CEPH_FSCRYPT_BLOCK_SIZE.
  42          */
  43         __le32 data_len;
  44
  45         __le64 change_attr;
  46         __le64 file_offset;
  47         __le32 block_size;
  48 } __packed;
  49
  50 struct ceph_fscrypt_auth {
  51         __le32  cfa_version;
  52         __le32  cfa_blob_len;
  53         u8      cfa_blob[FSCRYPT_SET_CONTEXT_MAX_SIZE];
  54 } __packed;
  55
  56 #define CEPH_FSCRYPT_AUTH_VERSION       1
  57 static inline u32 ceph_fscrypt_auth_len(struct ceph_fscrypt_auth *fa)
  58 {
  59         u32 ctxsize = le32_to_cpu(fa->cfa_blob_len);
  60
  61         return offsetof(struct ceph_fscrypt_auth, cfa_blob) + ctxsize;
  62 }
  63
  64 #ifdef CONFIG_FS_ENCRYPTION
  65 /*
  66  * We want to encrypt filenames when creating them, but the encrypted
  67  * versions of those names may have illegal characters in them. To mitigate
  68  * that, we base64 encode them, but that gives us a result that can exceed
  69  * NAME_MAX.
  70  *
  71  * Follow a similar scheme to fscrypt itself, and cap the filename to a
  72  * smaller size. If the ciphertext name is longer than the value below, then
  73  * sha256 hash the remaining bytes.
  74  *
  75  * For the fscrypt_nokey_name struct the dirhash[2] member is useless in ceph
  76  * so the corresponding struct will be:
  77  *
  78  * struct fscrypt_ceph_nokey_name {
  79  *      u8 bytes[157];
  80  *      u8 sha256[SHA256_DIGEST_SIZE];
  81  * }; // 180 bytes => 240 bytes base64-encoded, which is <= NAME_MAX (255)
  82  *
  83  * (240 bytes is the maximum size allowed for snapshot names to take into
  84  *  account the format: '_<SNAPSHOT-NAME>_<INODE-NUMBER>'.)
  85  *
  86  * Note that for long names that end up having their tail portion hashed, we
  87  * must also store the full encrypted name (in the dentry's alternate_name
  88  * field).
  89  */
  90 #define CEPH_NOHASH_NAME_MAX (180 - SHA256_DIGEST_SIZE)
  91
  92 #define CEPH_BASE64_CHARS(nbytes) DIV_ROUND_UP((nbytes) * 4, 3)
  93
  94 int ceph_base64_encode(const u8 *src, int srclen, char *dst);
  95 int ceph_base64_decode(const char *src, int srclen, u8 *dst);
  96
  97 void ceph_fscrypt_set_ops(struct super_block *sb);
  98
  99 void ceph_fscrypt_free_dummy_policy(struct ceph_fs_client *fsc);
 100
 101 int ceph_fscrypt_prepare_context(struct inode *dir, struct inode *inode,
 102                                  struct ceph_acl_sec_ctx *as);
 103 void ceph_fscrypt_as_ctx_to_req(struct ceph_mds_request *req,
 104                                 struct ceph_acl_sec_ctx *as);
 105 int ceph_encode_encrypted_dname(struct inode *parent, struct qstr *d_name,
 106                                 char *buf);
 107 int ceph_encode_encrypted_fname(struct inode *parent, struct dentry *dentry,
 108                                 char *buf);
 109
 110 static inline int ceph_fname_alloc_buffer(struct inode *parent,
 111                                           struct fscrypt_str *fname)
 112 {
 113         if (!IS_ENCRYPTED(parent))
 114                 return 0;
 115         return fscrypt_fname_alloc_buffer(NAME_MAX, fname);
 116 }
 117
 118 static inline void ceph_fname_free_buffer(struct inode *parent,
 119                                           struct fscrypt_str *fname)
 120 {
 121         if (IS_ENCRYPTED(parent))
 122                 fscrypt_fname_free_buffer(fname);
 123 }
 124
 125 int ceph_fname_to_usr(const struct ceph_fname *fname, struct fscrypt_str *tname,
 126                       struct fscrypt_str *oname, bool *is_nokey);
 127 int ceph_fscrypt_prepare_readdir(struct inode *dir);
 128
 129 static inline unsigned int ceph_fscrypt_blocks(u64 off, u64 len)
 130 {
 131         /* crypto blocks cannot span more than one page */
 132         BUILD_BUG_ON(CEPH_FSCRYPT_BLOCK_SHIFT > PAGE_SHIFT);
 133
 134         return ((off+len+CEPH_FSCRYPT_BLOCK_SIZE-1) >> CEPH_FSCRYPT_BLOCK_SHIFT) -
 135                 (off >> CEPH_FSCRYPT_BLOCK_SHIFT);
 136 }
 137
 138 /*
 139  * If we have an encrypted inode then we must adjust the offset and
 140  * range of the on-the-wire read to cover an entire encryption block.
 141  * The copy will be done using the original offset and length, after
 142  * we've decrypted the result.
 143  */
 144 static inline void ceph_fscrypt_adjust_off_and_len(struct inode *inode,
 145                                                    u64 *off, u64 *len)
 146 {
 147         if (IS_ENCRYPTED(inode)) {
 148                 *len = ceph_fscrypt_blocks(*off, *len) * CEPH_FSCRYPT_BLOCK_SIZE;
 149                 *off &= CEPH_FSCRYPT_BLOCK_MASK;
 150         }
 151 }
 152
 153 int ceph_fscrypt_decrypt_block_inplace(const struct inode *inode,
 154                                   struct page *page, unsigned int len,
 155                                   unsigned int offs, u64 lblk_num);
 156 int ceph_fscrypt_encrypt_block_inplace(const struct inode *inode,
 157                                   struct page *page, unsigned int len,
 158                                   unsigned int offs, u64 lblk_num,
 159                                   gfp_t gfp_flags);
 160 int ceph_fscrypt_decrypt_pages(struct inode *inode, struct page **page,
 161                                u64 off, int len);
 162 int ceph_fscrypt_decrypt_extents(struct inode *inode, struct page **page,
 163                                  u64 off, struct ceph_sparse_extent *map,
 164                                  u32 ext_cnt);
 165 int ceph_fscrypt_encrypt_pages(struct inode *inode, struct page **page, u64 off,
 166                                int len, gfp_t gfp);
 167
 168 static inline struct page *ceph_fscrypt_pagecache_page(struct page *page)
 169 {
 170         return fscrypt_is_bounce_page(page) ? fscrypt_pagecache_page(page) : page;
 171 }
 172
 173 #else /* CONFIG_FS_ENCRYPTION */
 174
 175 static inline void ceph_fscrypt_set_ops(struct super_block *sb)
 176 {
 177 }
 178
 179 static inline void ceph_fscrypt_free_dummy_policy(struct ceph_fs_client *fsc)
 180 {
 181 }
 182
 183 static inline int ceph_fscrypt_prepare_context(struct inode *dir,
 184                                                struct inode *inode,
 185                                                struct ceph_acl_sec_ctx *as)
 186 {
 187         if (IS_ENCRYPTED(dir))
 188                 return -EOPNOTSUPP;
 189         return 0;
 190 }
 191
 192 static inline void ceph_fscrypt_as_ctx_to_req(struct ceph_mds_request *req,
 193                                                 struct ceph_acl_sec_ctx *as_ctx)
 194 {
 195 }
 196
 197 static inline int ceph_encode_encrypted_dname(struct inode *parent,
 198                                               struct qstr *d_name, char *buf)
 199 {
 200         memcpy(buf, d_name->name, d_name->len);
 201         return d_name->len;
 202 }
 203
 204 static inline int ceph_encode_encrypted_fname(struct inode *parent,
 205                                               struct dentry *dentry, char *buf)
 206 {
 207         return -EOPNOTSUPP;
 208 }
 209
 210 static inline int ceph_fname_alloc_buffer(struct inode *parent,
 211                                           struct fscrypt_str *fname)
 212 {
 213         return 0;
 214 }
 215
 216 static inline void ceph_fname_free_buffer(struct inode *parent,
 217                                           struct fscrypt_str *fname)
 218 {
 219 }
 220
 221 static inline int ceph_fname_to_usr(const struct ceph_fname *fname,
 222                                     struct fscrypt_str *tname,
 223                                     struct fscrypt_str *oname, bool *is_nokey)
 224 {
 225         oname->name = fname->name;
 226         oname->len = fname->name_len;
 227         return 0;
 228 }
 229
 230 static inline int ceph_fscrypt_prepare_readdir(struct inode *dir)
 231 {
 232         return 0;
 233 }
 234
 235 static inline void ceph_fscrypt_adjust_off_and_len(struct inode *inode,
 236                                                    u64 *off, u64 *len)
 237 {
 238 }
 239
 240 static inline int ceph_fscrypt_decrypt_block_inplace(const struct inode *inode,
 241                                           struct page *page, unsigned int len,
 242                                           unsigned int offs, u64 lblk_num)
 243 {
 244         return 0;
 245 }
 246
 247 static inline int ceph_fscrypt_encrypt_block_inplace(const struct inode *inode,
 248                                           struct page *page, unsigned int len,
 249                                           unsigned int offs, u64 lblk_num,
 250                                           gfp_t gfp_flags)
 251 {
 252         return 0;
 253 }
 254
 255 static inline int ceph_fscrypt_decrypt_pages(struct inode *inode,
 256                                              struct page **page, u64 off,
 257                                              int len)
 258 {
 259         return 0;
 260 }
 261
 262 static inline int ceph_fscrypt_decrypt_extents(struct inode *inode,
 263                                                struct page **page, u64 off,
 264                                                struct ceph_sparse_extent *map,
 265                                                u32 ext_cnt)
 266 {
 267         return 0;
 268 }
 269
 270 static inline int ceph_fscrypt_encrypt_pages(struct inode *inode,
 271                                              struct page **page, u64 off,
 272                                              int len, gfp_t gfp)
 273 {
 274         return 0;
 275 }
 276
 277 static inline struct page *ceph_fscrypt_pagecache_page(struct page *page)
 278 {
 279         return page;
 280 }
 281 #endif /* CONFIG_FS_ENCRYPTION */
 282
 283 static inline loff_t ceph_fscrypt_page_offset(struct page *page)
 284 {
 285         return page_offset(ceph_fscrypt_pagecache_page(page));
 286 }
 287
 288 #endif /* _CEPH_CRYPTO_H */