Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2021 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | use anyhow::Result; |
| 18 | use log::error; |
Victor Hsieh | 4563623 | 2021-10-15 17:52:51 -0700 | [diff] [blame] | 19 | use nix::{ |
Victor Hsieh | bf944d7 | 2022-03-07 23:46:43 +0000 | [diff] [blame] | 20 | errno::Errno, fcntl::openat, fcntl::OFlag, sys::stat::fchmod, sys::stat::mkdirat, |
Victor Hsieh | f393a72 | 2021-12-08 13:04:27 -0800 | [diff] [blame] | 21 | sys::stat::mode_t, sys::stat::Mode, sys::statvfs::statvfs, sys::statvfs::Statvfs, |
| 22 | unistd::unlinkat, unistd::UnlinkatFlags, |
Victor Hsieh | 4563623 | 2021-10-15 17:52:51 -0700 | [diff] [blame] | 23 | }; |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 24 | use std::cmp::min; |
Victor Hsieh | 4563623 | 2021-10-15 17:52:51 -0700 | [diff] [blame] | 25 | use std::collections::{btree_map, BTreeMap}; |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 26 | use std::convert::TryInto; |
| 27 | use std::fs::File; |
| 28 | use std::io; |
| 29 | use std::os::unix::fs::FileExt; |
Victor Hsieh | 559b927 | 2021-11-08 15:15:14 -0800 | [diff] [blame] | 30 | use std::os::unix::io::{AsRawFd, FromRawFd, RawFd}; |
| 31 | use std::path::{Component, Path, PathBuf, MAIN_SEPARATOR}; |
Victor Hsieh | bf944d7 | 2022-03-07 23:46:43 +0000 | [diff] [blame] | 32 | use std::sync::{Arc, RwLock}; |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 33 | |
Victor Hsieh | bf944d7 | 2022-03-07 23:46:43 +0000 | [diff] [blame] | 34 | use crate::common::OwnedFd; |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 35 | use crate::fsverity; |
| 36 | use authfs_aidl_interface::aidl::com::android::virt::fs::IVirtFdService::{ |
Victor Hsieh | f7fc3d3 | 2021-11-22 10:20:33 -0800 | [diff] [blame] | 37 | BnVirtFdService, FsStat::FsStat, IVirtFdService, MAX_REQUESTING_DATA, |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 38 | }; |
Inseob Kim | c0886c2 | 2021-12-13 17:41:24 +0900 | [diff] [blame] | 39 | use authfs_fsverity_metadata::{ |
| 40 | get_fsverity_metadata_path, parse_fsverity_metadata, FSVerityMetadata, |
| 41 | }; |
Alan Stokes | 0e82b50 | 2022-08-08 14:44:48 +0100 | [diff] [blame^] | 42 | use binder::{ |
| 43 | BinderFeatures, ExceptionCode, Interface, Result as BinderResult, Status, StatusCode, Strong, |
| 44 | }; |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 45 | |
Victor Hsieh | f393a72 | 2021-12-08 13:04:27 -0800 | [diff] [blame] | 46 | /// Bitflags of forbidden file mode, e.g. setuid, setgid and sticky bit. |
| 47 | const FORBIDDEN_MODES: Mode = Mode::from_bits_truncate(!0o777); |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 48 | |
| 49 | /// Configuration of a file descriptor to be served/exposed/shared. |
| 50 | pub enum FdConfig { |
| 51 | /// A read-only file to serve by this server. The file is supposed to be verifiable with the |
| 52 | /// associated fs-verity metadata. |
| 53 | Readonly { |
| 54 | /// The file to read from. fs-verity metadata can be retrieved from this file's FD. |
| 55 | file: File, |
| 56 | |
Inseob Kim | c0886c2 | 2021-12-13 17:41:24 +0900 | [diff] [blame] | 57 | // Alternative metadata storing merkle tree and signature. |
| 58 | alt_metadata: Option<Box<FSVerityMetadata>>, |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 59 | }, |
| 60 | |
| 61 | /// A readable/writable file to serve by this server. This backing file should just be a |
| 62 | /// regular file and does not have any specific property. |
| 63 | ReadWrite(File), |
Victor Hsieh | 4563623 | 2021-10-15 17:52:51 -0700 | [diff] [blame] | 64 | |
Victor Hsieh | 559b927 | 2021-11-08 15:15:14 -0800 | [diff] [blame] | 65 | /// A read-only directory to serve by this server. |
Victor Hsieh | bf944d7 | 2022-03-07 23:46:43 +0000 | [diff] [blame] | 66 | InputDir(OwnedFd), |
Victor Hsieh | 559b927 | 2021-11-08 15:15:14 -0800 | [diff] [blame] | 67 | |
Victor Hsieh | 4563623 | 2021-10-15 17:52:51 -0700 | [diff] [blame] | 68 | /// A writable directory to serve by this server. |
Victor Hsieh | bf944d7 | 2022-03-07 23:46:43 +0000 | [diff] [blame] | 69 | OutputDir(OwnedFd), |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 70 | } |
| 71 | |
| 72 | pub struct FdService { |
Victor Hsieh | 4563623 | 2021-10-15 17:52:51 -0700 | [diff] [blame] | 73 | /// A pool of opened files and directories, which can be looked up by the FD number. |
Victor Hsieh | bf944d7 | 2022-03-07 23:46:43 +0000 | [diff] [blame] | 74 | fd_pool: Arc<RwLock<BTreeMap<i32, FdConfig>>>, |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 75 | } |
| 76 | |
| 77 | impl FdService { |
| 78 | pub fn new_binder(fd_pool: BTreeMap<i32, FdConfig>) -> Strong<dyn IVirtFdService> { |
Victor Hsieh | 4563623 | 2021-10-15 17:52:51 -0700 | [diff] [blame] | 79 | BnVirtFdService::new_binder( |
Victor Hsieh | bf944d7 | 2022-03-07 23:46:43 +0000 | [diff] [blame] | 80 | FdService { fd_pool: Arc::new(RwLock::new(fd_pool)) }, |
Victor Hsieh | 4563623 | 2021-10-15 17:52:51 -0700 | [diff] [blame] | 81 | BinderFeatures::default(), |
| 82 | ) |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 83 | } |
| 84 | |
Victor Hsieh | 4563623 | 2021-10-15 17:52:51 -0700 | [diff] [blame] | 85 | /// Handles the requesting file `id` with `handle_fn` if it is in the FD pool. This function |
| 86 | /// returns whatever `handle_fn` returns. |
| 87 | fn handle_fd<F, R>(&self, id: i32, handle_fn: F) -> BinderResult<R> |
Victor Hsieh | c85e4ef | 2021-10-18 15:28:53 -0700 | [diff] [blame] | 88 | where |
| 89 | F: FnOnce(&FdConfig) -> BinderResult<R>, |
| 90 | { |
Victor Hsieh | bf944d7 | 2022-03-07 23:46:43 +0000 | [diff] [blame] | 91 | let fd_pool = self.fd_pool.read().unwrap(); |
Victor Hsieh | 4563623 | 2021-10-15 17:52:51 -0700 | [diff] [blame] | 92 | let fd_config = fd_pool.get(&id).ok_or_else(|| new_errno_error(Errno::EBADF))?; |
| 93 | handle_fn(fd_config) |
| 94 | } |
| 95 | |
| 96 | /// Inserts a new FD and corresponding `FdConfig` created by `create_fn` to the FD pool, then |
| 97 | /// returns the new FD number. |
| 98 | fn insert_new_fd<F>(&self, fd: i32, create_fn: F) -> BinderResult<i32> |
| 99 | where |
| 100 | F: FnOnce(&mut FdConfig) -> BinderResult<(i32, FdConfig)>, |
| 101 | { |
Victor Hsieh | bf944d7 | 2022-03-07 23:46:43 +0000 | [diff] [blame] | 102 | let mut fd_pool = self.fd_pool.write().unwrap(); |
Chris Wailes | 641fc4a | 2021-12-01 15:03:21 -0800 | [diff] [blame] | 103 | let fd_config = fd_pool.get_mut(&fd).ok_or_else(|| new_errno_error(Errno::EBADF))?; |
| 104 | let (new_fd, new_fd_config) = create_fn(fd_config)?; |
Victor Hsieh | 4563623 | 2021-10-15 17:52:51 -0700 | [diff] [blame] | 105 | if let btree_map::Entry::Vacant(entry) = fd_pool.entry(new_fd) { |
| 106 | entry.insert(new_fd_config); |
| 107 | Ok(new_fd) |
| 108 | } else { |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 109 | Err(Status::new_exception_str( |
Victor Hsieh | 4563623 | 2021-10-15 17:52:51 -0700 | [diff] [blame] | 110 | ExceptionCode::ILLEGAL_STATE, |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 111 | Some(format!( |
| 112 | "The newly created FD {} is already in the pool unexpectedly", |
| 113 | new_fd |
| 114 | )), |
Victor Hsieh | 4563623 | 2021-10-15 17:52:51 -0700 | [diff] [blame] | 115 | )) |
| 116 | } |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 117 | } |
| 118 | } |
| 119 | |
| 120 | impl Interface for FdService {} |
| 121 | |
| 122 | impl IVirtFdService for FdService { |
| 123 | fn readFile(&self, id: i32, offset: i64, size: i32) -> BinderResult<Vec<u8>> { |
| 124 | let size: usize = validate_and_cast_size(size)?; |
| 125 | let offset: u64 = validate_and_cast_offset(offset)?; |
| 126 | |
Victor Hsieh | c85e4ef | 2021-10-18 15:28:53 -0700 | [diff] [blame] | 127 | self.handle_fd(id, |config| match config { |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 128 | FdConfig::Readonly { file, .. } | FdConfig::ReadWrite(file) => { |
| 129 | read_into_buf(file, size, offset).map_err(|e| { |
| 130 | error!("readFile: read error: {}", e); |
Victor Hsieh | be8b08d | 2021-10-29 16:31:24 -0700 | [diff] [blame] | 131 | new_errno_error(Errno::EIO) |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 132 | }) |
| 133 | } |
Victor Hsieh | 559b927 | 2021-11-08 15:15:14 -0800 | [diff] [blame] | 134 | FdConfig::InputDir(_) | FdConfig::OutputDir(_) => Err(new_errno_error(Errno::EISDIR)), |
Victor Hsieh | c85e4ef | 2021-10-18 15:28:53 -0700 | [diff] [blame] | 135 | }) |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 136 | } |
| 137 | |
| 138 | fn readFsverityMerkleTree(&self, id: i32, offset: i64, size: i32) -> BinderResult<Vec<u8>> { |
| 139 | let size: usize = validate_and_cast_size(size)?; |
| 140 | let offset: u64 = validate_and_cast_offset(offset)?; |
| 141 | |
Victor Hsieh | c85e4ef | 2021-10-18 15:28:53 -0700 | [diff] [blame] | 142 | self.handle_fd(id, |config| match config { |
Inseob Kim | c0886c2 | 2021-12-13 17:41:24 +0900 | [diff] [blame] | 143 | FdConfig::Readonly { file, alt_metadata, .. } => { |
| 144 | let mut buf = vec![0; size]; |
| 145 | |
| 146 | let s = if let Some(metadata) = &alt_metadata { |
| 147 | metadata.read_merkle_tree(offset, &mut buf).map_err(|e| { |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 148 | error!("readFsverityMerkleTree: read error: {}", e); |
Victor Hsieh | be8b08d | 2021-10-29 16:31:24 -0700 | [diff] [blame] | 149 | new_errno_error(Errno::EIO) |
Inseob Kim | c0886c2 | 2021-12-13 17:41:24 +0900 | [diff] [blame] | 150 | })? |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 151 | } else { |
Inseob Kim | c0886c2 | 2021-12-13 17:41:24 +0900 | [diff] [blame] | 152 | fsverity::read_merkle_tree(file.as_raw_fd(), offset, &mut buf).map_err(|e| { |
| 153 | error!("readFsverityMerkleTree: failed to retrieve merkle tree: {}", e); |
| 154 | new_errno_error(Errno::EIO) |
| 155 | })? |
| 156 | }; |
| 157 | debug_assert!(s <= buf.len(), "Shouldn't return more bytes than asked"); |
| 158 | buf.truncate(s); |
| 159 | Ok(buf) |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 160 | } |
| 161 | FdConfig::ReadWrite(_file) => { |
| 162 | // For a writable file, Merkle tree is not expected to be served since Auth FS |
| 163 | // doesn't trust it anyway. Auth FS may keep the Merkle tree privately for its own |
| 164 | // use. |
Victor Hsieh | be8b08d | 2021-10-29 16:31:24 -0700 | [diff] [blame] | 165 | Err(new_errno_error(Errno::ENOSYS)) |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 166 | } |
Victor Hsieh | 559b927 | 2021-11-08 15:15:14 -0800 | [diff] [blame] | 167 | FdConfig::InputDir(_) | FdConfig::OutputDir(_) => Err(new_errno_error(Errno::EISDIR)), |
Victor Hsieh | c85e4ef | 2021-10-18 15:28:53 -0700 | [diff] [blame] | 168 | }) |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 169 | } |
| 170 | |
| 171 | fn readFsveritySignature(&self, id: i32) -> BinderResult<Vec<u8>> { |
Victor Hsieh | c85e4ef | 2021-10-18 15:28:53 -0700 | [diff] [blame] | 172 | self.handle_fd(id, |config| match config { |
Inseob Kim | c0886c2 | 2021-12-13 17:41:24 +0900 | [diff] [blame] | 173 | FdConfig::Readonly { file, alt_metadata, .. } => { |
| 174 | if let Some(metadata) = &alt_metadata { |
| 175 | if let Some(signature) = &metadata.signature { |
| 176 | Ok(signature.clone()) |
| 177 | } else { |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 178 | Err(Status::new_service_specific_error_str( |
| 179 | -1, |
| 180 | Some("metadata doesn't contain a signature"), |
Inseob Kim | c0886c2 | 2021-12-13 17:41:24 +0900 | [diff] [blame] | 181 | )) |
| 182 | } |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 183 | } else { |
| 184 | let mut buf = vec![0; MAX_REQUESTING_DATA as usize]; |
| 185 | let s = fsverity::read_signature(file.as_raw_fd(), &mut buf).map_err(|e| { |
| 186 | error!("readFsverityMerkleTree: failed to retrieve merkle tree: {}", e); |
Victor Hsieh | be8b08d | 2021-10-29 16:31:24 -0700 | [diff] [blame] | 187 | new_errno_error(Errno::EIO) |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 188 | })?; |
| 189 | debug_assert!(s <= buf.len(), "Shouldn't return more bytes than asked"); |
| 190 | buf.truncate(s); |
| 191 | Ok(buf) |
| 192 | } |
| 193 | } |
| 194 | FdConfig::ReadWrite(_file) => { |
| 195 | // There is no signature for a writable file. |
Victor Hsieh | be8b08d | 2021-10-29 16:31:24 -0700 | [diff] [blame] | 196 | Err(new_errno_error(Errno::ENOSYS)) |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 197 | } |
Victor Hsieh | 559b927 | 2021-11-08 15:15:14 -0800 | [diff] [blame] | 198 | FdConfig::InputDir(_) | FdConfig::OutputDir(_) => Err(new_errno_error(Errno::EISDIR)), |
Victor Hsieh | c85e4ef | 2021-10-18 15:28:53 -0700 | [diff] [blame] | 199 | }) |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 200 | } |
| 201 | |
| 202 | fn writeFile(&self, id: i32, buf: &[u8], offset: i64) -> BinderResult<i32> { |
Victor Hsieh | c85e4ef | 2021-10-18 15:28:53 -0700 | [diff] [blame] | 203 | self.handle_fd(id, |config| match config { |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 204 | FdConfig::Readonly { .. } => Err(StatusCode::INVALID_OPERATION.into()), |
| 205 | FdConfig::ReadWrite(file) => { |
Victor Hsieh | be8b08d | 2021-10-29 16:31:24 -0700 | [diff] [blame] | 206 | let offset: u64 = offset.try_into().map_err(|_| new_errno_error(Errno::EINVAL))?; |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 207 | // Check buffer size just to make `as i32` safe below. |
| 208 | if buf.len() > i32::MAX as usize { |
Victor Hsieh | be8b08d | 2021-10-29 16:31:24 -0700 | [diff] [blame] | 209 | return Err(new_errno_error(Errno::EOVERFLOW)); |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 210 | } |
| 211 | Ok(file.write_at(buf, offset).map_err(|e| { |
| 212 | error!("writeFile: write error: {}", e); |
Victor Hsieh | be8b08d | 2021-10-29 16:31:24 -0700 | [diff] [blame] | 213 | new_errno_error(Errno::EIO) |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 214 | })? as i32) |
| 215 | } |
Victor Hsieh | 559b927 | 2021-11-08 15:15:14 -0800 | [diff] [blame] | 216 | FdConfig::InputDir(_) | FdConfig::OutputDir(_) => Err(new_errno_error(Errno::EISDIR)), |
Victor Hsieh | c85e4ef | 2021-10-18 15:28:53 -0700 | [diff] [blame] | 217 | }) |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 218 | } |
| 219 | |
| 220 | fn resize(&self, id: i32, size: i64) -> BinderResult<()> { |
Victor Hsieh | c85e4ef | 2021-10-18 15:28:53 -0700 | [diff] [blame] | 221 | self.handle_fd(id, |config| match config { |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 222 | FdConfig::Readonly { .. } => Err(StatusCode::INVALID_OPERATION.into()), |
| 223 | FdConfig::ReadWrite(file) => { |
| 224 | if size < 0 { |
Victor Hsieh | be8b08d | 2021-10-29 16:31:24 -0700 | [diff] [blame] | 225 | return Err(new_errno_error(Errno::EINVAL)); |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 226 | } |
| 227 | file.set_len(size as u64).map_err(|e| { |
| 228 | error!("resize: set_len error: {}", e); |
Victor Hsieh | be8b08d | 2021-10-29 16:31:24 -0700 | [diff] [blame] | 229 | new_errno_error(Errno::EIO) |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 230 | }) |
| 231 | } |
Victor Hsieh | 559b927 | 2021-11-08 15:15:14 -0800 | [diff] [blame] | 232 | FdConfig::InputDir(_) | FdConfig::OutputDir(_) => Err(new_errno_error(Errno::EISDIR)), |
Victor Hsieh | c85e4ef | 2021-10-18 15:28:53 -0700 | [diff] [blame] | 233 | }) |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 234 | } |
| 235 | |
| 236 | fn getFileSize(&self, id: i32) -> BinderResult<i64> { |
Victor Hsieh | c85e4ef | 2021-10-18 15:28:53 -0700 | [diff] [blame] | 237 | self.handle_fd(id, |config| match config { |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 238 | FdConfig::Readonly { file, .. } => { |
| 239 | let size = file |
| 240 | .metadata() |
| 241 | .map_err(|e| { |
| 242 | error!("getFileSize error: {}", e); |
Victor Hsieh | be8b08d | 2021-10-29 16:31:24 -0700 | [diff] [blame] | 243 | new_errno_error(Errno::EIO) |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 244 | })? |
| 245 | .len(); |
| 246 | Ok(size.try_into().map_err(|e| { |
| 247 | error!("getFileSize: File too large: {}", e); |
Victor Hsieh | be8b08d | 2021-10-29 16:31:24 -0700 | [diff] [blame] | 248 | new_errno_error(Errno::EFBIG) |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 249 | })?) |
| 250 | } |
| 251 | FdConfig::ReadWrite(_file) => { |
| 252 | // Content and metadata of a writable file needs to be tracked by authfs, since |
| 253 | // fd_server isn't considered trusted. So there is no point to support getFileSize |
| 254 | // for a writable file. |
Victor Hsieh | be8b08d | 2021-10-29 16:31:24 -0700 | [diff] [blame] | 255 | Err(new_errno_error(Errno::ENOSYS)) |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 256 | } |
Victor Hsieh | 559b927 | 2021-11-08 15:15:14 -0800 | [diff] [blame] | 257 | FdConfig::InputDir(_) | FdConfig::OutputDir(_) => Err(new_errno_error(Errno::EISDIR)), |
| 258 | }) |
| 259 | } |
| 260 | |
Victor Hsieh | dd99b46 | 2021-12-02 17:36:15 -0800 | [diff] [blame] | 261 | fn openFileInDirectory(&self, dir_fd: i32, file_path: &str) -> BinderResult<i32> { |
Victor Hsieh | 559b927 | 2021-11-08 15:15:14 -0800 | [diff] [blame] | 262 | let path_buf = PathBuf::from(file_path); |
| 263 | // Checks if the path is a simple, related path. |
| 264 | if path_buf.components().any(|c| !matches!(c, Component::Normal(_))) { |
| 265 | return Err(new_errno_error(Errno::EINVAL)); |
| 266 | } |
| 267 | |
Victor Hsieh | dd99b46 | 2021-12-02 17:36:15 -0800 | [diff] [blame] | 268 | self.insert_new_fd(dir_fd, |config| match config { |
Victor Hsieh | 559b927 | 2021-11-08 15:15:14 -0800 | [diff] [blame] | 269 | FdConfig::InputDir(dir) => { |
| 270 | let file = open_readonly_at(dir.as_raw_fd(), &path_buf).map_err(new_errno_error)?; |
| 271 | |
Inseob Kim | c0886c2 | 2021-12-13 17:41:24 +0900 | [diff] [blame] | 272 | let metadata_path_buf = get_fsverity_metadata_path(&path_buf); |
| 273 | let metadata = open_readonly_at(dir.as_raw_fd(), &metadata_path_buf) |
| 274 | .ok() |
| 275 | .and_then(|f| parse_fsverity_metadata(f).ok()); |
| 276 | |
| 277 | Ok((file.as_raw_fd(), FdConfig::Readonly { file, alt_metadata: metadata })) |
Victor Hsieh | 559b927 | 2021-11-08 15:15:14 -0800 | [diff] [blame] | 278 | } |
| 279 | FdConfig::OutputDir(_) => { |
| 280 | Err(new_errno_error(Errno::ENOSYS)) // TODO: Implement when needed |
| 281 | } |
| 282 | _ => Err(new_errno_error(Errno::ENOTDIR)), |
Victor Hsieh | 4563623 | 2021-10-15 17:52:51 -0700 | [diff] [blame] | 283 | }) |
| 284 | } |
| 285 | |
Victor Hsieh | f393a72 | 2021-12-08 13:04:27 -0800 | [diff] [blame] | 286 | fn createFileInDirectory(&self, dir_fd: i32, basename: &str, mode: i32) -> BinderResult<i32> { |
Victor Hsieh | dd99b46 | 2021-12-02 17:36:15 -0800 | [diff] [blame] | 287 | validate_basename(basename)?; |
| 288 | |
| 289 | self.insert_new_fd(dir_fd, |config| match config { |
Victor Hsieh | 559b927 | 2021-11-08 15:15:14 -0800 | [diff] [blame] | 290 | FdConfig::InputDir(_) => Err(new_errno_error(Errno::EACCES)), |
Victor Hsieh | 4563623 | 2021-10-15 17:52:51 -0700 | [diff] [blame] | 291 | FdConfig::OutputDir(dir) => { |
Victor Hsieh | f393a72 | 2021-12-08 13:04:27 -0800 | [diff] [blame] | 292 | let mode = validate_file_mode(mode)?; |
Victor Hsieh | 4563623 | 2021-10-15 17:52:51 -0700 | [diff] [blame] | 293 | let new_fd = openat( |
| 294 | dir.as_raw_fd(), |
| 295 | basename, |
Victor Hsieh | 928d503 | 2022-02-15 00:06:20 +0000 | [diff] [blame] | 296 | // This function is supposed to be only called when FUSE/authfs thinks the file |
| 297 | // does not exist. However, if the file does exist from the view of fd_server |
| 298 | // (where the execution context is considered untrusted), we prefer to honor |
| 299 | // authfs and still allow the create to success. Therefore, always use O_TRUNC. |
Victor Hsieh | 4563623 | 2021-10-15 17:52:51 -0700 | [diff] [blame] | 300 | OFlag::O_CREAT | OFlag::O_RDWR | OFlag::O_TRUNC, |
Victor Hsieh | f393a72 | 2021-12-08 13:04:27 -0800 | [diff] [blame] | 301 | mode, |
Victor Hsieh | 4563623 | 2021-10-15 17:52:51 -0700 | [diff] [blame] | 302 | ) |
| 303 | .map_err(new_errno_error)?; |
| 304 | // SAFETY: new_fd is just created and not an error. |
| 305 | let new_file = unsafe { File::from_raw_fd(new_fd) }; |
| 306 | Ok((new_fd, FdConfig::ReadWrite(new_file))) |
| 307 | } |
| 308 | _ => Err(new_errno_error(Errno::ENOTDIR)), |
| 309 | }) |
| 310 | } |
| 311 | |
Victor Hsieh | f393a72 | 2021-12-08 13:04:27 -0800 | [diff] [blame] | 312 | fn createDirectoryInDirectory( |
| 313 | &self, |
| 314 | dir_fd: i32, |
| 315 | basename: &str, |
| 316 | mode: i32, |
| 317 | ) -> BinderResult<i32> { |
Victor Hsieh | dd99b46 | 2021-12-02 17:36:15 -0800 | [diff] [blame] | 318 | validate_basename(basename)?; |
| 319 | |
Victor Hsieh | 4563623 | 2021-10-15 17:52:51 -0700 | [diff] [blame] | 320 | self.insert_new_fd(dir_fd, |config| match config { |
Victor Hsieh | 559b927 | 2021-11-08 15:15:14 -0800 | [diff] [blame] | 321 | FdConfig::InputDir(_) => Err(new_errno_error(Errno::EACCES)), |
Victor Hsieh | 4563623 | 2021-10-15 17:52:51 -0700 | [diff] [blame] | 322 | FdConfig::OutputDir(_) => { |
Victor Hsieh | f393a72 | 2021-12-08 13:04:27 -0800 | [diff] [blame] | 323 | let mode = validate_file_mode(mode)?; |
| 324 | mkdirat(dir_fd, basename, mode).map_err(new_errno_error)?; |
Victor Hsieh | bf944d7 | 2022-03-07 23:46:43 +0000 | [diff] [blame] | 325 | let new_dir_fd = |
| 326 | openat(dir_fd, basename, OFlag::O_DIRECTORY | OFlag::O_RDONLY, Mode::empty()) |
| 327 | .map_err(new_errno_error)?; |
| 328 | // SAFETY: new_dir_fd is just created and not an error. |
| 329 | let fd_owner = unsafe { OwnedFd::from_raw_fd(new_dir_fd) }; |
| 330 | Ok((new_dir_fd, FdConfig::OutputDir(fd_owner))) |
Victor Hsieh | 4563623 | 2021-10-15 17:52:51 -0700 | [diff] [blame] | 331 | } |
| 332 | _ => Err(new_errno_error(Errno::ENOTDIR)), |
Victor Hsieh | c85e4ef | 2021-10-18 15:28:53 -0700 | [diff] [blame] | 333 | }) |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 334 | } |
Victor Hsieh | f7fc3d3 | 2021-11-22 10:20:33 -0800 | [diff] [blame] | 335 | |
Victor Hsieh | dd99b46 | 2021-12-02 17:36:15 -0800 | [diff] [blame] | 336 | fn deleteFile(&self, dir_fd: i32, basename: &str) -> BinderResult<()> { |
| 337 | validate_basename(basename)?; |
| 338 | |
| 339 | self.handle_fd(dir_fd, |config| match config { |
Victor Hsieh | bf944d7 | 2022-03-07 23:46:43 +0000 | [diff] [blame] | 340 | FdConfig::OutputDir(_) => { |
Victor Hsieh | dd99b46 | 2021-12-02 17:36:15 -0800 | [diff] [blame] | 341 | unlinkat(Some(dir_fd), basename, UnlinkatFlags::NoRemoveDir) |
| 342 | .map_err(new_errno_error)?; |
| 343 | Ok(()) |
| 344 | } |
| 345 | FdConfig::InputDir(_) => Err(new_errno_error(Errno::EACCES)), |
| 346 | _ => Err(new_errno_error(Errno::ENOTDIR)), |
| 347 | }) |
| 348 | } |
| 349 | |
| 350 | fn deleteDirectory(&self, dir_fd: i32, basename: &str) -> BinderResult<()> { |
| 351 | validate_basename(basename)?; |
| 352 | |
| 353 | self.handle_fd(dir_fd, |config| match config { |
Victor Hsieh | bf944d7 | 2022-03-07 23:46:43 +0000 | [diff] [blame] | 354 | FdConfig::OutputDir(_) => { |
Victor Hsieh | dd99b46 | 2021-12-02 17:36:15 -0800 | [diff] [blame] | 355 | unlinkat(Some(dir_fd), basename, UnlinkatFlags::RemoveDir) |
| 356 | .map_err(new_errno_error)?; |
| 357 | Ok(()) |
| 358 | } |
| 359 | FdConfig::InputDir(_) => Err(new_errno_error(Errno::EACCES)), |
| 360 | _ => Err(new_errno_error(Errno::ENOTDIR)), |
| 361 | }) |
| 362 | } |
| 363 | |
Victor Hsieh | f393a72 | 2021-12-08 13:04:27 -0800 | [diff] [blame] | 364 | fn chmod(&self, fd: i32, mode: i32) -> BinderResult<()> { |
| 365 | self.handle_fd(fd, |config| match config { |
| 366 | FdConfig::ReadWrite(_) | FdConfig::OutputDir(_) => { |
| 367 | let mode = validate_file_mode(mode)?; |
| 368 | fchmod(fd, mode).map_err(new_errno_error) |
| 369 | } |
| 370 | _ => Err(new_errno_error(Errno::EACCES)), |
| 371 | }) |
| 372 | } |
| 373 | |
Victor Hsieh | f7fc3d3 | 2021-11-22 10:20:33 -0800 | [diff] [blame] | 374 | fn statfs(&self) -> BinderResult<FsStat> { |
| 375 | let st = statvfs("/data").map_err(new_errno_error)?; |
| 376 | try_into_fs_stat(st).map_err(|_e| new_errno_error(Errno::EINVAL)) |
| 377 | } |
| 378 | } |
| 379 | |
| 380 | fn try_into_fs_stat(st: Statvfs) -> Result<FsStat, std::num::TryFromIntError> { |
| 381 | Ok(FsStat { |
| 382 | blockSize: st.block_size().try_into()?, |
| 383 | fragmentSize: st.fragment_size().try_into()?, |
| 384 | blockNumbers: st.blocks().try_into()?, |
| 385 | blockAvailable: st.blocks_available().try_into()?, |
| 386 | inodesAvailable: st.files_available().try_into()?, |
| 387 | maxFilename: st.name_max().try_into()?, |
| 388 | }) |
Victor Hsieh | b0f5fc8 | 2021-10-15 17:24:19 -0700 | [diff] [blame] | 389 | } |
| 390 | |
| 391 | fn read_into_buf(file: &File, max_size: usize, offset: u64) -> io::Result<Vec<u8>> { |
| 392 | let remaining = file.metadata()?.len().saturating_sub(offset); |
| 393 | let buf_size = min(remaining, max_size as u64) as usize; |
| 394 | let mut buf = vec![0; buf_size]; |
| 395 | file.read_exact_at(&mut buf, offset)?; |
| 396 | Ok(buf) |
| 397 | } |
Victor Hsieh | be8b08d | 2021-10-29 16:31:24 -0700 | [diff] [blame] | 398 | |
| 399 | fn new_errno_error(errno: Errno) -> Status { |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 400 | Status::new_service_specific_error_str(errno as i32, Some(errno.desc())) |
Victor Hsieh | be8b08d | 2021-10-29 16:31:24 -0700 | [diff] [blame] | 401 | } |
Victor Hsieh | 559b927 | 2021-11-08 15:15:14 -0800 | [diff] [blame] | 402 | |
| 403 | fn open_readonly_at(dir_fd: RawFd, path: &Path) -> nix::Result<File> { |
| 404 | let new_fd = openat(dir_fd, path, OFlag::O_RDONLY, Mode::empty())?; |
| 405 | // SAFETY: new_fd is just created successfully and not owned. |
| 406 | let new_file = unsafe { File::from_raw_fd(new_fd) }; |
| 407 | Ok(new_file) |
| 408 | } |
Victor Hsieh | dd99b46 | 2021-12-02 17:36:15 -0800 | [diff] [blame] | 409 | |
Victor Hsieh | f393a72 | 2021-12-08 13:04:27 -0800 | [diff] [blame] | 410 | fn validate_and_cast_offset(offset: i64) -> Result<u64, Status> { |
| 411 | offset.try_into().map_err(|_| new_errno_error(Errno::EINVAL)) |
| 412 | } |
| 413 | |
| 414 | fn validate_and_cast_size(size: i32) -> Result<usize, Status> { |
| 415 | if size > MAX_REQUESTING_DATA { |
| 416 | Err(new_errno_error(Errno::EFBIG)) |
| 417 | } else { |
| 418 | size.try_into().map_err(|_| new_errno_error(Errno::EINVAL)) |
| 419 | } |
| 420 | } |
| 421 | |
Victor Hsieh | dd99b46 | 2021-12-02 17:36:15 -0800 | [diff] [blame] | 422 | fn validate_basename(name: &str) -> BinderResult<()> { |
| 423 | if name.contains(MAIN_SEPARATOR) { |
| 424 | Err(new_errno_error(Errno::EINVAL)) |
| 425 | } else { |
| 426 | Ok(()) |
| 427 | } |
| 428 | } |
Victor Hsieh | f393a72 | 2021-12-08 13:04:27 -0800 | [diff] [blame] | 429 | |
| 430 | fn validate_file_mode(mode: i32) -> BinderResult<Mode> { |
| 431 | let mode = Mode::from_bits(mode as mode_t).ok_or_else(|| new_errno_error(Errno::EINVAL))?; |
| 432 | if mode.intersects(FORBIDDEN_MODES) { |
| 433 | Err(new_errno_error(Errno::EPERM)) |
| 434 | } else { |
| 435 | Ok(mode) |
| 436 | } |
| 437 | } |