Step by step: start a Mayz security review, read how sure each finding is (Proven, Seen in the code, Not proven), run a live test on a private copy, retest after a fix, and let Ysra check security when it manages a build.

On this page

A Mayz review reads your app's code like an experienced tester and tells you what an attacker could do, how sure it is, and what to fix first. This page covers the security side, step by step. For everything else a review does (verdicts, privacy, supply chain, credits), see Mayz reviews.

In short

What it reads Your repository or folder, in its own copy: nothing in your project changes
What it checks Sign-in and permissions, other people's data, injection, sessions, uploads, secrets in the code and its history, packages with known problems
How sure Each finding says whether it was Proven, Seen in the code or Not proven
Then Fix these with Code, and Mayz checks the fix

1. Start a review#

  1. Open Mayz in the sidebar and choose + Review a repository (or pick Mayz at the top of Home's box).
  2. Choose the repository. It must be shared with Ysra through your GitHub connection (GitHub).
  3. Under Look at, choose Security (or Everything, which includes security and privacy).
  4. Tell Mayz anything it should know, for example "customers sign in; each shop must only see its own orders", or just send.

Open Mayz in the sidebar → Start a review, choose a folder on your computer or a repository, choose Look at: Security, and send.

ysra mayz ~/code/shop --focus security

The review takes a few minutes and usually uses 100–300 credits. It needs at least 100 credits left to start.

2. Read the report#

The verdict comes first: Ready, Needs work, Unsafe (a serious security problem) or Not finished. Then the counts Must fix now / Should fix / Minor, then Fix these first and Everything else.

Each finding shows what's wrong, why it matters, the evidence (file and line, or what Mayz saw), and how sure Mayz is.

How sure is each finding?#

Badge What it means
Proven ✓ An attack on a private test copy worked, and worked again when repeated. The finding shows the exact request Mayz sent and what came back. Only with a live test.
Found by an automatic check A scanner found it: a known-vulnerable package, a secret in the code.
Seen in the code I read it in the code; I didn't attack it. The code clearly allows it, but it wasn't tried on a running copy.
Not proven I tried … ways to attack it and it held. It is still in the code. Good news, said plainly, but worth a look.
Fixed ✓ After a fix, Mayz sent the same requests again and they now fail.
Still open After a fix, the same request still works.

The model's word alone never makes a finding Proven: Mayz plants its own fake secrets and test accounts in the copy, and a finding counts as proven only when one of those is actually reached, on the first try and on two replays.

3. "Prove it": a live test on a private copy#

On request

The live test is being rolled out to a few accounts. When it's on for yours, the start box shows Run a live security test in a private copy. It works on GitHub repositories.

With a live test, Mayz installs and starts your app in a sealed private copy: fake settings, made-up data, and no internet (the cut is checked before anything is tried). Then it tries what an attacker would, such as signing in as one test customer and asking for another's data, and only marks Proven what really worked, twice more on replay. The copy is thrown away afterwards.

  1. Start a review as above and tick Run a live security test in a private copy.
  2. Read what Mayz prepared:
    • What will run: the install and start commands;
    • Requests Mayz will test against the private copy;
    • Files left out of the test copy (such as your real .env);
    • Estimated cost, the spending limit, and the time limit (10 minutes at most). The cost is set aside from your credits up front; the estimate is valid for 15 minutes.
  3. If your repository has no mayz-live.json (how to install, seed and start the app), Mayz suggests one: read it and tick I reviewed this draft and confirm it for this run.
  4. Check Test accounts for the live test (Use these test accounts or Change) and the Made-up test values: tick They're made up, not real keys.
  5. Tick I confirm the listed seed files contain fictional people. Never put real customers' data in seed files.
  6. Tick I own this code or have permission to test it.
  7. Send.

The report then has Proven by attack, with what I sent and what came back, and Ideas that held: what was tried and failed. If time or budget ran out first, the ideas not tried are marked Not tried.

Only your own code

Live testing only ever runs against the private copy Mayz builds, never against your live site or anyone else's. Attack tools are refused everywhere else, including on your own computer.

4. Fix, then retest#

  1. Choose Fix these with Code (or Fix with Code / Fix just this one on a finding). Code makes the fixes in a new task.
  2. Mayz reviews the fix once by itself.
  3. For Proven findings, Mayz sends the same requests again to the fix. The report's Retest of what the attack proved section says I sent the same requests again to the fix on (your branch), then 1 fixed, 0 still open, with Fixed ✓, Still open or Not sent again for each.

The retest runs against the fix on GitHub. If it isn't pushed yet, Mayz says: … push it, then say review again. Then choose Review again.

5. "Let Ysra manage it" with a security check#

When you ask Ysra to build something and choose Let Ysra manage it, Ysra steers Code round by round against what you asked. Tick Check security before it's done: When it meets the goal, I review its security and send back what needs fixing.

  • Before the build is called done, Mayz reviews its security (Checking security).
  • Serious problems go back to Code as the next round (2 security problems sent back). A request the live test proved becomes a test that must now be refused.
  • Minor ones are listed in the final report.
  • It warns; it never blocks. You can take over at any time.

6. Keep watching with Guard#

A review is a snapshot. To be told when a push adds a secret, a malicious package or a backdoor, run the repository review again after changing dependencies.

Download and share#

Detailed report, Summary for managers, and Save the report as a Word file. A review is not a legal opinion, a certification or a replacement for a human audit.

YsraDocs