2 * linux/fs/f2fs/crypto_fname.c
4 * Copied from linux/fs/ext4/crypto.c
6 * Copyright (C) 2015, Google, Inc.
7 * Copyright (C) 2015, Motorola Mobility
9 * This contains functions for filename crypto management in f2fs
11 * Written by Uday Savagaonkar, 2014.
13 * Adjust f2fs dentry structure
16 * This has not yet undergone a rigorous security audit.
18 #include <crypto/hash.h>
19 #include <crypto/sha.h>
20 #include <keys/encrypted-type.h>
21 #include <keys/user-type.h>
22 #include <linux/crypto.h>
23 #include <linux/gfp.h>
24 #include <linux/kernel.h>
25 #include <linux/key.h>
26 #include <linux/list.h>
27 #include <linux/mempool.h>
28 #include <linux/random.h>
29 #include <linux/scatterlist.h>
30 #include <linux/spinlock_types.h>
31 #include <linux/f2fs_fs.h>
32 #include <linux/ratelimit.h>
35 #include "f2fs_crypto.h"
39 * f2fs_dir_crypt_complete() -
41 static void f2fs_dir_crypt_complete(struct crypto_async_request
*req
, int res
)
43 struct f2fs_completion_result
*ecr
= req
->data
;
45 if (res
== -EINPROGRESS
)
48 complete(&ecr
->completion
);
51 bool f2fs_valid_filenames_enc_mode(uint32_t mode
)
53 return (mode
== F2FS_ENCRYPTION_MODE_AES_256_CTS
);
56 static unsigned max_name_len(struct inode
*inode
)
58 return S_ISLNK(inode
->i_mode
) ? inode
->i_sb
->s_blocksize
:
63 * f2fs_fname_encrypt() -
65 * This function encrypts the input filename, and returns the length of the
66 * ciphertext. Errors are returned as negative numbers. We trust the caller to
67 * allocate sufficient memory to oname string.
69 static int f2fs_fname_encrypt(struct inode
*inode
,
70 const struct qstr
*iname
, struct f2fs_str
*oname
)
73 struct ablkcipher_request
*req
= NULL
;
74 DECLARE_F2FS_COMPLETION_RESULT(ecr
);
75 struct f2fs_crypt_info
*ci
= F2FS_I(inode
)->i_crypt_info
;
76 struct crypto_ablkcipher
*tfm
= ci
->ci_ctfm
;
78 char iv
[F2FS_CRYPTO_BLOCK_SIZE
];
79 struct scatterlist src_sg
, dst_sg
;
80 int padding
= 4 << (ci
->ci_flags
& F2FS_POLICY_FLAGS_PAD_MASK
);
81 char *workbuf
, buf
[32], *alloc_buf
= NULL
;
82 unsigned lim
= max_name_len(inode
);
84 if (iname
->len
<= 0 || iname
->len
> lim
)
87 ciphertext_len
= (iname
->len
< F2FS_CRYPTO_BLOCK_SIZE
) ?
88 F2FS_CRYPTO_BLOCK_SIZE
: iname
->len
;
89 ciphertext_len
= f2fs_fname_crypto_round_up(ciphertext_len
, padding
);
90 ciphertext_len
= (ciphertext_len
> lim
) ? lim
: ciphertext_len
;
92 if (ciphertext_len
<= sizeof(buf
)) {
95 alloc_buf
= kmalloc(ciphertext_len
, GFP_NOFS
);
101 /* Allocate request */
102 req
= ablkcipher_request_alloc(tfm
, GFP_NOFS
);
104 printk_ratelimited(KERN_ERR
105 "%s: crypto_request_alloc() failed\n", __func__
);
109 ablkcipher_request_set_callback(req
,
110 CRYPTO_TFM_REQ_MAY_BACKLOG
| CRYPTO_TFM_REQ_MAY_SLEEP
,
111 f2fs_dir_crypt_complete
, &ecr
);
114 memcpy(workbuf
, iname
->name
, iname
->len
);
115 if (iname
->len
< ciphertext_len
)
116 memset(workbuf
+ iname
->len
, 0, ciphertext_len
- iname
->len
);
119 memset(iv
, 0, F2FS_CRYPTO_BLOCK_SIZE
);
121 /* Create encryption request */
122 sg_init_one(&src_sg
, workbuf
, ciphertext_len
);
123 sg_init_one(&dst_sg
, oname
->name
, ciphertext_len
);
124 ablkcipher_request_set_crypt(req
, &src_sg
, &dst_sg
, ciphertext_len
, iv
);
125 res
= crypto_ablkcipher_encrypt(req
);
126 if (res
== -EINPROGRESS
|| res
== -EBUSY
) {
127 wait_for_completion(&ecr
.completion
);
131 ablkcipher_request_free(req
);
133 printk_ratelimited(KERN_ERR
134 "%s: Error (error code %d)\n", __func__
, res
);
136 oname
->len
= ciphertext_len
;
141 * f2fs_fname_decrypt()
142 * This function decrypts the input filename, and returns
143 * the length of the plaintext.
144 * Errors are returned as negative numbers.
145 * We trust the caller to allocate sufficient memory to oname string.
147 static int f2fs_fname_decrypt(struct inode
*inode
,
148 const struct f2fs_str
*iname
, struct f2fs_str
*oname
)
150 struct ablkcipher_request
*req
= NULL
;
151 DECLARE_F2FS_COMPLETION_RESULT(ecr
);
152 struct scatterlist src_sg
, dst_sg
;
153 struct f2fs_crypt_info
*ci
= F2FS_I(inode
)->i_crypt_info
;
154 struct crypto_ablkcipher
*tfm
= ci
->ci_ctfm
;
156 char iv
[F2FS_CRYPTO_BLOCK_SIZE
];
157 unsigned lim
= max_name_len(inode
);
159 if (iname
->len
<= 0 || iname
->len
> lim
)
162 /* Allocate request */
163 req
= ablkcipher_request_alloc(tfm
, GFP_NOFS
);
165 printk_ratelimited(KERN_ERR
166 "%s: crypto_request_alloc() failed\n", __func__
);
169 ablkcipher_request_set_callback(req
,
170 CRYPTO_TFM_REQ_MAY_BACKLOG
| CRYPTO_TFM_REQ_MAY_SLEEP
,
171 f2fs_dir_crypt_complete
, &ecr
);
174 memset(iv
, 0, F2FS_CRYPTO_BLOCK_SIZE
);
176 /* Create decryption request */
177 sg_init_one(&src_sg
, iname
->name
, iname
->len
);
178 sg_init_one(&dst_sg
, oname
->name
, oname
->len
);
179 ablkcipher_request_set_crypt(req
, &src_sg
, &dst_sg
, iname
->len
, iv
);
180 res
= crypto_ablkcipher_decrypt(req
);
181 if (res
== -EINPROGRESS
|| res
== -EBUSY
) {
182 wait_for_completion(&ecr
.completion
);
185 ablkcipher_request_free(req
);
187 printk_ratelimited(KERN_ERR
188 "%s: Error in f2fs_fname_decrypt (error code %d)\n",
193 oname
->len
= strnlen(oname
->name
, iname
->len
);
197 static const char *lookup_table
=
198 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+,";
201 * f2fs_fname_encode_digest() -
203 * Encodes the input digest using characters from the set [a-zA-Z0-9_+].
204 * The encoded string is roughly 4/3 times the size of the input string.
206 static int digest_encode(const char *src
, int len
, char *dst
)
208 int i
= 0, bits
= 0, ac
= 0;
212 ac
+= (((unsigned char) src
[i
]) << bits
);
215 *cp
++ = lookup_table
[ac
& 0x3f];
222 *cp
++ = lookup_table
[ac
& 0x3f];
226 static int digest_decode(const char *src
, int len
, char *dst
)
228 int i
= 0, bits
= 0, ac
= 0;
233 p
= strchr(lookup_table
, src
[i
]);
234 if (p
== NULL
|| src
[i
] == 0)
236 ac
+= (p
- lookup_table
) << bits
;
251 * f2fs_fname_crypto_round_up() -
253 * Return: The next multiple of block size
255 u32
f2fs_fname_crypto_round_up(u32 size
, u32 blksize
)
257 return ((size
+ blksize
- 1) / blksize
) * blksize
;
261 * f2fs_fname_crypto_alloc_obuff() -
263 * Allocates an output buffer that is sufficient for the crypto operation
264 * specified by the context and the direction.
266 int f2fs_fname_crypto_alloc_buffer(struct inode
*inode
,
267 u32 ilen
, struct f2fs_str
*crypto_str
)
271 struct f2fs_crypt_info
*ci
= F2FS_I(inode
)->i_crypt_info
;
274 padding
= 4 << (ci
->ci_flags
& F2FS_POLICY_FLAGS_PAD_MASK
);
275 if (padding
< F2FS_CRYPTO_BLOCK_SIZE
)
276 padding
= F2FS_CRYPTO_BLOCK_SIZE
;
277 olen
= f2fs_fname_crypto_round_up(ilen
, padding
);
278 crypto_str
->len
= olen
;
279 if (olen
< F2FS_FNAME_CRYPTO_DIGEST_SIZE
* 2)
280 olen
= F2FS_FNAME_CRYPTO_DIGEST_SIZE
* 2;
281 /* Allocated buffer can hold one more character to null-terminate the
283 crypto_str
->name
= kmalloc(olen
+ 1, GFP_NOFS
);
284 if (!(crypto_str
->name
))
290 * f2fs_fname_crypto_free_buffer() -
292 * Frees the buffer allocated for crypto operation.
294 void f2fs_fname_crypto_free_buffer(struct f2fs_str
*crypto_str
)
298 kfree(crypto_str
->name
);
299 crypto_str
->name
= NULL
;
303 * f2fs_fname_disk_to_usr() - converts a filename from disk space to user space
305 int f2fs_fname_disk_to_usr(struct inode
*inode
,
307 const struct f2fs_str
*iname
,
308 struct f2fs_str
*oname
)
310 const struct qstr qname
= FSTR_TO_QSTR(iname
);
314 if (is_dot_dotdot(&qname
)) {
315 oname
->name
[0] = '.';
316 oname
->name
[iname
->len
- 1] = '.';
317 oname
->len
= iname
->len
;
321 if (F2FS_I(inode
)->i_crypt_info
)
322 return f2fs_fname_decrypt(inode
, iname
, oname
);
324 if (iname
->len
<= F2FS_FNAME_CRYPTO_DIGEST_SIZE
) {
325 ret
= digest_encode(iname
->name
, iname
->len
, oname
->name
);
330 memcpy(buf
, hash
, 4);
331 memset(buf
+ 4, 0, 4);
334 memcpy(buf
+ 8, iname
->name
+ ((iname
->len
- 17) & ~15), 16);
335 oname
->name
[0] = '_';
336 ret
= digest_encode(buf
, 24, oname
->name
+ 1);
337 oname
->len
= ret
+ 1;
342 * f2fs_fname_usr_to_disk() - converts a filename from user space to disk space
344 int f2fs_fname_usr_to_disk(struct inode
*inode
,
345 const struct qstr
*iname
,
346 struct f2fs_str
*oname
)
349 struct f2fs_crypt_info
*ci
= F2FS_I(inode
)->i_crypt_info
;
351 if (is_dot_dotdot(iname
)) {
352 oname
->name
[0] = '.';
353 oname
->name
[iname
->len
- 1] = '.';
354 oname
->len
= iname
->len
;
359 res
= f2fs_fname_encrypt(inode
, iname
, oname
);
362 /* Without a proper key, a user is not allowed to modify the filenames
363 * in a directory. Consequently, a user space name cannot be mapped to
364 * a disk-space name */
368 int f2fs_fname_setup_filename(struct inode
*dir
, const struct qstr
*iname
,
369 int lookup
, struct f2fs_filename
*fname
)
371 struct f2fs_crypt_info
*ci
;
372 int ret
= 0, bigname
= 0;
374 memset(fname
, 0, sizeof(struct f2fs_filename
));
375 fname
->usr_fname
= iname
;
377 if (!f2fs_encrypted_inode(dir
) || is_dot_dotdot(iname
)) {
378 fname
->disk_name
.name
= (unsigned char *)iname
->name
;
379 fname
->disk_name
.len
= iname
->len
;
382 ret
= f2fs_get_encryption_info(dir
);
385 ci
= F2FS_I(dir
)->i_crypt_info
;
387 ret
= f2fs_fname_crypto_alloc_buffer(dir
, iname
->len
,
391 ret
= f2fs_fname_encrypt(dir
, iname
, &fname
->crypto_buf
);
394 fname
->disk_name
.name
= fname
->crypto_buf
.name
;
395 fname
->disk_name
.len
= fname
->crypto_buf
.len
;
401 /* We don't have the key and we are doing a lookup; decode the
404 if (iname
->name
[0] == '_')
406 if ((bigname
&& (iname
->len
!= 33)) ||
407 (!bigname
&& (iname
->len
> 43)))
410 fname
->crypto_buf
.name
= kmalloc(32, GFP_KERNEL
);
411 if (fname
->crypto_buf
.name
== NULL
)
413 ret
= digest_decode(iname
->name
+ bigname
, iname
->len
- bigname
,
414 fname
->crypto_buf
.name
);
419 fname
->crypto_buf
.len
= ret
;
421 memcpy(&fname
->hash
, fname
->crypto_buf
.name
, 4);
423 fname
->disk_name
.name
= fname
->crypto_buf
.name
;
424 fname
->disk_name
.len
= fname
->crypto_buf
.len
;
428 f2fs_fname_crypto_free_buffer(&fname
->crypto_buf
);
432 void f2fs_fname_free_filename(struct f2fs_filename
*fname
)
434 kfree(fname
->crypto_buf
.name
);
435 fname
->crypto_buf
.name
= NULL
;
436 fname
->usr_fname
= NULL
;
437 fname
->disk_name
.name
= NULL
;