Skip to content

Commit

Permalink
Bind VC create to Kotlin
Browse files Browse the repository at this point in the history
  • Loading branch information
KendallWeihe committed Aug 15, 2024
1 parent 99fb78e commit 12a136a
Show file tree
Hide file tree
Showing 25 changed files with 517 additions and 297 deletions.
4 changes: 3 additions & 1 deletion Justfile
Original file line number Diff line number Diff line change
Expand Up @@ -4,7 +4,9 @@ set shell := ["bash", "-uc"]
setup:
#!/bin/bash
source bin/activate-hermit
git submodule update --init --recursive
if [ ! -d ".git/modules/web5-spec" ]; then
git submodule update --init --recursive
fi
if [[ "$(cargo 2>&1)" == *"rustup could not choose a version of cargo to run"* ]]; then
rustup default 1.80.0
rustup target add aarch64-apple-darwin
Expand Down
7 changes: 3 additions & 4 deletions bindings/web5_uniffi/src/lib.rs
Original file line number Diff line number Diff line change
@@ -1,9 +1,7 @@
use web5_uniffi_wrapper::{
credentials::{
presentation_definition::PresentationDefinition,
verifiable_credential_1_1::{
data::VerifiableCredential as VerifiableCredentialData, VerifiableCredential,
},
verifiable_credential_1_1::{VerifiableCredential, VerifiableCredentialData},
},
crypto::{
dsa::{
Expand All @@ -25,10 +23,11 @@ use web5_uniffi_wrapper::{
portable_did::PortableDid,
resolution::resolution_result::ResolutionResult,
},
errors::RustCoreError,
errors::{RustCoreError, Web5Error},
};

use web5::{
credentials::verifiable_credential_1_1::VerifiableCredentialCreateOptions as VerifiableCredentialCreateOptionsData,
crypto::{dsa::Dsa, jwk::Jwk as JwkData},
dids::{
data_model::{
Expand Down
62 changes: 37 additions & 25 deletions bindings/web5_uniffi/src/web5.udl
Original file line number Diff line number Diff line change
Expand Up @@ -223,36 +223,48 @@ interface BearerDid {
Signer get_signer(string key_id);
};

dictionary VerifiableCredentialData {
sequence<string> context;
string id;
sequence<string> type;
string json_serialized_issuer;
timestamp issuance_date;
timestamp? expiration_date;
string json_serialized_credential_subject;
};

interface VerifiableCredential {
[Throws=RustCoreError]
constructor(VerifiableCredentialData data);
[Name=verify, Throws=RustCoreError]
constructor([ByRef] string vcjwt);
[Name=verify_with_verifier, Throws=RustCoreError]
constructor([ByRef] string vcjwt, Verifier verifier);
[Throws=RustCoreError]
string sign(BearerDid bearer_did);
[Throws=RustCoreError]
string sign_with_signer([ByRef] string key_id, Signer signer);
[Throws=RustCoreError]
VerifiableCredentialData get_data();
};

interface PresentationDefinition {
[Throws=RustCoreError]
constructor(string json_serialized_presentation_definition);
[Throws=RustCoreError]
string get_json_serialized_presentation_definition();
[Throws=RustCoreError]
sequence<string> select_credentials([ByRef] sequence<string> vc_jwts);
};





[Error]
interface Web5Error {
Error(string type, string variant, string msg);
};

dictionary VerifiableCredentialCreateOptionsData {
string? id;
sequence<string>? context;
sequence<string>? type;
timestamp? issuance_date;
timestamp? expiration_date;
};

interface VerifiableCredential {
[Throws=Web5Error, Name=create]
constructor(
string json_serialized_issuer,
string json_serialized_credential_subject,
VerifiableCredentialCreateOptionsData? options
);
VerifiableCredentialData get_data();
};

dictionary VerifiableCredentialData {
sequence<string> context;
sequence<string> type;
string id;
string json_serialized_issuer;
string json_serialized_credential_subject;
timestamp issuance_date;
timestamp? expiration_date;
};
Original file line number Diff line number Diff line change
@@ -1,22 +1,22 @@
use crate::errors::Result;
use crate::errors::ResultOld;
use web5::credentials::presentation_definition::PresentationDefinition as InnerPresentationDefinition;

pub struct PresentationDefinition(pub InnerPresentationDefinition);

impl PresentationDefinition {
pub fn new(json_serialized_presentation_definition: String) -> Result<Self> {
pub fn new(json_serialized_presentation_definition: String) -> ResultOld<Self> {
let inner_presentation_definition = serde_json::from_str::<InnerPresentationDefinition>(
&json_serialized_presentation_definition,
)?;

Ok(Self(inner_presentation_definition))
}

pub fn select_credentials(&self, vc_jwts: &Vec<String>) -> Result<Vec<String>> {
pub fn select_credentials(&self, vc_jwts: &Vec<String>) -> ResultOld<Vec<String>> {
Ok(self.0.select_credentials(vc_jwts)?)
}

pub fn get_json_serialized_presentation_definition(&self) -> Result<String> {
pub fn get_json_serialized_presentation_definition(&self) -> ResultOld<String> {
let json_serialized_presentation_definition = serde_json::to_string(&self.0)?;

Ok(json_serialized_presentation_definition)
Expand Down
Original file line number Diff line number Diff line change
@@ -1,103 +1,58 @@
use crate::{
crypto::dsa::{Signer, ToInnerSigner, ToInnerVerifier, Verifier},
dids::bearer_did::BearerDid,
errors::{Result, RustCoreError},
use crate::errors::Result;
use std::time::SystemTime;
use web5::{
credentials::verifiable_credential_1_1::{
CredentialSubject, Issuer, VerifiableCredential as InnerVerifiableCredential,
VerifiableCredentialCreateOptions,
},
json::FromJson,
};
use std::sync::{Arc, RwLock};
use web5::credentials::verifiable_credential_1_1::VerifiableCredential as InnerVerifiableCredential;

pub struct VerifiableCredential(pub Arc<RwLock<InnerVerifiableCredential>>);
pub struct VerifiableCredential {
inner_vc: InnerVerifiableCredential,
json_serialized_issuer: String,
json_serialized_credential_subject: String,
}

impl VerifiableCredential {
pub fn new(verifiable_credential: data::VerifiableCredential) -> Result<Self> {
let inner_verifiable_credential = verifiable_credential.to_inner()?;

Ok(Self(Arc::new(RwLock::new(inner_verifiable_credential))))
}

pub fn verify(vcjwt: &str) -> Result<Self> {
let inner_verifiable_credential = InnerVerifiableCredential::verify(vcjwt)?;

Ok(Self(Arc::new(RwLock::new(inner_verifiable_credential))))
}

pub fn verify_with_verifier(vcjwt: &str, verifier: Arc<dyn Verifier>) -> Result<Self> {
let inner_verifier = Arc::new(ToInnerVerifier(verifier));
let inner_verifiable_credential =
InnerVerifiableCredential::verify_with_verifier(vcjwt, inner_verifier)?;

Ok(Self(Arc::new(RwLock::new(inner_verifiable_credential))))
}

pub fn sign(&self, bearer_did: Arc<BearerDid>) -> Result<String> {
let inner_verifiable_credential = self
.0
.read()
.map_err(|e| RustCoreError::from_poison_error(e, "RwLockReadError"))?;

Ok(inner_verifiable_credential.sign(&bearer_did.0)?)
}

pub fn sign_with_signer(&self, key_id: &str, signer: Arc<dyn Signer>) -> Result<String> {
let inner_verifiable_credential = self
.0
.read()
.map_err(|e| RustCoreError::from_poison_error(e, "RwLockReadError"))?;

let inner_signer = Arc::new(ToInnerSigner(signer));
Ok(inner_verifiable_credential.sign_with_signer(key_id, inner_signer)?)
}

pub fn get_data(&self) -> Result<data::VerifiableCredential> {
let inner_verifiable_credential = self
.0
.read()
.map_err(|e| RustCoreError::from_poison_error(e, "RwLockReadError"))?;

data::VerifiableCredential::from_inner(inner_verifiable_credential.clone())
pub fn create(
json_serialized_issuer: String,
json_serialized_credential_subject: String,
options: Option<VerifiableCredentialCreateOptions>,
) -> Result<Self> {
let issuer = Issuer::from_json_string(&json_serialized_issuer)?;
let credential_subject =
CredentialSubject::from_json_string(&json_serialized_credential_subject)?;

let inner_vc = InnerVerifiableCredential::create(issuer, credential_subject, options)?;

Ok(Self {
inner_vc,
json_serialized_issuer,
json_serialized_credential_subject,
})
}

pub fn get_data(&self) -> VerifiableCredentialData {
VerifiableCredentialData {
context: self.inner_vc.context.clone(),
id: self.inner_vc.id.clone(),
r#type: self.inner_vc.r#type.clone(),
json_serialized_issuer: self.json_serialized_issuer.clone(),
json_serialized_credential_subject: self.json_serialized_credential_subject.clone(),
issuance_date: self.inner_vc.issuance_date,
expiration_date: self.inner_vc.expiration_date,
}
}
}

pub mod data {
use super::*;
use std::time::SystemTime;

#[derive(Clone)]
pub struct VerifiableCredential {
pub context: Vec<String>,
pub id: String,
pub r#type: Vec<String>,
pub json_serialized_issuer: String, // JSON serialized
pub issuance_date: SystemTime,
pub expiration_date: Option<SystemTime>,
pub json_serialized_credential_subject: String, // JSON serialized
}

impl VerifiableCredential {
pub fn from_inner(inner_verifiable_credential: InnerVerifiableCredential) -> Result<Self> {
Ok(Self {
context: inner_verifiable_credential.context.clone(),
id: inner_verifiable_credential.id.clone(),
r#type: inner_verifiable_credential.r#type.clone(),
json_serialized_issuer: serde_json::to_string(&inner_verifiable_credential.issuer)?,
issuance_date: inner_verifiable_credential.issuance_date,
expiration_date: inner_verifiable_credential.expiration_date,
json_serialized_credential_subject: serde_json::to_string(
&inner_verifiable_credential.credential_subject,
)?,
})
}

pub fn to_inner(&self) -> Result<InnerVerifiableCredential> {
Ok(InnerVerifiableCredential {
context: self.context.clone(),
id: self.id.clone(),
r#type: self.r#type.clone(),
issuer: serde_json::from_str(&self.json_serialized_issuer)?,
issuance_date: self.issuance_date,
expiration_date: self.expiration_date,
credential_subject: serde_json::from_str(&self.json_serialized_credential_subject)?,
})
}
}
#[derive(Clone)]
pub struct VerifiableCredentialData {
pub context: Vec<String>,
pub id: String,
pub r#type: Vec<String>,
pub json_serialized_issuer: String,
pub json_serialized_credential_subject: String,
pub issuance_date: SystemTime,
pub expiration_date: Option<SystemTime>,
}
6 changes: 3 additions & 3 deletions bindings/web5_uniffi_wrapper/src/crypto/dsa/ed25519.rs
Original file line number Diff line number Diff line change
@@ -1,5 +1,5 @@
use super::{Signer, Verifier};
use crate::errors::Result;
use crate::errors::ResultOld;
use web5::crypto::{
dsa::{
ed25519::{
Expand All @@ -24,7 +24,7 @@ impl Ed25519Signer {
}

impl Signer for Ed25519Signer {
fn sign(&self, payload: Vec<u8>) -> Result<Vec<u8>> {
fn sign(&self, payload: Vec<u8>) -> ResultOld<Vec<u8>> {
Ok(self.0.sign(&payload)?)
}
}
Expand All @@ -38,7 +38,7 @@ impl Ed25519Verifier {
}

impl Verifier for Ed25519Verifier {
fn verify(&self, payload: Vec<u8>, signature: Vec<u8>) -> Result<bool> {
fn verify(&self, payload: Vec<u8>, signature: Vec<u8>) -> ResultOld<bool> {
Ok(self.0.verify(&payload, &signature)?)
}
}
8 changes: 4 additions & 4 deletions bindings/web5_uniffi_wrapper/src/crypto/dsa/mod.rs
Original file line number Diff line number Diff line change
@@ -1,17 +1,17 @@
pub mod ed25519;

use crate::errors::Result;
use crate::errors::ResultOld;
use std::sync::Arc;
use web5::crypto::dsa::{Signer as InnerSigner, Verifier as InnerVerifier};

pub trait Signer: Send + Sync {
fn sign(&self, payload: Vec<u8>) -> Result<Vec<u8>>;
fn sign(&self, payload: Vec<u8>) -> ResultOld<Vec<u8>>;
}

pub struct ToOuterSigner(pub Arc<dyn InnerSigner>);

impl Signer for ToOuterSigner {
fn sign(&self, payload: Vec<u8>) -> Result<Vec<u8>> {
fn sign(&self, payload: Vec<u8>) -> ResultOld<Vec<u8>> {
Ok(self.0.sign(&payload)?)
}
}
Expand All @@ -26,7 +26,7 @@ impl InnerSigner for ToInnerSigner {
}

pub trait Verifier: Send + Sync {
fn verify(&self, payload: Vec<u8>, signature: Vec<u8>) -> Result<bool>;
fn verify(&self, payload: Vec<u8>, signature: Vec<u8>) -> ResultOld<bool>;
}

pub struct ToInnerVerifier(pub Arc<dyn Verifier>);
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -2,7 +2,7 @@ use super::{
dsa::{Signer, ToOuterSigner},
key_manager::KeyManager,
};
use crate::errors::Result;
use crate::errors::ResultOld;
use std::sync::Arc;
use web5::crypto::{
jwk::Jwk,
Expand All @@ -20,7 +20,7 @@ impl InMemoryKeyManager {
Self(InnerInMemoryKeyManager::new())
}

pub fn import_private_jwk(&self, private_key: Jwk) -> Result<Jwk> {
pub fn import_private_jwk(&self, private_key: Jwk) -> ResultOld<Jwk> {
Ok(self.0.import_private_jwk(private_key)?)
}

Expand All @@ -30,7 +30,7 @@ impl InMemoryKeyManager {
}

impl KeyManager for InMemoryKeyManager {
fn get_signer(&self, public_jwk: Jwk) -> Result<Arc<dyn Signer>> {
fn get_signer(&self, public_jwk: Jwk) -> ResultOld<Arc<dyn Signer>> {
let signer = self.0.get_signer(public_jwk)?;
let outer_signer = ToOuterSigner(signer);
Ok(Arc::new(outer_signer))
Expand Down
6 changes: 3 additions & 3 deletions bindings/web5_uniffi_wrapper/src/crypto/key_manager.rs
Original file line number Diff line number Diff line change
@@ -1,16 +1,16 @@
use super::dsa::{Signer, ToInnerSigner, ToOuterSigner};
use crate::errors::Result;
use crate::errors::ResultOld;
use std::sync::Arc;
use web5::crypto::{jwk::Jwk, key_managers::key_manager::KeyManager as InnerKeyManager};

pub trait KeyManager: Send + Sync {
fn get_signer(&self, public_jwk: Jwk) -> Result<Arc<dyn Signer>>;
fn get_signer(&self, public_jwk: Jwk) -> ResultOld<Arc<dyn Signer>>;
}

pub struct ToOuterKeyManager(pub Arc<dyn InnerKeyManager>);

impl KeyManager for ToOuterKeyManager {
fn get_signer(&self, public_jwk: Jwk) -> Result<Arc<dyn Signer>> {
fn get_signer(&self, public_jwk: Jwk) -> ResultOld<Arc<dyn Signer>> {
let signer = self.0.get_signer(public_jwk)?;
let outer_signer = ToOuterSigner(signer);
Ok(Arc::new(outer_signer))
Expand Down
Loading

0 comments on commit 12a136a

Please sign in to comment.