Przejdź do treści
Biblioteka skilli
Bezpieczeństwo · Przegląd i audyt

verify

/verify

Sprawdza, czy poprawka podatności z konkretnego znaleziska została wdrożona i czy problem nie wrócił.

Repozytorium
claude-code ↗
Licencja
MIT
Ostatnia zmiana repozytorium
07.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 07.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Sprawdza, czy poprawka podatności z konkretnego znaleziska została wdrożona i czy problem nie wrócił.

Wyzwalacze z opisu

verify fixconfirm fixcheck if vulnerability is fixedvalidate remediationrecheck findingtest if patch works
Oryginalny opis (EN)

This skill should be used when the user asks to "verify fix", "confirm fix", "check if vulnerability is fixed", "validate remediation", "recheck finding", or "test if patch works". Also triggers when the user has applied a security fix and wants confirmation that the vulnerability is actually resolved, or when referencing a finding ID and asking if it is still present.

Jak działa

  1. Supported Flags
  2. Workflow
  3. Output Format
  4. Pragmatism Notes
Sekcje z nagłówków SKILL.md, w oryginale · 161 linii, 1 011 słów
Podgląd SKILL.md
---
name: verify
description: >
  This skill should be used when the user asks to "verify fix", "confirm
  fix", "check if vulnerability is fixed", "validate remediation",
  "recheck finding", or "test if patch works". Also triggers when the user
  has applied a security fix and wants confirmation that the vulnerability
  is actually resolved, or when referencing a finding ID and asking if it
  is still present.
disable-model-invocation: true
---

# Fix Verification

Confirm that a security fix actually resolves the reported vulnerability.
Re-runs the specific check -- scanner rule or Claude analysis -- that
originally detected the issue. Outputs a clear verdict: FIXED or STILL
VULNERABLE with explanation. Updates the finding record in `.appsec/findings.json`.

## Supported Flags

Read `../../shared/schemas/flags.md` for the full flag specification.

| Flag | Verify Behavior |
|------|----------------|
| `--scope` | Identifies which findings to verify. Default: all findings with status `fix-applied` in scope. |
| `--depth quick` | Check only the exact location referenced in the finding. |
| `--depth standard` | Check the location + immediate callers and related code paths. |
| `--depth deep` | Standard + verify no variant of the vulnerability was introduced nearby. |
| `--depth expert` | Deep + attempt to construct a proof-of-concept that bypasses the fix. |
| `--severity` | Only verify findings at or above this severity. |
| `--format` | Default `text`. Use `json` for structured verification results. |

## Workflow

### Step 1: Identify Findings to Verify

Resolve which findings need verification:

1. **By finding ID**: User provides e.g., `INJ-001`. Load from `.appsec/findings.json`.
2. **By status**: Find all findings with status `fix-applied` that have not yet been verified.
3. **By scope**: Find all findings whose `location.file` falls within the resolved scope.
4. **All pending**: If no specific target, verify all `fix-applied` findings.

If no findings match, inform the user. If findings exist but none have `fix-applied` status, suggest running `/appsec:fix` first.

### Step 2: Load Finding Context

For each finding to verify:

1. **Read the finding record**: Original vulnerability details, CWE, location, snippet.
2. **Read the fix record**: What was changed (the diff), when it was applied.
3. **Read the current code**: Load the file at the finding's location using the Read tool.
4. **Determine the original detection method**: Was it found by a scanner (check `scanner.name`) or by Claude analysis?

### Step 3: Re-Run Detection

Apply the same detection method that found the original vulnerability:

#### Scanner-Detected Findings

If `scanner.name` is present and the scanner is available:

1. Run the specific scanner rule against the fixed file.
2. If the scanner no longer reports the finding at that location, mark as FIXED.
3. If the scanner still reports, mark as STILL VULNERABLE with scanner output.

**Scanner version awareness**: If the scanner version or configuration has changed since the original detection, note this in the verification result: `FIXED (note: scanner version changed since original detection — re-verify recommended).` This prevents false FIXED verdicts from rule changes.

#### Claude-Detected Findings

If the finding was detected by Claude analysis (no scanner, or scanner not available):

1. Re-read the code at the finding location with full context.
2. Apply the same analysis that detected the original vulnerability:
   - Is the vulnerable pattern still present?
   - Is user input still reaching the dangerous sink without sanitization?
   - Is the missing security control still missing?
3. Check that the fix is correct and complete:
   - Does the fix use the right mitigation for this vulnerability type?
   - Are there edge cases the fix misses (e.g., alternate code paths, encoding bypasses)?
   - Is the fix applied to all instances of the pattern, not just one?

### Step 4: Check for Fix Bypasses

At `--depth deep` and above, look for ways the fix might be circumvented:

