Verlass auf unzureichend vertrauenswürdige Komponente

Beschreibung

Verlass auf unzureichend vertrauenswürdige Komponente tritt auf, wenn ein Produkt aus mehreren separaten Komponenten aufgebaut ist, aber eine Komponente verwendet, die nicht ausreichend vertrauenswürdig ist, um Erwartungen an Sicherheit, Zuverlässigkeit, Aktualisierbarkeit und Wartbarkeit zu erfüllen. Produkte, die mehrere Komponenten kombinieren, riskieren die Einbeziehung nicht vertrauenswürdiger Elemente -- ob Drittanbieter-Hardware, Open-Source-Bibliotheken oder interne Legacy-Komponenten. Solche Komponenten können Schwachstellen beherbergen, die nicht zeitnah gepatcht werden können, versteckte Malware enthalten, sich der Aktualisierung widersetzen oder Spezifikationsanforderungen nicht erfüllen. Vertrauensbewertungen variieren zwischen Stakeholdern und erzeugen Kompromisse zwischen Sicherheit, Zuverlässigkeit, Safety und Kosten.

Risiko

Nicht vertrauenswürdige Komponenten haben schwerwiegende Auswirkungen. Supply-Chain-Kompromittierung. Versteckte Schwachstellen in Abhängigkeiten. Unmöglichkeit, Sicherheitsprobleme zu patchen. Malware in Drittanbieter-Code. Fehlende Sicherheitsupdates. Unbekannte Herkunft. Aufgegebene oder nicht gewartete Bibliotheken. Lizenz-Compliance-Probleme. Kaskadierende Schwachstellen. Hohe Wahrscheinlichkeit, wenn Abhängigkeitsmanagement vernachlässigt wird.

Lösung

Sicherstellen, dass Komponenten-Lieferketten Best Practices anwenden und dass Drittanbieter-Software von seriösen, aktiv gewarteten Anbietern stammt, während der Anforderungs- und Architekturphase. Eine Bill of Materials (BOM) und Software Bill of Materials (SBOM) pflegen -- ein formales, maschinenlesbares Inventar von Softwarekomponenten und Abhängigkeiten, während der Implementierungsphase. Komponentenänderungen kontinuierlich überwachen, insbesondere Schwachstellenankündigungen und End-of-Life-Pläne, während der Betriebs- und Patchingphase.

Häufige Auswirkungen

Auswirkung	Details
Integrität	Bereich: Integrität Kompromittierte Komponentenintegrität, die die Gesamtsystemsicherheit beeinträchtigt.
Verfügbarkeit	Bereich: Verfügbarkeit Reduzierte Wartbarkeit und Unmöglichkeit, Schwachstellen zu patchen.

Beispielcode

Verwundbarer Code

// VERWUNDBAR: package.json mit riskanten Abhängigkeiten

{
  "name": "vulnerable-app",
  "version": "1.0.0",
  "dependencies": {
    // VERWUNDBAR: Nicht gewartetes Paket (keine Updates seit 3+ Jahren)
    "abandoned-lib": "^1.0.0",

    // VERWUNDBAR: Paket mit bekannter kritischer Schwachstelle
    "lodash": "4.17.15",

    // VERWUNDBAR: Verwendung von Wildcard-Version (unvorhersehbare Updates)
    "some-package": "*",

    // VERWUNDBAR: Git-Abhängigkeit (keine Versionskontrolle)
    "git-dep": "git://github.com/user/repo.git",

    // VERWUNDBAR: Unbekannter/nicht vertrauenswürdiger Herausgeber
    "shady-npm-pkg": "^2.0.0",

    // VERWUNDBAR: Sehr alte Hauptversion
    "express": "3.0.0"
  }
}

# VERWUNDBAR: Python-Requirements mit riskanten Abhängigkeiten

# requirements.txt

# VERWUNDBAR: Keine Versions-Pinning
requests
django
flask

# VERWUNDBAR: Verwendung eines veralteten/nicht gewarteten Pakets
pycrypto==2.6.1  # Veraltet, pycryptodome verwenden

# VERWUNDBAR: Paket mit bekannten Schwachstellen
PyYAML==5.3  # CVE-2020-14343

# VERWUNDBAR: Installation von beliebiger URL
https://example.com/unknown-package.tar.gz

# VERWUNDBAR: Keine Hash-Verifikation
# pip install --no-verify-hashes

// VERWUNDBAR: Java pom.xml mit Abhängigkeitsproblemen

// pom.xml
/*
<dependencies>
    <!-- VERWUNDBAR: Veraltete Version mit bekannten CVEs -->
    <dependency>
        <groupId>org.apache.struts</groupId>
        <artifactId>struts2-core</artifactId>
        <version>2.3.30</version>  <!-- CVE-2017-5638 -->
    </dependency>

    <!-- VERWUNDBAR: Verwendung von SNAPSHOT (instabil) -->
    <dependency>
        <groupId>com.example</groupId>
        <artifactId>internal-lib</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>

    <!-- VERWUNDBAR: Keine Ausschlusse für transitive Abhängigkeiten -->
    <dependency>
        <groupId>some.group</groupId>
        <artifactId>big-framework</artifactId>
        <version>1.0</version>
        <!-- Zieht Hunderte von transitiven Abhängigkeiten ein -->
    </dependency>
</dependencies>
*/

