1 /*
2 * Copyright (C) 2023 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 //! Utility functions used by API tests.
18
19 use anyhow::{anyhow, Result};
20 use avb_bindgen::{
21 avb_footer_validate_and_byteswap, avb_vbmeta_image_header_to_host_byte_order, AvbFooter,
22 AvbVBMetaImageHeader,
23 };
24 use openssl::sha;
25 use pvmfw_avb::{verify_payload, AvbSlotVerifyError, DebugLevel, Digest, VerifiedBootData};
26 use std::{
27 fs,
28 mem::{size_of, transmute, MaybeUninit},
29 };
30
31 const MICRODROID_KERNEL_IMG_PATH: &str = "microdroid_kernel";
32 const INITRD_NORMAL_IMG_PATH: &str = "microdroid_initrd_normal.img";
33 const INITRD_DEBUG_IMG_PATH: &str = "microdroid_initrd_debuggable.img";
34 const PUBLIC_KEY_RSA4096_PATH: &str = "data/testkey_rsa4096_pub.bin";
35
36 pub const PUBLIC_KEY_RSA2048_PATH: &str = "data/testkey_rsa2048_pub.bin";
37
assert_payload_verification_with_initrd_fails( kernel: &[u8], initrd: &[u8], trusted_public_key: &[u8], expected_error: AvbSlotVerifyError, ) -> Result<()>38 pub fn assert_payload_verification_with_initrd_fails(
39 kernel: &[u8],
40 initrd: &[u8],
41 trusted_public_key: &[u8],
42 expected_error: AvbSlotVerifyError,
43 ) -> Result<()> {
44 assert_payload_verification_fails(kernel, Some(initrd), trusted_public_key, expected_error)
45 }
46
assert_payload_verification_fails( kernel: &[u8], initrd: Option<&[u8]>, trusted_public_key: &[u8], expected_error: AvbSlotVerifyError, ) -> Result<()>47 pub fn assert_payload_verification_fails(
48 kernel: &[u8],
49 initrd: Option<&[u8]>,
50 trusted_public_key: &[u8],
51 expected_error: AvbSlotVerifyError,
52 ) -> Result<()> {
53 assert_eq!(expected_error, verify_payload(kernel, initrd, trusted_public_key).unwrap_err());
54 Ok(())
55 }
56
load_latest_signed_kernel() -> Result<Vec<u8>>57 pub fn load_latest_signed_kernel() -> Result<Vec<u8>> {
58 Ok(fs::read(MICRODROID_KERNEL_IMG_PATH)?)
59 }
60
load_latest_initrd_normal() -> Result<Vec<u8>>61 pub fn load_latest_initrd_normal() -> Result<Vec<u8>> {
62 Ok(fs::read(INITRD_NORMAL_IMG_PATH)?)
63 }
64
load_latest_initrd_debug() -> Result<Vec<u8>>65 pub fn load_latest_initrd_debug() -> Result<Vec<u8>> {
66 Ok(fs::read(INITRD_DEBUG_IMG_PATH)?)
67 }
68
load_trusted_public_key() -> Result<Vec<u8>>69 pub fn load_trusted_public_key() -> Result<Vec<u8>> {
70 Ok(fs::read(PUBLIC_KEY_RSA4096_PATH)?)
71 }
72
extract_avb_footer(kernel: &[u8]) -> Result<AvbFooter>73 pub fn extract_avb_footer(kernel: &[u8]) -> Result<AvbFooter> {
74 let footer_start = kernel.len() - size_of::<AvbFooter>();
75 // SAFETY: The slice is the same size as the struct which only contains simple data types.
76 let mut footer = unsafe {
77 transmute::<[u8; size_of::<AvbFooter>()], AvbFooter>(kernel[footer_start..].try_into()?)
78 };
79 // SAFETY: The function updates the struct in-place.
80 unsafe {
81 avb_footer_validate_and_byteswap(&footer, &mut footer);
82 }
83 Ok(footer)
84 }
85
extract_vbmeta_header(kernel: &[u8], footer: &AvbFooter) -> Result<AvbVBMetaImageHeader>86 pub fn extract_vbmeta_header(kernel: &[u8], footer: &AvbFooter) -> Result<AvbVBMetaImageHeader> {
87 let vbmeta_offset: usize = footer.vbmeta_offset.try_into()?;
88 let vbmeta_size: usize = footer.vbmeta_size.try_into()?;
89 let vbmeta_src = &kernel[vbmeta_offset..(vbmeta_offset + vbmeta_size)];
90 // SAFETY: The latest kernel has a valid VBMeta header at the position specified in footer.
91 let vbmeta_header = unsafe {
92 let mut header = MaybeUninit::uninit();
93 let src = vbmeta_src.as_ptr() as *const _ as *const AvbVBMetaImageHeader;
94 avb_vbmeta_image_header_to_host_byte_order(src, header.as_mut_ptr());
95 header.assume_init()
96 };
97 Ok(vbmeta_header)
98 }
99
assert_latest_payload_verification_passes( initrd: &[u8], initrd_salt: &[u8], expected_debug_level: DebugLevel, ) -> Result<()>100 pub fn assert_latest_payload_verification_passes(
101 initrd: &[u8],
102 initrd_salt: &[u8],
103 expected_debug_level: DebugLevel,
104 ) -> Result<()> {
105 let public_key = load_trusted_public_key()?;
106 let kernel = load_latest_signed_kernel()?;
107 let verified_boot_data = verify_payload(&kernel, Some(initrd), &public_key)
108 .map_err(|e| anyhow!("Verification failed. Error: {}", e))?;
109
110 let footer = extract_avb_footer(&kernel)?;
111 let kernel_digest =
112 hash(&[&hash(&[b"bootloader"]), &kernel[..usize::try_from(footer.original_image_size)?]]);
113 let initrd_digest = Some(hash(&[&hash(&[initrd_salt]), initrd]));
114 let expected_boot_data = VerifiedBootData {
115 debug_level: expected_debug_level,
116 kernel_digest,
117 initrd_digest,
118 public_key: &public_key,
119 };
120 assert_eq!(expected_boot_data, verified_boot_data);
121
122 Ok(())
123 }
124
hash(inputs: &[&[u8]]) -> Digest125 pub fn hash(inputs: &[&[u8]]) -> Digest {
126 let mut digester = sha::Sha256::new();
127 inputs.iter().for_each(|input| digester.update(input));
128 digester.finish()
129 }
130