feat: Add no_std support by migrating from std to core and alloc and updating dependencies.

Author: BenBirt

Cargo.toml

@@ -14,10 +14,11 @@ license = "MIT"
 
 [dependencies]
 base16ct = "0.3.0"
-base64ct = { version = "1.8.0", features = ["alloc"] }
-ed25519-dalek = "2.2.0"
-sha2 = "0.10.8"
-thiserror = "2.0.17"
+base64ct = { version = "1.8.0", default-features = false, features = ["alloc"] }
+ed25519-dalek = { version = "2.2.0", default-features = false, features = ["alloc"] }
+sha2 = { version = "0.10.8", default-features = false }
+spin = "0.9"
+thiserror = { version = "2.0.17", default-features = false }
 
 [dev-dependencies]
 hex-literal = "1.0.0"

src/crypto.rs

@@ -1,4 +1,4 @@
-use std::fmt;
+use core::fmt;
 
 use ed25519_dalek::ed25519::signature::Verifier as _;
 use sha2::{Digest, Sha256};
@@ -31,7 +31,7 @@ pub struct Signature {
 }
 
 /// A SHA256 digest.
-#[derive(Clone, Eq, Hash, PartialEq)]
+#[derive(Clone, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub struct Hash {
     bytes: [u8; HASH_SIZE],
 }