// VERWUNDBAR: Go mit unverifizierten Abhängigkeiten

// go.mod

// VERWUNDBAR: Verwendung von Pseudo-Version (nicht getaggter Commit)
// require github.com/user/repo v0.0.0-20200101010101-abcdef123456

// VERWUNDBAR: Replace-Direktive zeigt auf lokalen/beliebigen Code
// replace github.com/original/repo => /local/path/to/code
// replace github.com/original/repo => github.com/fork/repo

// Verwundbarer Code, der unverifiziertes Paket verwendet
package main

import (
    // VERWUNDBAR: Import aus unbekannter Quelle
    "github.com/random-user/untrusted-crypto"
)

func main() {
    // Verwendung einer potenziell kompromittierten kryptographischen Bibliothek
    key := untrusted_crypto.GenerateKey()
    // ...
}

Sichere Lösung

// SICHER: package.json mit sicherem Abhängigkeitsmanagement

{
  "name": "secure-app",
  "version": "1.0.0",
  "dependencies": {
    // SICHER: Gepinnte Versionen von seriösen Maintainern
    "lodash": "4.17.21",
    "express": "4.18.2",

    // SICHER: Aktiv gewartete Alternativen
    "axios": "1.4.0"
  },
  "devDependencies": {
    // SICHER: Sicherheits-Scanning-Tools
    "npm-audit": "^1.0.0",
    "snyk": "^1.1000.0"
  },
  "scripts": {
    // SICHER: Sicherheitsprüfungen in CI/CD
    "security-check": "npm audit && snyk test",
    "preinstall": "npm audit"
  },
  "engines": {
    // SICHER: Unterstützte Node.js-Versionen angeben
    "node": ">=18.0.0"
  }
}

// package-lock.json bietet:
// - Exakte Versionen für alle Abhängigkeiten
// - Integritäts-Hashes (SHA-512)
// - Reproduzierbare Builds

# SICHER: Python-Requirements mit Sicherheitspraktiken

# requirements.txt mit gepinnten Versionen und Hashes

# SICHER: Gepinnte Versionen mit Hash-Verifikation
requests==2.31.0 \
    --hash=sha256:58cd2187c01e70e6e26505bca751777aa9f2ee0b7f4300988b709f44e013003f

django==4.2.5 \
    --hash=sha256:b6b2b5cae821077f137dc4898c6b46a3b4e2d2ae0f0eb9a5e6e0e0d3c8a5d4f1

# SICHER: Verwendung gewarteter kryptographischer Bibliothek
pycryptodome==3.19.0 \
    --hash=sha256:abcdef1234567890

# SICHER: Sichere YAML-Bibliothek
PyYAML==6.0.1 \
    --hash=sha256:1234567890abcdef

# requirements-dev.txt
# SICHER: Sicherheits-Scanning-Tools
safety==2.3.5
bandit==1.7.5
pip-audit==2.6.1

# SICHER: Python-Abhängigkeitsverifikation

import subprocess
import hashlib
import json
from typing import Dict, List

class DependencyVerifier:
    """SICHER: Abhängigkeiten vor der Verwendung verifizieren."""

    def __init__(self, sbom_path: str):
        self.sbom = self._load_sbom(sbom_path)

    def _load_sbom(self, path: str) -> Dict:
        """SICHER: Software Bill of Materials laden."""
        with open(path, 'r') as f:
            return json.load(f)

    def verify_all_dependencies(self) -> List[str]:
        """SICHER: Alle Abhängigkeiten gegen SBOM prüfen."""
        issues = []

        for dep in self.sbom.get('dependencies', []):
            name = dep['name']
            expected_version = dep['version']
            expected_hash = dep.get('hash')

            # SICHER: Prüfen ob installierte Version mit SBOM übereinstimmt
            installed = self._get_installed_version(name)
            if installed != expected_version:
                issues.append(f"{name}: Versionsabweichung "
                            f"(erwartet {expected_version}, erhalten {installed})")

            # SICHER: Integritäts-Hash verifizieren
            if expected_hash:
                actual_hash = self._compute_package_hash(name)
                if actual_hash != expected_hash:
                    issues.append(f"{name}: Hash-Abweichung")

            # SICHER: Auf bekannte Schwachstellen prüfen
            vulns = self._check_vulnerabilities(name, expected_version)
            if vulns:
                issues.extend(vulns)

        return issues

    def _check_vulnerabilities(self, name: str, version: str) -> List[str]:
        """SICHER: Gegen Schwachstellendatenbank prüfen."""
        # safety/pip-audit/etc. zur Prüfung verwenden
        result = subprocess.run(
            ['pip-audit', '--requirement', '-', '--strict'],
            input=f'{name}=={version}\n',
            capture_output=True,
            text=True
        )
        if result.returncode != 0:
            return [f"{name}: {result.stdout}"]
        return []

    def generate_sbom(self, output_path: str):
        """SICHER: SBOM im CycloneDX-Format generieren."""
        subprocess.run([
            'cyclonedx-py',
            '--format', 'json',
            '--output', output_path
        ], check=True)

