From 0f9de14dc1540a9148e52e3c5e066b6064a0bed8 Mon Sep 17 00:00:00 2001 From: "artem.ivanov" Date: Tue, 21 Nov 2023 09:28:26 +0300 Subject: [PATCH 01/14] Use message pack as encoding for proofs Signed-off-by: artem.ivanov --- Cargo.toml | 5 ++-- src/data_types/nonce.rs | 24 +++++++++++++++--- src/data_types/w3c/credential_proof.rs | 18 ++++++++----- src/data_types/w3c/encoded_object.rs | 19 ++++++++++++++ src/data_types/w3c/mod.rs | 1 + src/data_types/w3c/presentation_proof.rs | 31 +++++++++++++---------- src/services/w3c/credential_conversion.rs | 14 +++++----- src/utils/base64.rs | 14 ---------- src/utils/mod.rs | 2 ++ src/utils/msg_pack.rs | 15 +++++++++++ 10 files changed, 96 insertions(+), 47 deletions(-) create mode 100644 src/data_types/w3c/encoded_object.rs create mode 100644 src/utils/msg_pack.rs diff --git a/Cargo.toml b/Cargo.toml index 202c51b3..c154ddd5 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -24,10 +24,10 @@ ffi = ["dep:ffi-support"] zeroize = ["dep:zeroize"] logger = ["dep:env_logger"] vendored = ["anoncreds-clsignatures/openssl_vendored"] -w3c = ["base64", "chrono"] +w3c = ["base64", "chrono", "rmp-serde"] [dependencies] -anoncreds-clsignatures = "0.2.4" +anoncreds-clsignatures = { path = "/Users/artem/anoncreds-clsignatures-rs", features = ["bytes_serialization"] } bs58 = "0.4.0" env_logger = { version = "0.9.3", optional = true } ffi-support = { version = "0.4.0", optional = true } @@ -43,6 +43,7 @@ thiserror = "1.0.39" zeroize = { version = "1.5.7", optional = true, features = ["zeroize_derive"] } base64 = { version = "0.21.5", optional = true } chrono = { version = "0.4.31", optional = true, features = ["serde"] } +rmp-serde = { version = "1.1.2", optional = true } [dev-dependencies] rstest = "0.18.2" diff --git a/src/data_types/nonce.rs b/src/data_types/nonce.rs index ea2f0e27..c69f2807 100644 --- a/src/data_types/nonce.rs +++ b/src/data_types/nonce.rs @@ -5,6 +5,8 @@ use std::hash::{Hash, Hasher}; use crate::cl::{new_nonce, Nonce as CryptoNonce}; use crate::error::ConversionError; use serde::{de::Visitor, Deserialize, Deserializer, Serialize, Serializer}; +use serde::de::{Error, SeqAccess}; +use serde_json::Value; pub struct Nonce { strval: String, @@ -52,6 +54,12 @@ impl Nonce { Ok(Self { strval, native }) } + pub fn from_bytes(bytes: &[u8]) -> Result { + let native = CryptoNonce::from_bytes(bytes) + .map_err(|err| ConversionError::from_msg(format!("Error converting nonce from bytes: {err}")))?; + Self::from_native(native) + } + pub fn try_clone(&self) -> Result { Self::from_dec(self.strval.clone()) } @@ -142,7 +150,7 @@ impl Serialize for Nonce { where S: Serializer, { - serializer.serialize_str(&self.strval) + serializer.serialize_bytes(&self.native.to_bytes().unwrap_or_default()) } } @@ -157,7 +165,7 @@ impl<'a> Deserialize<'a> for Nonce { type Value = Nonce; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter.write_str("integer or string nonce") + formatter.write_str("integer or string nonce or bytes") } fn visit_i64(self, value: i64) -> Result @@ -187,9 +195,19 @@ impl<'a> Deserialize<'a> for Nonce { { Nonce::from_dec(value).map_err(E::custom) } + + fn visit_seq(self, mut seq: E) -> Result where E: SeqAccess<'a> { + let mut vec = Vec::new(); + + while let Ok(Some(Value::Number(elem))) = seq.next_element() { + vec.push(elem.as_u64().unwrap() as u8); + } + + Nonce::from_bytes(&vec).map_err(E::Error::custom) + } } - deserializer.deserialize_str(BigNumberVisitor) + deserializer.deserialize_any(BigNumberVisitor) } } diff --git a/src/data_types/w3c/credential_proof.rs b/src/data_types/w3c/credential_proof.rs index f9fe4c06..5efc1a94 100644 --- a/src/data_types/w3c/credential_proof.rs +++ b/src/data_types/w3c/credential_proof.rs @@ -5,6 +5,10 @@ use anoncreds_clsignatures::{ CredentialSignature as CLCredentialSignature, RevocationRegistry, SignatureCorrectnessProof, Witness, }; +use serde::Serialize; +use serde_json::Value; +use crate::data_types::w3c::encoded_object::EncodedObject; +use crate::Result; #[allow(clippy::large_enum_variant)] #[derive(Debug, Clone, Serialize, Deserialize)] @@ -23,11 +27,13 @@ pub struct CredentialSignatureProof { } impl CredentialSignatureProof { - pub fn new(signature: CredentialSignature) -> Self { - CredentialSignatureProof { - type_: CredentialSignatureType::AnonCredsProof2023, - signature: signature.encode(), - } + pub fn new(signature: CredentialSignature) -> Result { + Ok( + CredentialSignatureProof { + type_: CredentialSignatureType::AnonCredsProof2023, + signature: signature.encode()?, + } + ) } pub fn get_credential_signature(&self) -> Result { @@ -88,9 +94,7 @@ impl CredentialProof { pub struct CredentialSignature { pub(crate) signature: CLCredentialSignature, pub(crate) signature_correctness_proof: SignatureCorrectnessProof, - #[serde(skip_serializing_if = "Option::is_none")] pub(crate) rev_reg: Option, - #[serde(skip_serializing_if = "Option::is_none")] pub(crate) witness: Option, } diff --git a/src/data_types/w3c/encoded_object.rs b/src/data_types/w3c/encoded_object.rs new file mode 100644 index 00000000..1d46c07a --- /dev/null +++ b/src/data_types/w3c/encoded_object.rs @@ -0,0 +1,19 @@ +use serde::de::DeserializeOwned; +use serde::Serialize; +use crate::Result; +use crate::utils::msg_pack; +use crate::utils::base64; + +pub trait EncodedObject { + fn encode(&self) -> Result where Self: Serialize + DeserializeOwned { + let bytes = msg_pack::encode(self)?; + let base64_encoded = base64::encode(&bytes); + Ok(base64_encoded) + } + + fn decode(string: &str) -> Result where Self: Sized + DeserializeOwned { + let bytes = base64::decode(string.as_bytes())?; + let json = msg_pack::decode(&bytes)?; + Ok(json) + } +} \ No newline at end of file diff --git a/src/data_types/w3c/mod.rs b/src/data_types/w3c/mod.rs index 448e3a01..6b6adea2 100644 --- a/src/data_types/w3c/mod.rs +++ b/src/data_types/w3c/mod.rs @@ -7,3 +7,4 @@ pub mod one_or_many; pub mod presentation; pub mod presentation_proof; pub mod uri; +pub mod encoded_object; diff --git a/src/data_types/w3c/presentation_proof.rs b/src/data_types/w3c/presentation_proof.rs index a1fb3e5c..91e83223 100644 --- a/src/data_types/w3c/presentation_proof.rs +++ b/src/data_types/w3c/presentation_proof.rs @@ -3,6 +3,7 @@ use crate::utils::encoded_object::EncodedObject; use crate::Result; use anoncreds_clsignatures::{AggregatedProof, SubProof}; use std::collections::HashSet; +use crate::data_types::w3c::encoded_object::EncodedObject; #[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] @@ -37,13 +38,15 @@ impl CredentialPresentationProof { proof_value: CredentialPresentationProofValue, mapping: CredentialAttributesMapping, timestamp: Option, - ) -> CredentialPresentationProof { - CredentialPresentationProof { - type_: PresentationProofType::AnonCredsPresentationProof2023, - mapping, - timestamp, - proof_value: proof_value.encode(), - } + ) -> Result { + Ok( + CredentialPresentationProof { + type_: PresentationProofType::AnonCredsPresentationProof2023, + mapping, + timestamp, + proof_value: proof_value.encode()?, + } + ) } pub fn get_proof_value(&self) -> Result { @@ -70,12 +73,14 @@ pub struct PresentationProofValue { } impl PresentationProof { - pub fn new(proof_value: PresentationProofValue, nonce: String) -> PresentationProof { - PresentationProof { - type_: PresentationProofType::AnonCredsPresentationProof2023, - challenge: nonce, - proof_value: proof_value.encode(), - } + pub fn new(proof_value: PresentationProofValue, nonce: String) -> Result { + Ok( + PresentationProof { + type_: PresentationProofType::AnonCredsPresentationProof2023, + challenge: nonce, + proof_value: proof_value.encode()?, + } + ) } pub fn get_proof_value(&self) -> Result { diff --git a/src/services/w3c/credential_conversion.rs b/src/services/w3c/credential_conversion.rs index 2417b92e..209f91a3 100644 --- a/src/services/w3c/credential_conversion.rs +++ b/src/services/w3c/credential_conversion.rs @@ -106,7 +106,7 @@ pub fn credential_to_w3c( credential.rev_reg, credential.witness, ); - let proof = CredentialSignatureProof::new(signature); + let proof = CredentialSignatureProof::new(signature)?; let attributes = CredentialAttributes::from(&credential.values); let mut w3c_credential = W3CCredential::new(); @@ -258,10 +258,8 @@ mod tests { }; use crate::utils::encoded_object::EncodedObject; use crate::{issuer, ErrorKind}; - use anoncreds_clsignatures::{ - CredentialSignature as CLCredentialSignature, - SignatureCorrectnessProof as CLSignatureCorrectnessProof, - }; + use anoncreds_clsignatures::{CredentialSignature as CLCredentialSignature, SignatureCorrectnessProof as CLSignatureCorrectnessProof}; + use crate::data_types::w3c::encoded_object::EncodedObject; const ISSUER_ID: &str = "mock:uri"; const SCHEMA_ID: &str = "mock:uri"; @@ -296,7 +294,7 @@ mod tests { support_revocation: true, }, ) - .unwrap(); + .unwrap(); cred_def } @@ -369,7 +367,7 @@ mod tests { .expect("unable to convert credential to w3c form"); let legacy_credential = credential_from_w3c(&w3c_credential) .expect("unable to convert credential to legacy form"); - assert_eq!(json!(original_legacy_credential), json!(legacy_credential),) + assert_eq!(json!(original_legacy_credential), json!(legacy_credential), ) } #[test] @@ -405,7 +403,7 @@ mod tests { let proof = w3c_credential .get_credential_signature_proof() .expect("credential signature proof is not set"); - assert_eq!(proof.signature, _signature_data().encode()); + assert_eq!(proof.signature, _signature_data().encode().unwrap()); } #[test] diff --git a/src/utils/base64.rs b/src/utils/base64.rs index 3ebc3b13..f3507352 100644 --- a/src/utils/base64.rs +++ b/src/utils/base64.rs @@ -1,7 +1,4 @@ use base64::{engine, Engine}; -use serde::de::DeserializeOwned; -use serde::Serialize; -use serde_json::json; use crate::Error; @@ -9,19 +6,8 @@ pub fn encode>(val: T) -> String { engine::general_purpose::URL_SAFE.encode(val) } -pub fn encode_json(val: T) -> String { - let json = json!(val).to_string(); - encode(json) -} - pub fn decode>(val: T) -> Result, Error> { engine::general_purpose::URL_SAFE .decode(val) .map_err(|_| err_msg!("invalid base64 string")) } - -pub fn decode_json, V: DeserializeOwned>(val: T) -> Result { - let bytes = decode(val)?; - let json = serde_json::from_slice(&bytes)?; - Ok(json) -} diff --git a/src/utils/mod.rs b/src/utils/mod.rs index f64bcf45..a34e9eec 100644 --- a/src/utils/mod.rs +++ b/src/utils/mod.rs @@ -13,5 +13,7 @@ pub mod hash; pub mod query; +pub mod msg_pack; + #[macro_use] pub mod macros; diff --git a/src/utils/msg_pack.rs b/src/utils/msg_pack.rs new file mode 100644 index 00000000..f13749e6 --- /dev/null +++ b/src/utils/msg_pack.rs @@ -0,0 +1,15 @@ +use serde::de::DeserializeOwned; +use serde::Serialize; + +use crate::Result; + +pub fn encode(val: T) -> Result> { + rmp_serde::to_vec(&val) + .map_err(|_| err_msg!("unable to encode message using message pack")) +} + +pub fn decode(val: &[u8]) -> Result { + rmp_serde::from_slice(val) + .map_err(|_| err_msg!("unable to decode message using message pack")) +} + From 8ce9f8ce54885e73b46d85ac020e58279b5d739b Mon Sep 17 00:00:00 2001 From: "artem.ivanov" Date: Wed, 22 Nov 2023 10:00:29 +0300 Subject: [PATCH 02/14] Use message pack serialization for w3c proofs Signed-off-by: artem.ivanov --- Cargo.toml | 2 +- src/data_types/nonce.rs | 14 +++++++++----- src/data_types/w3c/credential_proof.rs | 19 +++++++------------ src/data_types/w3c/encoded_object.rs | 19 ------------------- src/data_types/w3c/mod.rs | 1 - src/services/w3c/credential_conversion.rs | 10 ++++++---- src/utils/encoder.rs | 23 +++++++++++++++++++++++ src/utils/mod.rs | 2 +- src/utils/msg_pack.rs | 7 ++----- 9 files changed, 49 insertions(+), 48 deletions(-) delete mode 100644 src/data_types/w3c/encoded_object.rs create mode 100644 src/utils/encoder.rs diff --git a/Cargo.toml b/Cargo.toml index c154ddd5..5bfafbdf 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -27,7 +27,7 @@ vendored = ["anoncreds-clsignatures/openssl_vendored"] w3c = ["base64", "chrono", "rmp-serde"] [dependencies] -anoncreds-clsignatures = { path = "/Users/artem/anoncreds-clsignatures-rs", features = ["bytes_serialization"] } +anoncreds-clsignatures = { git = "https://github.com/DSRCorporation/anoncreds-clsignatures-rs.git", branch = "feature/encoding", features = ["type_extensions"] } bs58 = "0.4.0" env_logger = { version = "0.9.3", optional = true } ffi-support = { version = "0.4.0", optional = true } diff --git a/src/data_types/nonce.rs b/src/data_types/nonce.rs index c69f2807..4570106b 100644 --- a/src/data_types/nonce.rs +++ b/src/data_types/nonce.rs @@ -4,8 +4,8 @@ use std::hash::{Hash, Hasher}; use crate::cl::{new_nonce, Nonce as CryptoNonce}; use crate::error::ConversionError; -use serde::{de::Visitor, Deserialize, Deserializer, Serialize, Serializer}; use serde::de::{Error, SeqAccess}; +use serde::{de::Visitor, Deserialize, Deserializer, Serialize, Serializer}; use serde_json::Value; pub struct Nonce { @@ -55,8 +55,9 @@ impl Nonce { } pub fn from_bytes(bytes: &[u8]) -> Result { - let native = CryptoNonce::from_bytes(bytes) - .map_err(|err| ConversionError::from_msg(format!("Error converting nonce from bytes: {err}")))?; + let native = CryptoNonce::from_bytes(bytes).map_err(|err| { + ConversionError::from_msg(format!("Error converting nonce from bytes: {err}")) + })?; Self::from_native(native) } @@ -150,7 +151,7 @@ impl Serialize for Nonce { where S: Serializer, { - serializer.serialize_bytes(&self.native.to_bytes().unwrap_or_default()) + serializer.serialize_str(&self.strval) } } @@ -196,7 +197,10 @@ impl<'a> Deserialize<'a> for Nonce { Nonce::from_dec(value).map_err(E::custom) } - fn visit_seq(self, mut seq: E) -> Result where E: SeqAccess<'a> { + fn visit_seq(self, mut seq: E) -> Result + where + E: SeqAccess<'a>, + { let mut vec = Vec::new(); while let Ok(Some(Value::Number(elem))) = seq.next_element() { diff --git a/src/data_types/w3c/credential_proof.rs b/src/data_types/w3c/credential_proof.rs index 5efc1a94..b0a57c80 100644 --- a/src/data_types/w3c/credential_proof.rs +++ b/src/data_types/w3c/credential_proof.rs @@ -1,14 +1,11 @@ use crate::data_types::w3c::presentation_proof::CredentialPresentationProof; -use crate::utils::encoded_object::EncodedObject; -use crate::Result; use anoncreds_clsignatures::{ - CredentialSignature as CLCredentialSignature, RevocationRegistry, SignatureCorrectnessProof, - Witness, + CredentialSignature as CLCredentialSignature, CredentialSignatureBytesProxy, + RevocationRegistry, RevocationRegistryBytesProxy, SignatureCorrectnessProof, + SignatureCorrectnessProofBytesProxy, Witness, WitnessBytesProxy, }; use serde::Serialize; use serde_json::Value; -use crate::data_types::w3c::encoded_object::EncodedObject; -use crate::Result; #[allow(clippy::large_enum_variant)] #[derive(Debug, Clone, Serialize, Deserialize)] @@ -28,12 +25,10 @@ pub struct CredentialSignatureProof { impl CredentialSignatureProof { pub fn new(signature: CredentialSignature) -> Result { - Ok( - CredentialSignatureProof { - type_: CredentialSignatureType::AnonCredsProof2023, - signature: signature.encode()?, - } - ) + Ok(CredentialSignatureProof { + type_: CredentialSignatureType::AnonCredsProof2023, + signature: signature.encode()?, + }) } pub fn get_credential_signature(&self) -> Result { diff --git a/src/data_types/w3c/encoded_object.rs b/src/data_types/w3c/encoded_object.rs deleted file mode 100644 index 1d46c07a..00000000 --- a/src/data_types/w3c/encoded_object.rs +++ /dev/null @@ -1,19 +0,0 @@ -use serde::de::DeserializeOwned; -use serde::Serialize; -use crate::Result; -use crate::utils::msg_pack; -use crate::utils::base64; - -pub trait EncodedObject { - fn encode(&self) -> Result where Self: Serialize + DeserializeOwned { - let bytes = msg_pack::encode(self)?; - let base64_encoded = base64::encode(&bytes); - Ok(base64_encoded) - } - - fn decode(string: &str) -> Result where Self: Sized + DeserializeOwned { - let bytes = base64::decode(string.as_bytes())?; - let json = msg_pack::decode(&bytes)?; - Ok(json) - } -} \ No newline at end of file diff --git a/src/data_types/w3c/mod.rs b/src/data_types/w3c/mod.rs index 6b6adea2..448e3a01 100644 --- a/src/data_types/w3c/mod.rs +++ b/src/data_types/w3c/mod.rs @@ -7,4 +7,3 @@ pub mod one_or_many; pub mod presentation; pub mod presentation_proof; pub mod uri; -pub mod encoded_object; diff --git a/src/services/w3c/credential_conversion.rs b/src/services/w3c/credential_conversion.rs index 209f91a3..c70322f2 100644 --- a/src/services/w3c/credential_conversion.rs +++ b/src/services/w3c/credential_conversion.rs @@ -258,8 +258,10 @@ mod tests { }; use crate::utils::encoded_object::EncodedObject; use crate::{issuer, ErrorKind}; - use anoncreds_clsignatures::{CredentialSignature as CLCredentialSignature, SignatureCorrectnessProof as CLSignatureCorrectnessProof}; - use crate::data_types::w3c::encoded_object::EncodedObject; + use anoncreds_clsignatures::{ + CredentialSignature as CLCredentialSignature, + SignatureCorrectnessProof as CLSignatureCorrectnessProof, + }; const ISSUER_ID: &str = "mock:uri"; const SCHEMA_ID: &str = "mock:uri"; @@ -294,7 +296,7 @@ mod tests { support_revocation: true, }, ) - .unwrap(); + .unwrap(); cred_def } @@ -367,7 +369,7 @@ mod tests { .expect("unable to convert credential to w3c form"); let legacy_credential = credential_from_w3c(&w3c_credential) .expect("unable to convert credential to legacy form"); - assert_eq!(json!(original_legacy_credential), json!(legacy_credential), ) + assert_eq!(json!(original_legacy_credential), json!(legacy_credential),) } #[test] diff --git a/src/utils/encoder.rs b/src/utils/encoder.rs new file mode 100644 index 00000000..5820bfd8 --- /dev/null +++ b/src/utils/encoder.rs @@ -0,0 +1,23 @@ +use crate::utils::base64; +use crate::utils::msg_pack; +use crate::Result; +use serde::de::DeserializeOwned; +use serde::Serialize; + +pub fn encode(object: &T) -> Result +where + T: Serialize, +{ + let bytes = msg_pack::encode(object)?; + let base64_encoded = base64::encode(bytes); + Ok(base64_encoded) +} + +pub fn decode(string: &str) -> Result +where + T: Sized + DeserializeOwned, +{ + let bytes = base64::decode(string.as_bytes())?; + let json = msg_pack::decode(&bytes)?; + Ok(json) +} diff --git a/src/utils/mod.rs b/src/utils/mod.rs index a34e9eec..0ba8c7db 100644 --- a/src/utils/mod.rs +++ b/src/utils/mod.rs @@ -7,7 +7,7 @@ pub mod base58; pub mod base64; #[cfg(feature = "w3c")] -pub mod encoded_object; +pub mod encoder; pub mod hash; diff --git a/src/utils/msg_pack.rs b/src/utils/msg_pack.rs index f13749e6..7ed0d2f9 100644 --- a/src/utils/msg_pack.rs +++ b/src/utils/msg_pack.rs @@ -4,12 +4,9 @@ use serde::Serialize; use crate::Result; pub fn encode(val: T) -> Result> { - rmp_serde::to_vec(&val) - .map_err(|_| err_msg!("unable to encode message using message pack")) + rmp_serde::to_vec(&val).map_err(|_| err_msg!("unable to encode message using message pack")) } pub fn decode(val: &[u8]) -> Result { - rmp_serde::from_slice(val) - .map_err(|_| err_msg!("unable to decode message using message pack")) + rmp_serde::from_slice(val).map_err(|_| err_msg!("unable to decode message using message pack")) } - From 3a9416088aa61c74d7bc378ce56c124772a98db7 Mon Sep 17 00:00:00 2001 From: "artem.ivanov" Date: Wed, 22 Nov 2023 11:59:35 +0300 Subject: [PATCH 03/14] Fixed rebase errors Signed-off-by: artem.ivanov --- src/data_types/w3c/credential_proof.rs | 1 - src/services/w3c/credential_conversion.rs | 1 - 2 files changed, 2 deletions(-) diff --git a/src/data_types/w3c/credential_proof.rs b/src/data_types/w3c/credential_proof.rs index b0a57c80..c89b1642 100644 --- a/src/data_types/w3c/credential_proof.rs +++ b/src/data_types/w3c/credential_proof.rs @@ -5,7 +5,6 @@ use anoncreds_clsignatures::{ SignatureCorrectnessProofBytesProxy, Witness, WitnessBytesProxy, }; use serde::Serialize; -use serde_json::Value; #[allow(clippy::large_enum_variant)] #[derive(Debug, Clone, Serialize, Deserialize)] diff --git a/src/services/w3c/credential_conversion.rs b/src/services/w3c/credential_conversion.rs index c70322f2..ad7a930d 100644 --- a/src/services/w3c/credential_conversion.rs +++ b/src/services/w3c/credential_conversion.rs @@ -256,7 +256,6 @@ mod tests { AttributeNames, CredentialDefinitionConfig, CredentialValues, MakeCredentialValues, SignatureType, }; - use crate::utils::encoded_object::EncodedObject; use crate::{issuer, ErrorKind}; use anoncreds_clsignatures::{ CredentialSignature as CLCredentialSignature, From 0fb159f13ea172424ec23fae5fb83843d87c97cf Mon Sep 17 00:00:00 2001 From: "artem.ivanov" Date: Thu, 23 Nov 2023 08:10:10 +0300 Subject: [PATCH 04/14] Removed redundant file Signed-off-by: artem.ivanov --- src/utils/encoded_object.rs | 20 -------------------- 1 file changed, 20 deletions(-) delete mode 100644 src/utils/encoded_object.rs diff --git a/src/utils/encoded_object.rs b/src/utils/encoded_object.rs deleted file mode 100644 index 26b5ea9f..00000000 --- a/src/utils/encoded_object.rs +++ /dev/null @@ -1,20 +0,0 @@ -use crate::utils::base64; -use crate::Result; -use serde::de::DeserializeOwned; -use serde::Serialize; - -pub trait EncodedObject { - fn encode(&self) -> String - where - Self: Serialize, - { - base64::encode_json(self) - } - - fn decode(string: &str) -> Result - where - Self: DeserializeOwned, - { - base64::decode_json(string) - } -} From d90114dbb925910c2979fdd5d56d6db363ec7520 Mon Sep 17 00:00:00 2001 From: "artem.ivanov" Date: Thu, 23 Nov 2023 11:28:47 +0300 Subject: [PATCH 05/14] Reworked encoding Signed-off-by: artem.ivanov --- Cargo.toml | 2 +- src/services/w3c/credential_conversion.rs | 1 + src/utils/encoded_object.rs | 25 +++++++++++++++++++++++ src/utils/encoder.rs | 23 --------------------- src/utils/mod.rs | 2 +- src/utils/msg_pack.rs | 3 ++- 6 files changed, 30 insertions(+), 26 deletions(-) create mode 100644 src/utils/encoded_object.rs delete mode 100644 src/utils/encoder.rs diff --git a/Cargo.toml b/Cargo.toml index 5bfafbdf..a476afa4 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -27,7 +27,7 @@ vendored = ["anoncreds-clsignatures/openssl_vendored"] w3c = ["base64", "chrono", "rmp-serde"] [dependencies] -anoncreds-clsignatures = { git = "https://github.com/DSRCorporation/anoncreds-clsignatures-rs.git", branch = "feature/encoding", features = ["type_extensions"] } +anoncreds-clsignatures = { git = "https://github.com/DSRCorporation/anoncreds-clsignatures-rs.git", branch = "feature/encoding"} bs58 = "0.4.0" env_logger = { version = "0.9.3", optional = true } ffi-support = { version = "0.4.0", optional = true } diff --git a/src/services/w3c/credential_conversion.rs b/src/services/w3c/credential_conversion.rs index ad7a930d..c70322f2 100644 --- a/src/services/w3c/credential_conversion.rs +++ b/src/services/w3c/credential_conversion.rs @@ -256,6 +256,7 @@ mod tests { AttributeNames, CredentialDefinitionConfig, CredentialValues, MakeCredentialValues, SignatureType, }; + use crate::utils::encoded_object::EncodedObject; use crate::{issuer, ErrorKind}; use anoncreds_clsignatures::{ CredentialSignature as CLCredentialSignature, diff --git a/src/utils/encoded_object.rs b/src/utils/encoded_object.rs new file mode 100644 index 00000000..cad5323c --- /dev/null +++ b/src/utils/encoded_object.rs @@ -0,0 +1,25 @@ +use crate::utils::base64; +use crate::utils::msg_pack; +use crate::Result; +use serde::de::DeserializeOwned; +use serde::Serialize; + +pub trait EncodedObject { + fn encode(&self) -> Result + where + Self: Serialize, + { + let bytes = msg_pack::encode(self)?; + let base64_encoded = base64::encode(bytes); + Ok(base64_encoded) + } + + fn decode(string: &str) -> Result + where + Self: DeserializeOwned, + { + let bytes = base64::decode(string.as_bytes())?; + let json = msg_pack::decode(&bytes)?; + Ok(json) + } +} diff --git a/src/utils/encoder.rs b/src/utils/encoder.rs deleted file mode 100644 index 5820bfd8..00000000 --- a/src/utils/encoder.rs +++ /dev/null @@ -1,23 +0,0 @@ -use crate::utils::base64; -use crate::utils::msg_pack; -use crate::Result; -use serde::de::DeserializeOwned; -use serde::Serialize; - -pub fn encode(object: &T) -> Result -where - T: Serialize, -{ - let bytes = msg_pack::encode(object)?; - let base64_encoded = base64::encode(bytes); - Ok(base64_encoded) -} - -pub fn decode(string: &str) -> Result -where - T: Sized + DeserializeOwned, -{ - let bytes = base64::decode(string.as_bytes())?; - let json = msg_pack::decode(&bytes)?; - Ok(json) -} diff --git a/src/utils/mod.rs b/src/utils/mod.rs index 0ba8c7db..a34e9eec 100644 --- a/src/utils/mod.rs +++ b/src/utils/mod.rs @@ -7,7 +7,7 @@ pub mod base58; pub mod base64; #[cfg(feature = "w3c")] -pub mod encoder; +pub mod encoded_object; pub mod hash; diff --git a/src/utils/msg_pack.rs b/src/utils/msg_pack.rs index 7ed0d2f9..fd53dde5 100644 --- a/src/utils/msg_pack.rs +++ b/src/utils/msg_pack.rs @@ -4,7 +4,8 @@ use serde::Serialize; use crate::Result; pub fn encode(val: T) -> Result> { - rmp_serde::to_vec(&val).map_err(|_| err_msg!("unable to encode message using message pack")) + rmp_serde::to_vec_named(&val) + .map_err(|_| err_msg!("unable to encode message using message pack")) } pub fn decode(val: &[u8]) -> Result { From 2a7cbe61f89ee4b18078ed2fbb71425ac1dd49c6 Mon Sep 17 00:00:00 2001 From: "artem.ivanov" Date: Sat, 2 Dec 2023 11:55:04 +0300 Subject: [PATCH 06/14] Fix rebase issues Signed-off-by: artem.ivanov --- src/data_types/w3c/credential_proof.rs | 7 +++--- src/data_types/w3c/presentation_proof.rs | 27 +++++++++-------------- src/services/w3c/credential_conversion.rs | 4 +++- src/services/w3c/issuer.rs | 2 +- src/services/w3c/prover.rs | 6 ++--- tests/anoncreds_demos.rs | 1 - 6 files changed, 22 insertions(+), 25 deletions(-) diff --git a/src/data_types/w3c/credential_proof.rs b/src/data_types/w3c/credential_proof.rs index c89b1642..5116ec4c 100644 --- a/src/data_types/w3c/credential_proof.rs +++ b/src/data_types/w3c/credential_proof.rs @@ -1,8 +1,9 @@ use crate::data_types::w3c::presentation_proof::CredentialPresentationProof; +use crate::utils::encoded_object::EncodedObject; +use crate::Result; use anoncreds_clsignatures::{ - CredentialSignature as CLCredentialSignature, CredentialSignatureBytesProxy, - RevocationRegistry, RevocationRegistryBytesProxy, SignatureCorrectnessProof, - SignatureCorrectnessProofBytesProxy, Witness, WitnessBytesProxy, + CredentialSignature as CLCredentialSignature, RevocationRegistry, SignatureCorrectnessProof, + Witness, }; use serde::Serialize; diff --git a/src/data_types/w3c/presentation_proof.rs b/src/data_types/w3c/presentation_proof.rs index 91e83223..1bd00a4e 100644 --- a/src/data_types/w3c/presentation_proof.rs +++ b/src/data_types/w3c/presentation_proof.rs @@ -3,7 +3,6 @@ use crate::utils::encoded_object::EncodedObject; use crate::Result; use anoncreds_clsignatures::{AggregatedProof, SubProof}; use std::collections::HashSet; -use crate::data_types::w3c::encoded_object::EncodedObject; #[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] @@ -39,14 +38,12 @@ impl CredentialPresentationProof { mapping: CredentialAttributesMapping, timestamp: Option, ) -> Result { - Ok( - CredentialPresentationProof { - type_: PresentationProofType::AnonCredsPresentationProof2023, - mapping, - timestamp, - proof_value: proof_value.encode()?, - } - ) + Ok(CredentialPresentationProof { + type_: PresentationProofType::AnonCredsPresentationProof2023, + mapping, + timestamp, + proof_value: proof_value.encode()?, + }) } pub fn get_proof_value(&self) -> Result { @@ -74,13 +71,11 @@ pub struct PresentationProofValue { impl PresentationProof { pub fn new(proof_value: PresentationProofValue, nonce: String) -> Result { - Ok( - PresentationProof { - type_: PresentationProofType::AnonCredsPresentationProof2023, - challenge: nonce, - proof_value: proof_value.encode()?, - } - ) + Ok(PresentationProof { + type_: PresentationProofType::AnonCredsPresentationProof2023, + challenge: nonce, + proof_value: proof_value.encode()?, + }) } pub fn get_proof_value(&self) -> Result { diff --git a/src/services/w3c/credential_conversion.rs b/src/services/w3c/credential_conversion.rs index c70322f2..a74681f7 100644 --- a/src/services/w3c/credential_conversion.rs +++ b/src/services/w3c/credential_conversion.rs @@ -357,7 +357,9 @@ mod tests { CredentialValuesEncoding::Auto, )); credential.set_attributes(CredentialAttributes::from(&_cred_values())); - credential.add_anoncreds_signature_proof(CredentialSignatureProof::new(_signature_data())); + credential.add_anoncreds_signature_proof( + CredentialSignatureProof::new(_signature_data()).unwrap(), + ); credential } diff --git a/src/services/w3c/issuer.rs b/src/services/w3c/issuer.rs index bca88f52..830d47fe 100644 --- a/src/services/w3c/issuer.rs +++ b/src/services/w3c/issuer.rs @@ -113,7 +113,7 @@ pub fn create_credential( rev_reg, witness, ); - let proof = CredentialSignatureProof::new(signature); + let proof = CredentialSignatureProof::new(signature)?; let credential_schema = CredentialSchema::new( cred_offer.schema_id.to_owned(), cred_offer.cred_def_id.to_owned(), diff --git a/src/services/w3c/prover.rs b/src/services/w3c/prover.rs index e0fd3791..20380775 100644 --- a/src/services/w3c/prover.rs +++ b/src/services/w3c/prover.rs @@ -126,7 +126,7 @@ pub fn process_credential( signature.rev_reg, signature.witness, ); - *proof = CredentialSignatureProof::new(signature); + *proof = CredentialSignatureProof::new(signature)?; trace!("process_w3c_credential <<< "); @@ -184,7 +184,7 @@ pub fn create_presentation( let presentation_proof_value = PresentationProofValue::new(cl_proof.aggregated_proof); let presentation_proof = - PresentationProof::new(presentation_proof_value, pres_req.nonce.to_string()); + PresentationProof::new(presentation_proof_value, pres_req.nonce.to_string())?; let mut presentation = W3CPresentation::new(); presentation.set_proof(presentation_proof); @@ -195,7 +195,7 @@ pub fn create_presentation( let mapping = build_mapping(pres_req, present)?; let credential_subject = build_credential_subject(pres_req, present)?; let proof_value = CredentialPresentationProofValue::new(sub_proof); - let proof = CredentialPresentationProof::new(proof_value, mapping, present.timestamp); + let proof = CredentialPresentationProof::new(proof_value, mapping, present.timestamp)?; let mut credential = present.cred.to_owned(); credential.set_anoncreds_presentation_proof(proof); diff --git a/tests/anoncreds_demos.rs b/tests/anoncreds_demos.rs index 3416fd68..911a195f 100644 --- a/tests/anoncreds_demos.rs +++ b/tests/anoncreds_demos.rs @@ -1,6 +1,5 @@ use anoncreds::data_types::pres_request::PredicateTypes; use anoncreds::data_types::w3c::credential::CredentialAttributeValue; -use anoncreds::data_types::w3c::credential_proof::CredentialProof; use anoncreds::data_types::w3c::presentation_proof::{PredicateAttribute, PredicateAttributeType}; use anoncreds::data_types::w3c::uri::URI; use anoncreds::verifier; From f99386a1d2d281f86344f4430233053269ec91eb Mon Sep 17 00:00:00 2001 From: "artem.ivanov" Date: Fri, 8 Dec 2023 09:37:43 +0300 Subject: [PATCH 07/14] Corrected rebase errors Signed-off-by: artem.ivanov --- Cargo.toml | 2 +- src/data_types/w3c/credential_proof.rs | 2 +- .../w3c}/encoded_object.rs | 24 +++++++++++++++++++ src/data_types/w3c/mod.rs | 1 + src/data_types/w3c/presentation_proof.rs | 2 +- src/services/w3c/credential_conversion.rs | 2 +- src/utils/mod.rs | 3 --- 7 files changed, 29 insertions(+), 7 deletions(-) rename src/{utils => data_types/w3c}/encoded_object.rs (52%) diff --git a/Cargo.toml b/Cargo.toml index a476afa4..04c68278 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -27,7 +27,7 @@ vendored = ["anoncreds-clsignatures/openssl_vendored"] w3c = ["base64", "chrono", "rmp-serde"] [dependencies] -anoncreds-clsignatures = { git = "https://github.com/DSRCorporation/anoncreds-clsignatures-rs.git", branch = "feature/encoding"} +anoncreds-clsignatures = "0.3.0" bs58 = "0.4.0" env_logger = { version = "0.9.3", optional = true } ffi-support = { version = "0.4.0", optional = true } diff --git a/src/data_types/w3c/credential_proof.rs b/src/data_types/w3c/credential_proof.rs index 5116ec4c..7968d7e7 100644 --- a/src/data_types/w3c/credential_proof.rs +++ b/src/data_types/w3c/credential_proof.rs @@ -1,5 +1,5 @@ +use crate::data_types::w3c::encoded_object::EncodedObject; use crate::data_types::w3c::presentation_proof::CredentialPresentationProof; -use crate::utils::encoded_object::EncodedObject; use crate::Result; use anoncreds_clsignatures::{ CredentialSignature as CLCredentialSignature, RevocationRegistry, SignatureCorrectnessProof, diff --git a/src/utils/encoded_object.rs b/src/data_types/w3c/encoded_object.rs similarity index 52% rename from src/utils/encoded_object.rs rename to src/data_types/w3c/encoded_object.rs index cad5323c..a624a2f7 100644 --- a/src/utils/encoded_object.rs +++ b/src/data_types/w3c/encoded_object.rs @@ -23,3 +23,27 @@ pub trait EncodedObject { Ok(json) } } + +#[cfg(test)] +mod tests { + use super::*; + + #[derive(Debug, PartialEq, Serialize, Deserialize)] + struct TestObject { + type_: String, + value: i32, + } + + impl EncodedObject for TestObject {} + + #[test] + fn encoded_object_encode_decode_works() { + let obj = TestObject { + type_: "Test".to_string(), + value: 1, + }; + let encoded = obj.encode().unwrap(); + let decoded = TestObject::decode(&encoded).unwrap(); + assert_eq!(obj, decoded) + } +} diff --git a/src/data_types/w3c/mod.rs b/src/data_types/w3c/mod.rs index 448e3a01..32e22475 100644 --- a/src/data_types/w3c/mod.rs +++ b/src/data_types/w3c/mod.rs @@ -2,6 +2,7 @@ pub mod constants; /// AnonCreds W3C Credentials definition pub mod credential; pub mod credential_proof; +pub mod encoded_object; pub mod one_or_many; /// AnonCreds W3C Presentation definition pub mod presentation; diff --git a/src/data_types/w3c/presentation_proof.rs b/src/data_types/w3c/presentation_proof.rs index 1bd00a4e..051cfa3e 100644 --- a/src/data_types/w3c/presentation_proof.rs +++ b/src/data_types/w3c/presentation_proof.rs @@ -1,5 +1,5 @@ use crate::data_types::pres_request::{PredicateInfo, PredicateTypes}; -use crate::utils::encoded_object::EncodedObject; +use crate::data_types::w3c::encoded_object::EncodedObject; use crate::Result; use anoncreds_clsignatures::{AggregatedProof, SubProof}; use std::collections::HashSet; diff --git a/src/services/w3c/credential_conversion.rs b/src/services/w3c/credential_conversion.rs index a74681f7..74fcbb30 100644 --- a/src/services/w3c/credential_conversion.rs +++ b/src/services/w3c/credential_conversion.rs @@ -251,12 +251,12 @@ mod tests { use crate::data_types::issuer_id::IssuerId; use crate::data_types::schema::SchemaId; use crate::data_types::w3c::constants::{ANONCREDS_CONTEXTS, ANONCREDS_CREDENTIAL_TYPES}; + use crate::data_types::w3c::encoded_object::EncodedObject; use crate::data_types::w3c::one_or_many::OneOrMany; use crate::types::{ AttributeNames, CredentialDefinitionConfig, CredentialValues, MakeCredentialValues, SignatureType, }; - use crate::utils::encoded_object::EncodedObject; use crate::{issuer, ErrorKind}; use anoncreds_clsignatures::{ CredentialSignature as CLCredentialSignature, diff --git a/src/utils/mod.rs b/src/utils/mod.rs index a34e9eec..9931f1d0 100644 --- a/src/utils/mod.rs +++ b/src/utils/mod.rs @@ -6,9 +6,6 @@ pub mod base58; #[cfg(feature = "w3c")] pub mod base64; -#[cfg(feature = "w3c")] -pub mod encoded_object; - pub mod hash; pub mod query; From 1dd27f023ec9aef5de9ed0bd14c8baed429047a4 Mon Sep 17 00:00:00 2001 From: "artem.ivanov" Date: Wed, 20 Dec 2023 09:36:28 +0300 Subject: [PATCH 08/14] Updated Rust version to 1.70.0 due to cross compilation issue Signed-off-by: artem.ivanov --- .github/workflows/build.yml | 2 +- src/services/w3c/prover.rs | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 0bdda9af..59c58ac2 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -1,7 +1,7 @@ name: "Anoncreds" env: - RUST_VERSION: "1.65.0" + RUST_VERSION: "1.70.0" CROSS_VERSION: "0.2.4" on: diff --git a/src/services/w3c/prover.rs b/src/services/w3c/prover.rs index 33d729c5..6bec5f68 100644 --- a/src/services/w3c/prover.rs +++ b/src/services/w3c/prover.rs @@ -219,9 +219,9 @@ pub fn create_presentation( Ok(presentation) } -fn build_credential_subject<'p>( +fn build_credential_subject( pres_req: &PresentationRequestPayload, - credentials: &PresentCredential<'p, W3CCredential>, + credentials: &PresentCredential<'_, W3CCredential>, ) -> Result { let mut credential_subject = CredentialSubject { id: credentials.cred.credential_subject.id.clone(), From 7c9939d169ed41743316772aba211d553d97d63c Mon Sep 17 00:00:00 2001 From: "artem.ivanov" Date: Wed, 20 Dec 2023 09:48:30 +0300 Subject: [PATCH 09/14] Fixed merge errors Signed-off-by: artem.ivanov --- src/data_types/w3c/encoded_object.rs | 49 --------------- src/data_types/w3c/proof.rs | 77 +++++++++++++++++------ src/services/w3c/credential_conversion.rs | 4 +- src/services/w3c/issuer.rs | 2 +- src/services/w3c/prover.rs | 6 +- src/services/w3c/verifier.rs | 13 +++- 6 files changed, 73 insertions(+), 78 deletions(-) delete mode 100644 src/data_types/w3c/encoded_object.rs diff --git a/src/data_types/w3c/encoded_object.rs b/src/data_types/w3c/encoded_object.rs deleted file mode 100644 index a624a2f7..00000000 --- a/src/data_types/w3c/encoded_object.rs +++ /dev/null @@ -1,49 +0,0 @@ -use crate::utils::base64; -use crate::utils::msg_pack; -use crate::Result; -use serde::de::DeserializeOwned; -use serde::Serialize; - -pub trait EncodedObject { - fn encode(&self) -> Result - where - Self: Serialize, - { - let bytes = msg_pack::encode(self)?; - let base64_encoded = base64::encode(bytes); - Ok(base64_encoded) - } - - fn decode(string: &str) -> Result - where - Self: DeserializeOwned, - { - let bytes = base64::decode(string.as_bytes())?; - let json = msg_pack::decode(&bytes)?; - Ok(json) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[derive(Debug, PartialEq, Serialize, Deserialize)] - struct TestObject { - type_: String, - value: i32, - } - - impl EncodedObject for TestObject {} - - #[test] - fn encoded_object_encode_decode_works() { - let obj = TestObject { - type_: "Test".to_string(), - value: 1, - }; - let encoded = obj.encode().unwrap(); - let decoded = TestObject::decode(&encoded).unwrap(); - assert_eq!(obj, decoded) - } -} diff --git a/src/data_types/w3c/proof.rs b/src/data_types/w3c/proof.rs index 48e4fcba..d8e706fa 100644 --- a/src/data_types/w3c/proof.rs +++ b/src/data_types/w3c/proof.rs @@ -1,8 +1,10 @@ use crate::data_types::cred_def::CredentialDefinitionId; use crate::data_types::rev_reg_def::RevocationRegistryDefinitionId; use crate::data_types::schema::SchemaId; -use crate::utils::encoded_object::EncodedObject; +use crate::utils::base64; +use crate::utils::msg_pack; use crate::Result; + use anoncreds_clsignatures::{ AggregatedProof, CredentialSignature as CLCredentialSignature, RevocationRegistry, SignatureCorrectnessProof, SubProof, Witness, @@ -37,45 +39,36 @@ pub enum CryptoSuite { AnonCredsPresVp2023, } -impl Default for DataIntegrityProof { - fn default() -> Self { - DataIntegrityProof { - type_: DataIntegrityProofType::DataIntegrityProof, - cryptosuite: CryptoSuite::AnonCredsVc2023, - proof_value: "".to_string(), - challenge: None, - } - } -} - impl DataIntegrityProof { pub fn new( cryptosuite: CryptoSuite, value: V, challenge: Option, - ) -> Self { - DataIntegrityProof { + ) -> Result { + Ok(DataIntegrityProof { cryptosuite, - proof_value: value.encode(), + proof_value: value.encode()?, challenge, - ..DataIntegrityProof::default() - } + type_: DataIntegrityProofType::DataIntegrityProof, + }) } - pub(crate) fn new_credential_proof(value: CredentialSignatureProof) -> DataIntegrityProof { + pub(crate) fn new_credential_proof( + value: CredentialSignatureProof, + ) -> Result { DataIntegrityProof::new(CryptoSuite::AnonCredsVc2023, value, None) } pub(crate) fn new_credential_presentation_proof( value: CredentialPresentationProofValue, - ) -> DataIntegrityProof { + ) -> Result { DataIntegrityProof::new(CryptoSuite::AnonCredsPresVc2023, value, None) } pub(crate) fn new_presentation_proof( value: PresentationProofValue, challenge: String, - ) -> DataIntegrityProof { + ) -> Result { DataIntegrityProof::new(CryptoSuite::AnonCredsPresVp2023, value, Some(challenge)) } @@ -197,3 +190,47 @@ pub struct CredentialProofDetails { pub rev_reg_index: Option, pub timestamp: Option, } + +pub trait EncodedObject { + fn encode(&self) -> Result + where + Self: Serialize, + { + let bytes = msg_pack::encode(self)?; + let base64_encoded = base64::encode(bytes); + Ok(base64_encoded) + } + + fn decode(string: &str) -> Result + where + Self: DeserializeOwned, + { + let bytes = base64::decode(string.as_bytes())?; + let json = msg_pack::decode(&bytes)?; + Ok(json) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[derive(Debug, PartialEq, Serialize, Deserialize)] + struct TestObject { + type_: String, + value: i32, + } + + impl EncodedObject for TestObject {} + + #[test] + fn encoded_object_encode_decode_works() { + let obj = TestObject { + type_: "Test".to_string(), + value: 1, + }; + let encoded = obj.encode().unwrap(); + let decoded = TestObject::decode(&encoded).unwrap(); + assert_eq!(obj, decoded) + } +} diff --git a/src/services/w3c/credential_conversion.rs b/src/services/w3c/credential_conversion.rs index b0da9b53..b7be8eff 100644 --- a/src/services/w3c/credential_conversion.rs +++ b/src/services/w3c/credential_conversion.rs @@ -110,7 +110,7 @@ pub fn credential_to_w3c( rev_reg: credential.rev_reg, witness: credential.witness, }; - let proof = DataIntegrityProof::new_credential_proof(signature); + let proof = DataIntegrityProof::new_credential_proof(signature)?; let w3c_credential = W3CCredential::new(issuer, attributes, proof, version); trace!("credential_to_w3c <<< w3c_credential {:?}", w3c_credential); @@ -347,7 +347,7 @@ pub(super) mod tests { W3CCredential::new( issuer_id(), CredentialAttributes::from(&cred_values()), - DataIntegrityProof::new_credential_proof(_signature_data()), + DataIntegrityProof::new_credential_proof(_signature_data()).unwrap(), None, ) } diff --git a/src/services/w3c/issuer.rs b/src/services/w3c/issuer.rs index df69d976..dd36adbf 100644 --- a/src/services/w3c/issuer.rs +++ b/src/services/w3c/issuer.rs @@ -116,7 +116,7 @@ pub fn create_credential( witness, }; - let proof = DataIntegrityProof::new_credential_proof(signature); + let proof = DataIntegrityProof::new_credential_proof(signature)?; let credential = W3CCredential::new( cred_def.issuer_id.to_owned(), raw_credential_values, diff --git a/src/services/w3c/prover.rs b/src/services/w3c/prover.rs index 6bec5f68..712b8902 100644 --- a/src/services/w3c/prover.rs +++ b/src/services/w3c/prover.rs @@ -119,7 +119,7 @@ pub fn process_credential( credential_signature.witness.as_ref(), )?; - *proof = DataIntegrityProof::new_credential_proof(credential_signature); + *proof = DataIntegrityProof::new_credential_proof(credential_signature)?; trace!("process_w3c_credential <<< "); @@ -192,7 +192,7 @@ pub fn create_presentation( timestamp: present.timestamp, sub_proof, }; - let proof = DataIntegrityProof::new_credential_presentation_proof(proof); + let proof = DataIntegrityProof::new_credential_presentation_proof(proof)?; let credential = W3CCredential { credential_subject, proof: OneOrMany::One(CredentialProof::DataIntegrityProof(proof)), @@ -208,7 +208,7 @@ pub fn create_presentation( let proof = DataIntegrityProof::new_presentation_proof( presentation_proof, presentation_request.nonce.to_string(), - ); + )?; let presentation = W3CPresentation::new(verifiable_credentials, proof, version); trace!( diff --git a/src/services/w3c/verifier.rs b/src/services/w3c/verifier.rs index f585f4e0..d2155982 100644 --- a/src/services/w3c/verifier.rs +++ b/src/services/w3c/verifier.rs @@ -370,7 +370,7 @@ mod tests { use crate::data_types::pres_request::{AttributeInfo, PredicateTypes}; use crate::data_types::w3c::credential_attributes::CredentialAttributes; use crate::data_types::w3c::presentation::PredicateAttribute; - use crate::data_types::w3c::proof::DataIntegrityProof; + use crate::data_types::w3c::proof::{CryptoSuite, DataIntegrityProof, DataIntegrityProofType}; use crate::w3c::credential_conversion::tests::{ cred_def_id, credential_definition, issuer_id, schema, schema_id, }; @@ -448,12 +448,19 @@ mod tests { timestamp: Some(PROOF_TIMESTAMP), sub_proof: _credential_proof(), }, - ); + ) + .unwrap(); W3CCredential::new(issuer_id(), _credential_attributes(), proof, None) } fn _w3_presentation() -> W3CPresentation { - W3CPresentation::new(vec![_credential()], DataIntegrityProof::default(), None) + let proof = DataIntegrityProof { + type_: DataIntegrityProofType::DataIntegrityProof, + cryptosuite: CryptoSuite::AnonCredsPresVp2023, + proof_value: "bla".to_string(), + challenge: Some("1".to_string()), + }; + W3CPresentation::new(vec![_credential()], proof, None) } fn _base_presentation_request() -> PresentationRequestPayload { From 50d4c6d1ab0dd25b087c1c5bfb610bb8feb87346 Mon Sep 17 00:00:00 2001 From: "artem.ivanov" Date: Wed, 20 Dec 2023 13:56:43 +0300 Subject: [PATCH 10/14] Returned rust version to 1.65.0 Signed-off-by: artem.ivanov --- .github/workflows/build.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index e9b2c678..1dd1030a 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -1,7 +1,7 @@ name: "Anoncreds" env: - RUST_VERSION: "1.70.0" + RUST_VERSION: "1.65.0" CROSS_VERSION: "0.2.4" on: From 5a1a50321139f2f2d348e739ddd149a27f0a816d Mon Sep 17 00:00:00 2001 From: "artem.ivanov" Date: Thu, 21 Dec 2023 10:13:01 +0300 Subject: [PATCH 11/14] Corrected proof value encoding Signed-off-by: artem.ivanov --- src/data_types/w3c/proof.rs | 26 +++++++++++++++++++++++++- src/utils/encoded_object.rs | 20 -------------------- src/utils/mod.rs | 3 --- 3 files changed, 25 insertions(+), 24 deletions(-) delete mode 100644 src/utils/encoded_object.rs diff --git a/src/data_types/w3c/proof.rs b/src/data_types/w3c/proof.rs index e30a0653..4c63503a 100644 --- a/src/data_types/w3c/proof.rs +++ b/src/data_types/w3c/proof.rs @@ -1,7 +1,6 @@ use crate::data_types::cred_def::CredentialDefinitionId; use crate::data_types::rev_reg_def::RevocationRegistryDefinitionId; use crate::data_types::schema::SchemaId; -use crate::utils::encoded_object::EncodedObject; use crate::Result; use anoncreds_clsignatures::{ AggregatedProof, CredentialSignature as CLCredentialSignature, RevocationRegistry, @@ -187,3 +186,28 @@ pub struct CredentialProofDetails { pub rev_reg_index: Option, pub timestamp: Option, } + +const BASE_HEADER: char = 'u'; + +pub trait EncodedObject { + fn encode(&self) -> String + where + Self: Serialize, + { + let serialized = crate::utils::base64::encode_json(self); + format!("{}{}", BASE_HEADER, serialized) + } + + fn decode(string: &str) -> Result + where + Self: DeserializeOwned, + { + match string.chars().next() { + Some(BASE_HEADER) => { + // ok + } + value => return Err(err_msg!("Unexpected multibase base header {:?}", value)), + } + crate::utils::base64::decode_json(&string[1..]) + } +} diff --git a/src/utils/encoded_object.rs b/src/utils/encoded_object.rs deleted file mode 100644 index 26b5ea9f..00000000 --- a/src/utils/encoded_object.rs +++ /dev/null @@ -1,20 +0,0 @@ -use crate::utils::base64; -use crate::Result; -use serde::de::DeserializeOwned; -use serde::Serialize; - -pub trait EncodedObject { - fn encode(&self) -> String - where - Self: Serialize, - { - base64::encode_json(self) - } - - fn decode(string: &str) -> Result - where - Self: DeserializeOwned, - { - base64::decode_json(string) - } -} diff --git a/src/utils/mod.rs b/src/utils/mod.rs index f64bcf45..9264538e 100644 --- a/src/utils/mod.rs +++ b/src/utils/mod.rs @@ -6,9 +6,6 @@ pub mod base58; #[cfg(feature = "w3c")] pub mod base64; -#[cfg(feature = "w3c")] -pub mod encoded_object; - pub mod hash; pub mod query; From 7c4d90f829ed2b910571e568e4ca11394ce72e03 Mon Sep 17 00:00:00 2001 From: "artem.ivanov" Date: Thu, 21 Dec 2023 10:20:44 +0300 Subject: [PATCH 12/14] Fixed merge errors Signed-off-by: artem.ivanov --- src/data_types/w3c/proof.rs | 5 +++-- src/services/w3c/credential_conversion.rs | 4 ++-- src/services/w3c/prover.rs | 6 +++--- src/utils/base64.rs | 4 ++-- 4 files changed, 10 insertions(+), 9 deletions(-) diff --git a/src/data_types/w3c/proof.rs b/src/data_types/w3c/proof.rs index bb3e977b..14bd0df4 100644 --- a/src/data_types/w3c/proof.rs +++ b/src/data_types/w3c/proof.rs @@ -195,13 +195,13 @@ pub struct CredentialProofDetails { const BASE_HEADER: char = 'u'; pub trait EncodedObject { - fn encode(&self) -> String + fn encode(&self) -> Result where Self: Serialize, { let bytes = msg_pack::encode(self)?; let base64_encoded = base64::encode(bytes); - format!("{}{}", BASE_HEADER, base64_encoded) + Ok(format!("{}{}", BASE_HEADER, base64_encoded)) } fn decode(string: &str) -> Result @@ -239,6 +239,7 @@ mod tests { value: 1, }; let encoded = obj.encode().unwrap(); + assert_eq!("ugqV0eXBlX6RUZXN0pXZhbHVlAQ", encoded); let decoded = TestObject::decode(&encoded).unwrap(); assert_eq!(obj, decoded) } diff --git a/src/services/w3c/credential_conversion.rs b/src/services/w3c/credential_conversion.rs index 9890fe18..fb698a43 100644 --- a/src/services/w3c/credential_conversion.rs +++ b/src/services/w3c/credential_conversion.rs @@ -110,7 +110,7 @@ pub fn credential_to_w3c( rev_reg: credential.rev_reg, witness: credential.witness, }; - let proof = DataIntegrityProof::new_credential_proof(signature); + let proof = DataIntegrityProof::new_credential_proof(signature)?; let w3c_credential = W3CCredential::new(issuer, attributes, proof, version.as_ref()); trace!("credential_to_w3c <<< w3c_credential {:?}", w3c_credential); @@ -347,7 +347,7 @@ pub(super) mod tests { W3CCredential::new( issuer_id(), CredentialAttributes::from(&cred_values()), - DataIntegrityProof::new_credential_proof(_signature_data()), + DataIntegrityProof::new_credential_proof(_signature_data()).unwrap(), None, ) } diff --git a/src/services/w3c/prover.rs b/src/services/w3c/prover.rs index 344fa072..812005ca 100644 --- a/src/services/w3c/prover.rs +++ b/src/services/w3c/prover.rs @@ -119,7 +119,7 @@ pub fn process_credential( credential_signature.witness.as_ref(), )?; - *proof = DataIntegrityProof::new_credential_proof(credential_signature); + *proof = DataIntegrityProof::new_credential_proof(credential_signature)?; trace!("process_w3c_credential <<< "); @@ -192,7 +192,7 @@ pub fn create_presentation( timestamp: present.timestamp, sub_proof, }; - let proof = DataIntegrityProof::new_credential_presentation_proof(proof); + let proof = DataIntegrityProof::new_credential_presentation_proof(proof)?; let credential = W3CCredential::derive(credential_attributes, proof, present.cred); verifiable_credentials.push(credential); } @@ -203,7 +203,7 @@ pub fn create_presentation( let proof = DataIntegrityProof::new_presentation_proof( presentation_proof, presentation_request.nonce.to_string(), - ); + )?; let presentation = W3CPresentation::new(verifiable_credentials, proof, version.as_ref()); trace!( diff --git a/src/utils/base64.rs b/src/utils/base64.rs index f3507352..457d3daf 100644 --- a/src/utils/base64.rs +++ b/src/utils/base64.rs @@ -3,11 +3,11 @@ use base64::{engine, Engine}; use crate::Error; pub fn encode>(val: T) -> String { - engine::general_purpose::URL_SAFE.encode(val) + engine::general_purpose::URL_SAFE_NO_PAD.encode(val) } pub fn decode>(val: T) -> Result, Error> { - engine::general_purpose::URL_SAFE + engine::general_purpose::URL_SAFE_NO_PAD .decode(val) .map_err(|_| err_msg!("invalid base64 string")) } From 1e0f32b04bdaf6c58b02303deaa5aa1e60040e7b Mon Sep 17 00:00:00 2001 From: "artem.ivanov" Date: Tue, 9 Jan 2024 09:42:50 +0300 Subject: [PATCH 13/14] Replaced unsafe unwrap Signed-off-by: artem.ivanov --- src/data_types/nonce.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/data_types/nonce.rs b/src/data_types/nonce.rs index 4570106b..c0070d0f 100644 --- a/src/data_types/nonce.rs +++ b/src/data_types/nonce.rs @@ -204,7 +204,11 @@ impl<'a> Deserialize<'a> for Nonce { let mut vec = Vec::new(); while let Ok(Some(Value::Number(elem))) = seq.next_element() { - vec.push(elem.as_u64().unwrap() as u8); + vec.push( + elem.as_u64() + .ok_or_else(|| E::Error::custom("invalid nonce"))? + as u8, + ); } Nonce::from_bytes(&vec).map_err(E::Error::custom) From 63e70851d90749197ce88002fbdf16e5fbc7ba1f Mon Sep 17 00:00:00 2001 From: "artem.ivanov" Date: Fri, 12 Jan 2024 08:30:28 +0300 Subject: [PATCH 14/14] Corrected expected value in broken test Signed-off-by: artem.ivanov --- src/data_types/w3c/proof.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/data_types/w3c/proof.rs b/src/data_types/w3c/proof.rs index e4a87cbe..d51f4bc9 100644 --- a/src/data_types/w3c/proof.rs +++ b/src/data_types/w3c/proof.rs @@ -236,9 +236,9 @@ pub trait EncodedObject { where Self: Serialize, { - let json = msg_pack::encode(self)?; - let serialized = base64::encode(json); - Ok(format!("{}{}", BASE_HEADER, serialized)) + let msg_pack_encoded = msg_pack::encode(self)?; + let base64_encoded = base64::encode(msg_pack_encoded); + Ok(format!("{}{}", BASE_HEADER, base64_encoded)) } fn decode(string: &str) -> Result @@ -359,7 +359,7 @@ pub(crate) mod tests { value: 1, }; let encoded = obj.encode().unwrap(); - assert_eq!("ueyJ0eXBlXyI6IlRlc3QiLCJ2YWx1ZSI6MX0", encoded); + assert_eq!("ugqV0eXBlX6RUZXN0pXZhbHVlAQ", encoded); let decoded = TestObject::decode(&encoded).unwrap(); assert_eq!(obj, decoded) }