hacktricks/network-services-pentesting/pentesting-web/code-review-tools.md

# Überprüfung des Quellcodes / SAST-Tools

<details>

<summary><strong>Lernen Sie AWS-Hacking von Null auf Held mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Andere Möglichkeiten, HackTricks zu unterstützen:

* Wenn Sie Ihr **Unternehmen in HackTricks bewerben möchten** oder **HackTricks als PDF herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) **GitHub-Repositories** senden.

</details>

## Anleitung und Listen von Tools

* [**https://owasp.org/www-community/Source\_Code\_Analysis\_Tools**](https://owasp.org/www-community/Source\_Code\_Analysis\_Tools)
* [**https://github.com/analysis-tools-dev/static-analysis**](https://github.com/analysis-tools-dev/static-analysis)

## Mehrsprachige Tools

### [Naxus - AI-Gents](https://www.naxusai.com/)

Es gibt ein **kostenloses Paket zur Überprüfung von PRs**.

### [**Semgrep**](https://github.com/returntocorp/semgrep)

Es ist ein **Open Source-Tool**.

#### Unterstützte Sprachen

| Kategorie     | Sprachen                                                                                              |
| ------------ | ----------------------------------------------------------------------------------------------------- |
| GA           | C# · Go · Java · JavaScript · JSX · JSON · PHP · Python · Ruby · Scala · Terraform · TypeScript · TSX |
| Beta         | Kotlin · Rust                                                                                         |
| Experimental | Bash · C · C++ · Clojure · Dart · Dockerfile · Elixir · HTML · Julia · Jsonnet · Lisp ·               |

#### Schnellstart

{% code overflow="wrap" %}
```bash
# Install https://github.com/returntocorp/semgrep#option-1-getting-started-from-the-cli
brew install semgrep

# Go to your repo code and scan
cd repo
semgrep scan --config auto
```
{% endcode %}

Sie können auch die [**semgrep VSCode-Erweiterung**](https://marketplace.visualstudio.com/items?itemName=Semgrep.semgrep) verwenden, um die Ergebnisse in VSCode zu erhalten.

### [**SonarQube**](https://www.sonarsource.com/products/sonarqube/downloads/)

Es gibt eine installierbare **kostenlose Version**.

#### Schnellstart

{% code overflow="wrap" %}
```bash
# Run the paltform in docker
docker run -d --name sonarqube -e SONAR_ES_BOOTSTRAP_CHECKS_DISABLE=true -p 9000:9000 sonarqube:latest
# Install cli tool
brew install sonar-scanner

# Go to localhost:9000 and login with admin:admin or admin:sonar
# Generate a local project and then a TOKEN for it

# Using the token and from the folder with the repo, scan it
cd path/to/repo
sonar-scanner \
-Dsonar.projectKey=<project-name> \
-Dsonar.sources=. \
-Dsonar.host.url=http://localhost:9000 \
-Dsonar.token=<sonar_project_token>
```
{% endcode %}

### CodeQL

Es gibt eine **installierbare kostenlose Version**, aber gemäß der Lizenz können Sie die **kostenlose CodeQL-Version nur in Open Source-Projekten** verwenden.

#### Installation

{% code overflow="wrap" %}
```bash
# Download your release from https://github.com/github/codeql-action/releases
## Example
wget https://github.com/github/codeql-action/releases/download/codeql-bundle-v2.14.3/codeql-bundle-osx64.tar.gz

# Move it to the destination folder
mkdir ~/codeql
mv codeql-bundle* ~/codeql

# Decompress it
cd ~/codeql
tar -xzvf codeql-bundle-*.tar.gz
rm codeql-bundle-*.tar.gz

# Add to path
echo 'export PATH="$PATH:/Users/username/codeql/codeql"' >> ~/.zshrc

# Check it's correctly installed
## Open a new terminal
codeql resolve qlpacks #Get paths to QL packs
```
{% endcode %}

#### Schnellstart - Datenbank vorbereiten

{% hint style="success" %}
Das erste, was Sie tun müssen, ist die **Datenbank vorzubereiten** (den Code-Baum erstellen), damit später die Abfragen darüber ausgeführt werden können.
{% endhint %}

* Sie können CodeQL erlauben, die Sprache des Repos automatisch zu erkennen und die Datenbank zu erstellen

{% code overflow="wrap" %}
```bash
codeql database create <database> --language <language>

# Example
codeql database create /path/repo/codeql_db --source-root /path/repo
## DB will be created in /path/repo/codeql_db
```
{% endcode %}

{% hint style="danger" %}
Dies **löst normalerweise einen Fehler aus**, der besagt, dass mehr als eine Sprache angegeben wurde (oder automatisch erkannt wurde). **Überprüfen Sie die nächsten Optionen**, um dies zu beheben!
{% endhint %}

* Sie können dies **manuell angeben**, indem Sie das **Repo** und die **Sprache** angeben ([Liste der Sprachen](https://docs.github.com/en/code-security/codeql-cli/getting-started-with-the-codeql-cli/preparing-your-code-for-codeql-analysis#running-codeql-database-create))

{% code overflow="wrap" %}
```bash
codeql database create <database> --language <language> --source-root </path/to/repo>

# Example
codeql database create /path/repo/codeql_db --language javascript --source-root /path/repo
## DB will be created in /path/repo/codeql_db
```
{% endcode %}

* Wenn Ihr Repository **mehr als 1 Sprache** verwendet, können Sie auch **1 Datenbank pro Sprache** erstellen und jede Sprache angeben.

{% code overflow="wrap" %}
```bash
export GITHUB_TOKEN=ghp_32849y23hij4...
codeql database create <database> --source-root /path/to/repo --db-cluster --language "javascript,python"

# Example
export GITHUB_TOKEN=ghp_32849y23hij4...
codeql database create /path/repo/codeql_db --source-root /path/to/repo --db-cluster --language "javascript,python"
## DBs will be created in /path/repo/codeql_db/*
```
{% endcode %}

* Sie können `codeql` auch erlauben, alle Sprachen für Sie zu erkennen und pro Sprache eine Datenbank zu erstellen. Sie müssen ihm einen **GITHUB\_TOKEN** geben.

{% code overflow="wrap" %}
```bash
export GITHUB_TOKEN=ghp_32849y23hij4...
codeql database create <database> --db-cluster --source-root </path/to/repo>

# Example
export GITHUB_TOKEN=ghp_32849y23hij4...
codeql database create /tmp/codeql_db --db-cluster --source-root /path/repo
## DBs will be created in /path/repo/codeql_db/*
```
{% endcode %}

#### Schnellstart - Code analysieren

{% hint style="success" %}
Jetzt ist es endlich an der Zeit, den Code zu analysieren.
{% endhint %}

Denken Sie daran, dass wenn Sie mehrere Sprachen verwendet haben, **eine Datenbank pro Sprache** im angegebenen Pfad erstellt wurde.

{% code overflow="wrap" %}
```bash
# Default analysis
codeql database analyze <database> --format=<format> --output=</out/file/path>
# Example
codeql database analyze /tmp/codeql_db/javascript --format=sarif-latest --output=/tmp/graphql_results.sarif

# Specify QL pack to use in the analysis
codeql database analyze <database> \
<qls pack> --sarif-category=<language> \
--sarif-add-baseline-file-info \ --format=<format> \
--output=/out/file/path>
# Example
codeql database analyze /tmp/codeql_db \
javascript-security-extended --sarif-category=javascript \
--sarif-add-baseline-file-info --format=sarif-latest \
--output=/tmp/sec-extended.sarif
```
{% code overflow="wrap" %}

#### Schnellstart - Skriptgesteuert

{% endcode %}
```bash
export GITHUB_TOKEN=ghp_32849y23hij4...
export REPO_PATH=/path/to/repo
export OUTPUT_DIR_PATH="$REPO_PATH/codeql_results"
mkdir -p "$OUTPUT_DIR_PATH"
export FINAL_MSG="Results available in: "

echo "Creating DB"
codeql database create "$REPO_PATH/codeql_db" --db-cluster --source-root "$REPO_PATH"
for db in `ls "$REPO_PATH/codeql_db"`; do
echo "Analyzing $db"
codeql database analyze "$REPO_PATH/codeql_db/$db" --format=sarif-latest --output="${OUTPUT_DIR_PATH}/$db).sarif"
FINAL_MSG="$FINAL_MSG ${OUTPUT_DIR_PATH}/$db.sarif ,"
echo ""
done

echo $FINAL_MSG
```
{% endcode %}

Sie können die Ergebnisse unter [**https://microsoft.github.io/sarif-web-component/**](https://microsoft.github.io/sarif-web-component/) visualisieren oder die VSCode-Erweiterung [**SARIF viewer**](https://marketplace.visualstudio.com/items?itemName=MS-SarifVSCode.sarif-viewer) verwenden.

Sie können auch die [**VSCode-Erweiterung**](https://marketplace.visualstudio.com/items?itemName=GitHub.vscode-codeql) verwenden, um die Ergebnisse in VSCode zu erhalten. Sie müssen immer noch manuell eine Datenbank erstellen, können dann jedoch beliebige Dateien auswählen und auf `Rechtsklick` -> `CodeQL: Run Queries in Selected Files` klicken.

### [**Snyk**](https://snyk.io/product/snyk-code/)

Es gibt eine **kostenlose installierbare Version**.

#### Schnellstart
```bash
# Install
sudo npm install -g snyk

# Authenticate (you can use a free account)
snyk auth

# Test for open source vulns & license issues
snyk test [--all-projects]

# Test for code vulnerabilities
## This will upload your code and you need to enable this option in: Settings > Snyk Code
snyk test code

# Test for vulns in images
snyk container test [image]

# Test for IaC vulns
snyk iac test
```
Sie können auch die [**snyk VSCode-Erweiterung**](https://marketplace.visualstudio.com/items?itemName=snyk-security.snyk-vulnerability-scanner) verwenden, um Ergebnisse in VSCode zu erhalten.

### [Insider](https://github.com/insidersec/insider)

Es ist **Open Source**, sieht aber **nicht gewartet** aus.

#### Unterstützte Sprachen

Java (Maven und Android), Kotlin (Android), Swift (iOS), .NET Full Framework, C# und Javascript (Node.js).

#### Schnellstart
```bash
# Check the correct release for your environment
$ wget https://github.com/insidersec/insider/releases/download/2.1.0/insider_2.1.0_linux_x86_64.tar.gz
$ tar -xf insider_2.1.0_linux_x86_64.tar.gz
$ chmod +x insider
$ ./insider --tech javascript  --target <projectfolder>
```
### [**DeepSource**](https://deepsource.com/pricing)&#x20;

Kostenlos für **öffentliche Repositories**.

## NodeJS

* **`yarn`**
```bash
# Install
brew install yarn
# Run
cd /path/to/repo
yarn audit
npm audit
```
* **`pnpm`**
```bash
# Install
npm install -g pnpm
# Run
cd /path/to/repo
pnpm audit
```
* [**nodejsscan**](https://github.com/ajinabraham/nodejsscan)**:** Statischer Sicherheitscode-Scanner (SAST) für Node.js-Anwendungen, unterstützt durch [libsast](https://github.com/ajinabraham/libsast) und [semgrep](https://github.com/returntocorp/semgrep).
```bash
# Install & run
docker run -it -p 9090:9090 opensecurity/nodejsscan:latest
# Got to localhost:9090
# Upload a zip file with the code
```
* [**RetireJS**](https://github.com/RetireJS/retire.js)**:** Das Ziel von Retire.js ist es, Ihnen dabei zu helfen, den Einsatz von JS-Bibliotheksversionen mit bekannten Sicherheitslücken zu erkennen.
```bash
# Install
npm install -g retire
# Run
cd /path/to/repo
retire --colors
```
## Electron

* [**electronegativity**](https://github.com/doyensec/electronegativity)**:** Es ist ein Tool zur Identifizierung von Fehlkonfigurationen und Sicherheits-Anti-Patterns in Electron-basierten Anwendungen.

## Python

* [**Bandit**](https://github.com/PyCQA/bandit)**:** Bandit ist ein Tool, das entwickelt wurde, um häufige Sicherheitsprobleme in Python-Code zu finden. Dazu verarbeitet Bandit jede Datei, erstellt einen AST daraus und führt entsprechende Plugins gegen die AST-Knoten aus. Sobald Bandit alle Dateien gescannt hat, generiert es einen Bericht.
```bash
# Install
pip3 install bandit

# Run
bandit -r <path to folder>
```
* [**safety**](https://github.com/pyupio/safety): Safety überprüft Python-Abhängigkeiten auf bekannte Sicherheitslücken und schlägt geeignete Maßnahmen zur Behebung der erkannten Schwachstellen vor. Safety kann auf Entwicklermaschinen, in CI/CD-Pipelines und auf Produktionssystemen ausgeführt werden.
```bash
# Install
pip install safety
# Run
safety check
```
* [~~**Pyt**~~](https://github.com/python-security/pyt): Nicht gewartet.

## .NET
```bash
# dnSpy
https://github.com/0xd4d/dnSpy

# .NET compilation
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe test.cs
```
## RUST

Rust is a systems programming language that focuses on safety, speed, and concurrency. It is designed to be memory safe and thread safe, making it a good choice for building reliable and efficient software. Rust's syntax is similar to C++, but it includes modern features such as pattern matching, type inference, and ownership semantics.

### Code Review Tools

When performing a code review in Rust, there are several tools that can help identify potential vulnerabilities and improve code quality. Here are some commonly used code review tools for Rust:

- **Clippy**: Clippy is a linter for Rust that provides helpful suggestions and warnings to improve code quality. It can catch common mistakes, enforce best practices, and identify potential bugs.

- **Rustfmt**: Rustfmt is a tool for formatting Rust code according to the official Rust style guidelines. It automatically formats code to ensure consistency and readability.

- **Cargo-audit**: Cargo-audit is a tool that checks Rust dependencies for known vulnerabilities. It scans the Cargo.lock file and compares it against a database of known vulnerabilities to identify any potential security issues.

- **Rust-analyzer**: Rust-analyzer is an integrated development environment (IDE) extension that provides code analysis and navigation features for Rust. It offers features such as code completion, documentation lookup, and refactoring support.

- **Rustdoc**: Rustdoc is a tool for generating documentation from Rust source code. It can be used to automatically generate API documentation for libraries and projects.

These tools can be used during the code review process to identify and fix potential vulnerabilities, enforce coding standards, and improve the overall quality of Rust code. By using these tools, developers can ensure that their code is secure, reliable, and maintainable.
```bash
# Install
cargo install cargo-audit

# Run
cargo audit

#Update the Advisory Database
cargo audit fetch
```
## Java

Java ist eine objektorientierte Programmiersprache, die häufig für die Entwicklung von plattformunabhängigen Anwendungen verwendet wird. Sie wurde von Sun Microsystems entwickelt und ist bekannt für ihre Robustheit, Sicherheit und Portabilität.

### Code-Überprüfungstools

Bei der Überprüfung des Codes in Java-Anwendungen können verschiedene Tools verwendet werden, um potenzielle Schwachstellen und Sicherheitslücken zu identifizieren. Hier sind einige beliebte Code-Überprüfungstools für Java:

- **FindBugs**: Ein statisches Analysetool, das potenzielle Fehler und Schwachstellen im Java-Code erkennt. Es kann verwendet werden, um Probleme wie Nullzeigerdereferenzierung, unsichere Datenkonvertierung und unsichere Verwendung von Kryptographie zu identifizieren.

- **PMD**: Ein weiteres statisches Analysetool, das den Java-Code auf potenzielle Probleme überprüft. Es kann verwendet werden, um Code-Stilprobleme, nicht verwendete Variablen und Methoden, unsichere Code-Konstrukte und andere potenzielle Schwachstellen zu identifizieren.

- **Checkstyle**: Ein Tool, das den Java-Code auf Einhaltung bestimmter Codierungsstandards überprüft. Es kann verwendet werden, um sicherzustellen, dass der Code konsistent formatiert ist und bestimmte Codierungsrichtlinien eingehalten werden.

- **SonarQube**: Eine umfassende Plattform für die statische Code-Analyse, die in der Lage ist, verschiedene Arten von Schwachstellen und Problemen im Java-Code zu identifizieren. Es bietet auch Funktionen zur Messung der Code-Qualität und zur Verfolgung von Code-Änderungen im Laufe der Zeit.

Diese Tools können während des Entwicklungsprozesses eingesetzt werden, um sicherzustellen, dass der Java-Code sicher und fehlerfrei ist. Es ist wichtig, regelmäßig Code-Überprüfungen durchzuführen, um potenzielle Schwachstellen zu identifizieren und zu beheben, bevor sie zu Sicherheitsproblemen führen.
```bash
# JD-Gui
https://github.com/java-decompiler/jd-gui

# Java compilation step-by-step
javac -source 1.8 -target 1.8 test.java
mkdir META-INF
echo "Main-Class: test" > META-INF/MANIFEST.MF
jar cmvf META-INF/MANIFEST.MF test.jar test.class
```
| Aufgabe           | Befehl                                                    |
| ----------------- | --------------------------------------------------------- |
| Jar ausführen     | java -jar \[jar]                                          |
| Jar entpacken     | unzip -d \[Ausgabeverzeichnis] \[jar]                      |
| Jar erstellen     | jar -cmf META-INF/MANIFEST.MF \[Ausgabe jar] \*            |
| Base64 SHA256     | sha256sum \[Datei] \| cut -d' ' -f1 \| xxd -r -p \| base64 |
| Signatur entfernen| rm META-INF/_.SF META-INF/_.RSA META-INF/\*.DSA           |
| Aus Jar löschen   | zip -d \[jar] \[zu entfernende Datei]                      |
| Klasse dekompilieren | procyon -o . \[Pfad zur Klasse]                          |
| Jar dekompilieren | procyon -jar \[jar] -o \[Ausgabeverzeichnis]               |
| Klasse kompilieren | javac \[Pfad zur .java Datei]                              |

## Los geht's
```bash
https://github.com/securego/gosec
```
## PHP

[Psalm](https://phpmagazine.net/2018/12/find-errors-in-your-php-applications-with-psalm.html) und [PHPStan](https://phpmagazine.net/2020/09/phpstan-pro-edition-launched.html).

### Wordpress Plugins

[https://www.pluginvulnerabilities.com/plugin-security-checker/](https://www.pluginvulnerabilities.com/plugin-security-checker/)

## Solidity

* [https://www.npmjs.com/package/solium](https://www.npmjs.com/package/solium)

## JavaScript

### Entdeckung

1. Burp:
* Spider und entdecke Inhalte
* Sitemap > filtern
* Sitemap > Rechtsklick auf Domain > Engagement-Tools > Skripte finden
2. [WaybackURLs](https://github.com/tomnomnom/waybackurls):
* `waybackurls <domain> |grep -i "\.js" |sort -u`

### Statische Analyse

#### Unminimieren/Verschönern

* [https://prettier.io/playground/](https://prettier.io/playground/)
* [https://beautifier.io/](https://beautifier.io/)

#### Deobfuskieren/Entpacken

**Hinweis**: Es ist möglicherweise nicht möglich, vollständig zu deobfuskieren.

1. Finde und verwende .map-Dateien:
* Wenn die .map-Dateien öffentlich zugänglich sind, können sie leicht deobfuskiert werden.
* Üblicherweise entspricht foo.js.map foo.js. Suche manuell danach.
* Verwende [JS Miner](https://github.com/PortSwigger/js-miner), um danach zu suchen.
* Stelle sicher, dass ein aktiver Scan durchgeführt wird.
* Lies '[Tipps/Notizen](https://github.com/minamo7sen/burp-JS-Miner/wiki#tips--notes)'
* Wenn gefunden, verwende [Maximize](https://www.npmjs.com/package/maximize), um zu deobfuskieren.
2. Ohne .map-Dateien, versuche JSnice:
* Referenzen: http://jsnice.org/ & https://www.npmjs.com/package/jsnice
* Tipps:
* Wenn du jsnice.org verwendest, klicke auf die Optionen-Schaltfläche neben der Schaltfläche "Nicify JavaScript" und deaktiviere "Infer types", um den Code nicht mit Kommentaren zu überladen.
* Stelle sicher, dass du keine leeren Zeilen vor dem Skript lässt, da dies den Deobfuskierungsprozess beeinflussen und zu ungenauen Ergebnissen führen kann.
3. Verwende console.log();
* Finde den Rückgabewert am Ende und ändere ihn in `console.log(<packerReturnVariable>);`, damit das deobfuskierte js anstelle der Ausführung gedruckt wird.
* Dann füge das modifizierte (und immer noch obfuskierte) js in https://jsconsole.com/ ein, um das deobfuskierte js in der Konsole protokolliert zu sehen.
* Gib schließlich die deobfuskierte Ausgabe in https://prettier.io/playground/ ein, um sie für die Analyse zu verschönern.
* **Hinweis**: Wenn du immer noch gepacktes (aber unterschiedliches) js siehst, könnte es rekursiv gepackt sein. Wiederhole den Vorgang.

Referenzen

* https://www.youtube.com/watch?v=\_v8r\_t4v6hQ
* https://blog.nvisium.com/angular-for-pentesters-part-1
* https://blog.nvisium.com/angular-for-pentesters-part-2

Tools

* https://portswigger.net/burp/documentation/desktop/tools/dom-invader

#### Weniger verwendete Referenzen

* https://cyberchef.org/
* https://olajs.com/javascript-prettifier
* https://jshint.com/
* https://github.com/jshint/jshint/

<details>

<summary><strong>Lerne AWS-Hacking von Null auf Held mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Andere Möglichkeiten, HackTricks zu unterstützen:

* Wenn du dein **Unternehmen in HackTricks bewerben möchtest** oder **HackTricks als PDF herunterladen möchtest**, schau dir die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop) an!
* Hol dir das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
* Entdecke [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Trete der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folge** uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Teile deine Hacking-Tricks, indem du PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repositories sendest.

</details>