Eine Node.js-Sicherheitsprüfungs-API für Platformatic Cloud erstellen und bereitstellen

In diesem Leitfaden beleuchten wir die leistungsstarke Kombination aus Platformatic und Fastify. So ermöglichen wir eine schnelle Backend-Entwicklung mit besonderem Augenmerk auf Robustheit und Sicherheit.

Ob Sie bereits erfahrene:r Node.js-Entwickler:in sind oder gerade erst anfangen: Dieser Artikel hilft Ihnen dabei, Ihre Kenntnisse zu Node.js-PaaS-Umgebungen wie Platformatic zu erweitern. Wir zeigen Ihnen, wie Sie Snyk nahtlos in Ihren Workflow integrieren, Ihren Code auf Schwachstellen und offengelegte Secrets prüfen und mit der Snyk API Sicherheitsanwendungen erstellen.

Mit einer umfassenden Tool-Suite in einem abgestimmten Paket ermöglicht Platformatic Node.js-Entwickler:innen, sich stärker auf die Kernfunktionen ihrer Anwendungen und weniger auf die Komplexität der Backend-Infrastruktur zu konzentrieren.

Eine Node.js-Anwendung mit dem Platformatic-Service einrichten

Erstellen Sie zunächst ein neues Verzeichnis für Ihre Node.js-Anwendung:

mkdir pkg-probe

Führen Sie anschließend den folgenden npm-Befehl aus, um den Platformatic-Projektgenerator zu installieren:

npm create platformatic@latest

Mit diesem Befehl werden Sie aufgefordert, den Download der neuesten Version des npm-Pakets platformatic zu bestätigen:

Need to install the following packages:
create-platformatic@1.11.0
Ok to proceed? (y) y

Beantworten Sie anschließend die Eingabeaufforderungen wie folgt, um einen neuen Node.js-API-Service einzurichten:

 Hello Liran Tal, welcome to Platformatic 1.11.0!
 Let's start by creating a new project.
? Which kind of project do you want to create? Service
? Where would you like to create your project? platformatic-service
? Do you want to run npm install? yes
? Do you want to use TypeScript? no
? What port do you want to use? 3042
? Do you want to create the github action to deploy this application to Platformatic Cloud? yes
? Do you want to enable PR Previews in your application? yes
? Do you want to init the git repository? no

Damit ist ein Platformatic-Service-Projekt im Verzeichnis platformatic-service erstellt. Es verwendet einfaches JavaScript und umfasst eine GitHub-Actions-Integration sowie verbundene PR-Reviews von Platformatic, die in jedem PR einen unveränderlichen Snapshot des Service bereitstellen.

Die Verzeichnis- und Dateistruktur sollte nun ungefähr so aussehen:

.
└── platformatic-service
    ├── README.md
    ├── global.d.ts
    ├── node_modules
    ├── package-lock.json
    ├── package.json
    ├── platformatic.service.json
    ├── plugins
    ├── routes
    └── test

5 directories, 5 files

Den Node.js-Platformatic-Service starten

Der generierte Platformatic-Service kann jetzt bereitgestellt werden. Starten wir die Anwendung. Zuvor müssen wir jedoch das Verzeichnis wechseln:

cd platformatic-service

Führen Sie anschließend Folgendes aus:

npm run start

lirantal  …/repos/pkg-probe/platformatic-service   v20.8.0 
♥ npm run start

> start
> platformatic start

[12:56:12.555] INFO (main/75676): Server listening at http://127.0.0.1:3042

Die generierte Node.js-Anwendung ist jetzt bereit und nimmt HTTP-Anfragen auf Port 3042 entgegen. Am standardmäßigen GET /-Endpunkt zeigt die Anwendung den folgenden einführenden Leitfaden an:

Beachten Sie, dass diese Indexseite speziell von der Platformatic-CLI bereitgestellt wird und für die lokale Entwicklung gedacht ist. Sie ist kein Bestandteil des clientseitigen Browser-Codes, der mit dem Node.js-Anwendungsservice bereitgestellt wird.

