Allow building without std on nightly (#10)

* allow building without stdlib by no_std feature

* document serde

* Fix tests

* cargo fmt

* Reword around `std` vs `no_std`

Author: thomwiggers

.github/workflows/ci.yml

@@ -39,6 +39,16 @@ jobs:
         with:
           command: test
 
+      - uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --no-default-features --features serde --manifest-path oqs/Cargo.toml
+
+      - uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --no-default-features --features no_std,serde --manifest-path oqs/Cargo.toml
+
       - uses: actions-rs/cargo@v1
         with:
           command: fmt

README.md

@@ -32,6 +32,21 @@ oqs = "0.2"
 
 ``oqs-sys`` can be specified equivalently.
 
+Serde support
+-------------
+
+You can enable ``serde`` serialization support by enabling the ``serde`` feature on the ``oqs`` rcate.
+
+`no_std` support
+----------------
+
+The ``oqs-sys`` crate does not use `std` at all.
+Note that the default features do enable building liboqs with ``openssl``, so use ``default-features = false``.
+
+For ``no_std`` suport in the ``oqs`` crate, enable the ``no_std`` feature.
+Make sure to also disable the ``oqs-sys/openssl`` feature by specifying ``default-features = false``.
+
+
 Running
 -------
 

oqs-sys/Cargo.toml

@@ -15,6 +15,7 @@ exclude = ["liboqs/tests/**", "liboqs/docs/**", "liboqs/scripts/**", "build/**/*
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+libc = "0.2"
 
 [build-dependencies]
 cmake = "0.1"

oqs-sys/build.rs

@@ -24,6 +24,9 @@ fn generate_bindings(outdir: &PathBuf, headerfile: &str, filter: &str) {
         .whitelist_type(filter)
         .whitelist_function(filter)
         .whitelist_var(filter)
+        // Use core and libc
+        .use_core()
+        .ctypes_prefix("::libc")
         // Finish the builder and generate the bindings.
         .generate()
         // Unwrap the Result and panic on failure.

oqs-sys/src/lib.rs

@@ -1,3 +1,6 @@
+//! Bindings to liboqs
+#![no_std]
+
 #[allow(clippy::all)]
 #[allow(non_upper_case_globals)]
 #[allow(non_camel_case_types)]

oqs/Cargo.toml

@@ -9,14 +9,16 @@ repository = "https://github.com/open-quantum-safe/liboqs-rust"
 license = "MIT OR Apache-2.0"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [dependencies]
-serde = { version = "1.0", optional = true, features = ["derive"] }
+libc = "0.2"
+cstr_core = { version = "0.2", default-features = false, features = ["alloc"], optional = true }
+serde = { version = "1.0", optional = true, default-features = false, features = ["derive", "alloc"] }
 
 [dependencies.oqs-sys]
 path = "../oqs-sys"
 version = "0.2.0"
 default-features = false
 
 [features]
+no_std = ["cstr_core"]
 default = ["oqs-sys/openssl"]

oqs/src/kem.rs

@@ -1,15 +1,22 @@
 //! KEM API
 //!
 //! See [`Kem`] for the main functionality
-use crate::ffi::kem as ffi;
-use crate::*;
-use std::os::raw;
-use std::ptr::NonNull;
+use alloc::borrow;
+use alloc::vec::Vec;
+
+use core::ptr::NonNull;
+
+#[cfg(feature = "no_std")]
+use cstr_core::CStr;
+#[cfg(not(feature = "no_std"))]
+use std::ffi::CStr;
 
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
+use crate::ffi::kem as ffi;
 use crate::newtype_buffer;
+use crate::*;
 
 newtype_buffer!(PublicKey, PublicKeyRef);
 newtype_buffer!(SecretKey, SecretKeyRef);
@@ -33,7 +40,7 @@ macro_rules! implement_kems {
             )*
         }
 
-        fn algorithm_to_id(algorithm: Algorithm) -> *const raw::c_char {
+        fn algorithm_to_id(algorithm: Algorithm) -> *const libc::c_char {
             let id: &[u8] = match algorithm {
                 $(
                     Algorithm::$kem => &ffi::$oqs_id[..],
@@ -130,7 +137,7 @@ implement_kems! {
     SikeP751Compressed: OQS_KEM_alg_sike_p751_compressed,
 }
 
-impl std::default::Default for Algorithm {
+impl core::default::Default for Algorithm {
     fn default() -> Self {
         Algorithm::Default
     }
@@ -146,7 +153,7 @@ impl Algorithm {
     /// Provides a pointer to the id of the algorithm
     ///
     /// For use with the FFI api methods
-    pub fn to_id(self) -> *const raw::c_char {
+    pub fn to_id(self) -> *const libc::c_char {
         algorithm_to_id(self)
     }
 }
@@ -172,16 +179,16 @@ impl Kem {
     }
 
     /// Get the name of the algorithm
-    pub fn name(&self) -> std::borrow::Cow<str> {
+    pub fn name(&self) -> borrow::Cow<str> {
         let kem = unsafe { self.kem.as_ref() };
-        let cstr = unsafe { std::ffi::CStr::from_ptr(kem.method_name) };
+        let cstr = unsafe { CStr::from_ptr(kem.method_name) };
         cstr.to_string_lossy()
     }
 
     /// Get the version of the implementation
-    pub fn version(&self) -> std::borrow::Cow<str> {
+    pub fn version(&self) -> borrow::Cow<str> {
         let kem = unsafe { self.kem.as_ref() };
-        let cstr = unsafe { std::ffi::CStr::from_ptr(kem.method_name) };
+        let cstr = unsafe { CStr::from_ptr(kem.method_name) };
         cstr.to_string_lossy()
     }
 

oqs/src/lib.rs

@@ -1,4 +1,5 @@
 #![warn(missing_docs)]
+#![cfg_attr(feature = "no_std", no_std)]
 //! Friendly bindings to liboqs
 //!
 //! See the [`kem::Kem`] and [`sig::Sig`] structs for how to use this crate.
@@ -37,7 +38,10 @@
 //!     Ok(())
 //! }
 //! ```
+// needs to be imported to be made available
+extern crate alloc;
 
+#[cfg(not(feature = "no_std"))]
 use std::sync::Once;
 
 use ffi::common::OQS_STATUS;
@@ -51,14 +55,26 @@ mod macros;
 ///
 /// Make sure to call this before you use any of the functions.
 ///
-/// This method is thread-safe and can be called more than once.
+/// When the `no_std` feature is not enabled, this method is thread-safe
+/// and can be called more than once.
+#[cfg(not(feature = "no_std"))]
 pub fn init() {
     static INIT: Once = Once::new();
     INIT.call_once(|| {
         unsafe { ffi::common::OQS_init() };
     });
 }
 
+/// Initialize liboqs
+///
+/// Needs to be called before you use any of the functions.
+///
+/// This no_std variant is not thread-safe.
+#[cfg(feature = "no_std")]
+pub fn init() {
+    unsafe { ffi::common::OQS_init() };
+}
+
 #[derive(Debug)]
 #[non_exhaustive]
 /// Possible errors
@@ -70,13 +86,14 @@ pub enum Error {
     /// Error occurred in OpenSSL functions external to liboqs
     ErrorExternalOpenSSL,
 }
+#[cfg(not(feature = "no_std"))]
 impl std::error::Error for Error {}
 
 /// Result type for operations that may fail
-pub type Result<T> = std::result::Result<T, Error>;
+pub type Result<T> = core::result::Result<T, Error>;
 
-impl std::fmt::Display for Error {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Display for Error {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {
             Error::AlgorithmDisabled => write!(f, "Algorithm has been disabled"),
             _ => write!(f, "OQS Error!"),

oqs/src/macros.rs

@@ -48,7 +48,7 @@ macro_rules! newtype_buffer {
             }
         }
 
-        impl<'a> std::ops::Deref for $name_ref<'a> {
+        impl<'a> core::ops::Deref for $name_ref<'a> {
             type Target = [u8];
             fn deref(&self) -> &Self::Target {
                 &self.bytes
@@ -72,6 +72,12 @@ macro_rules! newtype_buffer {
 
 #[cfg(test)]
 mod test {
+    use alloc::vec;
+    use alloc::vec::Vec;
+
+    #[cfg(feature = "serde")]
+    use serde::{Deserialize, Serialize};
+
     newtype_buffer!(TestBuf, TestBufRef);
 
     #[test]

oqs/src/sig.rs

@@ -1,13 +1,19 @@
 //! Signature API
 //!
 //! See [`Sig`] for the main functionality
+use alloc::borrow;
+use alloc::vec::Vec;
 
-use crate::ffi::sig as ffi;
-use crate::*;
-use std::os::raw;
-use std::ptr::NonNull;
+use core::ptr::NonNull;
+
+#[cfg(feature = "no_std")]
+use cstr_core::CStr;
+#[cfg(not(feature = "no_std"))]
+use std::ffi::CStr;
 
+use crate::ffi::sig as ffi;
 use crate::newtype_buffer;
+use crate::*;
 
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
@@ -35,7 +41,7 @@ macro_rules! implement_sigs {
             )*
         }
 
-        fn algorithm_to_id(algorithm: Algorithm) -> *const raw::c_char {
+        fn algorithm_to_id(algorithm: Algorithm) -> *const libc::c_char {
             let id: &[u8] = match algorithm {
                 $(
                     Algorithm::$sig => &ffi::$oqs_id[..],
@@ -136,7 +142,7 @@ implement_sigs! {
     SphincsShake256256sSimple: OQS_SIG_alg_sphincs_shake256_256s_simple,
 }
 
-impl std::default::Default for Algorithm {
+impl core::default::Default for Algorithm {
     fn default() -> Self {
         Algorithm::Default
     }
@@ -152,7 +158,7 @@ impl Algorithm {
     /// Provides a pointer to the id of the algorithm
     ///
     /// For use with the FFI api methods
-    pub fn to_id(self) -> *const raw::c_char {
+    pub fn to_id(self) -> *const libc::c_char {
         algorithm_to_id(self)
     }
 }
@@ -178,16 +184,16 @@ impl Sig {
     }
 
     /// Get the name of this signature algorithm
-    pub fn name(&self) -> std::borrow::Cow<str> {
+    pub fn name(&self) -> borrow::Cow<str> {
         let sig = unsafe { self.sig.as_ref() };
-        let cstr = unsafe { std::ffi::CStr::from_ptr(sig.method_name) };
+        let cstr = unsafe { CStr::from_ptr(sig.method_name) };
         cstr.to_string_lossy()
     }
 
     /// Version of this implementation
-    pub fn version(&self) -> std::borrow::Cow<str> {
+    pub fn version(&self) -> borrow::Cow<str> {
         let sig = unsafe { self.sig.as_ref() };
-        let cstr = unsafe { std::ffi::CStr::from_ptr(sig.method_name) };
+        let cstr = unsafe { CStr::from_ptr(sig.method_name) };
         cstr.to_string_lossy()
     }