]> git.bitcoin.ninja Git - rust-lightning/blob - lightning/src/crypto/utils.rs
Adapt intro node process_pending_htlcs test for non-intro nodes
[rust-lightning] / lightning / src / crypto / utils.rs
1 use bitcoin::hashes::{Hash, HashEngine};
2 use bitcoin::hashes::hmac::{Hmac, HmacEngine};
3 use bitcoin::hashes::sha256::Hash as Sha256;
4 use bitcoin::secp256k1::{Message, Secp256k1, SecretKey, ecdsa::Signature, Signing};
5
6 use crate::sign::EntropySource;
7
8 use core::ops::Deref;
9
10 macro_rules! hkdf_extract_expand {
11         ($salt: expr, $ikm: expr) => {{
12                 let mut hmac = HmacEngine::<Sha256>::new($salt);
13                 hmac.input($ikm);
14                 let prk = Hmac::from_engine(hmac).to_byte_array();
15                 let mut hmac = HmacEngine::<Sha256>::new(&prk[..]);
16                 hmac.input(&[1; 1]);
17                 let t1 = Hmac::from_engine(hmac).to_byte_array();
18                 let mut hmac = HmacEngine::<Sha256>::new(&prk[..]);
19                 hmac.input(&t1);
20                 hmac.input(&[2; 1]);
21                 (t1, Hmac::from_engine(hmac).to_byte_array(), prk)
22         }};
23         ($salt: expr, $ikm: expr, 2) => {{
24                 let (k1, k2, _) = hkdf_extract_expand!($salt, $ikm);
25                 (k1, k2)
26         }};
27         ($salt: expr, $ikm: expr, 5) => {{
28                 let (k1, k2, prk) = hkdf_extract_expand!($salt, $ikm);
29
30                 let mut hmac = HmacEngine::<Sha256>::new(&prk[..]);
31                 hmac.input(&k2);
32                 hmac.input(&[3; 1]);
33                 let k3 = Hmac::from_engine(hmac).to_byte_array();
34
35                 let mut hmac = HmacEngine::<Sha256>::new(&prk[..]);
36                 hmac.input(&k3);
37                 hmac.input(&[4; 1]);
38                 let k4 = Hmac::from_engine(hmac).to_byte_array();
39
40                 let mut hmac = HmacEngine::<Sha256>::new(&prk[..]);
41                 hmac.input(&k4);
42                 hmac.input(&[5; 1]);
43                 let k5 = Hmac::from_engine(hmac).to_byte_array();
44
45                 (k1, k2, k3, k4, k5)
46         }}
47 }
48
49 pub fn hkdf_extract_expand_twice(salt: &[u8], ikm: &[u8]) -> ([u8; 32], [u8; 32]) {
50         hkdf_extract_expand!(salt, ikm, 2)
51 }
52
53 pub fn hkdf_extract_expand_5x(salt: &[u8], ikm: &[u8]) -> ([u8; 32], [u8; 32], [u8; 32], [u8; 32], [u8; 32]) {
54         hkdf_extract_expand!(salt, ikm, 5)
55 }
56
57 #[inline]
58 pub fn sign<C: Signing>(ctx: &Secp256k1<C>, msg: &Message, sk: &SecretKey) -> Signature {
59         #[cfg(feature = "grind_signatures")]
60         let sig = ctx.sign_ecdsa_low_r(msg, sk);
61         #[cfg(not(feature = "grind_signatures"))]
62         let sig = ctx.sign_ecdsa(msg, sk);
63         sig
64 }
65
66 #[inline]
67 #[allow(unused_variables)]
68 pub fn sign_with_aux_rand<C: Signing, ES: Deref>(
69         ctx: &Secp256k1<C>, msg: &Message, sk: &SecretKey, entropy_source: &ES
70 ) -> Signature where ES::Target: EntropySource {
71         #[cfg(feature = "grind_signatures")]
72         let sig = loop {
73                 let sig = ctx.sign_ecdsa_with_noncedata(msg, sk, &entropy_source.get_secure_random_bytes());
74                 if sig.serialize_compact()[0] < 0x80 {
75                         break sig;
76                 }
77         };
78         #[cfg(all(not(feature = "grind_signatures"), not(feature = "_test_vectors")))]
79         let sig = ctx.sign_ecdsa_with_noncedata(msg, sk, &entropy_source.get_secure_random_bytes());
80         #[cfg(all(not(feature = "grind_signatures"), feature = "_test_vectors"))]
81         let sig = sign(ctx, msg, sk);
82         sig
83 }