read_metadata.c 4.8 KB

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