Offenlegung von Versionskontroll-Repository für unbefugte Kontrollsphäre

Beschreibung

Offenlegung von Versionskontroll-Repository für unbefugte Kontrollsphäre ist eine Schwachstelle, bei der ein Produkt ein CVS-, Git-, SVN- oder anderes Versionskontroll-Repository in einem Verzeichnis, Archiv oder einer anderen Ressource speichert, die für unbefugte Akteure zugänglich ist. Versionskontroll-Repositories enthalten Metadaten und Details in Unterverzeichnissen (wie .git, .svn, .hg), die ausgenutzt werden könnten, wenn sie auf Webservern oder in verteilten Archiven offengelegt werden. Diese Offenlegung kann Benutzernamen, Commit-Nachrichten, Dateinamen, Pfadstrukturen, IP-Adressen und detaillierte Diff-Daten enthüllen, die Quellcode-Ausschnitte offenlegen, die nie für öffentlichen Zugriff bestimmt waren.

Risiko

Offengelegte Versionskontroll-Repositories liefern Angreifern umfassende Aufklärungsinformationen. Die vollständige Quellcode-Historie kann aus .git-Verzeichnissen rekonstruiert werden und Sicherheitsschwachstellen, hartcodierte Anmeldedaten, API-Schlüssel und sensible Geschäftslogik enthüllen. Commit-Nachrichten können sicherheitsrelevante Informationen wie "SQL-Injection behoben" enthalten, die Angreifer auf Schwachstellen hinweisen. Autoreninformationen können für Social Engineering verwendet werden. Interne Dateipfade enthüllen die Serverstruktur. Frühere Versionen können Geheimnisse enthalten, die "gelöscht" wurden, aber in der Historie verbleiben. Angreifer scannen häufig nach .git/HEAD, .svn/entries oder ähnlichen Dateien als Teil der Aufklärung.

Lösung

Entfernen Sie alle Versionskontroll-Verzeichnisse und Metadaten aus Produktions-Deployments und öffentlich zugänglichen Servern. Konfigurieren Sie Webserver, um den Zugriff auf versteckte Verzeichnisse, die mit einem Punkt beginnen, zu verweigern. Verwenden Sie Deployment-Tools, die VCS-Metadaten ausschließen. Implementieren Sie Pre-Deployment-Prüfungen zur Erkennung von VCS-Artefakten. Konfigurieren Sie .gitignore und ähnliche Dateien, um zu verhindern, dass sensible Dateien getrackt werden. Verwenden Sie git archive oder äquivalente Befehle, die Quellcode ohne VCS-Metadaten exportieren. Blockieren Sie Anfragen an VCS-Pfade auf Webserver- oder CDN-Ebene. Prüfen Sie regelmäßig öffentlich zugängliche Systeme auf offengelegte Repositories.

Häufige Auswirkungen

Auswirkung	Details
Vertraulichkeit	Bereich: Vertraulichkeit Anwendungsdaten lesen - Angreifer können auf Quellcode, Konfigurationsdateien und sensible Daten aus der Versionskontroll-Historie zugreifen.
Vertraulichkeit	Bereich: Vertraulichkeit Dateien oder Verzeichnisse lesen - Versionskontroll-Metadaten legen Dateinamen, Verzeichnisstruktur, Benutzernamen und andere sensible Informationen über die Anwendung und ihre Entwickler offen.

Beispielcode

Verwundbare Konfiguration

# Verwundbar: Apache-Konfiguration erlaubt Zugriff auf VCS-Verzeichnisse
<VirtualHost *:80>
    ServerName example.com
    DocumentRoot /var/www/html

    # Keine Einschränkungen für versteckte Verzeichnisse
    # .git, .svn, .hg sind alle zugänglich

    # Angreifer kann zugreifen:
    # http://example.com/.git/HEAD
    # http://example.com/.git/config
    # http://example.com/.git/objects/
    # http://example.com/.svn/entries
</VirtualHost>

# Verwundbar: Nginx ohne VCS-Verzeichnisschutz
server {
    listen 80;
    server_name example.com;
    root /var/www/html;

    # Keine Location-Blöcke, die versteckte Verzeichnisse blockieren
    # .git-Verzeichnis vollständig offengelegt
}

# Verwundbar: Deployment das VCS-Metadaten einschließt
#!/bin/bash

