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
17011844 giorni faRevisionato da Kitploit
Sito web

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

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, 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)

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