Einstieg in die statische Analyse von PHP im Jahr 2024

Artikel von

21. März 2024

0 Min. Lesezeit

PHP ist eine beliebte serverseitige Skriptsprache, die häufig für die Webentwicklung eingesetzt wird. Mit Tools zur statischen Analyse können PHP-Entwickler:innen mehr hochwertige Softwareprodukte schneller bereitstellen und deployen. Diese Tools helfen, PHP-Codefehler, Sicherheitslücken und andere Probleme zu minimieren, die Qualität und Sicherheit der Anwendung beeinträchtigen können, wenn sie nicht frühzeitig im Entwicklungszyklus behoben werden.

Was ist statische Analyse?

Statische Analyse, auch statische Codeanalyse oder Quellcodeanalyse genannt, ist eine Methode zur Fehlersuche, bei der der Quellcode untersucht wird, bevor ein Programm ausgeführt wird. Dabei wird eine Reihe von Codierregeln auf den Quellcode eines Programms angewendet. Das Hauptziel der statischen Analyse besteht darin, Fehler frühzeitig in der Codeentwicklung zu erkennen und zu beheben.

Bei PHP bedeutet statische Analyse, den PHP-Code zu untersuchen, ohne ihn auszuführen. Dabei geht es unter anderem darum, Probleme zu finden, die Einhaltung von Codierungsstandards zu überprüfen und die Architektur besser zu verstehen.

So könnte ein Tool zur statischen Analyse ein Problem im PHP-Code hervorheben:

<?php
function add(int $left, int $right): int {
    return $left + $right;
}

echo add("one", "two");
?>

In diesem Beispiel würde das Tool zur statischen Analyse erkennen, dass die Argumente „one“ und „two“ keine Integer sind und damit gegen die Typdeklaration der Funktionsparameter verstoßen.

Die Bedeutung der statischen Analyse in der PHP-Entwicklung

Die statische Analyse spielt in der PHP-Entwicklung aus mehreren Gründen eine entscheidende Rolle. Erstens hilft sie dabei, PHP-Codefehler und potenzielle Probleme in der Codebasis zu erkennen, bevor der Code in die Produktion gelangt. Das ist besonders wichtig bei einer Sprache wie PHP, die dynamisch typisiert ist und daher leicht zu typbezogenen Fehlern führen kann.

Zweitens kann die statische Analyse in PHP sicherstellen, dass der Code einer festgelegten Reihe von Codierungsstandards entspricht. Das ist besonders bei großen Projekten oder der Zusammenarbeit im Team wichtig, denn ein einheitlicher Codierungsstil ist entscheidend für die Lesbarkeit und Wartbarkeit des Codes.

Schließlich kann die statische Analyse komplexen oder „riechenden“ Code aufdecken, der überarbeitet werden sollte. Durch Kennzahlen zur Codekomplexität kann sie als Leitfaden dienen, um die Gesamtqualität des Codes zu verbessern.

Vorteile der statischen Analyse

Die statische Analyse unterstützt Entwickler:innen und Sicherheitsteams, insbesondere bei der PHP-Entwicklung, dabei:

die Codequalität zu verbessern: Tools zur statischen Analyse helfen Entwickler:innen, die Qualität ihres Codes zu verbessern, indem sie Fehler, Sicherheitslücken und Verstöße gegen Codierungsstandards erkennen. Werden diese Probleme früh im Entwicklungszyklus behoben, können daraus keine größeren Schwierigkeiten entstehen.
die Sicherheit zu erhöhen: Aus Sicherheitsperspektive helfen Tools zur statischen Analyse dabei, potenzielle Sicherheitslücken in Ihrer Codebasis zu erkennen. Sie können häufige Sicherheitsprobleme wie Code-Injection in PHP, Cross-Site-Scripting (XSS) und Open-Redirect-Sicherheitslücken aufdecken.
Codefehler frühzeitig zu erkennen: Wenn Probleme früh erkannt werden, sparen Entwickler:innen mit statischer Analyse Zeit und Ressourcen. Sie kann den Zeitaufwand für Debugging und manuelle Code-Reviews erheblich verringern, sodass Entwickler:innen sich auf komplexere Aufgaben konzentrieren können. Starten Sie mit dem kostenlosen statischen Sicherheitsanalyse-Scan mit Snyk.
Standards einzuhalten: Die statische Analyse kann dazu beitragen, dass Ihre Codebasis die Branchenstandards für Codequalität, Sicherheit und Wartbarkeit erfüllt. Das ist besonders in regulierten Branchen wichtig, in denen die Einhaltung bestimmter Standards häufig vorgeschrieben ist.

