diff --git a/identity/src/signature.rs b/identity/src/signature.rs index a65355c..7ee125c 100644 --- a/identity/src/signature.rs +++ b/identity/src/signature.rs @@ -17,6 +17,13 @@ use serde::{Deserialize, Serialize}; use signature::Error as SigError; use signature::Signature as SigSignature; +use thiserror::Error as ThisError; + +#[derive(ThisError, Debug)] +pub enum SignatureError { + #[error("{0}")] + Error(#[from] SigError), +} #[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] pub struct Signature(pub ed25519_dalek::Signature); @@ -34,7 +41,7 @@ impl Signature { self.0.to_bytes() } - pub fn from_bytes(bytes: &[u8]) -> Result { + pub fn from_bytes(bytes: &[u8]) -> Result { let sig = ed25519_dalek::Signature::from_bytes(bytes)?; Ok(Signature(sig)) } diff --git a/src/trust.rs b/src/trust.rs index 4567676..b2db75b 100644 --- a/src/trust.rs +++ b/src/trust.rs @@ -15,13 +15,12 @@ */ use crate::trust::TrustError::{ - Base58DecodeError, DecodePublicKeyError, IncorrectTrustLength, ParseError, PublicKeyError, - SignatureError, SignatureFromBytesError, + Base58DecodeError, DecodePublicKeyError, IncorrectTrustLength, ParseError, SignatureError, }; use derivative::Derivative; use fluence_identity::key_pair::KeyPair; use fluence_identity::public_key::{PKError, PublicKey}; -use fluence_identity::signature::Signature; +use fluence_identity::signature::{Signature, SignatureError as SigError}; use serde::{Deserialize, Serialize}; use std::convert::TryInto; use std::num::ParseIntError; @@ -69,7 +68,7 @@ pub enum TrustError { /// Errors occured on signature verification #[error("{0}")] - SignatureError(ed25519_dalek::SignatureError), + SignatureError(#[from] ed25519_dalek::SignatureError), /// Errors occured on trust decoding from differrent formats #[error("Cannot decode the public key: {0} in the trust: {1}")] @@ -82,10 +81,10 @@ pub enum TrustError { Base58DecodeError(String, String, bs58::decode::Error), #[error("Cannot decode a signature from bytes: {0}")] - SignatureFromBytesError(signature::Error), + SignatureFromBytesError(#[from] SigError), #[error("{0}")] - PublicKeyError(PKError), + PublicKeyError(#[from] PKError), #[error( "Trust length should be 104: public key(32) + signature(64) + expiration date(8), was: {0}" @@ -179,10 +178,10 @@ impl Trust { return Err(IncorrectTrustLength(arr.len())); } - let pk = PublicKey::from_bytes(&arr[0..PK_LEN]).map_err(PublicKeyError)?; + let pk = PublicKey::from_bytes(&arr[0..PK_LEN])?; let signature = &arr[PK_LEN..PK_LEN + SIG_LEN]; - let signature = Signature::from_bytes(signature).map_err(SignatureFromBytesError)?; + let signature = Signature::from_bytes(signature)?; let expiration_bytes = &arr[PK_LEN + SIG_LEN..PK_LEN + SIG_LEN + EXPIRATION_LEN]; let expiration_date = u64::from_le_bytes(expiration_bytes.try_into().unwrap()); @@ -226,7 +225,7 @@ impl Trust { // 64 bytes signature let signature = Self::bs58_str_to_vec(signature, "signature")?; - let signature = Signature::from_bytes(&signature).map_err(SignatureFromBytesError)?; + let signature = Signature::from_bytes(&signature)?; // Duration let expires_at = Self::str_to_duration(expires_at, "expires_at")?; diff --git a/wasm/src/dto.rs b/wasm/src/dto.rs index 60302a3..f1628c4 100644 --- a/wasm/src/dto.rs +++ b/wasm/src/dto.rs @@ -1,4 +1,20 @@ use fluence::fce; +use fluence_identity::public_key::PKError; +use fluence_identity::signature::SignatureError; +use fluence_identity::{PublicKey, Signature}; +use std::convert::TryFrom; +use std::time::Duration; +use thiserror::Error as ThisError; + +#[derive(ThisError, Debug)] +pub enum DtoConversionError { + #[error("Cannot convert base58 string to bytes: {0}")] + Base58Error(#[from] bs58::decode::Error), + #[error("Cannot convert string to PublicKey: {0}")] + PublicKeyDecodeError(#[from] PKError), + #[error("Cannot convert string to PublicKey: {0}")] + SignatureDecodeError(#[from] SignatureError), +} #[fce] pub struct Certificate { @@ -12,6 +28,20 @@ impl From for Certificate { } } +impl TryFrom for trust_graph::Certificate { + type Error = DtoConversionError; + + fn try_from(c: Certificate) -> Result { + let chain: Result, DtoConversionError> = c + .chain + .into_iter() + .map(|t| trust_graph::Trust::try_from(t)) + .collect(); + let chain = chain?; + return Ok(trust_graph::Certificate { chain }); + } +} + #[fce] pub struct Trust { /// For whom this certificate is issued, base58 @@ -25,6 +55,24 @@ pub struct Trust { pub issued_at: u64, } +impl TryFrom for trust_graph::Trust { + type Error = DtoConversionError; + + fn try_from(t: Trust) -> Result { + let issued_for = PublicKey::from_base58(&t.issued_for)?; + let signature = bs58::decode(&t.signature).into_vec()?; + let signature = Signature::from_bytes(&signature)?; + let expires_at = Duration::from_secs(t.expires_at); + let issued_at = Duration::from_secs(t.issued_at); + return Ok(trust_graph::Trust { + issued_for, + expires_at, + signature, + issued_at, + }); + } +} + impl From for Trust { fn from(t: trust_graph::Trust) -> Self { let issued_for = bs58::encode(t.issued_for.to_bytes()).into_string(); diff --git a/wasm/src/service_api.rs b/wasm/src/service_api.rs index a05f775..f48bf58 100644 --- a/wasm/src/service_api.rs +++ b/wasm/src/service_api.rs @@ -14,7 +14,6 @@ use trust_graph::{CertificateError, TrustGraphError}; pub enum ServiceError { #[error("{0}")] PublicKeyDecodeError(#[from] PKError), - #[error("{0}")] TGError(#[from] TrustGraphError), #[error("{0}")] @@ -31,9 +30,11 @@ fn insert_cert_impl(certificate: String, duration: u64) -> Result<(), ServiceErr } #[fce] -// TODO: some sort of auth? -fn insert_cert(certificate: String, duration: u64) -> InsertResult { - insert_cert_impl(certificate, duration).into() +/// add a certificate in string representation to trust graph if it is valid +/// see `Certificate` class for string encoding/decoding +// TODO change `current_time` to time service +fn insert_cert(certificate: String, current_time: u64) -> InsertResult { + insert_cert_impl(certificate, current_time).into() } fn get_weight_impl(public_key: String) -> Result, ServiceError> {