1. **Alternate code paths**: Is there another route to the same sink that bypasses the fix?
2. **Encoding bypasses**: Can the input be encoded to evade the validation (double encoding, unicode, null bytes)?
3. **Type confusion**: Can the input type be changed to bypass validation (array instead of string)?
4. **Race conditions**: Can the check be bypassed via TOCTOU?
5. **Partial fix**: Does the fix cover all variants of the vulnerability?

### Step 5: Render Verdict

For each finding, output one of two verdicts:

#### FIXED

```
## FIXED: <Finding ID> - <Title>

**Status**: FIXED
**Verified at**: <timestamp>
**Method**: <scanner re-run | code analysis>

The vulnerability at `<file>:<line>` has been resolved.

**What changed**: <1-2 sentence summary of the fix>
**Confidence**: <high|medium> -- <why>
```

#### STILL VULNERABLE

```
## STILL VULNERABLE: <Finding ID> - <Title>

**Status**: STILL VULNERABLE
**Verified at**: <timestamp>
**Method**: <scanner re-run | code analysis>

The vulnerability at `<file>:<line>` has NOT been resolved.

**Reason**: <specific explanation of why the fix is insufficient>
**Remaining issue**: <what still needs to change>
**Suggestion**: <concrete next step to actually fix it>
```

### Step 6: Update Finding Records

Update each finding in `.appsec/findings.json`:

- **FIXED**: Set status to `verified-fixed`. Add `verified_at` timestamp and `verification.method`.
- **STILL VULNERABLE**: Set status to `fix-failed`. Add `verification.reason` explaining why. Preserve the original finding so `/appsec:fix` can be re-run.

Copy verified-fixed findings to `.appsec/fixed-history.json` for regression tracking (used by `/appsec:regression`).

### Step 7: Summary

After verifying all targeted findings, output a summary:

```
## Verification Summary

| Finding | Status | Confidence |
|---------|--------|------------|
| INJ-001 | FIXED | High |
| AC-003  | STILL VULNERABLE | High |

Verified: N/M findings fixed. N still require remediation.
```

## Output Format

Verification results reference the original finding but add verification metadata.

- `metadata.tool`: `"verify"`
- Original finding ID is preserved (not re-prefixed).

Finding ID prefix: **VER** (e.g., `VER-001`) only for new issues discovered during verification (e.g., the fix introduced a different vulnerability).

Findings follow `../../shared/schemas/findings.md`.

## Pragmatism Notes

- A finding is FIXED when the specific vulnerable pattern is resolved. Do not fail verification because of unrelated issues in the same file.
- Scanner re-runs are the strongest evidence. If the scanner that originally detected the issue no longer flags it, that is high-confidence FIXED.
- Claude analysis verification is medium-confidence by default. Note this in the output.
- If the fix moved the vulnerable code rather than resolving it, mark as STILL VULNERABLE and note the new location.
- If the entire function or file was deleted, verify the functionality was actually removed and not relocated. If truly removed, mark as FIXED.
- Do not penalize fixes that use a different mitigation strategy than suggested, as long as the vulnerability is resolved.

Wersje

RepozytoriumWynikLicencja
Ta strona · florianbuetow/claude-code100MIT
yonatangross/orchestkit100MIT
yonatangross/orchestkit100MIT
NolwennD/gabier100Apache-2.0
ericrisco/rsc-harness100MIT
sentimony/agentic-workflow100MIT
JoDi-27/JoDi-SDD100MIT
marcel-bich/marcel-bich-claude-marketplace100MIT
kdlbs/kandev100AGPL-3.0

Migawka bazy z 13.11.2026 · wersja paczki 60a99d4b6372 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100fix
    Generuje poprawki dla znalezisk bezpieczeństwa i podatności w aplikacji, także na podstawie identyfikatora znaleziska lub wskazania pliku i linii.
  • 100verify-fix
    Weryfikuje na wyraźne życzenie, czy poprawka bezpieczeństwa usuwa zgłoszoną podatność.
  • 100verify-fix
    Weryfikuje na wyraźne żądanie, czy poprawka zgłoszonej luki bezpieczeństwa rzeczywiście ją usuwa.
  • 100remediation-validator
    Ponownie uruchamia celowane skany po poprawkach, żeby potwierdzić, że podatności zniknęły, i wykrywa regresje.
  • 90vulnerability-validation
    Sprawdza, czy podejrzane podatności są osiągalne i realnie groźne, na podstawie artefaktów wyników skanów przed poprawką.
  • 90security-fix-finding
    Naprawia i weryfikuje potwierdzone lub prawdopodobne zgłoszenie bezpieczeństwa na wyraźną prośbę użytkownika.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.