Square CloudSquare Cloud

Vulnerability scanning with Cubic

Cubic checks your application's dependencies against OSV.dev, looks for credentials written in the code, and reviews memory and settings. The report lands in the chat with each finding's severity and fix, and nothing in the application changes.

Cubic comes with every plan. Scheduled check-ups through routines on Pro and Enterprise.

What the check-up looks at

Four checks run together and only read the application. Anything it couldn't read shows up as not checked, never as all clear.

Vulnerable dependencies

Every package is checked against OSV.dev, the open database that brings together the GitHub Advisory Database, PyPA, the Go vulnerability database, RustSec and other sources.

  • Severity from the advisory or computed from CVSS
  • The version that clears every advisory of the package
  • Transitive dependencies are audited too
  • Malicious packages flagged as critical
  • Withdrawn advisories don't count
  • Git dependencies npm refuses

Credentials in the code

Discord and GitHub tokens, AI provider and AWS keys, private keys and passwords in connection URLs written into the files.

  • File and line, never the value
  • Placeholders and local URLs ignored
  • A real value pasted into .env.example counts too
  • Fix: environment variable and revoke at the provider

Memory

The last 24 hours' RAM peak against the application's limit: a medium finding from 85%, high from 95%.

  • Never suggests lowering the memory
  • Fix: raise MEMORY or find what's growing
  • Static sites are left out

Settings

Automatic restart turned off, which leaves the application down after a crash until someone starts it again.

  • Fixed right in the config file
  • On by default for deploys from the dashboard

From the lockfile to what's installed

The check-up reads the dependency files at the root and, after the first start, what the application actually installed. Transitive dependencies and requirements.txt lines without a version get audited too.

Node.js

npm

The tree npm installed on the first start, transitives included. Before that, the package-lock.json at the root.

  • node_modules
  • package-lock.json

Python

PyPI

The packages pip installed, including unpinned and transitive ones. Before the first start, the pins (==) in requirements.txt.

  • site-packages
  • requirements.txt

PHP

Packagist

The composer.lock at the root, with the production packages.

  • composer.lock

Go

Go modules

The go.mod modules, with indirect ones and replace directives applied.

  • go.mod

Rust

crates.io

The Cargo.lock the first cargo run writes, with the crates from crates.io.

  • Cargo.lock

Ruby

RubyGems

The Gemfile.lock that bundle install maintains, with the gems from rubygems.org.

  • Gemfile.lock

Elixir

Hex

The mix.lock from mix deps.get, with the packages from the public Hex repository.

  • mix.lock

Several ecosystems, one report

An application with package-lock.json and requirements.txt gets both audited in the same check-up.

  • node_modulesInstalled
  • package-lock.jsonLockfile

How severity is set

Severity comes from the database that published the advisory. When it doesn't rate it, Cubic computes the CVSS v3 score from the advisory's vector and applies the ranges below. Findings that aren't advisories have a fixed severity.

CriticalCVSS

Score from 9.0 to 10. Usually exploitable over the network, with no login and no action from anyone.

  • Known malicious package (MAL- advisory)
  • Advisory rated critical
HighCVSS

Score from 7.0 to 8.9. Exploitable with little effort, or the damage is large.

  • Credential written in the code
  • Git dependency npm refuses
  • RAM peak at 95% of the limit or more
MediumCVSS

Score from 4.0 to 6.9. Needs an extra condition, such as prior access or someone's action.

  • RAM peak at 85% of the limit or more
  • Advisory with no rating or CVSS score
LowCVSS

Score from 0.1 to 3.9. Small impact or hard to exploit.

  • Automatic restart turned off

Only the name and version leave the platform

For each package, the check-up sends OSV.dev the ecosystem, the name and the version. Your code, your variables and the value of any credential found stay on Square Cloud.

Private packages stay out

Anything from git, a local path or a private registry is never sent, and the report says how many packages went unaudited.

Credentials by file and line only

The value found never reaches the model or the screen: only the kind, the file and the line.

New advisories within a day

OSV.dev answers are kept for a day. Running it again after a fix is instant, and an advisory published today shows up by tomorrow.

From finding to fix

