---
title: "Mayz security review of your code"
description: "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."
---

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](../developer/mayz.md).

!!! abstract "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

=== "Web app"

    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](../integrations/github.md)).
    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.

=== "Desktop app"

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

=== "CLI"

    ```bash
    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](#3-prove-it-a-live-test-on-a-private-copy). |
| **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

!!! info "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*.

!!! warning "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.
