mitmario.dev

Abhängigkeiten prüfen

Node.js Sandbox 4 Min Lesezeit 3 BeispieleLektion 6 von 8

Die Pakete im Projekt hat jemand geprüft, bevor sie hineinkamen. Seitdem kann in einem davon eine Lücke bekannt geworden sein. Und jedes Update bringt Code mit, den beim Prüfen niemand gesehen hat.

Was npm audit kann

npm audit vergleicht die Versionen in deinem Lockfile mit einer Datenbank gemeldeter Sicherheitslücken und sagt dir, welche davon betroffen sind. Das ist nützlich und kostet einen Befehl.

Was npm audit findet und was nicht
// So arbeitet npm audit: Es vergleicht deine Versionen gegen eine
// Datenbank gemeldeter Lücken. Was dort nicht steht, sieht es nicht.
const datenbank = [
  { paket: "minimatch", unter: "3.0.5", schwere: "high", titel: "ReDoS im Muster-Abgleich" },
  { paket: "tar", unter: "6.1.9", schwere: "high", titel: "Pfade brechen aus dem Zielordner aus" },
];

const installiert = [
  { paket: "minimatch", version: "3.0.4" },
  { paket: "tar", version: "6.2.1" },
  { paket: "buntes-log", version: "2.0.1", postinstall: "curl https://… | sh" },
];

function kleinerAls(a, b) {
  const [a1, a2, a3] = a.split(".").map(Number);
  const [b1, b2, b3] = b.split(".").map(Number);
  if (a1 !== b1) return a1 < b1;
  if (a2 !== b2) return a2 < b2;
  return a3 < b3;
}

function pruefe(paket, version) {
  const eintrag = datenbank.find((e) => e.paket === paket);
  if (!eintrag) return "kein Eintrag in der Datenbank";
  return kleinerAls(version, eintrag.unter) ? `${eintrag.schwere}: ${eintrag.titel}` : "Version ist neu genug";
}

for (const { paket, version, postinstall } of installiert) {
  console.log(`${paket.padEnd(12)} ${version.padEnd(8)} ${pruefe(paket, version)}`);
  if (postinstall) console.log(`${"".padEnd(12)} ${"".padEnd(8)} postinstall: ${postinstall}`);
}

console.log("");
console.log("buntes-log führt beim Installieren fremden Code aus und steht in");
console.log("keiner Datenbank. npm audit meldet dazu nichts, weil es nichts weiß.");

Nützlich ist es allerdings nur so weit, wie die Datenbank reicht. Der erste der drei Fälle ist ein Treffer, eine gemeldete Lücke in einer betroffenen Version. ReDoS heißt sie, weil ein passend gebauter Text den regulären Ausdruck im Paket so lange rechnen lässt, dass der Prozess für nichts anderes mehr Zeit hat. Beim zweiten Paket betrifft die gemeldete Lücke nur ältere Versionen als die installierte. Das dritte steht in keiner Datenbank. Es führt beim Installieren einen Befehl aus, der etwas aus dem Netz holt und ausführt.

Dazu meldet npm audit nichts, weil es nichts wissen kann. Eine Lücke muss erst jemandem auffallen, gemeldet, geprüft und veröffentlicht werden, und das dauert. Bis dahin ist neuer Schadcode für npm audit unsichtbar. Ein grünes Ergebnis heißt nur, dass nichts gemeldet ist.

Warum auf dem Server npm ci läuft

Der Bereich, den das Lockfile schließt
// Was die Registry für dieses Paket kannte, damals und heute.
const imJanuar = ["4.18.1", "4.18.2"];
const heute = ["4.18.1", "4.18.2", "4.19.0", "4.21.2", "5.0.0", "5.2.1"];

// "^4.18.2" heißt: alles ab 4.18.2, solange die erste Zahl gleich bleibt.
function loeseAuf(bereich, registry) {
  const ziffern = bereich.replace("^", "");
  const [haupt] = ziffern.split(".").map(Number);
  return registry.filter((v) => Number(v.split(".")[0]) === haupt).at(-1);
}

console.log('In der package.json steht:  "express": "^4.18.2"');
console.log("Noch ohne Lockfile:");
console.log(`npm install  im Januar      ${loeseAuf("^4.18.2", imJanuar)}`);
console.log(`npm install  heute          ${loeseAuf("^4.18.2", heute)}`);
console.log("");
console.log('Im Lockfile steht:          "version": "4.18.2"');
console.log('                            "integrity": "sha512-oxlOK…"');
console.log("");
console.log("npm ci       im Januar      4.18.2");
console.log("npm ci       heute          4.18.2");
console.log("");
console.log("Der Bereich sagt, was erlaubt ist. Das Lockfile sagt, was war.");
console.log("Und die Prüfsumme sagt, dass es dasselbe Paket ist wie damals.");

In der package.json steht ein Versionsbereich, etwa ^4.18.2, also alles ab dieser Version, solange die erste Zahl gleich bleibt. Ohne Lockfile löst npm install diesen Bereich gegen die Registry von heute auf. Im Januar kam dabei 4.18.2 heraus, heute 4.21.2, und im Projekt hat niemand etwas geändert.

