Zum Inhalt springen
Trainingslager IT-Trainingslager

Kapitel 3: Gespiegelte Bezugsquellen als einziger Bezugsweg (Harbor, Nexus, Artifactory)

In diesem Kapitel lernst du:

  • den Unterschied zwischen Proxy-Cache, kuratiertem Spiegel und Offline-Spiegel
  • wie du „einziger Bezugsweg” technisch durchsetzt: Client-Konfiguration, Egress-Sperre, Policy
  • wie du mit der Nexus-REST-API Spiegel für Container-Images, PyPI, Debian-Pakete und npm anlegst
  • wie du die demo-app so baust, dass sie ausschließlich über den Spiegel bezieht, und das mit einem gesperrten Netz beweist
  • wie Proxy-Cache-Projekte und Replikation in Harbor und Remote-/Virtual-Repositories in Artifactory funktionieren

Worum geht es?

Denk an eine Krankenhausapotheke. Die Stationen bestellen nicht selbst bei irgendeinem Großhändler im Internet. Alles läuft über die Apotheke. Die Apotheke kennt ihre Lieferanten, prüft die Ware, lagert sie und gibt sie an die Stationen aus. Kommt ein Rückruf, weiß sie sofort, welche Station welche Charge bekommen hat. Und weil die Stationen gar keinen anderen Bezugsweg haben, kann auch niemand „mal eben schnell” etwas Ungeprüftes bestellen.

Ein Spiegel (Mirror) für Softwarepakete ist diese Apotheke. Statt dass jeder Build direkt bei Docker Hub, PyPI, npm oder Debian bestellt, holen alle Builds ihre Zutaten aus einem zentralen Repository-Manager wie Nexus, Harbor oder Artifactory. Der Spiegel lädt beim ersten Mal aus dem Internet nach, speichert eine Kopie und liefert sie ab dann selbst aus.

Das allein ist Komfort. Sicherheit wird daraus erst durch den zweiten Teil der Überschrift: einziger Bezugsweg. Die Build-Umgebung darf das Internet gar nicht erreichen, nur den Spiegel. Dann ist der Spiegel der einzige Ort, an dem du kontrollieren, protokollieren und sperren musst.

   VORHER: jeder holt selbst          NACHHER: einziger Bezugsweg

  +-------+   +----------------+     +-------+               +------------+
  | Build |-->| Docker Hub     |     | Build |--+            | Docker Hub |
  |       |-->| PyPI           |     +-------+  |  +-------+ | PyPI       |
  |       |-->| deb.debian.org |                +->|Spiegel|>| Debian     |
  |       |-->| npm, curl ...  |     +-------+     | Nexus | | npm        |
  +-------+   +----------------+     | Build |---->|       | +------------+
                                     +-------+     +-------+
   Kontrolle: keine                      |      nur der Spiegel darf
   Protokoll: verteilt                   X      ins Internet
   Sperren:   unmöglich                  |  Firewall: direkter Weg
                                         v  ins Internet gesperrt
                                      Internet

Die Konzepte in einfach

Drei Arten von Spiegeln

Nicht jeder Spiegel ist gleich. Die drei Grundformen unterscheiden sich darin, wann und wie geprüft wird.

Art Wie er funktioniert Stärke Schwäche
Proxy/Cache lädt bei Bedarf nach, speichert bequem, sofort nutzbar lässt alles durch
Kuratierter Spiegel nur freigegebene Pakete volle Kontrolle Pflegeaufwand
Offline-Spiegel Kopie ohne Internetverbindung air-gapped möglich Aktualität, Transport

Proxy/Cache (Pull-Through-Cache). Der Spiegel ist ein Zwischenhändler. Fragt ein Build nach flask==3.0.3, schaut der Spiegel in seinem Lager nach. Ist das Paket da, liefert er es. Wenn nicht, holt er es vom Original, speichert es und liefert dann. Vorteile: Du hast ein zentrales Protokoll, schnellere Builds und Unabhängigkeit von Ausfällen oder Rate-Limits beim Original. Gelöschte oder manipulierte Upstream-Versionen erreichen dich nicht mehr, sobald du sie einmal im Cache hast. Nachteil: Ohne weitere Regeln lässt ein Proxy jedes Paket durch, auch ein brandneues Schadpaket.

Kuratierter Spiegel. Nur Pakete, die jemand freigegeben hat, sind verfügbar. Das kann manuell geschehen (Antrag und Prüfung) oder regelbasiert: „nur Pakete, die älter als 14 Tage sind, keine kritische Schwachstelle haben und eine erlaubte Lizenz tragen”. Kommerzielle Produkte wie Sonatype Repository Firewall oder JFrog Curation automatisieren das. Mit Bordmitteln baust du es aus einem Proxy plus einem internen (hosted) Repository und einem Freigabeprozess.

Offline-Spiegel. In einer Umgebung ohne Internet (air-gapped) gibt es keinen Upstream. Pakete werden außerhalb gesammelt, geprüft und über eine kontrollierte Übergabe (Datenträger, Datendiode) eingespielt. Werkzeuge dafür sind zum Beispiel skopeo sync oder Harbor-Replikation für Images, pip download für Python-Pakete und aptly oder apt-mirror für Debian. Wie die Übergabe sicher abläuft, zeigt Kapitel 4.

Merke: In der Praxis kombiniert man die Formen. Typisch: ein Proxy in der Build-Zone mit Regeln, dahinter ein kuratiertes Repository für Produktion und für hochsensible Netze ein Offline-Spiegel.

Repository-Typen: proxy, hosted, group

Nexus und Artifactory kennen dieselben drei Bausteine, nur heißen sie leicht anders.

Nexus Artifactory Zweck
proxy remote spiegelt eine externe Quelle
hosted local eigene, intern gebaute Pakete
group virtual bündelt mehrere Repos unter einer URL

Ein Group-Repository ist praktisch: Die Clients kennen nur eine URL, dahinter liegen interne und gespiegelte Pakete. Genau hier lauert aber eine Falle, die Dependency Confusion (Verwechslung von Abhängigkeiten). Gibt es ein internes Paket firma-utils in Version 1.2 und lädt ein Angreifer ein gleichnamiges Paket in Version 99.0 auf PyPI hoch, nimmt der Client womöglich die höhere Version aus dem Proxy.

