Rust Bitcoin signature verification

drehb · September 26, 2020, 2:13pm

For safecoin claims I was thinking that Bitcoin signatures will need to be verified. So I was looking for a Rust library that has this functionality.

From Electrum, this is the sort of thing I was looking for:

github.com

spesmilo/electrum/blob/725b6f15649c4f93dedfa2c241b6cbf7a82a65f0/electrum/tests/test_bitcoin.py#L185


      
              sig2 = sign_message_with_wif_privkey(
                  '5Hxn5C4SQuiV6e62A1MtZmbSeQyrLFhu5uYks62pU5VBUygK2KD', msg2)
              addr2 = '1GPHVTY8UD9my6jyP4tb2TYJwUbDetyNC6'
          
              sig1_b64 = base64.b64encode(sig1)
              sig2_b64 = base64.b64encode(sig2)
          
              self.assertEqual(sig1_b64, b'Hzsu0U/THAsPz/MSuXGBKSULz2dTfmrg1NsAhFp+wH5aKfmX4Db7ExLGa7FGn0m6Mf43KsbEOWpvUUUBTM3Uusw=')
              self.assertEqual(sig2_b64, b'HBQdYfv7kOrxmRewLJnG7sV6KlU71O04hUnE4tai97p7Pg+D+yKaWXsdGgHTrKw90caQMo/D6b//qX50ge9P9iI=')
          
              self.assertTrue(ecc.verify_message_with_address(addr1, sig1, msg1))
              self.assertTrue(ecc.verify_message_with_address(addr2, sig2, msg2))
          
              self.assertFalse(ecc.verify_message_with_address(addr1, b'wrong', msg1))
              self.assertFalse(ecc.verify_message_with_address(addr1, sig2, msg1))
          
          @needs_test_with_all_aes_implementations
          def test_decrypt_message(self):
              key = WalletStorage.get_eckey_from_password('pw123')
              self.assertEqual(b'me<(s_s)>age', key.decrypt_message(b'QklFMQMDFtgT3zWSQsa+Uie8H/WvfUjlu9UN9OJtTt3KlgKeSTi6SQfuhcg1uIz9hp3WIUOFGTLr4RNQBdjPNqzXwhkcPi2Xsbiw6UCNJncVPJ6QBg=='))
              self.assertEqual(b'me<(s_s)>age', key.decrypt_message(b'QklFMQKXOXbylOQTSMGfo4MFRwivAxeEEkewWQrpdYTzjPhqjHcGBJwdIhB7DyRfRQihuXx1y0ZLLv7XxLzrILzkl/H4YUtZB4uWjuOAcmxQH4i/Og=='))

The Rust libraries that I found seem to just have verification by public key, not by address.

github.com

rust-bitcoin/rust-secp256k1/blob/master/examples/sign_verify.rs

extern crate hashes;
extern crate secp256k1;

use hashes::{sha256, Hash};
use secp256k1::{ecdsa, Error, Message, PublicKey, Secp256k1, SecretKey, Signing, Verification};

fn verify<C: Verification>(
    secp: &Secp256k1<C>,
    msg: &[u8],
    sig: [u8; 64],
    pubkey: [u8; 33],
) -> Result<bool, Error> {
    let msg = sha256::Hash::hash(msg);
    let msg = Message::from_digest_slice(msg.as_ref())?;
    let sig = ecdsa::Signature::from_compact(&sig)?;
    let pubkey = PublicKey::from_slice(&pubkey)?;

    Ok(secp.verify_ecdsa(&msg, &sig, &pubkey).is_ok())
}

This file has been truncated. show original

github.com

paritytech/libsecp256k1/blob/12e3829d6cd2d6459c2c920d7cf222f3a930b955/tests/verify.rs#L175


      
          
          let pubkey_a = pubkey.serialize_uncompressed();
          assert_eq!(pubkey_a.len(), 65);
          
          let ctx_pubkey = PublicKey::parse(&pubkey_a).unwrap();
          let ctx_message = Message::parse(&message_arr);
          let signature_a = signature.serialize_compact();
          assert_eq!(signature_a.len(), 64);
          let ctx_sig = Signature::parse(&signature_a);
          
          secp256k1.verify(&message, &signature, &pubkey).unwrap();
          assert!(verify(&ctx_message, &ctx_sig, &ctx_pubkey));
          let mut f_ctx_sig = ctx_sig;
          f_ctx_sig.r.set_int(0);
          if f_ctx_sig.r != ctx_sig.r {
              assert!(!ECMULT_CONTEXT.verify_raw(
                  &f_ctx_sig.r,
                  &ctx_sig.s,
                  &ctx_pubkey.into(),
                  &ctx_message.0
              ));

drehb · October 1, 2020, 12:51pm

Ah ha, so that’s how it works…the public key can be calculated from the message and it’s signature.

https://www.reddit.com/r/Bitcoin/comments/18qy88/bitcoin_message_signing_and_verification/c8nhca0?utm_medium=android_app&utm_source=share&context=3