Reversing the Exponential Trend of Software Vulnerabilities

We combine Formal Methods with Generative AI to mathematically prove the absence of runtime errors in C codes.

The Challenge

CVEs are growing exponentially.

Legacy testing is failing the CVE crisis. Our solution prove code correctness at scale and eliminate the economic burden of vulnerabilities.

90%

Automation Achieved

We have reached 90% automation for formal verification in the C language.

70%+

Targeted CVEs

We target runtime errors, which account for over 70% of all Common Vulnerabilities and Exposures.

Math

Proven Security

We drastically reduce the engineering cost to *mathematically prove* the absence of execution errors.

Restore Trust in Legacy Code

It is now possible to detect 100% of runtime errors in your legacy code and identify its validity domains. Regain total confidence in its utilization.

Found valid domain:
INPUT_MAX < 65535
No Buffer Overflows detected.

Methodology

The Shift to Modular Architecture

Our formal methods software naturally finds validity domains, driving a necessary shift in global software architecture.

The Monolithic Trap

The idea that software should share all structures and functions with zero redundancy collapses past one million lines.

  • Exponential maintenance cost with code size.
  • Polluted symbol tables lowering code flexibility.
  • Fragile implementation; changes break external components.
Recommended

Decoupled Blocks & Contracts

We advocate for architecture cut into blocks connected by a Directed Acyclic Graph (DAG), using the C ABI for precise control.

Block Size

Ideally under 10k LoC.

Exposure

Strict minimum of functions.

  • Flexible Implementation: Rewrite blocks entirely without affecting others if the contract is kept.
  • Formal Knowledge: Entry point conditions guarantee absence of runtime errors.

Synergy with Generative AI

This modular approach is crucial for leveraging modern AI. Generative AIs are highly performant on small code blocks but degrade when context becomes too large. By keeping blocks under 10k lines, AI's ability to generate valid code in one go is maximized.

A Future Without Execution Errors

We envision a future where C code is decomposed into independent blocks, connected via the C ABI, and verified by formal methods.

Eliminate 70% of CVEs

Complete removal of CVEs caused by runtime execution faults.

Reduce the remaining 30%

Drastic reduction in logic errors, as controlling flow in sub-10k line blocks is significantly simpler.