PERCS 2.0 verstehen

PERCS 2.0 steht für PHP Enhanced Review Coding Standard und ist eine umfassende Weiterentwicklung der ursprünglichen PERCS-Version. Das fortschrittliche Tool zur statischen Analyse von PHP-Code ermöglicht es Entwickler:innen, bestimmte Codierungsstandards einzuhalten, die Codequalität zu verbessern und Codierungskonventionen zu stärken.

Diese PERCS-Version bietet zahlreiche Funktionen, darunter Syntaxprüfung, Prüfung des Codierungsstils und die Erkennung potenzieller Sicherheitslücken. Sie ist ein wertvolles Tool für PHP-Entwickler:innen, die die Qualität ihres Codes verbessern und die Einhaltung gängiger Codierungskonventionen sicherstellen möchten.

// Sample PHP code
<?php
$a = 1;
$b = 2;

// PERCS 2.0 can identify if this code adheres to the defined coding standards
$result = $a + $b;

// PERCS 2.0 will provide feedback on potential issues in this code
$result = add('1', 2);
?>

Die Einhaltung von Codierungsstandards ist in der Softwareentwicklung entscheidend. Sie sorgen dafür, dass Code lesbar, wartbar und konsistent ist. Das erleichtert die Zusammenarbeit im Team und neuen Entwickler:innen das Verständnis der Codebasis. Codierungsstandards beugen außerdem häufigen Programmierfehlern und potenziellen Sicherheitslücken vor. Mit einem einheitlichen Codierungsstil können Entwickler:innen Probleme effizienter erkennen und beheben.

// A non-standard code
<?php
function ADD($a,$b){return $a+$b;}
?>

// A standard code
<?php
function addNumbers($firstNumber, $secondNumber) {
    return $firstNumber + $secondNumber;
}
?>

PERCS 2.0 verbessert sowohl die Codequalität als auch die Einhaltung von Codierungskonventionen erheblich. Dazu gibt das Tool Entwickler:innen direktes Feedback zu ihrem Code und hebt Bereiche hervor, die Codierungsstandards nicht erfüllen oder potenzielle Sicherheitslücken aufweisen.

Mit PERCS 2.0 können Entwickler:innen eine höhere Codequalität durchsetzen und so sicherstellen, dass ihre PHP-Anwendungen zuverlässig, wartbar und sicher sind.

Die drei besten Tools zur statischen Analyse von PHP

Im Bereich Codesicherheit und Softwareentwicklung ist die statische Analyse ein wichtiger Faktor, um eine hohe Codequalität zu gewährleisten und potenzielle Sicherheitslücken zu erkennen, bevor sie zum Problem werden. Sehen wir uns drei leistungsstarke Tools zur statischen Analyse von PHP an: PHPStan, Psalm und Snyk. Mit diesen Tools können Entwickler:innen Fehler und Sicherheitsmängel im PHP-Code finden und so sicherstellen, dass die Anwendung Sicherheitsanforderungen erfüllt.

1. PHPStan

PHPStan ist eines der beliebtesten Tools zur statischen Analyse von PHP-Code. Es konzentriert sich darauf, Fehler im Code zu finden, ohne ihn tatsächlich auszuführen. Ein wesentlicher Vorteil von PHPStan ist, dass es ganze Fehlerklassen erkennen kann, noch bevor Sie Tests für den Code schreiben.

PHPStan installieren Sie mit Composer, einem Tool zur Abhängigkeitsverwaltung für PHP. So geht’s:

composer require --dev phpstan/phpstan

PHPStan auf Ihren PHP-Code anzuwenden, ist ganz einfach: Führen Sie den folgenden Befehl aus:

vendor/bin/phpstan analyse src

Hier steht src für das Verzeichnis, das Ihren PHP-Code enthält. PHPStan gibt anschließend eine Liste der potenziellen Probleme aus, die im Code gefunden wurden. Die Ausgabe enthält in der Regel den Dateinamen, die Zeilennummer und eine Beschreibung des Problems. So könnte die Ausgabe beispielsweise aussehen:

