fscrypt: new helper functions for ->symlink()

Currently, filesystems supporting fscrypt need to implement some tricky
logic when creating encrypted symlinks, including handling a peculiar
on-disk format (struct fscrypt_symlink_data) and correctly calculating
the size of the encrypted symlink.  Introduce helper functions to make
things a bit easier:

- fscrypt_prepare_symlink() computes and validates the size the symlink
  target will require on-disk.
- fscrypt_encrypt_symlink() creates the encrypted target if needed.

The new helpers actually fix some subtle bugs.  First, when checking
whether the symlink target was too long, filesystems didn't account for
the fact that the NUL padding is meant to be truncated if it would cause
the maximum length to be exceeded, as is done for filenames in
directories.  Consequently users would receive ENAMETOOLONG when
creating symlinks close to what is supposed to be the maximum length.
For example, with EXT4 with a 4K block size, the maximum symlink target
length in an encrypted directory is supposed to be 4093 bytes (in
comparison to 4095 in an unencrypted directory), but in
FS_POLICY_FLAGS_PAD_32-mode only up to 4064 bytes were accepted.

Second, symlink targets of "." and ".." were not being encrypted, even
though they should be, as these names are special in *directory entries*
but not in symlink targets.  Fortunately, we can fix this simply by
starting to encrypt them, as old kernels already accept them in
encrypted form.

Third, the output string length the filesystems were providing when
doing the actual encryption was incorrect, as it was forgotten to
exclude 'sizeof(struct fscrypt_symlink_data)'.  Fortunately though, this
bug didn't make a difference.

Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>

3 files changed, 99 insertions, 3 deletions

diff --git a/fs/crypto/fname.c b/fs/crypto/fname.c
index 52d4dbe1e8e7..62f13d533439 100644
--- a/fs/crypto/fname.c
+++ b/fs/crypto/fname.c
@@ -34,8 +34,8 @@ static inline bool fscrypt_is_dot_dotdot(const struct qstr *str)
  *
  * Return: 0 on success, -errno on failure
  */
