Cómo integrar GitHub Advanced Security con DefectDojo

in ☁️ Cloud & DevOps on by Gisela Torres
1 Me Gusta
GHAS y DefectDojo
View as Markdown

🔄 Actualizado: 11 de Marzo de 2026

¡Hola developer 👋🏻!

En muchos clientes con los que tengo la oportunidad de hablar sobre GitHub Advanced Security (GHAS) hay una pregunta que aparece una y otra vez:

“¿Puedo integrar las alertas de GitHub Advanced Security en mi herramienta de gestión de vulnerabilidades?”

Y normalmente esa herramienta suele ser DefectDojo, aunque también aparecen otras plataformas internas o soluciones personalizadas que muchas organizaciones utilizan para centralizar vulnerabilidades de distintas fuentes.

Es una pregunta muy razonable. En muchos entornos de seguridad ya existe una herramienta donde se agregan resultados de múltiples scanners, y lo que los equipos quieren es poder incorporar también las alertas que genera GitHub Advanced Security dentro de ese flujo.

Si todavía no conoces GitHub Advanced Security aquí te dejo un vídeo de mi canal de YouTube donde te muestro algunas de sus características:

En este artículo quiero compartir contigo una prueba de concepto (POC) que he construido para ver qué tan viable es mover a DefectDojo las alertas de:

  • Code Scanning
  • Secret Scanning
  • Dependabot Security Alerts

y qué opciones tenemos hoy para integrarlas.

¿Qué es DefectDojo?

Antes de mostrar cómo integrar GHAS con esta herramienta, merece la pena entender brevemente para qué sirve DefectDojo 😊

DefectDojo es una plataforma de gestión de vulnerabilidades de seguridad en aplicaciones que automatiza la agregación, normalización y gestión de hallazgos de seguridad.

En lugar de revisar los resultados de cada scanner por separado, DefectDojo permite centralizar los resultados en un único lugar.

Esto facilita:

  • agregar resultados de múltiples herramientas
  • estandarizar datos de seguridad
  • priorizar vulnerabilidades
  • gestionar hallazgos a lo largo del tiempo
  • generar reporting consolidado

Actualmente DefectDojo puede integrarse con más de 180 herramientas de seguridad.

La forma principal de hacerlo es mediante importers, que permiten importar resultados generados por scanners externos.

Existe un importer específico para GitHub, pero actualmente solo soporta Dependabot Security Alerts.

Por eso me puse a investigar cómo integrar también:

  • Code Scanning
  • Secret Scanning

Entorno de pruebas

Para mi prueba de concepto lo único que he hecho ha sido clonar el repo de la herramienta en mi local y arrancar la herramienta usando Docker compose.

git clone https://github.com/DefectDojo/django-DefectDojo.git
cd django-DefectDojo
docker compose up -d

Una vez que el entorno esté ejecutándose (puede tardar unos minutos porque tiene muchos contenedores que levantar) puedes recuperar la contraseña del admin usando este comando:

docker compose logs initializer | grep "Admin password:"

y acceder a la interfaz utilizando http://localhost:8080

Exponer entorno de pruebas usando un tunnel

Para que GitHub Actions pueda enviar datos a esta instancia de DefectDojo, necesitamos exponer el servicio mediante un túnel.

Puedes usar herramientas como:

  • ngrok
  • cloudflared
  • Pinggy
  • o cualquier alternativa similar

En mi caso utilicé Pinggy.io porque no requiere instalar nada en mi máquina.

Para exponer el puerto 8080 basta con ejecutar:

ssh -p 443 -R0:localhost:8080 qr@a.pinggy.io

Si utilizas la versión gratuita, los túneles duran 1 hora, pero basta con ejecutar el comando de nuevo para generar una nueva URL.

Cómo integrar GitHub Advanced Security con DefectDojo

