Andrew Walbran | 68a8c16 | 2022-03-07 15:38:42 +0000 | [diff] [blame] | 1 | // Copyright 2022, The Android Open Source Project |
| 2 | // |
| 3 | // Licensed under the Apache License, Version 2.0 (the "License"); |
| 4 | // you may not use this file except in compliance with the License. |
| 5 | // You may obtain a copy of the License at |
| 6 | // |
| 7 | // http://www.apache.org/licenses/LICENSE-2.0 |
| 8 | // |
| 9 | // Unless required by applicable law or agreed to in writing, software |
| 10 | // distributed under the License is distributed on an "AS IS" BASIS, |
| 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 12 | // See the License for the specific language governing permissions and |
| 13 | // limitations under the License. |
| 14 | |
| 15 | //! pVM firmware. |
| 16 | |
| 17 | #![no_main] |
| 18 | #![no_std] |
| 19 | |
Pierre-Clément Tosi | db74cb1 | 2022-12-08 13:56:25 +0000 | [diff] [blame] | 20 | extern crate alloc; |
| 21 | |
Alan Stokes | 4db76eb | 2023-04-26 14:28:15 +0100 | [diff] [blame] | 22 | mod bcc; |
Jiyong Park | c5d2ef2 | 2023-04-11 01:23:46 +0900 | [diff] [blame] | 23 | mod bootargs; |
Pierre-Clément Tosi | 20b6096 | 2022-10-17 13:35:27 +0100 | [diff] [blame] | 24 | mod config; |
Jaewan Kim | c6e023b | 2023-10-12 15:11:05 +0900 | [diff] [blame] | 25 | mod device_assignment; |
Pierre-Clément Tosi | 4f4f5eb | 2022-12-08 14:31:42 +0000 | [diff] [blame] | 26 | mod dice; |
Pierre-Clément Tosi | 5bbfca5 | 2022-10-21 12:14:35 +0100 | [diff] [blame] | 27 | mod entry; |
Andrew Walbran | dfb7337 | 2022-04-21 10:52:27 +0000 | [diff] [blame] | 28 | mod exceptions; |
Pierre-Clément Tosi | a0934c1 | 2022-11-25 20:54:11 +0000 | [diff] [blame] | 29 | mod fdt; |
Pierre-Clément Tosi | 1cc5eb7 | 2023-02-02 11:09:18 +0000 | [diff] [blame] | 30 | mod gpt; |
Pierre-Clément Tosi | 1cc5eb7 | 2023-02-02 11:09:18 +0000 | [diff] [blame] | 31 | mod instance; |
Pierre-Clément Tosi | a0934c1 | 2022-11-25 20:54:11 +0000 | [diff] [blame] | 32 | mod memory; |
Pierre-Clément Tosi | 10bea6f | 2024-11-26 22:04:10 +0000 | [diff] [blame] | 33 | mod rollback; |
Andrew Walbran | 68a8c16 | 2022-03-07 15:38:42 +0000 | [diff] [blame] | 34 | |
Alan Stokes | 4db76eb | 2023-04-26 14:28:15 +0100 | [diff] [blame] | 35 | use crate::bcc::Bcc; |
Pierre-Clément Tosi | 4ba7966 | 2023-02-13 11:22:41 +0000 | [diff] [blame] | 36 | use crate::dice::PartialInputs; |
| 37 | use crate::entry::RebootReason; |
Pierre-Clément Tosi | 9277880 | 2024-11-19 17:36:14 +0000 | [diff] [blame] | 38 | use crate::fdt::{modify_for_next_stage, sanitize_device_tree}; |
Pierre-Clément Tosi | 10bea6f | 2024-11-26 22:04:10 +0000 | [diff] [blame] | 39 | use crate::rollback::perform_rollback_protection; |
Alan Stokes | 7f27c0d | 2023-09-07 16:22:58 +0100 | [diff] [blame] | 40 | use alloc::borrow::Cow; |
Alan Stokes | 4db76eb | 2023-04-26 14:28:15 +0100 | [diff] [blame] | 41 | use alloc::boxed::Box; |
Shikha Panwar | 73ba0d4 | 2024-03-20 14:43:21 +0000 | [diff] [blame] | 42 | use bssl_avf::Digester; |
Shikha Panwar | 73ba0d4 | 2024-03-20 14:43:21 +0000 | [diff] [blame] | 43 | use cstr::cstr; |
Alice Wang | 87fbc4b | 2024-11-05 13:09:58 +0000 | [diff] [blame] | 44 | use diced_open_dice::{bcc_handover_parse, DiceArtifacts, DiceContext, Hidden, VM_KEY_ALGORITHM}; |
Shikha Panwar | 73ba0d4 | 2024-03-20 14:43:21 +0000 | [diff] [blame] | 45 | use libfdt::{Fdt, FdtNode}; |
Alan Stokes | 4db76eb | 2023-04-26 14:28:15 +0100 | [diff] [blame] | 46 | use log::{debug, error, info, trace, warn}; |
Pierre-Clément Tosi | 2d65298 | 2023-01-09 19:30:17 +0000 | [diff] [blame] | 47 | use pvmfw_avb::verify_payload; |
Jiyong Park | c5d2ef2 | 2023-04-11 01:23:46 +0900 | [diff] [blame] | 48 | use pvmfw_avb::DebugLevel; |
Alice Wang | 0aa3032 | 2023-01-31 11:00:10 +0000 | [diff] [blame] | 49 | use pvmfw_embedded_key::PUBLIC_KEY; |
Pierre-Clément Tosi | f2c19d4 | 2024-10-01 17:42:04 +0100 | [diff] [blame] | 50 | use vmbase::fdt::pci::{PciError, PciInfo}; |
Pierre-Clément Tosi | c332fae | 2023-06-22 11:37:12 +0000 | [diff] [blame] | 51 | use vmbase::heap; |
Pierre-Clément Tosi | 938b4fb | 2024-11-26 12:59:47 +0000 | [diff] [blame] | 52 | use vmbase::memory::{flush, init_shared_pool, SIZE_4KB}; |
Pierre-Clément Tosi | 8025197 | 2023-07-12 12:51:12 +0000 | [diff] [blame] | 53 | use vmbase::rand; |
Alice Wang | eade167 | 2023-06-08 14:56:20 +0000 | [diff] [blame] | 54 | use vmbase::virtio::pci; |
Andrew Walbran | 68a8c16 | 2022-03-07 15:38:42 +0000 | [diff] [blame] | 55 | |
Pierre-Clément Tosi | bfa4060 | 2024-12-09 20:13:57 +0000 | [diff] [blame^] | 56 | fn main<'a>( |
Pierre-Clément Tosi | 9277880 | 2024-11-19 17:36:14 +0000 | [diff] [blame] | 57 | untrusted_fdt: &mut Fdt, |
Alice Wang | 28cbcf1 | 2022-12-01 07:58:28 +0000 | [diff] [blame] | 58 | signed_kernel: &[u8], |
| 59 | ramdisk: Option<&[u8]>, |
Alice Wang | 843d831 | 2023-02-15 09:47:06 +0000 | [diff] [blame] | 60 | current_bcc_handover: &[u8], |
Alan Stokes | 6561833 | 2023-12-15 14:09:25 +0000 | [diff] [blame] | 61 | mut debug_policy: Option<&[u8]>, |
Pierre-Clément Tosi | 9277880 | 2024-11-19 17:36:14 +0000 | [diff] [blame] | 62 | vm_dtbo: Option<&mut [u8]>, |
| 63 | vm_ref_dt: Option<&[u8]>, |
Pierre-Clément Tosi | bfa4060 | 2024-12-09 20:13:57 +0000 | [diff] [blame^] | 64 | ) -> Result<(&'a [u8], bool), RebootReason> { |
Pierre-Clément Tosi | 37105a6 | 2022-10-18 12:21:48 +0100 | [diff] [blame] | 65 | info!("pVM firmware"); |
Pierre-Clément Tosi | 9277880 | 2024-11-19 17:36:14 +0000 | [diff] [blame] | 66 | debug!("FDT: {:?}", untrusted_fdt.as_ptr()); |
Pierre-Clément Tosi | a0934c1 | 2022-11-25 20:54:11 +0000 | [diff] [blame] | 67 | debug!("Signed kernel: {:?} ({:#x} bytes)", signed_kernel.as_ptr(), signed_kernel.len()); |
Alice Wang | a78279c | 2022-12-16 12:41:19 +0000 | [diff] [blame] | 68 | debug!("AVB public key: addr={:?}, size={:#x} ({1})", PUBLIC_KEY.as_ptr(), PUBLIC_KEY.len()); |
Pierre-Clément Tosi | a0934c1 | 2022-11-25 20:54:11 +0000 | [diff] [blame] | 69 | if let Some(rd) = ramdisk { |
| 70 | debug!("Ramdisk: {:?} ({:#x} bytes)", rd.as_ptr(), rd.len()); |
| 71 | } else { |
| 72 | debug!("Ramdisk: None"); |
| 73 | } |
Alan Stokes | 4db76eb | 2023-04-26 14:28:15 +0100 | [diff] [blame] | 74 | |
Alice Wang | 843d831 | 2023-02-15 09:47:06 +0000 | [diff] [blame] | 75 | let bcc_handover = bcc_handover_parse(current_bcc_handover).map_err(|e| { |
| 76 | error!("Invalid BCC Handover: {e:?}"); |
| 77 | RebootReason::InvalidBcc |
| 78 | })?; |
| 79 | trace!("BCC: {bcc_handover:x?}"); |
Andrew Walbran | 1969063 | 2022-12-07 16:41:30 +0000 | [diff] [blame] | 80 | |
Alan Stokes | 4db76eb | 2023-04-26 14:28:15 +0100 | [diff] [blame] | 81 | let cdi_seal = bcc_handover.cdi_seal(); |
| 82 | |
| 83 | let bcc = Bcc::new(bcc_handover.bcc()).map_err(|e| { |
| 84 | error!("{e}"); |
| 85 | RebootReason::InvalidBcc |
| 86 | })?; |
| 87 | |
| 88 | // The bootloader should never pass us a debug policy when the boot is secure (the bootloader |
| 89 | // is locked). If it gets it wrong, disregard it & log it, to avoid it causing problems. |
| 90 | if debug_policy.is_some() && !bcc.is_debug_mode() { |
| 91 | warn!("Ignoring debug policy, BCC does not indicate Debug mode"); |
| 92 | debug_policy = None; |
Alan Stokes | d1ee63e | 2023-04-24 16:17:39 +0100 | [diff] [blame] | 93 | } |
| 94 | |
Alice Wang | 1f0add0 | 2023-01-23 16:22:53 +0000 | [diff] [blame] | 95 | let verified_boot_data = verify_payload(signed_kernel, ramdisk, PUBLIC_KEY).map_err(|e| { |
Pierre-Clément Tosi | 2d65298 | 2023-01-09 19:30:17 +0000 | [diff] [blame] | 96 | error!("Failed to verify the payload: {e}"); |
| 97 | RebootReason::PayloadVerificationError |
| 98 | })?; |
Pierre-Clément Tosi | f90655d | 2023-06-28 11:00:17 +0000 | [diff] [blame] | 99 | let debuggable = verified_boot_data.debug_level != DebugLevel::None; |
| 100 | if debuggable { |
| 101 | info!("Successfully verified a debuggable payload."); |
| 102 | info!("Please disregard any previous libavb ERROR about initrd_normal."); |
| 103 | } |
Pierre-Clément Tosi | 2d65298 | 2023-01-09 19:30:17 +0000 | [diff] [blame] | 104 | |
Pierre-Clément Tosi | 938b4fb | 2024-11-26 12:59:47 +0000 | [diff] [blame] | 105 | let guest_page_size = verified_boot_data.page_size.unwrap_or(SIZE_4KB); |
| 106 | let fdt_info = sanitize_device_tree(untrusted_fdt, vm_dtbo, vm_ref_dt, guest_page_size)?; |
Pierre-Clément Tosi | 9277880 | 2024-11-19 17:36:14 +0000 | [diff] [blame] | 107 | let fdt = untrusted_fdt; // DT has now been sanitized. |
| 108 | let pci_info = PciInfo::from_fdt(fdt).map_err(handle_pci_error)?; |
| 109 | debug!("PCI: {:#x?}", pci_info); |
| 110 | // Set up PCI bus for VirtIO devices. |
| 111 | let mut pci_root = pci::initialize(pci_info).map_err(|e| { |
| 112 | error!("Failed to initialize PCI: {e}"); |
| 113 | RebootReason::InternalError |
| 114 | })?; |
| 115 | init_shared_pool(fdt_info.swiotlb_info.fixed_range()).map_err(|e| { |
| 116 | error!("Failed to initialize shared pool: {e}"); |
| 117 | RebootReason::InternalError |
| 118 | })?; |
| 119 | |
Pierre-Clément Tosi | 938b4fb | 2024-11-26 12:59:47 +0000 | [diff] [blame] | 120 | let next_bcc_size = guest_page_size; |
| 121 | let next_bcc = heap::aligned_boxed_slice(next_bcc_size, guest_page_size).ok_or_else(|| { |
Pierre-Clément Tosi | db74cb1 | 2022-12-08 13:56:25 +0000 | [diff] [blame] | 122 | error!("Failed to allocate the next-stage BCC"); |
| 123 | RebootReason::InternalError |
| 124 | })?; |
| 125 | // By leaking the slice, its content will be left behind for the next stage. |
| 126 | let next_bcc = Box::leak(next_bcc); |
Pierre-Clément Tosi | 4f4f5eb | 2022-12-08 14:31:42 +0000 | [diff] [blame] | 127 | |
Pierre-Clément Tosi | f58f3a3 | 2023-02-02 16:24:23 +0000 | [diff] [blame] | 128 | let dice_inputs = PartialInputs::new(&verified_boot_data).map_err(|e| { |
| 129 | error!("Failed to compute partial DICE inputs: {e:?}"); |
| 130 | RebootReason::InternalError |
| 131 | })?; |
Shikha Panwar | 37490d4 | 2024-03-19 22:14:58 +0000 | [diff] [blame] | 132 | |
Shikha Panwar | 8f7fc1a | 2024-04-10 10:41:34 +0000 | [diff] [blame] | 133 | let instance_hash = if cfg!(llpvm_changes) { Some(salt_from_instance_id(fdt)?) } else { None }; |
Pierre-Clément Tosi | 10bea6f | 2024-11-26 22:04:10 +0000 | [diff] [blame] | 134 | let (new_instance, salt, defer_rollback_protection) = perform_rollback_protection( |
| 135 | fdt, |
| 136 | &verified_boot_data, |
| 137 | &dice_inputs, |
| 138 | &mut pci_root, |
| 139 | cdi_seal, |
| 140 | instance_hash, |
| 141 | )?; |
Shikha Panwar | 73ba0d4 | 2024-03-20 14:43:21 +0000 | [diff] [blame] | 142 | trace!("Got salt for instance: {salt:x?}"); |
Pierre-Clément Tosi | 1cc5eb7 | 2023-02-02 11:09:18 +0000 | [diff] [blame] | 143 | |
Alan Stokes | 7f27c0d | 2023-09-07 16:22:58 +0100 | [diff] [blame] | 144 | let new_bcc_handover = if cfg!(dice_changes) { |
| 145 | Cow::Borrowed(current_bcc_handover) |
| 146 | } else { |
| 147 | // It is possible that the DICE chain we were given is rooted in the UDS. We do not want to |
| 148 | // give such a chain to the payload, or even the associated CDIs. So remove the |
| 149 | // entire chain we were given and taint the CDIs. Note that the resulting CDIs are |
| 150 | // still deterministically derived from those we received, so will vary iff they do. |
| 151 | // TODO(b/280405545): Remove this post Android 14. |
| 152 | let truncated_bcc_handover = bcc::truncate(bcc_handover).map_err(|e| { |
| 153 | error!("{e}"); |
| 154 | RebootReason::InternalError |
| 155 | })?; |
| 156 | Cow::Owned(truncated_bcc_handover) |
| 157 | }; |
Alan Stokes | a38d3b3 | 2023-05-05 12:19:18 +0100 | [diff] [blame] | 158 | |
Alice Wang | 6823ffc | 2024-10-29 15:54:34 +0000 | [diff] [blame] | 159 | trace!("BCC leaf subject public key algorithm: {:?}", bcc.leaf_subject_pubkey().cose_alg); |
| 160 | |
Alice Wang | 87fbc4b | 2024-11-05 13:09:58 +0000 | [diff] [blame] | 161 | let dice_context = DiceContext { |
| 162 | authority_algorithm: bcc.leaf_subject_pubkey().cose_alg.try_into().map_err(|e| { |
| 163 | error!("{e}"); |
| 164 | RebootReason::InternalError |
| 165 | })?, |
| 166 | subject_algorithm: VM_KEY_ALGORITHM, |
| 167 | }; |
Shikha Panwar | ffadd4d | 2024-05-28 13:47:56 +0000 | [diff] [blame] | 168 | dice_inputs |
| 169 | .write_next_bcc( |
| 170 | new_bcc_handover.as_ref(), |
| 171 | &salt, |
| 172 | instance_hash, |
| 173 | defer_rollback_protection, |
| 174 | next_bcc, |
Alice Wang | 87fbc4b | 2024-11-05 13:09:58 +0000 | [diff] [blame] | 175 | dice_context, |
Shikha Panwar | ffadd4d | 2024-05-28 13:47:56 +0000 | [diff] [blame] | 176 | ) |
| 177 | .map_err(|e| { |
Shikha Panwar | 8f7fc1a | 2024-04-10 10:41:34 +0000 | [diff] [blame] | 178 | error!("Failed to derive next-stage DICE secrets: {e:?}"); |
| 179 | RebootReason::SecretDerivationError |
Shikha Panwar | ffadd4d | 2024-05-28 13:47:56 +0000 | [diff] [blame] | 180 | })?; |
Pierre-Clément Tosi | db74cb1 | 2022-12-08 13:56:25 +0000 | [diff] [blame] | 181 | flush(next_bcc); |
| 182 | |
Pierre-Clément Tosi | 8025197 | 2023-07-12 12:51:12 +0000 | [diff] [blame] | 183 | let kaslr_seed = u64::from_ne_bytes(rand::random_array().map_err(|e| { |
| 184 | error!("Failed to generated guest KASLR seed: {e}"); |
| 185 | RebootReason::InternalError |
| 186 | })?); |
Pierre-Clément Tosi | b2d8aa7 | 2023-02-17 15:22:50 +0000 | [diff] [blame] | 187 | let strict_boot = true; |
Pierre-Clément Tosi | 8025197 | 2023-07-12 12:51:12 +0000 | [diff] [blame] | 188 | modify_for_next_stage( |
| 189 | fdt, |
| 190 | next_bcc, |
| 191 | new_instance, |
| 192 | strict_boot, |
| 193 | debug_policy, |
| 194 | debuggable, |
| 195 | kaslr_seed, |
| 196 | ) |
| 197 | .map_err(|e| { |
| 198 | error!("Failed to configure device tree: {e}"); |
| 199 | RebootReason::InternalError |
| 200 | })?; |
Pierre-Clément Tosi | db74cb1 | 2022-12-08 13:56:25 +0000 | [diff] [blame] | 201 | |
Alice Wang | 4379c83 | 2022-12-05 15:50:20 +0000 | [diff] [blame] | 202 | info!("Starting payload..."); |
Pierre-Clément Tosi | bfa4060 | 2024-12-09 20:13:57 +0000 | [diff] [blame^] | 203 | Ok((next_bcc, debuggable)) |
Pierre-Clément Tosi | 263ffd5 | 2022-10-05 20:27:50 +0100 | [diff] [blame] | 204 | } |
Andrew Walbran | d1d0318 | 2022-12-09 18:20:01 +0000 | [diff] [blame] | 205 | |
Shikha Panwar | 73ba0d4 | 2024-03-20 14:43:21 +0000 | [diff] [blame] | 206 | // Get the "salt" which is one of the input for DICE derivation. |
| 207 | // This provides differentiation of secrets for different VM instances with same payloads. |
| 208 | fn salt_from_instance_id(fdt: &Fdt) -> Result<Hidden, RebootReason> { |
| 209 | let id = instance_id(fdt)?; |
| 210 | let salt = Digester::sha512() |
| 211 | .digest(&[&b"InstanceId:"[..], id].concat()) |
| 212 | .map_err(|e| { |
| 213 | error!("Failed to get digest of instance-id: {e}"); |
| 214 | RebootReason::InternalError |
| 215 | })? |
| 216 | .try_into() |
| 217 | .map_err(|_| RebootReason::InternalError)?; |
| 218 | Ok(salt) |
| 219 | } |
| 220 | |
| 221 | fn instance_id(fdt: &Fdt) -> Result<&[u8], RebootReason> { |
| 222 | let node = avf_untrusted_node(fdt)?; |
| 223 | let id = node.getprop(cstr!("instance-id")).map_err(|e| { |
| 224 | error!("Failed to get instance-id in DT: {e}"); |
| 225 | RebootReason::InvalidFdt |
| 226 | })?; |
| 227 | id.ok_or_else(|| { |
| 228 | error!("Missing instance-id"); |
| 229 | RebootReason::InvalidFdt |
| 230 | }) |
| 231 | } |
| 232 | |
Shikha Panwar | 73ba0d4 | 2024-03-20 14:43:21 +0000 | [diff] [blame] | 233 | fn avf_untrusted_node(fdt: &Fdt) -> Result<FdtNode, RebootReason> { |
| 234 | let node = fdt.node(cstr!("/avf/untrusted")).map_err(|e| { |
| 235 | error!("Failed to get /avf/untrusted node: {e}"); |
| 236 | RebootReason::InvalidFdt |
| 237 | })?; |
| 238 | node.ok_or_else(|| { |
| 239 | error!("/avf/untrusted node is missing in DT"); |
| 240 | RebootReason::InvalidFdt |
| 241 | }) |
| 242 | } |
| 243 | |
Andrew Walbran | d1d0318 | 2022-12-09 18:20:01 +0000 | [diff] [blame] | 244 | /// Logs the given PCI error and returns the appropriate `RebootReason`. |
| 245 | fn handle_pci_error(e: PciError) -> RebootReason { |
| 246 | error!("{}", e); |
| 247 | match e { |
| 248 | PciError::FdtErrorPci(_) |
| 249 | | PciError::FdtNoPci |
| 250 | | PciError::FdtErrorReg(_) |
| 251 | | PciError::FdtMissingReg |
| 252 | | PciError::FdtRegEmpty |
| 253 | | PciError::FdtRegMissingSize |
| 254 | | PciError::CamWrongSize(_) |
| 255 | | PciError::FdtErrorRanges(_) |
| 256 | | PciError::FdtMissingRanges |
| 257 | | PciError::RangeAddressMismatch { .. } |
| 258 | | PciError::NoSuitableRange => RebootReason::InvalidFdt, |
Andrew Walbran | d1d0318 | 2022-12-09 18:20:01 +0000 | [diff] [blame] | 259 | } |
| 260 | } |