-static int fname_encrypt(struct inode *inode,
-                        const struct qstr *iname, struct fscrypt_str *oname)
+int fname_encrypt(struct inode *inode,
+                  const struct qstr *iname, struct fscrypt_str *oname)
 {
         struct skcipher_request *req = NULL;
         DECLARE_CRYPTO_WAIT(wait);
@@ -56,9 +56,11 @@ static int fname_encrypt(struct inode *inode,
          * Copy the filename to the output buffer for encrypting in-place and
          * pad it with the needed number of NUL bytes.
          */
+        if (WARN_ON(oname->len < iname->len))
+                return -ENOBUFS;
         cryptlen = max_t(unsigned int, iname->len, FS_CRYPTO_BLOCK_SIZE);
         cryptlen = round_up(cryptlen, padding);
-        cryptlen = min(cryptlen, lim);
+        cryptlen = min3(cryptlen, lim, oname->len);
         memcpy(oname->name, iname->name, iname->len);
         memset(oname->name + iname->len, 0, cryptlen - iname->len);
 
diff --git a/fs/crypto/fscrypt_private.h b/fs/crypto/fscrypt_private.h
index 2b848e7c92f0..6995bca5006b 100644
--- a/fs/crypto/fscrypt_private.h
+++ b/fs/crypto/fscrypt_private.h
@@ -98,6 +98,10 @@ extern int fscrypt_do_page_crypto(const struct inode *inode,
 extern struct page *fscrypt_alloc_bounce_page(struct fscrypt_ctx *ctx,
                                               gfp_t gfp_flags);
 
+/* fname.c */
+extern int fname_encrypt(struct inode *inode,
+                         const struct qstr *iname, struct fscrypt_str *oname);
+
 /* keyinfo.c */
 extern void __exit fscrypt_essiv_cleanup(void);
 
diff --git a/fs/crypto/hooks.c b/fs/crypto/hooks.c
index 9f5fb2eb9cf7..4b83e4af2e41 100644
--- a/fs/crypto/hooks.c
+++ b/fs/crypto/hooks.c
@@ -110,3 +110,93 @@ int __fscrypt_prepare_lookup(struct inode *dir, struct dentry *dentry)
         return 0;
 }
 EXPORT_SYMBOL_GPL(__fscrypt_prepare_lookup);
+
+int __fscrypt_prepare_symlink(struct inode *dir, unsigned int len,
+                              unsigned int max_len,
+                              struct fscrypt_str *disk_link)
+{
+        int err;
+
+        /*
+         * To calculate the size of the encrypted symlink target we need to know
+         * the amount of NUL padding, which is determined by the flags set in
+         * the encryption policy which will be inherited from the directory.
+         * The easiest way to get access to this is to just load the directory's
+         * fscrypt_info, since we'll need it to create the dir_entry anyway.
+         *
+         * Note: in test_dummy_encryption mode, @dir may be unencrypted.
+         */
+        err = fscrypt_get_encryption_info(dir);
+        if (err)
+                return err;
+        if (!fscrypt_has_encryption_key(dir))
+                return -ENOKEY;
+
+        /*
+         * Calculate the size of the encrypted symlink and verify it won't
+         * exceed max_len.  Note that for historical reasons, encrypted symlink
+         * targets are prefixed with the ciphertext length, despite this
+         * actually being redundant with i_size.  This decreases by 2 bytes the
+         * longest symlink target we can accept.
+         *
+         * We could recover 1 byte by not counting a null terminator, but
+         * counting it (even though it is meaningless for ciphertext) is simpler
+         * for now since filesystems will assume it is there and subtract it.
+         */
+        if (sizeof(struct fscrypt_symlink_data) + len > max_len)
+                return -ENAMETOOLONG;
+        disk_link->len = min_t(unsigned int,
+                               sizeof(struct fscrypt_symlink_data) +
+                                        fscrypt_fname_encrypted_size(dir, len),
+                               max_len);
+        disk_link->name = NULL;
+        return 0;
+}
+EXPORT_SYMBOL_GPL(__fscrypt_prepare_symlink);
+
+int __fscrypt_encrypt_symlink(struct inode *inode, const char *target,
+                              unsigned int len, struct fscrypt_str *disk_link)
+{
+        int err;
+        struct qstr iname = { .name = target, .len = len };
+        struct fscrypt_symlink_data *sd;
+        unsigned int ciphertext_len;
+        struct fscrypt_str oname;
+
+        err = fscrypt_require_key(inode);
+        if (err)
+                return err;
+
+        if (disk_link->name) {
+                /* filesystem-provided buffer */
+                sd = (struct fscrypt_symlink_data *)disk_link->name;
+        } else {
+                sd = kmalloc(disk_link->len, GFP_NOFS);
+                if (!sd)
+                        return -ENOMEM;
+        }
+        ciphertext_len = disk_link->len - sizeof(*sd);
+        sd->len = cpu_to_le16(ciphertext_len);
+
+        oname.name = sd->encrypted_path;
+        oname.len = ciphertext_len;
+        err = fname_encrypt(inode, &iname, &oname);
+        if (err) {
+                if (!disk_link->name)
+                        kfree(sd);
+                return err;
+        }
+        BUG_ON(oname.len != ciphertext_len);
+
+        /*
+         * Null-terminating the ciphertext doesn't make sense, but we still
+         * count the null terminator in the length, so we might as well
+         * initialize it just in case the filesystem writes it out.
+         */
+        sd->encrypted_path[ciphertext_len] = '\0';
+
+        if (!disk_link->name)
+                disk_link->name = (unsigned char *)sd;
+        return 0;
+}
+EXPORT_SYMBOL_GPL(__fscrypt_encrypt_symlink);