Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
OpenCRE — Piattaforma interattiva che collega standard e linee guida di sicurezza per progettare, sviluppare, testare e acquisire software sicuro. Fornisce un catalogo unificato di Common Requirements (CREs) con riferimenti incrociati agli standard di settore. | Kitploit
Strumenti/GitHubGitHub/owasp/opencre
Analisi delle VulnerabilitàThreat IntelligenceApprendimento e FormazioneRisorse Curate
GitHubowasp/opencre

OpenCRE

Piattaforma interattiva che collega standard e linee guida di sicurezza per progettare, sviluppare, testare e acquisire software sicuro. Fornisce un catalogo unificato di Common Requirements (CREs) con riferimenti incrociati agli standard di settore.

Vedi Repository
1701186 mesi faRevisionato da Kitploit

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi
Sito web

OpenCRE

Vai su https://www.opencre.org per vedere OpenCRE in funzione e ulteriori spiegazioni. OpenCRE sta per Open Common Requirement enumeration. È una piattaforma interattiva di collegamento dei contenuti per unire standard e linee guida di sicurezza. Offre un accesso facile e affidabile alle informazioni rilevanti in fase di progettazione, sviluppo, test e acquisto di software sicuro.

OpenCRE è composta da:

  • L'applicazione: un'applicazione web e CLI in Python per accedere ai dati, disponibile pubblicamente su opencre.org
  • I dati del catalogo: un catalogo di Common Requirements (CRE)
  • I dati di mappatura: collegamenti da ogni CRE alle sezioni pertinenti di una serie di standard
  • Strumenti e linee guida per contribuire ai dati e per eseguire l'applicazione localmente

Contribuisci con codice o mappature

Per vedere come puoi contribuire all'applicazione o ai dati (catalogo o mappature degli standard), consulta Contributing. Ti diamo il benvenuto!

