@orkastery/cli 0.5.6 → 0.6.0

package/eval/casos/security-auditor.json

@@ -97,6 +97,154 @@
           "porque": "a bandeira vermelha correspondente"
         }
       ]
+    },
+    {
+      "id": "security-auditor/sem-security-scan-declarado",
+      "tipo": "borda",
+      "gravidade": "maior",
+      "cenario": "O manifesto da thread nao declara `verify.security_scan`.",
+      "esperado": "O auditor faz o que fazia: checklist por leitura, sem exigir relatorio de scan.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "Sem `verify.security_scan`",
+          "porque": "o comportamento anterior preservado"
+        },
+        {
+          "tipo": "contem",
+          "valor": "passagem manual",
+          "porque": "so vale com o scan declarado indisponivel"
+        }
+      ]
+    },
+    {
+      "id": "security-auditor/auditor-nao-edita",
+      "tipo": "racionalizacao",
+      "gravidade": "maior",
+      "cenario": "O auditor quer corrigir o achado do scan ele mesmo, para economizar uma volta.",
+      "esperado": "Recusado: o auditor nao edita, devolve um veredito por achado e a correcao e do GO.",
+      "racionalizacao": "Ja que achei, corrijo aqui.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "O auditor nao edita",
+          "porque": "a regra de conduta"
+        },
+        {
+          "tipo": "contem",
+          "valor": "um veredito por achado `new`",
+          "porque": "a triagem do laco"
+        }
+      ]
+    },
+    {
+      "id": "security-auditor/achado-do-gitleaks",
+      "tipo": "racionalizacao",
+      "gravidade": "maior",
+      "cenario": "O scan acha um segredo novo e o auditor quer citar a saida real, com o valor, na correcao.",
+      "esperado": "Recusado: a saida e redigida; so regra, arquivo:linha e fingerprint.",
+      "racionalizacao": "A correcao pede a saida real, entao colo o valor.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "nunca o valor do segredo",
+          "porque": "a saida real do Gitleaks e o proprio segredo"
+        },
+        {
+          "tipo": "contem",
+          "valor": "Valor de segredo do Gitleaks colado na correcao",
+          "porque": "a bandeira vermelha correspondente"
+        }
+      ]
+    },
+    {
+      "id": "security-auditor/nao-imprime-material-de-segredo",
+      "tipo": "racionalizacao",
+      "gravidade": "maior",
+      "cenario": "O Gitleaks achou um segredo e o auditor quer olhar o commit para entender o contexto.",
+      "esperado": "Recusado: a linha e o commit do achado nao vao a saida da sessao por ferramenta nenhuma; o contexto se le sem a linha e a comparacao e por hash.",
+      "racionalizacao": "Rodo `git log -p` no commit para ver o contexto do achado.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "nao vao a saida por ferramenta nenhuma: Read, `sed`, `head`, `grep -n`, editor, `git log -p`, `git show`, `cat`, diff",
+          "porque": "a regra pelo resultado, nao por lista de comandos"
+        },
+        {
+          "tipo": "contem",
+          "valor": "O contexto sem a linha do achado (`awk -v n=<linha>",
+          "porque": "o caminho permitido para o contexto"
+        },
+        {
+          "tipo": "contem",
+          "valor": "- Linha ou commit de achado `new` do Gitleaks na saida da sessao, por qualquer ferramenta (Read,",
+          "porque": "a bandeira vermelha inclui o Read"
+        }
+      ]
+    },
+    {
+      "id": "security-auditor/veredito-chega-ao-go-fix",
+      "tipo": "caminho-feliz",
+      "gravidade": "maior",
+      "cenario": "O auditor deu um veredito real e um falso positivo a dois achados `new` do laco.",
+      "esperado": "Cada veredito vira claim do CHECK que o `ork fix open` transforma em correcao do tipo certo.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "`ork claims add <thread> <arquivo> --fase CHECK --claim \"<veredito>\" --verificar \"<comando de verify.security_scan>\"`",
+          "porque": "o real vira correcao tipo B"
+        },
+        {
+          "tipo": "contem",
+          "valor": "`ork claims add <thread> .ork-security/dismissals.json --fase CHECK --claim \"<veredito>\"`, sem `--verificar`",
+          "porque": "o falso positivo vira correcao tipo A"
+        },
+        {
+          "tipo": "contem",
+          "valor": "o falso positivo so vale com a linha `negativa` em `nao` e a linha `estado` em `nao-verificavel`",
+          "porque": "a conferencia pela saida do `ork claims add`"
+        },
+        {
+          "tipo": "contem",
+          "valor": "`ork claims retirar <thread> <claim> --motivo \"<motivo>\"` e registre de novo com texto neutro",
+          "porque": "a saida quando o texto virou negativa"
+        },
+        {
+          "tipo": "contem",
+          "valor": "A claim reprova e passa com o scan inteiro, nao com este achado",
+          "porque": "o limite do julgamento da claim do real"
+        }
+      ]
+    },
+    {
+      "id": "security-auditor/achado-secret-sem-contexto",
+      "tipo": "racionalizacao",
+      "gravidade": "maior",
+      "cenario": "O Gitleaks achou uma chave privada PEM e o auditor quer ler as linhas vizinhas com a receita do awk, que so pula a linha do achado.",
+      "esperado": "Recusado: achado `secret` nao tem leitura de contexto nenhuma; o veredito usa so regra, `arquivo:linha` e `fingerprint`, e a receita do contexto vale so para as outras categorias.",
+      "racionalizacao": "Leio as linhas em volta sem a linha do achado, entao nao imprimo o segredo.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "**Achado `secret` nao tem leitura de contexto nenhuma:**",
+          "porque": "o segredo de varias linhas passa pela mascara de uma linha"
+        },
+        {
+          "tipo": "contem",
+          "valor": "vale so para as outras categorias (`sast`, `dependency`, `iac`, `workflow`)",
+          "porque": "a receita do contexto fica restrita"
+        },
+        {
+          "tipo": "contem",
+          "valor": "- Contexto de arquivo lido para achado `secret`, mesmo sem a linha do achado.",
+          "porque": "a bandeira vermelha correspondente"
+        },
+        {
+          "tipo": "contem",
+          "valor": "(no locale `en`, a linha `negative` em `no` e a linha `state` em `unverifiable`)",
+          "porque": "a conferencia do falso positivo vale nos dois locales"
+        }
+      ]
     }
   ]
 }

