---
title: "Trojan"
description: "Die von Potatso unterstützten Trojan-Transporte, TLS-Optionen, Links und Funktionen."
---

> Documentation Index
> Fetch the complete documentation index at: https://potatso.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Trojan

Ein Trojan-Server wird durch ein **Passwort** und seine **TLS-Einstellungen** beschrieben, optional ergänzt um einen **Transport**, der die Verbindung trägt, etwa WebSocket oder gRPC. Trojan läuft immer innerhalb von TLS (oder REALITY), sodass die Verbindung für Beobachter wie ein gewöhnlicher HTTPS-Besuch aussieht. Potatso verbindet sich mit einem Server, wenn es dessen Transport und TLS-Einstellungen unterstützt. Prüfe anhand der Tabellen unten die Einstellungen deines Servers, wie dein Anbieter sie angibt oder wie sie in seinem `trojan://`-Link stehen.

Einen Trojan-Server kannst du von Hand, mit einem [`trojan://`-Link](#links) oder per Import hinzufügen:

- eines Clash- oder Mihomo-Abonnements,
- einer Xray- oder V2Ray-Konfiguration,
- einer Surge-Konfiguration.

Potatso importiert Trojan-Server noch nicht aus einer sing-box-Konfiguration. Nutze stattdessen den `trojan://`-Link des Servers.

## Transporte {#transports}

| Transport | Link-`type` | Unterstützt | Getestet mit |
| --- | --- | --- | --- |
| Nur TLS (kein Transport) | `tcp` oder keiner | ✅ | Xray, sing-box, trojan-go |
| WebSocket | `ws` | ✅ Mit oder ohne Early Data | Xray, sing-box, trojan-go |
| gRPC | `grpc` | ✅ | Xray, sing-box |
| HTTP/2 | `http` oder `h2` | ✅ | sing-box |
| HTTP Upgrade | `httpupgrade` | ✅ | Xray, sing-box |
| XHTTP | `xhttp` | ❌ | |
| mKCP, QUIC | `kcp`, `quic` | ❌ | |

Jeder Transport funktioniert mit UDP. Potatso importiert keinen Server, dessen Transport es nicht unterstützt.

Xray bietet HTTP/2 nicht mehr an: Xray-Server, die es nutzten, verwenden jetzt XHTTP, das Potatso noch nicht unterstützt.

## TLS {#tls}

| Einstellung | Clash-Schlüssel | Link-Parameter | Unterstützt |
| --- | --- | --- | --- |
| Servername (SNI) | `sni` | `sni`, `peer` | ✅ Ohne Angabe verwendet Potatso die Adresse des Servers. |
| ALPN | `alpn` | `alpn` | ✅ Ohne Angabe sendet Potatso `h2, http/1.1`, bei WebSocket und HTTP Upgrade `http/1.1` und bei gRPC und HTTP/2 `h2`. |
| Zertifikatsprüfung überspringen | `skip-cert-verify` | `allowInsecure`, `insecure` | ✅ |
| Zertifikat-Pinning (SHA-256) | `fingerprint` | | ✅ |
| Browser-Fingerabdruck | `client-fingerprint` | `fp` | ✅ `chrome`, `firefox`, `safari`, `ios`, `android`, `edge` und `random`. Andere Namen verbinden mit einem Standard-Handshake. |
| [REALITY](#reality) | `reality-opts` | `security=reality`, `pbk`, `sid` | ✅ Ohne Transport oder mit gRPC |
| Encrypted Client Hello (ECH) | `ech-opts` | `ech` | ✅ Mit der ECH-Konfiguration im Link oder Abonnement |
| Eigenes CA-Zertifikat | | | ❌ |
| TLS-Clientzertifikat | `certificate`, `private-key` | | ❌ |

Schaltest du die Zertifikatsprüfung aus, kann jeder zwischen dir und dem Server deinen Datenverkehr mitlesen. Pinne stattdessen das Zertifikat des Servers, wenn er ein selbstsigniertes nutzt: Setze den SHA-256 seines Zertifikats als Zertifikat-Pin.

Ein Browser-Fingerabdruck lässt den TLS-Handshake der Verbindung wie den dieses Browsers aussehen. Er ändert nicht, was der Server unterstützen muss.

### REALITY {#reality}

Ein REALITY-Server leiht sich das TLS-Zertifikat einer anderen Website und braucht daher kein eigenes. Setze den **Reality-Public-Key** und die **Reality-Short-ID** des Servers so, wie dein Anbieter sie angibt, und den Servernamen auf die Website, bei der sich der Server bedient. REALITY braucht einen Browser-Fingerabdruck: Haben dein Link oder deine Einstellungen keinen, verwendet Potatso `chrome`.

REALITY funktioniert ohne Transport und mit gRPC. Potatso importiert keinen REALITY-Server, der einen anderen Transport nutzt.

## Multiplexing {#mux}

Potatso kann mehrere Verbindungen über eine Trojan-Verbindung führen, mit dem Multiplexing von sing-box (`smux`, `yamux` oder `h2mux`), in einem Clash-Abonnement über `smux` festgelegt. Auf dem Server muss Multiplexing eingeschaltet sein. TCP und UDP funktionieren beide.

Das eigene Multiplexing von trojan-go (`mux` in einem trojan-go-Server) ist ein anderes Protokoll, das Potatso nicht unterstützt. Ein trojan-go-Server akzeptiert die Verbindungen von Potatso trotzdem auch ohne es.

## UDP {#udp}

Trojan trägt UDP über dieselbe TLS-Verbindung wie TCP. UDP ist wie in Clash standardmäßig aus. Schalte UDP-Relay in den Servereinstellungen ein, wenn dein Server UDP weiterleitet: Xray, sing-box und trojan-go tun das alle. Ein Clash-Abonnement schaltet es mit `udp: true` ein.

## Funktionsunterstützung {#features}

| Funktion | Unterstützt |
| --- | --- |
| [Trojan-Protokoll](https://trojan-gfw.github.io/trojan/protocol): Passwort-Hash, `CONNECT` | ✅ |
| Trojan `UDP ASSOCIATE` | ✅ |
| Trojan ohne TLS (`security=none`) | ❌ |
| Mehrere Benutzer auf einem Server | ✅ Jeder mit eigenem Passwort |
| Transporte WebSocket, gRPC, HTTP/2 und HTTP Upgrade | ✅ Siehe [Transporte](#transports) |
| Transporte XHTTP, mKCP und QUIC | ❌ |
| [REALITY](#reality) | ✅ Ohne Transport oder mit gRPC |
| ECH | ✅ |
| Multiplexing von sing-box (smux, yamux, h2mux) | ✅ |
| Multiplexing von trojan-go | ❌ |
| Shadowsocks-Verschlüsselung von trojan-go (`ss-opts`, `encryption=ss;…`) | ❌ |
| ShadowTLS, Restls oder JLS um Trojan | ❌ |
| `trojan://`- und `trojan-go://`-Links | ✅ |

Jede unterstützte Funktion ist gegen mindestens einen echten Trojan-Server getestet: [Xray](https://xtls.github.io/), [sing-box](https://sing-box.sagernet.org/) oder [trojan-go](https://p4gefau1t.github.io/trojan-go/).

Bei einem falschen Passwort antwortet ein Trojan-Server wie eine gewöhnliche Website (sein Fallback). Potatso kann dann nicht verbinden und zeigt keinen Passwortfehler an: Prüfe zuerst das Passwort, wenn ein Trojan-Server nie verbindet.

Potatso importiert keinen Server, der die Shadowsocks-Verschlüsselung von trojan-go, ShadowTLS, Restls oder JLS um Trojan nutzt, da es ohne sie verbinden würde und der Server nicht antworten würde.

Einige Funktionen von trojan-go sind Einstellungen seines eigenen Client-Programms, und Potatso erledigt dieselbe Aufgabe auf seine Weise:

- Routing: Nutze Regeln in deinem Profil.
- Lokale SOCKS5- und HTTP-Server sowie Weiterleitung: Potatso erfasst den Datenverkehr deines Geräts selbst.

## `trojan://`-Links {#links}

Ein `trojan://`-Link enthält einen ganzen Server in einer Zeile:

```text
trojan://password@host:port?parameters#name
```

| Teil | Beschreibung |
| --- | --- |
| `password` | Das Passwort, prozentkodiert. Alles vor dem `@` ist das Passwort, einschließlich jedes `:`. |
| `host` | Serveradresse. Setze eine IPv6-Adresse in eckige Klammern, etwa `[2001:db8::1]`. |
| `port` | Serverport. Fehlt er, verwendet Potatso 443. |
| `name` | Optional. Der Name des Servers in Potatso. |

Die Parameter folgen dem Format, das Xray und v2rayN verwenden:

| Parameter | Beschreibung |
| --- | --- |
| `security` | `tls` (der Standard) oder `reality`. |
| `type` | Der [Transport](#transports): `tcp`, `ws`, `grpc`, `http` (HTTP/2) oder `httpupgrade`. |
| `sni`, `peer` | Der TLS-Servername. |
| `alpn` | Die ALPN-Liste, durch Kommas getrennt und prozentkodiert. |
| `fp` | Der Browser-Fingerabdruck. |
| `allowInsecure` | `1` schaltet die Zertifikatsprüfung aus. |
| `host` | Der HTTP-`Host` für WebSocket, HTTP/2 und HTTP Upgrade. |
| `path` | Der Pfad für WebSocket, HTTP/2 und HTTP Upgrade. Ein WebSocket-Pfad wie `/ws?ed=2048` schaltet Early Data ein. |
| `serviceName` | Der gRPC-Dienstname. |
| `pbk`, `sid` | Der REALITY-Public-Key und die Short-ID. |
| `ech` | Die ECH-Konfiguration, Base64-kodiert und prozentkodiert. |

Potatso importiert auch `trojan-go://`-Links mit `type=original` (kein Transport) oder `type=ws`. Einen mit einem `encryption`-Parameter importiert es nicht, da dieser die Shadowsocks-Verschlüsselung von trojan-go braucht.

Wenn Potatso einen Trojan-Server teilt, bietet es einen `trojan://`-Link mit denselben Parametern an.

### Beispiele {#link-examples}

Jedes Beispiel zeigt den Link zum Importieren. Das Passwort ist `secret`.

Ein einfacher Server:

```text
trojan://secret@trojan.example.com:443?sni=trojan.example.com#Basic
```

WebSocket über `cdn.example.com`:

```text
trojan://secret@trojan.example.com:443?security=tls&type=ws&host=cdn.example.com&path=%2Fws#WebSocket
```

gRPC mit dem Dienstnamen `TrojanGun`:

```text
trojan://secret@trojan.example.com:443?security=tls&type=grpc&serviceName=TrojanGun#gRPC
```

HTTP/2:

```text
trojan://secret@trojan.example.com:443?security=tls&type=http&host=cdn.example.com&path=%2Fh2#HTTP2
```

HTTP Upgrade:

```text
trojan://secret@trojan.example.com:443?security=tls&type=httpupgrade&host=cdn.example.com&path=%2Fup#Upgrade
```

REALITY, bei `www.example.com` bedient:

```text
trojan://secret@trojan.example.com:443?security=reality&sni=www.example.com&pbk=Z84J2IelR9ch3k8VtlVhhs5ycBUlXA7wHBWcBrjqnAw&sid=0123abcd&fp=chrome#REALITY
```

Source: https://potatso.com/docs/de/protocols/trojan/index.mdx