Blake3 syscall (#17358)

programs/bpf/Cargo.lock

@@ -3069,6 +3069,7 @@ dependencies = [
 name = "solana-bpf-rust-sha"
 version = "1.8.0"
 dependencies = [
+ "blake3",
  "solana-program 1.8.0",
 ]
 

programs/bpf/c/src/sha/sha.c

@@ -43,5 +43,24 @@ extern uint64_t entrypoint(const uint8_t *input) {
     sol_assert(0 == sol_memcmp(result, expected, KECCAK_RESULT_LENGTH));
   }
 
+  // Blake3
+  {
+    uint8_t result[BLAKE3_RESULT_LENGTH];
+    uint8_t expected[] = {0xad, 0x5d, 0x97, 0x5b, 0xc2, 0xc7, 0x46, 0x19,
+                          0x31, 0xb4, 0x87, 0x5d, 0x19, 0x6, 0xc5, 0x36,
+                          0xf4, 0x97, 0xa8, 0x45, 0x55, 0xec, 0xaf, 0xf2,
+                          0x50, 0x70, 0xe3, 0xe2, 0x3d, 0xbe, 0x7, 0x8c};
+
+    uint8_t bytes1[] = {'G', 'a', 'g', 'g', 'a', 'b', 'l', 'a',
+                        'g', 'h', 'b', 'l', 'a', 'g', 'h', '!'};
+    uint8_t bytes2[] = {'f', 'l', 'u', 'r', 'b', 'o', 's'};
+    const SolBytes bytes[] = {{bytes1, SOL_ARRAY_SIZE(bytes1)},
+                              {bytes2, SOL_ARRAY_SIZE(bytes2)}};
+
+    sol_blake3(bytes, SOL_ARRAY_SIZE(bytes), result);
+
+    sol_assert(0 == sol_memcmp(result, expected, BLAKE3_RESULT_LENGTH));
+  }
+
   return SUCCESS;
 }

programs/bpf/rust/sha/Cargo.toml

@@ -10,6 +10,7 @@ documentation = "https://docs.rs/solana-bpf-rust-sha"
 edition = "2018"
 
 [dependencies]
+blake3 = "0.3.7"
 solana-program = { path = "../../../../sdk/program", version = "=1.8.0" }
 
 [lib]

programs/bpf/rust/sha/src/lib.rs

@@ -19,12 +19,22 @@ fn test_keccak256_hasher() {
     assert_eq!(hashv(vals), hasher.result());
 }
 
+fn test_blake3_hasher() {
+    use solana_program::blake3::hashv;
+    let v0: &[u8] = b"Gaggablaghblagh!";
+    let v1: &[u8] = b"flurbos!";
+    let vals: &[&[u8]] = &[v0, v1];
+    let hash = blake3::hash(&[v0, v1].concat());
+    assert_eq!(hashv(vals).0, *hash.as_bytes());
+}
+
 #[no_mangle]
 pub extern "C" fn entrypoint(_input: *mut u8) -> u64 {
     msg!("sha");
 
     test_sha256_hasher();
     test_keccak256_hasher();
+    test_blake3_hasher();
 
     0
 }
@@ -39,5 +49,6 @@ mod test {
     fn test_sha() {
         test_sha256_hasher();
         test_keccak256_hasher();
+        test_blake3_hasher();
     }
 }

programs/bpf/tests/programs.rs

@@ -1282,7 +1282,7 @@ fn assert_instruction_count() {
             ("relative_call", 10),
             ("sanity", 174),
             ("sanity++", 174),
-            ("sha", 694),
+            ("sha", 1040),
             ("struct_pass", 8),
             ("struct_ret", 22),
         ]);
@@ -1303,7 +1303,7 @@ fn assert_instruction_count() {
             ("solana_bpf_rust_param_passing", 46),
             ("solana_bpf_rust_rand", 498),
             ("solana_bpf_rust_sanity", 917),
-            ("solana_bpf_rust_sha", 29099),
+            ("solana_bpf_rust_sha", 32384),
         ]);
     }
 

programs/bpf_loader/src/syscalls.rs