Sicherheit: Gegenmaßnahmen gegen Dependency Confusion: interne Paketnamen mit eindeutigem Präfix oder Scope (@firma/... bei npm), interne Namen öffentlich reservieren, im Spiegel Routing- oder Ausschlussregeln für interne Namen auf dem Proxy setzen. Und niemals pip install --extra-index-url verwenden, denn pip behandelt alle Indizes gleichrangig.

„Einziger Bezugsweg” durchsetzen

Ein Spiegel, den man umgehen kann, ist eine Empfehlung, keine Kontrolle. Durchsetzen ist eine Sache mehrerer Schichten:

Schicht Maßnahme Erzwingt?
1. Client-Konfiguration pip.conf, .npmrc, apt-Quellen, Registry-Mirror nein, nur bequem
2. Netzwerk Egress-Sperre, Firewall, NetworkPolicy ja
3. Admission nur Images aus erlaubter Registry (Kapitel 9) ja, im Cluster
4. Prüfung Linter sucht fremde URLs im Build erkennt Abweichungen
5. Monitoring Alarm bei geblockten Verbindungen macht sichtbar

Schicht 1 sorgt dafür, dass der normale Weg der richtige ist. Entwickler sollen nicht kämpfen müssen. Schicht 2 ist der eigentliche Zwang. Build-Hosts und Runner-Pods dürfen nur den Spiegel und wenige interne Dienste erreichen (DNS, Git-Server). Alles andere wird an der Firewall oder per Kubernetes-NetworkPolicy verworfen. Wichtig: Der Spiegel selbst braucht natürlich Zugriff nach außen, aber nur auf die Upstream-Adressen, die du konfiguriert hast.

Für Kubernetes-Runner sieht eine Egress-Sperre so aus (Adressen sind Beispiele):

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: build-egress-nur-spiegel
  namespace: ci-runner
spec:
  podSelector: {}
  policyTypes: ["Egress"]
  egress:
    - to:
        - ipBlock:
            cidr: 10.20.30.40/32        # Nexus
      ports:
        - { protocol: TCP, port: 8081 }
        - { protocol: TCP, port: 8082 }
    - to:
        - namespaceSelector:
            matchLabels:
              kubernetes.io/metadata.name: kube-system
          podSelector:
            matchLabels:
              k8s-app: kube-dns
      ports:
        - { protocol: UDP, port: 53 }
        - { protocol: TCP, port: 53 }

Sobald eine NetworkPolicy mit Egress einen Pod auswählt, ist für diesen Pod jeder ausgehende Verkehr verboten, der nicht ausdrücklich erlaubt ist. Voraussetzung: Das Netzwerk-Plugin (CNI) des Clusters setzt NetworkPolicies auch um, zum Beispiel Calico oder Cilium.

Schicht 3 greift beim Deployment. Eine Kyverno- oder OPA-Regel lehnt jeden Pod ab, dessen Image nicht mit nexus.intern:8082/ oder harbor.intern/ beginnt. Das baust du in Kapitel 9.

Was alles gespiegelt werden muss

Ein typischer Container-Build bezieht aus drei Welten:

  • Container-Images: Basisimages wie python:3.12-slim. Clients: Docker, containerd, Podman, BuildKit.
  • Betriebssystem-Pakete: apt-get install bei Debian/Ubuntu, dnf install bei RHEL/Fedora. Die Paketlisten sind mit GPG signiert, der Spiegel reicht die Signaturen unverändert durch.
  • Sprachpakete: PyPI (pip), npm, Maven Central, Go-Module, NuGet, crates.io.

Die Client-Konfiguration auf einen Blick:

