OpenCRE

Visita https://www.opencre.org para ver OpenCRE en funcionamiento y más explicaciones. OpenCRE significa Open Common Requirement enumeration (enumeración abierta de requisitos comunes). Es una plataforma interactiva de enlace de contenidos para unir estándares y guías de seguridad. Ofrece un acceso fácil y robusto a la información relevante al diseñar, desarrollar, probar y adquirir software seguro.

OpenCRE consta de:

• La aplicación: una aplicación web y CLI en Python para acceder a los datos, que se ejecuta públicamente en opencre.org
• Los datos del catálogo: un catálogo de requisitos comunes (CREs)
• Los datos de mapeo: enlaces desde cada CRE a las secciones relevantes de una variedad de estándares
• Herramientas y guías para contribuir a los datos y ejecutar la aplicación localmente

Contribuye con código o mapeos

Para ver cómo puedes contribuir a la aplicación o a los datos (catálogo o mapeos de estándares), consulta Contribuciones. ¡Te damos una cálida bienvenida!

Documentación

• Documentación en la aplicación — primeros pasos, FAQ y referencia interactiva de la API
• FAQ — preguntas frecuentes (también se muestra en /docs#faq)
• Especificación OpenAPI — API REST pública (/rest/v1/openapi.yaml cuando está en ejecución)

Hoja de ruta

Para la hoja de ruta, consulta los issues.

Ejecutar tu propio OpenCRE

Eres libre de usar la aplicación pública de OpenCRE en opencre.org. Además, puedes ejecutar la tuya propia si quieres incluir, por ejemplo, tus propios estándares y guías de seguridad. A eso lo llamamos myOpenCRE.

Localmente

Docker

La forma más sencilla de ejecutar OpenCRE localmente es mediante el contenedor Docker publicado. Puedes hacerlo ejecutando:

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

Una vez que el contenedor haya terminado de descargar la información remota, puedes acceder a él en http://127.0.0.1:5000.

Si quieres desarrollar en OpenCRE o Docker no está disponible en tu entorno, también puedes ejecutarlo mediante la CLI.

Línea de comandos

Para ejecutarlo fuera de Docker necesitas instalar OpenCRE. Para instalar esta aplicación necesitas python3, yarn y virtualenv.

Clona el repositorio:

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

(Recomendado) Crea y activa un entorno virtual de Python:

python3 -m venv venv
source venv/bin/activate

Instala las dependencias:

make install

Descarga el último grafo de CRE desde el upstream ejecutando:

make upstream-sync

Puedes precalcular la caché local de gap-analysis después de las importaciones con:

make backfill-gap-analysis

Para ejecutar CRE localmente, puedes hacer:

make dev-flask

Para ejecutar la aplicación CLI, puedes ejecutar:

python cre.py --help

Para exportar la taxonomía de CRE + estándares a CSV (compatible con CI), ejecuta:

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

Ejemplo:

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

Notas:

• --export es un modo de exportación dedicado que finaliza después de escribir el CSV.
• --csv es obligatorio cuando se usa --export.
• Este modo exporta los datos de informes desde la API de OpenCRE y no modifica la base de datos local.

Para descargar una hoja de cálculo CRE remota localmente, puedes ejecutar:

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

Para añadir una hoja de cálculo remota a tu base de datos local, puedes ejecutar:

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

Para ejecutar la aplicación web en modo desarrollo, puedes ejecutar:

make start-containers
make start-worker

# in a separate shell
make dev-flask

Alternativamente, puedes usar el dockerfile con:

make docker && make docker-run

Algunas funciones, como Gap Analysis, requieren una base de datos neo4j en ejecución; puedes iniciarla con:

make docker-neo4j

Para ejecutar únicamente el backfill de pares de gap-analysis faltantes (sin iniciar Flask), usa:

RUN_COUNT=8 bash scripts/backfill_gap_analysis.sh

Operaciones de base de datos en producción (opencreorg)

Para las operaciones de producción, prefiere los scripts dedicados en scripts/db/. Estos scripts aplican salvaguardas de seguridad y siempre realizan una copia de seguridad nueva antes de cualquier cambio en la base de datos.

• Solo copia de seguridad:
  • APP_NAME=opencreorg scripts/db/backup-opencreorg.sh
• Sincronizar Postgres local con Heroku:
  • APP_NAME=opencreorg SOURCE_DB_URL="postgresql://cre:[email protected]:5432/cre" scripts/db/sync-local-to-opencreorg.sh
• Cirugía SQL específica:
  • APP_NAME=opencreorg scripts/db/surgery-opencreorg.sh --sql-file ./tmp/change.sql

Para cirugía destructiva (DELETE, DROP, TRUNCATE, ALTER irreversible), usa:

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

Runbooks:

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

Variables de entorno para que la aplicación se conecte a neo4jDB (por defecto):

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

Para ejecutar la aplicación web en producción necesitas gunicorn y puedes ejecutarla desde el directorio cre_sync:

make prod-run

Notas para macOS (Apple Silicon e Intel)

OpenCRE es totalmente compatible con macOS. Las siguientes notas son opcionales y están pensadas para ayudar a los colaboradores que ejecutan OpenCRE localmente en sistemas macOS.

Requisitos previos

Instala las herramientas necesarias con Homebrew:

brew install [email protected] yarn make

Nota: se recomienda Python 3.11. Las versiones más recientes de Python pueden causar incompatibilidades de dependencias.

Verifica la versión de Python:

python3 --version

Configuración del entorno virtual

Crea y activa un entorno virtual explícitamente con Python 3:

python3 -m venv venv
source venv/bin/activate

Actualiza pip:

pip install --upgrade pip

Instalación de dependencias

Instala las dependencias con el flujo de trabajo estándar:

make install

Si encuentras problemas de compilación, asegúrate de que Xcode Command Line Tools esté instalado:

xcode-select --install

Ejecución local

Sincroniza los datos CRE del upstream (requiere acceso a internet):

make upstream-sync

Luego inicia el servidor local:

make dev-flask

La aplicación estará disponible en:

http://127.0.0.1:5000

Consejo: para la mayoría de los usuarios de macOS, ejecutarlo mediante Docker es el enfoque más sencillo y fiable.

Uso de la API de OpenCRE

Consulta la guía de usuario de myOpenCRE sobre el uso de la API de OpenCRE para, por ejemplo, añadir tus propias guías y estándares de seguridad.

Compilación y ejecución con Docker

Puedes compilar las imágenes Docker de producción o de desarrollo con:

make docker-prod
make docker-dev

Las variables de entorno utilizadas por OpenCRE son:

Configuración del entorno

Copia el archivo de configuración de ejemplo:

cp .env.example .env

Luego edita .env y proporciona los valores adecuados para tu entorno.

Variables

• Base de datos: 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
• Modelos/reintentos de LLM: CRE_LLM_CHAT_MODEL, CRE_EMBED_ALIGN_MODEL, ,

Consulta .env.example para ver la lista completa y los valores por defecto.

Backend LiteLLM (opcional)

OpenCRE utiliza LiteLLM para las llamadas de LLM. Configura los modelos y las credenciales del proveedor mediante variables de entorno.

Ejemplo mínimo recomendado:

# 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

Notas:

• Trata los cambios en CRE_EMBED_MODEL o CRE_EMBED_EXPECTED_DIM como un evento de migración de datos (normalmente requiere volver a generar los embeddings).
• CRE_EMBED_EXPECTED_DIM es una salvaguarda: las escrituras fallan rápidamente si las dimensiones no coinciden.
• Mantén los modelos de chat/alineación y el modelo de embeddings configurables de forma independiente; solo los embeddings deben seguir siendo compatibles en dimensiones con los vectores almacenados.

Puedes ejecutar los contenedores con:

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

Desarrollo

Puedes ejecutar las pruebas del backend con:

make test

Puedes obtener un informe de cobertura con:

make cover

Intenta mantener la cobertura por encima del 70%.