Przejdź do treści
Biblioteka skilli
Bezpieczeństwo · Automatyzacja

lowkey

/lowkey

Prowadzi nietechnicznego użytkownika krok po kroku przez budowę własnego szyfrowanego serwera proxy na wynajętym VPS.

Repozytorium
lowkey ↗
Licencja
MIT
Ostatnia zmiana repozytorium
06.11.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
5
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 06.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Prowadzi nietechnicznego użytkownika krok po kroku przez budowę własnego szyfrowanego serwera proxy na wynajętym VPS.

Oryginalny opis (EN)

Walk a non-technical person, one verified step at a time, through building and using their own private encrypted proxy server on a rented VPS. Covers choosing a VPS and checking its route, choosing protocols that leave almost nothing readable on the wire (VLESS+REALITY, Hysteria2, Shadowsocks 2022), installing and hardening sing-box, generating matching client profiles and share links, picking the right app per device (Clash Verge Rev or another mihomo app for rule-based split routing; v2rayN, v2rayNG, Shadowrocket or Hiddify for a simple tap-to-connect setup), testing, and maintenance. Use it

Jak działa

  1. How to work with the person
  2. Ground rules: explain these early
  3. The path
  4. Step 0: intake
  5. Step 3: protocol choice (summary)
  6. Step 4: configs come from the script, not by hand
  7. Step 5: app choice (summary)
  8. Step 6: definition of done
  9. Lessons that cost us the most
  10. Glossary for the person
Sekcje z nagłówków SKILL.md, w oryginale · 134 linii, 2 013 słów
Podgląd SKILL.md
---
name: lowkey
description: Walk a non-technical person, one verified step at a time, through building and using their own private encrypted proxy server on a rented VPS. Covers choosing a VPS and checking its route, choosing protocols that leave almost nothing readable on the wire (VLESS+REALITY, Hysteria2, Shadowsocks 2022), installing and hardening sing-box, generating matching client profiles and share links, picking the right app per device (Clash Verge Rev or another mihomo app for rule-based split routing; v2rayN, v2rayNG, Shadowrocket or Hiddify for a simple tap-to-connect setup), testing, and maintenance. Use it whenever someone wants their own proxy, VPN-like server or "node", asks which proxy protocol or client app to use, needs help importing a profile or link into Clash Verge, v2rayN, v2rayNG, Stash or Shadowrocket, or says their self-hosted proxy is slow, blocked or not connecting. This includes requests phrased as "a fast private connection of my own" or in informal terms for proxy nodes.
---

# lowkey: your own encrypted proxy server, set up step by step

You are guiding someone who may never have used a terminal. They should end up with a private, encrypted proxy server, working apps on each of their devices, and enough understanding to keep it running. The guide is opinionated: it encodes what held up over months of running such servers for a small group of people, including the mistakes. Those are recorded in `references/` so you do not have to repeat them.

## How to work with the person

- **One step at a time.** For each step, say what it does and why in one plain sentence, then give the exact command or click path. Ask for the result (pasted output, or what they see on screen) and check it before moving on. Never hand over ten steps and hope.
- **Two working modes.** Pick whichever fits.
  - **Hands-on:** you can run commands, for example as a coding agent on their computer. Do the work, narrate briefly, and stop for their approval before anything that touches their accounts or money.
  - **Coach:** chat only. Give one command block at a time and read their pasted output carefully.
- **Plain words.** Define a term the first time you use it ("a *VPS* is a small computer you rent in a data centre"). See the glossary at the end. Avoid acronyms they did not use first.
- **Every step ends with a check that can fail.** That is how both of you know it worked, and it is what `scripts/node_test.py` exists for.

## Ground rules: explain these early

1. **Secrets never travel through chat.**
   - Do not ask for, or accept, passwords, SSH private keys, payment details or full client profiles in the conversation.
   - SSH access uses a key pair generated on their own computer; only the *public* key is given to the VPS provider.
   - If they paste a secret anyway, tell them to change it.
2. **They buy, pay and accept terms themselves.** You compare options and read the provider's acceptable-use policy with them, because some providers forbid proxies.
3. **Profiles travel as files or QR codes, never as text pasted into messaging apps.** Chat apps and input methods silently change characters: a `+` became a look-alike full-width plus and broke a key for five days before anyone noticed.
4. **Their server, their responsibility.**
   - Check that running a private proxy is lawful for them and allowed by the provider.
   - Keep the user list to people they know.
   - No torrents, scanning or mining through the server: abuse complaints get the IP blacklisted or the plan cancelled. The generated config already rejects BitTorrent.

## The path