Das Lockfile hält fest, was wirklich installiert wurde, mit der Version und einer Prüfsumme je Paket. npm ci installiert genau die Versionen aus dem Lockfile und rechnet ihre Prüfsummen nach. Passen Lockfile und package.json nicht zusammen, bricht es ab, statt das Lockfile anzupassen. Was seit gestern in der Registry passiert ist, kommt so nicht auf den Server.

Die Prüfsummen fangen dabei mehr als Übertragungsfehler. Bekommt ein Paket unter derselben Versionsnummer einen anderen Inhalt, passt die Prüfsumme nicht mehr, und npm ci hört auf. Das wirkt nur, wenn das Lockfile im Repository liegt.

Der Angriff über die Lieferkette

Ein Angriff über die Lieferkette (englisch supply chain) zielt auf ein Paket, von dem deins abhängt, am liebsten weit unten im Baum. Ein kleines Hilfspaket, das seit Jahren niemand pflegt und das in ein paar Millionen Projekten steckt, erreicht auf einen Schlag alle.

Dafür braucht es nicht mal einen Einbruch. Jemand bietet der überlasteten Maintainerin an, die Wartung zu übernehmen, arbeitet ein paar Monate ordentlich mit und veröffentlicht dann eine Version, die beim Installieren etwas Zusätzliches tut. Manchmal reicht auch ein Konto ohne Zwei-Faktor-Anmeldung.

Wie viel fremder Code beim Installieren läuft
// Ein kleiner Abhängigkeitsbaum. Drei der vier Pakete bringen Skripte
// mit, die beim Installieren laufen, und drei davon gehören dir nicht.
const baum = [
  { name: "meine-app", eigenes: true, skripte: ["prepare"] },
  { name: "buntes-log", eigenes: false, skripte: ["postinstall"] },
  { name: "schnell-parser", eigenes: false, skripte: ["install", "postinstall"] },
  { name: "farben", eigenes: false, skripte: [] },
];

function laufen(mitSkripten) {
  return baum.flatMap((p) => (mitSkripten ? p.skripte.map((s) => `${p.name}:${s}`) : []));
}

const alle = laufen(true);
const fremde = alle.filter((eintrag) => !eintrag.startsWith("meine-app:"));

console.log(`npm install                    ${alle.length} Skripte laufen`);
for (const eintrag of alle) console.log(`                               ${eintrag}`);
console.log("");
console.log(`npm install --ignore-scripts   ${laufen(false).length} Skripte laufen`);
console.log("");
console.log(`Davon aus fremdem Code:        ${fremde.length}`);
console.log("Sie laufen als du und dürfen alles, was du darfst.");

Beim Installieren laufen Skripte, im Beispiel vier, und drei davon stammen aus fremden Paketen. Sie laufen als du, mit deinen Rechten, in deinem Projektverzeichnis, und in einer Pipeline mit allen Zugangsdaten, die dort liegen. npm install --ignore-scripts schaltet sie ab.

Der Installationsbefehl der Sandbox, in der dieser Kurs läuft, enthält aus derselben Vorsicht --ignore-scripts. Gebraucht wird er hier nie, denn die beiden Pakete des Kurses liegen fertig auf der Maschine und werden nur kopiert. Der Weg, den es nicht braucht, soll trotzdem der sichere sein.

Was im Alltag hilft

Weniger Pakete sind der erste Schutz. Jede Abhängigkeit ist fremder Code mit eigenen Abhängigkeiten und eigenen Wartungssorgen, und die Frage aus Lektion 5.5, ob es von Hand nicht zwanzig Zeilen wären, gilt hier weiter.

Updates kommen am besten bewusst und nicht von selbst. Ein Bot, der jeden Tag alles aktualisiert und selbst zusammenführt, bringt eine übernommene Version am schnellsten ins Projekt. Ich aktualisiere in Abständen und gebündelt, mit einem Blick ins Changelog und darauf, wer das Paket veröffentlicht hat.

Und die Prüfung läuft bei jedem Bau statt von Hand. Ein Programm liest das Lockfile und endet mit Exit-Code 1, sobald ein Paket ein Installationsskript mitbringt, das noch niemand angesehen hat. Läuft es vor der Installation, hält es die Pipeline an, bevor dieses Skript irgendwo ausgeführt wird.

Wie Schadcode über fremde Repositories auch in KI-Werkzeuge kommt, steht im Blog-Artikel Poisoned Repos.

In der Aufgabe baust du so ein Programm für ein Lockfile mit neun Paketen.

Zum Mitnehmen

npm audit kennt nur Lücken, die schon gemeldet sind, und neuer Schadcode steht in keiner Datenbank. npm ci installiert nur, was im Lockfile steht, samt Prüfsummen, und die Installationsskripte fremder Pakete laufen mit deinen Rechten.

Jetzt du

Basis Konto, kostenlos

Zu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.

Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.

In diesem Kurs läuft dein Code auf einem Server. Dafür hat das Basis Konto 1 Stunde im Monat, mehr Zeit gibt es mit dem Premium Konto.

Was in dieser Lektion steckt

  • Artikel mit 3 Beispielen zum Ausprobieren

    Steht hier, ohne Konto lesbar.

  • Aufgabe, dein Code läuft auf einem Server

    Öffnet sich mit dem Basis Konto.