sbpf_runtime/syscalls/
crypto.rs

1use {
2    crate::config::ExecutionCost,
3    blake3::Hasher as Blake3Hasher,
4    sbpf_vm::{
5        compute::ComputeMeter,
6        errors::{SbpfVmError, SbpfVmResult},
7        memory::Memory,
8    },
9    sha2::Sha256,
10    sha3::Keccak256,
11};
12
13trait Hasher {
14    fn new() -> Self;
15    fn update(&mut self, data: &[u8]);
16    fn finalize(self) -> Vec<u8>;
17}
18
19impl Hasher for Sha256 {
20    fn new() -> Self {
21        sha2::Digest::new()
22    }
23    fn update(&mut self, data: &[u8]) {
24        sha2::Digest::update(self, data);
25    }
26    fn finalize(self) -> Vec<u8> {
27        sha2::Digest::finalize(self).to_vec()
28    }
29}
30
31impl Hasher for Keccak256 {
32    fn new() -> Self {
33        sha3::Digest::new()
34    }
35    fn update(&mut self, data: &[u8]) {
36        sha3::Digest::update(self, data);
37    }
38    fn finalize(self) -> Vec<u8> {
39        sha3::Digest::finalize(self).to_vec()
40    }
41}
42
43impl Hasher for Blake3Hasher {
44    fn new() -> Self {
45        blake3::Hasher::new()
46    }
47    fn update(&mut self, data: &[u8]) {
48        blake3::Hasher::update(self, data);
49    }
50    fn finalize(self) -> Vec<u8> {
51        blake3::Hasher::finalize(&self).as_bytes().to_vec()
52    }
53}
54
55fn read_slices(memory: &Memory, vals_addr: u64, vals_len: u64) -> SbpfVmResult<Vec<(u64, u64)>> {
56    let mut slices = Vec::with_capacity(vals_len as usize);
57    for i in 0..vals_len {
58        let slice_addr = vals_addr.saturating_add(i.saturating_mul(16));
59        let ptr = memory.read_u64(slice_addr)?;
60        let len = memory.read_u64(slice_addr.saturating_add(8))?;
61        slices.push((ptr, len));
62    }
63    Ok(slices)
64}
65
66fn hash_slices<H: Hasher>(
67    memory: &mut Memory,
68    compute: &ComputeMeter,
69    costs: &ExecutionCost,
70    vals_addr: u64,
71    vals_len: u64,
72    result_addr: u64,
73) -> SbpfVmResult<u64> {
74    if vals_len > costs.sha256_max_slices {
75        return Err(SbpfVmError::TooManySlices);
76    }
77
78    compute.consume(costs.sha256_base_cost)?;
79
80    let mut hasher = H::new();
81    if vals_len > 0 {
82        for (ptr, len) in read_slices(memory, vals_addr, vals_len)? {
83            let cost = costs
84                .mem_op_base_cost
85                .max(costs.sha256_byte_cost.saturating_mul(len / 2));
86            compute.consume(cost)?;
87            hasher.update(memory.read_bytes(ptr, len as usize)?);
88        }
89    }
90
91    memory.write_bytes(result_addr, &hasher.finalize())?;
92    Ok(0)
93}
94
95pub fn sol_sha256(
96    registers: [u64; 5],
97    memory: &mut Memory,
98    compute: &ComputeMeter,
99    costs: &ExecutionCost,
100) -> SbpfVmResult<u64> {
101    hash_slices::<Sha256>(
102        memory,
103        compute,
104        costs,
105        registers[0],
106        registers[1],
107        registers[2],
108    )
109}
110
111pub fn sol_keccak256(
112    registers: [u64; 5],
113    memory: &mut Memory,
114    compute: &ComputeMeter,
115    costs: &ExecutionCost,
116) -> SbpfVmResult<u64> {
117    hash_slices::<Keccak256>(
118        memory,
119        compute,
120        costs,
121        registers[0],
122        registers[1],
123        registers[2],
124    )
125}
126
127pub fn sol_blake3(
128    registers: [u64; 5],
129    memory: &mut Memory,
130    compute: &ComputeMeter,
131    costs: &ExecutionCost,
132) -> SbpfVmResult<u64> {
133    hash_slices::<Blake3Hasher>(
134        memory,
135        compute,
136        costs,
137        registers[0],
138        registers[1],
139        registers[2],
140    )
141}
sbpf_runtime/syscalls/crypto.rs

sbpf_runtime/syscalls/
crypto.rs
