Math API ecrecover and ripemd160 extension

core/crypto/Cargo.toml

@@ -13,6 +13,7 @@ c2-chacha = "0.3"
 curve25519-dalek = "3"
 derive_more = "0.99.9"
 ed25519-dalek = "1"
+ethereum-types = "0.11.0"
 lazy_static = "1.4"
 libc = "0.2"
 parity-secp256k1 = "0.7"

core/crypto/src/lib.rs

@@ -1,7 +1,8 @@
 pub use errors::{ParseKeyError, ParseKeyTypeError, ParseSignatureError};
 pub use key_file::KeyFile;
 pub use signature::{
-    ED25519PublicKey, KeyType, PublicKey, Secp256K1PublicKey, SecretKey, Signature,
+    ED25519PublicKey, KeyType, PublicKey, Secp256K1PublicKey, Secp256K1Signature, SecretKey,
+    Signature,
 };
 pub use signer::{EmptySigner, InMemorySigner, Signer};
 

core/crypto/src/signature.rs

@@ -7,8 +7,10 @@ use std::str::FromStr;
 
 use borsh::{BorshDeserialize, BorshSerialize};
 use ed25519_dalek::ed25519::signature::{Signature as _, Signer as _, Verifier as _};
+use ethereum_types::U256;
 use lazy_static::lazy_static;
 use rand_core::OsRng;
