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
use std::fmt::{self, Debug, Formatter};
use xor_name::XorName;
use rust_sodium::crypto::{box_, sign};
use rust_sodium::crypto::hash::sha256;
#[derive(Clone)]
pub struct FullId {
public_id: ::PublicId,
private_encrypt_key: box_::SecretKey,
private_sign_key: sign::SecretKey,
}
impl FullId {
pub fn new() -> FullId {
let encrypt_keys = box_::gen_keypair();
let sign_keys = sign::gen_keypair();
FullId {
public_id: ::PublicId::new(encrypt_keys.0, sign_keys.0),
private_encrypt_key: encrypt_keys.1,
private_sign_key: sign_keys.1,
}
}
pub fn with_keys(encrypt_keys: (box_::PublicKey,
box_::SecretKey),
sign_keys: (sign::PublicKey,
sign::SecretKey))
-> FullId {
FullId {
public_id: ::PublicId::new(encrypt_keys.0, sign_keys.0),
private_encrypt_key: encrypt_keys.1,
private_sign_key: sign_keys.1,
}
}
pub fn public_id(&self) -> &::PublicId {
&self.public_id
}
pub fn public_id_mut(&mut self) -> &mut ::PublicId {
&mut self.public_id
}
pub fn signing_private_key(&self) -> &sign::SecretKey {
&self.private_sign_key
}
pub fn encrypting_private_key(&self) -> &box_::SecretKey {
&self.private_encrypt_key
}
}
impl Default for FullId {
fn default() -> FullId {
FullId::new()
}
}
#[derive(Hash, PartialEq, Eq, PartialOrd, Ord, Copy, Clone, RustcEncodable, RustcDecodable)]
pub struct PublicId {
public_encrypt_key: box_::PublicKey,
public_sign_key: sign::PublicKey,
name: XorName,
}
impl Debug for PublicId {
fn fmt(&self, formatter: &mut Formatter) -> fmt::Result {
write!(formatter, "PublicId(name: {})", self.name)
}
}
impl PublicId {
pub fn name(&self) -> &XorName {
&self.name
}
pub fn set_name(&mut self, name: XorName) {
self.name = name;
}
pub fn encrypting_public_key(&self) -> &box_::PublicKey {
&self.public_encrypt_key
}
pub fn signing_public_key(&self) -> &sign::PublicKey {
&self.public_sign_key
}
fn new(public_encrypt_key: box_::PublicKey,
public_sign_key: sign::PublicKey)
-> PublicId {
PublicId {
public_encrypt_key: public_encrypt_key,
public_sign_key: public_sign_key,
name: XorName(sha256::hash(&public_sign_key[..]).0),
}
}
}