longfellow 0.1.0

data/vendor/longfellow-zk/lib/circuits/tests/base64/decode.h

@@ -0,0 +1,508 @@
+// Copyright 2026 Google LLC.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef PRIVACY_PROOFS_ZK_LIB_CIRCUITS_TESTS_BASE64_DECODE_H_
+#define PRIVACY_PROOFS_ZK_LIB_CIRCUITS_TESTS_BASE64_DECODE_H_
+
+#include <cstddef>
+#include <vector>
+
+#include "util/ceildiv.h"
+#include "util/panic.h"
+
+namespace proofs {
+
+// This class implements a circuit to assert a base64 url decoding.
+// A string in base64 consists of the characters A-Z a-z 0-9 - _ and =.
+// 0--25 are mapped to A-Z, 26--51 are mapped to a-z, 52--61 are mapped to 0-9,
+// and 62--63 are mapped to - and _ respectively.
+// The base64 encoding is padded with = to a multiple of 4.
+template <class LogicCircuit>
+class Base64Decoder {
+  using EltW = typename LogicCircuit::EltW;
+  using BitW = typename LogicCircuit::BitW;
+  using v8 = typename LogicCircuit::v8;
+  using v6 = typename LogicCircuit::template bitvec<6>;
+
+ public:
+  explicit Base64Decoder(const LogicCircuit& lc) : lc_(lc) {}
+
+  void base64_rawurl_decode(const v8 inputs[/*n*/],
+                            v8 output[/* ceil(n*6/8) */], size_t n) const {
+    check(n < (1 << 28), "input too large");  // avoid overflows
+    v6 zero = lc_.template vbit<6>(0);
+
+    size_t max = ceildiv<size_t>(n * 6, 8);
+    size_t oc = 0;
+
+    for (size_t i = 0; i < n; i += 4, oc += 3) {
+      v6 quad[4]{v6(zero), v6(zero), v6(zero), v6(zero)};
+      for (size_t j = 0; j < 4 && i + j < n; ++j) {
+        decode(inputs[i + j], quad[j]);
+      }
+      // repack
+      for (size_t j = 0; j < 24 && (oc + j / 8) < max; ++j) {
+        output[oc + j / 8][7 - (j % 8)] = quad[j / 6][5 - (j % 6)];
+      }
+    }
+  }
+
+  template <size_t N>
+  void base64_rawurl_decode_len(
+      const v8 inputs[/*n*/], v8 output[/* ceil(n*6/8) */], size_t n,
+      typename LogicCircuit::template bitvec<N>& len) const {
+    check(n < (1 << 28), "input too large");  // avoid overflows
+    v6 zero = lc_.template vbit<6>(0);
+
+    size_t max = ceildiv<size_t>(n * 6, 8);
+    size_t oc = 0;
+
+    for (size_t i = 0; i < n; i += 4, oc += 3) {
+      v6 quad[4]{v6(zero), v6(zero), v6(zero), v6(zero)};
+      BitW invalid;
+      for (size_t j = 0; j < 4 && i + j < n; ++j) {
+        decode(inputs[i + j], quad[j], invalid);
+        auto range = lc_.vlt(i + j, len);
+        lc_.assert_implies(range, lc_.lnot(invalid));
+      }
+      // repack
+      for (size_t j = 0; j < 24 && (oc + j / 8) < max; ++j) {
+        output[oc + j / 8][7 - (j % 8)] = quad[j / 6][5 - (j % 6)];
+      }
+    }
+  }
+
+  void decode(const v8& in, v6& out) const {
+    BitW invalid;
+    decode(in, out, invalid);
+    lc_.assert0(invalid);
+  }
+
+  void decode(const v8& in, v6& out, BitW& invalid) const {
+    v8 ni;
+    for (size_t i = 0; i < 8; ++i) {
+      ni[i] = lc_.lnot(in[i]);
+    }
+    std::vector<std::vector<BitW> > exp[] = {
+        {
+            //  ['!v4', '!v3', '!v2', '!v1', '!v0']
+            {
+                ni[4],
+                ni[3],
+                ni[2],
+                ni[1],
+                ni[0],
+            },
+            //  ['v4', 'v3', '!v2', 'v1', 'v0']
+            {
+                in[4],
+                in[3],
+                ni[2],
+                in[1],
+                in[0],
+            },
+            //  ['v5', 'v4', 'v3', 'v1', 'v0']
+            {
+                in[5],
+                in[4],
+                in[3],
+                in[1],
+                in[0],
+            },
+            //  ['!v6', 'v3', 'v2', '!v0']
+            {
+                ni[6],
+                in[3],
+                in[2],
+                ni[0],
+            },
+            //  ['v4', 'v3', 'v2', '!v1']
+            {
+                in[4],
+                in[3],
+                in[2],
+                ni[1],
+            },
+            //  ['v4', 'v3', 'v2', '!v0']
+            {
+                in[4],
+                in[3],
+                in[2],
+                ni[0],
+            },
+            //  ['!v6', '!v4', '!v3']
+            {
+                ni[6],
+                ni[4],
+                ni[3],
+            },
+            //  ['!v6', '!v4', '!v2']
+            {
+                ni[6],
+                ni[4],
+                ni[2],
+            },
+            //  ['!v6', 'v3', 'v1']
+            {
+                ni[6],
+                in[3],
+                in[1],
+            },
+            //  ['!v6', '!v5']
+            {
+                ni[6],
+                ni[5],
+            },
+            //  ['v7']
+            {
+                in[7],
+            },
+        },
+        {
+            //  ['v6', 'v5', 'v4', '!v3', '!v2']
+            {
+                in[6],
+                in[5],
+                in[4],
+                ni[3],
+                ni[2],
+            },
+            //  ['v6', 'v5', 'v4', '!v3', '!v0']
+            {
+                in[6],
+                in[5],
+                in[4],
+                ni[3],
+                ni[0],
+            },
+            //  ['v6', 'v5', 'v4', 'v2', '!v1']
+            {
+                in[6],
+                in[5],
+                in[4],
+                in[2],
+                ni[1],
+            },
+            //  ['v5', 'v2', 'v1', 'v0']
+            {
+                in[5],
+                in[2],
+                in[1],
+                in[0],
+            },
+            //  ['v4', 'v3', 'v1', 'v0']
+            {
+                in[4],
+                in[3],
+                in[1],
+                in[0],
+            },
+            //  ['v5', 'v3']
+            {
+                in[5],
+                in[3],
+            },
+            //  ['!v6', '!v2']
+            {
+                ni[6],
+                ni[2],
+            },
+            //  ['!v6', 'v2']
+            {
+                ni[6],
+                in[2],
+            },
+        },
+        {
+            //  ['v5', '!v4', '!v3', '!v1']
+            {
+                in[5],
+                ni[4],
+                ni[3],
+                ni[1],
+            },
+            //  ['v5', '!v4', '!v3', '!v2']
+            {
+                in[5],
+                ni[4],
+                ni[3],
+                ni[2],
+            },
+            //  ['!v5', 'v4', 'v1']
+            {
+                ni[5],
+                in[4],
+                in[1],
+            },
+            //  ['v5', '!v4', '!v3', '!v0']
+            {
+                in[5],
+                ni[4],
+                ni[3],
+                ni[0],
+            },
+            //  ['v4', 'v2', 'v1', 'v0']
+            {
+                in[4],
+                in[2],
+                in[1],
+                in[0],
+            },
+            //  ['!v5', 'v4', 'v0']
+            {
+                ni[5],
+                in[4],
+                in[0],
+            },
+            //  ['!v5', 'v4', 'v2']
+            {
+                ni[5],
+                in[4],
+                in[2],
+            },
+            //  ['v4', 'v3']
+            {
+                in[4],
+                in[3],
+            },
+            //  ['!v6', '!v2']
+            {
+                ni[6],
+                ni[2],
+            },
+            //  ['!v6', 'v2']
+            {
+                ni[6],
+                in[2],
+            },
+        },
+        {
+            //  ['v6', '!v3', '!v2', '!v1', '!v0']
+            {
+                in[6],
+                ni[3],
+                ni[2],
+                ni[1],
+                ni[0],
+            },
+            //  ['v6', 'v5', 'v4', '!v3', '!v2']
+            {
+                in[6],
+                in[5],
+                in[4],
+                ni[3],
+                ni[2],
+            },
+            //  ['v6', 'v5', 'v4', '!v3', '!v0']
+            {
+                in[6],
+                in[5],
+                in[4],
+                ni[3],
+                ni[0],
+            },
+            //  ['v6', 'v5', 'v4', 'v2', '!v1']
+            {
+                in[6],
+                in[5],
+                in[4],
+                in[2],
+                ni[1],
+            },
+            //  ['v5', '!v4', '!v3', '!v1']
+            {
+                in[5],
+                ni[4],
+                ni[3],
+                ni[1],
+            },
+            //  ['v5', '!v4', '!v3', '!v2']
+            {
+                in[5],
+                ni[4],
+                ni[3],
+                ni[2],
+            },
+            //  ['v5', '!v4', '!v3', '!v0']
+            {
+                in[5],
+                ni[4],
+                ni[3],
+                ni[0],
+            },
+            //  ['!v5', 'v3', 'v1']
+            {
+                ni[5],
+                in[3],
+                in[1],
+            },
+            //  ['v3', 'v2', 'v1', 'v0']
+            {
+                in[3],
+                in[2],
+                in[1],
+                in[0],
+            },
+            //  ['!v5', 'v3', 'v0']
+            {
+                ni[5],
+                in[3],
+                in[0],
+            },
+            //  ['!v5', 'v3', 'v2']
+            {
+                ni[5],
+                in[3],
+                in[2],
+            },
+            //  ['!v6', 'v3']
+            {
+                ni[6],
+                in[3],
+            },
+            //  ['!v6', 'v2']
+            {
+                ni[6],
+                in[2],
+            },
+        },
+        {
+            //  ['v5', '!v4', 'v2', '!v1', 'v0']
+            {
+                in[5],
+                ni[4],
+                in[2],
+                ni[1],
+                in[0],
+            },
+            //  ['v6', 'v5', 'v4', 'v2', '!v1']
+            {
+                in[6],
+                in[5],
+                in[4],
+                in[2],
+                ni[1],
+            },
+            //  ['!v5', '!v2', '!v1', '!v0']
+            {
+                ni[5],
+                ni[2],
+                ni[1],
+                ni[0],
+            },
+            //  ['v6', 'v5', 'v2', '!v0']
+            {
+                in[6],
+                in[5],
+                in[2],
+                ni[0],
+            },
+            //  ['v5', '!v2', 'v1', 'v0']
+            {
+                in[5],
+                ni[2],
+                in[1],
+                in[0],
+            },
+            //  ['!v5', 'v2', 'v0']
+            {
+                ni[5],
+                in[2],
+                in[0],
+            },
+            //  ['!v5', 'v2', 'v1']
+            {
+                ni[5],
+                in[2],
+                in[1],
+            },
+            //  ['!v6', '!v2']
+            {
+                ni[6],
+                ni[2],
+            },
+        },
+        {
+            //  ['v5', '!v4', 'v2', '!v1', 'v0']
+            {
+                in[5],
+                ni[4],
+                in[2],
+                ni[1],
+                in[0],
+            },
+            //  ['v6', 'v5', '!v1', 'v0']
+            {
+                in[6],
+                in[5],
+                ni[1],
+                in[0],
+            },
+            //  ['!v5', '!v1', '!v0']
+            {
+                ni[5],
+                ni[1],
+                ni[0],
+            },
+            //  ['!v5', 'v1', 'v0']
+            {
+                ni[5],
+                in[1],
+                in[0],
+            },
+            //  ['v5', 'v1', '!v0']
+            {
+                in[5],
+                in[1],
+                ni[0],
+            },
+            //  ['!v6', 'v1']
+            {
+                ni[6],
+                in[1],
+            },
+        },
+        {
+            //  ['v4', 'v3', 'v1', 'v0']
+            {
+                in[4],
+                in[3],
+                in[1],
+                in[0],
+            },
+            //  ['!v6', 'v4', 'v0']
+            {
+                ni[6],
+                in[4],
+                in[0],
+            },
+            //  ['v6', '!v0']
+            {
+                in[6],
+                ni[0],
+            },
+        },
+    };
+    invalid = lc_.or_of_and(exp[0]);
+    for (size_t i = 0; i < 6; ++i) {
+      out[5 - i] = lc_.or_of_and(exp[i + 1]);
+    }
+  }
+
+ private:
+  const LogicCircuit& lc_;
+};
+}  // namespace proofs
+
+#endif  // PRIVACY_PROOFS_ZK_LIB_CIRCUITS_TESTS_BASE64_DECODE_H_