# Verwundbar: Gesamtes Projekt einschließlich .git kopieren
cp -r /home/developer/project/* /var/www/html/

# Verwundbar: rsync ohne Ausschlusse
rsync -avz /home/developer/project/ /var/www/html/

# Verwundbar: tar ohne Ausschlusse
tar czf release.tar.gz /home/developer/project/
scp release.tar.gz server:/var/www/

# Auf Server, extrahiert mit intaktem .git
tar xzf release.tar.gz

# Verwundbar: Docker-Image mit VCS-Verzeichnis
FROM nginx:alpine

# Verwundbar: Kopiert gesamtes Verzeichnis einschließlich .git
COPY . /usr/share/nginx/html/

# .git-Verzeichnis ist jetzt im Image und wird von nginx bereitgestellt

# Verwundbar: CI/CD-Pipeline ohne Bereinigung
# GitHub Actions-Beispiel
name: Deploy
on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2

      # Verwundbar: Deployed Checkout einschließlich .git
      - name: Auf Server deployen
        run: |
          rsync -avz ./ user@server:/var/www/html/

Angreifer-Aufklärung

# Angreifer entdeckt offengelegtes .git-Verzeichnis
curl -I https://target.com/.git/HEAD
# HTTP/1.1 200 OK

# Git-Objekte herunterladen
wget -r --no-parent https://target.com/.git/

# Repository rekonstruieren
cd target.com
git checkout -- .

# Commit-Historie mit Geheimnissen anzeigen
git log --all --full-history
git log -p  # Diffs anzeigen

# Nach Geheimnissen in Historie suchen
git log -p | grep -i "password\|secret\|key\|token"

# Gelöschte sensible Dateien finden
git log --all --full-history -- "**/config.php"
git show <commit>:config.php

# Automatisierter .git-Offenlegungs-Scanner
import requests

def check_git_exposure(url):
    endpoints = [
        '/.git/HEAD',
        '/.git/config',
        '/.git/index',
        '/.git/logs/HEAD',
        '/.svn/entries',
        '/.svn/wc.db',
        '/.hg/requires',
        '/CVS/Root',
    ]

    for endpoint in endpoints:
        try:
            resp = requests.get(url + endpoint, timeout=5)
            if resp.status_code == 200:
                print(f"[VERWUNDBAR] {url}{endpoint}")
                return True
        except:
            pass
    return False

Behobene Konfiguration

# Behoben: Apache blockiert VCS-Verzeichnisse
<VirtualHost *:80>
    ServerName example.com
    DocumentRoot /var/www/html

    # Behoben: Alle versteckten Verzeichnisse blockieren
    <DirectoryMatch "^\.|\/\.">
        Require all denied
    </DirectoryMatch>

    # Behoben: VCS-Verzeichnisse explizit blockieren
    <DirectoryMatch "(\.git|\.svn|\.hg|CVS)">
        Require all denied
    </DirectoryMatch>

    # Behoben: VCS-Dateien blockieren
    <FilesMatch "(\.gitignore|\.gitmodules|\.svn|\.hg)$">
        Require all denied
    </FilesMatch>
</VirtualHost>

# Behoben: Nginx blockiert VCS-Verzeichnisse
server {
    listen 80;
    server_name example.com;
    root /var/www/html;

    # Behoben: Alle versteckten Dateien und Verzeichnisse blockieren
    location ~ /\. {
        deny all;
        return 404;
    }

    # Behoben: VCS-Verzeichnisse explizit blockieren
    location ~ /\.(git|svn|hg|bzr|cvs)/ {
        deny all;
        return 404;
    }

    # Behoben: Spezifische VCS-Dateien blockieren
    location ~ /\.(gitignore|gitmodules|gitattributes)$ {
        deny all;
        return 404;
    }
}

# Behoben: Deployment-Skripte die VCS-Metadaten ausschließen
#!/bin/bash

# Behoben: git archive zum Export ohne .git verwenden
git archive --format=tar HEAD | tar -x -C /var/www/html/

# Behoben: rsync mit Ausschlussen
rsync -avz \
    --exclude='.git' \
    --exclude='.svn' \
    --exclude='.hg' \
    --exclude='.gitignore' \
    --exclude='CVS' \
    /home/developer/project/ /var/www/html/

# Behoben: tar mit Ausschlussen
tar czf release.tar.gz \
    --exclude='.git' \
    --exclude='.svn' \
    --exclude='.hg' \
    /home/developer/project/

