safe_nd/identity/
client.rs

1// Copyright 2019 MaidSafe.net limited.
2//
3// This SAFE Network Software is licensed to you under the MIT license <LICENSE-MIT
4// https://opensource.org/licenses/MIT> or the Modified BSD license <LICENSE-BSD
5// https://opensource.org/licenses/BSD-3-Clause>, at your option. This file may not be copied,
6// modified, or distributed except according to those terms. Please review the Licences for the
7// specific language governing permissions and limitations relating to use of the SAFE Network
8// Software.
9
10use crate::keys::{BlsKeypair, SignatureShare};
11use crate::{utils, Error, Keypair, PublicKey, Signature};
12use ed25519_dalek::Keypair as Ed25519Keypair;
13use rand::{CryptoRng, Rng};
14use serde::{Deserialize, Deserializer, Serialize, Serializer};
15use signature::Signer;
16use std::fmt::{self, Debug, Display, Formatter};
17use threshold_crypto::{
18    serde_impl::SerdeSecret,
19    SecretKey as BlsSecretKey, //SecretKeyShare as BlsSecretKeyShare,
20};
21use xor_name::XorName;
22
23/// A struct holding a keypair variant and the corresponding public ID for a network Client.
24#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
25pub struct FullId {
26    keypair: Keypair,
27    public_id: PublicId,
28}
29
30impl FullId {
31    /// Constructs a `FullId` with a random Ed25519 keypair.
32    pub fn new_ed25519<T: CryptoRng + Rng>(rng: &mut T) -> Self {
33        let keypair = Keypair::new_ed25519(rng);
34        let public_key = keypair.public_key();
35        let public_id = PublicId {
36            name: public_key.into(),
37            public_key,
38        };
39        Self { keypair, public_id }
40    }
41
42    /// Constructs a `FullId` with a random BLS keypair.
43    pub fn new_bls<T: CryptoRng + Rng>(rng: &mut T) -> Self {
44        let keypair = Keypair::new_bls(rng);
45        let public_key = keypair.public_key();
46        let public_id = PublicId {
47            name: public_key.into(),
48            public_key,
49        };
50        Self { keypair, public_id }
51    }
52
53    // /// Constructs a `FullId` from a BLS secret key share.
54    // pub fn new_bls_share(bls_secret_key_share: BlsSecretKeyShare) -> Self {
55    //     let keypair = Keypair::new_bls_share(bls_secret_key_share);
56    //     let public_key = keypair.public_key();
57    //     let public_id = PublicId {
58    //         name: public_key.into(),
59    //         public_key,
60    //     };
61    //     Self { keypair, public_id }
62    // }
63
64    /// Creates a detached signature of `data`.
65    pub fn sign<T: AsRef<[u8]>>(&self, data: T) -> Signature {
66        match &self.keypair {
67            Keypair::Ed25519(keys) => Signature::Ed25519(keys.sign(data.as_ref())),
68            Keypair::Bls(keys) => Signature::Bls(keys.secret.inner().sign(data)),
69            Keypair::BlsShare(keys) => Signature::BlsShare(SignatureShare {
70                index: keys.index,
71                share: keys.secret.inner().sign(data),
72            }),
73        }
74    }
75
76    /// Returns the public ID.
77    pub fn public_id(&self) -> &PublicId {
78        &self.public_id
79    }
80
81    /// Returns the PublicKey of the PublicId.
82    pub fn public_key(&self) -> &PublicKey {
83        &self.public_id.public_key()
84    }
85
86    /// Returns a reference to the Keypair
87    pub fn keypair(&self) -> &Keypair {
88        &self.keypair
89    }
90}
91
92impl From<BlsSecretKey> for FullId {
93    fn from(bls_sk: BlsSecretKey) -> Self {
94        let public = bls_sk.public_key();
95        let keypair = Keypair::Bls(BlsKeypair {
96            secret: SerdeSecret(bls_sk),
97            public,
98        });
99        let public_key = keypair.public_key();
100        let public_id = PublicId {
101            name: public_key.into(),
102            public_key,
103        };
104        Self { keypair, public_id }
105    }
106}
107
108impl From<Ed25519Keypair> for FullId {
109    fn from(ed25519_keypair: Ed25519Keypair) -> Self {
110        let keypair = Keypair::Ed25519(ed25519_keypair);
111        let public_key = keypair.public_key();
112        let public_id = PublicId {
113            name: public_key.into(),
114            public_key,
115        };
116        Self { keypair, public_id }
117    }
118}
119
120// // This is required so we can have `impl Into<FullId>` as a function parameter
121// impl From<BlsSecretKeyShare> for FullId {
122//     fn from(bls_secret_key_share: BlsSecretKeyShare) -> Self {
123//         Self::new_bls_share(bls_secret_key_share)
124//     }
125// }
126
127/// A struct representing the public identity of a network Client.
128///
129/// It includes the public signing key, and this provides the Client's network address, i.e.
130/// `name()`.
131#[derive(Clone, Eq, PartialEq, PartialOrd, Ord, Hash)]
132pub struct PublicId {
133    name: XorName,
134    public_key: PublicKey,
135}
136
137impl PublicId {
138    /// Returns the Client's network address.
139    pub fn name(&self) -> &XorName {
140        &self.name
141    }
142
143    /// Returns the Client's public signing key.
144    pub fn public_key(&self) -> &PublicKey {
145        &self.public_key
146    }
147
148    /// Returns the PublicId serialised and encoded in z-base-32.
149    pub fn encode_to_zbase32(&self) -> String {
150        utils::encode(&self)
151    }
152
153    /// Creates from z-base-32 encoded string.
154    pub fn decode_from_zbase32<T: AsRef<str>>(encoded: T) -> Result<Self, Error> {
155        utils::decode(encoded)
156    }
157}
158
159impl Serialize for PublicId {
160    fn serialize<S: Serializer>(&self, serialiser: S) -> Result<S::Ok, S::Error> {
161        (&self.public_key).serialize(serialiser)
162    }
163}
164
165impl<'de> Deserialize<'de> for PublicId {
166    fn deserialize<D: Deserializer<'de>>(deserialiser: D) -> Result<Self, D::Error> {
167        let public_key: PublicKey = Deserialize::deserialize(deserialiser)?;
168        let name = public_key.into();
169        Ok(PublicId { name, public_key })
170    }
171}
172
173impl Debug for PublicId {
174    fn fmt(&self, formatter: &mut Formatter) -> fmt::Result {
175        write!(formatter, "Client({:?})", self.public_key)
176    }
177}
178
179impl Display for PublicId {
180    fn fmt(&self, formatter: &mut Formatter) -> fmt::Result {
181        Debug::fmt(self, formatter)
182    }
183}
safe_nd/identity/client.rs

safe_nd/identity/
client.rs
