Midair platform

Your personal fabric of tests static analyzer QA engineer AI feedback loop in minutes

For embedded devices, high-performance servers, complex environments, and virtually any software in the world.

Three-layer confidence in cybersecurity through static analysis, testing and runtime monitoring

Midair code view: findings and complexity over a repository
Midair test run: the suite tree beside the live run log
Midair node view: connection and agent details for a host

Static analysis

Validate source code through model checking, abstract interpretation and SMT solvers.

Testing

Validate that a fleet of devices and hosts works as expected in the whole product.

Runtime

Validate that every device and host does what is expected.

Automatically creating advanced tests? Yes, and that is pure magic.

gateway/src/handler.rs
pub fn handle(ctx: &Ctx, req: &Request) -> Result<Response> {    let peer = req.peer;    ctx.auth.bearer(&req.token)?;               // authorization    ctx.limiter.check(peer)?;                   // rate limit    verify_md5(&req.frame, req.checksum)?;      // checksums    let sock = mptcp_connect(peer)?;            // MPTCP    ctx.link.delay(Duration::from_millis(80));  // link delay    ctx.router.dispatch(peer, sock)}
Test run gateway Multi-user tests Flood test Frame corruption test Multi-path test Wi-Fi profiles Traffic shaping

Analyze the code like an attacker. On the go, right inside your AI agent.

AI agent

> Develop support for one-time passwords. Verify that it is mathematically correct.

uint32_t hotp(const uint8_t *secret, size_t len, uint64_t counter) {    uint8_t msg[8];    for (int i = 7; i >= 0; --i) { msg[i] = uint8_t(counter); counter >>= 8; }     uint8_t mac[20];    hmac_sha1(secret, len, msg, sizeof msg, mac);     int off = mac[19] & 0x0f;    uint32_t bin = (mac[off] << 24) | (mac[off + 1] << 16) |                   (mac[off + 2] << 8) | mac[off + 3];    return bin % 1000000;} bool verify(const uint8_t *secret, size_t len, uint64_t counter,            const char *code) {    char want[7];    std::snprintf(want, sizeof want, "%06u", hotp(secret, len, counter));     char got[7];    std::strncpy(got, code, sizeof got);    return std::strcmp(got, want) == 0;}
visao -- otp.cpp

otp.cpp:20:20 error arithm/integer/overflow MISRA 12.4

Possible integer overflow

mac[off] promotes to int, so bit 31 is the sign bit. RFC 4226 §5.4 masks the byte with 0x7f before the shift; without the mask the shift is undefined and about half of the counters produce a code no standard authenticator agrees with.

fix(mac[off] & 0x7f) << 24

otp.cpp:31:5 error cpp/string/no_null_terminator MISRA 21.17

Buffer not guaranteed null-terminated

strncpy does not write the terminating NUL when the source reaches the size limit. A submitted code of seven characters or more leaves got unterminated, and the strcmp below it reads past the buffer. The code is supplied by whoever is authenticating.

fixgot[sizeof got - 1] = '\0';

2 issues · the file compiles without warnings

Don't blindly trust. Run it. Collect the evidence.

delta --ports --fingerprint /etc --binaries /usr/bin --cfg norm.json 0

Ports:

- tcp 0.0.0.0:22 LISTEN (pid=412 sshd)

- tcp 0.0.0.0:443 LISTEN (pid=980 nginx)

- udp 0.0.0.0:123 LISTEN (pid=377 ntpd)

- tcp 0.0.0.0:2375 LISTEN (pid=1544 dockerd)

Persistence files:

- [systemd] /etc/systemd/system/agent.service mode 0644 uid 0

- [cron] /etc/cron.d/backup mode 0666 uid 0

- [profile] /etc/profile.d/env.sh mode 0644 uid 0

Binaries:

- /usr/bin/agent [aarch64 64-bit LE pie] libc=musl cc="gcc 12.2.0"

- /usr/bin/updater [aarch64 64-bit LE pie] libc=musl cc="gcc 12.2.0"

Binary hardening: NX 2/2, PIE 2/2, RELRO 2/2 (full 1), canary 1/2, fortify 0/2; 0 static, 0 stripped

Check failed

Violations

port high

Open port 2375 (tcp) does not match any policy rule

expectedmatching port-norm rule

actualno matching rule (port/proto/state/process)

persistence critical ATT&CK T1053.003

Persistence file '/etc/cron.d/backup' (cron) is world-writable

expectednot world-writable

actualworld-writable

hardening medium ATT&CK T1055

Binary '/usr/bin/agent' lacks required mitigation: stack canary

expectedstack canary

actualmissing

Found 3 violation(s)

Static analysis, testing and runtime. One platform: Midair.

TS Factory Visao Delta
The Midair dashboard with the project map Midair Vision: the findings to act on

Our clients work in different industries.

Network equipment on a bench

Network equipment

A Wi-Fi router is a full stack: the U-Boot bootloader, the firmware, the cloud management. We build all of it, test it for security and report what to fix. Support continues after release.

MPTCP · Wi-Fi mesh · SFP

A smart watch showing workout figures on the wrist of someone resting after exercise

Wearables and smartphones

A wearable or a phone needs hardware and software that fit each other. We design both, from the choice of the hardware platform to the full software.

Wi-Fi · BLE · network protocols

A row of racks in a data centre

High-performance servers

Rust and C++ are our languages for servers. Speed and security come first in the design.

Rust · C++

Monitors on a desk in an office, one of them showing code

Developer tools

We develop programming languages and help you refine their design. Static analysis tools, dynamic analysis tools and debuggers come from the same team.

compilers · static analysis · debuggers

A terminal window at a root prompt

Security and reverse engineering

Some systems must stay secure whatever the industry, and we build those. VPNs get special attention. Ethical reverse engineering is another option.

VPN · reverse engineering

A phone showing a Bitcoin price chart beside two coins

Blockchain

Our blockchain work covers zero-knowledge proofs and client development. Toolchains for RISC-V and for the zkVM are part of it.

zk · RISC-V · zkVM

NDA Wi-Fi router developers
NDA Blockchain companies
NDA Developer tool creators

We help teams build and test secure software in these industries.

Read more

Start at the level your project needs.

For evaluation

Free

€0

Explore Midair on a small project, a prototype or an initial evaluation.

The free plan includes
  • Basic static analysis
  • Dependency overview
  • Limited project validation
  • Community support
Most popular

Professional

€90per user / month

Connect analysis, distributed testing and runtime data in one production workflow.

Everything in Free, plus
  • Fast cloud setup
  • Advanced static analysis with Visao
  • Distributed testing with TS Factory
  • Runtime insights with Delta
  • CI/CD integration
  • Integration with existing R&D and AI-assisted workflows
  • Automated reports
  • Priority support
Recommended

Team

€990per month

Coordinate Midair across several projects and system layers.

Everything in Professional, plus
  • Cloud or on-premises deployment
  • 10 users included
  • Inter-project dependency analysis
  • Cross-layer dashboards
  • Project and team analytics
  • Dedicated project onboarding
For complex environments

Enterprise

Custom

Adapt Midair to a large-scale, embedded or regulated environment.

Everything in Team, plus
  • Unlimited users
  • Custom Visao rules
  • Custom integrations
  • Project-specific workflows and reporting
  • Custom AI workflow integration
  • Dedicated engineering support

A small team. Backed by science.

We work across compilers, distributed testing, embedded systems, networking, software engineering and product design.

Notes from our work. Written by the people doing it.