rebase 0.1.6

Rebase is a library for witnessing cryptographic attestations and issuing verifiable credentials
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

use crate::types::{
    defs::{resolve_key, DIDKey, DIDWeb, Subject, JWK},
    error::SubjectError,
};
use async_trait::async_trait;
use ed25519_dalek::{ed25519::signature::Signature, PublicKey, Verifier};
use hex;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use ssi::jwk::Params;
use tsify::Tsify;
use wasm_bindgen::prelude::*;

#[derive(Clone, Debug, Deserialize, JsonSchema, Serialize, Tsify)]
#[tsify(into_wasm_abi, from_wasm_abi)]
pub struct Ed25519Jwk {
    pub did: String,
    pub key_name: String,
}

impl Ed25519Jwk {
    pub fn new(did: &str, key_name: &str) -> Result<Self, SubjectError> {
        Ok(Ed25519Jwk {
            did: did.to_owned(),
            key_name: key_name.to_owned(),
        })
    }

    pub async fn jwk(&self) -> Result<JWK, SubjectError> {
        if !self.did.starts_with("did:web:") && !self.did.starts_with("did:key:") {
            return Err(SubjectError::Did(format!(
                "Currently only supports ed25519 keys as did:web or did:key, got: {}",
                self.did
            )));
        }

        let full_did = format!("{}#{}", self.did, self.key_name);
        if self.did.starts_with("did:key:") {
            let resolver = DIDKey {};
            resolve_key(&full_did, &resolver).await.map_err(|e| {
                SubjectError::Validation(format!("Could not build JWK from DID: {}", e))
            })
        } else if self.did.starts_with("did:web:") {
            let resolver = DIDWeb {};
            resolve_key(&full_did, &resolver).await.map_err(|e| {
                SubjectError::Validation(format!("Could not build JWK from DID: {}", e))
            })
        } else {
            Err(SubjectError::Validation(format!(
                "Delegate DID must be of did:web or did:key, got {}",
                self.did
            )))
        }
    }
}

#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
impl Subject for Ed25519Jwk {
    fn did(&self) -> Result<String, SubjectError> {
        Ok(self.did.clone())
    }

    fn display_id(&self) -> Result<String, SubjectError> {
        let s = self.did.trim_start_matches("did:web:");
        Ok(s.to_owned())
    }

    fn verification_method(&self) -> Result<String, SubjectError> {
        Ok(format!("{}#{}", &self.did, &self.key_name))
    }

    async fn valid_signature(&self, statement: &str, signature: &str) -> Result<(), SubjectError> {
        let jwk = self.jwk().await?;
        let pk = match &jwk.params {
            Params::OKP(o) => Ok(PublicKey::from_bytes(&o.public_key.0).map_err(|e| {
                SubjectError::Validation(format!("could not generate public key: {}", e))
            })?),
            _ => Err(SubjectError::Validation(
                "could not recover public key from jwk".to_string(),
            )),
        }?;

        let statement = statement.as_bytes();
        let signature = Signature::from_bytes(
            &hex::decode(signature).map_err(|e| SubjectError::Validation(e.to_string()))?,
        )
        .map_err(|e| SubjectError::Validation(e.to_string()))?;

        pk.verify(statement, &signature)
            .map_err(|e| SubjectError::Validation(e.to_string()))
    }
}

#[derive(Deserialize, Serialize)]
pub struct Res {
    #[serde(rename = "@context")]
    // pub context: Vec<Context>,
    pub context: String,
    pub id: String,
    #[serde(rename = "verificationMethod")]
    pub verification_method: Vec<VerificationMethod>,
    pub authentication: Vec<String>,
    #[serde(rename = "assertionMethod")]
    pub assertion_method: Vec<String>,
}

#[derive(Deserialize, Serialize)]
pub struct VerificationMethod {
    pub id: String,
    #[serde(rename = "type")]
    pub _type: String,
    pub controller: String,
    #[serde(rename = "publicKeyJwk")]
    pub key: VerificationPubKey,
}

#[derive(Deserialize, Serialize)]
pub struct VerificationPubKey {
    pub kty: String,
    pub crv: String,
    pub x: String,
}

#[derive(Deserialize, Serialize)]
pub struct ContextKey {
    #[serde(rename = "Ed25519VerificationKey2018")]
    pub verification_key: String,
    #[serde(rename = "publicKeyJwk")]
    pub public_key: ContextPubKey,
}

#[derive(Deserialize, Serialize)]
pub struct ContextPubKey {
    #[serde(rename = "@id")]
    pub id: String,
    #[serde(rename = "@type")]
    pub _type: String,
}

#[derive(Deserialize, Serialize)]
#[serde(untagged)]
pub enum Context {
    String(String),
    Struct(ContextKey),
}

// NOTE: Tests for this file can be found in issuer/ed25519
// There the function test_did_kepair from test_util is tested as
// both issuer and subject.