soroban-auth 0.0.4

Soroban authorization sdk
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

#![no_std]

use soroban_sdk::{serde::Serialize, Account, BigInt, BytesN, Env, RawVal, Symbol, Vec};

mod public_types;
pub use crate::public_types::{
    AccountSignatures, Ed25519Signature, Identifier, Signature, SignaturePayload,
    SignaturePayloadV0,
};

/// Users of this module will need to pass a struct to check_auth that
/// implements NonceAuth. NonceAuth should manage nonces in the contracts
/// storage, and wrap the Signature being verified.
///
/// ### Examples
/// ```
/// use soroban_sdk::{BigInt, Env, contracttype};
/// use soroban_auth::{check_auth, Identifier, Signature, NonceAuth};
///
/// #[contracttype]
/// pub enum DataKey {
///     Acc(Identifier),
///     Nonce(Identifier)
/// }
/// struct WrappedAuth(Signature);
///
/// impl NonceAuth for WrappedAuth {
///     fn read_nonce(e: &Env, id: Identifier) -> BigInt {
///        let key = DataKey::Nonce(id);
///        if let Some(nonce) = e.contract_data().get(key) {
///             nonce.unwrap()
///        } else {
///             BigInt::zero(e)
///        }
///     }
///    
///     fn read_and_increment_nonce(&self, e: &Env, id: Identifier) -> BigInt {
///         let key = DataKey::Nonce(id.clone());
///         let nonce = Self::read_nonce(e, id);
///         e.contract_data()
///             .set(key, nonce.clone() + BigInt::from_u32(e, 1));
///         nonce
///     }
///    
///     fn signature(&self) -> &Signature {
///         &self.0
///     }
/// }
/// ```
pub trait NonceAuth {
    /// Return the nonce stored in the contract.
    fn read_nonce(e: &Env, id: Identifier) -> BigInt;
    /// Return the nonce stored in the contract, and then increment it.
    fn read_and_increment_nonce(&self, e: &Env, id: Identifier) -> BigInt;
    /// Return the Signature used for authorization.
    fn signature(&self) -> &Signature;
}

fn check_ed25519_auth(env: &Env, auth: &Ed25519Signature, function: Symbol, args: Vec<RawVal>) {
    let msg = SignaturePayloadV0 {
        function,
        contract: env.get_current_contract(),
        network: env.ledger().network_passphrase(),
        args,
    };
    let msg_bin = SignaturePayload::V0(msg).serialize(env);

    env.verify_sig_ed25519(
        auth.public_key.clone().into(),
        msg_bin,
        auth.signature.clone().into(),
    );
}

fn check_account_auth(env: &Env, auth: &AccountSignatures, function: Symbol, args: Vec<RawVal>) {
    let acc = Account::from_public_key(&auth.account_id).unwrap();

    let msg = SignaturePayloadV0 {
        function,
        contract: env.get_current_contract(),
        network: env.ledger().network_passphrase(),
        args,
    };
    let msg_bytes = SignaturePayload::V0(msg).serialize(env);

    let threshold = acc.medium_threshold();
    let mut weight = 0u32;

    let sigs = &auth.signatures;
    let mut prev_pk: Option<BytesN<32>> = None;
    for sig in sigs.iter().map(Result::unwrap) {
        // Cannot take multiple signatures from the same key
        if let Some(prev) = prev_pk {
            if prev == sig.public_key {
                panic!("signature duplicate")
            }
            if prev > sig.public_key {
                panic!("signature out of order")
            }
        }

        env.verify_sig_ed25519(
            sig.public_key.clone().into(),
            msg_bytes.clone(),
            sig.signature.into(),
        );

        weight = weight
            .checked_add(acc.signer_weight(&sig.public_key))
            .expect("weight overflow");

        prev_pk = Some(sig.public_key);
    }

    if weight < threshold {
        panic!("insufficient signing weight")
    }
}

/// Checks a Signature that should be wrapped in a struct that implements NonceAuth.
/// Note that the nonce is expected to be 0 if the signature is of type Signature::Contract.
pub fn check_auth<T>(env: &Env, auth: &T, nonce: BigInt, function: Symbol, args: Vec<RawVal>)
where
    T: NonceAuth,
{
    match auth.signature() {
        Signature::Contract => {
            if nonce != BigInt::from_i32(env, 0) {
                panic!("nonce should be zero for Contract")
            }
            env.get_invoking_contract();
        }
        Signature::Ed25519(kea) => {
            let stored_nonce =
                auth.read_and_increment_nonce(env, Identifier::Ed25519(kea.public_key.clone()));
            if nonce != stored_nonce {
                panic!("incorrect nonce")
            }
            check_ed25519_auth(env, &kea, function, args)
        }
        Signature::Account(kaa) => {
            let stored_nonce =
                auth.read_and_increment_nonce(env, Identifier::Account(kaa.account_id.clone()));
            if nonce != stored_nonce {
                panic!("incorrect nonce")
            }
            check_account_auth(env, &kaa, function, args)
        }
    }
}