3131//! # #[cfg(all(feature = "rand-std", feature = "hashes-std"))] {
3232//! use secp256k1::rand::rngs::OsRng;
3333//! use secp256k1::{Secp256k1, Message};
34- //! use secp256k1::hashes::sha256;
34+ //! use secp256k1::hashes::{ sha256, Hash} ;
3535//!
3636//! let secp = Secp256k1::new();
3737//! let (secret_key, public_key) = secp.generate_keypair(&mut OsRng);
38- //! let message = Message::from_hashed_data::< sha256::Hash> ("Hello World !".as_bytes());
38+ //! let message = Message::from_digest( sha256::Hash::hash ("Hello world !".as_bytes()).to_byte_array ());
3939//!
4040//! let sig = secp.sign_ecdsa(&message, &secret_key);
4141//! assert!(secp.verify_ecdsa(&message, &sig, &public_key).is_ok());
4747//! ```rust
4848//! # #[cfg(all(feature = "global-context", feature = "hashes-std", feature = "rand-std"))] {
4949//! use secp256k1::{generate_keypair, Message};
50- //! use secp256k1::hashes::sha256;
50+ //! use secp256k1::hashes::{ sha256, Hash} ;
5151//!
5252//! let (secret_key, public_key) = generate_keypair(&mut rand::thread_rng());
53- //! let message = Message::from_hashed_data::< sha256::Hash> ("Hello World !".as_bytes());
53+ //! let message = Message::from_digest( sha256::Hash::hash ("Hello world !".as_bytes()).to_byte_array ());
5454//!
5555//! let sig = secret_key.sign_ecdsa(message);
5656//! assert!(sig.verify(&message, &public_key).is_ok());
@@ -176,8 +176,6 @@ use core::{fmt, mem, str};
176176
177177#[ cfg( all( feature = "global-context" , feature = "std" ) ) ]
178178pub use context:: global:: { self , SECP256K1 } ;
179- #[ cfg( feature = "hashes" ) ]
180- use hashes:: Hash ;
181179#[ cfg( feature = "rand" ) ]
182180pub use rand;
183181pub use secp256k1_sys as ffi;
@@ -198,34 +196,20 @@ pub use crate::scalar::Scalar;
198196/// Trait describing something that promises to be a 32-byte random number; in particular,
199197/// it has negligible probability of being zero or overflowing the group order. Such objects
200198/// may be converted to `Message`s without any error paths.
199+ #[ deprecated( since = "0.29.0" , note = "this will be removed soon" ) ]
201200pub trait ThirtyTwoByteHash {
202201 /// Converts the object into a 32-byte array
203202fn into_32 ( self ) -> [ u8 ; 32 ] ;
204203}
205204
206- #[ cfg( feature = "hashes" ) ]
207- impl ThirtyTwoByteHash for hashes:: sha256:: Hash {
208- fn into_32 ( self ) -> [ u8 ; 32 ] { self . to_byte_array ( ) }
209- }
210-
211- #[ cfg( feature = "hashes" ) ]
212- impl ThirtyTwoByteHash for hashes:: sha256d:: Hash {
213- fn into_32 ( self ) -> [ u8 ; 32 ] { self . to_byte_array ( ) }
214- }
215-
216- #[ cfg( feature = "hashes" ) ]
217- impl < T : hashes:: sha256t:: Tag > ThirtyTwoByteHash for hashes:: sha256t:: Hash < T > {
218- fn into_32 ( self ) -> [ u8 ; 32 ] { self . to_byte_array ( ) }
219- }
220-
221205/// A (hashed) message input to an ECDSA signature.
222206#[ derive( Copy , Clone , PartialEq , Eq , PartialOrd , Ord , Hash ) ]
223207pub struct Message ( [ u8 ; constants:: MESSAGE_SIZE ] ) ;
224208impl_array_newtype ! ( Message , u8 , constants:: MESSAGE_SIZE ) ;
225209impl_pretty_debug ! ( Message ) ;
226210
227211impl Message {
228- /// **If you just want to sign an arbitrary message use `Message::from_hashed_data` instead.**
212+ /// Creates a [`Message`] from a 32 byte slice `digest`.
229213///
230214/// Converts a `MESSAGE_SIZE`-byte slice to a message object. **WARNING:** the slice has to be a
231215/// cryptographically secure hash of the actual message that's going to be signed. Otherwise
@@ -239,8 +223,6 @@ impl Message {
239223
240224 /// Creates a [`Message`] from a `digest`.
241225///
242- /// **If you just want to sign an arbitrary message use `Message::from_hashed_data` instead.**
243- ///
244226/// The `digest` array has to be a cryptographically secure hash of the actual message that's
245227/// going to be signed. Otherwise the result of signing isn't a [secure signature].
246228///
@@ -250,8 +232,6 @@ impl Message {
250232
251233 /// Creates a [`Message`] from a 32 byte slice `digest`.
252234///
253- /// **If you just want to sign an arbitrary message use `Message::from_hashed_data` instead.**
254- ///
255235/// The slice has to be 32 bytes long and be a cryptographically secure hash of the actual
256236/// message that's going to be signed. Otherwise the result of signing isn't a [secure
257237/// signature].
@@ -272,34 +252,6 @@ impl Message {
272252 _ => Err ( Error :: InvalidMessage ) ,
273253 }
274254 }
275-
276- /// Constructs a [`Message`] by hashing `data` with hash algorithm `H`.
277- ///
278- /// Requires the feature `hashes` to be enabled.
279- ///
280- /// # Examples
281- ///
282- /// ```
283- /// # #[cfg(feature = "hashes")] {
284- /// use secp256k1::hashes::{sha256, Hash};
285- /// use secp256k1::Message;
286- ///
287- /// let m1 = Message::from_hashed_data::<sha256::Hash>("Hello world!".as_bytes());
288- /// // is equivalent to
289- /// let m2 = Message::from(sha256::Hash::hash("Hello world!".as_bytes()));
290- ///
291- /// assert_eq!(m1, m2);
292- /// # }
293- /// ```
294- #[ cfg( feature = "hashes" ) ]
295- pub fn from_hashed_data < H : ThirtyTwoByteHash + hashes:: Hash > ( data : & [ u8 ] ) -> Self {
296- <H as hashes:: Hash >:: hash ( data) . into ( )
297- }
298- }
299-
300- impl < T : ThirtyTwoByteHash > From < T > for Message {
301- /// Converts a 32-byte hash directly to a message without error paths.
302- fn from ( t : T ) -> Message { Message ( t. into_32 ( ) ) }
303255}
304256
305257impl fmt:: LowerHex for Message {
@@ -1043,24 +995,6 @@ mod tests {
1043995 let sig = SECP256K1 . sign_ecdsa ( & msg, & sk) ;
1044996 assert ! ( SECP256K1 . verify_ecdsa( & msg, & sig, & pk) . is_ok( ) ) ;
1045997 }
1046-
1047- #[ cfg( feature = "hashes" ) ]
1048- #[ test]
1049- fn test_from_hash ( ) {
1050- use hashes:: { sha256, sha256d, Hash } ;
1051-
1052- let test_bytes = "Hello world!" . as_bytes ( ) ;
1053-
1054- let hash = sha256:: Hash :: hash ( test_bytes) ;
1055- let msg = Message :: from ( hash) ;
1056- assert_eq ! ( msg. 0 , hash. to_byte_array( ) ) ;
1057- assert_eq ! ( msg, Message :: from_hashed_data:: <hashes:: sha256:: Hash >( test_bytes) ) ;
1058-
1059- let hash = sha256d:: Hash :: hash ( test_bytes) ;
1060- let msg = Message :: from ( hash) ;
1061- assert_eq ! ( msg. 0 , hash. to_byte_array( ) ) ;
1062- assert_eq ! ( msg, Message :: from_hashed_data:: <hashes:: sha256d:: Hash >( test_bytes) ) ;
1063- }
1064998}
1065999
10661000#[ cfg( bench) ]
0 commit comments