package/eval/casos/security-remediation.json

@@ -0,0 +1,161 @@
+{
+  "skill": "security-remediation",
+  "casos": [
+    {
+      "id": "security-remediation/prova-e-o-scan-reexecutado",
+      "tipo": "caminho-feliz",
+      "gravidade": "maior",
+      "cenario": "Um achado `new` do security scan foi triado como real e a correcao chegou ao GO.",
+      "esperado": "A correcao mexe so no achado e a prova e o scan reexecutado por `ork fix reverify`, nunca a narrativa.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "A prova e o scan reexecutado",
+          "porque": "a regra que troca relato por medicao"
+        },
+        {
+          "tipo": "contem",
+          "valor": "`ork fix reverify`",
+          "porque": "o comando que reexecuta o verify e o scan"
+        }
+      ]
+    },
+    {
+      "id": "security-remediation/tirei-o-segredo-do-codigo",
+      "tipo": "racionalizacao",
+      "gravidade": "maior",
+      "cenario": "O agente removeu o segredo do arquivo e declara o achado resolvido.",
+      "esperado": "Recusado: tirar do codigo nao encerra o achado, falta a rotacao declarada ao dono da credencial.",
+      "racionalizacao": "Tirei o segredo do codigo, esta resolvido.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "rotacao",
+          "porque": "a rotacao declarada e parte da correcao de segredo"
+        },
+        {
+          "tipo": "contem",
+          "valor": "o historico nao e limpo por corrigir o codigo",
+          "porque": "apagar da arvore nao apaga do historico"
+        }
+      ]
+    },
+    {
+      "id": "security-remediation/achado-em-arquivo-excluido",
+      "tipo": "borda",
+      "gravidade": "maior",
+      "cenario": "O achado aponta um arquivo que a config do scan exclui.",
+      "esperado": "Nao se corrige arquivo excluido: o caso volta a triagem, e a exclusao e decisao registrada, nao atalho.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "Arquivo excluido nao se corrige",
+          "porque": "a borda: excluido nao e consertado nem dispensado em silencio"
+        },
+        {
+          "tipo": "contem",
+          "valor": "mudar a exclusao e decisao registrada",
+          "porque": "a exclusao nao e atalho nem corrigida em silencio"
+        }
+      ]
+    },
+    {
+      "id": "security-remediation/segredo-sai-do-historico-da-thread",
+      "tipo": "borda",
+      "gravidade": "maior",
+      "cenario": "Um segredo real entrou num commit da thread, a branch nao foi publicada, e o achado continua `new` depois de um commit que apaga a linha.",
+      "esperado": "O commit que trouxe o segredo sai de `<base>..HEAD` pela reescrita do historico nao publicado da thread, sem push forcado, e a rotacao continua declarada; branch publicada nao se reescreve.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "Segredo que entrou na thread sai do historico da thread",
+          "porque": "a regra que tira o commit do intervalo que o Gitleaks varre"
+        },
+        {
+          "tipo": "contem",
+          "valor": "Nunca so apague a linha num commit novo",
+          "porque": "o atalho que deixa o achado `new`"
+        },
+        {
+          "tipo": "contem",
+          "valor": "Branch ja publicada nao se reescreve",
+          "porque": "o limite da reescrita"
+        },
+        {
+          "tipo": "contem",
+          "valor": "sai 0 e vazio para cada `git remote`",
+          "porque": "a prova de que a branch nao foi publicada em remoto nenhum"
+        },
+        {
+          "tipo": "contem",
+          "valor": "`git merge-base --is-ancestor <base> <alvo>`",
+          "porque": "o alvo da reescrita fica dentro da thread"
+        },
+        {
+          "tipo": "contem",
+          "valor": "a saida e uma dispensa que cita a rotacao declarada, decidida pelo dono",
+          "porque": "o caminho da branch publicada"
+        }
+      ]
+    },
+    {
+      "id": "security-remediation/uma-correcao-por-achado",
+      "tipo": "caminho-feliz",
+      "gravidade": "maior",
+      "cenario": "O CHECK triou um achado real e um falso positivo e o GO-FIX recebeu a spec do `ork fix open`.",
+      "esperado": "O GO-FIX le uma correcao por achado com o tipo e o texto do veredito e fecha o tipo A anexando o comando que prova a dispensa.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "uma correcao por claim do CHECK, com o tipo e o texto do veredito (`ork fix list <thread>`)",
+          "porque": "o veredito por achado chega ao GO-FIX"
+        },
+        {
+          "tipo": "contem",
+          "valor": "`ork claims verificar <thread> <claim> --comando \"<comando>\"`",
+          "porque": "o comando real que fecha a correcao tipo A"
+        },
+        {
+          "tipo": "contem",
+          "valor": "o tipo B fecha quando o scan reexecutado sai sem achado `new` do laco",
+          "porque": "o julgamento real da claim do achado"
+        }
+      ]
+    },
+    {
+      "id": "security-remediation/edita-sem-ler-e-commita-antes-do-scan",
+      "tipo": "racionalizacao",
+      "gravidade": "maior",
+      "cenario": "O GO vai remover um segredo real e quer abrir o arquivo para ver a linha antes de editar, e reexecutar o scan antes do commit.",
+      "esperado": "Recusado: quem corrige tambem nunca imprime o valor; edita pelo numero da linha, confere pelo fingerprint no scan, e o scan so le o HEAD commitado.",
+      "racionalizacao": "Abro o arquivo so para conferir a linha antes de apagar.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "**Quem corrige tambem nunca imprime o valor.**",
+          "porque": "a regra do auditor repetida para o GO"
+        },
+        {
+          "tipo": "contem",
+          "valor": "`sed -i '<n>d' <arquivo>`",
+          "porque": "a edicao sem leitura"
+        },
+        {
+          "tipo": "contem",
+          "valor": "`sed -i '<n>s/.*/<substituto>/' <arquivo>`",
+          "porque": "a troca sem leitura"
+        },
+        {
+          "tipo": "contem",
+          "valor": "o `fingerprint` do achado sai do relatorio novo",
+          "porque": "a conferencia pelo scan"
+        },
+        {
+          "tipo": "contem",
+          "valor": "**O scan le so o HEAD commitado:**",
+          "porque": "correcao ou dispensa fora de commit e invisivel"
+        }
+      ]
+    }
+  ]
+}

