feat: no_std

Author: sander

Cargo.toml

@@ -2,7 +2,7 @@
 name = "scal3"
 description = "Verify that systems operate under your sole control (prototype, patent pending)"
 license = "CC-BY-NC-4.0"
-version = "0.3.5"
+version = "0.3.7"
 edition = "2021"
 repository = "https://github.com/cleverbase/scal3"
 authors = ["Sander Dijkhuis <sander.dijkhuis@cleverbase.com>"]
@@ -28,6 +28,7 @@ minicbor-derive = "0.16.2"
 serde = { version = "1.0.219", features = ["derive"] }
 serde_bytes = "0.11.17"
 once_cell = "1.21.3"
+spin = { version = "0.9.8", default-features = false, features = ["mutex", "once", "spin_mutex"] }
 
 [dev-dependencies]
 hmac = "0.12.1"

src/api/mod.rs

@@ -2,6 +2,7 @@ use crate::domain::Authentication;
 use crate::handle::insert_authentication;
 use crate::{domain, program};
 use serde::{Deserialize, Serialize};
+use alloc::string::String;
 
 /// Enrolled verification data for the [subscriber].
 ///

src/dispatch.rs

@@ -5,6 +5,7 @@ use crate::api::{
 use crate::handle::get_authentication;
 use crate::{Error, ErrorResponse, Response};
 use serde::Deserialize;
+use alloc::vec::Vec;
 
 #[derive(Deserialize)]
 #[serde(tag = "type", rename_all = "camelCase")]

src/domain.rs

@@ -23,8 +23,8 @@ use p256::{ecdsa, FieldBytes, ProjectivePoint, PublicKey};
 use rand_chacha::ChaCha20Rng;
 use sha2::{Digest, Sha256};
 use signature::{Signer, Verifier as SignatureVerifier};
-use std::collections::BTreeMap;
-use std::io::Write;
+use alloc::collections::BTreeMap;
+use alloc::vec::Vec;
 
 pub(crate) struct Verifier {
     blinded_subscriber_share: p256::Scalar,
@@ -46,18 +46,41 @@ pub(crate) struct Pass {
 impl Pass {
     pub(crate) fn to_bytes(&self) -> [u8; 308] {
         let mut encoded = [0u8; 308];
-        let mut buf = &mut encoded[..];
-        buf.write_all(&challenge_to_bytes(self.subscriber_commitments))
-            .unwrap(); // 66
-        buf.write_all(&self.authenticator_proof.sig_device.to_bytes())
-            .unwrap(); // 64
-        buf.write_all(self.binding.pk.to_encoded_point(true).as_bytes())
-            .unwrap(); // 33
-        buf.write_all(&self.binding.signature.to_bytes()).unwrap(); // 64
-        buf.write_all(&pk_sender_to_bytes(&self.pk_kem_sender))
-            .unwrap(); // 33
-        buf.write_all(&self.sealed_signature_share).unwrap(); // 32
-        buf.write_all(&self.tag.to_bytes()).unwrap(); // 16
+        let mut offset = 0;
+        
+        // 66 bytes
+        let challenge_bytes = challenge_to_bytes(self.subscriber_commitments);
+        encoded[offset..offset + 66].copy_from_slice(&challenge_bytes);
+        offset += 66;
+        
+        // 64 bytes
+        let sig_device_bytes = self.authenticator_proof.sig_device.to_bytes();
+        encoded[offset..offset + 64].copy_from_slice(&sig_device_bytes);
+        offset += 64;
+        
+        // 33 bytes
+        let pk_bytes = self.binding.pk.to_encoded_point(true);
+        encoded[offset..offset + 33].copy_from_slice(pk_bytes.as_bytes());
+        offset += 33;
+        
+        // 64 bytes
+        let signature_bytes = self.binding.signature.to_bytes();
+        encoded[offset..offset + 64].copy_from_slice(&signature_bytes);
+        offset += 64;
+        
+        // 33 bytes
+        let pk_sender_bytes = pk_sender_to_bytes(&self.pk_kem_sender);
+        encoded[offset..offset + 33].copy_from_slice(&pk_sender_bytes);
+        offset += 33;
+        
+        // 32 bytes
+        encoded[offset..offset + 32].copy_from_slice(&self.sealed_signature_share);
+        offset += 32;
+        
+        // 16 bytes
+        let tag_bytes = self.tag.to_bytes();
+        encoded[offset..offset + 16].copy_from_slice(&tag_bytes);
+        
         encoded
     }
 
@@ -151,11 +174,22 @@ impl ClientExtensionTranscript {
 impl ClientExtensionTranscript {
     pub(crate) fn to_bytes(&self) -> [u8; 129] {
         let mut encoded = [0u8; 129];
-        let mut buf = &mut encoded[..];
-        buf.write_all(&self.pk_binding.to_encoded_point(true).as_bytes())
-            .unwrap();
-        buf.write_all(&self.sig_binding.to_bytes()).unwrap();
-        buf.write_all(&self.sig_joint_second.to_bytes()).unwrap();
+        let mut offset = 0;
+        
+        // 33 bytes
+        let pk_binding_bytes = self.pk_binding.to_encoded_point(true);
+        encoded[offset..offset + 33].copy_from_slice(pk_binding_bytes.as_bytes());
+        offset += 33;
+        
+        // 64 bytes
+        let sig_binding_bytes = self.sig_binding.to_bytes();
+        encoded[offset..offset + 64].copy_from_slice(&sig_binding_bytes);
+        offset += 64;
+        
+        // 32 bytes
+        let sig_joint_second_bytes = self.sig_joint_second.to_bytes();
+        encoded[offset..offset + 32].copy_from_slice(&sig_joint_second_bytes);
+        
         encoded
     }
 }
@@ -187,7 +221,7 @@ pub(crate) struct Provider {
 #[derive(Debug, PartialEq)]
 pub(crate) struct VerificationError;
 
-pub(crate) type Result = std::result::Result<(), VerificationError>;
+pub(crate) type Result = core::result::Result<(), VerificationError>;
 
 fn aad(masked_subscriber_share: &p256::Scalar, pk_joint: &frost::VerifyingKey) -> Vec<u8> {
     [
@@ -665,7 +699,7 @@ mod test {
         let mut rng_hpke = rand_chacha::ChaCha20Rng::from_seed(seed);
         let (sk_r, pk_r) = DhP256HkdfSha256::gen_keypair(&mut rng_hpke);
         let verifier = Verifier::new(&pk_r, &mask, &mut rng_hpke);
-        println!("size of share: {:?}", verifier.sealed_provider_share.len());
+        // Removed println! for no_std compatibility
         let shared_secret = dh(&sk_r, &verifier.pk_kem_subscriber);
         let s = verifier.verify(shared_secret, &pk_r);
         assert!(s.is_some());

src/ffi.rs

@@ -1,4 +1,7 @@
 use crate::dispatch::dispatch;
+use core::slice;
+use core::mem;
+use alloc::vec::Vec;
 
 /// Dispatches a CBOR-encoded request and outputs a CBOR-encoded response, which must be freed using [free].
 #[export_name = "scal3_process"]
@@ -8,11 +11,11 @@ pub unsafe extern "C" fn process(
     output_ptr: *mut *mut u8,
     output_len: *mut usize,
 ) {
-    let input = std::slice::from_raw_parts(input_ptr, input_len);
+    let input = slice::from_raw_parts(input_ptr, input_len);
     let vec = dispatch(input);
     let len = vec.len();
     let ptr = vec.as_ptr();
-    std::mem::forget(vec);
+    mem::forget(vec);
     *output_ptr = ptr as *mut u8;
     *output_len = len;
 }

src/handle.rs

@@ -1,20 +1,29 @@
-use std::collections::HashMap;
-use std::sync::Mutex;
+use alloc::collections::BTreeMap;
+use alloc::boxed::Box;
+use spin::Mutex;
 use crate::domain::Authentication;
-use once_cell::sync::Lazy;
+use spin::Once;
 
-static CONTEXTS: Lazy<Mutex<HashMap<u64, Box<Authentication>>>> = Lazy::new(Default::default);
-static NEXT_ID: Lazy<Mutex<u64>> = Lazy::new(|| Mutex::new(1));
+static CONTEXTS: Once<Mutex<BTreeMap<u64, Box<Authentication>>>> = Once::new();
+static NEXT_ID: Once<Mutex<u64>> = Once::new();
+
+fn get_contexts() -> &'static Mutex<BTreeMap<u64, Box<Authentication>>> {
+    CONTEXTS.call_once(|| Mutex::new(BTreeMap::new()))
+}
+
+fn get_next_id() -> &'static Mutex<u64> {
+    NEXT_ID.call_once(|| Mutex::new(1))
+}
 
 pub fn insert_authentication(authentication: Authentication) -> u64 {
-    let mut authentications = CONTEXTS.lock().unwrap();
-    let mut next = NEXT_ID.lock().unwrap();
+    let mut authentications = get_contexts().lock();
+    let mut next = get_next_id().lock();
     let id = *next;
     *next += 1;
     authentications.insert(id, Box::new(authentication));
     id
 }
 
 pub fn get_authentication(id: u64) -> Option<Box<Authentication>> {
-    CONTEXTS.lock().unwrap().remove(&id)
+    get_contexts().lock().remove(&id)
 }

src/lib.rs

@@ -1,5 +1,11 @@
+#![no_std]
 #![doc = include_str!("README.md")]
 
+#[cfg(test)]
+extern crate std;
+
+extern crate alloc;
+
 pub(crate) mod api;
 mod dispatch;
 mod domain;
@@ -13,7 +19,7 @@ use api::*;
 pub use dispatch::dispatch;
 pub use ffi::*;
 use getrandom::register_custom_getrandom;
-use std::num::NonZeroU32;
+use core::num::NonZeroU32;
 
 const CUSTOM_ERROR_CODE: u32 = getrandom::Error::CUSTOM_START + 0;
 fn stub_get_random(_buf: &mut [u8]) -> Result<(), getrandom::Error> {

src/program/provider.rs

@@ -3,7 +3,7 @@ use crate::domain;
 use crate::domain::{pk_recipient_from_bytes, shared_secret_from_bytes, Provider, Result, VerificationError};
 use hpke::Serializable;
 use p256::elliptic_curve::sec1::ToEncodedPoint;
-use std::io::Write;
+
 
 pub(crate) fn accept(
     provider: &Key,
@@ -25,23 +25,17 @@ pub(crate) fn challenge(randomness: &Randomness) -> Challenge {
     };
     let (_, commitments) = provider.challenge();
     let mut challenge = [0u8; 66];
-    let mut buffer = &mut challenge[..];
-    buffer
-        .write_all(
-            p256::PublicKey::from_sec1_bytes(&commitments.hiding().serialize().unwrap())
-                .unwrap()
-                .to_encoded_point(true)
-                .as_bytes(),
-        )
-        .unwrap();
-    buffer
-        .write_all(
-            p256::PublicKey::from_sec1_bytes(&commitments.binding().serialize().unwrap())
-                .unwrap()
-                .to_encoded_point(true)
-                .as_bytes(),
-        )
-        .unwrap();
+    // 33 bytes for hiding commitment
+    let hiding_point = p256::PublicKey::from_sec1_bytes(&commitments.hiding().serialize().unwrap())
+        .unwrap()
+        .to_encoded_point(true);
+    challenge[0..33].copy_from_slice(hiding_point.as_bytes());
+    
+    // 33 bytes for binding commitment
+    let binding_point = p256::PublicKey::from_sec1_bytes(&commitments.binding().serialize().unwrap())
+        .unwrap()
+        .to_encoded_point(true);
+    challenge[33..66].copy_from_slice(binding_point.as_bytes());
     challenge
 }
 
@@ -81,7 +75,7 @@ mod tests {
     #[test]
     fn test_challenge() {
         let randomness = [1u8; 32];
-        let challenge = challenge(&randomness);
-        println!("{:x?}", challenge);
+        let _challenge = challenge(&randomness);
+        // Removed println! for no_std compatibility
     }
 }