@@ -89,6 +89,7 @@ boilerplate!(Signature, 64);
 
 #[cfg(test)]
 mod tests {
+    use alloc::format;
     use hex_literal::hex;
 
     use super::*;

src/io/ascii/mod.rs

@@ -1,7 +1,8 @@
 mod parser;
 
 // This needs to be in scope to write!() to a String
-use std::fmt::Write as _;
+use alloc::{format, string::String, vec::Vec};
+use core::fmt::Write as _;
 
 use crate::{
     Hash, InclusionProof, Protoleaf, Signature, SignedTreeHead, SigsumSignature, WitnessCosignature,
@@ -175,6 +176,7 @@ impl SigsumSignature {
 
 #[cfg(test)]
 mod tests {
+    use alloc::{string::ToString, vec};
     use super::*;
     use hex_literal::hex;
     use lazy_static::lazy_static;

src/io/ascii/parser.rs

@@ -1,7 +1,8 @@
-use std::error::Error;
-use std::fmt;
-use std::iter::Peekable;
-use std::str::Lines;
+use alloc::{format, string::String, vec::Vec};
+use core::error::Error;
+use core::fmt;
+use core::iter::Peekable;
+use core::str::Lines;
 
 use crate::{
     crypto::{HASH_SIZE, PUBKEY_SIZE, SIGNATURE_SIZE},
@@ -28,7 +29,7 @@ macro_rules! bail {
     };
 }
 
-pub(crate) type Result<T> = std::result::Result<T, ParseAsciiError>;
+pub(crate) type Result<T> = core::result::Result<T, ParseAsciiError>;
 
 pub(crate) struct Parser<'a> {
     lines: Peekable<Lines<'a>>,
@@ -150,6 +151,7 @@ fn hexchar(ch: u8) -> Result<u8> {
 
 #[cfg(test)]
 mod tests {
+    use alloc::string::ToString;
     use super::*;
 
     #[test]

src/lib.rs

@@ -60,6 +60,10 @@
 //!
 //! Please make sure to update tests as appropriate.
 
+#![no_std]
+
+extern crate alloc;
+
 mod io {
     pub(crate) mod ascii;
 }

src/log.rs

@@ -1,5 +1,7 @@
 // Implements types related to the sigsum log
 
+use alloc::vec::Vec;
+
 use crate::crypto::{Hash, PublicKey, Signature};
 
 /// A signed tree head, as returned by the get-tree-head endpoint.

src/merkle/mod.rs

@@ -1,6 +1,7 @@
 // We want to keep the code as close as possible as the spec. So we ignore clippy warningcs.
 #![allow(clippy::all)]
 
+use alloc::vec::Vec;
 use sha2::{Digest, Sha256};
 
 type Hash = [u8; 32];
@@ -61,6 +62,7 @@ pub fn lsb(n: u64) -> bool {
 
 #[cfg(test)]
 mod tests {
+    use alloc::{string::String, vec::Vec};
     use super::*;
 
     use base64ct::{Base64, Encoding};

src/policy/builtin.rs

@@ -4,8 +4,8 @@
 //! and used directly as public statics, or looked up at runtime by name via
 //! [`Policy::builtin`].
 
-use std::ops::Deref;
-use std::sync::LazyLock;
+use core::ops::Deref;
+use spin::Lazy;
 
 use super::Policy;
 
@@ -20,7 +20,7 @@ pub struct BuiltInPolicy {
     /// The user-friendly name of the built-in policy.
     pub name: &'static str,
 
-    policy: LazyLock<Policy>,
+    policy: Lazy<Policy>,
 }
 
 impl BuiltInPolicy {
@@ -62,7 +62,7 @@ macro_rules! define_builtin_policies {
             #[doc = "```"]
             pub static $const_name: BuiltInPolicy = BuiltInPolicy {
                 name: $policy_name,
-                policy: LazyLock::new(|| {
+                policy: Lazy::new(|| {
                     Policy::parse(include_str!(concat!(
                         "../../builtin-policies/",
                         $policy_name,

src/policy/mod.rs

@@ -72,7 +72,7 @@
 //! let policy = builder.build();
 //! ```
 
-use std::collections::HashMap;
+use alloc::{collections::BTreeMap, string::String, vec::Vec};
 
 use crate::crypto::{Hash, PublicKey};
 
@@ -93,13 +93,13 @@ pub use parsing::ParsePolicyError;
 #[derive(Debug, Eq, PartialEq)]
 pub struct Policy {
     // logs keeps the list of log keys and URLs indexed by keyhash.
-    logs: HashMap<Hash, Entity>,
+    logs: BTreeMap<Hash, Entity>,
 
     // witnesses keeps the list of witness keys and URLs indexed by keyhash.
-    witnesses: HashMap<Hash, Entity>,
+    witnesses: BTreeMap<Hash, Entity>,
 
     // quorums keeps the quorum entries (witnesses and groups), indexed by name.
-    quorums: HashMap<String, Quorum>,
+    quorums: BTreeMap<String, Quorum>,
 
     // quorum is the quorum required by the policy. Invariant: if present, quorum must be an
     // existing key in quorums.
@@ -120,7 +120,7 @@ pub struct Witness {
 }
 
 pub struct Logs<'a> {
-    inner: std::collections::hash_map::Iter<'a, Hash, Entity>,
+    inner: alloc::collections::btree_map::Iter<'a, Hash, Entity>,
 }
 
 impl Iterator for Logs<'_> {
@@ -252,9 +252,9 @@ impl Default for PolicyBuilder {
 impl PolicyBuilder {
     pub fn new() -> Self {
         Self(Policy {
-            logs: HashMap::new(),
-            witnesses: HashMap::new(),
-            quorums: HashMap::new(),
+            logs: BTreeMap::new(),
+            witnesses: BTreeMap::new(),
+            quorums: BTreeMap::new(),
             quorum: None,
         })
     }
@@ -325,6 +325,7 @@ impl PolicyBuilder {
 
 #[cfg(test)]
 mod tests {
+    use alloc::{string::String, string::ToString, vec};
     use hex_literal::hex;
 
     use super::*;
@@ -333,9 +334,9 @@ mod tests {
     fn build_empty_policy() {
         let builder = PolicyBuilder::new();
         let expected = Policy {
-            logs: HashMap::new(),
-            witnesses: HashMap::new(),
-            quorums: HashMap::new(),
+            logs: BTreeMap::new(),
+            witnesses: BTreeMap::new(),
+            quorums: BTreeMap::new(),
             quorum: None,
         };
         assert_eq!(expected, builder.build());
@@ -379,7 +380,7 @@ mod tests {
             .unwrap();
         builder.set_quorum(String::from("mygroup")).unwrap();
         let expected = Policy {
-            logs: HashMap::from([
+            logs: BTreeMap::from([
                 (
                     hex!("e919506c3a798f2030f14046e39f03773c12b390e1010c95d2256d0ae594354e").into(),
                     Entity(
@@ -397,7 +398,7 @@ mod tests {
                     ),
                 ),
             ]),
-            witnesses: HashMap::from([
+            witnesses: BTreeMap::from([
                 (
                     hex!("d9440882ae2bd57076d4da2e7a12d4b26e137d56116419a69f8d6969709ed747").into(),
                     Entity(
@@ -415,7 +416,7 @@ mod tests {
                     ),
                 ),
             ]),
-            quorums: HashMap::from([
+            quorums: BTreeMap::from([
                 (
                     "witness01".into(),
                     Quorum::Witness(

src/policy/parsing.rs

@@ -1,5 +1,6 @@
-use std::iter::Enumerate;
-use std::str::Lines;
+use alloc::{format, string::String, string::ToString, vec::Vec};
+use core::iter::Enumerate;
+use core::str::Lines;
 
 use super::{Policy, PolicyBuilder};
 use crate::crypto::PublicKey;
@@ -17,7 +18,7 @@ macro_rules! bail {
     };
 }
 
-type Result<T> = std::result::Result<T, ParsePolicyError>;
+type Result<T> = core::result::Result<T, ParsePolicyError>;
 
 impl Policy {
     /// Parse a policy from its string representation according to the
@@ -161,6 +162,7 @@ impl<'a> Iterator for PolicyLines<'a> {
 
 #[cfg(test)]
 mod tests {
+    use alloc::{vec, vec::Vec};
     use hex_literal::hex;
 
     use super::*;