| Step | Goal | Details |
|---|---|---|
| 0 | Understand their devices, uses and network | below |
| 1 | Choose and buy a VPS; confirm it is reachable and the route is decent | `references/vps-and-routes.md` |
| 2 | First login with an SSH key; updates, firewall, safe SSH settings | `references/server-setup.md` |
| 3 | Choose protocols | below, and `references/protocols.md` |
| 4 | Install sing-box, generate configs, start the service | `references/server-setup.md`, `scripts/make_configs.py` |
| 5 | Pick and set up an app on each device | below, and `references/clients.md` |
| 6 | Verify end to end from their own network | `references/testing.md`, `scripts/node_test.py` |
| 7 | Hand over and maintain | `references/maintenance.md` |
| — | Something is wrong | `references/troubleshooting.md` |
| — | Relays, several people, self-updating profiles, residential exits | `references/advanced.md` |

## Step 0: intake

Ask these in one short message, then summarise the answers back:

1. Which devices: Windows, Mac, Linux, Android, iPhone or iPad?
2. What for: browsing, video, work or AI tools, gaming and calls (these need UDP), big downloads?
3. Roughly where they are, and which home internet provider they use. Route quality depends on both.
4. Should websites in their own country skip the proxy (*split routing*), or should everything go through it?
5. Budget per month, and who else will use it.
6. Have they used a terminal before? Do they have a computer, or only a phone? Without a computer, the server setup has to happen in the VPS provider's browser console.

## Step 3: protocol choice (summary)

| Protocol | Runs over | What an on-path observer can read | Forward secrecy | Use it as |
|---|---|---|---|---|
| **VLESS + REALITY + Vision** | TCP 443 | Only a TLS 1.3 handshake that names a borrowed real website. Unauthenticated visitors are passed through to that website. | Yes (TLS 1.3) | The default. Robust, and needs no domain or certificate |
| **Hysteria2 + salamander obfuscation** | UDP 443 (QUIC) | Nothing recognisable: even the QUIC headers are scrambled | Yes (TLS 1.3 inside) | The fast lane on long or lossy routes, whenever UDP gets through |
| **Shadowsocks 2022** | TCP and UDP | Nothing, only random-looking bytes | **No**: whoever later obtains the key can decrypt recorded traffic | Only behind a relay or private line, or as a spare |
| *Avoid* | | Plain HTTP or SOCKS (readable), legacy Shadowsocks ciphers, VMess, and any TLS setup with certificate checks off **and** no pinning | | |

**Default build:** REALITY on TCP 443 plus Hysteria2 on UDP 443, on the same server. Client profiles put both in a fallback group that tries Hysteria2 first and switches to REALITY automatically when UDP is blocked. It does **not** switch when Hysteria2 is merely slow, because the health check fetches a tiny page that still succeeds; at bad hours, pick REALITY by hand. The Hysteria2 certificate is self-signed and *pinned* by its SHA-256 fingerprint in every client that supports pinning. Reasoning and caveats are in `references/protocols.md`.

## Step 4: configs come from the script, not by hand

`scripts/make_configs.py` (Python 3, standard library only) generates everything from one set of secrets:

- the server config;
- the Hysteria2 certificate;
- per-person profiles for mihomo apps and Stash;
- share links for link-based apps.

Re-running it with the same `--out` keeps existing credentials, so adding a person never breaks anyone else.

```bash
python3 make_configs.py --out ~/proxy --server <server IPv4> [--server <server IPv6>] \
    --reality-target <TLS 1.3 site, see vps-and-routes.md> \
    [--user alice --user bob] [--home-region <2-letter country>] [--home-geosite <list name>] \
    [--hy2-up <Mbps> --hy2-down <Mbps>]    # desktop profiles of the users in this run; phones get none
```

Different home lines need one run per person with the same `--out`; credentials never change between runs (`references/server-setup.md`, step 7).

Run it on the server: Debian ships Python 3 and OpenSSL. Then follow `references/server-setup.md` to install sing-box from its official package, install the files, check them and start the service.

**Do not start the service before installing the generated config.** The package ships an example config that runs a Shadowsocks server whose password is public. Don't hand-write configs. A one-character mismatch between the server and a client (a public key, a short ID, a certificate pin) fails silently, which is exactly what generation from shared secrets prevents.

## Step 5: app choice (summary)

| Device | Wants split routing (home-country sites direct, the rest proxied) | Wants the simplest thing |
|---|---|---|
| Windows, macOS, Linux | **Clash Verge Rev**: import `mihomo.yaml` | **v2rayN**: import `share-links.txt` |
| Android | **Clash Meta for Android** or **FlClash**: import `mihomo-mobile.yaml` (or `mihomo.yaml` when no fixed rate was set) | **v2rayNG**: scan the QR code of each link |
| iPhone, iPad | **Stash** (paid): import `stash.yaml` | **Shadowrocket** (paid) or **Hiddify** (free): scan the QR codes |

Profile apps (mihomo family) run the generated rule-based profile with automatic fallback and show a connection list. Link apps are quicker to set up, but each node is selected by hand and routing comes from the app's own presets.

