We raced FHE and Garbled Circuits...see who won!

Over the past month, our team has made significant strides in enhancing the compute capabilities of our protocol, expanding our developer tools, and exploring new partnerships and use cases. We're excited to share these developments with our community, showcasing how we're making secure computation more accessible and efficient.

Transition to a Maliciously Secure Garbled Circuits Engine

A major milestone this month was the successful integration of a new garbled circuits primitive that is maliciously secure. Previously, we utilized a scheme that was semi-honest (requiring some degree of trust between different parties), which served as a valuable starting point. However, to meet our goals for security and performance, we sought a solution that offers stronger guarantees and better scalability.

Why?

• Malicious Security in 2PC: This approach provides malicious security in a two-party computation (2PC) setting. This means that even if one party behaves dishonestly, the protocol ensures the integrity and confidentiality of the computation.
• Enhanced Performance: This approach is optimized for efficiency, accelerating computation times, and making encrypted computations more practical for real-world applications.
• Robust Functionality: Supports a wide range of arithmetic operations, aligning with our vision to enable complex, secure computations.

Implementing Comprehensive Arithmetic Operations

Building on the engine’s capabilities, we've successfully implemented a suite of essential arithmetic and logical operations:

• Arithmetic Operations: Addition, Subtraction, Multiplication, Division, Remainder, Exponentiation
• Comparison Operators: Equal to, Not Equal to, Greater Than, Less Than, Greater Than or Equal To, Less Than or Equal To

An example use case could be an organization that wants to determine how many users have a blood pressure reading greater than 120 without accessing individual readings.

Furthermore, we've made progress on composable circuits, allowing us to combine multiple operations into a single circuit. This advancement reduces the number of communication rounds and improves performance, enabling computations like the following to be executed efficiently in one step.

Introducing the Gateway Compute SDK: Simplifying Secure Computation

To make these advanced capabilities accessible, we've developed an abstraction layer: Gateway Compute SDK. This tool allows developers to write computations in a familiar, intuitive manner while handling the underlying complexities of secure computation.

Key Features of the SDK

• Intuitive Syntax: Write code using standard programming constructs without needing deep cryptographic expertise.
• Type Support: Currently supports unsigned integers, with plans to expand to more data types.
• Composable Operations: Supports composable circuits, enabling complex expressions and algorithms to be implemented seamlessly.
• Seamless Integration: Easily incorporates into existing development workflows, reducing the learning curve.

By abstracting the intricate details, the SDK empowers developers to focus on innovation, accelerating the adoption of privacy-preserving technologies.

Networking Advancements

We've also enhanced the networking capabilities of our compute layer. By establishing secure gRPC communication between garbler and evaluator nodes, we enable distributed computation across different machines. This networking feature allows computations to be performed efficiently in a decentralized environment, further strengthening the robustness of our protocol.

Benchmarking Success

Efficiency is crucial for the practicality of secure computation. Our benchmarks indicate that our garbled circuits approach offers significant performance improvements over traditional methods like Fully Homomorphic Encryption (FHE). For instance, operations like exponentiation in our system are faster than multiplication in other schemes. This advancement brings us closer to real-time secure computations, opening doors to applications previously considered impractical due to computational overhead.

Enhancing Integration and User Experience

Beyond developing the core computation capabilities, we've focused on improving the overall user experience:

• Storage SDK Enhancements: We've developed new SDKs in JavaScript, Rust, and Go, providing developers with flexible tools to integrate our protocol into their applications.
• Dashboard Updates: Our user dashboard has been refined for better usability, including bug fixes and improved data visualization, making it easier for users to manage their data assets.
• Robust Testing: Extensive integration testing guarantees that all components work harmoniously, providing a reliable foundation for developers.

Exploring Future Directions

While garbled circuits offer significant advantages, we recognize the limitations in certain use cases, such as private AI inferences, where performance constraints exist. For example, executing AI model inferences using garbled circuits or FHE can be prohibitively slow.

We are exploring the integration of other cryptographic primitives, such as Trusted Execution Environments (TEEs) and proxy re-encryption, to expand the range of applications we can support. By adopting a flexible approach that leverages the strengths of different technologies, we aim to provide a comprehensive solution for secure computation, accommodating a variety of computational needs and use cases.

Looking Ahead

Our journey doesn't stop here. We are committed to:

• Expanding Functionality: Incorporating more complex data types and operations to handle a broader range of computations.
• Optimizing Performance: Continuously improving efficiency to support more demanding applications.
• Enhancing Developer Tools: Further refining our SDKs, documentation, and APIs to make integration seamless.
• Collaborative Innovation: Partnering with organizations to explore new use cases in areas like privacy-preserving analytics and secure data sharing.
• Infrastructure Efficiency: Ongoing efforts to optimize our infrastructure for cost-effectiveness and scalability.

Conclusion

The progress we've made in October represents a significant leap forward in our mission to make secure computation accessible and practical. By integrating a maliciously secure garbled circuits engine, implementing comprehensive arithmetic operations, enhancing our developer tools, and exploring new partnerships, we're paving the way for a new era of privacy-preserving applications.

We are excited about the possibilities these advancements unlock and remain dedicated to driving innovation in secure computation. Thank you for your continued support as we work towards a future where data privacy and functionality go hand in hand.