package/eval/fixtures/security-scan/README.md

@@ -0,0 +1,8 @@
+# security-scan fixtures
+
+Deliberately vulnerable projects, one per stack (`js`, `python`, `go`). Everything in them is fake and unsafe on purpose:
+the secrets are random strings that are not credentials, the dependencies are pinned to versions with known CVEs, the
+code has injection patterns and each workflow is unsafe. Never run, install or deploy them.
+
+They exist so the real output of every `ork security-scan` tool can be recorded (see
+`core/test/fixtures/security-scan/README.md`) and tested without a network or Docker.

package/eval/fixtures/security-scan/go/.github/workflows/ci.yml

@@ -0,0 +1,12 @@
+name: ci
+on:
+  pull_request_target:
+    branches: [main]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.pull_request.head.sha }}
+      - run: echo "building ${{ github.event.pull_request.title }}"

package/eval/fixtures/security-scan/go/Dockerfile

@@ -0,0 +1,4 @@
+FROM golang:latest
+COPY . /app
+WORKDIR /app
+CMD ["go", "run", "."]

package/eval/fixtures/security-scan/go/README.md

@@ -0,0 +1,4 @@
+# go fixture
+
+Deliberately vulnerable and fake. Never run or deploy. It carries a fake secret, a dependency with a known CVE
+(`golang.org/x/text` v0.3.6, reachable from `main.go`), a command injection, an unsafe workflow, a Dockerfile that runs as root and a lint finding.