The check-up only reads. The fix happens in your next message, like any other request to Cubic.

  1. 01

    Ask for the check-up

    Type /checkup and the application's name in the chat, or just ask. That turn only reads: nothing is changed.

  2. 02

    Read the report

    Each finding carries the severity, the advisories (GHSA, CVE) and the version that resolves all of them, with how to apply it: in the manifest or, for a transitive dependency, by pinning the version.

  3. 03

    Ask for the fix

    “Ask Cubic to fix it” sends the finding to the chat. Cubic edits the dependency file like any other change.

  4. 04

    Check again

    Run the check-up once more to confirm: what didn't change comes from the cache, with no new query.

  • Direct dependency

    Bumps the version in the manifest: package.json, requirements.txt, composer.json, go.mod, Cargo.toml, Gemfile or mix.exs.

  • Transitive dependency

    Pins the version without swapping the package that pulls it in: overrides in npm, a pin in requirements.txt, cargo update -p or bundle update.

  • On Node, reinstall

    The start only runs npm install when the node_modules folder doesn't exist. After editing package.json, Cubic deletes the folder and restarts.

  • On Python, Ruby and Elixir, every start

    pip, bundle and mix install the dependencies on every start: the new version goes in on the next restart.

When and where to run it

One application in depth, all of them at once, or every week without having to remember.

In the chat, with /checkup

The full check-up of one application: dependencies, credentials in the code, memory and settings. Up to 3 every 10 minutes.

  • /checkup app-name
  • Or ask: is anything vulnerable?

Every application at once

A quick pass over up to 10 applications, starting with the ones with the most memory, with one report per application. The credential scan is left to each application's own check-up.

  • The 10 with the most memory first
  • No credential scan

Every week, with a routine

On Pro and Enterprise, a routine runs the check-up at the time you pick and reports in a conversation, critical findings first.

  • Pro and Enterprise
  • Report in a conversation, critical first

Findings become tasks

“Create tasks” sends the findings to the board of the workspace that shares the application, one per task, with the fix in the text.

  • One task per finding
  • The fix goes in the task text

What's left out

The check-up is a quick read of the application and is clear about what it covers. This is what it checks and what it doesn't.

The check-up checks
Left out
Known vulnerabilities, published in public advisories
Flaws that don't have an advisory yet (zero-day)
Credentials written in the application's files
Logic flaws in your code, such as SQL injection or XSS
Files, installed dependencies and metrics, read-only
Attacks on the application or network tests: it's not a pentest
Packages from the public registries of seven ecosystems
Packages from git, a local path or a private registry
Node.js, Python, PHP, Go, Rust, Ruby and Elixir
Java (Maven, Gradle) and .NET dependencies
The fix for each finding, ready to ask Cubic for
Changes on its own: Cubic only fixes when you ask

A plan for every stage of your project

From your first deploy to 1 TB of RAM, without switching platforms. Each phase adds memory and features to the one before, and upgrades apply instantly.

Compare all plans
1 GB → 2 GB

Hobby

Take the idea off localhost and put it online.

  • Up to 2 vCPU
  • Real-time metrics
  • Blob Storage
  • One-click rollback
  • Square Shield anti-DDoS
  • Cubic AI agent

FromR$12.49/mo

4 GB → 8 GB

Standard

Recommended

Production with databases, your own domain and a team.

  • Up to 4 vCPU
  • Databases
  • Custom domain
  • Load balancer
  • AI Gateway
  • Workspaces

FromR$44.99/mo

12 GB → 24 GB

Pro

More memory, daily snapshots and visibility into what runs.

  • Up to 12 vCPU
  • Daily application snapshots
  • Performance analytics
  • Cubic Pro and routines
  • Priority support

FromR$124.99/mo

32 GB → 1 TB

Enterprise

Large operations, with a private Discord channel.

  • Up to 16 vCPU
  • Private Discord channel

FromR$299.90/mo