Ökosystem Konfiguration Beispielwert
pip /etc/pip.conf oder PIP_INDEX_URL index-url = https://nexus.intern/repository/pypi-proxy/simple
npm .npmrc registry=https://nexus.intern/repository/npm-proxy/
apt /etc/apt/sources.list.d/*.sources URIs: https://nexus.intern/repository/debian-bookworm/
dnf /etc/yum.repos.d/*.repo baseurl=https://nexus.intern/repository/rocky-baseos/

Für Maven trägst du in der settings.xml einen Mirror für alle Repositories ein:

<settings>
  <mirrors>
    <mirror>
      <id>nexus</id>
      <mirrorOf>*</mirrorOf>
      <url>https://nexus.intern/repository/maven-public/</url>
    </mirror>
  </mirrors>
</settings>

Für Container-Images gibt es zwei Wege. Entweder schreibst du den Spiegel direkt in die Image-Referenz (nexus.intern:8082/library/python:3.12-slim). Oder du konfigurierst die Container-Runtime so, dass sie Anfragen an docker.io auf den Spiegel umlenkt. Bei containerd geschieht das über hosts.toml:

# /etc/containerd/certs.d/docker.io/hosts.toml
server = "https://registry-1.docker.io"

[host."https://nexus.intern:8082"]
  capabilities = ["pull", "resolve"]

Achtung: containerd fällt auf den server-Eintrag zurück, wenn der Spiegel nicht antwortet. Ohne Egress-Sperre ist die Umlenkung also kein Zwang. Bei Docker gilt die Option registry-mirrors in der daemon.json außerdem nur für Images von Docker Hub, nicht für ghcr.io oder quay.io.

Merke: Der Digest eines Images ändert sich durch einen Spiegel nicht. python:3.12-slim@sha256:abc… ist über Docker Hub und über Nexus derselbe Inhalt. Digest-Pinning aus Kapitel 2 und Spiegel ergänzen sich also perfekt.

Harbor: Proxy-Cache-Projekte und Replikation

Harbor ist eine CNCF-Registry speziell für OCI-Artefakte (Images, Helm-Charts, Signaturen, SBOMs). Für Sprachpakete ist Harbor nicht gedacht. Für Images bringt es zwei passende Funktionen mit.

Proxy-Cache-Projekt. Du legst einen Registry-Endpunkt an (zum Beispiel Docker Hub) und ein Projekt, das als Proxy-Cache für diesen Endpunkt dient. Clients ziehen dann über harbor.intern/<projekt>/<image>. Über die Harbor-API (v2.0) sieht das verkürzt so aus:

# 1. Registry-Endpunkt für Docker Hub anlegen
curl -s -u "admin:${HARBOR_PW}" -H 'Content-Type: application/json' \
  -X POST https://harbor.intern/api/v2.0/registries -d '{
    "name": "dockerhub",
    "type": "docker-hub",
    "url": "https://hub.docker.com",
    "credential": {"type": "basic", "access_key": "hubuser",
                   "access_secret": "<Token aus Vault>"}
  }'

# 2. Proxy-Cache-Projekt anlegen (registry_id aus GET /api/v2.0/registries)
curl -s -u "admin:${HARBOR_PW}" -H 'Content-Type: application/json' \
  -X POST https://harbor.intern/api/v2.0/projects -d '{
    "project_name": "dockerhub-proxy",
    "registry_id": 1,
    "metadata": {"public": "false"}
  }'

# 3. Nutzen
docker pull harbor.intern/dockerhub-proxy/library/python:3.12-slim

Bei offiziellen Docker-Hub-Images gehört library/ in den Pfad. In ein Proxy-Cache-Projekt kann niemand pushen, es ist reiner Lesezugriff auf den Upstream.

Replikation. Harbor kann Artefakte regelbasiert zwischen Registries kopieren, per Push (von Harbor weg) oder Pull (zu Harbor hin), zeitgesteuert, ereignisgesteuert oder manuell. So verteilst du freigegebene Basisimages von einer zentralen Harbor-Instanz in die Standorte oder in eine Zielzone. Eine Regel per API, verkürzt:

{
  "name": "basisimages-in-zielzone",
  "dest_registry": { "id": 3 },
  "dest_namespace": "basis",
  "filters": [
    { "type": "name", "value": "basis/**" },
    { "type": "tag", "value": "v*" }
  ],
  "trigger": {
    "type": "scheduled",
    "trigger_settings": { "cron": "0 0 2 * * *" }
  },
  "override": true,
  "enabled": true
}

Die Regel wird per POST /api/v2.0/replication/policies angelegt. Ohne src_registry ist die lokale Harbor-Instanz die Quelle (Push-Replikation). Harbor nutzt ein Cron-Format mit sechs Feldern, das erste Feld sind Sekunden. Diese Regel läuft also täglich um 02:00 Uhr. Für die Übergabe über Zonengrenzen ist Replikation allein zu wenig, weil Prüfung und Freigabe fehlen. Das ergänzt Kapitel 4.

Artifactory: Remote- und Virtual-Repositories

JFrog Artifactory ist ein kommerzieller Repository-Manager mit sehr breiter Formatunterstützung. Das Modell entspricht Nexus:

  • Remote Repository: Proxy für eine externe Quelle, zum Beispiel pypi-remote auf https://files.pythonhosted.org.
  • Local Repository: eigene Artefakte, zum Beispiel docker-local für gebaute Images.
  • Virtual Repository: bündelt Local und Remote unter einem Namen, zum Beispiel pypi aus pypi-local und pypi-remote. Die Reihenfolge der Auflösung ist konfigurierbar.

Die Client-URLs folgen einem festen Schema:

pip:    https://art.intern/artifactory/api/pypi/pypi/simple
npm:    https://art.intern/artifactory/api/npm/npm/
Docker: art.intern/docker/python:3.12-slim   (je nach Docker-Zugriffsmethode)

Für Automatisierung gibt es die JFrog-CLI jf und die REST-API. Die Prinzipien „einziger Bezugsweg” und „Egress-Sperre” gelten genauso.

Hands-on-Lab: Nexus als einziger Bezugsweg

Du startest Nexus Repository, legst per REST-API vier Proxy-Repositories an und baust die demo-app so, dass sie alles über Nexus bezieht. Zum Schluss sperrst du das Internet für den Build-Container und beweist, dass es trotzdem funktioniert.

Voraussetzungen aus Kapitel 0: Docker läuft mit mindestens 8 GB RAM, ~/seclab/demo-app existiert, curl, jq und crane sind installiert.

  Host (localhost)
  +-------------------------------------------------------------+
  |  Docker-Netz "bridge" (mit Internet)                        |
  |      +---------------------------+                          |
  |      | nexus  :8081 (UI, PyPI,   |----> Docker Hub, PyPI,   |
  |      |        apt, npm)          |      deb.debian.org, npm |
  |      |        :8082 (Docker)     |                          |
  |      +---------------------------+                          |
  |                  |                                          |
  |  Docker-Netz "seclab-intern" (--internal, KEIN Internet)    |
  |      +------------------+                                   |
  |      | Build-Container  |---- nur http://nexus:8081 ------> |
  |      +------------------+                                   |
  +-------------------------------------------------------------+

Schritt 1: Arbeitsverzeichnis und internes Netz anlegen

mkdir -p ~/seclab/kap03
cd ~/seclab/kap03
cp -r ~/seclab/demo-app demo-app
docker network create --internal seclab-intern
docker network inspect seclab-intern -f '{{.Internal}}'

Erwartete Ausgabe (die erste Zeile ist die ID des neuen Netzes):

3f9c1a...
true

--internal bedeutet: Container in diesem Netz können sich gegenseitig erreichen, aber nicht nach außen. Das ist unsere Simulation der Firewall vor den Build-Hosts.

Schritt 2: Nexus starten

docker run -d --name nexus \
  -p 8081:8081 -p 8082:8082 \
  -v nexus-data:/nexus-data \
  -e INSTALL4J_ADD_VM_PARAMS="-Xms1g -Xmx1g -XX:MaxDirectMemorySize=1g" \
  sonatype/nexus3
docker network connect seclab-intern nexus

Nexus hängt jetzt in zwei Netzen: im Standardnetz bridge mit Internet (für den Upstream) und in seclab-intern (für die Builds). Port 8081 ist UI und REST-API sowie der Zugang für PyPI, apt und npm. Port 8082 reservieren wir für den Docker-Proxy, denn Docker-Clients erwarten eine Registry an der Wurzel eines Hosts und Ports.

Der Start dauert ein bis drei Minuten. Warte, bis die Status-API antwortet:

NEXUS=http://localhost:8081
until [ "$(curl -s -o /dev/null -w '%{http_code}' \
  "$NEXUS/service/rest/v1/status")" = "200" ]; do
  echo "warte auf Nexus ..."; sleep 10
done
echo "Nexus ist bereit"

Erwartete Ausgabe:

warte auf Nexus ...
warte auf Nexus ...
Nexus ist bereit

Tipp: Die Heap-Einstellung über INSTALL4J_ADD_VM_PARAMS hält Nexus im Lab bei rund 2 GB Speicherbedarf. In Produktion gibt Sonatype deutlich mehr vor. Seit Version 3.77 heißt die freie Variante „Community Edition” und hat Nutzungsgrenzen, für das Lab spielen die keine Rolle.

Schritt 3: Admin-Passwort holen und ändern

Beim ersten Start erzeugt Nexus ein zufälliges Admin-Passwort in einer Datei:

INITIAL_PW=$(docker exec nexus cat /nexus-data/admin.password)
echo "$INITIAL_PW"

Erwartete Ausgabe: eine UUID, zum Beispiel 5c1d8a3e-....

Ändere es per API auf ein Lab-Passwort:

NEXUS_PW='lab-nexus-123'   # Lab-Wert, niemals in Produktion
curl -s -o /dev/null -w '%{http_code}\n' -u "admin:${INITIAL_PW}" \
  -X PUT -H 'Content-Type: text/plain' --data "${NEXUS_PW}" \
  "$NEXUS/service/rest/v1/security/users/admin/change-password"

Erwartete Ausgabe:

204

204 No Content heißt Erfolg. Ab jetzt nutzen wir eine kleine Hilfsfunktion, damit die Befehle kurz bleiben:

nx() { curl -s -u "admin:${NEXUS_PW}" -H 'Content-Type: application/json' "$@"; }
nx "$NEXUS/service/rest/v1/security/users?userId=admin" | jq -r '.[0].userId'

Erwartete Ausgabe:

admin

Achtung: Neuere Nexus-Versionen (Community Edition) verlangen beim ersten Login die Zustimmung zur Lizenz (EULA). Melde dich dafür einmal in der UI unter http://localhost:8081 als admin an und folge dem Assistenten. Wähle dort „Enable anonymous access”, das brauchen wir im nächsten Schritt. Ältere Versionen fragen nicht nach einer EULA.

Schritt 4: Anonymen Lesezugriff und Docker-Realm aktivieren

Damit Build-Clients ohne Login lesen können, aktivieren wir den anonymen Zugriff. Für anonyme Docker-Pulls braucht Nexus zusätzlich den „Docker Bearer Token Realm”:

nx -X PUT "$NEXUS/service/rest/v1/security/anonymous" \
  -d '{"enabled": true, "userId": "anonymous",
       "realmName": "NexusAuthorizingRealm"}' | jq '.enabled'

REALMS=$(nx "$NEXUS/service/rest/v1/security/realms/active" \
  | jq -c '. + ["DockerToken"] | unique')
nx -o /dev/null -w '%{http_code}\n' -X PUT \
  "$NEXUS/service/rest/v1/security/realms/active" -d "$REALMS"
nx "$NEXUS/service/rest/v1/security/realms/active"

Erwartete Ausgabe:

true
204
["DockerToken","NexusAuthenticatingRealm"]

Die genaue Liste der Realms kann je nach Version abweichen. Wichtig ist, dass DockerToken enthalten ist.

Sicherheit: Anonymes Lesen ist im Lab bequem. In Produktion vergibst du für jede Pipeline einen eigenen technischen Benutzer mit Leserechten oder nutzt Tokens. Dann siehst du im Protokoll, welche Pipeline welches Paket geholt hat.

Schritt 5: Docker-Proxy auf Docker Hub anlegen

Lege die Konfiguration als JSON-Datei an:

cat > docker-hub.json <<'EOF'
{
  "name": "docker-hub",
  "online": true,
  "storage": { "blobStoreName": "default", "strictContentTypeValidation": true },
  "proxy": {
    "remoteUrl": "https://registry-1.docker.io",
    "contentMaxAge": 1440,
    "metadataMaxAge": 1440
  },
  "negativeCache": { "enabled": true, "timeToLive": 1440 },
  "httpClient": { "blocked": false, "autoBlock": true },
  "docker": { "v1Enabled": false, "forceBasicAuth": false, "httpPort": 8082 },
  "dockerProxy": { "indexType": "HUB" }
}
EOF
nx -o /dev/null -w '%{http_code}\n' -X POST -d @docker-hub.json \
  "$NEXUS/service/rest/v1/repositories/docker/proxy"

Erwartete Ausgabe:

201

Die wichtigsten Felder:

  • remoteUrl: der Upstream, hier die Registry-API von Docker Hub.
  • contentMaxAge / metadataMaxAge: Minuten, die Inhalte und Metadaten (etwa die Zuordnung Tag zu Digest) als frisch gelten.
  • docker.httpPort: 8082: Nexus öffnet einen eigenen HTTP-Connector auf Port 8082 für dieses Repository.
  • forceBasicAuth: false: erlaubt anonyme Pulls über den Token-Realm aus Schritt 4.
  • indexType: HUB: Suche und Index laufen gegen Docker Hub.

Jetzt der Test. Docker erlaubt HTTP-Registries auf localhost ohne Zusatzkonfiguration:

docker pull localhost:8082/library/python:3.12-slim
crane digest localhost:8082/library/python:3.12-slim
crane digest python:3.12-slim

Erwartete Ausgabe (gekürzt):

3.12-slim: Pulling from library/python
...
Status: Downloaded newer image for localhost:8082/library/python:3.12-slim
localhost:8082/library/python:3.12-slim
sha256:4a3f...
sha256:4a3f...

Beide Digests sind identisch. Der Spiegel liefert bitgleich dasselbe Image wie Docker Hub.

Tipp: Docker Hub begrenzt anonyme Pulls pro IP-Adresse. Weil jetzt nur noch Nexus bei Docker Hub anfragt und alles cached, sinkt die Zahl der Pulls drastisch. In Produktion hinterlegst du zusätzlich ein Docker-Hub-Konto im Proxy unter httpClient.authentication.

Schritt 6: PyPI-Proxy anlegen

cat > pypi-proxy.json <<'EOF'
{
  "name": "pypi-proxy",
  "online": true,
  "storage": { "blobStoreName": "default", "strictContentTypeValidation": true },
  "proxy": {
    "remoteUrl": "https://pypi.org",
    "contentMaxAge": 1440,
    "metadataMaxAge": 1440
  },
  "negativeCache": { "enabled": true, "timeToLive": 1440 },
  "httpClient": { "blocked": false, "autoBlock": true }
}
EOF
nx -o /dev/null -w '%{http_code}\n' -X POST -d @pypi-proxy.json \
  "$NEXUS/service/rest/v1/repositories/pypi/proxy"
curl -s "$NEXUS/repository/pypi-proxy/simple/flask/" \
  | grep -o 'flask-3.0.3[^<"#]*' | sort -u

Erwartete Ausgabe:

201
flask-3.0.3-py3-none-any.whl
flask-3.0.3.tar.gz

Die Seite /simple/flask/ ist der „Simple Repository Index” nach PEP 503, genau das, was pip abfragt. Nexus schreibt die Download-Links darin so um, dass sie auf Nexus selbst zeigen und nicht auf files.pythonhosted.org.

Schritt 7: APT-Proxy für Debian bookworm anlegen

cat > apt-proxy.json <<'EOF'
{
  "name": "debian-bookworm",
  "online": true,
  "storage": { "blobStoreName": "default", "strictContentTypeValidation": true },
  "proxy": {
    "remoteUrl": "http://deb.debian.org/debian/",
    "contentMaxAge": 1440,
    "metadataMaxAge": 1440
  },
  "negativeCache": { "enabled": true, "timeToLive": 1440 },
  "httpClient": { "blocked": false, "autoBlock": true },
  "apt": { "distribution": "bookworm", "flat": false }
}
EOF
nx -o /dev/null -w '%{http_code}\n' -X POST -d @apt-proxy.json \
  "$NEXUS/service/rest/v1/repositories/apt/proxy"

Erwartete Ausgabe:

201

Jetzt testen wir aus dem internen Netz heraus. Debian-Images ab bookworm nutzen das deb822-Format unter /etc/apt/sources.list.d/debian.sources. Wir ersetzen diese Datei durch eine, die auf Nexus zeigt:

cat > nexus.sources <<'EOF'
Types: deb
URIs: http://nexus:8081/repository/debian-bookworm/
Suites: bookworm
Components: main
Signed-By: /usr/share/keyrings/debian-archive-keyring.gpg
EOF
docker pull localhost:8082/library/debian:bookworm-slim
docker run --rm --network seclab-intern \
  -v "$PWD/nexus.sources:/etc/apt/sources.list.d/debian.sources:ro" \
  localhost:8082/library/debian:bookworm-slim \
  bash -c 'apt-get update && apt-get install -y --no-install-recommends jq \
    && jq --version'

Erwartete Ausgabe (gekürzt):

Get:1 http://nexus:8081/repository/debian-bookworm bookworm InRelease [151 kB]
Get:2 http://nexus:8081/repository/debian-bookworm bookworm/main amd64 Packages ...
...
Setting up jq (1.6-2.1) ...
jq-1.6

Beachte zwei Dinge. Erstens: Der Container steht im internen Netz ohne Internet, trotzdem klappt die Installation. Zweitens: Signed-By zeigt auf den Debian-Schlüsselbund im Image. apt prüft die Signatur der Paketlisten weiterhin gegen den Debian-Schlüssel. Ein manipulierter Spiegel könnte keine gefälschten Pakete unterschieben, ohne dass apt abbricht.

Merke: Sicherheitsupdates kommen bei Debian aus einem eigenen Archiv (security.debian.org, Suite bookworm-security). Dafür legst du in der Praxis ein zweites APT-Proxy-Repository an. Das ist Teil der Übung.

Schritt 8: npm-Proxy anlegen

cat > npm-proxy.json <<'EOF'
{
  "name": "npm-proxy",
  "online": true,
  "storage": { "blobStoreName": "default", "strictContentTypeValidation": true },
  "proxy": {
    "remoteUrl": "https://registry.npmjs.org",
    "contentMaxAge": 1440,
    "metadataMaxAge": 1440
  },
  "negativeCache": { "enabled": true, "timeToLive": 1440 },
  "httpClient": { "blocked": false, "autoBlock": true }
}
EOF
nx -o /dev/null -w '%{http_code}\n' -X POST -d @npm-proxy.json \
  "$NEXUS/service/rest/v1/repositories/npm/proxy"
curl -s "$NEXUS/repository/npm-proxy/lodash" | jq -r '."dist-tags".latest'

Erwartete Ausgabe:

201
4.17.21

Die Versionsnummer kann bei dir höher sein. Ein npm-Client nutzt den Proxy mit einer Zeile in der .npmrc des Projekts:

registry=http://localhost:8081/repository/npm-proxy/

Prüfe zum Schluss, welche Repositories jetzt existieren:

nx "$NEXUS/service/rest/v1/repositories" \
  | jq -r '.[] | select(.type=="proxy") | "\(.format)\t\(.name)"'

Erwartete Ausgabe (Auszug, Nexus bringt zusätzlich eigene Standard-Repositories wie maven-central mit):

docker  docker-hub
pypi    pypi-proxy
apt     debian-bookworm
npm     npm-proxy
maven2  maven-central

Schritt 9: Gegenprobe – ohne Spiegel geht nichts

Jetzt beweisen wir, dass das interne Netz wirklich gesperrt ist. Ein Build-Container versucht, direkt von PyPI zu laden:

docker run --rm --network seclab-intern \
  localhost:8082/library/python:3.12-slim \
  pip download --no-deps --retries 0 --timeout 5 -d /tmp flask==3.0.3

Erwartete Ausgabe (gekürzt, Fehlermeldung je nach Docker-Version):

WARNING: ... Failed to establish a new connection: [Errno -3] Temporary
  failure in name resolution ...
ERROR: Could not find a version that satisfies the requirement flask==3.0.3
  (from versions: none)
ERROR: No matching distribution found for flask==3.0.3

Statt des Namensauflösungsfehlers kann auch [Errno 101] Network is unreachable erscheinen. Beides heißt: Kein Weg ins Internet.

Jetzt derselbe Container mit Spiegel. Lege dazu eine pip.conf an:

cat > pip.conf <<'EOF'
[global]
index-url = http://nexus:8081/repository/pypi-proxy/simple
trusted-host = nexus
EOF
docker run --rm --network seclab-intern \
  -v "$PWD/pip.conf:/etc/pip.conf:ro" \
  localhost:8082/library/python:3.12-slim \
  pip download --no-deps -d /tmp flask==3.0.3

Erwartete Ausgabe:

Looking in indexes: http://nexus:8081/repository/pypi-proxy/simple
Collecting flask==3.0.3
  Downloading http://nexus:8081/repository/pypi-proxy/packages/flask/3.0.3/...
Saved /tmp/flask-3.0.3-py3-none-any.whl
Successfully downloaded flask

pip liest /etc/pip.conf als systemweite Konfiguration. trusted-host ist nötig, weil wir im Lab HTTP statt HTTPS nutzen. In Produktion steht Nexus hinter TLS mit einem Zertifikat deiner eigenen PKI, dann entfällt trusted-host.

Schritt 10: Abhängigkeiten der demo-app über den Spiegel holen

Jetzt der echte Build-Schritt. Der Build-Container im internen Netz lädt alle Abhängigkeiten der demo-app als Wheels in ein Verzeichnis. Er läuft mit deiner UID, damit die Dateien dir gehören:

cd ~/seclab/kap03/demo-app
cp ../pip.conf .
docker run --rm --network seclab-intern \
  --user "$(id -u):$(id -g)" -e HOME=/tmp \
  -v "$PWD/pip.conf:/etc/pip.conf:ro" -v "$PWD":/w -w /w \
  localhost:8082/library/python:3.12-slim \
  pip download --only-binary=:all: -r requirements.txt -d wheels
ls wheels

Erwartete Ausgabe (Versionen der transitiven Pakete können abweichen):

blinker-1.8.2-py3-none-any.whl
certifi-2024.8.30-py3-none-any.whl
chardet-4.0.0-py2.py3-none-any.whl
click-8.1.7-py3-none-any.whl
flask-3.0.3-py3-none-any.whl
gunicorn-22.0.0-py3-none-any.whl
idna-2.10-py2.py3-none-any.whl
itsdangerous-2.2.0-py3-none-any.whl
jinja2-3.1.4-py3-none-any.whl
markupsafe-2.1.5-cp312-cp312-manylinux_2_17_x86_64....whl
packaging-24.1-py3-none-any.whl
requests-2.25.0-py2.py3-none-any.whl
urllib3-1.26.20-py2.py3-none-any.whl
werkzeug-3.0.4-py3-none-any.whl

--only-binary=:all: verhindert, dass pip Quellpakete lädt, die beim Installieren Code ausführen könnten. Hast du in Kapitel 2 ein requirements.lock mit Hashes erzeugt, kannst du es hier statt requirements.txt verwenden. Die Hashes stimmen, weil Nexus die Dateien unverändert ausliefert.

Schritt 11: Das Image hermetisch bauen

Jetzt bauen wir das Image ohne jeden Netzzugang. Das Basisimage kommt aus dem Spiegel, die Pakete aus dem Verzeichnis wheels:

cat > Dockerfile.mirror <<'EOF'
# syntax=docker/dockerfile:1
ARG BASE_IMAGE=localhost:8082/library/python:3.12-slim
FROM ${BASE_IMAGE} AS build
WORKDIR /build
COPY requirements.txt .
COPY wheels/ /wheels/
RUN pip install --no-cache-dir --no-index --find-links=/wheels \
      --prefix=/install -r requirements.txt

FROM ${BASE_IMAGE}
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1
COPY --from=build /install /usr/local
WORKDIR /app
COPY app.py .
USER 10001:10001
EXPOSE 8000
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "app:app"]
EOF
docker build --network=none -f Dockerfile.mirror \
  -t localhost:5001/demo-app:1.0.0-mirror .

Erwartete Ausgabe (letzte Zeilen):

 => [build 5/5] RUN pip install --no-cache-dir --no-index --find-links=/wheels ...
 ...
 => => naming to localhost:5001/demo-app:1.0.0-mirror

Was hier passiert:

  • --network=none nimmt allen RUN-Schritten das Netz weg. Der Build ist damit hermetisch: Er kann nichts nachladen, was nicht vorher im Build-Kontext lag.
  • --no-index --find-links=/wheels zwingt pip, nur aus dem lokalen Verzeichnis zu installieren.
  • Das Basisimage löst der Docker-Daemon auf, nicht der RUN-Schritt. Es kommt über localhost:8082 aus Nexus.
  • Die globale ARG BASE_IMAGE vor dem ersten FROM gilt in beiden FROM-Zeilen. In Produktion übergibst du hier per --build-arg den Spiegel deiner Organisation, idealerweise mit Digest.

Achtung: Falls die .dockerignore aus Kapitel 0 das Verzeichnis wheels/ ausschließt, schlägt COPY wheels/ fehl. Prüfe das mit cat .dockerignore.

Starte das Image zur Kontrolle und schiebe es in die Build-Registry:

docker run -d --rm --name demo-mirror -p 18001:8000 \
  localhost:5001/demo-app:1.0.0-mirror
sleep 2 && curl -s http://localhost:18001/ && docker stop demo-mirror
docker push localhost:5001/demo-app:1.0.0-mirror
crane digest localhost:5001/demo-app:1.0.0-mirror

Erwartete Ausgabe:

{"status":"ok"}
demo-mirror
...
sha256:b81f...

Schritt 12: Nachweis im Spiegel prüfen

Der Spiegel weiß jetzt genau, was deine Builds bezogen haben. Das ist die Grundlage für Audit und Schwachstellen-Reaktion:

nx "$NEXUS/service/rest/v1/components?repository=pypi-proxy" \
  | jq -r '.items[] | "\(.name) \(.version)"' | sort
nx "$NEXUS/service/rest/v1/components?repository=docker-hub" \
  | jq -r '.items[] | "\(.name):\(.version)"'

Erwartete Ausgabe (Auszug):

flask 3.0.3
gunicorn 22.0.0
requests 2.25.0
urllib3 1.26.20
...
library/debian:bookworm-slim
library/python:3.12-slim

Die API liefert pro Aufruf eine Seite. Bei vielen Komponenten enthält die Antwort ein Feld continuationToken, das du für die nächste Seite als Parameter anhängst.

Stell dir vor, morgen wird eine kritische Lücke in urllib3 1.26.20 bekannt. Mit dieser Liste weißt du sofort, ob deine Builds die Version je bezogen haben. Zusammen mit SBOMs (Kapitel 7) siehst du auch, in welchen Images sie steckt.

Schritt 13: Aufräumen

docker stop nexus
docker network disconnect seclab-intern nexus
docker network rm seclab-intern
docker image rm localhost:8082/library/debian:bookworm-slim

Das Volume nexus-data bleibt erhalten. Mit docker start nexus hast du den Spiegel samt Cache wieder. Wenn du komplett neu anfangen willst: docker rm nexus && docker volume rm nexus-data.

Fortschritt speichern? Kostenlos registrieren

Typische Stolperfallen

Symptom Ursache Lösung
curl auf Status liefert 000 Nexus startet noch 1–3 Minuten warten, docker logs nexus prüfen
401 Unauthorized bei docker pull Docker-Realm fehlt oder forceBasicAuth DockerToken aktivieren, forceBasicAuth: false
http: server gave HTTP response to HTTPS client Registry nicht auf localhost insecure-registries setzen oder TLS nutzen
400 beim Anlegen eines Repos Pflichtfeld im JSON fehlt oder Name belegt Antworttext lesen, -w weglassen
Port 8082 antwortet nicht httpPort nicht gesetzt oder Port nicht gemappt -p 8082:8082 und docker.httpPort prüfen
pip: not a trusted or secure host HTTP ohne trusted-host trusted-host setzen oder HTTPS nutzen
apt: NO_PUBKEY oder not signed falscher Signed-By-Pfad Pfad zum Debian-Keyring prüfen
Proxy liefert plötzlich nichts mehr autoBlock nach Upstream-Fehlern Status in der UI prüfen, Upstream-Erreichbarkeit testen

Übung: Den Spiegel erweitern

Deine Organisation braucht zwei weitere Bezugsquellen:

  1. Debian-Sicherheitsupdates für bookworm als eigenes APT-Proxy-Repository debian-security.
  2. Maven Central als eigenes Proxy-Repository maven-proxy.

Lege beide per REST-API an. Prüfe die Sicherheitsupdates mit einem apt-get update im internen Netz und Maven mit einem curl auf eine POM-Datei, zum Beispiel org/apache/commons/commons-lang3/3.14.0/commons-lang3-3.14.0.pom.

Hinweis 1: Die Debian-Sicherheitsupdates liegen unter http://security.debian.org/debian-security/, die Suite heißt bookworm-security. In der deb822-Datei kannst du mehrere Abschnitte untereinander schreiben, getrennt durch eine Leerzeile.

Hinweis 2: Der Endpunkt für Maven ist /service/rest/v1/repositories/maven/proxy. Maven-Repositories brauchen zusätzlich einen Block "maven" mit versionPolicy (zum Beispiel RELEASE) und layoutPolicy (zum Beispiel STRICT).

Lösung

APT-Proxy für die Sicherheitsupdates:

cat > apt-security.json <<'EOF'
{
  "name": "debian-security",
  "online": true,
  "storage": { "blobStoreName": "default", "strictContentTypeValidation": true },
  "proxy": {
    "remoteUrl": "http://security.debian.org/debian-security/",
    "contentMaxAge": 1440,
    "metadataMaxAge": 1440
  },
  "negativeCache": { "enabled": true, "timeToLive": 1440 },
  "httpClient": { "blocked": false, "autoBlock": true },
  "apt": { "distribution": "bookworm-security", "flat": false }
}
EOF
nx -o /dev/null -w '%{http_code}\n' -X POST -d @apt-security.json \
  "$NEXUS/service/rest/v1/repositories/apt/proxy"

Die Quellen-Datei mit zwei Abschnitten:

Types: deb
URIs: http://nexus:8081/repository/debian-bookworm/
Suites: bookworm
Components: main
Signed-By: /usr/share/keyrings/debian-archive-keyring.gpg

Types: deb
URIs: http://nexus:8081/repository/debian-security/
Suites: bookworm-security
Components: main
Signed-By: /usr/share/keyrings/debian-archive-keyring.gpg

Nach apt-get update im internen Netz erscheinen Zeilen mit debian-security bookworm-security InRelease.

Maven-Proxy:

cat > maven-proxy.json <<'EOF'
{
  "name": "maven-proxy",
  "online": true,
  "storage": { "blobStoreName": "default", "strictContentTypeValidation": true },
  "proxy": {
    "remoteUrl": "https://repo1.maven.org/maven2/",
    "contentMaxAge": -1,
    "metadataMaxAge": 1440
  },
  "negativeCache": { "enabled": true, "timeToLive": 1440 },
  "httpClient": { "blocked": false, "autoBlock": true },
  "maven": { "versionPolicy": "RELEASE", "layoutPolicy": "STRICT" }
}
EOF
nx -o /dev/null -w '%{http_code}\n' -X POST -d @maven-proxy.json \
  "$NEXUS/service/rest/v1/repositories/maven/proxy"
POM=org/apache/commons/commons-lang3/3.14.0/commons-lang3-3.14.0.pom
curl -s -o /dev/null -w '%{http_code}\n' "$NEXUS/repository/maven-proxy/$POM"

Erwartet: zweimal 201, dann 200. contentMaxAge: -1 bedeutet „nie neu prüfen”. Das ist für Maven-Releases richtig, denn ein veröffentlichtes Release darf sich nie ändern. Warum ein eigener Name? Nexus bringt bereits ein Repository maven-central mit. In Produktion entfernst du nicht genutzte Standard-Repositories, damit niemand versehentlich daran vorbei bezieht.

Fortschritt speichern? Kostenlos registrieren

Aus der Praxis

Architektur in regulierten Umgebungen. In Behörden und KRITIS-Unternehmen steht der Spiegel typischerweise in einer DMZ oder einer eigenen „Bezugszone”. Nur er darf über einen Forward-Proxy mit Allowlist ins Internet, und zwar ausschließlich zu den konfigurierten Upstreams. Die Build-Zone erreicht nur den Spiegel. Die Produktionszone erreicht nur eine zweite, kuratierte Registry, die über eine kontrollierte Übergabe befüllt wird (Kapitel 4). In air-gapped Netzen gibt es gar keinen Upstream, dort wird der Spiegel über Datenträger oder eine Datendiode aktualisiert.

Kuratierung mit Bordmitteln. Ohne kommerzielle Firewall-Produkte arbeiten viele Organisationen mit zwei Stufen. Ein Proxy in der Build-Zone ist für Entwickler offen und wird kontinuierlich gescannt. Ein hosted Repository für Produktion enthält nur Pakete und Images, die einen Freigabeprozess durchlaufen haben: Scan, Lizenzprüfung, ggf. Mindestalter. Nexus OSS bietet zusätzlich Routing Rules, mit denen du Pfade per regulärem Ausdruck erlauben oder sperren kannst, etwa um interne Paketnamen auf dem PyPI-Proxy zu blockieren.

Betrieb. Ein Spiegel wird zur kritischen Abhängigkeit. Fällt er aus, baut niemand mehr. Plane deshalb Hochverfügbarkeit oder zumindest schnelles Wiederherstellen, Backups des Blob-Stores und der Datenbank, Speicherüberwachung und Bereinigungsregeln (Cleanup Policies) für alte Inhalte. Nexus und Harbor stellen Metriken im Prometheus-Format bereit, die du in dein Monitoring übernimmst.

Monitoring der Durchsetzung. Der Beweis, dass der Spiegel wirklich der einzige Bezugsweg ist, kommt aus der Firewall. Werte geblockte Egress-Verbindungen von Build-Hosts aus und alarmiere darauf. Ein Anstieg zeigt dir ein Team, das versucht, am Spiegel vorbei zu bauen, oft unabsichtlich, weil ein Werkzeug eine eigene Download-URL eingebaut hat. Diese Fälle behandelst du mit den Teams, nicht gegen sie (Kapitel 10).

Zugangsdaten. Der Spiegel braucht eigene Zugangsdaten für die Upstreams, etwa ein Docker-Hub-Konto, und die Pipelines brauchen Lesezugänge zum Spiegel. Diese Daten gehören in ein Secrets-Management und werden regelmäßig rotiert (Kapitel 6). Pro Pipeline ein eigener technischer Benutzer macht das Zugriffsprotokoll aussagekräftig.

Audit. Prüfer wollen typischerweise drei Dinge sehen: eine Liste der erlaubten Upstreams mit Begründung, den technischen Nachweis der Egress-Sperre (Firewall-Regeln, NetworkPolicies) und Protokolle, welche Komponenten wann bezogen wurden. Halte die Repository-Konfiguration als Code fest, zum Beispiel als JSON-Dateien wie in diesem Lab in Git oder mit dem Terraform-Provider für Nexus oder Harbor. Dann ist jede Änderung am Bezugsweg ein nachvollziehbarer Merge Request.

Interviewfragen

F: Was ist der Unterschied zwischen einem Proxy-Cache und einem kuratierten Spiegel?

A: Ein Proxy-Cache lädt jedes angefragte Paket bei Bedarf vom Upstream und speichert es. Er bringt Protokoll, Geschwindigkeit und Unabhängigkeit, lässt aber alles durch. Ein kuratierter Spiegel enthält nur freigegebene Pakete, manuell oder regelbasiert geprüft. Er gibt mehr Kontrolle, kostet aber Pflegeaufwand.

F: Wie stellst du sicher, dass der Spiegel wirklich der einzige Bezugsweg ist?

A: Mit mehreren Schichten. Client-Konfiguration macht den richtigen Weg bequem. Durchgesetzt wird über Netzwerk: Egress-Sperre an der Firewall oder per NetworkPolicy, nur der Spiegel darf ins Internet. Im Cluster zusätzlich eine Admission-Policy, die nur Images aus der eigenen Registry zulässt. Und Monitoring der geblockten Verbindungen.

F: Was ist Dependency Confusion und wie schützt du dich?

A: Ein Angreifer veröffentlicht ein öffentliches Paket mit dem Namen eines internen Pakets und einer höheren Version. Clients, die mehrere Indizes gleichrangig nutzen, nehmen die höhere Version. Schutz: kein --extra-index-url, interne Namen mit Scope oder Präfix, Namen öffentlich reservieren, im Spiegel interne Namen auf dem Proxy blockieren.

F: Verändert ein Spiegel den Digest eines Images?

A: Nein. Der Digest ist der Hash des Manifests. Ein Spiegel liefert Manifest und Layer unverändert aus, deshalb funktionieren Digest-Pinning und Signaturprüfung auch über den Spiegel.

F: Warum kann ein kompromittierter APT-Spiegel nicht einfach Pakete austauschen?

A: Die Paketlisten sind vom Debian-Archiv signiert, und die Listen enthalten die Hashes aller Pakete. apt prüft die Signatur gegen den lokalen Schlüsselbund. Ein Spiegel kann höchstens alte, korrekt signierte Stände ausliefern oder Updates zurückhalten. Dagegen helfen die Valid-Until-Felder in den Release-Dateien und Monitoring.

F: Wie funktioniert ein Proxy-Cache-Projekt in Harbor?

A: Man legt einen Registry-Endpunkt an, etwa Docker Hub, und ein Projekt mit Bezug auf diesen Endpunkt. Clients ziehen über harbor/<projekt>/<image>. Harbor holt fehlende Images vom Upstream und cached sie. Pushen in das Projekt ist nicht möglich.

F: Was ist ein hermetischer Build und wie hängt er mit dem Spiegel zusammen?

A: Ein hermetischer Build hat während der Ausführung keinen Netzzugang. Alle Eingaben werden vorher deklariert und bereitgestellt. Der Spiegel ist die kontrollierte Quelle, aus der diese Eingaben in einem vorgelagerten Schritt geholt werden, zum Beispiel per pip download. Der eigentliche Build läuft dann mit --network=none.

Zusammenfassung

Das hast du gelernt:

  • Ein Spiegel ist die Apotheke deiner Lieferkette: zentral beziehen, speichern, protokollieren, sperren können.
  • Proxy-Cache, kuratierter Spiegel und Offline-Spiegel ergänzen sich. Die Wahl hängt von Zone und Schutzbedarf ab.
  • „Einziger Bezugsweg” entsteht erst durch eine Egress-Sperre. Client-Konfiguration allein ist nur eine Empfehlung.
  • Mit der Nexus-REST-API hast du Proxys für Docker Hub, PyPI, Debian und npm angelegt, als nachvollziehbaren Code in JSON-Dateien.
  • Ein Container im --internal-Netz konnte PyPI nicht erreichen, über Nexus aber problemlos installieren. Der eigentliche Image-Build lief mit --network=none hermetisch.
  • Digests und Signaturen bleiben über den Spiegel gültig. Digest-Pinning, apt-Signaturen und pip-Hashes funktionieren weiter.
  • Harbor bietet Proxy-Cache-Projekte und regelbasierte Replikation für OCI-Artefakte, Artifactory bildet dasselbe Modell mit Remote-, Local- und Virtual-Repositories ab.