Merge pull request #790 from CosmWasm/recover_pubkey

Add pubkey recovery API

Author: mergify[bot]

Cargo.lock

@@ -316,6 +316,7 @@ nightly toolchain installed as well.
 
 ```sh
 cargo fmt \
+  && (cd packages/crypto && cargo build && cargo test && cargo clippy -- -D warnings) \
   && (cd packages/std && cargo wasm-debug --features iterator && cargo test --features iterator && cargo clippy --features iterator -- -D warnings && cargo schema) \
   && (cd packages/storage && cargo build && cargo test --features iterator && cargo clippy --features iterator -- -D warnings) \
   && (cd packages/schema && cargo build && cargo test && cargo clippy -- -D warnings) \

README.md

@@ -34,11 +34,12 @@ backtraces = ["cosmwasm-std/backtraces", "cosmwasm-vm/backtraces"]
 [dependencies]
 cosmwasm-std = { path = "../../packages/std", features = ["iterator"] }
 cosmwasm-storage = { path = "../../packages/storage", features = ["iterator"] }
+hex = "0.4"
 schemars = "0.7"
 serde = { version = "1.0.103", default-features = false, features = ["derive"] }
 sha2 = "0.9"
+sha3 = "0.9"
 
 [dev-dependencies]
 cosmwasm-vm = { path = "../../packages/vm", default-features = false, features = ["iterator"] }
 cosmwasm-schema = { path = "../../packages/schema" }
-hex = "0.4"

contracts/crypto-verify/Cargo.lock

@@ -45,6 +45,41 @@
         }
       }
     },
+    {
+      "description": "Ethereum text verification (compatible to the eth_sign RPC/web3 enpoint). This cannot be used to verify transaction.\n\nSee https://web3js.readthedocs.io/en/v1.2.0/web3-eth.html#sign",
+      "type": "object",
+      "required": [
+        "verify_ethereum_text"
+      ],
+      "properties": {
+        "verify_ethereum_text": {
+          "type": "object",
+          "required": [
+            "message",
+            "signature",
+            "signer_address"
+          ],
+          "properties": {
+            "message": {
+              "description": "Message to verify. This will be wrapped in the standard container `\"\\x19Ethereum Signed Message:\\n\" + len(message) + message` before verification.",
+              "type": "string"
+            },
+            "signature": {
+              "description": "Serialized signature. Fixed length format (64 bytes `r` and `s` plus the one byte `v`).",
+              "allOf": [
+                {
+                  "$ref": "#/definitions/Binary"
+                }
+              ]
+            },
+            "signer_address": {
+              "description": "Signer address. This is matched case insensitive, so you can provide checksummed and non-checksummed addresses. Checksums are not validated.",
+              "type": "string"
+            }
+          }
+        }
+      }
+    },
     {
       "description": "Tendermint format (ed25519 verification scheme).",
       "type": "object",

contracts/crypto-verify/Cargo.toml

@@ -1,8 +1,9 @@
-use sha2::{Digest, Sha256};
-
 use cosmwasm_std::{
-    entry_point, to_binary, Deps, DepsMut, Env, MessageInfo, QueryResponse, Response, StdResult,
+    entry_point, to_binary, Deps, DepsMut, Env, MessageInfo, QueryResponse, Response, StdError,
+    StdResult,
 };
+use sha2::{Digest, Sha256};
+use sha3::Keccak256;
 
 use crate::msg::{
     list_verifications, HandleMsg, InitMsg, ListVerificationsResponse, QueryMsg, VerifyResponse,
@@ -38,6 +39,16 @@ pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> StdResult<QueryResponse> {
             &signature.0,
             &public_key.0,
         )?),
+        QueryMsg::VerifyEthereumText {
+            message,
+            signature,
+            signer_address,
+        } => to_binary(&query_verify_ethereum_text(
+            deps,
+            &message,
+            &signature,
+            &signer_address,
+        )?),
         QueryMsg::VerifyTendermintSignature {
             message,
             signature,
@@ -62,7 +73,41 @@ pub fn query_verify_cosmos(
     let hash = Sha256::digest(message);
 
     // Verification
-    let result = deps.api.secp256k1_verify(&*hash, signature, public_key);
+    let result = deps
+        .api
+        .secp256k1_verify(hash.as_ref(), signature, public_key);
+    match result {
+        Ok(verifies) => Ok(VerifyResponse { verifies }),
+        Err(err) => Err(err.into()),
+    }
+}
+
+pub fn query_verify_ethereum_text(
+    deps: Deps,
+    message: &str,
+    signature: &[u8],
+    signer_address: &str,
+) -> StdResult<VerifyResponse> {
+    // Hashing
+    let mut hasher = Keccak256::new();
+    hasher.update(format!("\x19Ethereum Signed Message:\n{}", message.len()));
+    hasher.update(message);
+    let hash = hasher.finalize();
+
+    // Decompose signature
+    let (v, rs) = match signature.split_last() {
+        Some(pair) => pair,
+        None => return Err(StdError::generic_err("Signature must not be empty")),
+    };
+    let recovery = get_recovery_param(*v)?;
+
+    // Verification
+    let calculated_pubkey = deps.api.secp256k1_recover_pubkey(&hash, rs, recovery)?;
+    let calculated_address = ethereum_address(&calculated_pubkey)?;
+    if signer_address.to_ascii_lowercase() != calculated_address {
+        return Ok(VerifyResponse { verifies: false });
+    }
+    let result = deps.api.secp256k1_verify(&hash, rs, &calculated_pubkey);
     match result {
         Ok(verifies) => Ok(VerifyResponse { verifies }),
         Err(err) => Err(err.into()),
@@ -87,13 +132,44 @@ pub fn query_list_verifications(deps: Deps) -> StdResult<ListVerificationsRespon
     })
 }
 
+fn ethereum_address(pubkey: &[u8]) -> StdResult<String> {
+    let (tag, data) = match pubkey.split_first() {
+        Some(pair) => pair,
+        None => return Err(StdError::generic_err("Public key must not be empty")),
+    };
+    if *tag != 0x04 {
+        return Err(StdError::generic_err("Public key start with 0x04"));
+    }
+    if data.len() != 64 {
+        return Err(StdError::generic_err("Public key must be 65 bytes long"));
+    }
+
+    let hash = Keccak256::digest(data);
+    let mut out = String::with_capacity(42);
+    out.push_str("0x");
+    out.push_str(&hex::encode(&hash[hash.len() - 20..]));
+    Ok(out)
+}
+
+fn get_recovery_param(v: u8) -> StdResult<u8> {
+    // See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-155.md
+    // for how `v` is composed.
+    match v {
+        27 => Ok(0),
+        28 => Ok(1),
+        _ => Err(StdError::generic_err("Values of v other than 27 and 28 not supported. Replay protection (EIP-155) cannot be used here."))
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
     use cosmwasm_std::testing::{
         mock_dependencies, mock_env, mock_info, MockApi, MockQuerier, MockStorage,
     };
-    use cosmwasm_std::{from_slice, Binary, OwnedDeps, StdError, VerificationError};
+    use cosmwasm_std::{
+        from_slice, Binary, OwnedDeps, RecoverPubkeyError, StdError, VerificationError,
+    };
 
     const CREATOR: &str = "creator";
 
@@ -107,6 +183,11 @@ mod tests {
     const ED25519_PUBLIC_KEY_HEX: &str =
         "fc51cd8e6218a1a38da47ed00230f0580816ed13ba3303ac5deb911548908025";
 
+    // Signed text "connect all the things" using MyEtherWallet with private key b5b1870957d373ef0eeffecc6e4812c0fd08f554b37b233526acc331bf1544f7
+    const ETHEREUM_MESSAGE: &str = "connect all the things";
+    const ETHEREUM_SIGNATURE_HEX: &str = "dada130255a447ecf434a2df9193e6fbba663e4546c35c075cd6eea21d8c7cb1714b9b65a4f7f604ff6aad55fba73f8c36514a512bbbba03709b37069194f8a41b";
+    const ETHEREUM_SIGNER_ADDRESS: &str = "0x12890D2cce102216644c59daE5baed380d84830c";
+
     fn setup() -> OwnedDeps<MockStorage, MockApi, MockQuerier> {
         let mut deps = mock_dependencies(&[]);
         let msg = InitMsg {};
@@ -187,6 +268,81 @@ mod tests {
         )
     }
 
+    #[test]
+    fn ethereum_signature_verify_works() {
+        let deps = setup();
+
+        let message = ETHEREUM_MESSAGE;
+        let signature = hex::decode(ETHEREUM_SIGNATURE_HEX).unwrap();
+        let signer_address = ETHEREUM_SIGNER_ADDRESS;
+
+        let verify_msg = QueryMsg::VerifyEthereumText {
+            message: message.into(),
+            signature: signature.into(),
+            signer_address: signer_address.into(),
+        };
+        let raw = query(deps.as_ref(), mock_env(), verify_msg).unwrap();
+        let res: VerifyResponse = from_slice(&raw).unwrap();
+
+        assert_eq!(res, VerifyResponse { verifies: true });
+    }
+
+    #[test]
+    fn ethereum_signature_verify_fails_for_corrupted_message() {
+        let deps = setup();
+
+        let mut message = String::from(ETHEREUM_MESSAGE);
+        message.push('!');
+        let signature = hex::decode(ETHEREUM_SIGNATURE_HEX).unwrap();
+        let signer_address = ETHEREUM_SIGNER_ADDRESS;
+
+        let verify_msg = QueryMsg::VerifyEthereumText {
+            message: message.into(),
+            signature: signature.into(),
+            signer_address: signer_address.into(),
+        };
+        let raw = query(deps.as_ref(), mock_env(), verify_msg).unwrap();
+        let res: VerifyResponse = from_slice(&raw).unwrap();
+
+        assert_eq!(res, VerifyResponse { verifies: false });
+    }
+
+    #[test]
+    fn ethereum_signature_verify_fails_for_corrupted_signature() {
+        let deps = setup();
+
+        let message = ETHEREUM_MESSAGE;
+        let signer_address = ETHEREUM_SIGNER_ADDRESS;
+
+        // Wrong signature
+        let mut signature = hex::decode(ETHEREUM_SIGNATURE_HEX).unwrap();
+        signature[5] ^= 0x01;
+        let verify_msg = QueryMsg::VerifyEthereumText {
+            message: message.into(),
+            signature: signature.into(),
+            signer_address: signer_address.into(),
+        };
+        let raw = query(deps.as_ref(), mock_env(), verify_msg).unwrap();
+        let res: VerifyResponse = from_slice(&raw).unwrap();
+        assert_eq!(res, VerifyResponse { verifies: false });
+
+        // Broken signature
+        let signature = vec![0x1c; 65];
+        let verify_msg = QueryMsg::VerifyEthereumText {
+            message: message.into(),
+            signature: signature.into(),
+            signer_address: signer_address.into(),
+        };
+        let result = query(deps.as_ref(), mock_env(), verify_msg);
+        match result.unwrap_err() {
+            StdError::RecoverPubkeyErr {
+                source: RecoverPubkeyError::UnknownErr { .. },
+                ..
+            } => {}
+            err => panic!("Unexpected error: {:?}", err),
+        }
+    }
+
     #[test]
     fn tendermint_signature_verify_works() {
         let deps = setup();

contracts/crypto-verify/schema/query_msg.json

@@ -23,6 +23,20 @@ pub enum QueryMsg {
         /// Serialized compressed (33 bytes) or uncompressed (65 bytes) public key.
         public_key: Binary,
     },
+    /// Ethereum text verification (compatible to the eth_sign RPC/web3 enpoint).
+    /// This cannot be used to verify transaction.
+    ///
+    /// See https://web3js.readthedocs.io/en/v1.2.0/web3-eth.html#sign
+    VerifyEthereumText {
+        /// Message to verify. This will be wrapped in the standard container
+        /// `"\x19Ethereum Signed Message:\n" + len(message) + message` before verification.
+        message: String,
+        /// Serialized signature. Fixed length format (64 bytes `r` and `s` plus the one byte `v`).
+        signature: Binary,
+        /// Signer address.
+        /// This is matched case insensitive, so you can provide checksummed and non-checksummed addresses. Checksums are not validated.
+        signer_address: String,
+    },
     /// Tendermint format (ed25519 verification scheme).
     VerifyTendermintSignature {
         /// Message to verify.