------ ----------------------------------------------------------------
  Line   src/Example.php
------ ----------------------------------------------------------------
  10     Parameter #1 $a of method Example::add() expects int, string given.
------ ----------------------------------------------------------------

2. Psalm

Psalm ist ein weiteres leistungsstarkes Tool zur statischen Analyse von PHP. Es wurde entwickelt, um Syntax- und Logikfehler im Code zu erkennen. Ein großer Vorteil von Psalm ist, dass es Typen in Ihrem PHP-Code ableiten und so typbezogene Fehler erkennen kann, bevor sie auftreten.

Psalm können Sie mit Composer installieren:

composer require --dev vimeo/psalm

Führen Sie den folgenden Befehl aus, um Psalm auf Ihren PHP-Code anzuwenden:

vendor/bin/psalm

Die Ausgabe von Psalm zeigt wie bei PHPStan eine Liste der Probleme in Ihrem Code. Psalm gibt außerdem für jedes Problem einen Schweregrad an, der Ihnen bei der Priorisierung von Korrekturen helfen kann.

Hier sehen Sie eine Beispielausgabe von Psalm:

ERROR: InvalidArgument - src/Example.php:10:10 - Argument 1 of Example::add expects int, string provided

3. Snyk für Codesicherheit in der PHP-Entwicklung

Snyk ist ein sicherheitsorientiertes Tool für Entwickler:innen, mit dem sie Schwachstellen und Sicherheitsprobleme in ihrem Code, in <nbsp>Open-Source-Abhängigkeiten, Container-Images und vielem mehr finden, verstehen und beheben können. Das Tool lässt sich direkt in Ihren bestehenden Workflow integrieren. Es funktioniert nahtlos mit verschiedenen IDEs und Build-Tools. So können Sie das PHPStorm-Plugin oder die VS-Code-Erweiterung von Snyk ganz einfach kostenlos installieren und Ihren Code auf Sicherheitslücken scannen.

Snyk erkennt unsicheren Code mithilfe seiner umfassenden Schwachstellendatenbank und leistungsfähigen Codeanalyse. Dadurch kann das Tool eine Vielzahl potenzieller Sicherheitsbedrohungen erkennen, darunter die Codeausführung, von der das SuiteCRM-Projekt betroffen war, und die Remote-Codeausführung in dompdf.

Sehen wir uns ein Beispiel für eine SQL-Injection an, die Snyk erkennen kann:

// Example of SQL Injection Vulnerability
<?php

$conn = new mysqli("127.0.0.1", "user", "MySecretPassword", "db");

function doSqlQuery() {
  $query = "SELECT * FROM users WHERE login = '" . $_POST["login"];

  return mysqli_query($conn, $query);
}

$target = $_GET["target"];

header("Location: " . $target);

echo $_GET["user"];

Im obigen PHP-Codeausschnitt werden Benutzereingaben direkt an die SQL-Abfrage angehängt, wodurch der Code anfällig für SQL-Injection-Angriffe ist. Die statische PHP-Codeanalyse von Snyk stuft dies als schwerwiegendes Sicherheitsrisiko ein. Ich empfehle Ihnen die Snyk-Learn-Lektion zu SQL-Injections, in der Sie erfahren, warum der obige Code unsicher ist und wie Sie diese Sicherheitslücke verhindern können.

Snyk Code findet SQL-Injection-Schwachstellen in PHP-Code.

Snyk hilft auch dabei, häufige Fehler im PHP-Code zu erkennen, die zu Sicherheitsproblemen führen können. So kann etwa die Verwendung einer veralteten oder nicht unterstützten PHP-Funktion Sicherheitslücken in der Anwendung verursachen.

Snyk in PHPStorm und der VS-Code-IDE integrieren

Snyk lässt sich ganz einfach in beliebte IDEs wie PHPStorm und Visual Studio Code integrieren und liefert beim Programmieren Feedback in Echtzeit sowie Ergebnisse von Schwachstellenscans.