@@ -13,15 +13,15 @@ use solana_sdk::{
     account::{Account, AccountSharedData, ReadableAccount},
     account_info::AccountInfo,
     account_utils::StateMut,
-    bpf_loader, bpf_loader_deprecated,
+    blake3, bpf_loader, bpf_loader_deprecated,
     bpf_loader_upgradeable::{self, UpgradeableLoaderState},
     clock::Clock,
     entrypoint::{MAX_PERMITTED_DATA_INCREASE, SUCCESS},
     epoch_schedule::EpochSchedule,
     feature_set::{
-        cpi_data_cost, demote_sysvar_write_locks, enforce_aligned_host_addrs,
-        keccak256_syscall_enabled, memory_ops_syscalls, set_upgrade_authority_via_cpi_enabled,
-        sysvar_via_syscall, update_data_on_realloc,
+        blake3_syscall_enabled, cpi_data_cost, demote_sysvar_write_locks,
+        enforce_aligned_host_addrs, keccak256_syscall_enabled, memory_ops_syscalls,
+        set_upgrade_authority_via_cpi_enabled, sysvar_via_syscall, update_data_on_realloc,
     },
     hash::{Hasher, HASH_BYTES},
     ic_msg,
@@ -134,6 +134,10 @@ pub fn register_syscalls(
         syscall_registry.register_syscall_by_name(b"sol_keccak256", SyscallKeccak256::call)?;
     }
 
+    if invoke_context.is_feature_active(&blake3_syscall_enabled::id()) {
+        syscall_registry.register_syscall_by_name(b"sol_blake3", SyscallBlake3::call)?;
+    }
+
     if invoke_context.is_feature_active(&sysvar_via_syscall::id()) {
         syscall_registry
             .register_syscall_by_name(b"sol_get_clock_sysvar", SyscallGetClockSysvar::call)?;
@@ -316,6 +320,16 @@ pub fn bind_syscall_context_objects<'a>(
             loader_id,
         }),
     );
+    bind_feature_gated_syscall_context_object!(
+        vm,
+        invoke_context.is_feature_active(&blake3_syscall_enabled::id()),
+        Box::new(SyscallBlake3 {
+            base_cost: bpf_compute_budget.sha256_base_cost,
+            byte_cost: bpf_compute_budget.sha256_byte_cost,
+            compute_meter: invoke_context.get_compute_meter(),
+            loader_id,
+        }),
+    );
 
     let is_sysvar_via_syscall_active = invoke_context.is_feature_active(&sysvar_via_syscall::id());
 
@@ -1329,6 +1343,65 @@ impl<'a> SyscallObject<BpfError> for SyscallMemset<'a> {
     }
 }
 
+// Blake3
+pub struct SyscallBlake3<'a> {
+    base_cost: u64,
+    byte_cost: u64,
+    compute_meter: Rc<RefCell<dyn ComputeMeter>>,
+    loader_id: &'a Pubkey,
+}
+impl<'a> SyscallObject<BpfError> for SyscallBlake3<'a> {
+    fn call(
+        &mut self,
+        vals_addr: u64,
+        vals_len: u64,
+        result_addr: u64,
+        _arg4: u64,
+        _arg5: u64,
+        memory_mapping: &MemoryMapping,
+        result: &mut Result<u64, EbpfError<BpfError>>,
+    ) {
+        question_mark!(self.compute_meter.consume(self.base_cost), result);
+        let hash_result = question_mark!(
+            translate_slice_mut::<u8>(
+                memory_mapping,
+                result_addr,
+                blake3::HASH_BYTES as u64,
+                self.loader_id,
+                true,
+            ),
+            result
+        );
+        let mut hasher = blake3::Hasher::default();
+        if vals_len > 0 {
+            let vals = question_mark!(
+                translate_slice::<&[u8]>(memory_mapping, vals_addr, vals_len, self.loader_id, true),
+                result
+            );
+            for val in vals.iter() {
+                let bytes = question_mark!(
+                    translate_slice::<u8>(
+                        memory_mapping,
+                        val.as_ptr() as u64,
+                        val.len() as u64,
+                        self.loader_id,
+                        true,
+                    ),
+                    result
+                );
+                question_mark!(
+                    self.compute_meter
+                        .consume(self.byte_cost * (val.len() as u64 / 2)),
+                    result
+                );
+                hasher.hash(bytes);
+            }
+        }
+        hash_result.copy_from_slice(&hasher.result().to_bytes());
+        *result = Ok(0);
+    }
+}
+
 // Cross-program invocation syscalls
 
 struct AccountReferences<'a> {