OpenCRE

Rendez-vous sur https://www.opencre.org pour voir OpenCRE en action et obtenir plus d'explications. OpenCRE signifie « Open Common Requirement enumeration » (énumération ouverte des exigences communes). C'est une plateforme interactive de liaison de contenu pour unifier les normes et directives de sécurité. Elle offre un accès simple et fiable aux informations pertinentes lors de la conception, du développement, des tests et de l'acquisition de logiciels sécurisés.

OpenCRE se compose de :

• L'application : une application web et CLI Python pour accéder aux données, disponible publiquement sur opencre.org
• Les données du catalogue : un catalogue d'exigences communes (CREs)
• Les données de mappage : des liens de chaque CRE vers les sections pertinentes d'un ensemble de normes
• Des outils et des directives pour contribuer aux données et exécuter l'application localement

Contribuer au code ou aux mappages

Pour voir comment contribuer à l'application ou aux données (catalogue ou mappages de normes), consultez Contribuer. Votre contribution est vraiment la bienvenue !

Documentation

• Documentation dans l'application — démarrage rapide, FAQ et référence API interactive
• FAQ — questions fréquemment posées (également consultable sur /docs#faq)
• Spécification OpenAPI — API REST publique (/rest/v1/openapi.yaml lorsqu'elle est en cours d'exécution)

Feuille de route

Pour la feuille de route, veuillez consulter les issues.

Exécuter votre propre OpenCRE

Vous êtes libre d'utiliser l'application publique opencre sur opencre.org. En dehors de cela, vous pouvez exécuter votre propre instance si vous souhaitez par exemple inclure vos propres normes et directives de sécurité. Nous appelons cela myOpenCRE.

Localement

Docker

Le moyen le plus simple d'exécuter OpenCRE localement est de lancer le conteneur Docker publié. Pour ce faire, exécutez :

docker run -p 5000:5000 ghcr.io/owasp/opencre/opencre:latest

Une fois que le conteneur a fini de télécharger les informations distantes, vous pouvez y accéder sur http://127.0.0.1:5000.

Si vous souhaitez développer sur OpenCRE ou si Docker n'est pas disponible dans votre environnement, vous pouvez également l'exécuter via la CLI.

Ligne de commande

Pour exécuter en dehors de Docker, vous devez installer OpenCRE. Pour installer cette application, vous avez besoin de python3, yarn et virtualenv.

Clonez le dépôt :

git clone https://github.com/OWASP/OpenCRE

(Recommandé) Créez et activez un environnement virtuel Python :

python3 -m venv venv
source venv/bin/activate

Installez les dépendances :

make install

Téléchargez le dernier graphe CRE depuis l'amont en exécutant :

make upstream-sync

Vous pouvez précalculer le cache local d'analyse des écarts après les imports avec :

make backfill-gap-analysis

Pour exécuter CRE localement, vous pouvez ensuite faire :

make dev-flask

Pour exécuter l'application CLI, vous pouvez lancer :

python cre.py --help

Pour exporter la taxonomie CRE + normes au format CSV (adapté à la CI), exécutez :

python cre.py --export --csv <path/to/output.csv>

Exemple :

python cre.py --export --csv artifacts/cres_and_standards.csv

Remarques :

• --export est un mode d'exportation dédié et se termine après l'écriture du CSV.
• --csv est requis lors de l'utilisation de --export.
• Ce mode exporte les données de rapport de l'API OpenCRE et ne modifie pas la base de données locale.

Pour télécharger localement une feuille de calcul CRE distante, vous pouvez exécuter :

python cre.py --review --from_spreadsheet <google sheets url>

Pour ajouter une feuille de calcul distante à votre base de données locale, vous pouvez exécuter :

python cre.py --add --from_spreadsheet <google sheets url>

Pour exécuter l'application web en développement, vous pouvez lancer :

make start-containers
make start-worker

# in a separate shell
make dev-flask

Alternativement, vous pouvez utiliser le Dockerfile avec :

make docker && make docker-run

Certaines fonctionnalités comme l'analyse des écarts (Gap Analysis) nécessitent une base de données neo4j en cours d'exécution ; vous pouvez la démarrer avec :

make docker-neo4j

Pour exécuter uniquement le remplissage des paires manquantes de l'analyse des écarts (sans démarrer Flask), utilisez :

RUN_COUNT=8 bash scripts/backfill_gap_analysis.sh

Opérations de base de données en production (opencreorg)

Privilégiez les scripts dédiés dans scripts/db/ pour les opérations de production. Ces scripts appliquent des garde-fous de sécurité et créent toujours une sauvegarde fraîche avant toute modification de la base de données.

• Sauvegarde uniquement :
  • APP_NAME=opencreorg scripts/db/backup-opencreorg.sh
• Synchroniser le Postgres local vers Heroku :
  • APP_NAME=opencreorg SOURCE_DB_URL="postgresql://cre:[email protected]:5432/cre" scripts/db/sync-local-to-opencreorg.sh
• Intervention SQL ciblée :
  • APP_NAME=opencreorg scripts/db/surgery-opencreorg.sh --sql-file ./tmp/change.sql

Pour une intervention destructrice (DELETE, DROP, TRUNCATE, ALTER irréversible), utilisez :

APP_NAME=opencreorg \
CONFIRM_DESTRUCTIVE=I_UNDERSTAND_OPENCREORG_PROD_DB_DESTRUCTIVE_ACTION \
scripts/db/surgery-opencreorg.sh --sql-file ./tmp/destructive-change.sql --destructive

Manuels d'exploitation :

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

Variables d'environnement pour que l'application se connecte à neo4jDB (par défaut) :

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

Pour exécuter l'application web en production, vous avez besoin de gunicorn et vous pouvez lancer depuis le répertoire cre_sync :

make prod-run

Notes macOS (Apple Silicon et Intel)

OpenCRE est entièrement pris en charge sur macOS. Les notes suivantes sont facultatives et destinées à aider les contributeurs qui exécutent OpenCRE localement sur des systèmes macOS.

Prérequis

Installez les outils requis avec Homebrew :

brew install [email protected] yarn make

Remarque : Python 3.11 est recommandé. Les versions plus récentes de Python peuvent provoquer des incompatibilités de dépendances.

Vérifiez la version de Python :

python3 --version

Configuration de l'environnement virtuel

Créez et activez un environnement virtuel explicitement avec Python 3 :

python3 -m venv venv
source venv/bin/activate

Mettez à niveau pip :

pip install --upgrade pip

Installation des dépendances

Installez les dépendances en suivant le processus standard :

make install

Si vous rencontrez des problèmes de compilation, assurez-vous que les outils en ligne de commande Xcode sont installés :

xcode-select --install

Exécution locale

Synchronisez les données CRE amont (nécessite un accès Internet) :

make upstream-sync

Puis démarrez le serveur local :

make dev-flask

L'application sera disponible à l'adresse :

http://127.0.0.1:5000

Astuce : pour la plupart des utilisateurs de macOS, l'exécution via Docker est l'approche la plus simple et la plus fiable.

Utilisation de l'API OpenCRE

Consultez le guide d'utilisation de myOpenCRE pour utiliser l'API OpenCRE afin, par exemple, d'ajouter vos propres directives et normes de sécurité.

Construction et exécution avec Docker

Vous pouvez construire les images Docker de production ou de développement avec :

make docker-prod
make docker-dev

Les variables d'environnement utilisées par OpenCRE sont :

Configuration de l'environnement

Copiez le fichier de configuration d'exemple :

cp .env.example .env

Puis modifiez .env et fournissez les valeurs adaptées à votre environnement.

Variables

• Base de données : 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
• Modèles/relances LLM : CRE_LLM_CHAT_MODEL, CRE_EMBED_ALIGN_MODEL, ,

Voir .env.example pour la liste complète et les valeurs par défaut.

Backend LiteLLM (optionnel)

OpenCRE utilise LiteLLM pour les appels aux LLM. Configurez les modèles et les identifiants du fournisseur via les variables d'environnement.

Exemple minimal recommandé :

# 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

Remarques :

• Traitez les modifications de CRE_EMBED_MODEL ou CRE_EMBED_EXPECTED_DIM comme un événement de migration de données (nécessite généralement une ré-embedding).
• CRE_EMBED_EXPECTED_DIM est une protection : les écritures échouent rapidement en cas d'incohérence de dimension.
• Gardez les modèles de chat/alignement et le modèle d'embedding configurables indépendamment ; seuls les embeddings doivent rester dimensionnellement compatibles avec les vecteurs stockés.

Vous pouvez exécuter les conteneurs avec :

make docker-prod-run
make docker-dev-run

Développement

Vous pouvez exécuter les tests du backend avec :

make test

Vous pouvez obtenir un rapport de couverture avec :

make cover

Essayez de maintenir la couverture au-dessus de 70 %.