Den Platformatic-Service erkunden 

Um besser zu verstehen, wie diese Node.js-Anwendung funktioniert, sehen wir uns die Platformatic-Konfiguration und Verzeichnisstruktur genauer an.

Die Datei platformatic.service.json definiert die Gesamtkonfiguration des bereitgestellten Platformatic-Service, etwa den Port für HTTP-Anfragen sowie die zu ladenden Plugins oder Routen (die ebenfalls als Plugin definiert sind). Hier sehen Sie die generierte Service-Konfigurationsdatei:

{
  "$schema": "https://platformatic.dev/schemas/v1.11.0/service",
  "service": {
    "openapi": true
  },
  "watch": true,
  "plugins": {
    "paths": [
      {
        "path": "./plugins",
        "encapsulate": false
      },
      "./routes"
    ]
  },
  "server": {
    "hostname": "{PLT_SERVER_HOSTNAME}",
    "port": "{PORT}",
    "logger": {
      "level": "{PLT_SERVER_LOGGER_LEVEL}"
    }
  }
}

Wie in der obigen Konfiguration zu sehen ist, enthält plugins einen Eintrag ./routes, der das Verzeichnis angibt, aus dem API-Routen geladen werden.

Die HTTP-Routen finden Sie in der Datei routes/root.js. Das sofort einsatzbereite Beispiel enthält den folgenden GET-Endpunkt unter dem Pfadparameter /example:

/// <reference path="../global.d.ts" />
'use strict'

/** @param {import('fastify').FastifyInstance} fastify */
module.exports = async function (fastify, opts) {
  fastify.get('/example', async (request, reply) => {
    return { hello: fastify.example }
  })
}

Prüfen wir mit der folgenden HTTP-Anfrage an GET /example, ob das funktioniert:

 curl http://localhost:3042/example -vvv  
