fixes

shake256-33bytes-demo/.gitignore

@@ -0,0 +1,4 @@
+/target
+**/target
+/target 2
+**/target 2

shake256-33bytes-demo/Cargo.toml

@@ -24,12 +24,9 @@ rand = "0.8"
 cipher = { version = "0.4", features = ["std"] }
 serde = { version = "1", default-features = false, features = ["derive", "alloc"] }
 
-
-[build-dependencies]
-risc0-build = "2.3.1"
-
 [package.metadata.risc0]
 methods = ["methods/guest"]
 
-[lints.rust]
+
-unexpected_cfgs = { level = "allow", check-cfg = ['cfg(rust_analyzer)'] }
+[build-dependencies]
+risc0-build = "2.3.1"

shake256-33bytes-demo/methods/Cargo.toml

@@ -7,4 +7,4 @@ edition = "2021"
 risc0-build = { version = "2.3.1" }
 
 [package.metadata.risc0]
-methods = ["methods/guest"]
+methods = ["guest"]

shake256-33bytes-demo/methods/guest/src/main.rs

@@ -70,20 +70,29 @@ mod crypto {
         out_index: u32,
     ) -> [u8; 32] {
         let mut hasher = Sha256::new();
+<<<<<<< HEAD
         hasher.update( b"NSSA/v0.1/KDF-SHA256");
         sha2::Digest::update(&mut hasher, &ss_bytes);
         sha2::Digest::update(&mut hasher, &epk[..]);
         sha2::Digest::update(&mut hasher, &ipk[..]);
         sha2::Digest::update(&mut hasher, &commitment[..]);
         sha2::Digest::update(&mut hasher, &out_index.to_le_bytes());
+=======
+        hasher.update(b"NSSA/v0.1/KDF-SHA256");
+        hasher.update(&ss_bytes);
+        hasher.update(&epk[..]);
+        hasher.update(&ipk[..]);
+        hasher.update(&commitment[..]);
+        hasher.update(&out_index.to_le_bytes());
+>>>>>>> 998382a (fixes)
         hasher.finalize().into()
     }
 
     pub fn enc_xor_shake256(key: &[u8; 32], info: &[u8], pt: &[u8]) -> Vec<u8> {
         let mut sh = Shake::v256();
-        tiny_keccak::Hasher::update(&mut sh, b"NSSA/v0.1/shake-ks");
+        sh.update(b"NSSA/v0.1/shake-ks");
-        tiny_keccak::Hasher::update(&mut sh, &key[..]);
+        sh.update(&key[..]);
-        tiny_keccak::Hasher::update(&mut sh, info);
+        sh.update(info);
 
         let mut ks = vec![0u8; pt.len()];
         sh.finalize(&mut ks);

shake256-33bytes-demo/methods/src/lib.rs

@@ -0,0 +1 @@
+include!(concat!(env!("OUT_DIR"), "/methods.rs"));

shake256-33bytes-demo/methods/src/main.rs

@@ -1,83 +0,0 @@
-#![no_std]
-#![no_main]
-
-extern crate alloc;
-
-use alloc::vec::Vec;
-use hkdf::Hkdf;
-use risc0_zkvm::guest::env;
-use risc0_zkvm::guest::entry;
-use serde::{Deserialize, Serialize};
-use sha2::{Digest, Sha256};
-use sha3::{digest::{ExtendableOutput, Update, XofReader}, Shake256};
-
-entry!(main);
-
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct EncInput {
-    pub plaintext: Vec<u8>,
-    pub ss_bytes: [u8; 32],
-    pub epk_bytes: Vec<u8>,
-    pub ipk_bytes: Vec<u8>,
-    pub commitment: [u8; 32],
-    pub out_index: u32,
-}
-
-fn nssa_kdf(
-    ss_bytes: &[u8; 32],
-    epk: &[u8; 32],
-    ipk: &[u8; 32],
-    commitment: &[u8; 32],
-    out_index: u32,
-) -> ([u8; 32], Vec<u8>) {
-    // salt = SHA256("NSSA/v0.1/KDF-SHA256")
-    let mut hasher = Sha256::new();
-    hasher.update(b"NSSA/v0.1/KDF-SHA256");
-    let salt = hasher.finalize();
-
-    let hk = Hkdf::<Sha256>::new(Some(&salt), ss_bytes);
-
-    // info = "NSSA/v0.1/enc" || Epk || Ipk || commitment || le(out_index)
-    let mut info = Vec::with_capacity(3 + 33 + 33 + 32 + 4 + 16);
-    info.extend_from_slice(b"NSSA/v0.1/enc");
-    info.extend_from_slice(epk);
-    info.extend_from_slice(ipk);
-    info.extend_from_slice(commitment);
-    info.extend_from_slice(&out_index.to_le_bytes());
-
-    let mut k_enc = [0u8; 32];
-    hk.expand(&info, &mut k_enc).unwrap();
-
-    (k_enc, info)
-}
-
-fn enc_xor_shake256(k_enc: &[u8; 32], ad: &[u8], pt: &[u8]) -> Vec<u8> {
-    let mut shake = Shake256::default();
-    shake.update(b"NSSA/v0.1/ENC/SHAKE256");
-    shake.update(k_enc);
-    shake.update(ad);
-    let mut xof = shake.finalize_xof();
-
-    let mut ks = vec![0u8; pt.len()];
-    xof.read(&mut ks);
-
-    pt.iter().zip(ks).map(|(p, k)| p ^ k).collect()
-}
-
-pub fn main() {
-    let input: EncInput = env::read();
-
-    let (k_enc, info) = nssa_kdf(
-        &input.ss_bytes,
-        &input.epk_compressed,
-        &input.ipk_compressed,
-        &input.commitment,
-        input.out_index,
-    );
-
-    let ct = enc_xor_shake256(&k_enc, &info, &input.plaintext);
-
-    // Commit ciphertext to the journal
-    env::commit_slice(&ct);
-}

shake256-33bytes-demo/src/lib.rs

@@ -1,11 +1,9 @@
-use serde::{Deserialize, Serialize};
-
-// ---------- expose generated guest constants ----------  
 pub mod methods {
     include!(concat!(env!("OUT_DIR"), "/methods.rs"));
 }
-// -------------------------------------------------------
 
+
+use serde::{Deserialize, Serialize};
 // ---------- 33-byte wrapper (public) ----------
 pub mod ser_bytes33 {                // (public so main.rs can use it)
     use core::fmt;
@@ -61,20 +59,20 @@ pub mod crypto {                         // makes the module public
         out_index: u32,
     ) -> [u8; 32] {
         let mut hasher = Sha256::new();
-        sha2::Digest::update(&mut hasher, b"NSSA/v0.1/KDF-SHA256");
+        hasher.update(b"NSSA/v0.1/KDF-SHA256");
-        sha2::Digest::update(&mut hasher, &ss_bytes);
+        hasher.update(&ss_bytes);
-        sha2::Digest::update(&mut hasher, &epk[..]);
+        hasher.update(&epk[..]);
-        sha2::Digest::update(&mut hasher, &ipk[..]);
+        hasher.update(&ipk[..]);
-        sha2::Digest::update(&mut hasher, &commitment[..]);
+        hasher.update(&commitment[..]);
-        sha2::Digest::update(&mut hasher, &out_index.to_le_bytes());
+        hasher.update(&out_index.to_le_bytes());
         hasher.finalize().into()
     }
 
     pub fn enc_xor_shake256(key: &[u8; 32], info: &[u8], pt: &[u8]) -> Vec<u8> {
         let mut sh = Shake::v256();
-        tiny_keccak::Hasher::update(&mut sh, b"NSSA/v0.1/shake-ks");
+        sh.update(b"NSSA/v0.1/shake-ks");
-        tiny_keccak::Hasher::update(&mut sh, &key[..]);
+        sh.update(&key[..]);
-        tiny_keccak::Hasher::update(&mut sh, info);
+        sh.update(info);
 
         let mut ks = vec![0u8; pt.len()];
         sh.finalize(&mut ks);
@@ -100,6 +98,7 @@ pub struct EncInput {
     pub commitment: [u8; 32],
     pub out_index: u32,
 }
+
 // ------------------------------------------------------------
 
 pub fn build_info(epk: &Bytes33, ipk: &Bytes33) -> Vec<u8> {

shake256-33bytes-demo/src/main.rs

@@ -35,8 +35,7 @@ fn main() -> anyhow::Result<()> {
     0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,
     0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,0x40,
 ];
-
+let input = EncInput {
-    let input = EncInput {
         ss_bytes,
         epk_bytes: Bytes33::from(epk_raw), 
         ipk_bytes: Bytes33::from(ipk_raw),