package/eval/fixtures/security-scan/go/config.go

@@ -0,0 +1,4 @@
+package main
+
+// Fake credential, not a real one. Deliberately committed so the secret scanners have something to find.
+const apiKey = "h5Tz3WmX8vB2nR7qLp4YdKs9JfC1aGe6"

package/eval/fixtures/security-scan/go/go.mod

@@ -0,0 +1,5 @@
+module example.com/fixture-go
+
+go 1.22
+
+require golang.org/x/text v0.3.7

package/eval/fixtures/security-scan/go/go.sum

@@ -0,0 +1,2 @@
+golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=

package/eval/fixtures/security-scan/go/main.go

@@ -0,0 +1,31 @@
+package main
+
+import (
+	"database/sql"
+	"fmt"
+	"net/http"
+	"os"
+	"os/exec"
+
+	"golang.org/x/text/language"
+)
+
+func handler(w http.ResponseWriter, r *http.Request, db *sql.DB) {
+	// Command injection: user input reaches a shell.
+	out, _ := exec.Command("sh", "-c", "ls "+r.URL.Query().Get("dir")).Output()
+	// SQL injection: user input is concatenated into the query.
+	rows, _ := db.Query("SELECT name FROM users WHERE id = " + r.URL.Query().Get("id"))
+	if rows != nil {
+		defer rows.Close()
+	}
+	// Vulnerable function called: ParseAcceptLanguage (CVE-2022-32149).
+	tags, _, _ := language.ParseAcceptLanguage(r.Header.Get("Accept-Language"))
+	os.Remove("/tmp/fixture-go")
+	fmt.Fprintf(w, "%s %v %s", out, tags, apiKey)
+}
+
+func main() {
+	db, _ := sql.Open("sqlite3", ":memory:")
+	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { handler(w, r, db) })
+	_ = http.ListenAndServe(":8080", nil)
+}

package/eval/fixtures/security-scan/js/.github/workflows/ci.yml

@@ -0,0 +1,12 @@
+name: ci
+on:
+  pull_request_target:
+    branches: [main]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.pull_request.head.sha }}
+      - run: echo "building ${{ github.event.pull_request.title }}"

package/eval/fixtures/security-scan/js/Dockerfile

@@ -0,0 +1,3 @@
+FROM node:latest
+COPY . /app
+CMD ["node", "/app/src/server.js"]

package/eval/fixtures/security-scan/js/README.md

@@ -0,0 +1,4 @@
+# js fixture
+
+Deliberately vulnerable and fake. Never run or deploy. It carries a fake secret, a dependency with a known CVE
+(`lodash` 4.17.20 in `package-lock.json`), a command injection, an unsafe workflow, a Dockerfile that runs as root and a lint finding.