Nach der Installation des Snyk-Plugins für PHPStorm können Sie Scans direkt in Ihrer IDE ausführen. Klicken Sie einfach im Project Explorer mit der rechten Maustaste auf Ihr Projekt, wählen Sie Snyk Scan aus und sehen Sie sich die Scan-Ergebnisse im Tab Snyk im unteren Bereich an.

Snyk in VS Code integrieren

Um Snyk in VS Code zu integrieren, installieren Sie die Erweiterung Snyk Vulnerability Scanner aus dem VS-Code-Marktplatz. Nach der Installation scannt Snyk Ihr Projekt automatisch auf unsichere PHP-Codemuster und anfällige Abhängigkeiten in Ihrer Composer-Datei. Sie können ein Projekt auch erneut scannen: Öffnen Sie dazu die Command Palette (Ctrl+Shift+P), geben Sie Snyk ein und wählen Sie die Option Snyk: Rescan aus. Die Scan-Ergebnisse werden in einem neuen Snyk-Tab in der Seitenleiste angezeigt.

Statische PHP-Analyse in CI/CD-Pipelines integrieren

Angesichts der zunehmenden Komplexität der Softwareentwicklung und des wachsenden Bedarfs an sicheren Anwendungen ist es wichtiger denn je, Tools zur statischen Analyse und für den Codierungsstil in Ihren PHP-Entwicklungsworkflow zu integrieren. Continuous-Integration-(CI)- und Continuous-Deployment-(CD)-Pipelines bieten eine ideale Umgebung, um diese Prozesse zu automatisieren und so während des gesamten Entwicklungszyklus die Codequalität und Sicherheit zu gewährleisten.

Diese Tools tragen nicht nur zur Codequalität und Konsistenz bei, sondern dienen auch als erste Verteidigungslinie gegen potenzielle Sicherheitsbedrohungen. Sie helfen dabei, potenzielle Sicherheitslücken bereits in frühen Phasen der Softwareentwicklung zu erkennen und zu beheben – und sparen so langfristig Zeit, Aufwand und Ressourcen.

# An example of integrating PHPStan into a CI/CD pipeline using GitHub Actions

name: PHPStan

on: [push, pull_request]

jobs:
  analysis
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - uses: shivammathur/setup-php@v2
        with:
          php-version: '7.4'
          tools: phpstan
      - run: composer install --no-progress
      - run: phpstan analyse

Im obigen Beispiel ist PHPStan mithilfe von GitHub Actions in eine CI/CD-Pipeline integriert. So wird die statische Analyse bei jedem Push und jedem Pull-Request automatisch ausgeführt. Potenzielle Probleme werden früh erkannt und Code-Reviews effizienter.

Vorteile der Integration statischer Analyse in die CI-Automatisierung

Die Integration statischer Analyse in Ihre CI-Pipeline bietet zahlreiche Vorteile:

Fehler frühzeitig erkennen: Die statische Analyse kann potenzielle Probleme und Sicherheitslücken früh im Entwicklungsprozess erkennen und so Zeit und Kosten für deren Behebung senken.
Codequalität verbessern: Indem Codierungsstandards und Best Practices durchgesetzt werden, trägt die statische Analyse zu saubererem und besser wartbarem Code bei.
Sicherheit erhöhen: Die statische Analyse kann Sicherheitslücken im Code erkennen und so zu sichereren Anwendungen beitragen.

Tools für den Codierungsstil kennenlernen

Als Nächstes geht es darum, einen einheitlichen Codierungsstil beizubehalten. Tools für den Codierungsstil spielen eine wichtige Rolle dabei, einen einheitlichen Stil in der gesamten Codebasis durchzusetzen und den Code lesbar und wartbar zu machen. Sie können außerdem die Wahrscheinlichkeit von Fehlern und Sicherheitslücken verringern, indem sie gute Programmierpraktiken durchsetzen. Dafür gibt es spezielle Tools für den PHP-Codierungsstil: PHPCS, StyleCI und PHP-CS-Fixer.

Warum ein Tool für den Codierungsstil einsetzen?

Codierungsstandards umfassen Richtlinien und Best Practices für das Schreiben von Code. Sie helfen Entwickler:innen dabei, sauberen, professionellen und fehlerfreien Code zu schreiben. Ein einheitlicher Codierungsstil verbessert die Lesbarkeit des Codes, verringert seine Komplexität und fördert die Wiederverwendung von Code. Hier kommen Tools für den Codierungsstil ins Spiel: Sie überprüfen den Code automatisch auf Stilprobleme und können diese in manchen Fällen sogar beheben.