data/vendor/longfellow-zk/lib/circuits/tests/base64/decode_circuit_test.cc

@@ -0,0 +1,95 @@
+// Copyright 2026 Google LLC.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <cstddef>
+#include <cstring>
+#include <memory>
+#include <string>
+
+#include "arrays/dense.h"
+#include "circuits/compiler/circuit_dump.h"
+#include "circuits/compiler/compiler.h"
+#include "circuits/logic/compiler_backend.h"
+#include "circuits/logic/evaluation_backend.h"
+#include "circuits/logic/logic.h"
+#include "circuits/tests/base64/decode.h"
+#include "gf2k/gf2_128.h"
+#include "sumcheck/prover.h"
+#include "gtest/gtest.h"
+
+namespace proofs {
+namespace {
+
+typedef GF2_128<> Field;
+const Field F;
+
+using CompilerBackend = CompilerBackend<Field>;
+using LogicCircuit = Logic<Field, CompilerBackend>;
+
+using EvaluationBackend = EvaluationBackend<Field>;
+using Logic = Logic<Field, EvaluationBackend>;
+
+TEST(Base64, Circuit) {
+  QuadCircuit<Field> Q(F);
+  const CompilerBackend cbk(&Q);
+  const LogicCircuit LC(&cbk, F);
+  const EvaluationBackend ebk(F);
+  const Logic L(&ebk, F);
+  constexpr size_t nc = 1;
+
+  using v8 = LogicCircuit::v8;
+  using v6 = LogicCircuit::template bitvec<6>;
+
+  Base64Decoder<LogicCircuit> bd(LC);
+
+  v8 in = LC.vinput<8>();
+  v6 out;
+
+  bd.decode(in, out);
+  LC.voutput(out, 0);
+
+  auto CIRCUIT = Q.mkcircuit(nc);
+  dump_info<Field>("Base64Decoder", nc, Q);
+
+  // now evaluate the circuit on all inputs
+  std::string valid =
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+
+  // Loop over all input symbols.
+  for (size_t c = 0; c < 256; ++c) {
+    auto win = L.template vbit<8>(c);
+    auto W = std::make_unique<Dense<Field>>(nc, /*constant one*/ 1 + 8);
+    W->v_[0] = F.one();
+    for (size_t i = 0; i < 8; ++i) {
+      W->v_[1 + i] = L.eval(win[i]).elt();
+    }
+
+    Prover<Field>::inputs pin;
+    Prover<Field> prover(F);
+    auto V = prover.eval_circuit(&pin, CIRCUIT.get(), W->clone(), F);
+
+    size_t ind = valid.find(c);
+    if (ind != std::string::npos) {
+      auto want = L.template vbit<6>(ind);
+      for (size_t i = 0; i < 6; ++i) {
+        EXPECT_EQ(V->v_[i], L.eval(want[i]).elt());
+      }
+    } else {
+      EXPECT_EQ(V, nullptr);
+    }
+  }
+}
+
+}  // namespace
+}  // namespace proofs