Documentazione

  • Documentazione in-app — guida introduttiva, FAQ e riferimento API interattivo
  • FAQ — domande frequenti (disponibile anche all'indirizzo /docs#faq)
  • Specifica OpenAPI — API REST pubblica (/rest/v1/openapi.yaml quando è in esecuzione)

Roadmap

Per una roadmap, consulta le issues.

Eseguire la tua OpenCRE

Sei libero di utilizzare l'applicazione pubblica opencre su opencre.org. Inoltre, puoi eseguire la tua se vuoi includere, ad esempio, i tuoi standard e le tue linee guida di sicurezza. La chiamiamo myOpenCRE.

In locale

Docker

Il modo più semplice per eseguire OpenCRE localmente è tramite il container Docker pubblicato. Puoi farlo eseguendo:

root@kitploit:~
docker run -p 5000:5000 ghcr.io/owasp/opencre/opencre:latest

Dopo che il container ha terminato di scaricare le informazioni remote, puoi accedervi su http://127.0.0.1:5000.

Se vuoi sviluppare su OpenCRE o se docker non è disponibile nel tuo ambiente, puoi eseguirlo in alternativa tramite CLI.

Riga di comando

Per eseguire OpenCRE al di fuori di Docker è necessario installarla. Per installare questa applicazione servono python3, yarn e virtualenv.

Clona il repository:

root@kitploit:~
git clone https://github.com/OWASP/OpenCRE

(Consigliato) Crea e attiva un ambiente virtuale Python:

root@kitploit:~
python3 -m venv venv
source venv/bin/activate

Installa le dipendenze:

root@kitploit:~
make install

Scarica l'ultimo grafo CRE da upstream eseguendo:

root@kitploit:~
make upstream-sync

Puoi precalcolare la cache locale di gap-analysis dopo le importazioni con:

root@kitploit:~
make backfill-gap-analysis

Per eseguire CRE localmente, puoi quindi eseguire:

root@kitploit:~
make dev-flask

Per eseguire l'applicazione CLI, puoi eseguire:

root@kitploit:~
python cre.py --help

Per esportare la tassonomia di CRE + standard in CSV (adatto alla CI), esegui:

root@kitploit:~
python cre.py --export --csv <path/to/output.csv>

Esempio:

root@kitploit:~
python cre.py --export --csv artifacts/cres_and_standards.csv

Note:

  • --export è una modalità di esportazione dedicata e termina dopo aver scritto il CSV.
  • --csv è obbligatorio quando si usa --export.
  • Questa modalità esporta i dati del report dall'API OpenCRE e non modifica il DB locale.

Per scaricare localmente un foglio di calcolo CRE remoto, puoi eseguire:

root@kitploit:~
python cre.py --review --from_spreadsheet <google sheets url>

Per aggiungere un foglio di calcolo remoto al tuo database locale, puoi eseguire:

root@kitploit:~
python cre.py --add --from_spreadsheet <google sheets url>

Per eseguire l'applicazione web per lo sviluppo, puoi usare:

root@kitploit:~
make start-containers
make start-worker

# in a separate shell
make dev-flask

In alternativa, puoi usare il dockerfile con:

root@kitploit:~
make docker && make docker-run

Alcune funzionalità come Gap Analysis richiedono un DB neo4j in esecuzione; puoi avviarlo con:

root@kitploit:~
make docker-neo4j

Per eseguire solo il backfill delle coppie di gap-analysis mancanti (senza avviare Flask), usa:

root@kitploit:~
RUN_COUNT=8 bash scripts/backfill_gap_analysis.sh

Operazioni sul DB di produzione (opencreorg)

Preferisci gli script dedicati in scripts/db/ per le operazioni di produzione. Questi script applicano misure di sicurezza e creano sempre un backup aggiornato prima delle modifiche al DB.

  • Solo backup:
    • APP_NAME=opencreorg scripts/db/backup-opencreorg.sh
  • Sincronizza il Postgres locale con Heroku:
    • APP_NAME=opencreorg SOURCE_DB_URL="postgresql://cre:[email protected]:5432/cre" scripts/db/sync-local-to-opencreorg.sh
  • Intervento SQL mirato:
    • APP_NAME=opencreorg scripts/db/surgery-opencreorg.sh --sql-file ./tmp/change.sql

Per interventi distruttivi (DELETE, DROP, TRUNCATE, ALTER irreversibile), usa:

root@kitploit:~
APP_NAME=opencreorg \
CONFIRM_DESTRUCTIVE=I_UNDERSTAND_OPENCREORG_PROD_DB_DESTRUCTIVE_ACTION \
scripts/db/surgery-opencreorg.sh --sql-file ./tmp/destructive-change.sql --destructive

Runbook:

  • docs/runbooks/opencreorg-db-sync-and-surgery.md
  • docs/runbooks/opencreorg-db-destructive-ops-checklist.md

Variabili d'ambiente per la connessione dell'app a neo4jDB (predefinite):

  • NEO4J_URL (neo4j//neo4j:password@localhost:7687)

Per eseguire l'applicazione web in produzione è necessario gunicorn e puoi eseguirla dalla directory cre_sync:

root@kitploit:~
make prod-run

Note per macOS (Apple Silicon e Intel)

OpenCRE è completamente supportata su macOS. Le note seguenti sono facoltative e pensate per aiutare i contributori che eseguono OpenCRE localmente su sistemi macOS.

Prerequisiti

Installa gli strumenti richiesti usando Homebrew:

root@kitploit:~
brew install [email protected] yarn make

Nota: Python 3.11 è consigliato. Versioni più recenti di Python potrebbero causare incompatibilità di dipendenze.

Verifica la versione di Python:

root@kitploit:~
python3 --version

Configurazione dell'ambiente virtuale

Crea e attiva esplicitamente un ambiente virtuale usando Python 3:

root@kitploit:~
python3 -m venv venv
source venv/bin/activate

Aggiorna pip:

root@kitploit:~
pip install --upgrade pip

Installazione delle dipendenze

Installa le dipendenze usando il flusso di lavoro standard:

root@kitploit:~
make install

Se incontri problemi di build, assicurati che gli Xcode Command Line Tools siano installati:

root@kitploit:~
xcode-select --install

Esecuzione locale

Sincronizza i dati CRE upstream (richiede accesso a Internet):

root@kitploit:~
make upstream-sync

Quindi avvia il server locale:

root@kitploit:~
make dev-flask

L'applicazione sarà disponibile all'indirizzo:

root@kitploit:~
http://127.0.0.1:5000

Suggerimento: per la maggior parte degli utenti macOS, eseguire tramite Docker è l'approccio più semplice e affidabile.

Utilizzo dell'API OpenCRE

Consulta la guida utente myOpenCRE sull'utilizzo dell'API OpenCRE per, ad esempio, aggiungere le tue linee guida e i tuoi standard di sicurezza.

Build ed esecuzione di Docker

Puoi creare le immagini Docker di produzione o di sviluppo con:

root@kitploit:~
make docker-prod
make docker-dev

Le variabili d'ambiente usate da OpenCRE sono:

Configurazione dell'ambiente

Copia il file di configurazione di esempio:

root@kitploit:~
cp .env.example .env

Poi modifica .env e inserisci valori appropriati per il tuo ambiente.

Variabili

  • Database: DEV_DATABASE_URL
  • Neo4j: NEO4J_URL
  • Redis: REDIS_HOST, REDIS_PORT, REDIS_URL, REDIS_NO_SSL
  • Flask: FLASK_CONFIG, INSECURE_REQUESTS
  • Embeddings: NO_GEN_EMBEDDINGS, CRE_EMBED_MODEL, CRE_EMBED_EXPECTED_DIM, CRE_VALIDATE_EMBED_DIM_ON_INIT
  • Modelli/retry LLM: CRE_LLM_CHAT_MODEL, CRE_EMBED_ALIGN_MODEL, ,

Vedi .env.example per l'elenco completo e i valori predefiniti.

Backend LiteLLM (facoltativo)

OpenCRE usa LiteLLM per le chiamate LLM. Configura modelli e credenziali del provider tramite variabili d'ambiente.

Esempio minimo consigliato:

root@kitploit:~
# Chat / completion models (LiteLLM model strings)
CRE_LLM_CHAT_MODEL=gemini/gemini-2.5-flash
CRE_EMBED_ALIGN_MODEL=gemini/gemini-2.5-flash

# Embedding model used for persisted vectors
CRE_EMBED_MODEL=gemini/gemini-embedding-001
CRE_EMBED_EXPECTED_DIM=3072
CRE_VALIDATE_EMBED_DIM_ON_INIT=1

# Retry policy
CRE_LLM_MAX_RETRIES=2
CRE_LLM_RETRY_SLEEP_SECONDS=15

# Provider credential (example for Gemini)
GEMINI_API_KEY=your-key

Note:

  • Tratta le modifiche a CRE_EMBED_MODEL o CRE_EMBED_EXPECTED_DIM come un evento di migrazione dei dati (di solito richiede un re-embedding).
  • CRE_EMBED_EXPECTED_DIM è una salvaguardia: le scritture falliscono rapidamente in caso di mancata corrispondenza delle dimensioni.
  • Mantieni i modelli chat/alignment e il modello di embedding configurabili separatamente; solo gli embedding devono rimanere compatibili in termini di dimensioni con i vettori memorizzati.

Puoi eseguire i container con:

root@kitploit:~
make docker-prod-run
make docker-dev-run

Sviluppo

Puoi eseguire i test del backend con:

root@kitploit:~
make test

Puoi ottenere un report di copertura con:

root@kitploit:~
make cover

Cerca di mantenere la copertura sopra il 70%.

Code style: black GitHub Super-Linter Main Branch Build

Issues PR's Welcome GitHub contributors GitHub last commit GitHub commit activity

Open in GitHub Codespaces

Scarica lo strumento
CRE_LLM_MAX_RETRIES
CRE_LLM_RETRY_SLEEP_SECONDS
  • Credenziali del provider: OPENAI_API_KEY, GEMINI_API_KEY, GCP_NATIVE
  • Autenticazione Google: GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET, GOOGLE_SECRET_JSON, LOGIN_ALLOWED_DOMAINS
  • GCP: GCP_NATIVE
  • Autenticazione foglio di calcolo: OpenCRE_gspread_Auth
  • Feature flags: CRE_ENABLE_HEALTH (abilita la sonda deploy/uptime GET /rest/v1/health; disattivato per impostazione predefinita, restituisce 404 se non impostato), CRE_ENABLE_MYOPENCRE (espone MyOpenCRE in GET /api/capabilities; disattivato per impostazione predefinita), CRE_ENABLE_LOGIN (espone l'interfaccia Login/Logout tramite capabilities.login; disattivato per impostazione predefinita)