+use secp256k1::Message;
 use serde::{Deserialize, Serialize};
 
 lazy_static! {
@@ -556,6 +558,80 @@ impl<'de> serde::Deserialize<'de> for SecretKey {
 #[derive(Clone)]
 pub struct Secp256K1Signature([u8; 65]);
 
+impl Secp256K1Signature {
+    fn check_v(&self) -> Result<u8, crate::errors::ParseSignatureError> {
+        match self.0[64] {
+            27 | 28 => Ok(self.0[64] - 27),
+            _ => Err(crate::errors::ParseSignatureError::InvalidData {
+                error_message: "invalid `v` value".to_string(),
+            }),
+        }
+    }
+
+    pub fn check_signature_values(&self) -> bool {
+        let mut r_bytes = [0u8; 32];
+        r_bytes.copy_from_slice(&self.0[0..32]);
+        let r = U256::from(r_bytes);
+
+        let mut s_bytes = [0u8; 32];
+        s_bytes.copy_from_slice(&self.0[32..64]);
+        let s = U256::from(s_bytes);
+
+        let _v = match self.check_v() {
+            Ok(v) => v,
+            Err(_e) => return false,
+        };
+
+        if r.is_zero() || s.is_zero() {
+            return false;
+        }
+
+        let secp256k1_n = U256::from([
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xfe, 0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0, 0x3b, 0xbf, 0xd2, 0x5e, 0x8c,
+            0xd0, 0x36, 0x41, 0x41,
+        ]);
+
+        let secp256k1_half_n = secp256k1_n / U256::from(2);
+        // Reject upper range of s values (ECDSA malleability)
+        if s > secp256k1_half_n {
+            return false;
+        }
+
+        r < secp256k1_n && s < secp256k1_n
+    }
+
+    pub fn recover(
+        &self,
+        msg: [u8; 32],
+    ) -> Result<Secp256K1PublicKey, crate::errors::ParseSignatureError> {
+        let v = self.check_v()?;
+
+        // This can't fail because of the check above. It will fall in range.
+        let recover_id = secp256k1::RecoveryId::from_i32(i32::from(v)).unwrap();
+
+        let recoverable_sig =
+            secp256k1::RecoverableSignature::from_compact(&SECP256K1, &self.0[0..64], recover_id)
+                .map_err(|err| crate::errors::ParseSignatureError::InvalidData {
+                error_message: err.to_string(),
+            })?;
+        let msg = Message::from(msg);
+
+        let res = SECP256K1
+            .recover(&msg, &recoverable_sig)
+            .map_err(|err| crate::errors::ParseSignatureError::InvalidData {
+                error_message: err.to_string(),
+            })?
+            .serialize_vec(&SECP256K1, false);
+
+        let pk = Secp256K1PublicKey::try_from(&res[0..64]).map_err(|err| {
+            crate::errors::ParseSignatureError::InvalidData { error_message: err.to_string() }
+        })?;
+
+        Ok(pk)
+    }
+}
+
 impl From<[u8; 65]> for Secp256K1Signature {
     fn from(data: [u8; 65]) -> Self {
         Self(data)

core/primitives-core/Cargo.toml

@@ -24,7 +24,7 @@ lazy_static = "1.4"
 
 [features]
 default = []
-protocol_feature_add_account_versions = []
 protocol_feature_evm = []
+protocol_feature_add_account_versions = []
 protocol_feature_alt_bn128 = []
 protocol_feature_tx_size_limit = []

core/primitives-core/src/config.rs

@@ -223,6 +223,14 @@ pub struct ExtCostsConfig {
     /// Cost of getting sha256 per byte
     pub keccak512_byte: Gas,
 
+    /// Cost of getting ripemd160 base
+    pub ripemd160_base: Gas,
+    /// Cost of getting ripemd160 per message block
+    pub ripemd160_block: Gas,
+
+    /// Cost of calling ecrecover
+    pub ecrecover_base: Gas,
+
     /// Cost for calling logging.
     pub log_base: Gas,
     /// Cost for logging per byte
@@ -353,6 +361,9 @@ impl Default for ExtCostsConfig {
             keccak256_byte: SAFETY_MULTIPLIER * 7157035,
             keccak512_base: SAFETY_MULTIPLIER * 1937129412,
             keccak512_byte: SAFETY_MULTIPLIER * 12216567,
+            ripemd160_base: SAFETY_MULTIPLIER * 15136567500, // 10 x sha256_base
+            ripemd160_block: SAFETY_MULTIPLIER * 80391170 * 8, // 10 x sha256_byte x 8 bytes
+            ecrecover_base: SAFETY_MULTIPLIER * 75682837500, // 50 x sha256_base
             log_base: SAFETY_MULTIPLIER * 1181104350,
             log_byte: SAFETY_MULTIPLIER * 4399597,
             storage_write_base: SAFETY_MULTIPLIER * 21398912000,
@@ -423,6 +434,9 @@ impl ExtCostsConfig {
             keccak256_byte: 0,
             keccak512_base: 0,
             keccak512_byte: 0,
+            ripemd160_base: 0,
+            ripemd160_block: 0,
+            ecrecover_base: 0,
             log_base: 0,
             log_byte: 0,
             storage_write_base: 0,
@@ -494,6 +508,9 @@ pub enum ExtCosts {
     keccak256_byte,
     keccak512_base,
     keccak512_byte,
+    ripemd160_base,
+    ripemd160_block,
+    ecrecover_base,
     log_base,
     log_byte,
     storage_write_base,
@@ -618,6 +635,9 @@ impl ExtCosts {
             keccak256_byte => config.keccak256_byte,
             keccak512_base => config.keccak512_base,
             keccak512_byte => config.keccak512_byte,
+            ripemd160_base => config.ripemd160_base,
+            ripemd160_block => config.ripemd160_block,
+            ecrecover_base => config.ecrecover_base,
             log_base => config.log_base,
             log_byte => config.log_byte,
             storage_write_base => config.storage_write_base,
@@ -692,6 +712,9 @@ impl ExtCosts {
             "keccak256_byte",
             "keccak512_base",
             "keccak512_byte",
+            "ripemd160_base",
+            "ripemd160_block",
+            "ecrecover_base",
             "log_base",
             "log_byte",
             "storage_write_base",

runtime/near-vm-logic/Cargo.toml

@@ -17,10 +17,13 @@ base64 = "0.13"
 borsh = "0.8.1"
 bs58 = "0.4"
 byteorder = "1.2"
+num-integer = "0.1"
+ripemd160 = "0.9.0"
 serde = { version = "1", features = ["derive"] }
 sha2 = ">=0.8,<0.10"
 sha3 = ">=0.8,<0.10"
 
+near-crypto = { path = "../../core/crypto" }
 near-primitives = { path = "../../core/primitives" }
 near-primitives-core = { path = "../../core/primitives-core", version = "0.1.0" }
 near-vm-errors = { path = "../near-vm-errors", version = "3.0.0" }

runtime/near-vm-logic/src/gas_counter.rs

@@ -144,18 +144,18 @@ impl GasCounter {
         self.deduct_gas(value, value)
     }
 
-    /// A helper function to pay per byte gas
-    pub fn pay_per_byte(&mut self, cost: ExtCosts, num_bytes: u64) -> Result<()> {
-        let use_gas = num_bytes
+    /// A helper function to pay a multiple of a cost.
+    pub fn pay_per(&mut self, cost: ExtCosts, num: u64) -> Result<()> {
+        let use_gas = num
             .checked_mul(cost.value(&self.ext_costs_config))
             .ok_or(HostError::IntegerOverflow)?;
 
-        self.inc_ext_costs_counter(cost, num_bytes);
+        self.inc_ext_costs_counter(cost, num);
         self.update_profile_host(cost, use_gas);
         self.deduct_gas(use_gas, use_gas)
     }
 
-    /// A helper function to pay base cost gas
+    /// A helper function to pay base cost gas.
     pub fn pay_base(&mut self, cost: ExtCosts) -> Result<()> {
         let base_fee = cost.value(&self.ext_costs_config);
         self.inc_ext_costs_counter(cost, 1);