From nobody Sat Feb 7 05:52:15 2026 Received: from fout-b5-smtp.messagingengine.com (fout-b5-smtp.messagingengine.com [202.12.124.148]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id D30F31AA1E4; Thu, 27 Feb 2025 03:12:29 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=202.12.124.148 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1740625951; cv=none; b=bFimsrGtStY/CJqTNFRbEgr09hW5ypG5dbJ4XLHqVMYAXiPmW9iPBAdClfO/4I3LF6z1947fFMVnGK7Iv/8N5NX9luwbE4hit7MZeoG8PKwzOCEOvQLF8w7087a7vbwqY+81O4zSSFi1CIosspSLmnNJOX5kMbgcBQqBxvzDK3M= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1740625951; c=relaxed/simple; bh=oLc6vRpYJ0xDVs2Dp2SxK42oRhdIET3pEOCkPPlQDTk=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=ocImuJMpYwdht4L6GbW13dJiqs5R/eWehlwKhl1NqHOHBbUIf2AUYUMkUPpGYsrZwgd05xqkF5jZd3jbuSVh1EtdJkQrj0OVOGLTUeGfT5gF6xBnWhSBvXSLLyX5cuehzchpMoCeuaVazBUcEFe4zVNTsgZdF1ynXHfOr42wodk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=alistair23.me; spf=pass smtp.mailfrom=alistair23.me; dkim=pass (2048-bit key) header.d=alistair23.me header.i=@alistair23.me header.b=HamN6V9y; dkim=pass (2048-bit key) header.d=messagingengine.com header.i=@messagingengine.com header.b=Iu21XGJ5; arc=none smtp.client-ip=202.12.124.148 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=alistair23.me Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=alistair23.me Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=alistair23.me header.i=@alistair23.me header.b="HamN6V9y"; dkim=pass (2048-bit key) header.d=messagingengine.com header.i=@messagingengine.com header.b="Iu21XGJ5" Received: from phl-compute-06.internal (phl-compute-06.phl.internal [10.202.2.46]) by mailfout.stl.internal (Postfix) with ESMTP id 9F82411401BD; Wed, 26 Feb 2025 22:12:28 -0500 (EST) Received: from phl-mailfrontend-01 ([10.202.2.162]) by phl-compute-06.internal (MEProxy); Wed, 26 Feb 2025 22:12:29 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=alistair23.me; h=cc:cc:content-transfer-encoding:content-type:date:date:from :from:in-reply-to:in-reply-to:message-id:mime-version:references :reply-to:subject:subject:to:to; s=fm1; t=1740625948; x= 1740712348; bh=gvplroEYlID/SuFvQTVuGaL+OgftQDgU+sH7ibNw/EY=; b=H amN6V9ykH3sBV6UobUMbew3hkf75Yw6PYVR0ys3kaNBYBUTqe5imt/gEaTSfJnDM oIEd24RF0wqzWagEX+E/2ZHvEOVnM7/GraGg2q2WEADiYkaPCcWZrlQCHwNQTBVi U8Et3NsljPvdAJQ5Cg8dak1N8DQkp22i+G0Oh+ufqDNLUrLneXKOzrh6z5Mu2lp7 jOTUU27pVVxMfkmOERra6j31XCI8gvufuINrgVvpWEu1LYJg5IEPlkqazerFaIvn xaFnmcSE9Bth0afhNtVXWlnW0MSjLJtZr+1/5zsbxdbc7HYDM9CH5YjyUXv2kbHw H0E7Q8wfiUIa0Akjxe6IQ== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:cc:content-transfer-encoding :content-type:date:date:feedback-id:feedback-id:from:from :in-reply-to:in-reply-to:message-id:mime-version:references :reply-to:subject:subject:to:to:x-me-proxy:x-me-sender :x-me-sender:x-sasl-enc; s=fm1; t=1740625948; x=1740712348; bh=g vplroEYlID/SuFvQTVuGaL+OgftQDgU+sH7ibNw/EY=; b=Iu21XGJ5gtoE3EMn2 2pe/AJr/BA6qKaH3n1mUOPEB0/QOgmIPpxrbuDLH572NiB5KxYxGs27mh7ClqRZg WtDD7bbUFYOWG/QlCoG8D7hj9Vs052kSV6hZPhucnILkoxvHI5ILfGeekIsxXk6o xL2ldfRj0kL+3LDlPjOy/BajMdl1kHM5WEUUNRhEGQk0PF60yyQAUzEi+MffV4iI DsuzkvKa19ZDoFCPVgvBY2GEVtUpcloZhfYI49jDkhl9dseGJrFQrA6dVkNhhDh6 lNBYq4UYnSl8fk7yHD3Uwk2KW1GcYA4tyAtb8IQ1vd28BTFs3XtrKARMisQ2k2io q1m2g== X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgeefvddrtddtgdekieefiecutefuodetggdotefrod ftvfcurfhrohhfihhlvgemucfhrghsthforghilhdpggftfghnshhusghstghrihgsvgdp uffrtefokffrpgfnqfghnecuuegrihhlohhuthemuceftddtnecuogfuohhrthgvugftvg gtihhpvdculdegtddmnecujfgurhephffvvefufffkofgjfhgggfestdekredtredttden ucfhrhhomheptehlihhsthgrihhrucfhrhgrnhgtihhsuceorghlihhsthgrihhrsegrlh hishhtrghirhdvfedrmhgvqeenucggtffrrghtthgvrhhnpefhvedvvdefjeduffeujefh hfeigfelheelvdfgfeejueeuhfelieffleehleekudenucffohhmrghinhepsggrshgvpg grshihmhgpvghntgdrrghspdgsrghsvggphhgrshhhpggrlhhgpghnrghmvgdrrghspdht rhgrnhhstghrihhpthdrrghspdhophgrqhhuvggpuggrthgrpghlvghnrdhtohenucevlh hushhtvghrufhiiigvpedtnecurfgrrhgrmhepmhgrihhlfhhrohhmpegrlhhishhtrghi rhesrghlihhsthgrihhrvdefrdhmvgdpnhgspghrtghpthhtohepvddtpdhmohguvgepsh hmthhpohhuthdprhgtphhtthhopehlihhnuhigqdgtgihlsehvghgvrhdrkhgvrhhnvghl rdhorhhgpdhrtghpthhtoheplhhinhhugidqkhgvrhhnvghlsehvghgvrhdrkhgvrhhnvg hlrdhorhhgpdhrtghpthhtoheplhhukhgrshesfihunhhnvghrrdguvgdprhgtphhtthho pehlihhnuhigqdhptghisehvghgvrhdrkhgvrhhnvghlrdhorhhgpdhrtghpthhtohepsg hhvghlghgrrghssehgohhoghhlvgdrtghomhdprhgtphhtthhopehjohhnrghthhgrnhdr tggrmhgvrhhonheshhhurgifvghirdgtohhmpdhrtghpthhtoheprhhushhtqdhfohhrqd hlihhnuhigsehvghgvrhdrkhgvrhhnvghlrdhorhhgpdhrtghpthhtoheprghkphhmsehl ihhnuhigqdhfohhunhgurghtihhonhdrohhrghdprhgtphhtthhopegsohhquhhnrdhfvg hnghesghhmrghilhdrtghomh X-ME-Proxy: Feedback-ID: ifd214418:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Wed, 26 Feb 2025 22:12:22 -0500 (EST) From: Alistair Francis To: linux-cxl@vger.kernel.org, linux-kernel@vger.kernel.org, lukas@wunner.de, linux-pci@vger.kernel.org, bhelgaas@google.com, Jonathan.Cameron@huawei.com, rust-for-linux@vger.kernel.org, akpm@linux-foundation.org Cc: boqun.feng@gmail.com, bjorn3_gh@protonmail.com, wilfred.mallawa@wdc.com, aliceryhl@google.com, ojeda@kernel.org, alistair23@gmail.com, a.hindborg@kernel.org, tmgross@umich.edu, gary@garyguo.net, alex.gaynor@gmail.com, benno.lossin@proton.me, Alistair Francis Subject: [RFC v2 20/20] lib: rspdm: Support SPDM challenge Date: Thu, 27 Feb 2025 13:09:52 +1000 Message-ID: <20250227030952.2319050-21-alistair@alistair23.me> X-Mailer: git-send-email 2.48.1 In-Reply-To: <20250227030952.2319050-1-alistair@alistair23.me> References: <20250227030952.2319050-1-alistair@alistair23.me> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Signed-off-by: Alistair Francis --- lib/rspdm/consts.rs | 6 + lib/rspdm/lib.rs | 8 +- lib/rspdm/state.rs | 212 ++++++++++++++++++++++++++++++-- lib/rspdm/validator.rs | 65 +++++++++- rust/bindings/bindings_helper.h | 1 + 5 files changed, 283 insertions(+), 9 deletions(-) diff --git a/lib/rspdm/consts.rs b/lib/rspdm/consts.rs index ffaf36ec583b..af4e1a98dc5b 100644 --- a/lib/rspdm/consts.rs +++ b/lib/rspdm/consts.rs @@ -98,6 +98,8 @@ pub(crate) enum SpdmErrorCode { =20 pub(crate) const SPDM_GET_CERTIFICATE: u8 =3D 0x82; =20 +pub(crate) const SPDM_CHALLENGE: u8 =3D 0x83; + #[cfg(CONFIG_CRYPTO_RSA)] pub(crate) const SPDM_ASYM_RSA: u32 =3D SPDM_ASYM_RSASSA_2048 | SPDM_ASYM_RSASSA_3072 | SPDM_ASYM_RSASSA_4096; @@ -127,3 +129,7 @@ pub(crate) enum SpdmErrorCode { // pub(crate) const SPDM_MAX_REQ_ALG_STRUCT: usize =3D 4; =20 pub(crate) const SPDM_OPAQUE_DATA_FMT_GENERAL: u8 =3D 1 << 1; + +pub(crate) const SPDM_PREFIX_SZ: usize =3D 64; +pub(crate) const SPDM_COMBINED_PREFIX_SZ: usize =3D 100; +pub(crate) const SPDM_MAX_OPAQUE_DATA: usize =3D 1024; diff --git a/lib/rspdm/lib.rs b/lib/rspdm/lib.rs index b7ad3b8c659e..c0e3e039c14f 100644 --- a/lib/rspdm/lib.rs +++ b/lib/rspdm/lib.rs @@ -137,17 +137,23 @@ provisioned_slots &=3D !(1 << slot); } =20 + let mut verify =3D true; let mut provisioned_slots =3D state.provisioned_slots; while (provisioned_slots as usize) > 0 { let slot =3D provisioned_slots.trailing_zeros() as u8; =20 if let Err(e) =3D state.validate_cert_chain(slot) { - return e.to_errno() as c_int; + pr_debug!("Certificate in slot {slot} failed to verify: {e:?}"= ); + verify =3D false; } =20 provisioned_slots &=3D !(1 << slot); } =20 + if let Err(e) =3D state.challenge(state.provisioned_slots.trailing_zer= os() as u8, verify) { + return e.to_errno() as c_int; + } + 0 } =20 diff --git a/lib/rspdm/state.rs b/lib/rspdm/state.rs index 974d2ee8c0ce..4629c12a1b81 100644 --- a/lib/rspdm/state.rs +++ b/lib/rspdm/state.rs @@ -14,23 +14,27 @@ bindings, error::{code::EINVAL, from_err_ptr, to_result, Error}, str::CStr, + str::CString, validate::Untrusted, }; =20 use crate::consts::{ SpdmErrorCode, SPDM_ASYM_ALGOS, SPDM_ASYM_ECDSA_ECC_NIST_P256, SPDM_AS= YM_ECDSA_ECC_NIST_P384, SPDM_ASYM_ECDSA_ECC_NIST_P521, SPDM_ASYM_RSASSA_2048, SPDM_ASYM_RSASSA= _3072, - SPDM_ASYM_RSASSA_4096, SPDM_ERROR, SPDM_GET_VERSION_LEN, SPDM_HASH_ALG= OS, SPDM_HASH_SHA_256, - SPDM_HASH_SHA_384, SPDM_HASH_SHA_512, SPDM_KEY_EX_CAP, SPDM_MAX_VER, S= PDM_MEAS_CAP_MASK, - SPDM_MEAS_SPEC_DMTF, SPDM_MIN_DATA_TRANSFER_SIZE, SPDM_MIN_VER, SPDM_O= PAQUE_DATA_FMT_GENERAL, + SPDM_ASYM_RSASSA_4096, SPDM_COMBINED_PREFIX_SZ, SPDM_ERROR, SPDM_GET_V= ERSION_LEN, + SPDM_HASH_ALGOS, SPDM_HASH_SHA_256, SPDM_HASH_SHA_384, SPDM_HASH_SHA_5= 12, SPDM_KEY_EX_CAP, + SPDM_MAX_OPAQUE_DATA, SPDM_MAX_VER, SPDM_MEAS_CAP_MASK, SPDM_MEAS_SPEC= _DMTF, + SPDM_MIN_DATA_TRANSFER_SIZE, SPDM_MIN_VER, SPDM_OPAQUE_DATA_FMT_GENERA= L, SPDM_PREFIX_SZ, SPDM_REQ, SPDM_RSP_MIN_CAPS, SPDM_SLOTS, SPDM_VER_10, SPDM_VER_11, SPD= M_VER_12, }; use crate::validator::{ - GetCapabilitiesReq, GetCapabilitiesRsp, GetCertificateReq, GetCertific= ateRsp, GetDigestsReq, - GetDigestsRsp, GetVersionReq, GetVersionRsp, NegotiateAlgsReq, Negotia= teAlgsRsp, RegAlg, - SpdmErrorRsp, SpdmHeader, + ChallengeReq, ChallengeRsp, GetCapabilitiesReq, GetCapabilitiesRsp, Ge= tCertificateReq, + GetCertificateRsp, GetDigestsReq, GetDigestsRsp, GetVersionReq, GetVer= sionRsp, + NegotiateAlgsReq, NegotiateAlgsRsp, RegAlg, SpdmErrorRsp, SpdmHeader, }; =20 +const SPDM_CONTEXT: &str =3D "responder-challenge_auth signing"; + /// The current SPDM session state for a device. Based on the /// C `struct spdm_state`. /// @@ -78,6 +82,12 @@ /// @slot_sz: Certificate chain size (in bytes). /// @leaf_key: Public key portion of leaf certificate against which to che= ck /// responder's signatures. +/// @transcript: Concatenation of all SPDM messages exchanged during an +/// authentication or measurement sequence. Used to verify the signature, +/// as it is computed over the hashed transcript. +/// @next_nonce: Requester nonce to be used for the next authentication +/// sequence. Populated from user space through sysfs. +/// If user space does not provide a nonce, the kernel uses a random one. /// /// `authenticated`: Whether device was authenticated successfully. pub struct SpdmState { @@ -113,6 +123,10 @@ pub struct SpdmState { pub(crate) slot: [Option>; SPDM_SLOTS], slot_sz: [usize; SPDM_SLOTS], pub(crate) leaf_key: Option<*mut bindings::public_key>, + + transcript: KVec, + + next_nonce: Option<&'static mut [u8]>, } =20 #[repr(C, packed)] @@ -156,6 +170,8 @@ pub(crate) fn new( slot: [const { None }; SPDM_SLOTS], slot_sz: [0; SPDM_SLOTS], leaf_key: None, + transcript: KVec::new(), + next_nonce: None, } } =20 @@ -263,7 +279,7 @@ fn spdm_err(&self, rsp: &SpdmErrorRsp) -> Result<(), Er= ror> { /// The data in `request_buf` is sent to the device and the response is /// stored in `response_buf`. pub(crate) fn spdm_exchange( - &self, + &mut self, request_buf: &mut [u8], response_buf: &mut [u8], ) -> Result { @@ -271,6 +287,8 @@ pub(crate) fn spdm_exchange( let request: &mut SpdmHeader =3D Untrusted::new_mut(request_buf).v= alidate_mut()?; let response: &SpdmHeader =3D Untrusted::new_ref(response_buf).val= idate()?; =20 + self.transcript.extend_from_slice(request_buf, GFP_KERNEL)?; + let transport_function =3D self.transport.ok_or(EINVAL)?; // SAFETY: `transport_function` is provided by the new(), we are // calling the function. @@ -337,6 +355,12 @@ pub(crate) fn get_version(&mut self) -> Result<(), Err= or> { unsafe { response_vec.set_len(rc as usize) }; =20 let response: &mut GetVersionRsp =3D Untrusted::new_mut(&mut respo= nse_vec).validate_mut()?; + let rsp_sz =3D core::mem::size_of::() + + 2 + + response.version_number_entry_count as usize * 2; + + self.transcript + .extend_from_slice(&response_vec[..rsp_sz], GFP_KERNEL)?; =20 let mut foundver =3D false; for i in 0..response.version_number_entry_count { @@ -400,6 +424,9 @@ pub(crate) fn get_capabilities(&mut self) -> Result<(),= Error> { let response: &mut GetCapabilitiesRsp =3D Untrusted::new_mut(&mut response_vec).validate_mut()?; =20 + self.transcript + .extend_from_slice(&response_vec[..rsp_sz], GFP_KERNEL)?; + self.rsp_caps =3D u32::from_le(response.flags); if (self.rsp_caps & SPDM_RSP_MIN_CAPS) !=3D SPDM_RSP_MIN_CAPS { to_result(-(bindings::EPROTONOSUPPORT as i32))?; @@ -539,6 +566,9 @@ pub(crate) fn negotiate_algs(&mut self) -> Result<(), E= rror> { let response: &mut NegotiateAlgsRsp =3D Untrusted::new_mut(&mut response_vec).validate_mut()?; =20 + self.transcript + .extend_from_slice(&response_vec[..rsp_sz], GFP_KERNEL)?; + self.base_asym_alg =3D response.base_asym_sel; self.base_hash_alg =3D response.base_hash_sel; self.meas_hash_alg =3D response.measurement_hash_algo; @@ -598,6 +628,10 @@ pub(crate) fn get_digests(&mut self) -> Result<(), Err= or> { unsafe { response_vec.set_len(rc as usize) }; =20 let response: &mut GetDigestsRsp =3D Untrusted::new_mut(&mut respo= nse_vec).validate_mut()?; + let rsp_sz =3D core::mem::size_of::() + response.param= 2 as usize * self.hash_len; + + self.transcript + .extend_from_slice(&response_vec[..rsp_sz], GFP_KERNEL)?; =20 if rc < (core::mem::size_of::() @@ -659,6 +693,10 @@ fn get_cert_exchange( unsafe { response_vec.set_len(rc as usize) }; =20 let response: &mut GetCertificateRsp =3D Untrusted::new_mut(respon= se_vec).validate_mut()?; + let rsp_sz =3D core::mem::size_of::() + 4 + response.p= ortion_length as usize; + + self.transcript + .extend_from_slice(&response_vec[..rsp_sz], GFP_KERNEL)?; =20 if rc < (core::mem::size_of::() + response.portio= n_length as usize) as i32 @@ -836,4 +874,164 @@ pub(crate) fn validate_cert_chain(&mut self, slot: u8= ) -> Result<(), Error> { =20 Ok(()) } + + pub(crate) fn challenge_rsp_len(&mut self, nonce_len: usize, opaque_le= n: usize) -> usize { + let mut length =3D + core::mem::size_of::() + self.hash_len + nonce_len= + opaque_len + 2; + + if self.version >=3D 0x13 { + length +=3D 8; + } + + length + self.sig_len + } + + fn verify_signature(&mut self, response_vec: &mut [u8]) -> Result<(), = Error> { + let sig_start =3D response_vec.len() - self.sig_len; + let mut sig =3D bindings::public_key_signature::default(); + let mut mhash: KVec =3D KVec::new(); + + sig.s =3D &mut response_vec[sig_start..] as *mut _ as *mut u8; + sig.s_size =3D self.sig_len as u32; + sig.encoding =3D self.base_asym_enc.as_ptr(); + sig.hash_algo =3D self.base_hash_alg_name.as_ptr(); + + let mut m: KVec =3D KVec::new(); + m.extend_with(SPDM_COMBINED_PREFIX_SZ + self.hash_len, 0, GFP_KERN= EL)?; + + if let Some(desc) =3D &mut self.desc { + desc.tfm =3D self.shash; + + unsafe { + to_result(bindings::crypto_shash_digest( + *desc, + self.transcript.as_ptr(), + (self.transcript.len() - self.sig_len) as u32, + m[SPDM_COMBINED_PREFIX_SZ..].as_mut_ptr(), + ))?; + }; + } else { + to_result(-(bindings::EPROTO as i32))?; + } + + if self.version <=3D 0x11 { + sig.digest =3D m[SPDM_COMBINED_PREFIX_SZ..].as_mut_ptr(); + } else { + let major =3D self.version >> 4; + let minor =3D self.version & 0xF; + + let output =3D CString::try_from_fmt(fmt!("dmtf-spdm-v{major:x= }.{minor:x}.*dmtf-spdm-v{major:x}.{minor:x}.*dmtf-spdm-v{major:x}.{minor:x}= .*dmtf-spdm-v{major:x}.{minor:x}.*"))?; + let mut buf =3D output.take_buffer(); + let zero_pad_len =3D SPDM_COMBINED_PREFIX_SZ - SPDM_PREFIX_SZ = - SPDM_CONTEXT.len() - 1; + + buf.extend_with(zero_pad_len, 0, GFP_KERNEL)?; + buf.extend_from_slice(SPDM_CONTEXT.as_bytes(), GFP_KERNEL)?; + + m[..SPDM_COMBINED_PREFIX_SZ].copy_from_slice(&buf); + + mhash.extend_with(self.hash_len, 0, GFP_KERNEL)?; + + if let Some(desc) =3D &mut self.desc { + desc.tfm =3D self.shash; + + unsafe { + to_result(bindings::crypto_shash_digest( + *desc, + m.as_ptr(), + m.len() as u32, + mhash.as_mut_ptr(), + ))?; + }; + } else { + to_result(-(bindings::EPROTO as i32))?; + } + + sig.digest =3D mhash.as_mut_ptr(); + } + + sig.digest_size =3D self.hash_len as u32; + + if let Some(leaf_key) =3D self.leaf_key { + unsafe { to_result(bindings::public_key_verify_signature(leaf_= key, &sig)) } + } else { + to_result(-(bindings::EPROTO as i32)) + } + } + + pub(crate) fn challenge(&mut self, slot: u8, verify: bool) -> Result<(= ), Error> { + let mut request =3D ChallengeReq::default(); + request.version =3D self.version; + request.param1 =3D slot; + + let nonce_len =3D request.nonce.len(); + + if let Some(nonce) =3D &self.next_nonce { + request.nonce.copy_from_slice(&nonce); + self.next_nonce =3D None; + } else { + unsafe { + bindings::get_random_bytes(&mut request.nonce as *mut _ as= *mut c_void, nonce_len) + }; + } + + let req_sz =3D if self.version <=3D 0x12 { + core::mem::size_of::() - 8 + } else { + core::mem::size_of::() + }; + + let rsp_sz =3D self.challenge_rsp_len(nonce_len, SPDM_MAX_OPAQUE_D= ATA); + + // SAFETY: `request` is repr(C) and packed, so we can convert it t= o a slice + let request_buf =3D unsafe { from_raw_parts_mut(&mut request as *m= ut _ as *mut u8, req_sz) }; + + let mut response_vec: KVec =3D KVec::with_capacity(rsp_sz, GFP= _KERNEL)?; + // SAFETY: `request` is repr(C) and packed, so we can convert it t= o a slice + let response_buf =3D unsafe { from_raw_parts_mut(response_vec.as_m= ut_ptr(), rsp_sz) }; + + let rc =3D self.spdm_exchange(request_buf, response_buf)?; + + if rc < (core::mem::size_of::() as i32) { + pr_err!("Truncated challenge response\n"); + to_result(-(bindings::EIO as i32))?; + } + + // SAFETY: `rc` bytes where inserted to the raw pointer by spdm_ex= change + unsafe { response_vec.set_len(rc as usize) }; + + let _response: &mut ChallengeRsp =3D Untrusted::new_mut(&mut respo= nse_vec).validate_mut()?; + + let opaque_len_offset =3D core::mem::size_of::() + sel= f.hash_len + nonce_len; + let opaque_len =3D u16::from_le_bytes( + response_vec[opaque_len_offset..(opaque_len_offset + 2)] + .try_into() + .unwrap_or([0, 0]), + ); + + let rsp_sz =3D self.challenge_rsp_len(nonce_len, opaque_len as usi= ze); + + if rc < rsp_sz as i32 { + pr_err!("Truncated challenge response\n"); + to_result(-(bindings::EIO as i32))?; + } + + self.transcript + .extend_from_slice(&response_vec[..rsp_sz], GFP_KERNEL)?; + + if verify { + /* Verify signature at end of transcript against leaf key */ + match self.verify_signature(&mut response_vec[..rsp_sz]) { + Ok(()) =3D> { + pr_info!("Authenticated with certificate slot {slot}"); + self.authenticated =3D true; + } + Err(e) =3D> { + pr_err!("Cannot verify challenge_auth signature: {e:?}= "); + self.authenticated =3D false; + } + }; + } + + Ok(()) + } } diff --git a/lib/rspdm/validator.rs b/lib/rspdm/validator.rs index a8bc3378676f..f8a5337841f0 100644 --- a/lib/rspdm/validator.rs +++ b/lib/rspdm/validator.rs @@ -17,7 +17,7 @@ }; =20 use crate::consts::{ - SPDM_ASYM_ALGOS, SPDM_CTEXPONENT, SPDM_GET_CAPABILITIES, SPDM_GET_CERT= IFICATE, + SPDM_ASYM_ALGOS, SPDM_CHALLENGE, SPDM_CTEXPONENT, SPDM_GET_CAPABILITIE= S, SPDM_GET_CERTIFICATE, SPDM_GET_DIGESTS, SPDM_GET_VERSION, SPDM_HASH_ALGOS, SPDM_MEAS_SPEC_DM= TF, SPDM_NEGOTIATE_ALGS, SPDM_REQ_CAPS, }; @@ -424,3 +424,66 @@ fn validate(unvalidated: &mut Unvalidated>) -= > Result Ok(rsp) } } + +#[repr(C, packed)] +pub(crate) struct ChallengeReq { + pub(crate) version: u8, + pub(crate) code: u8, + pub(crate) param1: u8, + pub(crate) param2: u8, + + pub(crate) nonce: [u8; 32], + pub(crate) context: [u8; 8], +} + +impl Default for ChallengeReq { + fn default() -> Self { + ChallengeReq { + version: 0, + code: SPDM_CHALLENGE, + param1: 0, + param2: 0, + nonce: [0; 32], + context: [0; 8], + } + } +} + +#[repr(C, packed)] +pub(crate) struct ChallengeRsp { + pub(crate) version: u8, + pub(crate) code: u8, + pub(crate) param1: u8, + pub(crate) param2: u8, + + pub(crate) cert_chain_hash: __IncompleteArrayField, + pub(crate) nonce: [u8; 32], + pub(crate) message_summary_hash: __IncompleteArrayField, + + pub(crate) opaque_data_len: u16, + pub(crate) opaque_data: __IncompleteArrayField, + + pub(crate) context: [u8; 8], + pub(crate) signature: __IncompleteArrayField, +} + +impl Validate<&mut Unvalidated>> for &mut ChallengeRsp { + type Err =3D Error; + + fn validate(unvalidated: &mut Unvalidated>) -> Result { + let raw =3D unvalidated.raw_mut(); + if raw.len() < mem::size_of::() { + return Err(EINVAL); + } + + let ptr =3D raw.as_mut_ptr(); + // CAST: `ChallengeRsp` only contains integers and has `repr(C)`. + let ptr =3D ptr.cast::(); + // SAFETY: `ptr` came from a reference and the cast above is valid. + let rsp: &mut ChallengeRsp =3D unsafe { &mut *ptr }; + + // rsp.opaque_data_len =3D rsp.opaque_data_len.to_le(); + + Ok(rsp) + } +} diff --git a/rust/bindings/bindings_helper.h b/rust/bindings/bindings_helpe= r.h index daeb599fb990..16b8602c6d1a 100644 --- a/rust/bindings/bindings_helper.h +++ b/rust/bindings/bindings_helper.h @@ -7,6 +7,7 @@ */ =20 #include +#include #include #include #include --=20 2.48.1