Para poder demostrar que es posible integrar las alertas que nos ofrece GHAS en DefectDojo he creado este repositorio que está compuesto de varias cosas:

  1. Por un lado en el directorio requests hay varios archivos para la extensión REST Client que me va a permitir probar las diferentes integraciones antes de hacerlas realidad dentro de un flujo de GitHub Actions (más fácil de probar en local).
  2. Los flujos de GitHub Actions dentro del directorio .github/workflows.

Importar las alertas de Dependabot Security

Se podría decir que este tipo de alertas son las más sencillas, ya que DefectDojo tiene un importer específico para este tipo. Esta utiliza una consulta de tipo GraphQL que en la documentación no se especifica 😖 peeero esta es la que necesitas 😃:

POST https://api.github.com/graphql
Content-Type: application/json
Authorization: Bearer {{ PAT }}
X-REQUEST-TYPE: GraphQL
query ($name: String!, $owner: String!) {  
  repository(owner: $owner, name: $name) {
    nameWithOwner
    url
    vulnerabilityAlerts(first: 20) {
      totalCount
      nodes {
        id
        number
        createdAt
        state
        vulnerableManifestPath
        vulnerableRequirements        
        securityVulnerability {
          package {
            name
          }
          advisory {
            severity
            summary
            description
            references{
              url
            }
            identifiers {
              type
              value
            }
            cvss {
              score     
              vectorString        
            }
            cwes(first: 5) {              
              nodes {
                cweId
                name
                description
              }
            }
          }
        }        
      }
    }
    nameWithOwner
    url
  }
}
{
    "name": "{{ REPO_NAME }}",
    "owner": "{{ OWNER }}"
}

Esta va a devolver las alertas en el formato que el importer espera y la puedes probar en local usando este archivo /requests/ghas_alerts_requests.http En DefectDojo las importaciones tienen que ir asociadas a un Producto y este tener lo que se conoce como un Engagement. Si estás ejecutando una instancia de prueba, puedes crear de forma sencilla estos artefactos usando este archivo: requests/create_defectDojo_artifacts.http

Por otro lado, si quieres integrar esta llamada como parte de un flujo de GitHub Actions en este flujo puedes ver cómo lanzarlo: .github/workflows/send_dependabot_security_alerts.yml Para poder ejecutar el mismo satisfactoriamente necesitas 4 cosas principalmente:

  1. El producto que hayas creado en DefectDojo
  2. La URL de tu DefectDojo que debería de ser tu tunel + /api/v2
  3. El engagement ID donde se va a asociar la importación que se haga
  4. Una GitHub App para poder hacer la llamada a la API de GraphQL y recuperar las alertas.

Para este último punto, la GitHub App solamente necesita los scopes:

  • Code scanning alerts (Read-only)
  • Dependabot alerts (Read-only)
  • Secret scanning alerts (Read-only)

Por último, la llamada a la API de DefectDojo tendrá la siguiente pinta:

            - name: Upload Results to DefectDojo
              run: |
                curl -X POST "${{ env.DEFECTDOJO_URL }}/import-scan/" \
                -H "Authorization: Token ${{ secrets.DEFECTDOJO_TOKEN }}" \
                -F 'product_name=${{ env.DEFECTDOJO_PRODUCT_NAME }}' \
                -F 'engagement=${{ env.ENGAGEMENT_ID }}' \
                -F 'scan_type="Github Vulnerability Scan"' \
                -F 'file=@dependabot-security-alerts.json'

Como puedes ver en este caso el valor de scan_type es Github Vulnerability Scan.

Importar las alertas de Code Scanning

Para el caso de las alertas de code scanning no tenemos un importer específico para este tipo pero sí existe un importer de tipo SARIF que es justamente el formato que utilizan este tipo de alertas en la plataforma de GitHub. En este caso, al igual que en el anterior hace falta un producto y un engagement en el cual asociar las importaciones, pero podemos reutilizar el mismo. Si quieres ver las alertas que tiene un repo de este tipo en local puedes usar este archivo: requests/send_code_scanning_alerts.http

