11#[ cfg( feature = "ed25519" ) ]
2- use ursa:: signatures:: { ed25519:: Ed25519Sha512 , SignatureScheme } ;
2+ use curve25519_dalek:: edwards:: CompressedEdwardsY ;
3+ #[ cfg( feature = "ed25519" ) ]
4+ use ed25519_dalek:: { ExpandedSecretKey , PublicKey , SecretKey , Signature } ;
5+ #[ cfg( feature = "ed25519" ) ]
6+ use rand:: { thread_rng, RngCore } ;
7+ #[ cfg( feature = "ed25519" ) ]
8+ use sha2:: digest:: Digest ;
9+
10+ #[ cfg( feature = "ed25519" ) ]
11+ use std:: convert:: TryFrom ;
312
413use zeroize:: Zeroize ;
514
@@ -35,20 +44,22 @@ impl PrivateKey {
3544 let alg = alg. unwrap_or_default ( ) ;
3645 match alg {
3746 KeyType :: ED25519 => {
38- let ( _pk, sk) = Ed25519Sha512
39- . keypair ( None )
40- . map_err ( |_| "Error creating signing key" ) ?;
41- Ok ( Self :: new ( sk, Some ( KeyType :: ED25519 ) ) )
47+ let mut sk = [ 0u8 ; 32 ] ;
48+ thread_rng ( ) . fill_bytes ( & mut sk[ ..] ) ;
49+ Self :: from_seed ( & sk[ ..] )
4250 }
4351 _ => Err ( "Unsupported key type" . into ( ) ) ,
4452 }
4553 }
4654
4755 #[ cfg( feature = "ed25519" ) ]
4856 pub fn from_seed ( seed : & [ u8 ] ) -> Result < Self , ConversionError > {
49- let ( _pk , sk ) = Ed25519Sha512 :: expand_keypair ( seed)
57+ let sk = SecretKey :: from_bytes ( seed)
5058 . map_err ( |err| format ! ( "Error creating signing key: {}" , err) ) ?;
51- Ok ( Self :: new ( sk, Some ( KeyType :: ED25519 ) ) )
59+ let mut esk = [ 0u8 ; 64 ] ;
60+ esk[ ..32 ] . copy_from_slice ( sk. as_bytes ( ) ) ;
61+ esk[ 32 ..] . copy_from_slice ( PublicKey :: from ( & sk) . as_bytes ( ) ) ;
62+ Ok ( Self :: new ( esk, Some ( KeyType :: ED25519 ) ) )
5263 }
5364
5465 pub fn public_key ( & self ) -> Result < VerKey , ConversionError > {
@@ -66,10 +77,11 @@ impl PrivateKey {
6677 pub fn key_exchange ( & self ) -> Result < Self , ConversionError > {
6778 match self . alg {
6879 KeyType :: ED25519 => {
69- let sk = ursa:: keys:: PrivateKey ( self . key_bytes ( ) ) ;
70- let x_sk = Ed25519Sha512 :: sign_key_to_key_exchange ( & sk)
71- . map_err ( |err| format ! ( "Error converting to x25519 key: {}" , err) ) ?;
72- Ok ( Self :: new ( & x_sk, Some ( KeyType :: X25519 ) ) )
80+ let mut hash = sha2:: Sha512 :: digest ( & self . key [ ..32 ] ) ;
81+ let x_sk =
82+ x25519_dalek:: StaticSecret :: from ( <[ u8 ; 32 ] >:: try_from ( & hash[ ..32 ] ) . unwrap ( ) ) ;
83+ hash. zeroize ( ) ;
84+ Ok ( Self :: new ( & x_sk. to_bytes ( ) , Some ( KeyType :: X25519 ) ) )
7385 }
7486 _ => Err ( "Unsupported key format for key exchange" . into ( ) ) ,
7587 }
@@ -79,10 +91,10 @@ impl PrivateKey {
7991 pub fn sign < M : AsRef < [ u8 ] > > ( & self , message : M ) -> Result < Vec < u8 > , ConversionError > {
8092 match self . alg {
8193 KeyType :: ED25519 => {
82- let sk = ursa :: keys :: PrivateKey ( self . key_bytes ( ) ) ;
83- Ok ( Ed25519Sha512
84- . sign ( message. as_ref ( ) , & sk )
85- . map_err ( |err| format ! ( "Error signing payload: {}" , err ) ) ? )
94+ let esk = ExpandedSecretKey :: from ( & SecretKey :: from_bytes ( & self . key [ .. 32 ] ) . unwrap ( ) ) ;
95+ let pk = PublicKey :: from_bytes ( & self . key [ 32 .. ] ) . unwrap ( ) ;
96+ let sig = esk . sign ( message. as_ref ( ) , & pk ) ;
97+ Ok ( sig . to_bytes ( ) . into ( ) )
8698 }
8799 _ => Err ( "Unsupported key format for signing" . into ( ) ) ,
88100 }
@@ -164,11 +176,15 @@ impl VerKey {
164176 pub fn key_exchange ( & self ) -> Result < Self , ConversionError > {
165177 match self . alg {
166178 KeyType :: ED25519 => {
167- let vk = ursa:: keys:: PublicKey ( self . key_bytes ( ) ) ;
168- let x_vk = Ed25519Sha512 :: ver_key_to_key_exchange ( & vk) . map_err ( |err| {
169- format ! ( "Error converting to x25519 key: {}" , err. to_string( ) )
170- } ) ?;
171- Ok ( Self :: new ( & x_vk, Some ( KeyType :: X25519 ) ) )
179+ let vky = CompressedEdwardsY :: from_slice ( & self . key [ ..] ) ;
180+ if let Some ( x_vk) = vky. decompress ( ) {
181+ Ok ( Self :: new (
182+ x_vk. to_montgomery ( ) . as_bytes ( ) . to_vec ( ) ,
183+ Some ( KeyType :: X25519 ) ,
184+ ) )
185+ } else {
186+ Err ( "Error converting to x25519 key" . into ( ) )
187+ }
172188 }
173189 _ => Err ( "Unsupported verkey type" . into ( ) ) ,
174190 }
@@ -182,10 +198,12 @@ impl VerKey {
182198 ) -> Result < bool , ConversionError > {
183199 match self . alg {
184200 KeyType :: ED25519 => {
185- let vk = ursa:: keys:: PublicKey ( self . key_bytes ( ) ) ;
186- Ok ( Ed25519Sha512
187- . verify ( message. as_ref ( ) , signature. as_ref ( ) , & vk)
188- . map_err ( |err| format ! ( "Error validating message signature: {}" , err) ) ?)
201+ let vk = PublicKey :: from_bytes ( & self . key [ ..] ) . unwrap ( ) ;
202+ if let Ok ( sig) = Signature :: try_from ( signature. as_ref ( ) ) {
203+ Ok ( vk. verify_strict ( message. as_ref ( ) , & sig) . is_ok ( ) )
204+ } else {
205+ Err ( "Error validating message signature" . into ( ) )
206+ }
189207 }
190208 _ => Err ( "Unsupported verkey type" . into ( ) ) ,
191209 }
@@ -258,13 +276,11 @@ impl EncodedVerKey {
258276 if key. chars ( ) . next ( ) == Some ( '~' ) {
259277 let mut vk_bytes = base58:: decode ( & key[ 1 ..] ) ?;
260278 if vk_bytes. len ( ) != 16 {
261- return Err ( ConversionError :: from_msg (
262- "Expected 16-byte abbreviated verkey" ,
263- ) ) ;
279+ return Err ( "Expected 16-byte abbreviated verkey" . into ( ) ) ;
264280 }
265281 let mut did_bytes = base58:: decode ( did) ?;
266282 if did_bytes. len ( ) != 16 {
267- return Err ( ConversionError :: from_msg ( "DID must be 16 bytes in length" ) ) ;
283+ return Err ( "DID must be 16 bytes in length" . into ( ) ) ;
268284 }
269285 did_bytes. append ( & mut vk_bytes) ;
270286 Ok ( Self :: new (
@@ -284,11 +300,11 @@ impl EncodedVerKey {
284300 pub fn abbreviated_for_did ( & self , did : & str ) -> Result < String , ConversionError > {
285301 let did_bytes = base58:: decode ( did) ?;
286302 if did_bytes. len ( ) != 16 {
287- return Err ( ConversionError :: from_msg ( "DID must be 16 bytes in length" ) ) ;
303+ return Err ( "DID must be 16 bytes in length" . into ( ) ) ;
288304 }
289305 let vk = self . key_bytes ( ) ?;
290306 if vk. len ( ) != 32 {
291- return Err ( ConversionError :: from_msg ( "Expected 32-byte verkey" ) ) ;
307+ return Err ( "Expected 32-byte verkey" . into ( ) ) ;
292308 }
293309 if & vk[ ..16 ] == did_bytes. as_slice ( ) {
294310 let mut result = "~" . to_string ( ) ;
@@ -487,6 +503,30 @@ mod tests {
487503 )
488504 }
489505
506+ #[ cfg( feature = "ed25519" ) ]
507+ #[ test]
508+ fn key_from_seed ( ) {
509+ const SEED : & [ u8 ; 32 ] = b"aaaabbbbccccddddeeeeffffgggghhhh" ;
510+ let sk = PrivateKey :: from_seed ( & SEED [ ..] ) . unwrap ( ) ;
511+ assert_eq ! (
512+ & sk. as_ref( ) [ ..] ,
513+ & [
514+ 97 , 97 , 97 , 97 , 98 , 98 , 98 , 98 , 99 , 99 , 99 , 99 , 100 , 100 , 100 , 100 , 101 , 101 , 101 ,
515+ 101 , 102 , 102 , 102 , 102 , 103 , 103 , 103 , 103 , 104 , 104 , 104 , 104 , 113 , 22 , 13 , 44 ,
516+ 71 , 184 , 166 , 148 , 196 , 234 , 85 , 148 , 234 , 22 , 204 , 148 , 187 , 247 , 77 , 119 , 250 ,
517+ 28 , 37 , 255 , 29 , 31 , 159 , 159 , 245 , 68 , 107 , 235
518+ ]
519+ ) ;
520+ let xk = sk. key_exchange ( ) . unwrap ( ) ;
521+ assert_eq ! (
522+ & xk. as_ref( ) ,
523+ & [
524+ 208 , 235 , 232 , 147 , 241 , 214 , 250 , 182 , 45 , 157 , 20 , 202 , 31 , 184 , 226 , 115 , 149 ,
525+ 82 , 210 , 89 , 50 , 100 , 22 , 67 , 21 , 8 , 124 , 198 , 100 , 252 , 237 , 107
526+ ]
527+ ) ;
528+ }
529+
490530 #[ cfg( feature = "ed25519" ) ]
491531 #[ test]
492532 fn sign_and_verify ( ) {
@@ -495,6 +535,8 @@ mod tests {
495535 let sig = sk. sign ( & message) . unwrap ( ) ;
496536 let vk = sk. public_key ( ) . unwrap ( ) ;
497537 assert ! ( vk. verify_signature( & message, & sig) . unwrap( ) ) ;
538+ assert ! ( vk. verify_signature( & message, & [ ] ) . is_err( ) ) ;
539+ assert ! ( !vk. verify_signature( & "goodbye" , & sig) . unwrap( ) ) ;
498540 }
499541
500542 #[ cfg( feature = "ed25519" ) ]
0 commit comments