In der PHP-Entwicklung sind diese Tools unverzichtbar. Sie helfen nicht nur dabei, einen einheitlichen Codierungsstil beizubehalten, sondern spielen auch eine wichtige Rolle beim Erkennen potenzieller Sicherheitslücken. Das ist in der heutigen Cyberbedrohungslandschaft entscheidend, denn schon kleinste Codierungsfehler können zu schwerwiegenden Sicherheitsverletzungen führen.

PHP_CodeSniffer (PHPCS)

PHP_CodeSniffer (PHPCS) besteht aus zwei PHP-Skripten. Das Hauptskript phpcs zerlegt PHP-, JavaScript- und CSS-Dateien in Tokens, um Verstöße gegen einen festgelegten Codierungsstandard zu erkennen. Ein zweites Skript, phpcbf, behebt Verstöße gegen den Codierungsstandard automatisch.

Sie können PHPCS mit Composer installieren:

composer global require "squizlabs/php_codesniffer=*"

Nach der Installation können Sie den Befehl phpcs in Ihrem Projektverzeichnis ausführen:

phpcs /path/to/your/php/files

PHPCS gibt alle gefundenen Verstöße gegen Codierungsstandards aus. Zum Beispiel:

FILE: /path/to/your/php/files/example.php
--------------------------------------------------------------------------------
FOUND 1 ERROR AFFECTING 1 LINE
--------------------------------------------------------------------------------
 20 | ERROR | [x] Line indented incorrectly; expected 4 spaces, found 2
--------------------------------------------------------------------------------
PHPCBF CAN FIX THE 1 MARKED SNIFF VIOLATIONS AUTOMATICALLY
--------------------------------------------------------------------------------

Mit dem Befehl phpcbf können Sie diese Probleme automatisch beheben:

phpcbf /path/to/your/php/files

StyleCI

StyleCI ist ein Continuous-Integration-Dienst für PHP-Codierungsstile. Das webbasierte Tool lässt sich in Ihre GitHub-, GitLab- oder Bitbucket-Repositories integrieren. Es überprüft jeden Push und Pull Request, um sicherzustellen, dass der Code dem konfigurierten Codierungsstil entspricht.

Um StyleCI zu nutzen, müssen Sie sich auf der Website registrieren und Ihre Repositories verknüpfen.

PHP-CS-Fixer

Das Tool PHP-CS-Fixer von FriendsOfPHP erkennt nicht nur Verstöße gegen Codierungsstandards, sondern behebt sie auch in Ihrem PHP-Code.

Sie können PHP-CS-Fixer mit Composer installieren:

composer global require friendsofphp/php-cs-fixer

Nach der Installation von PHP-CS-Fixer können Sie Ihren Code mit dem Befehl php-cs-fixer korrigieren:

php-cs-fixer fix /path/to/your/php/files

PHP-CS-Fixer gibt die Dateien aus, die es korrigiert hat:

Fixed all files in 0.123 seconds, 12.000 MB memory used

Fazit

In diesem Blogbeitrag haben wir die Bedeutung von statischer Analyse und Tools für Codierungsstile in der PHP-Entwicklung erläutert. Wir haben gesehen, wie diese Tools nicht nur die Qualität der Codebasis, sondern auch die allgemeine Sicherheit der Anwendung verbessern können.

Tools für statische Analyse wie PHPStan, Psalm und Snyk spielen eine zentrale Rolle dabei, potenzielle Probleme in Ihrem PHP-Code zu erkennen, die zu Fehlern oder Sicherheitslücken führen können. Sie analysieren Ihren Code eingehend, ohne ihn tatsächlich auszuführen. So lassen sich Fehler bereits frühzeitig erkennen.

Wenn Sie PHP-Anwendungen in Containern entwickeln, empfehle ich Ihnen, sich als Nächstes diese Ressourcen anzusehen:

Starten Sie mit Capture-the-Flag

Erfahren Sie in unserem virtuellen On-Demand-Workshop für Einsteiger, wie Sie Capture-the-Flag-Challenges lösen.

Jetzt ansehen