*   Trying 127.0.0.1:3042...
* Connected to localhost (127.0.0.1) port 3042 (#0)
> GET /example HTTP/1.1
> Host: localhost:3042
> User-Agent: curl/8.1.2
> Accept: */*
> 

< HTTP/1.1 200 OK
< content-type: application/json; charset=utf-8
< content-length: 18
< Date: Thu, 16 Nov 2023 11:24:41 GMT
< Connection: keep-alive
< Keep-Alive: timeout=5
< 
* Connection #0 to host localhost left intact
{"hello":"foobar"}%   

Eine neue Route hinzufügen, um npm-Pakete auf Sicherheitslücken zu prüfen

Fügen wir unserer Node.js-API nun eine neue Funktion hinzu, mit der sie Paketnamen und Versionsangaben entgegennimmt und diese auf bekannte Sicherheitslücken prüft.

In diesem Abschnitt des Tutorials führen wir folgende Schritte aus:

• Die Snyk CLI installieren und einrichten

• Das Snyk-API-Token abrufen

• Mit dem API-Token HTTP-Anfragen an die Snyk API senden

• Einen neuen API-Endpunkt POST /test/vulnerabilities im Node.js-Platformatic-Service definieren

Die Snyk CLI installieren und einrichten, um ein API-Token abzurufen

Der Einstieg in die Snyk CLI ist ganz einfach: Installieren Sie das npm-Paket.

npm install -g snyk

Wenn Sie die Snyk-Abhängigkeit global im npm-Paketbereich installieren, können Sie damit verschiedene Aspekte von Code und Sicherheit in den JavaScript-Projekten prüfen, an denen Sie arbeiten. Snyk kann übrigens auch Code und Abhängigkeiten in Python, Java, Ruby, PHP und weiteren Programmiersprachen prüfen!

Als Nächstes müssen Sie ein kostenloses Snyk-Konto erstellen, damit Sie die API zu Paketschwachstellen abfragen können. Führen Sie dazu Folgendes aus:

snyk auth

Folgen Sie den Anweisungen der CLI. Anschließend können Sie Ihr API-Token mit dem Befehl snyk config abrufen, der einen API-Konfigurationsschlüssel zurückgibt:

snyk config

api: <YOUR_API_TOKEN_HERE>

Bewahren Sie das API-Token griffbereit auf – wir verwenden es gleich. Achten Sie jedoch darauf, dass es nicht versehentlich ins öffentliche Internet gelangt.

Jetzt können Sie Ihren Code und Ihre Abhängigkeiten auf Sicherheitslücken prüfen. Nutzen Sie die Gelegenheit und testen Sie Ihre Node.js-Platformatic-Service-Anwendung.

lirantal  …/pkg-probe/platformatic-service   main !   v20.8.0 
♥  snyk test   

Testing ~/repos/pkg-probe/platformatic-service...

Organization:      snyk-demo-567
Package manager:   npm
Target file:       package-lock.json
Project name:      package.json
Open source:       no
Project path:      ~/repos/pkg-probe/platformatic-service
Licenses:          enabled

✔ Tested 500 dependencies for known issues, no vulnerable paths found.

Next steps:
- Run `snyk monitor` to be notified about new related vulnerabilities.
- Run `snyk test` as part of your CI/test.

Ein großes Lob an das Platformatic-Team: Die Projekt-Tools enthalten keine einzige Schwachstelle!

Weitere Informationen zur Verwendung der Snyk CLI finden Sie in den Snyk User Docs und in unserem praktischen Snyk CLI Cheat Sheet.

Den Node.js-API-Endpunkt POST /test/vulnerabilities definieren

Öffnen Sie die Datei routes/root.js und fügen Sie direkt nach dem vorhandenen Code fastify.get() eine neue Fastify-API-Route hinzu:

  fastify.post("/test/vulnerabilities", async (request, reply) => {
    const packageName = request.query.packageName;
    const packageVersion = request.query.packageVersion;

    const snykApiToken = "12345”
    const url = `https://snyk.io/api/v1/test/npm/${packageName}/${packageVersion}`;

    const response = await fetch(url, {
      headers: {
        Authorization: `token ${snykApiToken}`,
      },
    });

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const data = await response.json();
    return { vulnerabilities: data.issues?.vulnerabilities };
  });

Mit diesem Code wird ein API-Endpunkt eingerichtet, der npm-Pakete mithilfe des Snyk-v1-API-Endpunkts auf Schwachstellen prüft. Sehen wir uns die einzelnen Teile genauer an:

Zunächst wird die Fastify-Route erstellt:

fastify.post("/test/vulnerabilities", async (request, reply) => {...});

Diese Zeile erstellt einen neuen POST-Endpunkt unter /test/vulnerabilities. Dabei kommt Fastify zum Einsatz, ein schnelles Web-Framework mit geringem Overhead für Node.js. Das Schlüsselwort async zeigt an, dass diese Funktion asynchrone Vorgänge ausführen kann.

Als Nächstes lesen wir die Query-Parameter aus der HTTP-Anfrage aus:

const packageName = request.query.packageName;
const packageVersion = request.query.packageVersion;

Diese Parameter geben das npm-Paket und die Version an, die auf Schwachstellen geprüft werden sollen.

Im nächsten Schritt beginnt die Integration der Snyk API:

const snykApiToken = "12345";
const url = `https://snyk.io/api/v1/test/npm/${packageName}/${packageVersion}`;
const response = await fetch(url, { headers: { Authorization: `token ${snykApiToken}` } });

Die URL des Snyk-API-Endpunkts wird aus dem Paketnamen und einer expliziten Versionsnummer zusammengesetzt (kein Tag – „latest“ wird also nicht unterstützt). Anschließend rufen wir die Snyk API asynchron mit fetch auf und übergeben das Autorisierungstoken in den Anfrage-Headern. Dabei handelt es sich um das API-Token, das Sie mit dem Befehl snyk config abgerufen haben.

Zum Schluss gibt der Endpunkt die im angegebenen npm-Paket gefundenen Schwachstellen zurück. Mit optional chaining (?.) werden Fälle abgefangen, in denen die Antwort keine Probleme enthält.

return { vulnerabilities: data.issues?.vulnerabilities };

Abschließend können Sie die Fastify-Routendefinition für den Endpunkt POST /test/vulnerabilities verbessern, indem Sie ein Anfrage- und Antwortschema definieren. Damit fügen Sie eine Eingabevalidierung hinzu und sorgen dafür, dass die Route automatisch in der OpenAPI-API-Dokumentation erfasst wird. Ich empfehle Ihnen das Platformatic movie app tutorial und den Blogbeitrag von Simon Plenderleith zum Erstellen von REST-APIs mit Platformatic DB.

Achten Sie darauf, keine vertraulichen Informationen wie API-Schlüssel offenzulegen!

Ist Ihnen aufgefallen, dass wir das API-Token gerade fest im Code hinterlegt haben? Ein absolutes No-Go!

Das ist mir allerdings nicht entgangen, denn ich habe die Snyk-Erweiterung in meiner VS-Code-IDE installiert. Sie erkennt automatisch Secrets und weist auf unsichere Codestellen in meinem eigenen Code hin, die eine Sicherheitslücke verursachen könnten:

Installieren Sie die Snyk-Erweiterung direkt über die VS-Code-IDE oder informieren Sie sich im VS-Code-Marketplace über die Snyk-Erweiterungen.

Beheben wir nun dank der Warnung zur Secret-Erkennung dieses offengelegte Zugangsdaten-Token. Legen Sie zunächst eine neue Umgebungsvariable in der Datei .env an und ersetzen Sie „1234“ durch Ihr eigenes Snyk-API-Token:

PLT_SNYK_API_TOKEN=1234

Anschließend fügen wir die Variable zur Konfigurationsdatei platformatic.service.json hinzu. Ändern Sie dazu den vorhandenen Zeichenfolgen-Schlüssel ./routes im Array in ein Objekt mit einem options-Schlüssel:

{
  …
  "plugins": {
    "paths": [
      {
        "path": "./plugins",
        "encapsulate": false
      },
     {
        "path": "./routes",
        "options": {
           "snykApiToken": "{PLT_SNYK_API_TOKEN}"
       }
     }
    ]
  },
  …
}

module.exports = async function (fastify, opts) {

    const snykApiToken = opts.snykApiToken;
    const url = `https://snyk.io/api/v1/test/npm/${packageName}/${packageVersion}`;

Wenn Sie npm run start zum Starten des Node.js-Platformatic-Service verwenden, müssen Sie den Befehl nicht erneut ausführen. Die automatische Neuladung aktualisiert den Servercode jedes Mal, wenn Sie Routen- oder Plugin-Dateien speichern.

Ein npm-Paket mit unserem neuen Node.js-API-Service auf Sicherheitslücken prüfen 

Jetzt, da Snyk und der Node.js-Platformatic-API-Service miteinander verbunden sind, prüfen wir, ob alles zusammen funktioniert.

Prüfen wir, ob die neueste Version des npm-Pakets vm2 sicher verwendet werden kann. Einige Entwickler:innen nutzen es als Sicherheits-Sandbox, um nicht vertrauenswürdigen Code auszuführen.

Die folgende HTTP-Anfrage gibt den Paketnamen und die neueste Versionsnummer aus der npmjs-Registry an und leitet die Ausgabe an das Tool jq weiter, um die JSON-Antwort übersichtlich darzustellen:

curl -X POST "http://localhost:3042/test/vulnerabilities?packageName=vm2&packageVersion=3.9.19" | jq 

{
  "vulnerabilities": [
    {
      "id": "SNYK-JS-VM2-5772823",
      "url": "https://snyk.io/vuln/SNYK-JS-VM2-5772823",
      "title": "Remote Code Execution (RCE)",
      "type": "vuln",
      "description": "## Overview\n[vm2](https://github.com/patriksimek/vm2#readme) is a sandbox that can run untrusted code with whitelisted Node's built-in modules.\n\nAffected versions of this package are vulnerable to Remote Code Execution (RCE) due to insufficient checks which allow an attacker to escape the sandbox.\r\n\r\n**Note:**\r\n\r\nAccording to the maintainer, the security issue cannot be properly addressed and the library will be discontinued.\n## Remediation\nThere is no fixed version for `vm2`.\n## References\n- [GitHub Issue](https://github.com/patriksimek/vm2/issues/533)\n",
      "from": [
        "vm2@3.9.19"
      ],
      "package": "vm2",
      "version": "3.9.19",
      "severity": "critical",
      "exploitMaturity": "proof-of-concept",
      "language": "js",
      "packageManager": "npm",
      "semver": {
        "vulnerable": [
          "*"
        ]
      },
      "publicationTime": "2023-07-12T14:50:43.988574Z",
      "disclosureTime": "2023-07-12T14:10:56Z",
      "isUpgradable": false,
      "isPatchable": false,
      "isPinnable": false,
      "identifiers": {
        "CVE": [
          "CVE-2023-37903"
        ],

Es funktioniert! Herzlichen Glückwunsch: Sie haben Ihr erstes Sicherheitstool mit Snyk und Platformatic erstellt!

Erstellen wir nun ein Frontend für diese Webanwendung und stellen anschließend die Node.js-API auf Platformatic Cloud bereit.

Eine Vue-Frontend-Anwendung zum Prüfen auf Sicherheitslücken

In diesem Abschnitt sehen wir uns die Bausteine der Frontend-Webanwendung an, die mit der Node.js-Backend-API kommuniziert, die wir mit dem Platformatic-Service erstellt haben.

Die Frontend-Webanwendung besteht aus folgenden Komponenten:

• Ein clientseitiges Frontend mit Vue.js 3 und Vite

• Tailwind CSS

Das Frontend ist ein einfaches Formular mit Texteingabefeldern für den Paketnamen und die Paketversion. Die Angaben werden an die Node.js-Platformatic-API gesendet.

Hier sehen Sie ein einfaches Vue.js-Formular, das mit dem lokal ausgeführten Node.js-Service unter localhost:3042 kommuniziert:

<script setup>
import { ref } from "vue";

const processing = ref(false);
const packageName = ref("vm2");
const packageVersion = ref("3.9.19");
const vulnerabilities = ref([]);

async function scanPackage() {
  processing.value = true;

  const BASE_URL = "http://localhost:3042";
  const httpResponseRaw = await fetch(
    `${BASE_URL}/test/vulnerabilities?packageName=${packageName.value}&packageVersion=${packageVersion.value}`,
    {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
      },
      body: JSON.stringify({}),
    }
  );

  const httpResponse = await httpResponseRaw.json();
  vulnerabilities.value = httpResponse.vulnerabilities;

  processing.value = false;
}
</script>

Den vollständigen Code für die Frontend-Webanwendung finden Sie in diesem GitHub-Repository: https://github.com/lirantal/pkg-probe.

Die Node.js-Backend-API auf Platformatic Cloud bereitstellen

Platformatic Cloud ist eine spezialisierte PaaS (Platform as a Service), die sich ideal zum Hosten von Node.js-Anwendungen eignet. Neben den hervorragenden Tools von Platformatic können wir nun auch die Cloud-Umgebung nutzen, um unsere Sicherheitsprüfungs-Webanwendung zu hosten und im Internet verfügbar zu machen.

Melden Sie sich zunächst auf der Landingpage über die Schaltfläche Connect with GitHub an. Autorisieren Sie die GitHub-App-Integration und bestätigen Sie die Nutzungsbedingungen und die Datenschutzerklärung. Anschließend können Sie im Dashboard auf Create an app klicken:

Dieser Standard-Workflow erstellt eine neue Platformatic-Beispielanwendung. Da Ihre Anwendung jedoch bereits läuft, klicken Sie unten auf dem Anweisungsbildschirm auf den Link Do it manually.

Geben Sie als Nächstes einen Namen für die Anwendung und den Workspace ein. Lassen Sie Dynamic Workspace deaktiviert, da Sie derzeit keine automatisierten PR-Reviews benötigen, um die Node.js-Anwendung über die CLI bereitzustellen.

Anschließend sehen Sie einen Platformatic-Übersichtsbildschirm wie diesen:

Jetzt verfügen wir über die Workspace-ID und den API-Schlüssel, die wir für die Bereitstellung unserer Node.js-Backend-Anwendung in der Platformatic-Cloud-Hosting-Umgebung benötigen.

Wechseln Sie mit Workspace-ID und API-Schlüssel bereit in das Verzeichnis platformatic-service Ihrer Projekte, um einen npm-Lifecycle-Befehl im Quellcode der Node.js-API auszuführen. Führen Sie den folgenden Befehl npm run deploy aus und geben Sie die Platformatic-Cloud-Workspace-Details wie folgt an:

$  npm run deploy

This application will be deployed to Platformatic Cloud. To change the target use the --deploy-service-host flag
? Select workspace type: static
? Enter workspace id: 09d9a354-b755-40da-b4ab-841a43d8c074
? Enter workspace key: ********************************
[13:41:52] INFO: Found Platformatic config file: platformatic.service.json
[13:41:54] INFO: Project has been successfully archived
[13:41:55] INFO: Uploading bundle (95.9 MB) to the cloud…
…
[13:42:52] INFO: Application has been successfully started

Nach Abschluss des Befehls wird auch die URL angezeigt, unter der die Node.js-API bereitgestellt wurde und erreichbar ist, zum Beispiel: https://something-something-funny.deploy.space

Wenn wir das Platformatic-Cloud-Dashboard unter https://platformatic.cloud erneut öffnen, sehen wir unsere neu erstellte Sicherheitsprüfungsanwendung:

Wenn wir unsere Anwendung öffnen, sehen wir den Echtzeitstatus, etwa Leistungskennzahlen und die öffentliche URL für den Zugriff auf die Anwendung:

Eine letzte Konfiguration müssen Sie noch für die von Platformatic betriebene Node.js-API hinzufügen: CORS aktivieren.

Fügen wir der Node.js-API eine CORS-Konfiguration hinzu. Öffnen Sie die Datei .env und ergänzen Sie die folgende Platformatic-CORS-Konfiguration:

PLT_SERVER_CORS_ORIGIN=http://localhost:5173

Wie Sie in dieser Beispielkonfiguration sehen, ist sie auf den lokalen Entwicklungsserver-Port von Vue.js auf localhost eingestellt. Wenn Sie Ihr Frontend an einem anderen Ort bereitstellen, etwa in einer Netlify- oder Vercel-Cloud-Hosting-Umgebung, müssen Sie den Wert entsprechend anpassen.

Aktualisieren Sie als Nächstes die Konfigurationsdirektive server in platformatic.service.json, sodass sie auch Folgendes enthält:

  "server": {
    "hostname": "{PLT_SERVER_HOSTNAME}",
     // other configuration options…
     // add CORS too:
    "cors": {
      "origin": "{PLT_SERVER_CORS_ORIGIN}"
    }
 }

Erfolg

Das war’s!

Sie haben erfolgreich eine Node.js-Webanwendung erstellt, die mithilfe der Snyk API nach Sicherheitslücken sucht, und sie für die öffentliche Nutzung in der Hosting-Umgebung Platformatic Cloud bereitgestellt.