pub type Digest = [u8; 32];
pub const ZERO_DIGEST: Digest = [0u8; 32];
pub const SEAL_LEN: usize = 4 + 256;
pub trait Sha256: Copy {
fn hash(&self, bytes: &[u8]) -> Digest;
}
impl<F: Fn(&[u8]) -> Digest + Copy> Sha256 for F {
fn hash(&self, bytes: &[u8]) -> Digest {
self(bytes)
}
}
#[cfg(feature = "sha2")]
#[derive(Clone, Copy, Debug, Default)]
pub struct Sha2Hasher;
#[cfg(feature = "sha2")]
impl Sha256 for Sha2Hasher {
fn hash(&self, bytes: &[u8]) -> Digest {
use sha2::Digest as _;
let mut hasher = sha2::Sha256::new();
hasher.update(bytes);
hasher.finalize().into()
}
}
pub fn tagged_struct<H: Sha256>(sha: H, tag: &str, down: &[Digest], data: &[u32]) -> Digest {
assert!(
down.len() <= MAX_DOWN,
"tagged_struct takes at most 4 down digests"
);
assert!(
data.len() <= MAX_DATA,
"tagged_struct takes at most 2 data words"
);
let mut buf = [0u8; TAGGED_STRUCT_CAPACITY];
let mut n = 0usize;
let tag_digest = sha.hash(tag.as_bytes());
buf[n..n + 32].copy_from_slice(&tag_digest);
n += 32;
for digest in down {
buf[n..n + 32].copy_from_slice(digest);
n += 32;
}
for word in data {
buf[n..n + 4].copy_from_slice(&word.to_le_bytes());
n += 4;
}
let count = down.len() as u16;
buf[n..n + 2].copy_from_slice(&count.to_le_bytes());
n += 2;
sha.hash(&buf[..n])
}
const MAX_DOWN: usize = 4;
const MAX_DATA: usize = 2;
const TAGGED_STRUCT_CAPACITY: usize = 32 + 32 * MAX_DOWN + 4 * MAX_DATA + 2;
pub fn system_state_digest<H: Sha256>(sha: H, merkle_root: &Digest, pc: u32) -> Digest {
tagged_struct(sha, "risc0.SystemState", &[*merkle_root], &[pc])
}
pub fn halted_post_state_digest<H: Sha256>(sha: H) -> Digest {
system_state_digest(sha, &ZERO_DIGEST, 0)
}
pub fn output_digest<H: Sha256>(sha: H, journal_digest: &Digest) -> Digest {
tagged_struct(sha, "risc0.Output", &[*journal_digest, ZERO_DIGEST], &[])
}
pub fn journal_digest<H: Sha256>(sha: H, journal: &[u8]) -> Digest {
sha.hash(journal)
}
pub fn receipt_claim_ok_digest<H: Sha256>(sha: H, image_id: &Digest, journal: &[u8]) -> Digest {
let output = output_digest(sha, &journal_digest(sha, journal));
tagged_struct(
sha,
"risc0.ReceiptClaim",
&[
ZERO_DIGEST, *image_id, halted_post_state_digest(sha), output,
],
&[0, 0], )
}
pub fn split_digest(digest: &Digest) -> ([u8; 16], [u8; 16]) {
let mut reversed = [0u8; 32];
for (i, byte) in digest.iter().rev().enumerate() {
reversed[i] = *byte;
}
let mut hi = [0u8; 16];
let mut lo = [0u8; 16];
hi.copy_from_slice(&reversed[0..16]);
lo.copy_from_slice(&reversed[16..32]);
(lo, hi)
}
pub fn scalar_from_u128_be(value: &[u8; 16]) -> Digest {
let mut out = [0u8; 32];
out[16..32].copy_from_slice(value);
out
}
pub fn groth16_public_inputs(
control_root: &Digest,
claim_digest: &Digest,
bn254_control_id: &Digest,
) -> [Digest; 5] {
let (root_lo, root_hi) = split_digest(control_root);
let (claim_lo, claim_hi) = split_digest(claim_digest);
[
scalar_from_u128_be(&root_lo),
scalar_from_u128_be(&root_hi),
scalar_from_u128_be(&claim_lo),
scalar_from_u128_be(&claim_hi),
reverse_bytes(bn254_control_id),
]
}
pub fn reverse_bytes(digest: &Digest) -> Digest {
let mut out = [0u8; 32];
for (i, byte) in digest.iter().rev().enumerate() {
out[i] = *byte;
}
out
}
pub fn selector_from_params_digest(params_digest: &Digest) -> [u8; 4] {
[
params_digest[0],
params_digest[1],
params_digest[2],
params_digest[3],
]
}
pub fn groth16_verifier_parameters_digest<H: Sha256>(
sha: H,
control_root: &Digest,
bn254_control_id: &Digest,
verifying_key_digest: &Digest,
) -> Digest {
tagged_struct(
sha,
"risc0.Groth16ReceiptVerifierParameters",
&[*control_root, *bn254_control_id, *verifying_key_digest],
&[],
)
}
#[cfg(all(test, feature = "sha2"))]
mod tests {
use super::*;
#[cfg(not(feature = "std"))]
use alloc::vec::Vec;
fn sha256(bytes: &[u8]) -> Digest {
Sha2Hasher.hash(bytes)
}
#[test]
fn tagged_struct_matches_manual_construction() {
let down = [[1u8; 32], [2u8; 32]];
let data = [7u32, 9u32];
let mut expected = Vec::new();
expected.extend_from_slice(&sha256(b"tag"));
expected.extend_from_slice(&down[0]);
expected.extend_from_slice(&down[1]);
expected.extend_from_slice(&7u32.to_le_bytes());
expected.extend_from_slice(&9u32.to_le_bytes());
expected.extend_from_slice(&2u16.to_le_bytes());
assert_eq!(
tagged_struct(Sha2Hasher, "tag", &down, &data),
sha256(&expected)
);
}
#[test]
fn split_digest_reverses_then_splits() {
let mut digest = [0u8; 32];
for (i, byte) in digest.iter_mut().enumerate() {
*byte = i as u8;
}
let (lo, hi) = split_digest(&digest);
assert_eq!(hi[0], 31);
assert_eq!(hi[15], 16);
assert_eq!(lo[0], 15);
assert_eq!(lo[15], 0);
}
#[test]
fn scalars_are_zero_extended() {
let value = [0xabu8; 16];
let scalar = scalar_from_u128_be(&value);
assert_eq!(&scalar[0..16], &[0u8; 16]);
assert_eq!(&scalar[16..32], &value);
}
#[test]
fn public_inputs_have_five_scalars_and_a_reversed_control_id() {
let inputs = groth16_public_inputs(&[1u8; 32], &[2u8; 32], &[3u8; 32]);
assert_eq!(inputs.len(), 5);
let mut control_id = [0u8; 32];
control_id[0] = 0xaa;
control_id[31] = 0xbb;
let inputs = groth16_public_inputs(&[1u8; 32], &[2u8; 32], &control_id);
assert_eq!(inputs[4][0], 0xbb);
assert_eq!(inputs[4][31], 0xaa);
}
#[test]
fn claim_digest_changes_with_journal_and_image() {
let a = receipt_claim_ok_digest(Sha2Hasher, &[1u8; 32], b"hello");
let b = receipt_claim_ok_digest(Sha2Hasher, &[1u8; 32], b"hell0");
let c = receipt_claim_ok_digest(Sha2Hasher, &[2u8; 32], b"hello");
assert_ne!(a, b);
assert_ne!(a, c);
}
#[test]
fn selector_is_the_first_four_bytes() {
let digest = [9u8; 32];
assert_eq!(selector_from_params_digest(&digest), [9u8, 9, 9, 9]);
}
#[test]
#[should_panic(expected = "at most 4 down digests")]
fn too_many_down_digests_is_refused_rather_than_truncated() {
tagged_struct(Sha2Hasher, "x", &[[0u8; 32]; 5], &[]);
}
#[test]
#[should_panic(expected = "at most 2 data words")]
fn too_many_data_words_is_refused_rather_than_truncated() {
tagged_struct(Sha2Hasher, "x", &[], &[1, 2, 3]);
}
#[test]
fn a_closure_works_as_the_hasher() {
let closure = |bytes: &[u8]| -> Digest { Sha2Hasher.hash(bytes) };
assert_eq!(
receipt_claim_ok_digest(closure, &[7u8; 32], b"journal"),
receipt_claim_ok_digest(Sha2Hasher, &[7u8; 32], b"journal")
);
}
}