Por otro lado, lo que he hecho para estas alertas ha sido aprovecharme del flujo de CodeQL (el cual tengo en modo avanzado y lo he llamado .github/workflows/codeql_and_defectdojo.yml) para que, una vez que termine el mismo coger directamente los archivos de tipo SARIF que genera y subirlos a la plataforma (y también como parte de los artefactos de la ejecución por si quiero probarlos con el archivo send_code_scanning_alerts.http):

    - name: Extract repository name
      run: |
        REPO_NAME=$(echo ${{ github.repository }} | cut -d'/' -f2)
        echo "REPO_NAME=$REPO_NAME" >> $GITHUB_ENV
    - name: Upload a Build Artifact
      uses: actions/upload-artifact@v4.6.0
      with:
        # Artifact name
        name: ${{matrix.language}}-codeql-result
        # A file, directory or wildcard pattern that describes what to upload
        path:  /home/runner/work/${{ env.REPO_NAME }}/results/${{matrix.language}}.sarif
    - name: Upload Results to DefectDojo
      run: |
        curl -X POST "${{ env.DEFECTDOJO_URL }}/import-scan/" \
        -H "Authorization: Token ${{ secrets.DEFECTDOJO_TOKEN }}" \
        -F 'product_name=${{ env.DEFECTDOJO_PRODUCT_NAME }}' \
        -F 'engagement=${{ env.ENGAGEMENT_ID }}' \
        -F 'scan_type="SARIF"' \
        -F 'file=@/home/runner/work/${{ env.REPO_NAME }}/results/${{matrix.language}}.sarif'

Importas las alertas de Secret Scanning

Y ya por último, el caso más «complicado» ha sido con las alertas relacionadas con los secretos ya que la respuesta de la API no encaja con ninguno de los importers que tiene DefectDojo a día de hoy. Pero no pasa nada, lo que he hecho ha sido, en primer lugar, usando ese archivo create_defectDojo_artifacts.http un nuevo tipo de test que he llamado GitHub Advanced Security – Secret Scanning (puedes llamarlo como quieras):

// For the secrets you'll need to create  a new test type.
# @name addTestType
POST {{baseUrl}}/test_types/
Authorization: Token {{token}}
Content-Type: application/json
{
  "name": "GitHub Advanced Security - Secret Scanning",
  "description": "GitHub Advanced Security - Secret Scanning",
  "static_tool": true,
  "active": true 
}
@testTypeId = {{ addTestType.response.body.id }}

y luego crear un test de ese tipo:

// And then a test to associate the findings with.
# @name addTest
POST {{baseUrl}}/tests/
Authorization: Token {{token}}
Content-Type: application/json
{
  "title": "GitHub Advanced Security - Secret Scanning", 
  "engagement": {{engagementId}},
  "test_type": {{testTypeId}},
  "target_start": "2025-02-20",
  "target_end": "2025-02-20"
}
###
@testId = {{ addTest.response.body.id }}

O si quieres, puedes utilizar este archivo con todos los pasos para este escenario en concreto: requests/send_secrets_alerts.http El reto aquí ha sido recuperar el JSON que me sirviera para cuadrarlo con las propiedades que tiene que tener un JSON de tipo finding. Para ello he estado jugando con este otro archivo .jq que puedes usar cómodamente con la extensión Visual Code jq playground, dandole la forma que me ha parecido a cada uno de los cambios. Obviamente esto en una POC y estoy segura que para un entorno productivo hacen falta más datos, pero eran más que suficientes para probar que la integración funciona.

Y ya, por último, te he dejado este flujo que hace todo este proceso: .github/workflows/send_secrets_to_defectdojo.yml El cual se vuelve a apoyar en la GitHub App que uso en el flujo para las alertas de Dependabot y en JQ para poder dar forma a las alertas y luego finalmente enviarlas a DefectDojo 😃

Si quieres saber más sobre la cultura DevSecOps puedes echarle un vistazo a mi serie en mi canal de YouTube:

¡Nos vemos 👋🏻!

Deja un comentario

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.