We verified the server against two client cores: mihomo (inside Clash Verge Rev and the other profile apps) and Xray (inside v2rayN and v2rayNG). Stash's REALITY entry and the iOS link apps follow their documentation but are untested on a device; say so to the person. Install sources, import steps and Stash's different field names are in `references/clients.md`.

## Step 6: definition of done

- [ ] `sing-box check` passes on the server, and a deliberately broken copy fails it.
- [ ] From the person's own network, `scripts/node_test.py` reports PASS for **every** node, with the expected exit IP. Run it against both the profile and the share links, and with `--expect-blocked` pointing at a loopback service on the server.
- [ ] In each app, a home-country site shows `DIRECT` and a foreign site shows the proxy in the connection list. An IP-check page shows the server's address.
- [ ] One evening-peak speed test per protocol, with the result written down so later problems have a baseline.
- [ ] Hand-over checklist done (`references/maintenance.md`).

## Lessons that cost us the most

1. **Measure from the right place.** With a TUN-mode proxy app running, every local ping, traceroute and speed test goes through it. Test with the app off, or bind to the physical adapter.
2. **The return route decides speed.** It is assigned per IP and changes without notice. Test both directions and both IPv4 and IPv6, and keep both entries in the client.
3. **Long UDP flows get throttled or dropped on some paths,** and a path can pass small requests while killing every download over about 1 MB. Test sustained transfers, and keep REALITY as the fallback.
4. **Hysteria2 bandwidth semantics.** The server's `up_mbps` caps each user's *download*. A client's `down` should be close to the real line speed, its `up` about 80% of the real upload, and phones should set neither (BBR). `mihomo -t` does not validate these values.
5. **Rule data downloads can stall a client at start-up** on networks where GitHub's raw file host is slow. The generated profiles fetch rule data from jsDelivr.
6. **Keep the client DNS simple.** Use fake-IP mode, one plain resolver, and no clever per-domain resolver policies; ours added half-minute stalls. Proxied names are resolved on the server.
7. **Chrome treats the default IPv6 fake-IP range as a local network** and asks for permission on every site. Use `2001:2::/48`, then clear the fake-IP cache.
8. **When a site misbehaves, look at the app's connection list before changing anything.**
9. **Firewalls and SSH lock you out more than anything else.** Arm an automatic undo first. Remember that a `Port` line in sshd replaces port 22, and that the provider's cloud firewall is a second layer.
10. **Proxy users can reach the server's own loopback services** (dashboards, databases) unless the server rejects private destinations. The generated config does, and `--expect-blocked` proves it: with the rules removed, our test reached a monitoring dashboard on the server.
11. **UDP that no node can carry leaks out directly** in mihomo unless a final `AND,((NETWORK,UDP)),REJECT` rule catches it. The generated profiles end with that rule; keep it when editing.
12. **Pin the Hysteria2 certificate instead of switching checks off.** mihomo and Xray both refused a wrong pin in our tests, while an unpinned "skip verification" setup lets anyone in the path impersonate the server.

## Glossary for the person

- **VPS:** a rented virtual computer in a data centre.
- **SSH:** the encrypted remote terminal used to manage it.
- **Key pair:** a private key that stays on the person's computer, and a public key that may be shared.
- **Proxy node:** one way to connect to the server; each protocol and address is one node.
- **TUN mode:** the app captures all of the device's traffic, like a VPN. **System-proxy mode** covers only apps that honour the system proxy setting.
- **Split routing:** home-country sites go direct, everything else through the server.
- **Fake-IP:** the app answers name lookups with placeholder addresses, so real lookups happen at the server.
- **Fallback group:** a list of nodes used in order; the app moves to the next one when the current one fails.
Pliki w paczce (5)
  • .gitattributes 1 KB
  • .gitignore 1 KB
  • LICENSE 1 KB
  • README.md 4 KB
  • SKILL.md 13 KB

Wersje

W bazie nie ma innych skilli o nazwie lowkey.

Migawka bazy z 13.11.2026 · wersja paczki 333f0a64b7c6 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100claude-proxy-guard
    Instaluje i konfiguruje Claude Proxy Guard z Clash Verge lub Mihomo na macOS i sprawdza diagnostyką, czy działa.
  • 100clash-proxy-switch
    Wykrywa zainstalowane klienty Clash, przełącza je na tryb globalny i sprawdza, czy wyjście do sieci działa.
  • 90clash-doctor
    Diagnozuje Clash Verge i mihomo: błędy proxy, routing dla narzędzi AI, tryb TUN i przełączanie subskrypcji.
  • 100privacy-fortress
    Audytuje i wzmacnia prywatność sieciową na Windows, macOS, Linuksie, Androidzie i iOS: DNS, wycieki, reguły proxy i VPN oraz kontrolę ekspozycji.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.