blob: 9f9614a0212c3711614256d1ba2456f0043181d9 [file] [log] [blame]
Andrew Walbran68a8c162022-03-07 15:38:42 +00001// 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 Tosidb74cb12022-12-08 13:56:25 +000020extern crate alloc;
21
Alan Stokes4db76eb2023-04-26 14:28:15 +010022mod bcc;
Jiyong Parkc5d2ef22023-04-11 01:23:46 +090023mod bootargs;
Pierre-Clément Tosi20b60962022-10-17 13:35:27 +010024mod config;
Jaewan Kimc6e023b2023-10-12 15:11:05 +090025mod device_assignment;
Pierre-Clément Tosi4f4f5eb2022-12-08 14:31:42 +000026mod dice;
Pierre-Clément Tosi5bbfca52022-10-21 12:14:35 +010027mod entry;
Andrew Walbrandfb73372022-04-21 10:52:27 +000028mod exceptions;
Pierre-Clément Tosia0934c12022-11-25 20:54:11 +000029mod fdt;
Pierre-Clément Tosi1cc5eb72023-02-02 11:09:18 +000030mod gpt;
Pierre-Clément Tosida4440a2022-08-22 18:06:32 +010031mod helpers;
Pierre-Clément Tosi1cc5eb72023-02-02 11:09:18 +000032mod instance;
Pierre-Clément Tosia0934c12022-11-25 20:54:11 +000033mod memory;
Andrew Walbran68a8c162022-03-07 15:38:42 +000034
Alan Stokes4db76eb2023-04-26 14:28:15 +010035use crate::bcc::Bcc;
Pierre-Clément Tosi4ba79662023-02-13 11:22:41 +000036use crate::dice::PartialInputs;
37use crate::entry::RebootReason;
Pierre-Clément Tosi92778802024-11-19 17:36:14 +000038use crate::fdt::{modify_for_next_stage, sanitize_device_tree};
Pierre-Clément Tosi4ba79662023-02-13 11:22:41 +000039use crate::helpers::GUEST_PAGE_SIZE;
Shikha Panwar37490d42024-03-19 22:14:58 +000040use crate::instance::EntryBody;
41use crate::instance::Error as InstanceError;
42use crate::instance::{get_recorded_entry, record_instance_entry};
Alan Stokes7f27c0d2023-09-07 16:22:58 +010043use alloc::borrow::Cow;
Alan Stokes4db76eb2023-04-26 14:28:15 +010044use alloc::boxed::Box;
Shikha Panwar73ba0d42024-03-20 14:43:21 +000045use bssl_avf::Digester;
Alan Stokes4db76eb2023-04-26 14:28:15 +010046use core::ops::Range;
Shikha Panwar73ba0d42024-03-20 14:43:21 +000047use cstr::cstr;
Alice Wang87fbc4b2024-11-05 13:09:58 +000048use diced_open_dice::{bcc_handover_parse, DiceArtifacts, DiceContext, Hidden, VM_KEY_ALGORITHM};
Shikha Panwar73ba0d42024-03-20 14:43:21 +000049use libfdt::{Fdt, FdtNode};
Alan Stokes4db76eb2023-04-26 14:28:15 +010050use log::{debug, error, info, trace, warn};
Pierre-Clément Tosi2d652982023-01-09 19:30:17 +000051use pvmfw_avb::verify_payload;
Alice Wangab0d0202023-05-17 08:07:41 +000052use pvmfw_avb::Capability;
Jiyong Parkc5d2ef22023-04-11 01:23:46 +090053use pvmfw_avb::DebugLevel;
Alice Wang0aa30322023-01-31 11:00:10 +000054use pvmfw_embedded_key::PUBLIC_KEY;
Pierre-Clément Tosif2c19d42024-10-01 17:42:04 +010055use vmbase::fdt::pci::{PciError, PciInfo};
Pierre-Clément Tosic332fae2023-06-22 11:37:12 +000056use vmbase::heap;
Pierre-Clément Tosi92778802024-11-19 17:36:14 +000057use vmbase::memory::{flush, init_shared_pool};
Pierre-Clément Tosi80251972023-07-12 12:51:12 +000058use vmbase::rand;
Alice Wangeade1672023-06-08 14:56:20 +000059use vmbase::virtio::pci;
Andrew Walbran68a8c162022-03-07 15:38:42 +000060
Pierre-Clément Tosi4f4f5eb2022-12-08 14:31:42 +000061const NEXT_BCC_SIZE: usize = GUEST_PAGE_SIZE;
62
Alice Wang28cbcf12022-12-01 07:58:28 +000063fn main(
Pierre-Clément Tosi92778802024-11-19 17:36:14 +000064 untrusted_fdt: &mut Fdt,
Alice Wang28cbcf12022-12-01 07:58:28 +000065 signed_kernel: &[u8],
66 ramdisk: Option<&[u8]>,
Alice Wang843d8312023-02-15 09:47:06 +000067 current_bcc_handover: &[u8],
Alan Stokes65618332023-12-15 14:09:25 +000068 mut debug_policy: Option<&[u8]>,
Pierre-Clément Tosi92778802024-11-19 17:36:14 +000069 vm_dtbo: Option<&mut [u8]>,
70 vm_ref_dt: Option<&[u8]>,
Pierre-Clément Tosi64aff642024-07-31 16:20:21 +010071) -> Result<(Range<usize>, bool), RebootReason> {
Pierre-Clément Tosi37105a62022-10-18 12:21:48 +010072 info!("pVM firmware");
Pierre-Clément Tosi92778802024-11-19 17:36:14 +000073 debug!("FDT: {:?}", untrusted_fdt.as_ptr());
Pierre-Clément Tosia0934c12022-11-25 20:54:11 +000074 debug!("Signed kernel: {:?} ({:#x} bytes)", signed_kernel.as_ptr(), signed_kernel.len());
Alice Wanga78279c2022-12-16 12:41:19 +000075 debug!("AVB public key: addr={:?}, size={:#x} ({1})", PUBLIC_KEY.as_ptr(), PUBLIC_KEY.len());
Pierre-Clément Tosia0934c12022-11-25 20:54:11 +000076 if let Some(rd) = ramdisk {
77 debug!("Ramdisk: {:?} ({:#x} bytes)", rd.as_ptr(), rd.len());
78 } else {
79 debug!("Ramdisk: None");
80 }
Alan Stokes4db76eb2023-04-26 14:28:15 +010081
Alice Wang843d8312023-02-15 09:47:06 +000082 let bcc_handover = bcc_handover_parse(current_bcc_handover).map_err(|e| {
83 error!("Invalid BCC Handover: {e:?}");
84 RebootReason::InvalidBcc
85 })?;
86 trace!("BCC: {bcc_handover:x?}");
Andrew Walbran19690632022-12-07 16:41:30 +000087
Alan Stokes4db76eb2023-04-26 14:28:15 +010088 let cdi_seal = bcc_handover.cdi_seal();
89
90 let bcc = Bcc::new(bcc_handover.bcc()).map_err(|e| {
91 error!("{e}");
92 RebootReason::InvalidBcc
93 })?;
94
95 // The bootloader should never pass us a debug policy when the boot is secure (the bootloader
96 // is locked). If it gets it wrong, disregard it & log it, to avoid it causing problems.
97 if debug_policy.is_some() && !bcc.is_debug_mode() {
98 warn!("Ignoring debug policy, BCC does not indicate Debug mode");
99 debug_policy = None;
Alan Stokesd1ee63e2023-04-24 16:17:39 +0100100 }
101
Alice Wang1f0add02023-01-23 16:22:53 +0000102 let verified_boot_data = verify_payload(signed_kernel, ramdisk, PUBLIC_KEY).map_err(|e| {
Pierre-Clément Tosi2d652982023-01-09 19:30:17 +0000103 error!("Failed to verify the payload: {e}");
104 RebootReason::PayloadVerificationError
105 })?;
Pierre-Clément Tosif90655d2023-06-28 11:00:17 +0000106 let debuggable = verified_boot_data.debug_level != DebugLevel::None;
107 if debuggable {
108 info!("Successfully verified a debuggable payload.");
109 info!("Please disregard any previous libavb ERROR about initrd_normal.");
110 }
Pierre-Clément Tosi2d652982023-01-09 19:30:17 +0000111
Pierre-Clément Tosi92778802024-11-19 17:36:14 +0000112 let fdt_info = sanitize_device_tree(untrusted_fdt, vm_dtbo, vm_ref_dt)?;
113 let fdt = untrusted_fdt; // DT has now been sanitized.
114 let pci_info = PciInfo::from_fdt(fdt).map_err(handle_pci_error)?;
115 debug!("PCI: {:#x?}", pci_info);
116 // Set up PCI bus for VirtIO devices.
117 let mut pci_root = pci::initialize(pci_info).map_err(|e| {
118 error!("Failed to initialize PCI: {e}");
119 RebootReason::InternalError
120 })?;
121 init_shared_pool(fdt_info.swiotlb_info.fixed_range()).map_err(|e| {
122 error!("Failed to initialize shared pool: {e}");
123 RebootReason::InternalError
124 })?;
125
Pierre-Clément Tosidb74cb12022-12-08 13:56:25 +0000126 let next_bcc = heap::aligned_boxed_slice(NEXT_BCC_SIZE, GUEST_PAGE_SIZE).ok_or_else(|| {
127 error!("Failed to allocate the next-stage BCC");
128 RebootReason::InternalError
129 })?;
130 // By leaking the slice, its content will be left behind for the next stage.
131 let next_bcc = Box::leak(next_bcc);
Pierre-Clément Tosi4f4f5eb2022-12-08 14:31:42 +0000132
Pierre-Clément Tosif58f3a32023-02-02 16:24:23 +0000133 let dice_inputs = PartialInputs::new(&verified_boot_data).map_err(|e| {
134 error!("Failed to compute partial DICE inputs: {e:?}");
135 RebootReason::InternalError
136 })?;
Shikha Panwar37490d42024-03-19 22:14:58 +0000137
Shikha Panwar8f7fc1a2024-04-10 10:41:34 +0000138 let instance_hash = if cfg!(llpvm_changes) { Some(salt_from_instance_id(fdt)?) } else { None };
Shikha Panwarffadd4d2024-05-28 13:47:56 +0000139 let defer_rollback_protection = should_defer_rollback_protection(fdt)?
140 && verified_boot_data.has_capability(Capability::SecretkeeperProtection);
141 let (new_instance, salt) = if defer_rollback_protection {
Shikha Panwar73ba0d42024-03-20 14:43:21 +0000142 info!("Guest OS is capable of Secretkeeper protection, deferring rollback protection");
143 // rollback_index of the image is used as security_version and is expected to be > 0 to
144 // discourage implicit allocation.
145 if verified_boot_data.rollback_index == 0 {
146 error!("Expected positive rollback_index, found 0");
147 return Err(RebootReason::InvalidPayload);
148 };
Shikha Panwar9ecf2532024-06-06 06:51:00 +0000149 (false, instance_hash.unwrap())
150 } else if verified_boot_data.has_capability(Capability::RemoteAttest) {
151 info!("Service VM capable of remote attestation detected, performing version checks");
152 if service_vm_version::VERSION != verified_boot_data.rollback_index {
153 // For RKP VM, we only boot if the version in the AVB footer of its kernel matches
154 // the one embedded in pvmfw at build time.
155 // This prevents the pvmfw from booting a roll backed RKP VM.
156 error!(
157 "Service VM version mismatch: expected {}, found {}",
158 service_vm_version::VERSION,
159 verified_boot_data.rollback_index
160 );
161 return Err(RebootReason::InvalidPayload);
162 }
Shikha Panwar8f7fc1a2024-04-10 10:41:34 +0000163 (false, instance_hash.unwrap())
Alice Wangfe0b9762024-11-21 14:47:54 +0000164 } else if verified_boot_data.has_capability(Capability::TrustySecurityVm) {
165 // The rollback protection of Trusty VMs are handled by AuthMgr, so we don't need to
166 // handle it here.
167 info!("Trusty Security VM detected");
168 (false, instance_hash.unwrap())
Shikha Panwar73ba0d42024-03-20 14:43:21 +0000169 } else {
Shikha Panwar9ecf2532024-06-06 06:51:00 +0000170 info!("Fallback to instance.img based rollback checks");
Shikha Panwar73ba0d42024-03-20 14:43:21 +0000171 let (recorded_entry, mut instance_img, header_index) =
172 get_recorded_entry(&mut pci_root, cdi_seal).map_err(|e| {
173 error!("Failed to get entry from instance.img: {e}");
Shikha Panwar37490d42024-03-19 22:14:58 +0000174 RebootReason::InternalError
175 })?;
Shikha Panwar73ba0d42024-03-20 14:43:21 +0000176 let (new_instance, salt) = if let Some(entry) = recorded_entry {
Shikha Panwar9ecf2532024-06-06 06:51:00 +0000177 check_dice_measurements_match_entry(&dice_inputs, &entry)?;
Shikha Panwar8f7fc1a2024-04-10 10:41:34 +0000178 let salt = instance_hash.unwrap_or(entry.salt);
Shikha Panwar73ba0d42024-03-20 14:43:21 +0000179 (false, salt)
180 } else {
181 // New instance!
Shikha Panwar8f7fc1a2024-04-10 10:41:34 +0000182 let salt = instance_hash.map_or_else(rand::random_array, Ok).map_err(|e| {
183 error!("Failed to generated instance.img salt: {e}");
184 RebootReason::InternalError
185 })?;
186
Shikha Panwar73ba0d42024-03-20 14:43:21 +0000187 let entry = EntryBody::new(&dice_inputs, &salt);
188 record_instance_entry(&entry, cdi_seal, &mut instance_img, header_index).map_err(
189 |e| {
190 error!("Failed to get recorded entry in instance.img: {e}");
191 RebootReason::InternalError
192 },
193 )?;
194 (true, salt)
195 };
196 (new_instance, salt)
Shikha Panwar37490d42024-03-19 22:14:58 +0000197 };
Shikha Panwar73ba0d42024-03-20 14:43:21 +0000198 trace!("Got salt for instance: {salt:x?}");
Pierre-Clément Tosi1cc5eb72023-02-02 11:09:18 +0000199
Alan Stokes7f27c0d2023-09-07 16:22:58 +0100200 let new_bcc_handover = if cfg!(dice_changes) {
201 Cow::Borrowed(current_bcc_handover)
202 } else {
203 // It is possible that the DICE chain we were given is rooted in the UDS. We do not want to
204 // give such a chain to the payload, or even the associated CDIs. So remove the
205 // entire chain we were given and taint the CDIs. Note that the resulting CDIs are
206 // still deterministically derived from those we received, so will vary iff they do.
207 // TODO(b/280405545): Remove this post Android 14.
208 let truncated_bcc_handover = bcc::truncate(bcc_handover).map_err(|e| {
209 error!("{e}");
210 RebootReason::InternalError
211 })?;
212 Cow::Owned(truncated_bcc_handover)
213 };
Alan Stokesa38d3b32023-05-05 12:19:18 +0100214
Alice Wang6823ffc2024-10-29 15:54:34 +0000215 trace!("BCC leaf subject public key algorithm: {:?}", bcc.leaf_subject_pubkey().cose_alg);
216
Alice Wang87fbc4b2024-11-05 13:09:58 +0000217 let dice_context = DiceContext {
218 authority_algorithm: bcc.leaf_subject_pubkey().cose_alg.try_into().map_err(|e| {
219 error!("{e}");
220 RebootReason::InternalError
221 })?,
222 subject_algorithm: VM_KEY_ALGORITHM,
223 };
Shikha Panwarffadd4d2024-05-28 13:47:56 +0000224 dice_inputs
225 .write_next_bcc(
226 new_bcc_handover.as_ref(),
227 &salt,
228 instance_hash,
229 defer_rollback_protection,
230 next_bcc,
Alice Wang87fbc4b2024-11-05 13:09:58 +0000231 dice_context,
Shikha Panwarffadd4d2024-05-28 13:47:56 +0000232 )
233 .map_err(|e| {
Shikha Panwar8f7fc1a2024-04-10 10:41:34 +0000234 error!("Failed to derive next-stage DICE secrets: {e:?}");
235 RebootReason::SecretDerivationError
Shikha Panwarffadd4d2024-05-28 13:47:56 +0000236 })?;
Pierre-Clément Tosidb74cb12022-12-08 13:56:25 +0000237 flush(next_bcc);
238
Pierre-Clément Tosi80251972023-07-12 12:51:12 +0000239 let kaslr_seed = u64::from_ne_bytes(rand::random_array().map_err(|e| {
240 error!("Failed to generated guest KASLR seed: {e}");
241 RebootReason::InternalError
242 })?);
Pierre-Clément Tosib2d8aa72023-02-17 15:22:50 +0000243 let strict_boot = true;
Pierre-Clément Tosi80251972023-07-12 12:51:12 +0000244 modify_for_next_stage(
245 fdt,
246 next_bcc,
247 new_instance,
248 strict_boot,
249 debug_policy,
250 debuggable,
251 kaslr_seed,
252 )
253 .map_err(|e| {
254 error!("Failed to configure device tree: {e}");
255 RebootReason::InternalError
256 })?;
Pierre-Clément Tosidb74cb12022-12-08 13:56:25 +0000257
Alice Wang4379c832022-12-05 15:50:20 +0000258 info!("Starting payload...");
Pierre-Clément Tosi97f52492023-04-04 15:52:17 +0100259
260 let bcc_range = {
261 let r = next_bcc.as_ptr_range();
262 (r.start as usize)..(r.end as usize)
263 };
264
Pierre-Clément Tosi64aff642024-07-31 16:20:21 +0100265 Ok((bcc_range, debuggable))
Pierre-Clément Tosi263ffd52022-10-05 20:27:50 +0100266}
Andrew Walbrand1d03182022-12-09 18:20:01 +0000267
Shikha Panwar9ecf2532024-06-06 06:51:00 +0000268fn check_dice_measurements_match_entry(
Shikha Panwar73ba0d42024-03-20 14:43:21 +0000269 dice_inputs: &PartialInputs,
270 entry: &EntryBody,
271) -> Result<(), RebootReason> {
Shikha Panwar73ba0d42024-03-20 14:43:21 +0000272 ensure_dice_measurements_match_entry(dice_inputs, entry).map_err(|e| {
273 error!(
274 "Dice measurements do not match recorded entry. \
275 This may be because of update: {e}"
276 );
277 RebootReason::InternalError
278 })?;
279
280 Ok(())
281}
282
Shikha Panwar37490d42024-03-19 22:14:58 +0000283fn ensure_dice_measurements_match_entry(
284 dice_inputs: &PartialInputs,
285 entry: &EntryBody,
286) -> Result<(), InstanceError> {
287 if entry.code_hash != dice_inputs.code_hash {
288 Err(InstanceError::RecordedCodeHashMismatch)
289 } else if entry.auth_hash != dice_inputs.auth_hash {
290 Err(InstanceError::RecordedAuthHashMismatch)
291 } else if entry.mode() != dice_inputs.mode {
292 Err(InstanceError::RecordedDiceModeMismatch)
293 } else {
294 Ok(())
295 }
296}
297
Shikha Panwar73ba0d42024-03-20 14:43:21 +0000298// Get the "salt" which is one of the input for DICE derivation.
299// This provides differentiation of secrets for different VM instances with same payloads.
300fn salt_from_instance_id(fdt: &Fdt) -> Result<Hidden, RebootReason> {
301 let id = instance_id(fdt)?;
302 let salt = Digester::sha512()
303 .digest(&[&b"InstanceId:"[..], id].concat())
304 .map_err(|e| {
305 error!("Failed to get digest of instance-id: {e}");
306 RebootReason::InternalError
307 })?
308 .try_into()
309 .map_err(|_| RebootReason::InternalError)?;
310 Ok(salt)
311}
312
313fn instance_id(fdt: &Fdt) -> Result<&[u8], RebootReason> {
314 let node = avf_untrusted_node(fdt)?;
315 let id = node.getprop(cstr!("instance-id")).map_err(|e| {
316 error!("Failed to get instance-id in DT: {e}");
317 RebootReason::InvalidFdt
318 })?;
319 id.ok_or_else(|| {
320 error!("Missing instance-id");
321 RebootReason::InvalidFdt
322 })
323}
324
325fn should_defer_rollback_protection(fdt: &Fdt) -> Result<bool, RebootReason> {
326 let node = avf_untrusted_node(fdt)?;
327 let defer_rbp = node
328 .getprop(cstr!("defer-rollback-protection"))
329 .map_err(|e| {
330 error!("Failed to get defer-rollback-protection property in DT: {e}");
331 RebootReason::InvalidFdt
332 })?
333 .is_some();
334 Ok(defer_rbp)
335}
336
337fn avf_untrusted_node(fdt: &Fdt) -> Result<FdtNode, RebootReason> {
338 let node = fdt.node(cstr!("/avf/untrusted")).map_err(|e| {
339 error!("Failed to get /avf/untrusted node: {e}");
340 RebootReason::InvalidFdt
341 })?;
342 node.ok_or_else(|| {
343 error!("/avf/untrusted node is missing in DT");
344 RebootReason::InvalidFdt
345 })
346}
347
Andrew Walbrand1d03182022-12-09 18:20:01 +0000348/// Logs the given PCI error and returns the appropriate `RebootReason`.
349fn handle_pci_error(e: PciError) -> RebootReason {
350 error!("{}", e);
351 match e {
352 PciError::FdtErrorPci(_)
353 | PciError::FdtNoPci
354 | PciError::FdtErrorReg(_)
355 | PciError::FdtMissingReg
356 | PciError::FdtRegEmpty
357 | PciError::FdtRegMissingSize
358 | PciError::CamWrongSize(_)
359 | PciError::FdtErrorRanges(_)
360 | PciError::FdtMissingRanges
361 | PciError::RangeAddressMismatch { .. }
362 | PciError::NoSuitableRange => RebootReason::InvalidFdt,
Andrew Walbrand1d03182022-12-09 18:20:01 +0000363 }
364}