Shadowsocks är ett lätt, SOCKS5-baserat krypterat proxyprotokoll som ursprungligen utformades för att kringgå trafikformning och blockering i vanliga nätverk. Till skillnad från ett fullständigt VPN använder det bara proxy för den trafik som en applikation explicit skickar till det, har nästan ingen protokolloverhead och fungerar bra även på begränsade anslutningar. Det försöker inte imitera en riktig TLS-handskakning som VLESS+Reality gör – dess styrka är enkelhet, brett klientstöd (routrar, telefoner, webbläsare) och mycket låg latens, på bekostnad av att vara något enklare att fingeravtrycka efter trafikmönster i ett noggrant inspekterat nätverk.
Det finns två aktivt underhållna serverimplementeringar:
- shadowsocks-rust — den moderna referensimplementeringen från organisationen shadowsocks, skriven i Rust. Den stöder den nyare AEAD-2022-chifferfamiljen, utvecklas aktivt och är den implementation som den här guiden installerar och konfigurerar i detalj.
- shadowsocks-libev — den äldre C-implementationen. Den underhålls fortfarande för buggfixar, levereras som ett färdigt apt-paket med egna systemd-enheter och är ett bra val om du vill ha den absolut enklaste installationen utan manuell binärhantering. Den här guiden behandlar det som en alternativ installationsväg i avsnitt 3.
Den här guiden beskriver hur du manuellt konfigurerar servern via kommandoraden – utan att använda en webbpanel eller Docker. Där fältet "IP-adress" visas, ersätt det med din VPS faktiska IP-adress.
Det här behöver du: en VPS som kör Ubuntu 22.04/24.04 eller Debian 11/12, root-åtkomst, din VPS IP-adress och en ledig UDP/TCP-port (den här guiden använder 8388, Shadowsocks standardport).
Har du ingen server än? Se Hur man beställer en server och betalar för den.
Jämför detta med andra självhostade alternativ först? Se Xray VLESS Reality Guide för ett TLS-kamouflagebaserat alternativ, AmneziaWG Server Deployment Guide för ett WireGuard-baserat alternativ, eller Hysteria2 och TUIC-konfiguration för två andra moderna proxyprotokoll.
Ansluter till servern
Windows (PuTTY)
Öppna PuTTY, ange din VPS IP-adress i fältet Värdnamn, ställ in porten till 22 och logga in som root med lösenordet som din VPS-leverantör skickade till dig via e-post.
Serverns IP-adress: din IP-adress
logga in som: root
Lösenord: ditt lösenord
För en detaljerad genomgång av hur man ansluter via PuTTY/SSH, se Så här ansluter du till en Linux-server via SSH.
Linux / macOS (terminal)
ssh root@your_IP_address
Alla kommandon nedan körs på servern, i samma SSH-session – som täcker avsnitt 2 till 7, plus serversidekontrollerna i avsnitt 13. Avsnitt 8–12 (installation och konfiguration av klientapparna) sker istället på din egen Windows/macOS/Linux/Android/iOS-enhet, eftersom det är den enheten som proxyn behöver köras på; vart och ett av dessa avsnitt anger explicit vilka linjer, om några, som fortfarande berör servern.
Förbereder servern
Uppdatera systemet
Innan du installerar något, uppdatera paketlistan och uppgradera installerade paket:
apt update -y && apt upgrade -y
Om detta uppgraderar kärnan är det en bra idé att starta om programmet innan du fortsätter. (För en uppdatering om apt och hur Linux-pakethanterare fungerar, se Linux-pakethanterare .) Kontrollera med:
cat /var/run/reboot-required
Om filen finns, starta om först med 'reboot', vänta ~30 sekunder och anslut sedan igen.
Installera verktygen som används i den här guiden
apt install -y curl wget tar xz-utils ufw qrencode
curl/wget och tar/xz-utils behövs för att hämta och packa upp utgåvearkivet för shadowsocks-rust; ufw är brandväggen som konfigurerats nedan; qrencode omvandlar den färdiga klientlänken till en skannbar QR-kod i avsnitt 7.
Konfigurera brandväggen (UFW)
För mer information om UFW-regler, se Konfigurera brandvägg i Linux.
Öppna de två portarna du behöver: 22/tcp för SSH (hoppa över den här regeln så riskerar du att förlora åtkomst till servern) och 8388, både tcp och udp — Shadowsocks proxiesar både TCP-anslutningar och UDP-associationer (användbart för DNS och vissa spel/appar), så båda riktningarna för porten måste vara öppna.
ufw allow 22/tcp
ufw allow 8388/tcp
ufw allow 8388/udp
ufw --force enable
ufw status
Alla tre regler ska visas som ALLOW i ufw-statusutdata. Om du senare ändrar porten i config.json, uppdatera dessa regler så att de matchar.
Installera serverprogramvaran
Välj ett av de två alternativen nedan. Alternativ A (shadowsocks-rust) rekommenderas: det är den aktivt utvecklade implementeringen och stöder de moderna AEAD-2022-chiffer som används senare i den här guiden. Alternativ B (shadowsocks-libev) är ett bra val om du hellre vill använda ett vanligt apt-paket med en färdig systemd-enhet och inte behöver AEAD-2022.
Alternativ A — shadowsocks-rost (rekommenderas)
Shadowsocks-rust levererar inte ett apt-paket med aktuella utgåvor, så det installeras genom att ladda ner den förbyggda statiska binärfilen från projektets GitHub-utgåvor. Hämta den senaste utgåvetaggen från GitHub API:et och ladda ner det matchande Linux x86_64-arkivet:
SS_VER=$(curl -s https://api.github.com/repos/shadowsocks/shadowsocks-rust/releases/latest | grep -Po '"tag_name": "\K[^"]*')
echo "Latest version: $SS_VER"
cd /root
wget "https://github.com/shadowsocks/shadowsocks-rust/releases/download/${SS_VER}/shadowsocks-${SS_VER}.x86_64-unknown-linux-gnu.tar.xz"
Om din VPS är arm64 istället för x86_64 (kontrollera med `uname -m`), ersätt x86_64-unknown-linux-gnu med aarch64-unknown-linux-gnu i filnamnet ovan.
Extrahera arkivet och installera binärfilerna i hela systemet:
tar -xf shadowsocks-*.tar.xz
install -m 755 ssserver ssservice ssmanager ssurl /usr/local/bin/
rm -f shadowsocks-*.tar.xz ssserver ssservice ssmanager ssurl sslocal 2>/dev/null
Verifiera att binärfilen är på plats och kontrollera den installerade versionen:
ssserver --version
Skapa katalogen som konfigurationsfilen ska finnas i:
mkdir -p /etc/shadowsocks-rust
Den här guiden installerar en fixad version istället för att skicka ett installationsskript till bash. För att uppgradera senare, kör de två kommandona ovan igen med en ny SS_VER-sökning, stoppa tjänsten, ersätt binärfilen och starta om den (avsnitt 6).
Alternativ B — shadowsocks-libev (alternativt, apt-paket)
Shadowsocks-libev ingår i Ubuntus universe-repository (Ubuntu 16.10+) och Debians huvudrepository (Debian 8+), så ingen tredjeparts-PPA behövs på 22.04/24.04 eller Debian 11/12:
apt install -y shadowsocks-libev
Om apt rapporterar att paketet inte hittas är universe-förrådet inaktiverat; aktivera det och försök igen:
add-apt-repository universe && apt update && apt install -y shadowsocks-libev
Paketet installerar sina egna systemd-enheter (shadowsocks-libev.service för standardkonfigurationen, plus [email protected] för namngivna konfigurationer per instans) och skapar /etc/shadowsocks-libev/config.json automatiskt — Avsnitt 4–6 noterar de libev-specifika kommandona och filsökvägarna bredvid de oanvända. Resten av den här guidens klientavsnitt (7–13) gäller identiskt för båda serverimplementeringarna, eftersom båda använder samma Shadowsocks/SIP002-protokoll på kabeln.
Generera lösenordet och välja en chiffer
Shadowsocks-autentisering är ett enda delat lösenord plus en chiffer (krypteringsmetod) som båda sidor måste komma överens om – det finns inget separat UUID, nyckelpar eller certifikat att hantera.
Chifferfamiljer
- AEAD-2022 (rekommenderas, endast shadowsocks-rust): 2022-blake3-aes-128-gcm, 2022-blake3-aes-256-gcm, 2022-blake3-chacha20-poly1305. Nyare design (SIP022) med starkare replay-skydd och stöd för flera användare som delar en port. Lösenordet måste vara en base64-sträng med exakt chifferns nyckellängd (16 byte för 128-bitarsvarianterna, 32 byte för 256-bitarsvarianten).
- Klassisk AEAD (stöds av både rust och libev): aes-256-gcm, aes-128-gcm, chacha20-ietf-poly1305. Brett kompatibel med äldre klienter och med shadowsocks-libev; lösenordet kan vara vilket lösenord som helst, eftersom det matas via en nyckelderiveringsfunktion snarare än att användas direkt som nyckelmaterial.
Den här guiden använder 2022-blake3-aes-256-gcm för servern shadowsocks-rust, eftersom det är det starkaste och mest aktuella alternativet och alla klienter som rekommenderas senare (v2rayN, v2rayNG, Shadowrocket, Streisand, ShadowsocksX-NG) stöder det. Om du installerade shadowsocks-libev i avsnitt 3, använd chacha20-ietf-poly1305 eller aes-256-gcm istället, eftersom libev inte implementerar AEAD-2022.
Generera en nyckel (shadowsocks-rust)
ssservice genkey -m "2022-blake3-aes-256-gcm"
Detta skriver ut en base64-sträng – det är ditt lösenord. Kopiera den till en säker plats; du klistrar in den i både serverkonfigurationen i avsnitt 5 och klientlänken i avsnitt 7.
Välj ett lösenord (shadowsocks-libev)
För de klassiska AEAD-chiffer som används av shadowsocks-libev fungerar vilken tillräckligt lång slumpmässig sträng som helst, eftersom den körs genom PBKDF/HKDF snarare än används som en rå nyckel. Generera en med:
openssl rand -base64 32
Skriva serverkonfigurationen
Shadowsocks-rost
Öppna konfigurationsfilen för redigering:
nano /etc/shadowsocks-rust/config.json
Klistra in mallen nedan och ersätt med ditt eget lösenord från avsnitt 4 (och porten från avsnitt 2, om du ändrade den från 8388):
{
"server": "0.0.0.0",
"server_port": 8388,
"password": "YOUR-GENERATED-KEY-HERE",
"method": "2022-blake3-aes-256-gcm",
"mode": "tcp_and_udp",
"timeout": 300,
"nofile": 51200
}
Tryck Ctrl+O (WriteOut) för att spara filen, Enter för att bekräfta filnamnet och sedan Ctrl+X för att avsluta nano.
De viktiga fälten: server listens on all interfaces (0.0.0.0); server_port är porten som öppnades i avsnitt 2; password/method är autentiseringsuppgifterna och chiffern från avsnitt 4; mode aktiverar både TCP- och UDP-reläering; timeout är timeouten för inaktiv anslutning i sekunder; nofile höjer filbeskrivningsgränsen för upptagna servrar.
Validera JSON:n och att binärfilen accepterar den innan du kopplar in den i systemd:
ssserver -c /etc/shadowsocks-rust/config.json --help >/dev/null && echo "binary OK"
python3 -m json.tool /etc/shadowsocks-rust/config.json >/dev/null && echo "JSON OK"
Skapa systemd-enheten (shadowsocks-rust)
Den binära versionen levererar inte en systemd-enhet, så skapa en:
nano /etc/systemd/system/ssserver.service
[Unit]
Description=Shadowsocks-Rust Server
Documentation=https://github.com/shadowsocks/shadowsocks-rust
After=network.target
[Service]
Type=simple
ExecStart=/usr/local/bin/ssserver -c /etc/shadowsocks-rust/config.json
Restart=on-failure
RestartSec=5s
LimitNOFILE=51200
User=root
[Install]
WantedBy=multi-user.target
Spara och avsluta som ovan, be sedan systemd att hämta den nya enhetsfilen:
systemctl daemon-reload
Shadowsocks-libev
apt-paketet har redan skapat /etc/shadowsocks-libev/config.json med en standardkonfiguration (endast loopback, slumpmässigt lösenord) och en egen systemd-enhet. Öppna den för redigering:
nano /etc/shadowsocks-libev/config.json
Ersätt innehållet med:
{
"server":"0.0.0.0",
"server_port":8388,
"password":"YOUR-PASSPHRASE-HERE",
"method":"chacha20-ietf-poly1305",
"mode":"tcp_and_udp",
"timeout":300
}
Standardkonfigurationen använder server: [":1", "127.0.0.1"] (endast loopback); att ändra den till "0.0.0.0" gör servern nåbar från den publika IP-adressen — hoppa inte över detta om du kopierade stockfilen istället för mallen ovan.
Starta tjänsten och aktivera autostart
Shadowsocks-rost
systemctl enable --now ssserver
systemctl status ssserver --no-pager
Status ska visa aktiv (körs). Bekräfta att något faktiskt lyssnar på porten (båda protokollen):
ss -lntp | grep ':8388'
ss -lunp | grep ':8388'
Om tjänsten inte startar är det snabbaste sättet att se varför genom att använda systemd-journalen (för bakgrundsinformation om att läsa Linux-loggar i allmänhet, se Hur man läser Linux-loggar och var man hittar dem ):
journalctl -u ssserver -n 50 --no-pager
Shadowsocks-libev
systemctl restart shadowsocks-libev
systemctl enable shadowsocks-libev
systemctl status shadowsocks-libev --no-pager
Kontrollera porten och loggarna på samma sätt som för shadowsocks-rust, men ersätt med tjänstnamnet:
ss -lntp | grep ':8388'
ss -lunp | grep ':8388'
journalctl -u shadowsocks-libev -n 50 --no-pager
Bygga klientanslutningslänken
Shadowsocks-klienter importerar en enda ss://-delningslänk (URL-formatet SIP002) istället för en konfigurationsfil. Länken kodar chiffern och lösenordet som base64 i användarinfo-delen av URL:en:
ss://base64(method:password)@your_IP_address:port#label
Bygg base64-delen på servern (detta undviker eventuella stavfel från handkodning):
METHOD="2022-blake3-aes-256-gcm"
PASSWORD="YOUR-GENERATED-KEY-HERE"
USERINFO=$(echo -n "${METHOD}:${PASSWORD}" | base64 -w0)
echo "ss://${USERINFO}@your_IP_address:8388#My-SS-Server"
Exempelutdata (med platshållartangent):
ss://MjAyMi1ibGFrZTMtYWVzLTI1Ni1nY206eHl6X2V4YW1wbGVfa2V5X2hlcmU=@your_IP_address:8388#My-SS-Server
Texten efter # är bara en visningsetikett som du kan byta namn på fritt i vilken klient som helst. För en shadowsocks-libev-server, ersätt METHOD="chacha20-ietf-poly1305" (eller aes-256-gcm) och dess lösenfras från avsnitt 4 istället.
Gör om den till en QR-kod så att mobilanvändare kan skanna den direkt:
qrencode -o ~/ss-client.png "ss://${USERINFO}@your_IP_address:8388#My-SS-Server"
Kopiera PNG-filen till din egen dator med scp, kör den från datorns terminal (eller PowerShell i Windows), inte från servern:
scp root@your_IP_address:~/ss-client.png .
Ansluta från Windows
Allt i det här avsnittet sker på din Windows-dator, inte via SSH – klienten måste köras på den enhet som faktiskt kommer att använda proxyn.
Installera v2rayN
v2rayN är en gratis, aktivt underhållen GUI-klient med inbyggt stöd för Shadowsocks tillsammans med VLESS, VMess, Trojan och andra. Ladda ner den senaste versionen från projektets sida.
Hämta Windows 64-bitars .zip-filen (en fristående version behöver ingen separat .NET-körning som i de senaste v2rayN-versionerna), extrahera den var som helst och kör v2rayN.exe.
Importera servern
Kopiera ss://-länken som byggdes i avsnitt 7 till ditt urklipp (eller kopiera QR-PNG-filen med scp och öppna den), välj sedan Servrar → Importera mass-URL från urklipp i v2rayN (eller skanna QR-koden via den inbyggda skannern). Den nya serverprofilen visas i listan med etiketten du angav efter #.
Högerklicka på profilen och välj den som aktiv, aktivera sedan systemproxyn (eller TUN-läget, för routning av hela maskinen) från huvudfönstrets verktygsfält.
Ansluter från macOS
Allt i det här avsnittet sker på din Mac, inte via SSH.
Installera ShadowsocksX-NG
ShadowsocksX-NG är den långvariga inbyggda macOS GUI-klienten för Shadowsocks; den nuvarande utgåvan levererar en inbyggd Apple Silicon-version tillsammans med Intel. Ladda ner den senaste .dmg-filen från utgivningssidan.
Öppna .dmg-filen och dra ShadowsocksX-NG till Program. Starta den sedan – den visas som en ikon i menyraden.
Importera servern
Kopiera ss://-länken från avsnitt 7 till ditt urklipp, klicka sedan på menyikonen → Servrar → Serverinställningar → +-tecknet längst ner till vänster och välj "Importera från monteringsbord" (eller skanna QR-koden med "Skanna QR-kod från skärmen" efter att du öppnat PNG-filen). Välj den nya profilen från menyradens rullgardinsmeny, aktivera sedan "Shadowsocks: På" och välj routingläget "PAC Auto" eller "Globalt" från samma meny.
Ansluta från ett Linux-skrivbord
Allt i det här avsnittet sker på din egen Linux-maskin, inte på VPS:en.
Installera den lokala klienten
Om du installerade shadowsocks-rust på servern i avsnitt 3, innehåller samma utgåvaarkiv sslocal, en lokal SOCKS5/HTTP-proxyklient. Ladda ner och installera den på samma sätt som serverns binärfil (justera OS/arch-suffixet för din dator om det inte är x86_64-unknown-linux-gnu):
SS_VER=$(curl -s https://api.github.com/repos/shadowsocks/shadowsocks-rust/releases/latest | grep -Po '"tag_name": "\K[^"]*')
wget "https://github.com/shadowsocks/shadowsocks-rust/releases/download/${SS_VER}/shadowsocks-${SS_VER}.x86_64-unknown-linux-gnu.tar.xz"
tar -xf shadowsocks-*.tar.xz
sudo install -m 755 sslocal /usr/local/bin/
Konfigurera och kör
Skapa en liten lokal konfigurationsfil som lyssnar på 127.0.0.1:1080 som en SOCKS5-proxy:
mkdir -p ~/.config/shadowsocks-rust
cat > ~/.config/shadowsocks-rust/local.json << 'EOF'
{
"server": "your_IP_address",
"server_port": 8388,
"password": "YOUR-GENERATED-KEY-HERE",
"method": "2022-blake3-aes-256-gcm",
"local_address": "127.0.0.1",
"local_port": 1080,
"mode": "tcp_and_udp"
}
EOF
sslocal -c ~/.config/shadowsocks-rust/local.json
Rikta din webbläsare eller ditt systemnätverksinställningar mot en SOCKS5-proxy på 127.0.0.1:1080. För ett grafiskt gränssnitt kan Nekoray- eller ShadowsocksX-Qt5-liknande forks importera samma ss://-länk från avsnitt 7 och hantera sslocal åt dig istället för att köra den manuellt.
Ansluter från Android
Allt här sker på din Android-enhet, inte via SSH.
Installera en klient
Två bra alternativ:
- Shadowsocks för Android — den officiella klienten från organisationen shadowsocks. Installera den från Google Play (sök efter "Shadowsocks"), eller ladda ner APK:en direkt från projektets releasesida om Play inte är tillgängligt i din applikation. område.
- v2rayNG — Android-motsvarigheten till v2rayN, som stöder Shadowsocks tillsammans med VLESS/VMess/Trojan; användbart om du vill ha en app för flera protokoll typer.
Importera servern
I endera appen: tryck på +-knappen, välj "Importera från urklipp" efter att du kopierat ss://-länken från avsnitt 7, eller "Skanna QR-kod" och rikta kameran mot PNG-filen. Tryck på den importerade profilen för att välja den och tryck sedan på anslutningsknappen. Android kommer att be om VPN-behörighet första gången – godkänn den för att upprätta tunneln.
Ansluter från iOS
Allt här sker på din iPhone eller iPad, inte via SSH.
Installera en Shadowsocks-kompatibel klient
Shadowrocket är den mest använda iOS-klienten med stöd för Shadowsocks; det är en betald app som finns i de flesta butiker. Sök efter den i App Store eller öppna den.
Streisand är ett gratis alternativ med öppen källkod som också stöder Shadowsocks tillsammans med VLESS, Trojan och andra protokoll.
App Store-kataloger varierar beroende på butik/region och kan ändras över tid. Om ingen av dem syns i din, sök i App Store efter "Shadowsocks" eller "V2Box".
Importera servern
Kopiera länken ss:// till ditt urklipp, öppna klienten och använd alternativet Lägg till/Importera från urklipp, eller skanna QR-koden från avsnitt 7 med klientens inbyggda skanner. Aktivera den nya profilen; iOS kommer att be om VPN-konfigurationsbehörighet första gången, vilket du måste godkänna via Face ID, Touch ID eller ditt lösenord.
Verifierar anslutningen
Med tunneln aktiv från avsnitt 8, 9, 10, 11 eller 12, gå tillbaka till din egen enhet (inte SSH-sessionen) och öppna valfri "vad är min IP"-kontroll i en webbläsare — adressen som visas ska matcha din VPS IP-adress, din_IP-adress.
För att verifiera från serversidan istället, kontrollera systemd-journalen för anslutningsaktivitet och bekräfta etablerade sessioner på porten (använd ssserver för rust-journalen eller shadowsocks-libev för libev-journalen):
journalctl -u ssserver -n 50 --no-pager
ss -tnp | grep ':8388'
Referens:
|
Fält |
Värderar |
|
Adress |
din VPS:s offentliga IP-adress |
|
Port |
8388 (samma hamn som öppnades i sektion 2) |
|
Lösenord |
nyckeln/lösenfrasen som genererades i avsnitt 4 |
|
Metod |
2022-blake3-aes-256-gcm (rost) eller chacha20-ietf-poly1305 (libev) — måste matcha exakt på båda sidor |
|
Mode |
tcp_and_udp — aktiverar både TCP-proxy och UDP-relä (DNS, vissa spel) |
|
Insticksmodulen |
ingen används i den här guiden — Shadowsocks behöver inget SNI, certifikat eller transport-plugin för att fungera |
Slutsats
Genom att följa den här guiden kör din VPS sin egen Shadowsocks-server — antingen shadowsocks-rust med en modern AEAD-2022-chiffer, eller shadowsocks-libev från Ubuntu/Debians eget repository — som en systemd-tjänst som överlever en omstart utan någon åtgärd från din sida.
Lägga till fler användare:
- Enklast: generera ett andra lösenord (avsnitt 4) och kör en andra ssserver/shadowsocks-libev-instans på en annan port med sin egen konfigurationsfil och systemd-enhet, upprepa sedan avsnitt 5–7 för den porten.
- shadowsocks-rust med en AEAD-2022-chiffer stöder även flera användare som delar en port och lösenordshärledningsnyckel via arrayen "users" i config.json (Extensible Identity Headers, SIP022) — se konfigurationsavsnittet i shadowsocks-rust README för den exakta syntaxen om du behöver trafikredovisning per användare på en enda port.
Några vanor som är värda att behålla när servern väl är igång:
- Håll servern uppdaterad. För shadowsocks-rust, kör regelbundet nedladdnings- och installationsstegen från avsnitt 3 med en ny versionssökning, och starta sedan om ssserver med systemctl. För shadowsocks-libev täcker vanlig apt upgrade det.
- Säkerhetskopiera config.json någonstans privat utanför servern. Den lagrar alla klienters lösenord; att förlora den innebär att inloggningsuppgifterna för varje enhet genereras på nytt.
- Rotera lösenordet om en enhet förloras eller en klient komprometteras: generera ett nytt (avsnitt 4), uppdatera config.json, starta om tjänsten och återskapa klientlänken (avsnitt 7) för varje återstående enhet.
Om anslutningen inte uppstår, kontrollera i ordning:
- tjänstens status (systemctl status ssserver --no-pager, eller shadowsocks-libev) och journalen (journalctl -u ssserver -n 50 --no-pager)
- brandväggsreglerna (ufw-status — porten måste vara öppen för både tcp och udp)
- att porten inte redan är bunden av en annan tjänst (ss -lntp | grep ':8388' ska bara visa ssserver/ss-server)
- att lösenordet, metoden och porten i klienten matchar config.json exakt — ett enda felaktigt tecken misslyckas med handskakningen i tysthet, vanligtvis visas det som en anslutningstimeout snarare än ett explicit fel.
- det läget är inställt på tcp_and_udp på servern om klienten behöver UDP (DNS-over-proxy, vissa spel/appar) och inte bara tcp_only
Jämför Shadowsocks med andra alternativ? Se Xray VLESS Reality Guide för ett TLS-kamouflagebaserat protokoll som är svårare att fingeravtrycksläsa på ett hårt filtrerat nätverk, AmneziaWG Server Deployment Guide och How to set up Wireguard VPN on your server för WireGuard-baserade alternativ, eller Hysteria2 och TUIC-konfiguration för två protokoll byggda för förlustbringande eller hårt filtrerade nätverk. Om du bara behöver en enkel proxy snarare än en fullständig tunnelinstallation är 3proxy-konfiguration på CentOS/ArchLinux ett mycket enklare alternativ, och den äldre VPN-serverinstallationen på Linux: PPTP eller OpenVPN? täcker protokoll som är enklare att konfigurera men mycket lättare för DPI att upptäcka och blockera. För generell serverhärdning när proxyn är aktiv, se Linux-användare: Hantering och behörigheter.