HobbyStandardProEnterprise
Compute
RAM1 GB → 2 GB4 GB → 8 GB12 GB → 24 GB32 GB → 1 TB
vCPU1 → 246 → 1216
Platform
Real-time metricsIncludedIncludedIncludedIncluded
Blob StorageIncludedIncludedIncludedIncluded
One-click rollbackIncludedIncludedIncludedIncluded
Square Shield anti-DDoSIncludedIncludedIncludedIncluded
Cubic AI agentIncludedIncludedIncludedIncluded
DatabasesNot includedIncludedIncludedIncluded
Custom domainNot includedIncludedIncludedIncluded
Load balancerapps per domainNot included2510
AI GatewayNot includedIncludedIncludedIncluded
Daily application snapshotsNot includedNot includedIncludedIncluded
Performance analyticsNot includedNot includedIncludedIncluded
Cubic Pro and routinesNot includedNot includedIncludedIncluded
Team and support
Workspacesmembers per workspaceNot included3 → 710 → 2020 → 50
Priority supportNot includedNot includedIncludedIncluded
Private Discord channelNot includedNot includedNot includedIncluded

4.9 out of 5

482 reviews on Google and Trustpilot

Hosted in a partner datacenter with certifications

  • Tier 3
  • ISO 27001
  • SOC 2 Type II
  • Always-On DDoS Protection
Explore our infrastructure

Vulnerability scanning questions

What is the Cubic check-up?

A read-only review of an application: dependencies with known vulnerabilities, credentials written in the code, the RAM peak of the last 24 hours and automatic restart. The result shows up in the chat as a report, with each finding's severity and fix.

Where do the vulnerabilities come from?

From OSV.dev, the open database that brings together the GitHub Advisory Database, PyPA, the Go vulnerability database, RustSec and other sources. When an advisory has no severity, it is computed from its CVSS score; withdrawn advisories are ignored.

Which languages are covered?

npm (Node.js), PyPI (Python), Composer (PHP), Go modules, crates.io (Rust), RubyGems (Ruby) and Hex (Elixir). The check-up reads package-lock.json, requirements.txt, composer.lock, go.mod, Cargo.lock, Gemfile.lock and mix.lock, plus what the application installed when it started.

Does the check-up find vulnerabilities in transitive dependencies?

Yes. After the first start, it reads what was actually installed (the npm tree in node_modules and the packages pip installed), so a package pulled in by another one gets audited too. The fix says how to pin the version: overrides in package.json, a pin in requirements.txt, cargo update or bundle update.

Do I need to upload package-lock.json?

No. The CLI and the VS Code extension leave package-lock.json out of the deploy by default, and the check-up reads the tree npm installed on the first start. Before the first start, with no lockfile, the report warns that the npm dependencies haven't been audited yet.

Does my code leave Square Cloud?

No. Only each package's ecosystem, name and version go to OSV.dev. Packages from git, a local path or a private registry are never sent, and the value of a credential found never reaches the model or the screen.

Does the check-up change my application?

No, it only reads. To fix a finding, ask Cubic in the next message, like any other change.

What if it can't read something?

The report lists what went unchecked, such as an application without a lockfile, a file over 4 MB or the vulnerability database not answering. A report with items like that never shows as all clear.

What happens with a malicious package?

A package OSV.dev marks as malicious becomes a critical finding: the fix is to remove it and rotate every credential the application holds, since it may have read them.

Has a credential found in the code already leaked?

There's no way to know, so treat it as exposed: it's in the files, in the snapshots and in any repository the code was pushed to. Move the value to an environment variable, revoke the credential at the provider and create a new one.

Does the check-up look for flaws in my own code?

No. It looks for credentials written in the files, but it doesn't analyze the code's logic (SQL injection, XSS, permissions). For a code review, /review reads the application's files and points out what's missing or broken.

How is it different from npm audit or pip-audit?

The idea is the same: check the versions against public advisories. The check-up runs on the application as it's installed on Square Cloud, brings every ecosystem into one report, adds credentials, memory and settings, and Cubic applies the fix when you ask.

How often should I run the check-up?

After updating dependencies, before an important release and every so often, because new advisories come out every day for versions that were already installed. On Pro and Enterprise, a weekly routine does it for you.

Which plans include the check-up?

Every plan, along with Cubic. The check-up of one application runs up to 3 times every 10 minutes; check-ups scheduled through routines are on Pro and Enterprise.

Ship your project today

Join the 500,000+ developers who have used Square Cloud to host their projects.

  • Deploy in seconds via GitHub, CLI or .zip
  • Isolated, always-on containers
  • Automatic TLS on every domain
  • Anti-DDoS on layers 3, 4 and 7
  • Snapshots with 1-click restore
  • Cubic, the AI agent, on every plan
  • Fixed price in reais, with NFS-e
  • No per-request charges