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 | da4440a | 2022-08-22 18:06:32 +0100 | [diff] [blame] | 31 | mod helpers; |
Pierre-Clément Tosi | 1cc5eb7 | 2023-02-02 11:09:18 +0000 | [diff] [blame] | 32 | mod instance; |
Pierre-Clément Tosi | a0934c1 | 2022-11-25 20:54:11 +0000 | [diff] [blame] | 33 | mod memory; |
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; |
| 38 | use crate::fdt::modify_for_next_stage; |
Pierre-Clément Tosi | 4ba7966 | 2023-02-13 11:22:41 +0000 | [diff] [blame] | 39 | use crate::helpers::GUEST_PAGE_SIZE; |
Pierre-Clément Tosi | 1cc5eb7 | 2023-02-02 11:09:18 +0000 | [diff] [blame] | 40 | use crate::instance::get_or_generate_instance_salt; |
Alan Stokes | 7f27c0d | 2023-09-07 16:22:58 +0100 | [diff] [blame] | 41 | use alloc::borrow::Cow; |
Alan Stokes | 4db76eb | 2023-04-26 14:28:15 +0100 | [diff] [blame] | 42 | use alloc::boxed::Box; |
| 43 | use core::ops::Range; |
Alan Stokes | c4354b8 | 2023-05-04 16:06:52 +0100 | [diff] [blame] | 44 | use diced_open_dice::{bcc_handover_parse, DiceArtifacts}; |
Andrew Walbran | 730375d | 2022-12-21 14:04:34 +0000 | [diff] [blame] | 45 | use fdtpci::{PciError, PciInfo}; |
Andrew Walbran | 1969063 | 2022-12-07 16:41:30 +0000 | [diff] [blame] | 46 | use libfdt::Fdt; |
Alan Stokes | 4db76eb | 2023-04-26 14:28:15 +0100 | [diff] [blame] | 47 | use log::{debug, error, info, trace, warn}; |
Pierre-Clément Tosi | 2d65298 | 2023-01-09 19:30:17 +0000 | [diff] [blame] | 48 | use pvmfw_avb::verify_payload; |
Alice Wang | ab0d020 | 2023-05-17 08:07:41 +0000 | [diff] [blame] | 49 | use pvmfw_avb::Capability; |
Jiyong Park | c5d2ef2 | 2023-04-11 01:23:46 +0900 | [diff] [blame] | 50 | use pvmfw_avb::DebugLevel; |
Alice Wang | 0aa3032 | 2023-01-31 11:00:10 +0000 | [diff] [blame] | 51 | use pvmfw_embedded_key::PUBLIC_KEY; |
Pierre-Clément Tosi | c332fae | 2023-06-22 11:37:12 +0000 | [diff] [blame] | 52 | use vmbase::heap; |
Alice Wang | 3fa9b80 | 2023-06-06 07:52:31 +0000 | [diff] [blame] | 53 | use vmbase::memory::flush; |
Alice Wang | 93ee98a | 2023-06-08 08:20:39 +0000 | [diff] [blame] | 54 | use vmbase::memory::MEMORY; |
Pierre-Clément Tosi | 8025197 | 2023-07-12 12:51:12 +0000 | [diff] [blame] | 55 | use vmbase::rand; |
Alice Wang | eade167 | 2023-06-08 14:56:20 +0000 | [diff] [blame] | 56 | use vmbase::virtio::pci; |
Andrew Walbran | 68a8c16 | 2022-03-07 15:38:42 +0000 | [diff] [blame] | 57 | |
Pierre-Clément Tosi | 4f4f5eb | 2022-12-08 14:31:42 +0000 | [diff] [blame] | 58 | const NEXT_BCC_SIZE: usize = GUEST_PAGE_SIZE; |
| 59 | |
Alice Wang | 28cbcf1 | 2022-12-01 07:58:28 +0000 | [diff] [blame] | 60 | fn main( |
Pierre-Clément Tosi | db74cb1 | 2022-12-08 13:56:25 +0000 | [diff] [blame] | 61 | fdt: &mut Fdt, |
Alice Wang | 28cbcf1 | 2022-12-01 07:58:28 +0000 | [diff] [blame] | 62 | signed_kernel: &[u8], |
| 63 | ramdisk: Option<&[u8]>, |
Alice Wang | 843d831 | 2023-02-15 09:47:06 +0000 | [diff] [blame] | 64 | current_bcc_handover: &[u8], |
Alan Stokes | 6561833 | 2023-12-15 14:09:25 +0000 | [diff] [blame] | 65 | mut debug_policy: Option<&[u8]>, |
Pierre-Clément Tosi | 97f5249 | 2023-04-04 15:52:17 +0100 | [diff] [blame] | 66 | ) -> Result<Range<usize>, RebootReason> { |
Pierre-Clément Tosi | 37105a6 | 2022-10-18 12:21:48 +0100 | [diff] [blame] | 67 | info!("pVM firmware"); |
Pierre-Clément Tosi | 8036b4f | 2023-02-17 10:31:31 +0000 | [diff] [blame] | 68 | debug!("FDT: {:?}", fdt.as_ptr()); |
Pierre-Clément Tosi | a0934c1 | 2022-11-25 20:54:11 +0000 | [diff] [blame] | 69 | debug!("Signed kernel: {:?} ({:#x} bytes)", signed_kernel.as_ptr(), signed_kernel.len()); |
Alice Wang | a78279c | 2022-12-16 12:41:19 +0000 | [diff] [blame] | 70 | 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] | 71 | if let Some(rd) = ramdisk { |
| 72 | debug!("Ramdisk: {:?} ({:#x} bytes)", rd.as_ptr(), rd.len()); |
| 73 | } else { |
| 74 | debug!("Ramdisk: None"); |
| 75 | } |
Alan Stokes | 4db76eb | 2023-04-26 14:28:15 +0100 | [diff] [blame] | 76 | |
Alice Wang | 843d831 | 2023-02-15 09:47:06 +0000 | [diff] [blame] | 77 | let bcc_handover = bcc_handover_parse(current_bcc_handover).map_err(|e| { |
| 78 | error!("Invalid BCC Handover: {e:?}"); |
| 79 | RebootReason::InvalidBcc |
| 80 | })?; |
| 81 | trace!("BCC: {bcc_handover:x?}"); |
Andrew Walbran | 1969063 | 2022-12-07 16:41:30 +0000 | [diff] [blame] | 82 | |
Alan Stokes | 4db76eb | 2023-04-26 14:28:15 +0100 | [diff] [blame] | 83 | let cdi_seal = bcc_handover.cdi_seal(); |
| 84 | |
| 85 | let bcc = Bcc::new(bcc_handover.bcc()).map_err(|e| { |
| 86 | error!("{e}"); |
| 87 | RebootReason::InvalidBcc |
| 88 | })?; |
| 89 | |
| 90 | // The bootloader should never pass us a debug policy when the boot is secure (the bootloader |
| 91 | // is locked). If it gets it wrong, disregard it & log it, to avoid it causing problems. |
| 92 | if debug_policy.is_some() && !bcc.is_debug_mode() { |
| 93 | warn!("Ignoring debug policy, BCC does not indicate Debug mode"); |
| 94 | debug_policy = None; |
Alan Stokes | d1ee63e | 2023-04-24 16:17:39 +0100 | [diff] [blame] | 95 | } |
| 96 | |
Andrew Walbran | 1969063 | 2022-12-07 16:41:30 +0000 | [diff] [blame] | 97 | // Set up PCI bus for VirtIO devices. |
Andrew Walbran | d1d0318 | 2022-12-09 18:20:01 +0000 | [diff] [blame] | 98 | let pci_info = PciInfo::from_fdt(fdt).map_err(handle_pci_error)?; |
| 99 | debug!("PCI: {:#x?}", pci_info); |
Alice Wang | eff5839 | 2023-07-04 13:32:09 +0000 | [diff] [blame] | 100 | let mut pci_root = pci::initialize(pci_info, MEMORY.lock().as_mut().unwrap()).map_err(|e| { |
| 101 | error!("Failed to initialize PCI: {e}"); |
Alice Wang | 287de62 | 2023-06-08 13:17:03 +0000 | [diff] [blame] | 102 | RebootReason::InternalError |
| 103 | })?; |
Andrew Walbran | 1969063 | 2022-12-07 16:41:30 +0000 | [diff] [blame] | 104 | |
Alice Wang | 1f0add0 | 2023-01-23 16:22:53 +0000 | [diff] [blame] | 105 | 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] | 106 | error!("Failed to verify the payload: {e}"); |
| 107 | RebootReason::PayloadVerificationError |
| 108 | })?; |
Pierre-Clément Tosi | f90655d | 2023-06-28 11:00:17 +0000 | [diff] [blame] | 109 | let debuggable = verified_boot_data.debug_level != DebugLevel::None; |
| 110 | if debuggable { |
| 111 | info!("Successfully verified a debuggable payload."); |
| 112 | info!("Please disregard any previous libavb ERROR about initrd_normal."); |
| 113 | } |
Pierre-Clément Tosi | 2d65298 | 2023-01-09 19:30:17 +0000 | [diff] [blame] | 114 | |
Shikha Panwar | 4a0651d | 2023-09-28 13:06:13 +0000 | [diff] [blame] | 115 | if verified_boot_data.has_capability(Capability::RemoteAttest) { |
Alice Wang | ab0d020 | 2023-05-17 08:07:41 +0000 | [diff] [blame] | 116 | info!("Service VM capable of remote attestation detected"); |
Alice Wang | 12e4c86 | 2023-12-11 13:52:27 +0000 | [diff] [blame] | 117 | if service_vm_version::VERSION != verified_boot_data.rollback_index { |
| 118 | // For RKP VM, we only boot if the version in the AVB footer of its kernel matches |
| 119 | // the one embedded in pvmfw at build time. |
| 120 | // This prevents the pvmfw from booting a roll backed RKP VM. |
| 121 | error!( |
| 122 | "Service VM version mismatch: expected {}, found {}", |
| 123 | service_vm_version::VERSION, |
| 124 | verified_boot_data.rollback_index |
| 125 | ); |
| 126 | return Err(RebootReason::InvalidPayload); |
| 127 | } |
Alice Wang | ab0d020 | 2023-05-17 08:07:41 +0000 | [diff] [blame] | 128 | } |
| 129 | |
Shikha Panwar | 4a0651d | 2023-09-28 13:06:13 +0000 | [diff] [blame] | 130 | if verified_boot_data.has_capability(Capability::SecretkeeperProtection) { |
| 131 | info!("Guest OS is capable of Secretkeeper protection"); |
| 132 | // For Secretkeeper based Antirollback protection, rollback_index of the image > 0 |
| 133 | if verified_boot_data.rollback_index == 0 { |
| 134 | error!( |
| 135 | "Expected positive rollback_index, found {:?}", |
| 136 | verified_boot_data.rollback_index |
| 137 | ); |
| 138 | return Err(RebootReason::InvalidPayload); |
| 139 | }; |
| 140 | } |
| 141 | |
Pierre-Clément Tosi | db74cb1 | 2022-12-08 13:56:25 +0000 | [diff] [blame] | 142 | let next_bcc = heap::aligned_boxed_slice(NEXT_BCC_SIZE, GUEST_PAGE_SIZE).ok_or_else(|| { |
| 143 | error!("Failed to allocate the next-stage BCC"); |
| 144 | RebootReason::InternalError |
| 145 | })?; |
| 146 | // By leaking the slice, its content will be left behind for the next stage. |
| 147 | let next_bcc = Box::leak(next_bcc); |
Pierre-Clément Tosi | 4f4f5eb | 2022-12-08 14:31:42 +0000 | [diff] [blame] | 148 | |
Pierre-Clément Tosi | f58f3a3 | 2023-02-02 16:24:23 +0000 | [diff] [blame] | 149 | let dice_inputs = PartialInputs::new(&verified_boot_data).map_err(|e| { |
| 150 | error!("Failed to compute partial DICE inputs: {e:?}"); |
| 151 | RebootReason::InternalError |
| 152 | })?; |
Pierre-Clément Tosi | 90cd4f1 | 2023-02-17 11:19:56 +0000 | [diff] [blame] | 153 | let (new_instance, salt) = get_or_generate_instance_salt(&mut pci_root, &dice_inputs, cdi_seal) |
| 154 | .map_err(|e| { |
Pierre-Clément Tosi | 1cc5eb7 | 2023-02-02 11:09:18 +0000 | [diff] [blame] | 155 | error!("Failed to get instance.img salt: {e}"); |
| 156 | RebootReason::InternalError |
| 157 | })?; |
| 158 | trace!("Got salt from instance.img: {salt:x?}"); |
| 159 | |
Alan Stokes | 7f27c0d | 2023-09-07 16:22:58 +0100 | [diff] [blame] | 160 | let new_bcc_handover = if cfg!(dice_changes) { |
| 161 | Cow::Borrowed(current_bcc_handover) |
| 162 | } else { |
| 163 | // It is possible that the DICE chain we were given is rooted in the UDS. We do not want to |
| 164 | // give such a chain to the payload, or even the associated CDIs. So remove the |
| 165 | // entire chain we were given and taint the CDIs. Note that the resulting CDIs are |
| 166 | // still deterministically derived from those we received, so will vary iff they do. |
| 167 | // TODO(b/280405545): Remove this post Android 14. |
| 168 | let truncated_bcc_handover = bcc::truncate(bcc_handover).map_err(|e| { |
| 169 | error!("{e}"); |
| 170 | RebootReason::InternalError |
| 171 | })?; |
| 172 | Cow::Owned(truncated_bcc_handover) |
| 173 | }; |
Alan Stokes | a38d3b3 | 2023-05-05 12:19:18 +0100 | [diff] [blame] | 174 | |
Alan Stokes | 7f27c0d | 2023-09-07 16:22:58 +0100 | [diff] [blame] | 175 | dice_inputs.write_next_bcc(new_bcc_handover.as_ref(), &salt, next_bcc).map_err(|e| { |
| 176 | error!("Failed to derive next-stage DICE secrets: {e:?}"); |
| 177 | RebootReason::SecretDerivationError |
| 178 | })?; |
Pierre-Clément Tosi | db74cb1 | 2022-12-08 13:56:25 +0000 | [diff] [blame] | 179 | flush(next_bcc); |
| 180 | |
Pierre-Clément Tosi | 8025197 | 2023-07-12 12:51:12 +0000 | [diff] [blame] | 181 | let kaslr_seed = u64::from_ne_bytes(rand::random_array().map_err(|e| { |
| 182 | error!("Failed to generated guest KASLR seed: {e}"); |
| 183 | RebootReason::InternalError |
| 184 | })?); |
Pierre-Clément Tosi | b2d8aa7 | 2023-02-17 15:22:50 +0000 | [diff] [blame] | 185 | let strict_boot = true; |
Pierre-Clément Tosi | 8025197 | 2023-07-12 12:51:12 +0000 | [diff] [blame] | 186 | modify_for_next_stage( |
| 187 | fdt, |
| 188 | next_bcc, |
| 189 | new_instance, |
| 190 | strict_boot, |
| 191 | debug_policy, |
| 192 | debuggable, |
| 193 | kaslr_seed, |
| 194 | ) |
| 195 | .map_err(|e| { |
| 196 | error!("Failed to configure device tree: {e}"); |
| 197 | RebootReason::InternalError |
| 198 | })?; |
Pierre-Clément Tosi | db74cb1 | 2022-12-08 13:56:25 +0000 | [diff] [blame] | 199 | |
Alice Wang | 4379c83 | 2022-12-05 15:50:20 +0000 | [diff] [blame] | 200 | info!("Starting payload..."); |
Pierre-Clément Tosi | 97f5249 | 2023-04-04 15:52:17 +0100 | [diff] [blame] | 201 | |
| 202 | let bcc_range = { |
| 203 | let r = next_bcc.as_ptr_range(); |
| 204 | (r.start as usize)..(r.end as usize) |
| 205 | }; |
| 206 | |
| 207 | Ok(bcc_range) |
Pierre-Clément Tosi | 263ffd5 | 2022-10-05 20:27:50 +0100 | [diff] [blame] | 208 | } |
Andrew Walbran | d1d0318 | 2022-12-09 18:20:01 +0000 | [diff] [blame] | 209 | |
| 210 | /// Logs the given PCI error and returns the appropriate `RebootReason`. |
| 211 | fn handle_pci_error(e: PciError) -> RebootReason { |
| 212 | error!("{}", e); |
| 213 | match e { |
| 214 | PciError::FdtErrorPci(_) |
| 215 | | PciError::FdtNoPci |
| 216 | | PciError::FdtErrorReg(_) |
| 217 | | PciError::FdtMissingReg |
| 218 | | PciError::FdtRegEmpty |
| 219 | | PciError::FdtRegMissingSize |
| 220 | | PciError::CamWrongSize(_) |
| 221 | | PciError::FdtErrorRanges(_) |
| 222 | | PciError::FdtMissingRanges |
| 223 | | PciError::RangeAddressMismatch { .. } |
| 224 | | PciError::NoSuitableRange => RebootReason::InvalidFdt, |
Andrew Walbran | d1d0318 | 2022-12-09 18:20:01 +0000 | [diff] [blame] | 225 | } |
| 226 | } |