# Behoben: Alle VCS-Verzeichnisse nach Deployment finden und entfernen
find /var/www/html -type d -name ".git" -exec rm -rf {} + 2>/dev/null
find /var/www/html -type d -name ".svn" -exec rm -rf {} + 2>/dev/null
find /var/www/html -type d -name ".hg" -exec rm -rf {} + 2>/dev/null

# Behoben: Verifikation
if [ -d "/var/www/html/.git" ]; then
    echo "FEHLER: .git-Verzeichnis im Deployment gefunden!"
    exit 1
fi

# Behoben: Docker-Image ohne VCS-Verzeichnisse
FROM nginx:alpine

# Behoben: .dockerignore zum Ausschluss von VCS verwenden
# .dockerignore-Inhalt:
# .git
# .svn
# .hg
# .gitignore
# .gitmodules

# Oder nur benötigte Dateien explizit kopieren
COPY --chown=nginx:nginx src/ /usr/share/nginx/html/
COPY --chown=nginx:nginx public/ /usr/share/nginx/html/

# Behoben: VCS-Artefakte entfernen, die durchschlüpfen könnten
RUN find /usr/share/nginx/html -name ".git*" -type d -exec rm -rf {} + 2>/dev/null || true && \
    find /usr/share/nginx/html -name ".svn" -type d -exec rm -rf {} + 2>/dev/null || true

# Behoben: CI/CD-Pipeline mit ordnungsgemäßer Bereinigung
name: Deploy
on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2

      # Behoben: VCS-Artefakte vor Deployment entfernen
      - name: VCS-Artefakte bereinigen
        run: |
          rm -rf .git .gitignore .gitmodules
          find . -name ".git*" -type d -exec rm -rf {} + 2>/dev/null || true

      # Behoben: Oder git archive verwenden
      - name: Sauberes Archiv erstellen
        run: |
          git archive --format=tar --output=release.tar HEAD
          mkdir deploy
          tar -xf release.tar -C deploy/

      - name: Auf Server deployen
        run: |
          rsync -avz --delete deploy/ user@server:/var/www/html/

      # Behoben: Deployment verifizieren
      - name: Verifizieren dass kein VCS offengelegt ist
        run: |
          if curl -s -o /dev/null -w "%{http_code}" https://example.com/.git/HEAD | grep -q "200"; then
            echo "FEHLER: .git-Verzeichnis ist offengelegt!"
            exit 1
          fi

# Behoben: Pre-Deployment-Prüfskript
import os
import sys

def check_vcs_artifacts(deploy_dir):
    """Auf VCS-Artefakte vor Deployment prüfen."""
    vcs_patterns = ['.git', '.svn', '.hg', 'CVS', '.bzr']
    found = []

    for root, dirs, files in os.walk(deploy_dir):
        for pattern in vcs_patterns:
            if pattern in dirs:
                found.append(os.path.join(root, pattern))
            for f in files:
                if f.startswith('.git'):
                    found.append(os.path.join(root, f))

    if found:
        print("FEHLER: VCS-Artefakte im Deployment-Verzeichnis gefunden:")
        for path in found:
            print(f"  - {path}")
        return False
    return True

if __name__ == '__main__':
    deploy_dir = sys.argv[1] if len(sys.argv) > 1 else '/var/www/html'
    if not check_vcs_artifacts(deploy_dir):
        sys.exit(1)
    print("OK: Keine VCS-Artefakte gefunden")

---

CVE-Beispiele

Keine spezifischen CVEs sind in der MITRE-Datenbank für dieses CWE gelistet. Offengelegte Git-Repositories waren jedoch an zahlreichen Sicherheitsvorfällen beteiligt:

• Offengelegte .git-Verzeichnisse haben zu Quellcode-Lecks bei großen Unternehmen geführt
• In der Git-Historie gefundene Anmeldedaten haben Kontoübernahmen ermöglicht
• Dies ist ein häufiger Fund in Bug-Bounty-Programmen

---

Referenzen

1. MITRE. "CWE-527: Exposure of Version-Control Repository to an Unauthorized Control Sphere." https://cwe.mitre.org/data/definitions/527.html

2. OWASP. "Source Code Disclosure."

3. GitTools. "Tools für die Ausnutzung offengelegter .git-Verzeichnisse."