greq: Add SnpGuestRequestDriver

SnpGuestRequestDriver is a driver for the SNP_GUEST_REQUEST mechanism. Its
implementation follows the AMD SEV-SNP specification, chapter 7.

The send_request() method of the driver is used to send a SNP_GUEST_REQUEST
command to the PSP.

The test case aes_gcm_encrypt_and_decrypt() is used to validate both the load
and unwrap methods of the driver.

Signed-off-by: Claudio Carvalho <[email protected]>

Author: cclaudio

src/greq/driver.rs

@@ -0,0 +1,370 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+//
+// Copyright (C) 2023 IBM
+//
+// Authors: Claudio Carvalho <[email protected]>
+
+//! `SNP_GUEST_REQUEST` driver
+
+extern crate alloc;
+
+use crate::address::VirtAddr;
+use crate::cpu::percpu::this_cpu_mut;
+use crate::error::SvsmError;
+use crate::greq::msg::{MemoryPage, SnpGuestRequestExtData, SnpGuestRequestMsg};
+use crate::protocols::errors::{SvsmReqError, SvsmResultCode};
+use crate::sev::ghcb::GhcbError;
+use crate::sev::secrets_page::{disable_vmpck0, get_vmpck0, is_vmpck0_clear, VMPCK_SIZE};
+use crate::BIT;
+
+// Hypervisor error codes
+
+/// Buffer provided is too small
+pub const SNP_GUEST_REQ_INVALID_LEN: u64 = BIT!(32);
+/// Hypervisor busy, try again
+pub const SNP_GUEST_REQ_ERR_BUSY: u64 = BIT!(33);
+
+#[derive(Debug, PartialEq)]
+enum DriverState {
+    Initial = 0,
+    Ready = 1,
+    Failed = 2,
+}
+
+#[derive(PartialEq, Copy, Clone)]
+pub enum SnpGuestRequestClass {
+    Regular,
+    Extended,
+}
+
+/// `SNP_GUEST_REQUEST` driver
+#[derive(Debug)]
+pub struct SnpGuestRequestDriver {
+    /// `SNP_GUEST_REQUEST` message that carries the request. Shared page.
+    request: SnpGuestRequestMsg,
+    /// `SNP_GUEST_REQUEST` message that carries the response. Shared page.
+    response: SnpGuestRequestMsg,
+    /// Protected page where we encrypt/decrypt the `SNP_GUEST_REQUEST` message.
+    staging: SnpGuestRequestMsg,
+    /// `SNP_GUEST_REQUEST` extended data, usually used to carry
+    /// hypervisor-provided data (e.g. attestation report certificates)
+    ext_data: SnpGuestRequestExtData,
+    /// Each `SNP_GUEST_REQUEST` message contains a sequence number per VMPCK.
+    /// It is incremented with each message sent. Messages sent by the guest to
+    /// the PSP and by the PSP to the guest must be delivered in order. If not,
+    /// the PSP will reject subsequent messages by the guest when it detects that
+    /// the sequence numbers are out of sync.
+    ///
+    /// NOTE: If the vmpl field of a `SNP_GUEST_REQUEST` message is set to VMPL0,
+    /// then it must contain the VMPL0 sequence number and be protected (encrypted)
+    /// with the VMPCK0 key; additionally, if this message fails, the VMPCK0 key
+    /// must be disabled. The same idea applies to the other VMPL levels.
+    ///
+    /// The guest kernel runs in VMPL1 and it should be able to protect and send
+    /// VMPL1 `SNP_GUEST_REQUEST` messages directly to the PSP; hence,
+    /// the SVSM needs to support only VMPL0 `SNP_GUEST_REQUEST` messages.
+    /// In other words, it needs to maintain the sequence number only for VMPL0.
+    vmpck0_seqno: u64,
+    /// Driver current state. `SNP_GUEST_REQUEST` messages can be sent to the PSP
+    /// only if the driver is in the ready state.
+    state: DriverState,
+}
+
+impl SnpGuestRequestDriver {
+    /// Prepare for a new extended guest request
+    pub fn extended_request_prepare(&mut self, len: usize) -> Result<(), SvsmReqError> {
+        self.ext_data.set_len(len)?;
+        self.ext_data.clear();
+
+        Ok(())
+    }
+
+    /// Copy the first n bytes from the extended data to the provided buffer
+    pub fn extended_data_ncopy_to(
+        &self,
+        n: usize,
+        outbuf: VirtAddr,
+        outbuf_size: usize,
+    ) -> Result<(), SvsmReqError> {
+        self.ext_data.ncopy_to(n, outbuf, outbuf_size)
+    }
+
+    /// Check if the extended data is zeroed
+    pub fn is_extended_data_clear(&self) -> bool {
+        self.ext_data.is_clear()
+    }
+
+    /// The global driver instance GREQ_DRIVER requires "pub const fn default()",
+    /// however, const Default trait is not supported (yet?)
+    /// <https://github.com/rust-lang/rust/issues/67792>
+    ///
+    /// Once it is supported we should be able to just annotate the structure
+    /// with something like `#[derive(const_Default)]`
+    pub const fn default() -> Self {
+        Self {
+            request: SnpGuestRequestMsg::default(),
+            response: SnpGuestRequestMsg::default(),
+            staging: SnpGuestRequestMsg::default(),
+            ext_data: SnpGuestRequestExtData::default(),
+            vmpck0_seqno: 0,
+            state: DriverState::Initial,
+        }
+    }
+
+    fn do_init(&mut self) -> Result<(), SvsmReqError> {
+        self.request.init(MemoryPage::Unencrypted)?;
+        self.response.init(MemoryPage::Unencrypted)?;
+        self.ext_data.init(MemoryPage::Unencrypted)?;
+
+        self.staging.init(MemoryPage::Encrypted)?;
+
+        Ok(())
+    }
+
+    fn is_ready(&self) -> bool {
+        self.state == DriverState::Ready
+    }
+
+    /// Initialize the `SNP_GUEST_REQUEST` driver
+    pub fn init(&mut self) -> Result<(), SvsmReqError> {
+        if self.state != DriverState::Initial {
+            return Err(SvsmReqError::invalid_request());
+        }
+
+        let result = self.do_init();
+        if result.is_ok() {
+            self.state = DriverState::Ready;
+        } else {
+            self.free();
+            self.state = DriverState::Failed;
+            // Without the driver we can't send `SNP_GUEST_REQUEST` messages to the PSP.
+            // Clear the VMPCK0 to prevent it from being exploited.
+            disable_vmpck0();
+        }
+
+        result
+    }
+
+    /// Free the memory allocated for the `SNP_GUEST_REQUEST` driver
+    pub fn free(&mut self) {
+        self.request.free();
+        self.response.free();
+        self.staging.free();
+        self.ext_data.free();
+    }
+
+    /// Get the last VMPCK0 sequence number accounted
+    fn seqno_last_used(&self) -> u64 {
+        self.vmpck0_seqno
+    }
+
+    /// Increase the VMPCK0 sequence number by two. In order to keep the
+    /// sequence number in-sync with the PSP, this is called only when the
+    /// `SNP_GUEST_REQUEST` response is received.
+    fn seqno_add_two(&mut self) {
+        self.vmpck0_seqno += 2;
+    }
+
+    /// Call the GHCB layer to send the encrypted SNP_GUEST_REQUEST message
+    /// to the PSP.
+    fn send(&mut self, req_class: SnpGuestRequestClass) -> Result<(), SvsmReqError> {
+        self.response.clear();
+
+        if req_class == SnpGuestRequestClass::Extended {
+            this_cpu_mut().ghcb().guest_ext_request(
+                self.request.as_va(),
+                self.response.as_va(),
+                self.ext_data.as_va(),
+                self.ext_data.npages(),
+            )?;
+        } else {
+            this_cpu_mut()
+                .ghcb()
+                .guest_request(self.request.as_va(), self.response.as_va())?;
+        }
+
+        self.seqno_add_two();
+
+        Ok(())
+    }
+
+    /// Send a VMPL0 `SNP_GUEST_REQUEST` command to the PSP.
+    /// The command will be encrypted using AES-256 GCM.
+    ///
+    /// # Parameters:
+    ///
+    /// * `msg_type`: type of the command stored in `buffer`
+    /// * `req_class`: whether or not this is an extended `SNP_GUEST_REQUEST` command
+    /// * `buffer`: [VirtAddr] of the buffer that contains the `SNP_GUEST_REQUEST` command
+    ///             The same buffer will also be used to store the response.
+    /// * `buffer_size`: Total size of `buffer` in bytes
+    /// * `buffer_len`: Number of bytes from `buffer` being used for the command
+    ///
+    /// # Return codes:
+    ///
+    /// * Success:
+    ///     * `usize`: Number of bytes from `buffer` being used for the response
+    /// * Error:
+    ///     * `SvsmReqError`
+    pub fn send_request(
+        &mut self,
+        msg_type: u8,
+        req_class: SnpGuestRequestClass,
+        buffer: VirtAddr,
+        buffer_size: usize,
+        buffer_len: u16,
+    ) -> Result<usize, SvsmReqError> {
+        if !self.is_ready() || is_vmpck0_clear() {
+            return Err(SvsmReqError::invalid_request());
+        }
+        // Message sequence number overflow, the driver will not able
+        // to send `SNP_GUEST_REQUEST` messages to the PSP. The sequence number is
+        // restored only when the guest is rebooted.
+        // Let's clear the VMPCK0 to prevent it from being exploited.
+        let Some(msg_seqno) = self.seqno_last_used().checked_add(1) else {
+            log::error!("SNP_GUEST_REQUEST: sequence number overflow");
+            disable_vmpck0();
+            return Err(SvsmReqError::invalid_request());
+        };
+
+        // VMPL0 `SNP_GUEST_REQUEST` commands are encrypted with the VMPCK0
+        let vmpck0: [u8; VMPCK_SIZE] = get_vmpck0();
+
+        // For security reasons, perform the message load in encrypted memory (staging)
+        // and then copy it to shared memory (request)
+        self.staging
+            .load(msg_type, msg_seqno, &vmpck0, buffer, buffer_len)?;
+        self.request.copy_from(&self.staging)?;
+
+        if let Err(e) = self.send(req_class) {
+            if let SvsmReqError::FatalError(SvsmError::Ghcb(GhcbError::VmgexitError(_rbx, info2))) =
+                e
+            {
+                // For some reason the hypervisor did not forward the request to the PSP.
+                // Let's resend it to prevent the IV from being exploited.
+                match info2 & 0xffff_ffff_0000_0000u64 {
+                    // The certificate buffer provided is too small.
+                    SNP_GUEST_REQ_INVALID_LEN => {
+                        if req_class == SnpGuestRequestClass::Extended {
+                            if let Err(e1) = self.send(SnpGuestRequestClass::Regular) {
+                                log::error!(
+                                    "SNP_GUEST_REQ_INVALID_LEN. Aborting, request resend failed"
+                                );
+                                disable_vmpck0();
+                                return Err(e1);
+                            }
+                            return Err(e);
+                        } else {
+                            // We sent a regular SNP_GUEST_REQUEST, but the hypervisor returned
+                            // an error code that is exclusive for extended SNP_GUEST_REQUEST
+                            disable_vmpck0();
+                            return Err(SvsmReqError::invalid_request());
+                        }
+                    }
+                    // The hypervisor is busy.
+                    SNP_GUEST_REQ_ERR_BUSY => {
+                        if let Err(e2) = self.send(SnpGuestRequestClass::Regular) {
+                            log::error!("SNP_GUEST_REQ_ERR_BUSY. Aborting, request resend failed");
+                            disable_vmpck0();
+                            return Err(e2);
+                        }
+                        // ... request resend worked, continue normally.
+                    }
+                    // Failed for unknown reason. Status codes can be found in
+                    // the AMD SEV-SNP spec or in the linux kernel include/uapi/linux/psp-sev.h
+                    _ => {
+                        log::error!("SNP_GUEST_REQUEST failed, unknown error code={}\n", info2);
+                        disable_vmpck0();
+                        return Err(e);
+                    }
+                }
+            }
+        }
+
+        let msg_seqno = self.seqno_last_used();
+
+        // For security reasons, perform the message unwrap in encrypted memory (staging)
+        self.staging.copy_from(&self.response)?;
+        let result = self
+            .staging
+            .unwrap(msg_type + 1, msg_seqno, &vmpck0, buffer, buffer_size);
+
+        if let Err(e) = result {
+            match e {
+                // The buffer provided is too small to store the unwrapped response.
+                // There is no need to clear the VMPCK0, just report it as invalid parameter.
+                SvsmReqError::RequestError(SvsmResultCode::INVALID_PARAMETER) => (),
+                _ => disable_vmpck0(),
+            }
+        }
+
+        result
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    extern crate alloc;
+
+    use alloc::vec::Vec;
+
+    use crate::{
+        address::VirtAddr,
+        greq::driver::{DriverState, SnpGuestRequestDriver},
+        greq::msg::{SnpGuestRequestMsg, SNP_MSG_REPORT_REQ},
+        sev::secrets_page::VMPCK_SIZE,
+        types::PAGE_SIZE,
+    };
+
+    static mut DRIVER: SnpGuestRequestDriver = SnpGuestRequestDriver::default();
+    static mut REQUEST: [u8; PAGE_SIZE] = [0u8; PAGE_SIZE];
+
+    fn guest_request_driver_init() {
+        let req_va = unsafe { VirtAddr::from(REQUEST.as_mut_ptr()) };
+
+        unsafe {
+            DRIVER.vmpck0_seqno = 1;
+            DRIVER.request = SnpGuestRequestMsg { buffer: req_va };
+            DRIVER.state = DriverState::Ready;
+        }
+    }
+
+    #[test]
+    fn aes_gcm_encrypt_and_decrypt() {
+        guest_request_driver_init();
+
+        let payload = b"request-to-be-encrypted";
+        let vmpck0 = [5u8; VMPCK_SIZE];
+
+        unsafe {
+            let result = DRIVER.request.load(
+                SNP_MSG_REPORT_REQ,
+                DRIVER.vmpck0_seqno,
+                &vmpck0,
+                VirtAddr::from(payload as *const u8),
+                payload.len() as u16,
+            );
+
+            assert!(result.is_ok());
+
+            let mut decrypted_payload: Vec<u8> = Vec::with_capacity(PAGE_SIZE);
+            let decrypted_payload_va = VirtAddr::from(decrypted_payload.as_ptr());
+
+            let result = DRIVER.request.unwrap(
+                SNP_MSG_REPORT_REQ,
+                DRIVER.vmpck0_seqno,
+                &vmpck0,
+                decrypted_payload_va,
+                PAGE_SIZE,
+            );
+
+            assert!(result.is_ok());
+
+            let decrypted_payload_len = result.unwrap();
+            assert_eq!(decrypted_payload_len, payload.len());
+
+            decrypted_payload.set_len(decrypted_payload_len);
+            assert_eq!(decrypted_payload.as_slice(), payload);
+        }
+    }
+}

src/greq/mod.rs

@@ -4,4 +4,5 @@
 //
 // Authors: Claudio Carvalho <[email protected]>
 
+pub mod driver;
 pub mod msg;