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 */ 289