feat(nistp256): Add P256 support (#21)

* p-256 algo acheivement unlocked

* rm erroneous rustdoc

* add P256 to KEY_CODECS, cover edge cases of 0x04

* clippy fix

Author: DougAnderson444

crates/bs-peer/src/platform/browser/opfs.rs

@@ -107,52 +107,6 @@ impl Blockstore for OPFSBlockstore {
 }
 
 /// A Wrapper sturct around OPFSBlockstore so that we can make it [Send]
-///
-/// # Example
-/// ```no_run
-/// use wasm_bindgen_futures::spawn_local;
-/// use peerpiper_browser::opfs::OPFSWrapped;
-/// use peerpiper_core::Blockstore;
-///
-/// spawn_local(async move {
-///    let Ok(blockstore) = OPFSWrapped::new().await else {
-///         panic!("Failed to create OPFSWrapped");
-///    };
-///    
-///    // Use blockstore when starting peerpiper
-///    
-///    // 16 is arbitrary, but should be enough for now
-///    let (tx_evts, mut rx_evts) = mpsc::channel(16);
-///
-///    // client sync oneshot
-///    let (tx_client, rx_client) = oneshot::channel();
-///
-///    // command_sender will be used by other wasm_bindgen functions to send commands to the network
-///    // so we will need to wrap it in a Mutex or something to make it thread safe.
-///    let (network_command_sender, network_command_receiver) = tokio::sync::mpsc::channel(8);
-///
-///    let bstore = blockstore.clone();
-///
-///    spawn_local(async move {
-///        peerpiper::start(
-///            tx_evts,
-///            network_command_receiver,
-///            tx_client,
-///            libp2p_endpoints,
-///            bstore,
-///        )
-///        .await
-///        .expect("never end")
-///    });
-///
-///    // wait on rx_client to get the client handle
-///    let client_handle = rx_client.await?;
-///
-///    commander
-///        .with_network(network_command_sender)
-///       .with_client(client_handle);
-/// });
-/// ```
 #[derive(Debug, Clone)]
 pub struct OPFSWrapped {
     inner: SendWrapper<OPFSBlockstore>,

crates/multikey/.cargo/config.toml

@@ -0,0 +1,2 @@
+[target.wasm32-unknown-unknown]
+rustflags = ["--cfg", "getrandom_backend=\"wasm_js\""]

crates/multikey/.gitignore

@@ -0,0 +1 @@
+pkg/

crates/multikey/Cargo.toml

@@ -7,6 +7,9 @@ description = "Multikey self-describing cryptographic key data"
 readme = "README.md"
 license = "Apache-2.0"
 
+[lib]
+crate-type = ["cdylib", "rlib"]
+
 [features]
 default = ["serde"]
 wasm = ["getrandom/wasm_js"] # needed for CI testing on wasm32-unknown-unknown
@@ -19,6 +22,10 @@ ed25519-dalek = { version = "2.1.1", features = ["rand_core"] }
 elliptic-curve.workspace = true
 hex.workspace = true
 k256 = "0.13"
+p256 = { version = "0.13", default-features = false, features = [
+  "ecdsa",
+  "arithmetic",
+] }
 ml-kem = { version = "0.2.1", features = ["deterministic"] }
 multibase.workspace = true
 multicodec.workspace = true
@@ -46,8 +53,11 @@ ssh-key = { version = "0.6", default-features = false, features = [
   "alloc",
   "ecdsa",
   "ed25519",
+  "p256",
 ] }
-getrandom = { version = "0.3.2", features = ["wasm_js"], optional = true }
+getrandom = { version = "0.3", features = ["wasm_js"] }
+# We have netsed deps that use v0.2, so we need to ensure the feature is flagged here
+getrandom_v02 = { package = "getrandom", version = "0.2.15", features = ["js"] }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 ssh-key = { version = "0.6", features = ["alloc", "crypto", "ed25519"] }
@@ -56,6 +66,7 @@ ssh-key = { version = "0.6", features = ["alloc", "crypto", "ed25519"] }
 serde_cbor.workspace = true
 serde_json.workspace = true
 serde_test.workspace = true
+wasm-bindgen-test = "0.3"
 
 [lints]
 workspace = true

crates/multikey/justfile

@@ -0,0 +1,3 @@
+test-wasm:
+  wasm-pack build --target web
+  wasm-pack test --headless --chrome --all-features

crates/multikey/src/error.rs

@@ -63,6 +63,12 @@ pub enum Error {
     UnsupportedAlgorithm(String),
 }
 
+impl From<ssh_key::Error> for Error {
+    fn from(e: ssh_key::Error) -> Self {
+        Error::Conversions(ConversionsError::Ssh(e.into()))
+    }
+}
+
 /// Attributes errors created by this library
 #[derive(Clone, Debug, thiserror::Error)]
 #[non_exhaustive]

crates/multikey/src/mk.rs

@@ -1,7 +1,7 @@
-// SPDX-License-Idnetifier: Apache-2.0
+// SPDX-License-Identifier: Apache-2.0
 use crate::{
     error::{AttributesError, CipherError, ConversionsError, KdfError},
-    views::{bcrypt, bls12381, chacha20, ed25519, mlkem, secp256k1},
+    views::{bcrypt, bls12381, chacha20, ed25519, mlkem, p256, secp256k1},
     AttrId, AttrView, CipherAttrView, CipherView, ConvView, DataView, Error, FingerprintView,
     KdfAttrView, KdfView, SignView, ThresholdAttrView, ThresholdView, VerifyView, Views,
 };
@@ -13,21 +13,23 @@ use multiutil::{BaseEncoded, CodecInfo, EncodingInfo, Varbytes, VarbytesIter, Va
 use ssh_key::{
     private::{EcdsaKeypair, KeypairData},
     public::{EcdsaPublicKey, KeyData},
+    Algorithm::*,
     EcdsaCurve, PrivateKey, PublicKey,
 };
 use std::{collections::BTreeMap, fmt, num::NonZeroUsize};
 use zeroize::Zeroizing;
 
 /// the list of key codecs supported for key generation
-pub const KEY_CODECS: [Codec; 7] = [
+pub const KEY_CODECS: [Codec; 8] = [
     Codec::Bls12381G1Priv,
     Codec::Bls12381G2Priv,
     Codec::Ed25519Priv,
+    Codec::P256Priv,
     /*
     Codec::LamportSha3256Priv,
     Codec::LamportSha3384Priv,
     Codec::LamportSha3512Priv,
-    Codec::P256Priv,
+
     Codec::P384Priv,
     Codec::P521Priv,
     */
@@ -205,6 +207,7 @@ impl Views for Multikey {
             | Codec::Bls12381G2Pub
             | Codec::Bls12381G2PubShare => Ok(Box::new(bls12381::View::try_from(self)?)),
             Codec::Ed25519Pub | Codec::Ed25519Priv => Ok(Box::new(ed25519::View::try_from(self)?)),
+            Codec::P256Pub | Codec::P256Priv => Ok(Box::new(p256::View::try_from(self)?)),
             Codec::Secp256K1Pub | Codec::Secp256K1Priv => {
                 Ok(Box::new(secp256k1::View::try_from(self)?))
             }
@@ -250,6 +253,7 @@ impl Views for Multikey {
             | Codec::Bls12381G2Pub
             | Codec::Bls12381G2PubShare => Ok(Box::new(bls12381::View::try_from(self)?)),
             Codec::Ed25519Pub | Codec::Ed25519Priv => Ok(Box::new(ed25519::View::try_from(self)?)),
+            Codec::P256Pub | Codec::P256Priv => Ok(Box::new(p256::View::try_from(self)?)),
             Codec::Secp256K1Pub | Codec::Secp256K1Priv => {
                 Ok(Box::new(secp256k1::View::try_from(self)?))
             }
@@ -318,6 +322,7 @@ impl Views for Multikey {
             | Codec::Bls12381G2Pub
             | Codec::Bls12381G2PubShare => Ok(Box::new(bls12381::View::try_from(self)?)),
             Codec::Ed25519Pub | Codec::Ed25519Priv => Ok(Box::new(ed25519::View::try_from(self)?)),
+            Codec::P256Pub | Codec::P256Priv => Ok(Box::new(p256::View::try_from(self)?)),
             Codec::Secp256K1Pub | Codec::Secp256K1Priv => {
                 Ok(Box::new(secp256k1::View::try_from(self)?))
             }
@@ -343,6 +348,7 @@ impl Views for Multikey {
             | Codec::Bls12381G2Pub
             | Codec::Bls12381G2PubShare => Ok(Box::new(bls12381::View::try_from(self)?)),
             Codec::Ed25519Pub | Codec::Ed25519Priv => Ok(Box::new(ed25519::View::try_from(self)?)),
+            Codec::P256Pub | Codec::P256Priv => Ok(Box::new(p256::View::try_from(self)?)),
             Codec::Secp256K1Pub | Codec::Secp256K1Priv => {
                 Ok(Box::new(secp256k1::View::try_from(self)?))
             }
@@ -377,6 +383,7 @@ impl Views for Multikey {
             | Codec::Bls12381G2Pub
             | Codec::Bls12381G2PubShare => Ok(Box::new(bls12381::View::try_from(self)?)),
             Codec::Ed25519Pub | Codec::Ed25519Priv => Ok(Box::new(ed25519::View::try_from(self)?)),
+            Codec::P256Pub | Codec::P256Priv => Ok(Box::new(p256::View::try_from(self)?)),
             Codec::Secp256K1Pub | Codec::Secp256K1Priv => {
                 Ok(Box::new(secp256k1::View::try_from(self)?))
             }
@@ -406,6 +413,7 @@ impl Views for Multikey {
             | Codec::Bls12381G2Pub
             | Codec::Bls12381G2PubShare => Ok(Box::new(bls12381::View::try_from(self)?)),
             Codec::Ed25519Pub | Codec::Ed25519Priv => Ok(Box::new(ed25519::View::try_from(self)?)),
+            Codec::P256Pub | Codec::P256Priv => Ok(Box::new(p256::View::try_from(self)?)),
             Codec::Secp256K1Pub | Codec::Secp256K1Priv => {
                 Ok(Box::new(secp256k1::View::try_from(self)?))
             }
@@ -485,16 +493,52 @@ impl Builder {
         })
     }
 
-    /// new builder from ssh_key::PublicKey source
+    /// Build from [ssh_key::PublicKey] source
     pub fn new_from_ssh_public_key(sshkey: &PublicKey) -> Result<Self, Error> {
-        use ssh_key::Algorithm::*;
         match sshkey.algorithm() {
             Ecdsa { curve } => {
                 use EcdsaCurve::*;
                 let (key_bytes, codec) = match curve {
                     NistP256 => {
                         if let KeyData::Ecdsa(EcdsaPublicKey::NistP256(point)) = sshkey.key_data() {
-                            (point.as_bytes().to_vec(), Codec::P256Pub)
+                            // SSH stores points in uncompressed format
+                            // Convert to compressed SEC1 format to match to_public_key()
+                            let point_bytes = point.as_bytes();
+
+                            // Parse the point - it may have the 0x04 tag (65 bytes) or not (64 bytes)
+                            let verifying_key = if point_bytes.len() == 65 && point_bytes[0] == 0x04
+                            {
+                                // Already has the tag, use as-is
+                                ::p256::ecdsa::VerifyingKey::from_sec1_bytes(point_bytes).map_err(
+                                    |e| {
+                                        ConversionsError::PublicKeyFailure(format!(
+                                            "Invalid P-256 point: {}",
+                                            e
+                                        ))
+                                    },
+                                )?
+                            } else if point_bytes.len() == 64 {
+                                // Need to add the 0x04 tag
+                                let mut uncompressed_bytes = vec![0x04];
+                                uncompressed_bytes.extend_from_slice(point_bytes);
+                                ::p256::ecdsa::VerifyingKey::from_sec1_bytes(&uncompressed_bytes)
+                                    .map_err(|e| {
+                                        ConversionsError::PublicKeyFailure(format!(
+                                            "Invalid P-256 point: {}",
+                                            e
+                                        ))
+                                    })?
+                            } else {
+                                return Err(ConversionsError::PublicKeyFailure(format!(
+                                    "Invalid P-256 point length: {}",
+                                    point_bytes.len()
+                                ))
+                                .into());
+                            };
+
+                            // Convert to compressed format
+                            let compressed_point = verifying_key.to_encoded_point(true);
+                            (compressed_point.as_bytes().to_vec(), Codec::P256Pub)
                         } else {
                             return Err(ConversionsError::UnsupportedAlgorithm(
                                 sshkey.algorithm().to_string(),

crates/multikey/src/views.rs

@@ -1,10 +1,9 @@
-use std::num::NonZeroUsize;
-
-// SPDX-License-Idnetifier: Apache-2.0
+// SPDX-License-Identifier: Apache-2.0
 use crate::{Error, Multikey};
 use multicodec::Codec;
 use multihash::Multihash;
 use multisig::Multisig;
+use std::num::NonZeroUsize;
 use zeroize::Zeroizing;
 
 // algorithms implement different sets of view
@@ -13,6 +12,7 @@ pub(crate) mod bls12381;
 pub(crate) mod chacha20;
 pub(crate) mod ed25519;
 pub(crate) mod mlkem;
+pub(crate) mod p256;
 pub(crate) mod secp256k1;
 // Attributes views let you inquire about the Multikey and retrieve data
 // associated with the particular view.

crates/multikey/src/views/bls12381.rs

@@ -476,8 +476,8 @@ impl ConvView for View<'_> {
                 let tav = pk.threshold_attr_view()?;
                 let key_share: Vec<u8> = KeyShare(
                     tav.identifier()?,
-                    tav.threshold()?.into(),
-                    tav.limit()?.into(),
+                    tav.threshold()?,
+                    tav.limit()?,
                     key_bytes.to_vec(),
                 )
                 .into();
@@ -496,7 +496,7 @@ impl ConvView for View<'_> {
                 let tav = pk.threshold_attr_view()?;
                 let key_share: Vec<u8> = KeyShare(
                     tav.identifier()?,
-                    tav.threshold()?.into(),
+                    tav.threshold()?,
                     tav.limit()?,
                     key_bytes.to_vec(),
                 )
@@ -556,15 +556,15 @@ impl ConvView for View<'_> {
                 let sav = self.mk.threshold_attr_view()?;
                 let secret_key_share: Vec<u8> = KeyShare(
                     sav.identifier()?,
-                    sav.threshold()?.into(),
+                    sav.threshold()?,
                     sav.limit()?,
                     secret_bytes.to_vec(),
                 )
                 .into();
                 let pav = pk.threshold_attr_view()?;
                 let public_key_share: Vec<u8> = KeyShare(
                     pav.identifier()?,
-                    pav.threshold()?.into(),
+                    pav.threshold()?,
                     pav.limit()?,
                     key_bytes.to_vec(),
                 )
@@ -590,15 +590,15 @@ impl ConvView for View<'_> {
                 let sav = self.mk.threshold_attr_view()?;
                 let secret_key_share: Vec<u8> = KeyShare(
                     sav.identifier()?,
-                    sav.threshold()?.into(),
+                    sav.threshold()?,
                     sav.limit()?,
                     secret_bytes.to_vec(),
                 )
                 .into();
                 let pav = pk.threshold_attr_view()?;
                 let public_key_share: Vec<u8> = KeyShare(
                     pav.identifier()?,
-                    pav.threshold()?.into(),
+                    pav.threshold()?,
                     pav.limit()?,
                     key_bytes.to_vec(),
                 )