# Verwendung
verifier = DependencyVerifier('sbom.json')
issues = verifier.verify_all_dependencies()
if issues:
    print("Abhängigkeitsverifikation fehlgeschlagen:")
    for issue in issues:
        print(f"  - {issue}")
    exit(1)

// SICHER: Java pom.xml mit sicherem Abhängigkeitsmanagement

/*
<project>
    <properties>
        <!-- SICHER: Zentralisiertes Versionsmanagement -->
        <spring.version>6.0.11</spring.version>
        <jackson.version>2.15.2</jackson.version>
    </properties>

    <dependencyManagement>
        <!-- SICHER: BOM für konsistente Versionen verwenden -->
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-framework-bom</artifactId>
                <version>${spring.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <!-- SICHER: Aktualisierte, gepatchte Version -->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-core</artifactId>
            <version>6.3.0</version>
        </dependency>

        <!-- SICHER: Verwundbare transitive Abhängigkeiten ausschließen -->
        <dependency>
            <groupId>some.group</groupId>
            <artifactId>big-framework</artifactId>
            <version>2.0</version>
            <exclusions>
                <exclusion>
                    <groupId>commons-collections</groupId>
                    <artifactId>commons-collections</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <!-- SICHER: Ausgeschlossene Abhängigkeit durch sichere Version ersetzen -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-collections4</artifactId>
            <version>4.4</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- SICHER: OWASP Dependency Check -->
            <plugin>
                <groupId>org.owasp</groupId>
                <artifactId>dependency-check-maven</artifactId>
                <version>8.4.0</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>check</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <failBuildOnCVSS>7</failBuildOnCVSS>
                </configuration>
            </plugin>

            <!-- SICHER: Abhängigkeitskonvergenz durchsetzen -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-enforcer-plugin</artifactId>
                <version>3.4.1</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>enforce</goal>
                        </goals>
                        <configuration>
                            <rules>
                                <dependencyConvergence/>
                                <banDuplicatePomDependencyVersions/>
                            </rules>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>
*/

// SICHER: Go mit verifizierten Abhängigkeiten

// go.mod mit ordnungsgemäßer Versionierung

/*
module example.com/secure-app

go 1.21

// SICHER: Getaggte Releases verwenden
require (
    github.com/go-chi/chi/v5 v5.0.10
    golang.org/x/crypto v0.14.0
)

// SICHER: go.sum bietet automatisch Hash-Verifikation
// Ausführen: go mod verify
*/

// SICHER: Abhängigkeitsverifikation in CI/CD
package main

import (
    "fmt"
    "os/exec"
)

func verifyDependencies() error {
    // SICHER: Modul-Prüfsummen verifizieren
    cmd := exec.Command("go", "mod", "verify")
    if err := cmd.Run(); err != nil {
        return fmt.Errorf("Modul-Verifikation fehlgeschlagen: %w", err)
    }

    // SICHER: Auf Schwachstellen mit govulncheck prüfen
    cmd = exec.Command("govulncheck", "./...")
    output, err := cmd.CombinedOutput()
    if err != nil {
        return fmt.Errorf("Schwachstellenprüfung fehlgeschlagen: %s", output)
    }

    // SICHER: Prüfen dass keine Replace-Direktiven auf nicht vertrauenswürdige Quellen zeigen
    cmd = exec.Command("go", "mod", "graph")
    // Parsen und validieren...

    return nil
}

// SICHER: SBOM-Generierung
func generateSBOM(outputPath string) error {
    // cyclonedx-gomod oder ähnliches verwenden
    cmd := exec.Command("cyclonedx-gomod", "mod", "-json", "-output", outputPath)
    return cmd.Run()
}

---

CVE-Beispiele

• CVE-2021-44228: Log4Shell - Kritische Schwachstelle in der weit verbreiteten Apache Log4j-Bibliothek.
• CVE-2020-8203: Prototype Pollution in Lodash, die Millionen von Anwendungen betrifft.
• CVE-2017-5638: Apache Struts-Schwachstelle, die beim Equifax-Datenleck ausgenutzt wurde.

---

Verwandte CWEs

• CWE-710: Improper Adherence to Coding Standards (übergeordnet)
• CWE-1104: Use of Unmaintained Third Party Components (untergeordnet)
• CWE-1329: Reliance on Component That is Not Updateable (untergeordnet)

---

Referenzen

1. MITRE Corporation. "CWE-1357: Reliance on Insufficiently Trustworthy Component." https://cwe.mitre.org/data/definitions/1357.html
2. OWASP. "Software Component Verification Standard (SCVS)"
3. NTIA. "Software Bill of Materials (SBOM)"