sha256 tests updated to c

circuits/sha256/sha256compression.circom

@@ -74,6 +74,9 @@ template Sha256compression() {
                 sigmaPlus[t-16].in7[k] <== w[t-7][k];
                 sigmaPlus[t-16].in15[k] <== w[t-15][k];
                 sigmaPlus[t-16].in16[k] <== w[t-16][k];
+            }
+
+            for (k=0; k<32; k++) {
                 w[t][k] <== sigmaPlus[t-16].out[k];
             }
         }

circuits/sha256/sigma.circom

@@ -24,22 +24,26 @@ include "shift.circom";
 template SmallSigma(ra, rb, rc) {
     signal input in[32];
     signal output out[32];
-
-    component xor3 = Xor3(32);
+    var k;
 
     component rota = RotR(32, ra);
     component rotb = RotR(32, rb);
     component shrc = ShR(32, rc);
 
-    for (var k=0; k<32; k++) {
+    for (k=0; k<32; k++) {
         rota.in[k] <== in[k];
         rotb.in[k] <== in[k];
         shrc.in[k] <== in[k];
+    }
 
+    component xor3 = Xor3(32);
+    for (k=0; k<32; k++) {
         xor3.a[k] <== rota.out[k];
         xor3.b[k] <== rotb.out[k];
         xor3.c[k] <== shrc.out[k];
+    }
 
+    for (k=0; k<32; k++) {
         out[k] <== xor3.out[k];
     }
 }
@@ -47,22 +51,26 @@ template SmallSigma(ra, rb, rc) {
 template BigSigma(ra, rb, rc) {
     signal input in[32];
     signal output out[32];
-
-    component xor3 = Xor3(32);
+    var k;
 
     component rota = RotR(32, ra);
     component rotb = RotR(32, rb);
     component rotc = RotR(32, rc);
-
-    for (var k=0; k<32; k++) {
+    for (k=0; k<32; k++) {
         rota.in[k] <== in[k];
         rotb.in[k] <== in[k];
         rotc.in[k] <== in[k];
+    }
 
+    component xor3 = Xor3(32);
+
+    for (k=0; k<32; k++) {
         xor3.a[k] <== rota.out[k];
         xor3.b[k] <== rotb.out[k];
         xor3.c[k] <== rotc.out[k];
+    }
 
+    for (k=0; k<32; k++) {
         out[k] <== xor3.out[k];
     }
 }

circuits/sha256/sigmaplus.circom

@@ -26,20 +26,24 @@ template SigmaPlus() {
     signal input in15[32];
     signal input in16[32];
     signal output out[32];
+    var k;
 
-    component sum = BinSum(32, 4);
     component sigma1 = SmallSigma(17,19,10);
     component sigma0 = SmallSigma(7, 18, 3);
-
-    for (var k=0; k<32; k++) {
+    for (k=0; k<32; k++) {
         sigma1.in[k] <== in2[k];
         sigma0.in[k] <== in15[k];
+    }
 
+    component sum = BinSum(32, 4);
+    for (k=0; k<32; k++) {
         sum.in[0][k] <== sigma1.out[k];
         sum.in[1][k] <== in7[k];
         sum.in[2][k] <== sigma0.out[k];
         sum.in[3][k] <== in16[k];
+    }
 
+    for (k=0; k<32; k++) {
         out[k] <== sum.out[k];
     }
 }

circuits/sha256/t1.circom

@@ -30,23 +30,28 @@ template T1() {
     signal input w[32];
     signal output out[32];
 
-    component sum = BinSum(32, 5);
-    component ch = Ch(32);
+    var ki;
 
+    component ch = Ch(32);
     component bigsigma1 = BigSigma(6, 11, 25);
 
-    for (var ki=0; ki<32; ki++) {
+    for (ki=0; ki<32; ki++) {
         bigsigma1.in[ki] <== e[ki];
         ch.a[ki] <== e[ki];
         ch.b[ki] <== f[ki];
-        ch.c[ki] <== g[ki]
+        ch.c[ki] <== g[ki];
+    }
 
+    component sum = BinSum(32, 5);
+    for (ki=0; ki<32; ki++) {
         sum.in[0][ki] <== h[ki];
         sum.in[1][ki] <== bigsigma1.out[ki];
         sum.in[2][ki] <== ch.out[ki];
         sum.in[3][ki] <== k[ki];
         sum.in[4][ki] <== w[ki];
+    }
 
+    for (ki=0; ki<32; ki++) {
         out[ki] <== sum.out[ki];
     }
 }

circuits/sha256/t2.circom

@@ -26,22 +26,25 @@ template T2() {
     signal input b[32];
     signal input c[32];
     signal output out[32];
-
-    component sum = BinSum(32, 2);
+    var k;
 
     component bigsigma0 = BigSigma(2, 13, 22);
     component maj = Maj(32);
-
-    for (var k=0; k<32; k++) {
-
+    for (k=0; k<32; k++) {
         bigsigma0.in[k] <== a[k];
         maj.a[k] <== a[k];
         maj.b[k] <== b[k];
         maj.c[k] <== c[k];
+    }
+
+    component sum = BinSum(32, 2);
 
+    for (k=0; k<32; k++) {
         sum.in[0][k] <== bigsigma0.out[k];
         sum.in[1][k] <== maj.out[k];
+    }
 
+    for (k=0; k<32; k++) {
         out[k] <== sum.out[k];
     }
 }

test/sha256.js

@@ -37,7 +37,7 @@ function bitArray2buffer(a) {
 describe("SHA256 test", function () {
     this.timeout(100000);
 
-/*
+
     it("Should work bits to array and array to bits", async () => {
         const b = new Buffer.alloc(64);
         for (let i=0; i<64; i++) {
@@ -50,13 +50,9 @@ describe("SHA256 test", function () {
     });
 
     it("Should calculate a hash of 1 compressor", async () => {
-        const cirDef = await compiler(path.join(__dirname, "circuits", "sha256_2_test.circom"));
-        const circuit = new snarkjs.Circuit(cirDef);
-
-        console.log("Vars: "+circuit.nVars);
-        console.log("Constraints: "+circuit.nConstraints);
+        const cir = await c_tester(path.join(__dirname, "circuits", "sha256_2_test.circom"));
 
-        const witness = circuit.calculateWitness({ "a": "1", "b": "2" });
+        const witness = await cir.calculateWitness({ "a": "1", "b": "2" });
 
         const b = new Buffer.alloc(54);
         b[26] = 1;
@@ -75,15 +71,8 @@ describe("SHA256 test", function () {
     }).timeout(1000000);
 
     it("Should calculate a hash of 2 compressor", async () => {
-        const cirDef = await compiler(path.join(__dirname, "circuits", "sha256_test512.circom"),  {reduceConstraints:false}  );
-        const circuit = new snarkjs.Circuit(cirDef);
-
-        console.log("Vars: "+circuit.nVars);
-        console.log("Constraints: "+circuit.nConstraints);
-
-        // const testStr = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
+        const cir = await c_tester(path.join(__dirname, "circuits", "sha256_test512.circom"));
 
-        // const b = Buffer.from(testStr, 'utf8');
         const b = new Buffer.alloc(64);
         for (let i=0; i<64; i++) {
             b[i] = i+1;
@@ -94,37 +83,7 @@ describe("SHA256 test", function () {
             .digest("hex");
 
         const arrIn = buffer2bitArray(b);
-        const witness = circuit.calculateWitness({ "in": arrIn } , {logOutput: false} );
-
-        const arrOut = witness.slice(1, 257);
-        const hash2 = bitArray2buffer(arrOut).toString("hex");
-
-        assert.equal(hash, hash2);
-
-    }).timeout(1000000);
-
-
-    it("Should calculate a hash of 2 compressor", async () => {
-        const cirDef = await compiler(path.join(__dirname, "circuits", "sha256_test448.circom"),  {reduceConstraints:false}  );
-        const circuit = new snarkjs.Circuit(cirDef);
-
-        console.log("Vars: "+circuit.nVars);
-        console.log("Constraints: "+circuit.nConstraints);
-
-
-        const testStr = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
-
-        const b = Buffer.from(testStr, 'utf8');
-        //  for (let i=0; i<64; i++) {
-        //    b[i] = i+1;
-        //  }
-
-        const hash = crypto.createHash("sha256")
-            .update(b)
-            .digest("hex");
-
-        const arrIn = buffer2bitArray(b);
-        const witness = circuit.calculateWitness({ "in": arrIn }, {logOutput: false});
+        const witness = await cir.calculateWitness({ "in": arrIn });
 
         const arrOut = witness.slice(1, 257);
         const hash2 = bitArray2buffer(arrOut).toString("hex");
@@ -132,7 +91,6 @@ describe("SHA256 test", function () {
         assert.equal(hash, hash2);
 
     }).timeout(1000000);
-*/
     it ("Should calculate a hash of 2 compressor", async () => {
         const cir = await c_tester(path.join(__dirname, "circuits", "sha256_test448.circom"));
 
@@ -146,7 +104,6 @@ describe("SHA256 test", function () {
 
         const arrIn = buffer2bitArray(b);
 
-        console.log(JSON.stringify({ "in": arrIn }));
         const witness = await cir.calculateWitness({ "in": arrIn });
 
         const arrOut = witness.slice(1, 257);