checkpoint

veilid-core/src/crypto/envelope.rs

@@ -89,7 +89,7 @@ impl Envelope {
         }
 
         // Check crypto kind
-        let crypto_kind = CryptoKind(
+        let crypto_kind = FourCC(
             data[0x04..0x08]
                 .try_into()
                 .map_err(VeilidAPIError::internal)?,

veilid-core/src/crypto/mod.rs

@@ -231,23 +231,22 @@ impl Crypto {
     /// Returns the set of signature cryptokinds that validate and are supported
     /// If any cryptokinds are supported and do not validate, the whole operation
     /// returns an error
-    pub fn verify_signatures<F, R>(
+    pub fn verify_signatures(
         &self,
+        node_ids: &[TypedKey],
         data: &[u8],
-        signatures: &[TypedKeySignature],
-        transform: F,
-    ) -> Result<Vec<R>, VeilidAPIError>
-    where
-        F: Fn(&TypedKeySignature) -> R,
-    {
-        let mut out = Vec::<R>::with_capacity(signatures.len());
-        for sig in signatures {
-            if let Some(vcrypto) = self.get(sig.kind) {
-                vcrypto.verify(&sig.key, data, &sig.signature)?;
-                out.push(transform(sig));
+        typed_signatures: &[TypedSignature],
+    ) -> Result<(), VeilidAPIError> {
+        for sig in typed_signatures {
+            for nid in node_ids {
+                if nid.kind == sig.kind {
+                    if let Some(vcrypto) = self.get(sig.kind) {
+                        vcrypto.verify(&nid.key, data, &sig.signature)?;
+                    }
+                }
             }
         }
-        Ok(out)
+        Ok(())
     }
 
     /// Signature set generation
@@ -256,14 +255,14 @@ impl Crypto {
     pub fn generate_signatures<F, R>(
         &self,
         data: &[u8],
-        keypairs: &[TypedKeyPair],
+        typed_key_pairs: &[TypedKeyPair],
         transform: F,
     ) -> Result<Vec<R>, VeilidAPIError>
     where
         F: Fn(&TypedKeyPair, Signature) -> R,
     {
-        let mut out = Vec::<R>::with_capacity(keypairs.len());
-        for kp in keypairs {
+        let mut out = Vec::<R>::with_capacity(typed_key_pairs.len());
+        for kp in typed_key_pairs {
             if let Some(vcrypto) = self.get(kp.kind) {
                 let sig = vcrypto.sign(&kp.key, &kp.secret, data)?;
                 out.push(transform(kp, sig))

veilid-core/src/crypto/receipt.rs

@@ -90,7 +90,7 @@ impl Receipt {
         }
 
         // Check crypto kind
-        let crypto_kind = CryptoKind(
+        let crypto_kind = FourCC(
             data[0x04..0x08]
                 .try_into()
                 .map_err(VeilidAPIError::internal)?,

veilid-core/src/crypto/types.rs

@@ -1,61 +1,30 @@
 use super::*;
 
 use core::cmp::{Eq, Ord, PartialEq, PartialOrd};
-use core::convert::{TryFrom, TryInto};
+use core::convert::TryInto;
 use core::fmt;
 use core::hash::Hash;
 
 use rkyv::{Archive as RkyvArchive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
 
 /// Cryptography version fourcc code
+pub type CryptoKind = FourCC;
+
 #[derive(
+    Clone,
     Copy,
     Debug,
-    Default,
-    Clone,
-    Hash,
+    Serialize,
+    Deserialize,
     PartialOrd,
     Ord,
     PartialEq,
     Eq,
-    Serialize,
-    Deserialize,
+    Hash,
     RkyvArchive,
     RkyvSerialize,
     RkyvDeserialize,
 )]
-#[archive_attr(repr(C), derive(CheckBytes, PartialOrd, Ord, PartialEq, Eq))]
-pub struct CryptoKind(pub [u8; 4]);
-
-impl From<[u8; 4]> for CryptoKind {
-    fn from(b: [u8; 4]) -> Self {
-        Self(b)
-    }
-}
-impl TryFrom<&[u8]> for CryptoKind {
-    type Error = VeilidAPIError;
-    fn try_from(b: &[u8]) -> Result<Self, Self::Error> {
-        Ok(Self(b.try_into().map_err(VeilidAPIError::generic)?))
-    }
-}
-
-impl fmt::Display for CryptoKind {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
-        write!(f, "{}", String::from_utf8_lossy(&self.0))
-    }
-}
-impl FromStr for CryptoKind {
-    type Err = VeilidAPIError;
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(Self(
-            s.as_bytes().try_into().map_err(VeilidAPIError::generic)?,
-        ))
-    }
-}
-
-#[derive(
-    Clone, Copy, Debug, Serialize, Deserialize, RkyvArchive, RkyvSerialize, RkyvDeserialize,
-)]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct TypedKey {
     pub kind: CryptoKind,
@@ -87,7 +56,19 @@ impl FromStr for TypedKey {
 }
 
 #[derive(
-    Clone, Copy, Debug, Serialize, Deserialize, RkyvArchive, RkyvSerialize, RkyvDeserialize,
+    Clone,
+    Copy,
+    Debug,
+    PartialOrd,
+    Ord,
+    PartialEq,
+    Eq,
+    Hash,
+    Serialize,
+    Deserialize,
+    RkyvArchive,
+    RkyvSerialize,
+    RkyvDeserialize,
 )]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct TypedKeyPair {
@@ -131,7 +112,19 @@ impl FromStr for TypedKeyPair {
 }
 
 #[derive(
-    Clone, Copy, Debug, Serialize, Deserialize, RkyvArchive, RkyvSerialize, RkyvDeserialize,
+    Clone,
+    Copy,
+    Debug,
+    PartialOrd,
+    Ord,
+    PartialEq,
+    Eq,
+    Hash,
+    Serialize,
+    Deserialize,
+    RkyvArchive,
+    RkyvSerialize,
+    RkyvDeserialize,
 )]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct TypedSignature {
@@ -175,7 +168,19 @@ impl FromStr for TypedSignature {
 }
 
 #[derive(
-    Clone, Copy, Debug, Serialize, Deserialize, RkyvArchive, RkyvSerialize, RkyvDeserialize,
+    Clone,
+    Copy,
+    Debug,
+    PartialOrd,
+    Ord,
+    PartialEq,
+    Eq,
+    Hash,
+    Serialize,
+    Deserialize,
+    RkyvArchive,
+    RkyvSerialize,
+    RkyvDeserialize,
 )]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct TypedKeySignature {

veilid-core/src/crypto/vld0/mod.rs

@@ -14,7 +14,7 @@ use ed25519_dalek as ed;
 use x25519_dalek as xd;
 
 const AEAD_OVERHEAD: usize = 16;
-pub const CRYPTO_KIND_VLD0: CryptoKind = CryptoKind([b'V', b'L', b'D', b'0']);
+pub const CRYPTO_KIND_VLD0: CryptoKind = FourCC([b'V', b'L', b'D', b'0']);
 
 fn ed25519_to_x25519_pk(key: &ed::PublicKey) -> Result<xd::PublicKey, VeilidAPIError> {
     let bytes = key.to_bytes();