fs/verity/read_metadata.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Ioctl to read verity metadata
   4  *
   5  * Copyright 2021 Google LLC
   6  */
   7
   8 #include "fsverity_private.h"
   9
  10 #include <linux/backing-dev.h>
  11 #include <linux/highmem.h>
  12 #include <linux/sched/signal.h>
  13 #include <linux/uaccess.h>
  14
  15 static int fsverity_read_merkle_tree(struct inode *inode,
  16                                      const struct fsverity_info *vi,
  17                                      void __user *buf, u64 offset, int length)
  18 {
  19         const struct fsverity_operations *vops = inode->i_sb->s_vop;
  20         u64 end_offset;
  21         unsigned int offs_in_page;
  22         pgoff_t index, last_index;
  23         int retval = 0;
  24         int err = 0;
  25
  26         end_offset = min(offset + length, vi->tree_params.tree_size);
  27         if (offset >= end_offset)
  28                 return 0;
  29         offs_in_page = offset_in_page(offset);
  30         last_index = (end_offset - 1) >> PAGE_SHIFT;
  31
  32         /*
  33          * Iterate through each Merkle tree page in the requested range and copy
  34          * the requested portion to userspace.  Note that the Merkle tree block
  35          * size isn't important here, as we are returning a byte stream; i.e.,
  36          * we can just work with pages even if the tree block size != PAGE_SIZE.
  37          */
  38         for (index = offset >> PAGE_SHIFT; index <= last_index; index++) {
  39                 unsigned long num_ra_pages =
  40                         min_t(unsigned long, last_index - index + 1,
  41                               inode->i_sb->s_bdi->io_pages);
  42                 unsigned int bytes_to_copy = min_t(u64, end_offset - offset,
  43                                                    PAGE_SIZE - offs_in_page);
  44                 struct page *page;
  45                 const void *virt;
  46
  47                 page = vops->read_merkle_tree_page(inode, index, num_ra_pages);
  48                 if (IS_ERR(page)) {
  49                         err = PTR_ERR(page);
  50                         fsverity_err(inode,
  51                                      "Error %d reading Merkle tree page %lu",
  52                                      err, index);
  53                         break;
  54                 }
  55
  56                 virt = kmap_local_page(page);
  57                 if (copy_to_user(buf, virt + offs_in_page, bytes_to_copy)) {
  58                         kunmap_local(virt);
  59                         put_page(page);
  60                         err = -EFAULT;
  61                         break;
  62                 }
  63                 kunmap_local(virt);
  64                 put_page(page);
  65
  66                 retval += bytes_to_copy;
  67                 buf += bytes_to_copy;
  68                 offset += bytes_to_copy;
  69
  70                 if (fatal_signal_pending(current))  {
  71                         err = -EINTR;
  72                         break;
  73                 }
  74                 cond_resched();
  75                 offs_in_page = 0;
  76         }
  77         return retval ? retval : err;
  78 }
  79
  80 /* Copy the requested portion of the buffer to userspace. */
  81 static int fsverity_read_buffer(void __user *dst, u64 offset, int length,
  82                                 const void *src, size_t src_length)
  83 {
  84         if (offset >= src_length)
  85                 return 0;
  86         src += offset;
  87         src_length -= offset;
  88
  89         length = min_t(size_t, length, src_length);
  90
  91         if (copy_to_user(dst, src, length))
  92                 return -EFAULT;
  93
  94         return length;
  95 }
  96
  97 static int fsverity_read_descriptor(struct inode *inode,
  98                                     void __user *buf, u64 offset, int length)
  99 {
 100         struct fsverity_descriptor *desc;
 101         size_t desc_size;
 102         int res;
 103
 104         res = fsverity_get_descriptor(inode, &desc);
 105         if (res)
 106                 return res;
 107
 108         /* don't include the builtin signature */
 109         desc_size = offsetof(struct fsverity_descriptor, signature);
 110         desc->sig_size = 0;
 111
 112         res = fsverity_read_buffer(buf, offset, length, desc, desc_size);
 113
 114         kfree(desc);
 115         return res;
 116 }
 117
 118 static int fsverity_read_signature(struct inode *inode,
 119                                    void __user *buf, u64 offset, int length)
 120 {
 121         struct fsverity_descriptor *desc;
 122         int res;
 123
 124         res = fsverity_get_descriptor(inode, &desc);
 125         if (res)
 126                 return res;
 127
 128         if (desc->sig_size == 0) {
 129                 res = -ENODATA;
 130                 goto out;
 131         }
 132
 133         /*
 134          * Include only the builtin signature.  fsverity_get_descriptor()
 135          * already verified that sig_size is in-bounds.
 136          */
 137         res = fsverity_read_buffer(buf, offset, length, desc->signature,
 138                                    le32_to_cpu(desc->sig_size));
 139 out:
 140         kfree(desc);
 141         return res;
 142 }
 143
 144 /**
 145  * fsverity_ioctl_read_metadata() - read verity metadata from a file
 146  * @filp: file to read the metadata from
 147  * @uarg: user pointer to fsverity_read_metadata_arg
 148  *
 149  * Return: length read on success, 0 on EOF, -errno on failure
 150  */
 151 int fsverity_ioctl_read_metadata(struct file *filp, const void __user *uarg)
 152 {
 153         struct inode *inode = file_inode(filp);
 154         const struct fsverity_info *vi;
 155         struct fsverity_read_metadata_arg arg;
 156         int length;
 157         void __user *buf;
 158
 159         vi = fsverity_get_info(inode);
 160         if (!vi)
 161                 return -ENODATA; /* not a verity file */
 162         /*
 163          * Note that we don't have to explicitly check that the file is open for
 164          * reading, since verity files can only be opened for reading.
 165          */
 166
 167         if (copy_from_user(&arg, uarg, sizeof(arg)))
 168                 return -EFAULT;
 169
 170         if (arg.__reserved)
 171                 return -EINVAL;
 172
 173         /* offset + length must not overflow. */
 174         if (arg.offset + arg.length < arg.offset)
 175                 return -EINVAL;
 176
 177         /* Ensure that the return value will fit in INT_MAX. */
 178         length = min_t(u64, arg.length, INT_MAX);
 179
 180         buf = u64_to_user_ptr(arg.buf_ptr);
 181
 182         switch (arg.metadata_type) {
 183         case FS_VERITY_METADATA_TYPE_MERKLE_TREE:
 184                 return fsverity_read_merkle_tree(inode, vi, buf, arg.offset,
 185                                                  length);
 186         case FS_VERITY_METADATA_TYPE_DESCRIPTOR:
 187                 return fsverity_read_descriptor(inode, buf, arg.offset, length);
 188         case FS_VERITY_METADATA_TYPE_SIGNATURE:
 189                 return fsverity_read_signature(inode, buf, arg.offset, length);
 190         default:
 191                 return -EINVAL;
 192         }
 193 }
 194 EXPORT_SYMBOL_GPL(fsverity_ioctl_read_metadata);