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
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.