xinyin025/3x-ui
1
0
Fork 0
mirror of https://github.com/MHSanaei/3x-ui.git synced 2026-08-24 11:57:15 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
940842495968fc52a38fd0a8f6f8498dd6e70de5
3x-ui/internal/web/translation/vi-VN.json
T
Kuzz007 effcccceac feat(amneziawg): add native AmneziaWG protocol support (#6105) 
* feat(amneziawg): add native AmneziaWG protocol backend

AmneziaWG (WireGuard plus DPI-resistant obfuscation) needs no Docker
here — it runs as a genuine kernel interface via awg-quick/awg, managed
the same way internal/mtproto manages mtg: one Inbound row is one
desired Instance, and a Manager reconciles running interfaces toward
the database every 10s (internal/web/job/amneziawg_job.go) plus
immediately after a client edit (applyLocalAmneziaWG).

Clients reuse model.Client verbatim (the same PrivateKey/PublicKey/
PreSharedKey/AllowedIPs fields WireGuard already uses), so bulk
operations, the QR/share-link modal and subscriptions come from the
shared inbound infrastructure instead of a parallel implementation.
internal/amneziawg owns the obfuscation param generator/validator
(ported from coinman-dev/3ax-ui, upgraded to AmneziaWG 2.0's S3/S4
padding and I1 signature packet) and the exec wrapper around
awg-quick/awg, with fingerprint-based reconcile (noop / reload-via-
syncconf / full restart) mirroring mtproto.Manager so a same-protocol
edit doesn't force an unnecessary interface bounce that would drop
every peer's connection.

Frontend and install.sh's DKMS/awg-tools setup are tracked separately;
this is backend-only.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* feat(amneziawg): add frontend support and fix a Go->Zod generator gap

Wires the amneziawg protocol through the panel UI the same way every
other protocol is registered: a Zod settings schema (nested
{server, clients}, matching the Go JSON exactly), the protocol enum,
the inbound-form's per-protocol fields component and its
tab-visibility allowlist, the default-settings factory, the client
schema dispatcher, and the sniffing-capability exclusion (no Xray
inbound exists for amneziawg, same as mtproto).

Client key/allowedIPs fields are reused rather than duplicated: since
AmneziaWG clients are wire-identical to WireGuard clients (same
model.Client fields), ClientFormModal renders one shared field block
for both, switching only the visible label by which protocol is
active. The private-key input also gets a live public-key sync via a
new useEffect, because unlike WireGuard's Xray-native inbound (which
re-derives its public key at runtime and never stores one),
AmneziaWG's server.publicKey is a real persisted field the Go backend
reads directly — free-typing a new private key without this would
silently save a mismatched keypair.

Adds a downloadable per-client .conf (amneziawgConfig.ts, mirroring
wireguardConfig.ts) with the obfuscation lines, and an
InboundOption.AwgServer field on the Go side so the config builder
gets the full server block in one round trip.

Along the way, running tools/openapigen surfaced a real bug: it
doesn't flatten anonymously-embedded Go structs the way encoding/json
does, so ServerSettings embedding Obfuscation20 produced a Zod schema
with a nested `obfuscation20` key that never matches the real wire
JSON. Fixed by un-embedding (flat fields + an accessor method) and
registering internal/amneziawg in the generator's own package list,
which had been silently emitting a dangling schema reference.

English and Russian translations are complete; the other 10 locale
files still fall back to English for the new keys.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* feat(amneziawg): complete frontend parity for the Inbounds list page

The Clients page (form, CRUD, QR/config) already worked from the
prior commit; this closes the remaining gap on the Inbounds side and
in a couple of protocol allowlists that a plain search for existing
wireguard/mtproto handling turned up.

lib/xray/inbound-link.ts gets amneziawg-specific link/config builders
(genAmneziaWGLink/genAmneziaWGConfig, plus the *s fan-out variants)
mirroring the wireguard ones — AmneziaWG has no legacy peers-array to
fall back to, so these read settings.clients directly and add the
obfuscation lines every client must share with the server. Wired into
genInboundLinks generically, and into three consumers that call the
wireguard builders directly rather than through that dispatcher:
QrCodeModal, InboundInfoModal, and InboundsPage's bulk export.

ClientInfoModal, ClientBulkAddModal, and the bulk attach/detach modals
each had their own protocol allowlist that needed amneziawg added
alongside wireguard/mtproto.

Two real gaps surfaced by grepping every remaining 'wireguard' /
Protocols.WIREGUARD hit in frontend/src rather than trusting the
checklist was exhaustive:
- useInbounds.ts's TRACKED_PROTOCOLS gates the deactive/depleted/
  expiring/online client counts shown per inbound on the list page;
  without amneziawg those counts would silently read zero.
- inbound-tag.ts is an explicit client-side mirror of the Go backend's
  port_conflict.go (the file says so itself: "Keep in sync"). It still
  only special-cased wireguard for UDP, so an amneziawg inbound would
  have fallen through to the TCP default and disagreed with the
  backend's own port-conflict math.

Also finishes translating the AmneziaWG UI strings into the 11 locale
files that were still falling back to English (ar-EG, es-ES, fa-IR,
id-ID, ja-JP, pt-BR, tr-TR, uk-UA, vi-VN, zh-CN, zh-TW), matching
en-US/ru-RU key-for-key (26 new keys, verified by count in every file).

Not run anywhere: npm run typecheck / build. This machine has neither
Node nor npm, so nothing here has compiled — reviewed by hand plus
brace/paren balance checks and cross-referencing the generated Zod/TS
types. Treat this as needing a real typecheck before shipping.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* docs(install): note that AmneziaWG kernel module install is still manual

Tracked separately (not yet ported into this script) — see
coinman-dev/3ax-ui's install_amneziawg for the reference approach
(ppa:amnezia/ppa). Also serves as a real, path-filter-matching change
to get the previous empty commit's CI trigger to actually fire —
release.yml's push trigger is paths-scoped and an empty commit changes
no files, so it never matched.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* feat(amneziawg): add a button to randomize obfuscation parameters

Mirrors the existing key-regenerate button next to the private key
field. Client-side randomization matches the ranges/constraints of
GenerateObfuscation20's "default" preset (internal/amneziawg/params.go)
closely enough for a form suggestion — the user can still hand-edit any
field afterward.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* feat(install): auto-install the AmneziaWG DKMS module + amneziawg-tools

Ports install_amneziawg from coinman-dev/3ax-ui's install.sh, adapted to
this script's broader distro coverage and NONINTERACTIVE convention:

- Ubuntu/Debian/Armbian: ppa:amnezia/ppa (primary, tested path), with a
  reachability pre-check for the Launchpad PPA host — often blocked by
  hosting providers, especially Russian VPS — so a flaky network skips
  the feature instead of hanging apt through several retries.
- Fedora/RHEL-family, Arch/Manjaro/Parch: best-effort fallback to plain
  wireguard-tools (+ AUR amneziawg-dkms via yay/paru when available),
  with a manual-install pointer.
- Everything else: manual-install pointer only.

Also installs ndppd and persists IPv4/IPv6 forwarding (for the future
IPv6/NDP phase, not yet wired into the panel) and adds a Secure Boot
warning at the end of the run, since a DKMS-built module is unsigned
and won't load while it's enabled — a common trap on cloud VPS images.

Never fatal: the panel installs and runs fine either way, an AmneziaWG
inbound just won't bring up its tunnel until the module is present.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* fix(amneziawg): resolve all 3 real CI failures (typecheck/lint/codegen)

Found by checking the fork's Actions tab after the last two pushes —
the release build passed (it doesn't run these checks) but the
separate CI workflow caught three real issues:

- golangci-lint (noctx): every internal/amneziawg/manager.go exec.Command
  call is now exec.CommandContext with a 30s timeout, so a hung
  awg-quick/awg invocation can't block the reconcile job indefinitely
  (mirrors internal/mtproto/process.go's own CommandContext usage).
- tsc --noEmit: frontend/src/schemas/client.ts's hand-maintained
  InboundOptionSchema (used by the useClients hook, separate from the
  auto-generated one in generated/) never got an awgServer field added
  when the AmneziaWG frontend work was done — every read of
  inbound.awgServer.* in amneziawgConfig.ts was typing as {}. Added
  AwgServerOptionSchema, nested (not flattened like wg*) to match what
  amneziawgConfig.ts already expects. Also guarded server.publicKey in
  inbound-link.ts's genAmneziaWGLink against the schema's optional type.
- codegen staleness: frontend/public/openapi.json is produced by a Node
  script (gen:api) this machine can't run; hand-applied the exact diff
  the CI failure log already showed (amneziawg protocol enum entry,
  ServerSettings schema, InboundOption.awgServer, one example payload),
  verified as valid JSON.

Also confirmed independently by this run: install_amneziawg (previous
commit) installed and loaded the DKMS module successfully on both amd64
and arm64 CI runners. The two "Deploy Smoke Tests" failures are
unrelated to this change — this fork has only ever published the
dev-latest pre-release, and GitHub's /releases/latest API deliberately
excludes pre-releases, so the smoke test's no-argument install path
(which resolves "latest") has nothing to find. Not a regression; needs
an actual tagged release whenever that's wanted.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* feat(amneziawg): Phase 2a — IPv6 support + NDP proxy

Adds native dual-stack IPv6 to AmneziaWG inbounds, ported from
coinman-dev/3ax-ui's approach:

- ServerSettings gets ipv6Enabled/ipv6Subnet/ipv6ExternalInterface;
  Instance carries the server's own IPv6 address (first host of the
  subnet) alongside its IPv4 one.
- defaultAmneziaWGClients allocates an IPv6 host address per client
  (second AllowedIPs entry) when the server has IPv6 enabled, reusing
  allocateWireguardAddress — which needed a real fix along the way: it
  always suffixed "/32" regardless of address family, which is wrong
  for an IPv6 host address (needs /128). Now family-aware.
- generateServerConfig's PostUp/PostDown gains IPv6 forward-accept
  rules, proxy_ndp sysctl, and one `ip -6 neigh add/del proxy` entry per
  enabled peer with an IPv6 address — the lightweight per-client
  method, not the ndppd-daemon whole-subnet method (not worth the
  config-file-management complexity at this scale; ndppd itself is
  still installed by install.sh in case that changes later).
- ValidateIPv6Subnet rejects a malformed subnet before save.
- Frontend: ipv6Enabled/ipv6Subnet/ipv6ExternalInterface fields on the
  AmneziaWG inbound form, EN+RU translations, openapi.json/generated/*
  regenerated (the latter via `go run ./tools/openapigen`, pure Go).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* fix(amneziawg): fill in IPv6 fields missed by the Phase 2a commit

Two real gaps the CI caught (both new fields, both my miss):

- inbound-defaults.ts's createDefaultAmneziawgInboundSettings() built a
  server object literal predating ipv6Enabled/ipv6Subnet/
  ipv6ExternalInterface — AmneziawgServer's inferred type now requires
  them (zod .default() fields are non-optional post-parse), so this
  didn't typecheck at all.
- openapi.json's ipv6Enabled property was missing the description the
  real generator attaches (the Go doc comment covering all three IPv6
  fields is attached to the first one) — a one-line diff, but git
  diff --exit-code doesn't care how small.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* feat(amneziawg): Phase 2b — per-client port-forwarding

Admins can now set a per-client ForwardedPorts string (e.g. "80, 443,
8000-8100") that gets DNAT'd + FORWARD'd to that peer's tunnel address
via iptables rules in PostUp/PostDown, ported and simplified from
coinman-dev/3ax-ui's shared/portfwd.

Two decisions worth flagging for future readers:

- The iptables --comment tag on each rule is awg-fwd-<fnv32a(email)>,
  not the raw client email. Email is admin/API-supplied free text that
  ends up embedded in a shell-executed PostUp/PostDown line; a hash
  can never carry a shell metacharacter through where raw
  interpolation could.
- The reconcile manager gained a third fingerprint (portFwdFP, next to
  the existing structural/peers ones). `awg syncconf` only touches the
  WireGuard peer table — it never re-applies PostUp/PostDown iptables
  rules — so a port-forward-only change has to force a full
  awg-quick down+up bounce, same as a structural change, rather than
  the lighter sync a plain peer add/remove can use.

Also fixes a real pre-existing bug found while wiring up IPv6 client
allocation in the previous commit's spirit: allocateWireguardAddress
always suffixed "/32" regardless of address family, which produced
invalid host bits for IPv6 (needs "/128").

ForwardedPorts flows through model.Client -> model.ClientRecord
(gorm column wg_forwarded_ports, auto-migrated) -> ToRecord/ToClient/
MergeClientRecord, mirroring the awgServer field's earlier lesson
that new fields need checking against a second, hand-maintained
persistence-layer struct.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* feat(amneziawg): route a client's traffic through Xray via the Routing page

Every enabled AmneziaWG inbound gets its own Xray TPROXY bridge
automatically, with no toggle to enable first: a loopback
dokodemo-door inbound (sockopt.tproxy) tagged with the AmneziaWG
inbound's own real tag, so it's already selectable in the existing
Routing page's inbound-tag picker — the same trick the mtproto
sidecar's own bridge already relies on (InboundService.GetInboundTags
is a plain, protocol-blind SELECT over every inbound row's tag, no
dedicated UI plumbing needed).

internal/amneziawg's defaultPostUpDown TPROXYs every peer's traffic
into that bridge unconditionally; the bridge's port is derived
deterministically from the inbound's id (EgressPortForInbound) so the
kernel-side reconcile loop and the Xray-config generator never need to
negotiate a runtime value between them.

injectAmneziawgEgress never generates a routing rule itself — whether
a client's traffic goes anywhere beyond Xray's default routing is
entirely up to whatever rules the admin adds through the existing
Routing UI (pick the AmneziaWG inbound's tag as source, optionally a
specific peer's IP via that page's own Source-IP field, and an
outbound), exactly the same workflow as routing any other protocol.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* fix(amneziawg): recover orphaned interfaces after an ungraceful exit

Two gaps left an AmneziaWG interface stuck outside the manager's
control after a crash (kill -9/OOM/panic skips StopAll):

- ensureRestart's teardown was gated on the in-memory `exists` map,
  which is always empty on a fresh process, so a survived interface
  never got interfaceDown before interfaceUp tried `ip link add`
  against a name the kernel already had — failing forever and never
  populating m.ifaces, so traffic accounting silently stopped and the
  inbound could never be removed. Gate on isInterfaceUp instead, which
  checks real kernel state rather than this process's own bookkeeping.

- An inbound deleted from the database entirely while the panel was
  down has no entry in `desired` ever again, so it never reaches the
  per-id cleanup loop in Reconcile (which only walks m.ifaces). Add a
  one-time sweepOrphansLocked scan of configDir, mirroring
  mtproto.Manager.sweepOrphansLocked, that tears down and removes any
  leftover interface/config not in the current desired set.

Found by the automated review on MHSanaei/3x-ui#6105 (Finding 1).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* i18n(amneziawg): backfill IPv6/obfuscation/port-forwarding keys in 11 locales

Only en-US/ru-RU ever got these 9 keys as each AmneziaWG feature landed
(the regenerate-obfuscation button, then Phase 2a's IPv6 fields, then
Phase 2b's per-client ForwardedPorts) — the other 11 locale files were
never backfilled, so i18next has been silently falling back to English
for all of them since Phase 1. Cosmetic-only (never broke anything),
but now closed for every shipped locale.

* fix(amneziawg): resolve 7 Medium findings from the automated PR review

Each is independently reproducible; fixed together since one review pass
found all of them.

- manager.go: the shared "ip rule add fwmark" policy route had no
  existence check, so it duplicated in "ip rule show" on every interface
  bounce (which hostRulesFingerprint forces on any client add/remove/
  re-IP). Now checked via "ip rule list | grep -q ..." first. (Finding 2)

- params.go: ExternalInterface, IPv6ExternalInterface, and subnetIp/
  subnetCidr are interpolated unescaped into a shell-executed PostUp/
  PostDown line, but only obfuscation and the IPv6 subnet were validated
  before save. Added ValidateInterfaceName (a strict charset+length
  pattern) and ValidateSubnetIPv4 (netip.ParsePrefix), wired into
  normalizeAmneziaWGSettings. (Finding 3)

- amneziawg_job.go: IsAwgInstalled() existed but nothing ever called it,
  so a host without awg/awg-quick (the Docker image, RHEL, Arch, a failed
  install.sh PPA step) logged a reconcile failure every 10s forever. Now
  checked once an inbound actually needs it, warning once instead of
  spamming. (Finding 4)

- client_inbound_apply.go: the WireGuard/AmneziaWG credential
  carry-forward (added so a metadata-only client edit doesn't rotate
  keys) never covered ForwardedPorts, so a partial edit -- an API call or
  Telegram-bot toggle that omits the field -- silently wiped a client's
  port-forwarding spec. Carried forward and written back the same way the
  key fields already are. (Finding 5)

- manager.go: hostRulesFingerprint keyed each peer on its IPv4 address
  only, and structuralFingerprint omitted IPv6Enabled/IPv6ExternalInterface
  entirely, so an IPv6-only change could pick the syncconf reload path
  (which never re-runs PostUp, leaving a stale NDP-proxy entry) or be a
  complete no-op. Both fingerprints now cover the IPv6 fields. (Finding 6)

- port_conflict.go: the AmneziaWG egress bridge (injectAmneziawgEgress)
  binds 127.0.0.1:63100+id with no collision check anywhere, since it
  isn't a database row the ordinary port-conflict query can see -- same
  blind spot the reserved Xray API port already has its own check for.
  Added the equivalent check for the AmneziaWG bridge port. (Finding 7)

- install.sh: install_amneziawg ran unconditionally for every install/
  update, building a DKMS kernel module and enabling host-wide IPv4/IPv6
  forwarding whether or not the feature is ever used. Gated behind a new
  should_install_amneziawg (XUI_INSTALL_AMNEZIAWG=true/false, or an
  interactive y/N prompt defaulting to no). Also replaced the deprecated
  apt-key adv with a dedicated keyring + signed-by= on the Debian branch,
  and guarded its sources.list appends against duplication on a retried
  install. (Finding 8)

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* feat(amneziawg): make the Xray TPROXY bridge a per-inbound opt-in

Addresses Finding 10 from the automated PR review: an always-on TPROXY
bridge makes every AmneziaWG tunnel hard-depend on Xray being up (all
traffic, including DNS, drops whenever Xray restarts), and forces a full
awg-quick down+up bounce on any client add/remove/re-IP, permanently
losing the syncconf fast path.

Adds ServerSettings.RouteThroughXray (off by default):

- defaultPostUpDown only emits the TPROXY/policy-route rules when it's
  on; a plain AmneziaWG tunnel now has zero Xray dependency out of the
  box.
- structuralFingerprint covers it (toggling it changes whether PostUp/
  PostDown contain any TPROXY rules at all -- structural, not a
  per-peer host-rule). hostRulesFingerprint's IPv4 tracking is now
  itself conditional on RouteThroughXray (and IPv6 tracking on
  IPv6Enabled), so an instance that never uses either keeps the
  syncconf fast path for a plain peer re-IP.
- injectAmneziawgEgress only creates a bridge for inbounds that opted
  in; checkAmneziawgEgressConflict (the Finding-7 fix) now parses each
  candidate through InstanceFromInbound so a non-routed inbound's port
  is correctly never treated as reserved.
- New inbound-level Switch in the AmneziaWG form; the actual outbound
  decision is still made entirely through the panel's stock Routing
  page, same as before -- only whether the bridge exists at all is now
  a choice.

Translation keys added to all 13 locales in the same commit this time,
not backfilled later (see Finding 9's lesson).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* fix(amneziawg): resolve 4 Low findings from the automated PR review

- manager.go: serverAddress assumed subnetIp always ends in ".0"; a
  base like "10.8.1.5" was used verbatim as the server's own address,
  eventually colliding with peer allocation (which starts at .2
  upward). Now derives the first host of the actual subnetIp/subnetCidr
  network via netip, matching serverAddressV6's own approach. A /32
  base (no host bits at all) is still used as-is. (Finding 12, partial
  -- the /16 pool-widening half of this finding only exists on the
  upstream-pr/amneziawg branch's merged client_wireguard.go, not here;
  handled separately on that branch.)

- manager.go: ensureLocked carried the previous per-peer traffic
  counters (`last`) forward even through a full restart, but
  awg-quick down+up resets the kernel's own counters to zero -- the
  next CollectTraffic computed a large negative delta (clamped to 0),
  silently discarding real traffic. Extracted the decision into
  nextTrafficBaseline: only a reload (syncconf) preserves the
  baseline. (Finding 13)

- portfwd.go: exported ForwardedPortsInclude; inbound_amneziawg.go's
  new checkForwardedPortsConflict uses it to reject, at save time, a
  client's forwardedPorts that would DNAT the panel's own port or
  another enabled inbound's port to the tunnel client --
  portForwardLines has no destination restriction, so this collision
  was previously silent. Wired into both the single-client update path
  and the add-client path (client_inbound_apply.go), plus
  normalizeAmneziaWGSettings for the whole-inbound save path. (Finding 14)

- inbound.go: InboundOption.AwgServer sent the whole ServerSettings
  struct including PrivateKey to GetInboundOptions callers -- a
  shared, admin-wide dropdown-filling endpoint the frontend's own
  AwgServerOptionSchema never reads that field from. Redacted it
  before assigning. (Finding 11)

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* fix(amneziawg): don't widen the peer address pool past AmneziaWG's own subnet

Completes Finding 12 from the automated PR review (the serverAddress half
of this finding was already fixed on main and cherry-picked here). This
half is specific to this branch: allocateWireguardAddress's /16
pool-widening fallback is an independent addition from upstream's own
main that this branch inherited during the cherry-pick rebase -- it
doesn't exist on the fork's own main at all, so this fix can't be
cherry-picked the normal way and is committed directly here.

Widening is safe for WireGuard's own Xray-native inbound (AllowedIPs
isn't tied to a strict kernel interface subnet), but AmneziaWG's kernel
interface Address is exactly the configured subnet -- an address
allocated from the containing /16 once the /24 fills up would be
silently unroutable. allocateWireguardAddress now takes an explicit
allowWidening bool: WireGuard's own caller passes true (unchanged
behavior), AmneziaWG's passes false (fails loudly on exhaustion instead).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* docs(docker): note that AmneziaWG doesn't work in this image

Investigated: the image is Alpine-based, and AmneziaWG's own packaging
(DKMS module + amneziawg-tools) doesn't target Alpine/musl at all --
unlike the Debian/Ubuntu/Fedora/Arch paths install.sh already handles,
there's no package to apk add even with full host network/capabilities.
The panel already degrades gracefully (IsAwgInstalled() logs one warning
instead of retrying forever), so no code change is needed -- just made
the reason explicit at the point where a user would reach for cap_add/
network_mode to try to work around it.

* fix(sub): include amneziawg inbounds in subscription links

getInboundsBySubId's SQL protocol allowlist never had 'amneziawg' added,
so every AmneziaWG client was silently excluded from all three
subscription formats (plain/individual links, JSON, Clash) and from the
Telegram bot's QR/individual-link buttons, which fetch through the same
path. genAmneziaWGLink itself was already fully implemented and already
wired into GetLink's dispatch switch -- it just never got a chance to
run. Same bug shape as the earlier TRACKED_PROTOCOLS frontend gap: a
hardcoded protocol list one entry short.

Found while investigating whether the Telegram bot needed AmneziaWG-
specific client-management code -- it doesn't (the bot itself is fully
protocol-agnostic), but this is the actual root cause of "can't share
an AmneziaWG client's config via the bot."

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* fix(inbound): enforce node-eligibility server-side, not just in the UI

Investigated multi-node interaction with AmneziaWG: the master's own
reconcile (DesiredAmneziaWGInstances) and Xray config generation
(injectAmneziawgEgress, the GenXrayInboundConfig protocol skip) all
correctly filter on NodeID IS NULL, so a node-assigned AmneziaWG (or
MTProto) inbound would never be managed by the master. But nothing
stopped one from being created that way: NODE_ELIGIBLE_PROTOCOLS
(frontend/src/pages/inbounds/form/InboundFormModal.tsx) only hides the
node picker client-side -- a direct API call could set nodeId on an
AmneziaWG inbound, which every node then reconciles as an ordinary
local inbound (nodes run the identical binary, full cron suite
included), leaving it running unmanaged and untracked by the master's
own AmneziaWG bookkeeping.

Added isNodeEligibleProtocol (inbound_protocol.go), mirroring the
frontend's allowlist, and enforced it in both AddInbound (the actually
exploitable path -- nodeId comes straight from the request) and
UpdateInbound (defense in depth; NodeID is already restored from the
stored row there before this check, so it mainly guards against a
protocol change on an existing node-hosted inbound).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* fix(amneziawg): allow TPROXY-marked traffic through a default-deny INPUT chain

TPROXY never rewrites a packet's own destination address, only the routing
decision. A default-deny firewall whose INPUT chain sanity-checks "is this
destination actually local" (UFW's ufw-not-local, via addrtype --dst-type
LOCAL, is a concrete example) silently drops the redirected packet before
Xray's socket ever sees it -- RouteThroughXray looked fully configured
(TPROXY rule present and counting, Xray listening with IP_TRANSPARENT set)
yet every peer's traffic vanished with no trace on either side.

Adds an idempotent, never-torn-down "iptables -I INPUT 1 -m mark --mark
<fwmark> -j ACCEPT" alongside the existing shared policy route, so this
works regardless of which firewall manager owns the rest of the INPUT chain.

* fix(frontend): give AmneziaWG the same UDP tag and its own tag color

The Inbounds list only special-cased isWireguard/isHysteria for the "UDP"
network badge, so an AmneziaWG row showed just the bare protocol tag with
no transport badge next to it. Added the missing isAmneziawg flag (mirrors
isWireguard exactly) and wired it into the same branch.

Client-row protocol-color maps in ClientsPage/HostList had no amneziawg
entry, silently falling back to grey -- ClientInfoModal already had
amneziawg: 'yellow' from earlier work, these two just never got it.

* feat(logs): show which AmneziaWG client an access-log line belongs to

The dokodemo-door TPROXY bridge every AmneziaWG peer's traffic is routed
through has no per-user identity, so Xray's own access log never carries an
"email:" token for these lines -- the Access Logs modal showed a blank
Email column for every in-*-udp row, even though every other protocol's
rows show the client normally.

The peer's decapsulated tunnel IP does survive as the log's "from" address,
and that IP deterministically maps to exactly one configured peer. Builds a
"<inbound tag>|<ip>" -> email index from the same AmneziaWG inbounds already
parsed elsewhere (amneziawg.InstanceFromInbound), and fills in Email from it
whenever the raw log line didn't have one.

* fix(amneziawg): enable sniffing on the TPROXY bridge

Domain-based Routing rules could never match RouteThroughXray traffic: an
AmneziaWG peer resolves DNS itself, through the tunnel, before ever sending
a packet, so the decapsulated traffic TPROXY hands to the bridge is already
a bare destination IP with no domain name attached at the network layer.
Every other inbound recovers this via sniffing (confirmed working for the
stock wireguard inbound, which does have it configured); the bridge never
got a sniffing block at all, so only tag/IP/network-based rules could ever
match it -- any domain rule above it in the list was silently unreachable.

* docs: add an AmneziaWG config page and list it as a supported protocol

Closes the PR checklist gap: the feature shipped with zero mention on
the docs site. Mirrors reality.mdx's structure (key settings, setup
steps, config excerpt) and notes the Docker/multi-node/Telegram-bot
caveats the PR itself is honest about not having confirmed.

* fix: address the fresh review round on PR #6105 (8 findings)

1. hostRulesFingerprint didn't account for ForwardedPorts when
   RouteThroughXray was off, so re-IPing a peer with port-forwarding
   configured left stale DNAT rules pointing at an address the next
   peer could be handed.
2. Server/client config values (keys, email, I1) were never validated
   for control characters before being written into the generated
   .conf; a newline could smuggle a PostUp hook into awg-quick's
   parser. Added ValidateConfigValue at save time and a
   sanitizeConfigValue backstop at render time.
3. checkForwardedPortsConflict didn't scope to node_id IS NULL, so a
   port used only on a different node produced a false collision; also
   hoisted the panel-port/inbounds lookup out of the per-client loop
   (portConflictContext) so N clients cost one query, not N.
4. PostDown commands were ";"-joined and abort on the first failure;
   appendOrTrue makes teardown best-effort so an external firewall
   flush can't leave DNAT rules to accumulate across bounces.
5. The "ip rule list | grep -q" existence check could SIGPIPE under
   pipefail and re-add a duplicate rule; switched to grep -c >/dev/null.
6. Ported the vpn:// share-link format (base64url of the plain .conf
   text, matching the real AmneziaVPN app) onto this branch -- it had
   only ever landed on our own fork's main, so this PR branch was still
   on the old amneziawg://+query-params scheme our own docs no longer
   described. Also corrected the docs' install.sh claim (opt-in/
   interactive, not automatic) and stale pre-opt-in comments in
   route_egress.go.
7. install.sh: Arch's ndppd install used pacman -Syu (full system
   upgrade) instead of -Sy like every other call in the script; and
   should_install_amneziawg re-prompted on every `x-ui update` even
   when awg was already installed.
8. CollectTraffic could clobber a concurrent restart's freshly-reset
   (empty) traffic baseline with stale pre-restart counters, since
   getPeerStats runs lock-free; now checks pointer identity before
   writing back. sweepOrphansLocked permanently disabled itself on a
   transient os.ReadDir failure instead of allowing a retry.

go build/vet/test and frontend typecheck/lint/build/vitest all pass.

* fix(install.sh): check the live sysctl value, not sysctl.conf text

Reviewer feedback (cherts, PR #6105): grepping /etc/sysctl.conf for the
setting name is unreliable -- many distros split sysctl config across
/etc/sysctl.d/*.conf, and /etc/sysctl.conf can be a symlink into that
directory, so the check can miss an already-active setting (harmless
duplicate append) or match a disabled/commented line (forwarding
silently stays off). Query the live value via `sysctl -n` instead,
which is accurate regardless of which file set it. Applied the same
fix to both the IPv6 and IPv4 checks for consistency.

* fix: update inbound_amneziawg.go to the split buildInboundForLocalRuntime

Same fork-only-file blind spot as the one caught on our own main after
the 3.6.0 sync: upstream split buildRuntimeInboundForAPI into
buildInboundForNodePush / buildInboundForLocalRuntime (part of the
node-sync client-deletion fix, 5bc81dfd), updating every call site it
could see. This file doesn't exist upstream, so it kept calling the
old name even after the branch merged in that commit.

* fix(frontend): recognize AmneziaWG's vpn:// scheme in share-link labels

The shared link-tag/label helper (used by the client info modal, QR
modal, and subscription page) had no entry for the vpn:// scheme
AmneziaWG links use, so it fell through to the generic fallback: a
plain "Vpn" tag with no color, and an empty remark/port that made the
row's title fall back to "Link N" instead of the inbound's actual
name:port — unlike every other protocol, which shows its real tag and
label.

vpn:// links are base64url of a plain .conf text (matching the real
AmneziaVPN app's own share-link format), not a structured URL, so
there's no query string or #hash to read a remark/port from. Decode
the payload and pull the remark/endpoint back out of the .conf text
directly instead.

* fix(xray): force a full restart for TPROXY inbounds, never hot-add them

Real incident: an AmneziaWG inbound with RouteThroughXray enabled lost
all internet on that connection after a migration. Root-caused on the
live box -- iptables TPROXY counters were incrementing (packets
correctly redirected to 127.0.0.1:63110), but nothing was actually
listening there (ss showed nothing on that port) until a full
`systemctl restart x-ui`, after which the bridge came up immediately.

Xray-core's gRPC AddInbound reports success for a new sockopt.tproxy
inbound (internal/amneziawg's own Xray egress bridge is the only kind
this fork ever generates) but doesn't reliably bind a working listener
for it outside of process startup -- the bridge silently never comes
up, and RouteThroughXray traffic goes nowhere until the next full
restart happens to occur for an unrelated reason.

diffInbounds already has this exact defensive pattern for REALITY
inbounds ("a gRPC remove+add does not reliably rebuild the REALITY
authenticator"), just never extended to TPROXY, and only in the
already-existing-then-changed branch -- the "brand new inbound" branch
had no such guard at all, which is exactly the path a freshly-enabled
RouteThroughXray bridge takes. Added inboundUsesTproxy and wired it
into both branches.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* fix(amneziawg): flag Xray for resync when a peer edit changes qualifying state

Real production bug, root-caused on iiadmin-vps: updateAmneziaWGInbound/
AddInbound/DelInbound only ever updated the kernel interface via
amneziawg.GetManager() -- they never called SetNeedRestart the way every
other protocol's mutation path does (client_crud.go, inbound.go, etc. all
do). injectAmneziawgEgress's TPROXY bridge inbound depends on
InstanceFromInbound finding at least one qualifying peer plus
RouteThroughXray, so an edit that flips that (first peer added, last one
removed, RouteThroughXray toggled on) previously required a full panel
restart before the bridge actually got created, with no error anywhere:
the kernel interface would handshake fine, but traffic redirected into the
bridge's TPROXY port went nowhere because nothing was listening there.

diffInbounds/inboundUsesTproxy already correctly force a full restart for
a brand new TPROXY inbound (bdee0a20) -- that part was never the bug. The
gap was entirely upstream: nothing ever told Xray a resync was even needed.

* fix(clients): reject AllowedIPs already used on another WireGuard/AmneziaWG inbound

defaultWireguardClients/defaultAmneziaWGClients only ever checked uniqueness
against their own inbound's client list, so two inbounds sharing a subnet
(same protocol or not) could silently hand out or accept the same address --
the exact scenario behind a real duplicate-IP incident where a WireGuard and
an AmneziaWG client both ended up on the same address. otherTunnelAllowedIPs
now collects every address already claimed on every other tunnel inbound and
folds it into both the auto-allocation pool and the manual-entry collision
check, naming the other inbound in the error when it fires.

* fix(frontend): add the missing AmneziaWG config download on the sub page

The subscription page already gave WireGuard links their own "Config"
block (copy/download/QR of the actual .conf, via wireguardConfigFromLink
reversing the wireguard:// query params) but had no equivalent for
AmneziaWG's vpn:// links -- its isWireguardLink gate never matched them,
and no reverse-parse helper existed for this page specifically. Every
other surface (InboundInfoModal, ClientInfoModal, ClientQrModal) already
had this parity; this was the one page that didn't.

Fixed by adding amneziawgConfigFromLink (inbound-link.ts), simpler than
its WireGuard counterpart since a vpn:// payload already *is* the plain
.conf text -- just base64url-decode it, no query-param reconstruction
needed -- and wiring it into SubPage.tsx alongside the existing WireGuard
block, reusing the same pages.clients.amneziaWgConfig label the other
three surfaces already use.

* fix(xray): force a full restart for password-auth SOCKS5 hot-apply

Real production incident: editing a client under an AmneziaWG inbound
left its embedded SOCKS5 relay's settings byte-different (a new account
list), and Xray's gRPC remove+add hot swap silently dropped the account
for a peer whose email contained non-ASCII characters -- its tunnel kept
handshaking fine but all its traffic got rejected at the SOCKS5 layer,
while every other peer on the same relay was unaffected. A full restart
(reading the same JSON straight from disk) always produced the correct
account list. socks isn't in userDiffableProtocols (that only covers
vless/vmess/trojan's clients+email shape, not accounts+user), so any
settings drift on this inbound fell through to the generic remove+add
path. Forces a restart instead, the same defensive choice already made
for REALITY and TPROXY -- scoped to auth:"password" specifically so the
other, noauth SOCKS5 bridges (panel/node/mtproto egress) keep the cheaper
hot path.

* Fix Attach reusing one identity's address across wg/awg inbounds

ClientService.Attach deliberately copies one identity's stored
AllowedIPs into every WireGuard/AmneziaWG inbound it's attached to
in the same call, so the same person gets the same tunnel address
on every protocol they use. Its loop calls addInboundClient once per
inbound, and each of those independently computes
otherTunnelAllowedIPs -- so by the second inbound in the batch, the
first inbound's just-written copy of this identity's own address
looked like a cross-inbound collision against itself.

Real production symptom this caused: detaching then re-attaching a
client to both wg and awg failed with "wireguard: allowedIPs entry
X is already used by a client on inbound 'awg' (#N)" -- the exact
address the identity is supposed to keep, rejected as if it belonged
to someone else.

Add a selfEmails exclusion to otherTunnelAllowedIPs and populate it
from the client(s) being processed at the one real call site. Safe
unconditionally: ClientRecord.Email is globally unique, so a match
can only ever be this same identity's own entry on a sibling inbound,
never a genuine different client's address.

Reproduced the underlying mechanism live (manual entry correctly
rejected as a cross-inbound collision; fresh auto-allocation
correctly avoided a used address) before writing the fix, to confirm
the guard itself works and the bug is specifically in how Attach's
per-inbound calls interact with it.

* Attach: allocate fresh when re-attaching with no active tunnel

The previous fix (82cc69f5) made Attach's own address-reuse
correctly not collide with itself across inbounds -- but it still
always reused an identity's stored AllowedIPs verbatim, even when
that identity currently has zero WireGuard/AmneziaWG attachments at
all. A real report from testing this live: an identity fully
detached from both its wg and awg inbounds, then re-attached, got
its old address back even though several lower addresses were free
-- because nothing about being fully detached ever cleared the
stored value Attach copies from.

Add hasTunnelAttachment, checked once against the identity's CURRENT
inbound set before Attach's loop runs: if none of its current
inbounds is WireGuard/AmneziaWG, clear the stored AllowedIPs so this
attach allocates fresh (matching what a brand-new client would get)
instead of resurrecting an address nothing reserves anymore. Left
alone when the identity already has an active tunnel elsewhere, so
extending it to a second protocol still keeps a consistent address.

* Fix TestOtherTunnelAllowedIPsExcludesSelfEmail's own test setup

CI caught this: the "genuinely different client" (other@wg) was
seeded onto the SAME inbound passed as excludeID, which
otherTunnelAllowedIPs already excludes entirely regardless of the
selfEmails fix -- so the assertion that its address is still
reported could never have passed, proving nothing either way. Move
it onto the sibling inbound alongside shared@id, which is what the
test actually needs to exercise (two clients on one sibling, one
excluded by email, one not).

* Attach: never inherit an address that doesn't fit the target inbound

hasTunnelAttachment (from the earlier fix, commit 51067f16) only
asked "does this identity have ANY tunnel attachment", treating that
as license to reuse its stored address verbatim on every inbound
being attached. Real production case this missed: an identity's
stored address came from WireGuard's own fallback subnet
(10.0.0.0/24, used when that inbound has no other clients to infer a
base from), then got attached to a second, AmneziaWG inbound
configured for a completely different subnet (10.8.1.0/24).
defaultAmneziaWGClients's already-set-AllowedIPs branch only checks
for collisions, never subnet membership, so the mismatched address
was accepted silently -- producing a peer that can never actually
connect, since an AmneziaWG address must fall inside the kernel
interface's own configured subnet to be routable at all.

Add addressesFitAmneziaWGInbound, checked per inbound inside Attach's
loop: if the inherited address doesn't fit the SPECIFIC inbound being
attached, clear it just for that one so it gets a fresh, valid
allocation instead, while other already-attached inbounds keep their
existing values. WireGuard has no equivalent strict subnet
requirement (allocateWireguardAddress can widen to a fallback pool
for it), so this only ever constrains AmneziaWG targets.

* Give WireGuard an explicit, admin-configurable subnet field

WireGuard previously had no configurable subnet at all -- only an
implicit one, either inferred from existing clients' own addresses
(wireguardAllocationBase) or a hardcoded 10.0.0.0/24 fallback when
none exist yet. AmneziaWG, by contrast, has always had a real
server.subnetIp/subnetCidr field in its settings, editable in the
UI. User request: give WireGuard the same treatment.

Backend: explicitWireguardSubnetBase reads an optional subnetIp/
subnetCidr pair from the inbound's own settings JSON (mirroring
AmneziaWG's defaultAmneziaWGSubnetBases). defaultWireguardClients
checks it first; only when unset does it fall back to today's
inference-from-existing-clients behavior, so an inbound saved before
this field existed keeps working exactly as it always has.

Frontend: subnetIp/subnetCidr added to WireguardInboundSettingsSchema
and the inbound form (mirroring AmneziaWG's own field layout/labels),
with a real default (10.0.0.0/24, the same value the backend already
fell back to) seeded for newly created inbounds so the field starts
populated and editable rather than blank. Translated across all 13
locales.

This also structurally closes the class of bug fixed in
82cc69f5/291c47b3: with wg and awg subnets explicit and
independently controllable, an admin who wants matching addresses
across both protocols can configure them to actually agree, instead
of one silently inheriting the other's incompatible range.

* Split the client edit form's AllowedIPs into per-protocol fields

A client attached to both WireGuard and AmneziaWG shared one AllowedIPs
form field with a dynamically-switching label, so its two genuinely
different addresses could never both be shown or edited correctly.
Worse, Update/Create broadcast that one shared value to every attached
wg/awg inbound with no subnet-fit check, so an ordinary edit save could
silently overwrite one protocol's address with the other's -- the same
bug class already fixed for Attach, but reachable from any client edit.

model.Client gains an optional AllowedIPsByInbound map so a caller can
send distinct values per inbound; Update/Create honor it and, when it's
absent, clear a shared value that doesn't fit an AmneziaWG inbound's own
subnet instead of writing it through. A new TunnelAllowedIPsByInbound
read path feeds the real per-inbound address to the client edit form via
GET, which now renders two separate, correctly-labeled fields whenever
both protocols are attached (unchanged single dynamic field otherwise).

* Regenerate openapi.json for the new allowedIPsByInbound field

Follow-up to 878ee839: gen:zod (frontend/src/generated) was already
regenerated and committed, but gen:api (frontend/public/openapi.json)
wasn't, so CI's codegen drift check failed.

* Fix build breakage from merging upstream main: Update() gained a limitHwid param

Two of our own AllowedIPs tests (not present upstream, so the merge never
flagged them as conflicting) still called the old 3-arg Update(inboundSvc,
id, client) -- upstream's hardware-ID-limit feature added a required
limitHwid parameter that every other caller in this package already
passes. Also drop createDefaultInboundSettings from InboundsPage.tsx: the
merge conflict resolution kept the import, but upstream's clone-payload
refactor (buildClonePayload, inbound-clone.ts) already calls it
internally now -- this file doesn't need it directly anymore.

* Fix real bug: AmneziaWG clients rejected as "empty client ID" in 3 places

Three switch statements on inbound.Protocol handle "wireguard" explicitly
(checking client.PublicKey) but fall through to the default case for
"amneziawg" (checking client.ID, which AmneziaWG clients never set --
they use PublicKey/Email like WireGuard, not the VMess/VLESS UUID field).
This is what the 4 AllowedIPs tests were actually catching:
UpdateInboundClient's newClientId derivation hit this same default branch,
so every Update() on an AmneziaWG client returned "empty client ID"
before ever reaching the AllowedIPs logic being tested.

Fixed by adding "amneziawg" alongside "wireguard" in each switch:
addInboundClient's per-client validation, UpdateInboundClient's
newClientId derivation, and AddInbound's per-client validation (the
third one wasn't hit by these tests, but has the identical bug -- creating
a brand-new AmneziaWG inbound with a client attached would fail the
same way).

* refactor(amneziawg): rename Obfuscation20 to Obfuscation31, drop the dead mobile preset

Mechanical rename ahead of the AmneziaWG 3.1 parameter work: the type,
generator and prose all said 2.0, and the "mobile" generator preset was
reachable only from its own test. No behavior change.

* feat(amneziawg): AmneziaWG 3.1 obfuscation parameters (backend + generated schemas)

Adds the 3.1 parameter surface to the inbound settings and both Go config
emitters: I2-I5 signature packets, HeaderProtectionKey (base64 32-byte,
shared server<->client), ContentPaddingAddition, the five handshake-timing
randomization ranges (RekeyAfterTime/RekeyTimeout/RejectAfterTime/
KeepaliveTimeout/MaxHandshakeAttempts), and the RandomTrailers/
DisableCookies switches. Freshly generated sets fill everything except
I2-I5 (matching Amnezia's own generator) with jittered ranges bracketing
WireGuard's stock timing constants; every reject window starts >= 30s
above the rekey window by construction. Empty fields stay off the wire,
so blanking a field disables just that feature.

Validation generalizes the H1-H4 range checker for the new uint32-range
fields, requires min 1 on timers, cross-checks rekey-vs-reject, and
demands a real 32-byte base64 header-protection key. The manager warns
once per process when the installed awg tools predate 3.1 but an inbound
uses 3.1 parameters (awg-quick rejects unknown keys with a generic
error otherwise); apply still proceeds.

Requires amneziawg-tools v3.1.20260812+ / module or amneziawg-go
v3.1.20260814+ on the host.

* feat(amneziawg): emit and randomize 3.1 parameters in the frontend

Both client-config emitters (the vpn:// link builder and the clients-page
.conf builder) now carry the 3.1 [Interface] lines in the same order as
the Go emitters. The obfuscation randomizer moves out of InboundFormModal
into a shared lib/xray/amneziawg-obfuscation.ts that also fills the new
fields, and createDefaultAmneziawgInboundSettings switches from static
values to that generator — a fresh inbound now really gets the unique
fingerprint the docs promise instead of the same jc=5/jmin=10 set on
every install.

Schema parse-time defaults for the new fields stay ''/false on purpose:
real values come only from the generator, so resaving an inbound never
mutates its stored parameters. A new parity test pins the hand-written
AmneziawgServerSchema to the generated ServerSettings key set, so a field
added on one side can no longer silently vanish from configs.

* feat(amneziawg): 3.1 form fields and translations

Inbound form gains inputs for I2-I5, HeaderProtectionKey (filled by the
existing obfuscation Regenerate button), ContentPaddingAddition, the five
timing ranges, and the RandomTrailers/DisableCookies switches; the MTU
input picks up the min=1 its schema already enforced. All 13 locales get
the 19 new keys and drop the "2.0" branding from the s3/s4/i1 labels.

* docs(amneziawg): document 3.1 parameters; install.sh kernel/version notes

The AmneziaWG page's obfuscation section moves from the 2.0 to the 3.1
parameter set: table rows for I2-I5, HeaderProtectionKey,
ContentPaddingAddition, the timing-randomization ranges and the
RandomTrailers/DisableCookies switches, a requirements callout (tools
v3.1.20260812+, module/awg-go v3.1.20260814+, Linux 6.7+ for the DKMS
path), and a sample client .conf that matches what the panel actually
emits (including the DNS defaults and PersistentKeepalive it always had).

install.sh warns before a DKMS build on a pre-6.7 kernel and after any
install that left pre-3.1 amneziawg-tools on PATH.

Also updates the hosts API operation paths ({id} -> {groupId}) in the
stale ru/zh/fa reference pages: syncing docs/public/openapi.json for the
new AmneziaWG schema fields surfaced that rename, which had never been
copied over, and the docs build fails on paths missing from the spec.

* fix(amneziawg): reject control characters and canonicalize 3.1 range values

Adversarial review of the 3.1 work surfaced a validation gap:
base64.DecodeString silently ignores CR/LF, so a header-protection key
that picked up a line wrap in transit decoded to a valid 32 bytes,
passed validation, and was emitted verbatim into every client config —
where the orphan second line breaks the import while the server (whose
emitter strips control chars) keeps running with the correct key. The
key and range validators now reject control characters outright.

Also from the same review: range values are canonicalized on save
("110 - 140" -> "110-140", whitespace-only collapses to feature-off,
closing a case where the server conf rendered an invalid blank-value
line the client emitters omitted); the rekey/reject invariant is now
enforced against WireGuard's 120s/180s defaults when only one side is
set; and the structural fingerprint joins on "\n" instead of "|",
which is a legal I1-I5 character and made adjacent free-text fields
join-ambiguous.

* fix(install): resolve latest release tag via web redirect to dodge API rate limits

The non-interactive install smoke test resolved the release version through
the unauthenticated GitHub API (api.github.com/.../releases/latest), which
allows only 60 requests/hour per IP. The test installs twice in one run, and
on shared CI runner IPs the second call gets rate-limited, returns no
tag_name, and install.sh treats an empty version as fatal (exit 1) — the same
"Failed to fetch x-ui version" real users hit behind CGNAT/shared addresses.

resolve_latest_tag() now reads the tag from the github.com releases/latest
web redirect (not subject to the API rate limit), falling back to the API
only if the redirect yields nothing. Verified with the real
deploy/test/smoke-noninteractive.sh (two installs, both green).

* fix(amneziawg): three review findings on #6105, plus a comment trim

1. A peer's allowedIPs reached the generated .conf unvalidated and
   unsanitized, unlike email/publicKey/preSharedKey which
   normalizeAmneziaWGSettings already guards. A newline in an entry let a
   following "[Interface]" re-open the interface section, whose "PostUp = ..."
   awg-quick then runs as root on the next apply. Reproduced end to end
   against generateServerConfig. The save path now rejects and canonicalizes
   through normalizeWireguardAllowedIPs, and the render path sanitizes as a
   backstop for rows predating the validation (an upgrade, a restored backup,
   a direct DB edit). H1-H4 get the same render-time sanitize, and the two NIC
   name fields a plausibility check, since stripping control characters alone
   would still let a shell metacharacter into a root-executed PostUp line.

2. EgressPortForInbound is 63100 + inbound id, so an id past 2435 derives a
   port above 65535 -- and Xray rejects the whole generated config over one
   invalid port, taking every other protocol down with it. It now reports
   ok=false past the range, and both the Xray bridge and its TPROXY rules are
   skipped instead of emitting an impossible port.

3. The downloadable AmneziaWG .conf read ClientRecord.allowedIPs, a single
   shared column that holds the WireGuard address for an identity attached to
   both protocols -- the exact ambiguity tunnelAllowedIPs was added to resolve
   for the edit form. The info and QR modals already hydrate that field, so
   they now pass this inbound's own address to the builder.

Also trims the comment blocks in the files touched here to the 2-line
guidance in CLAUDE.md: internal/amneziawg alone carried 423 comment lines in
over-long blocks against 118 for the comparable internal/mtproto, and is now
at 110. Every non-obvious constraint is kept (the kernel S1/S2 rule, why
PostDown is best-effort, why grep -c and not -q, why the fingerprints split
three ways); the narration is gone. Two hot_diff.go comments pointed at an
internal/amneziawgnet package and an injectAmneziawgnetSocks function that
exist nowhere in the tree; the checks themselves are unchanged.

* feat(logs): add an AmneziaWG log view to the overview

The overview has an access-log view for Xray but nothing for AmneziaWG, so
when a tunnel misbehaves there is no way to see it from the panel at all. A
kernel tunnel logs no per-request lines, so the equivalent view is built from
the two things it does expose:

- Live per-peer activity from `awg show <iface> dump`, joined to the client
  email through the desired peer set: last handshake, endpoint, allowed IPs,
  cumulative transfer and online state, newest handshake first.
- The panel's own AmneziaWG event lines (interface up/down, awg-quick
  failures, the pre-3.1 tools warning), which are what actually explain a peer
  being absent from the table.

POST /panel/api/server/amneziawglogs/:count serves both, with the same
count + filter contract GetXrayLogs uses, and the modal mirrors XrayLogModal's
toolbar, auto-update, mobile cards and download. The action-bar button is
gated on a new status.amneziawg.configured, which stays true while an inbound
exists but its interface is down -- exactly when the event lines matter.

Verified against a running panel: the endpoint returns the peer table and
real event lines ("awg/awg-quick not found on PATH", "create config dir:
permission denied"), and count and filter both narrow as documented.

One of those lines surfaced a Debugf that had been rendering as
"for inbound1:amneziawg:"; fixed here since it is now user-visible.

* fix(amneziawg): stop double-counting a routed inbound's traffic

injectAmneziawgEgress tags its Xray bridge with the AmneziaWG inbound's own
tag, so the stock Routing page can target it. Xray therefore reports that
bridge's bytes under the inbound's tag, and XrayTrafficJob feeds them to
AddTraffic -- which accumulates -- on top of the same bytes AmneziaWGJob
already reported from `awg show dump`. An inbound with routeThroughXray on
counted roughly twice its real traffic, which also inflates the quota checks
that read the same counters.

The awg counters are the complete measure: every peer, whether or not TPROXY
routed it, and the same wire bytes the per-client totals are built from, so
they stay and the Xray rows are dropped. Per-client stats were never affected
-- a dokodemo-door bridge has no per-user identity, so Xray emits no
user>>>email rows for it.

Filtering happens before every consumer, so the DB totals, the external
traffic inform and the dashboard's live speed all read one source per inbound.
The set of bridge tags now comes from a predicate shared with
injectAmneziawgEgress itself, with a test that pins the two together -- naming
one tag too few doubles the traffic again, one too many makes real traffic
vanish.

* fix(amneziawg): align the three .conf emitters on one peer field order

The panel builds an AmneziaWG client .conf in three independent places, and
they disagreed: buildAmneziaWGClientConfig put PresharedKey right after
PublicKey (wg-quick(8)'s own order, and what both WireGuard emitters on the
clients side already use), while genAmneziaWGConfig and the Go
amneziaWGConfigText put it after Endpoint. A user comparing a subscription
link against a downloaded .conf sees the difference immediately, and the
generators are exactly the kind of parallel implementation CLAUDE.md warns
about drifting.

Moves the two outliers onto the wg-quick order. Also drops the stray trailing
newline that only appeared when PersistentKeepalive was set, so a config now
always ends on its last set field whichever that is -- the same shape all
three emitters produce for the same client.

Parsing is unaffected either way (the format is order-insensitive, and the
AmneziaVPN app reads it as a flat key-value bag), so this changes only the
rendered text. Adds a test on each side that pins the peer block's field
order, since nothing previously asserted it.

* refactor(amneziawg): switch to the embedded amneziawg-go/gVisor architecture

Replaces the kernel-module (DKMS) + awg-quick + TPROXY backend with the
fork's own embedded design: amneziawg-go runs in-process over a userspace
gVisor netstack, and each peer's decapsulated traffic relays into its own
loopback Xray SOCKS5 inbound, so Xray's native stats/sniffing/routing work
for free instead of through hand-rolled bridges. No kernel module, no DKMS,
no Secure Boot conflicts, works the same in a container as on bare metal.

- internal/amneziawgnet: new package (Device/UAPI, gVisor netstack, TCP/UDP
  forwarding, SOCKS5 relay, peer identity, IPv6 host-alias egress identity,
  per-client port-forwarding) - amneziawg-go v3.1.20260814 + gvisor.
- internal/amneziawg: keep the reusable protocol-shape types/validation
  (Instance/Peer/Obfuscation, InstanceFromInbound); drop the OS-shellout
  half (awg-quick, TPROXY policy routing, NDP proxy, peer-stats parsing).
- internal/web/service: rewire the 5 integration points (job, runtime,
  client-apply, web shutdown, xray config) from the old manager to the new
  one; the AmneziaWG log view is rebuilt on the embedded Device's own UAPI
  dump (extended to carry endpoint/AllowedIPs) instead of `awg show dump`.
- install.sh: drop DKMS/ndppd/TPROXY/Secure-Boot installer code (~250
  lines) - an entire recurring class of installer fragility goes away.
- frontend: drop the now-meaningless routeThroughXray toggle (the relay is
  always on); keep the field in the Zod schema, unexposed, so it isn't
  silently stripped from stored settings on next save - two regression
  tests deliberately depend on the Go struct still carrying it.
- docs/i18n: rewrite amneziawg.mdx for the new architecture; drop the
  dead routeThroughXray translation keys across all 13 locales.

Real production throughput (embedded core datapath, isolated bench, same
box the kernel-module path was measured on): ~296 Mbit/s up, ~640 Mbit/s
down, vs. 414.69 MB/s (~3.3 Gbit/s) for the kernel module on the same
hardware - a real gap, tempered by this being single-stream/no-SOCKS5-hop
and most VPN traffic being latency-bound rather than throughput-saturating.

* fix(amneziawg): restore the branch's own Obfuscation31 shape + 2 CodeQL findings

The previous push's wholesale-copy of types.go/params.go from the fork's
main branch pulled in that branch's own independent (and incompatible)
naming for the same AWG 3.1 feature set: Obfuscation20/GenerateObfuscation20
instead of this branch's already-shipped Obfuscation31/GenerateObfuscation31,
and a missing CanonicalizeUintRange -- broke every Go CI job (the whole
matrix fails to compile when any one package doesn't, which is why govulncheck/
golangci/postgres-durable-first/race all failed identically, not just go-test).

Restores params.go/params_test.go verbatim from this branch's own last
commit (a strict superset of validation: it already cross-checks rekey vs.
reject timing windows, which the copied version never did) and folds the
3.0/3.1 fields (HeaderProtectionKey, ContentPaddingAddition, the 5 timing
fields, RandomTrailers/DisableCookies) into Obfuscation31 itself, matching
the original struct exactly instead of as separate top-level Instance
fields. instance.go, the two amneziawgnet call sites, and 7 amneziawgnet
test files updated to match. Also drops the one test (sanitizeConfigValue)
that only ever served the retired kernel-module .conf writer -- correctly
not ported, so the test testing it shouldn't have been copied either.

Also fixes 2 CodeQL findings the same push surfaced: a clamped uint64->int64
conversion for the new log view's live byte counters (server.go), and an
unneeded len+len sum feeding a slice pre-size in the v6-egress outbound
merge (xray.go) -- append already grows correctly without it.

* chore(amneziawg): regenerate frontend schemas for updated doc comments

npm run gen was missed after the previous commit's types.go doc-comment
edits (Obfuscation20 -> Obfuscation31, ValidateHeaderProtection ->
ValidateObfuscation in the prose) -- openapigen bakes those comments
into the generated schema's description field, so the committed
frontend/src/generated/schemas.ts and openapi.json still had the old
wording. codegen's git-diff-exit-code check caught it correctly.

* fix(amneziawg): narrow 2 test fixtures that collided with MaxForwardedPorts

TestCheckForwardedPortsConflict_CollidesWithEnabledInboundPort and
..._NoCollisionWhenPortsDontOverlap used "8000-8100"/"9000-9100" as their
ForwardedPorts fixture -- 101 ports each, one over MaxForwardedPorts (100).
The cap check (checkForwardedPortsConflict, added this session alongside
the SOCKS-phantom-port check) fires first, so both tests got "more than
100 forwarded ports" instead of ever reaching the collision logic they're
actually testing. The cap itself has its own dedicated boundary test
already; these two just needed a narrower range that still covers/misses
port 8080 as intended -- 8075-8085 and 9075-9085, 11 ports each.

* fix(amneziawg): checkAmneziawgnetSocksConflict had no receiver in its new home

My merge-conflict resolution kept this as a method call (s.checkAmneziawgnetSocksConflict)
inside checkPortConflictTx, a plain function with no *InboundService receiver --
upstream's #6225 fix moved the port-conflict check out of the (s *InboundService)
method and into this new tx-scoped free function, and I didn't notice the call
site needed to change shape too. CI caught it immediately (undefined: s); nothing
in this specific package can be locally verified past internal/database's own
unrelated, pre-existing CGO build issue on this dev machine.

Since the signature had to change either way, folded in the fix already flagged
as a separate follow-up: checkAmneziawgnetSocksConflict now takes the caller's
db handle instead of fetching its own via database.GetDB(), so it actually runs
inside the same serialized transaction #6225 introduced -- previously it sat
right next to that race fix without benefiting from it.

* fix: address the review findings on the embedded AmneziaWG PR

5 blocking findings:

- Floor S3/S4 at 12 in both obfuscation generators (Go and frontend) and
  reject a hand-edited value below that when HeaderProtectionKey is set --
  IpcSet requires it, and ~39% of previously-generated sets violated it
  silently.
- Guard PrivateKey/PrimaryDNS/SecondaryDNS/remark against newline injection
  in the AmneziaWG .conf builder (both the Go subscription-link path and
  the frontend downloadable-config path) -- unguarded, any of them could
  inject an arbitrary config line into a subscriber's client.
- Bound the derived AmneziaWG SOCKS relay port to <= 65535 once an
  inbound's id is known, and check the reverse direction (does the relay
  port collide with an existing inbound's port) on both create and update
  -- previously only port -> relay collisions were checked, not relay ->
  port.
- Gate injectAmneziawgV6Egress on the same V6AliasesActive predicate
  desiredV6Aliases already uses, so the two can't disagree about whether a
  peer's IPv6 identity is actually active at the OS level.

2 minor findings:

- Fix the forwarded-ports cap check's off-by-one (a spec covering exactly
  the cap was rejected as if it were over it).
- Correct docker-compose.yml's stale comment describing the retired
  DKMS/kernel-module architecture.

* chore: retrigger CI

build (armv5) failed on a transient Go module proxy network error
(INTERNAL_ERROR stream reset on sagernet/sing), unrelated to this PR's
changes.

* docs: fix doc comments still describing the retired DKMS/awg-quick design

A few doc comments (and one illustrative test log line) survived the
embedded-architecture cutover unchanged and now contradict the code
they sit next to:

- internal/amneziawg/types.go's package comment claimed this package
  still owns a Manager that reconciles OS-level interfaces via
  awg-quick/DKMS -- that Manager was removed; the reconcile loop lives
  in internal/amneziawgnet now, and this package is protocol-shape-only.
- internal/amneziawg/params.go's ValidateObfuscation/ValidateConfigValue
  comments cited "awg-quick up" / "awg-quick executes as root" as the
  reason to validate -- the server itself never calls awg-quick in this
  architecture; the same value still reaches a real rendered .conf that
  a client app or an admin's own awg-quick CLI applies downstream, so
  the validation is still warranted, just for a different consumer.
  Mirrored the same fix in inbound_amneziawg.go's matching comment and
  its test's comment.
- internal/amneziawgnet/manager.go's Manager doc comments (x3) pointed
  readers at "internal/amneziawg.Manager" for comparison -- that type no
  longer exists in this diff at all. Repointed at internal/mtproto.Manager,
  the pattern this was actually modeled on and the one that's still real.
- Swapped one test's illustrative "awg-quick up awg2 failed" log line for
  a message shaped like this architecture's actual amneziawgnet logging,
  so a reader skimming the test doesn't wonder whether the server still
  shells out to awg-quick.

No behavior change.

* fix(docs): re-run codegen for xray-settings.mdx after conflict merge

The automated conflict-resolution hand-merge for this generated file
was content-correct but didn't byte-match a real regen (different
YAML long-string folding style). Re-ran npm run gen + docs' gen:api
and kept that canonical output instead.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* fix(amneziawg): drop the dead access-log email backfill

amneziawgEmailIndex keyed peers by "<tag>|<tunnel IP>", a scheme built
for the retired TPROXY bridge where the peer's decapsulated tunnel
address survived as the access log's from-address. The embedded
architecture relays through a loopback SOCKS5 dial, so every AmneziaWG
log line's from-address is 127.0.0.1:<ephemeral> and the lookup could
never match: the index was rebuilt on every log view just to miss.
Remove the index, its GetXrayLogs wiring and its test. If per-line
emails are wanted back, the relay would have to publish a
local-port->email registry for the viewer to resolve loopback sources.

* fix(api): generate AmneziaWGLogs/PeerActivity schemas instead of hand-writing them

The amneziawglogs endpoint's response structs were missing from
openapigen's StructAllow, so they were silently absent from every
generated schema/example, the endpoints.ts entry carried a hand-written
response, and AmneziaWGLogModal.tsx duplicated the shapes as local
interfaces - the exact drift the allowlist rule exists to prevent.
Allowlist both structs with example tags, point the endpoint at the
generated schema, import the generated types in the modal, and sync
docs/public/openapi.json.

* chore(amneziawg): drop the unreferenced quiccapture package

Nothing imports internal/amneziawg/quiccapture and no route exposes it;
its package doc justifies the code as a port of
frontend/src/lib/xray/i1Generators.ts, which does not exist in this
repository, and promises an API round-trip that also does not exist.
1,110 lines of unreachable code with misleading provenance claims.
Revert this commit to bring the package back when the live-capture I1
feature and its frontend counterpart actually land.

* fix(clients): re-run cross-inbound conflict checks on the serialized writer

The new client-level checks - cross-inbound AllowedIPs collisions and
AmneziaWG forwardedPorts conflicts - read a fresh DB snapshot, decide,
and only then enter runSerializedTx, while lockInbound only serializes
writers on the SAME inbound. Two concurrent client creates on two
different tunnel inbounds both passed the read and both committed,
yielding two peers with one address: the exact check-then-claim race
81cfd857 (#6225) closed for AddInbound, which this PR's own
checkAmneziawgnetSocksReverseConflict already cites. Keep the pre-tx
pass for fail-fast UX and re-validate inside the transaction, where the
single writer makes the answer authoritative. The race test drives two
goroutines at two inbounds and demands exactly one winner; it fails
with committed=2 when the in-tx re-check is removed.

* fix(amneziawg): hot-apply depletion disables like mtproto does

applyTrafficMutationBatch special-cases MTProto so a quota/expiry
depletion cuts the sidecar immediately, but AmneziaWG fell through to
runtime AddUser/RemoveUser - explicit no-ops for this protocol - so a
depleted peer kept tunneling until the next 10s reconcile tick. Route
it through applyLocalAmneziaWG, whose own contract (re-read committed
settings, filter depleted clients, push to the interface) is exactly
this case; the comment claiming it mirrors applyLocalMtproto is now
true for the depletion path too.

* fix(amneziawg): persist cleared DNS fields instead of resurrecting defaults

PrimaryDNS/SecondaryDNS marshaled with omitempty, so clearing them
persisted settings with no key at all - and the frontend re-parses
stored settings through a Zod schema whose .default('8.8.8.8') /
.default('8.8.4.4') fire on missing keys, silently repopulating the
form on every load and re-persisting the defaults on the next save.
Blank is a documented, meaningful state (no DNS line in client
configs); drop omitempty so a cleared value survives the round-trip.
The regression test normalizes a server block with cleared DNS and
fails when the keys are dropped.

* fix(amneziawg): accept cleared numeric obfuscation/subnet fields in the form

AntD InputNumber emits null when cleared, Zod .default() only replaces
undefined, and unlike wireguard.ts - whose optionalClearedInt comment
documents exactly this failure mode - the AmneziaWG schema declared
subnetCidr and jc/jmin/jmax/s1-s4 as bare z.number() defaults. Clearing
any of the eight fields made safeParse reject the null and block the
save until the user retyped a value. Absorb null into undefined while
keeping each field's schema default, so a cleared field refills its
documented default and legacy blobs with absent keys behave as before.

* fix(amneziawg): guard the third .conf emitter against newline injection

The review-round fix added the newline guard to amneziaWGConfigText (Go)
and buildAmneziaWGClientConfig, but genAmneziaWGConfig in inbound-link.ts
- the third of the three emitters its own comment says must not drift -
still rendered privateKey/primaryDns/secondaryDns/remark unescaped, so a
newline there injected a config line (e.g. a rogue PostUp) into the
inbound form's downloaded .conf. Add the same guard, plus the regression
tests the original fix shipped without: all four fields on the Go and
both frontend emitters go red if any guard is removed.

* test(amneziawg): pin the S3/S4 floors the TS drift guard claims to mirror

The test's docstring says it mirrors internal/amneziawg/params_test.go,
but it asserted S3>=8/S4>=4 while the Go test and both generators pin
12/12 - the floor ValidateObfuscation enforces whenever a header
protection key is set, which this generator always sets. A regression
narrowing the TS floors into 8-11/4-11 would have passed the drift
guard and produced configs the backend rejects on save.

* docs: restore the pia repo-map entry and document the AmneziaWG subsystem

Merging main dropped CLAUDE.md's internal/pia/ bullet (added by #6272)
while resolving the repo-map conflict - the package itself is untouched.
Restore it, add the missing map entries for the two packages this branch
introduces (internal/amneziawg/, internal/amneziawgnet/), bump the cron
count, and give amneziawg_job its row in architecture.md's 5.4 table.

* chore(amneziawg): correct comments stranded by the architecture pivot

ae77c7e9's cutover to the embedded gVisor path deleted the kernel-module
code but left several comments describing it in the present tense:
hot_diff.go cited the removed service.amneziawgEgressStreamSettings and
wrongly claimed AmneziaWG is the only sockopt.tproxy source (tunnel's
TProxy mode is the live one the guard protects), socks_config.go pointed
at the deleted EgressBasePort/EgressPortForInbound, manager.go referred
to the deleted Manager and its fingerprinting as live code, web.go's
cron registration claimed the job scrapes traffic (its own doc says it
does not), and types.go capped ContentPaddingAddition at uint16 when
validation and upstream both use uint32.

* style(lint): satisfy gofumpt/goimports so make verify is green

json_service.go's two 'Tag: "proxy"}' literals came in with main's own
cc245a90 formatting commit and fail the repo's gofumpt gate for everyone;
the import grouping in inbound_amneziawg.go is from the serialized-writer
fix on this branch.

---------

Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com>
Co-authored-by: Sanaei <ho3ein.sanaei@gmail.com>
Co-authored-by: claude[bot] <41898282+claude[bot]@users.noreply.github.com>
2026-08-24 02:41:15 +02:00

2253 lines
144 KiB
JSON
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
{
"username": "Tên người dùng",
"password": "Mật khẩu",
"login": "Đăng nhập",
"confirm": "Xác nhận",
"cancel": "Hủy bỏ",
"close": "Đóng",
"save": "Lưu",
"logout": "Đăng xuất",
"create": "Tạo",
"add": "Thêm",
"remove": "Xóa",
"update": "Cập nhật",
"copy": "Sao chép",
"copied": "Đã sao chép",
"more": "thêm",
"download": "Tải xuống",
"regenerate": "Tạo lại",
"jsonEditor": "Trình chỉnh sửa JSON",
"downloadImage": "Tải hình ảnh",
"sort": "Sắp xếp",
"remark": "Ghi chú",
"enable": "Kích hoạt",
"protocol": "Giao thức",
"search": "Tìm kiếm",
"filter": "Lọc",
"all": "Tất cả",
"from": "Từ",
"to": "Đến",
"done": "Xong",
"loading": "Đang tải",
"refresh": "Làm mới",
"clear": "Xóa",
"second": "Giây",
"minute": "Phút",
"hour": "Giờ",
"day": "Ngày",
"check": "Kiểm tra",
"indefinite": "Không xác định",
"unlimited": "Không giới hạn",
"none": "Không",
"qrCode": "Mã QR",
"info": "Thông tin thêm",
"edit": "Sửa",
"delete": "Xóa",
"reset": "Đặt lại",
"noData": "Không có dữ liệu.",
"copySuccess": "Đã sao chép thành công",
"sure": "Chắc chắn",
"encryption": "Mã hóa",
"transmission": "Truyền tải",
"host": "Host",
"path": "Đường dẫn",
"camouflage": "Ngụy trang",
"status": "Trạng thái",
"enabled": "Đã kích hoạt",
"disabled": "Đã tắt",
"depleted": "Depleted",
"depletingSoon": "Depleting...",
"offline": "Ngoại tuyến",
"online": "Trực tuyến",
"domainName": "Tên miền",
"monitor": "Listening IP",
"certificate": "Chứng chỉ số",
"fail": "Thất bại",
"comment": "Bình luận",
"success": "Thành công",
"lastOnline": "Lần online gần nhất",
"lastSubFetch": "Lần tải gói đăng ký gần nhất",
"getVersion": "Lấy phiên bản",
"install": "Cài đặt",
"clients": "Các khách hàng",
"usage": "Sử dụng",
"twoFactorCode": "Mã",
"remained": "Còn lại",
"security": "Bảo vệ",
"emptyDnsDesc": "Không có máy chủ DNS nào được thêm.",
"emptyFakeDnsDesc": "Không có máy chủ Fake DNS nào được thêm.",
"emptyBalancersDesc": "Không có bộ cân bằng tải nào được thêm.",
"somethingWentWrong": "Đã xảy ra lỗi",
"subscription": {
"title": "Thông tin đăng ký",
"subId": "ID đăng ký",
"status": "Trạng thái",
"downloaded": "Đã tải xuống",
"uploaded": "Đã tải lên",
"expiry": "Hết hạn",
"totalQuota": "Tổng hạn mức",
"individualLinks": "Liên kết riêng lẻ",
"active": "Hoạt động",
"inactive": "Không hoạt động",
"unlimited": "Không giới hạn",
"noExpiry": "Không hết hạn",
"copyAllConfigs": "Sao chép tất cả cấu hình",
"copyAllConfigsCopied": "Đã sao chép tất cả cấu hình",
"email": "Email"
},
"menu": {
"theme": "Chủ đề",
"dashboard": "Trạng thái hệ thống",
"inbounds": "Inbound",
"clients": "Khách hàng",
"groups": "Nhóm",
"nodes": "Nút",
"settings": "Cài đặt bảng điều khiển",
"xray": "Cấu hình Xray",
"routing": "Định tuyến",
"outbounds": "Outbound",
"apiDocs": "Tài liệu API",
"donate": "Quyên góp",
"hosts": "Hosts",
"docs": "Tài liệu",
"openMenu": "Mở menu",
"pinSidebar": "Ghim thanh bên",
"unpinSidebar": "Bỏ ghim thanh bên",
"subFormats": "Sub Formats"
},
"pages": {
"login": {
"hello": "Xin chào",
"title": "Chào mừng",
"loginAgain": "Thời hạn đăng nhập đã hết. Vui lòng đăng nhập lại.",
"toasts": {
"invalidFormData": "Dạng dữ liệu nhập không hợp lệ.",
"emptyUsername": "Vui lòng nhập tên người dùng.",
"emptyPassword": "Vui lòng nhập mật khẩu.",
"wrongUsernameOrPassword": "Tên người dùng, mật khẩu hoặc mã xác thực hai yếu tố không hợp lệ.",
"successLogin": "Bạn đã đăng nhập vào tài khoản thành công."
}
},
"index": {
"cpu": "CPU",
"swap": "Swap",
"storage": "Lưu trữ",
"memory": "Bộ nhớ",
"xrayStatus": "Xray",
"stopXray": "Dừng",
"restartXray": "Khởi động lại",
"xraySwitch": "Phiên bản",
"xrayUpdates": "Cập nhật Xray",
"xraySwitchClickDesk": "Hãy lựa chọn thận trọng, vì các phiên bản cũ có thể không tương thích với các cấu hình hiện tại.",
"updatePanel": "Cập nhật Panel",
"panelUpdateDesc": "Điều này sẽ cập nhật 3X-UI lên bản phát hành mới nhất và khởi động lại dịch vụ panel.",
"currentPanelVersion": "Phiên bản panel hiện tại",
"latestPanelVersion": "Phiên bản panel mới nhất",
"panelUpToDate": "Panel đã được cập nhật",
"devChannel": "Kênh phát triển",
"devChannelWarning": "Bản dev bám theo từng commit trên main và không phải bản ổn định — không có hạ cấp tự động.",
"currentCommit": "Commit hiện tại",
"latestCommit": "Commit mới nhất",
"updateChannelChanged": "Đã đổi kênh cập nhật",
"xrayStatusUnknown": "Không xác định",
"xrayStatusRunning": "Đang chạy",
"xrayStatusStop": "Dừng",
"xrayStatusError": "Lỗi",
"systemHistoryTitle": "Lịch sử hệ thống",
"historyTitleCpu": "Mức sử dụng CPU",
"historyTitleMem": "Mức sử dụng bộ nhớ",
"historyTitleNetwork": "Băng thông mạng",
"historyTitlePackets": "Gói tin mạng",
"historyTitleDisk": "I/O đĩa",
"historyTitleOnline": "Máy khách trực tuyến",
"historyTitleLoad": "Tải trung bình hệ thống (1 / 5 / 15 phút)",
"historyTitleConnections": "Kết nối đang hoạt động (TCP / UDP)",
"historyTitleDiskUsage": "Sử dụng dung lượng đĩa",
"historyTabBandwidth": "Băng thông",
"historyTabPackets": "Gói tin",
"historyTabDisk": "Đĩa I/O",
"historyTabOnline": "Trực tuyến",
"historyTabLoad": "Tải",
"historyTabConnections": "Kết nối",
"historyTabDiskUsage": "Sử dụng đĩa",
"xrayMetricsTitle": "Chỉ số Xray",
"xrayTitleHeap": "Bộ nhớ Heap đã cấp phát",
"xrayTitleSys": "Bộ nhớ dành riêng từ HĐH",
"xrayTitleObjects": "Đối tượng Heap đang hoạt động",
"xrayTitleGcCount": "Chu kỳ GC đã hoàn thành",
"xrayTitleGcPause": "Thời lượng tạm dừng GC",
"xrayTitleObservatory": "Tình trạng kết nối đi",
"xrayTabHeap": "Heap",
"xrayTabSys": "Sys",
"xrayTabObjects": "Đối tượng",
"xrayTabGcCount": "Số lần GC",
"xrayTabGcPause": "Tạm dừng GC",
"xrayTabObservatory": "Đài quan sát",
"xrayMetricsDisabled": "Điểm cuối chỉ số Xray chưa được cấu hình",
"xrayMetricsHint": "Thêm khối metrics cấp cao nhất vào cấu hình xray với tag là metrics_out và listen là 127.0.0.1:11111, sau đó khởi động lại xray.",
"xrayObservatoryEmpty": "Chưa có dữ liệu Observatory",
"xrayObservatoryHint": "Thêm khối observatory vào cấu hình xray liệt kê các tag outbound cần kiểm tra, sau đó khởi động lại xray.",
"xrayObservatoryTagPlaceholder": "Chọn outbound",
"xrayObservatoryAlive": "Hoạt động",
"xrayObservatoryDead": "Ngừng",
"xrayObservatoryLastSeen": "Lần cuối thấy",
"xrayObservatoryLastTry": "Lần thử cuối",
"connectionCount": "Số lượng kết nối",
"ipAddresses": "Địa chỉ IP",
"toggleIpVisibility": "Chuyển đổi hiển thị IP",
"overallSpeed": "Tốc độ tổng thể",
"upload": "Tải lên",
"download": "Tải xuống",
"sent": "Đã gửi",
"received": "Đã nhận",
"xraySwitchVersionDialog": "Bạn có chắc chắn muốn thay đổi phiên bản Xray không?",
"xraySwitchVersionDialogDesc": "Hành động này sẽ thay đổi phiên bản Xray thành #version#.",
"xraySwitchVersionPopover": "Xray đã được cập nhật thành công",
"panelUpdateDialog": "Bạn có chắc muốn cập nhật panel không?",
"panelUpdateDialogDesc": "Điều này sẽ cập nhật 3X-UI lên #version# và khởi động lại dịch vụ panel.",
"panelUpdateStartedPopover": "Bắt đầu cập nhật panel",
"panelUpdateFailedTitle": "Cập nhật panel thất bại",
"panelUpdateFailedDesc": "Bản cập nhật không hoàn tất thành công. Hãy kiểm tra nhật ký máy chủ, hoặc chạy 'x-ui update' từ dòng lệnh.",
"panelUpdateUnknownTitle": "Không thể xác nhận việc cập nhật đã hoàn tất",
"panelUpdateUnknownDesc": "Panel không báo cáo kết quả kịp thời. Hãy tải lại trang để kiểm tra phiên bản hiện tại, hoặc kiểm tra nhật ký máy chủ.",
"geofileUpdateDialog": "Bạn có chắc chắn muốn cập nhật geofile không?",
"geofileUpdateDialogDesc": "Hành động này sẽ cập nhật tệp #filename#.",
"geofilesUpdateDialogDesc": "Thao tác này sẽ cập nhật tất cả các tập tin.",
"geofilesUpdateAll": "Cập nhật tất cả",
"geofileUpdatePopover": "Geofile đã được cập nhật thành công",
"geodataTitle": "Tự động cập nhật Geodata",
"geodataHint": "Xray tải các tệp này theo lịch và nạp lại nóng mà không cần khởi động lại. URL phải là HTTPS. Mỗi tệp phải tồn tại sẵn trong thư mục bin thì Xray mới có thể cập nhật.",
"geodataCron": "Lịch cập nhật (cron)",
"geodataOutbound": "Tải qua outbound (tùy chọn)",
"geodataFile": "Tên tệp",
"geodataAddFile": "Thêm tệp",
"geodataSaveRestart": "Lưu và khởi động lại Xray",
"geodataConfirmTitle": "Lưu cài đặt geodata?",
"geodataConfirmContent": "Mẫu cấu hình Xray sẽ được cập nhật và Xray sẽ khởi động lại.",
"geodataInvalidUrl": "Mỗi tệp cần một URL HTTPS.",
"geodataInvalidFile": "Tên tệp phải là tên đơn giản, ví dụ geosite_custom.dat (không chứa đường dẫn).",
"geodataInvalidCron": "Cron phải có 5 trường, ví dụ 0 4 * * *",
"geodataEmpty": "Chưa cấu hình tệp nào. Trong quy tắc định tuyến, tham chiếu tệp dạng ext:geosite_custom.dat:category.",
"dontRefresh": "Đang tiến hành cài đặt, vui lòng không làm mới trang này.",
"logs": "Nhật ký",
"accessLogs": "Nhật ký truy cập",
"autoUpdate": "Tự động cập nhật",
"amneziawgLogs": "Nhật ký AmneziaWG",
"amneziawgHandshake": "Bắt tay gần nhất",
"amneziawgInterface": "Giao diện mạng",
"amneziawgInbound": "Inbound",
"amneziawgEndpoint": "Điểm cuối",
"amneziawgIdle": "Nhàn rỗi",
"amneziawgEvents": "Sự kiện",
"amneziawgNoPeers": "Hiện không có peer AmneziaWG nào hoạt động",
"amneziawgNoEvents": "Chưa ghi nhận sự kiện AmneziaWG nào",
"config": "Cấu hình",
"backupTitle": "Sao lưu & Khôi phục",
"exportDatabase": "Sao lưu",
"exportDatabaseDesc": "Nhấp để tải xuống tệp .db chứa bản sao lưu cơ sở dữ liệu hiện tại của bạn vào thiết bị. Tệp này cũng có thể được khôi phục vào bảng điều khiển chạy PostgreSQL.",
"importDatabase": "Khôi phục",
"importDatabaseDesc": "Nhấp để chọn và tải lên bản sao lưu .db hoặc tệp kết xuất di trú (.dump) từ thiết bị của bạn để khôi phục cơ sở dữ liệu.",
"importDatabaseSuccess": "Đã nhập cơ sở dữ liệu thành công",
"importDatabaseError": "Lỗi xảy ra khi nhập cơ sở dữ liệu",
"readDatabaseError": "Lỗi xảy ra khi đọc cơ sở dữ liệu",
"getDatabaseError": "Lỗi xảy ra khi truy xuất cơ sở dữ liệu",
"getConfigError": "Lỗi xảy ra khi truy xuất tệp cấu hình",
"backupPostgresNote": "Bảng điều khiển này chạy trên PostgreSQL. «Sao lưu» tải xuống một tệp lưu trữ pg_dump (.dump) và «Khôi phục» nạp lại bằng pg_restore. «Khôi phục» cũng chấp nhận cơ sở dữ liệu SQLite (.db) hoặc tệp kết xuất di trú SQLite và nhập dữ liệu của chúng vào PostgreSQL. Máy chủ cần cài đặt các công cụ máy khách PostgreSQL (pg_dump và pg_restore).",
"exportDatabasePgDesc": "Nhấn để tải xuống bản kết xuất PostgreSQL (.dump) của cơ sở dữ liệu hiện tại về thiết bị của bạn.",
"importDatabasePgDesc": "Nhấn để chọn và tải lên bản sao lưu PostgreSQL (.dump), cơ sở dữ liệu SQLite (.db) hoặc tệp kết xuất di trú SQLite nhằm khôi phục cơ sở dữ liệu của bạn. Thao tác này sẽ thay thế toàn bộ dữ liệu hiện tại.",
"migrationDownload": "Tải tệp di trú",
"migrationDownloadPgDesc": "Nhấp để tải xuống cơ sở dữ liệu SQLite .db được tạo từ dữ liệu PostgreSQL của bạn, sẵn sàng chạy bảng điều khiển này trên SQLite.",
"avg": "TB",
"peak": "đỉnh",
"free": "trống",
"openSockets": "socket đang mở",
"throughputSub": "Tổng theo giao diện mạng",
"avgWindow": "Trung bình trong khoảng",
"healthWarm": "{list} — đang cao",
"healthCritical": "{list} — nguy cấp",
"panel": "Panel",
"threads": "Luồng",
"uptime": "Thời gian chạy",
"logLevelDebug": "Debug",
"logLevelInfo": "Info",
"logLevelNotice": "Notice",
"logLevelWarning": "Warning",
"logLevelError": "Error",
"accessDirect": "DIRECT",
"accessBlocked": "BLOCKED",
"accessProxy": "PROXY",
"importKeepHostSettings": "Giữ cài đặt của máy này",
"importKeepHostSettingsDesc": "Giữ nguyên địa chỉ lắng nghe, cổng, đường dẫn cơ sở, chứng chỉ và danh tính node của bảng điều khiển này thay vì lấy chúng từ tệp đã tải lên."
},
"inbounds": {
"totalDownUp": "Tổng tải lên/tải xuống",
"totalUsage": "Tổng sử dụng",
"inboundCount": "Số lượng điểm vào",
"operate": "Menu",
"enable": "Kích hoạt",
"remark": "Chú thích",
"node": "Node",
"deployTo": "Triển khai tới",
"localPanel": "Panel cục bộ",
"fallbacks": {
"title": "Fallbacks",
"empty": "Chưa có fallback nào",
"add": "Thêm fallback",
"pickInbound": "Chọn một inbound",
"matchAny": "bất kỳ",
"destPlaceholder": "tự động (listen:port của child)",
"needsTls": "Fallback khả dụng sau khi chọn TLS hoặc Reality trong thẻ Bảo mật (chỉ VLESS/Trojan trên RAW)."
},
"protocol": "Giao thức",
"port": "Cổng",
"portMap": "Ánh xạ cổng",
"traffic": "Lưu lượng",
"speed": "Tốc độ",
"expireDate": "Ngày hết hạn",
"createdAt": "Tạo lúc",
"updatedAt": "Cập nhật",
"resetTraffic": "Đặt lại lưu lượng",
"addInbound": "Thêm điểm vào",
"generalActions": "Hành động chung",
"modifyInbound": "Chỉnh sửa điểm vào (Inbound)",
"deleteConfirmTitle": "Xóa inbound \"{remark}\"?",
"deleteConfirmContent": "Hành động này xóa inbound và toàn bộ khách hàng của nó. Không thể hoàn tác.",
"resetConfirmTitle": "Đặt lại lưu lượng của \"{remark}\"?",
"resetConfirmContent": "Đặt lại bộ đếm lên/xuống về 0 cho inbound này.",
"selectedCount": "Đã chọn {count}",
"selectAll": "Chọn tất cả",
"bulkDeleteConfirmTitle": "Xóa {count} inbound?",
"bulkDeleteConfirmContent": "Hành động này xóa các inbound đã chọn và toàn bộ khách hàng của chúng. Không thể hoàn tác.",
"cloneConfirmTitle": "Sao chép inbound \"{remark}\"?",
"cloneConfirmContent": "Tạo bản sao với cổng mới và danh sách khách hàng trống.",
"delAllClients": "Xóa tất cả khách hàng",
"delAllClientsConfirmTitle": "Xóa toàn bộ {count} khách hàng khỏi \"{remark}\"?",
"delAllClientsConfirmContent": "Xóa mọi khách hàng khỏi inbound này và hủy bản ghi lưu lượng của họ. Bản thân inbound vẫn được giữ lại. Hành động này không thể hoàn tác.",
"attachClients": "Gắn client vào…",
"addClientsToGroup": "Thêm client vào nhóm…",
"attachClientsTitle": "Gắn client từ «{remark}»",
"attachClientsDesc": "Gắn cùng {count} client (cùng UUID/mật khẩu và lưu lượng chung) vào các inbound đã chọn. Họ vẫn ở trên inbound này.",
"attachClientsTargets": "Inbound đích",
"attachClientsNoTargets": "Không có inbound tương thích khác để gắn.",
"attachClientsResult": "Đã gắn {attached}, bỏ qua {skipped}.",
"attachClientsResultMixed": "Đã gắn {attached}, bỏ qua {skipped}, lỗi {errors}.",
"attachClientsSelectLabel": "Client để gắn",
"attachClientsSearchPlaceholder": "Tìm email hoặc ghi chú",
"attachClientsStatusDisabled": "Đã tắt",
"attachClientsSelectedCount": "Đã chọn {selected}/{total}",
"attachExistingClients": "Gắn client hiện có…",
"attachExistingTitle": "Gắn client hiện có vào «{remark}»",
"attachExistingDesc": "Gắn các client hiện có ({count} khả dụng) vào inbound này — cùng UUID/mật khẩu và lưu lượng chung. Các client đã có trên inbound sẽ được bỏ qua.",
"attachExistingNoClients": "Chưa có client nào. Hãy tạo client trước, rồi gắn vào đây.",
"attachExistingStatusAttached": "Đã gắn",
"detachClients": "Tách client",
"detachClientsTitle": "Tách client của «{remark}»",
"detachClientsDesc": "Chỉ xóa client đã chọn khỏi inbound này. Hồ sơ client được giữ lại (dùng Delete để xóa hoàn toàn). Nguồn có tổng cộng {count} client.",
"detachClientsResult": "Đã tách {detached}, bỏ qua {skipped}.",
"detachClientsResultMixed": "Đã tách {detached}, bỏ qua {skipped}, lỗi {errors}.",
"detachClientsSelectLabel": "Client để tách",
"exportLinksTitle": "Xuất liên kết inbound",
"exportSubsTitle": "Xuất liên kết đăng ký",
"exportAllLinksTitle": "Xuất tất cả liên kết inbound",
"exportAllSubsTitle": "Xuất tất cả liên kết đăng ký",
"exportAllLinksFileName": "Tat-ca-Inbound",
"exportAllSubsFileName": "Tat-ca-Inbound-Subs",
"inboundJsonTitle": "JSON inbound",
"resetTrafficContent": "Xác nhận đặt lại lưu lượng?",
"copyLink": "Sao chép liên kết",
"address": "Địa chỉ",
"network": "Mạng",
"destinationPort": "Cổng đích",
"targetAddress": "Địa chỉ mục tiêu",
"monitorDesc": "Mặc định để trống",
"meansNoLimit": "= Không giới hạn. (đơn vị: GB)",
"totalFlow": "Tổng lưu lượng",
"leaveBlankToNeverExpire": "Để trống để không bao giờ hết hạn",
"certificatePath": "Đường dẫn tập",
"certificateContent": "Nội dung tập",
"publicKey": "Khóa công khai",
"privatekey": "Khóa cá nhân",
"client": "Người dùng",
"export": "Xuất liên kết",
"clone": "Sao chép",
"resetAllTraffic": "Đặt lại lưu lượng cho tất cả điểm vào",
"resetAllTrafficTitle": "Đặt lại lưu lượng cho tất cả điểm vào",
"resetAllTrafficContent": "Bạn có chắc chắn muốn đặt lại lưu lượng cho tất cả điểm vào không?",
"email": "Email",
"IPLimit": "Giới hạn IP",
"IPLimitlog": "Lịch sử IP",
"IPLimitlogclear": "Xóa Lịch sử",
"setDefaultCert": "Đặt chứng chỉ từ bảng điều khiển",
"setDefaultCertEmpty": "Không có chứng chỉ nào được cấu hình cho bảng điều khiển. Hãy đặt một chứng chỉ trong Cài đặt trước.",
"streamTab": "Luồng",
"securityTab": "Bảo mật",
"sniffingTab": "Dò gói",
"sniffingMetadataOnly": "Chỉ siêu dữ liệu",
"sniffingRouteOnly": "Chỉ định tuyến",
"sniffingIpsExcluded": "IP bị loại trừ",
"sniffingDomainsExcluded": "Tên miền bị loại trừ",
"decryption": "Giải mã",
"encryption": "Mã hóa",
"vlessAuthX25519": "X25519 (native)",
"vlessAuthMlkem768": "ML-KEM-768 (native)",
"vlessAuthX25519Xorpub": "X25519 (xorpub)",
"vlessAuthX25519Random": "X25519 (random)",
"vlessAuthMlkem768Xorpub": "ML-KEM-768 (xorpub)",
"vlessAuthMlkem768Random": "ML-KEM-768 (random)",
"vlessAuthCustom": "Tùy chỉnh",
"vlessAuthSelected": "Đã chọn: {auth}",
"vlessAuthGenerate": "Tạo khóa",
"vlessAuthGenerateButton": "Tạo",
"advanced": {
"title": "Các phần JSON của inbound",
"subtitle": "JSON inbound đầy đủ và các trình chỉnh sửa riêng cho settings, sniffing và streamSettings.",
"all": "Tất cả",
"allHelp": "Đối tượng inbound đầy đủ với mọi trường trong một trình chỉnh sửa.",
"settings": "Cài đặt",
"settingsHelp": "Bao đóng khối settings của Xray:",
"sniffing": "Sniffing",
"sniffingHelp": "Bao đóng khối sniffing của Xray:",
"stream": "Stream",
"streamHelp": "Bao đóng khối stream của Xray:"
},
"subSortIndex": "Thứ tự sub",
"inboundInfo": "Thông tin Inbound",
"exportInbound": "Xuất nhập khẩu",
"import": "Nhập",
"importInbound": "Nhập inbound",
"periodicTrafficResetTitle": "Đặt lại lưu lượng",
"periodicTrafficResetDay": "Ngày đặt lại hàng tháng",
"periodicTrafficReset": {
"never": "Không bao giờ",
"daily": "Hàng ngày",
"weekly": "Hàng tuần",
"monthly": "Hàng tháng",
"hourly": "Hàng giờ"
},
"toasts": {
"obtain": "Nhận",
"updateSuccess": "Cập nhật thành công",
"logCleanSuccess": "Đã xóa nhật ký",
"inboundUpdateSuccess": "Đã cập nhật thành công kết nối inbound",
"inboundCreateSuccess": "Đã tạo thành công kết nối inbound",
"bulkDeleted": "Đã xóa {count} inbound",
"bulkDeletedMixed": "Đã xóa {ok}, thất bại {failed}",
"clonedMany": "Đã nhân bản {count} inbound",
"clonedMixed": "Đã nhân bản {ok}, thất bại {failed}",
"inboundDeleteSuccess": "Đã xóa thành công kết nối inbound",
"inboundClientAddSuccess": "Đã thêm client inbound",
"inboundClientDeleteSuccess": "Đã xóa client inbound",
"inboundClientUpdateSuccess": "Đã cập nhật client inbound",
"savedNodeOfflineWillSync": "Đã lưu cục bộ. Một nút hỗ trợ đang ngoại tuyến hoặc bị tắt — thay đổi sẽ được đồng bộ khi kết nối lại.",
"resetAllClientTrafficSuccess": "Đã đặt lại toàn bộ lưu lượng client",
"resetAllTrafficSuccess": "Đã đặt lại toàn bộ lưu lượng",
"resetInboundClientTrafficSuccess": "Đã đặt lại lưu lượng",
"resetInboundTrafficSuccess": "Đã đặt lại lưu lượng Inbound",
"trafficGetError": "Lỗi khi lấy thông tin lưu lượng",
"getNewX25519CertError": "Lỗi khi lấy chứng chỉ X25519.",
"getNewmldsa65Error": "Lỗi khi lấy chứng chỉ mldsa65.",
"getNewVlessEncError": "Lỗi khi lấy chứng chỉ VlessEnc.",
"scanRealityTargetError": "Quét mục tiêu REALITY thất bại.",
"scanRealityTargetFeasible": "Mục tiêu khả dụng — đã điền mục tiêu và SNI.",
"scanRealityTargetNotFeasible": "Mục tiêu có thể truy cập nhưng không khả dụng cho REALITY.",
"scanRealityTargetPrivate": "Đích hoạt động nhưng nằm trong mạng riêng/nội bộ.",
"invalidClientField": "Khách hàng {client}: trường {field} — {reason}",
"invalidField": "{field} — {reason}",
"moreIssues": "{message} (+{count} lỗi khác)"
},
"form": {
"echSockopt": "ECH Sockopt",
"echSockoptTip": "Tùy chọn socket cho kết nối mà Xray dùng để lấy danh sách cấu hình ECH (ví dụ định tuyến truy vấn qua một outbound dialerProxy). Để tắt để dùng giá trị mặc định.",
"curvePreferences": "Ưu tiên đường cong",
"curvePreferencesTip": "Giới hạn các đường cong trao đổi khóa TLS mà máy chủ cung cấp, theo thứ tự ưu tiên (ví dụ X25519MLKEM768, X25519). Để trống để dùng giá trị mặc định của Xray-core.",
"masterKeyLog": "Nhật ký khóa chính",
"masterKeyLogTip": "Đường dẫn để ghi các khóa chính TLS (định dạng SSLKEYLOGFILE) phục vụ gỡ lỗi bằng Wireshark. Để trống khi chạy thực tế — vì ai có tệp này đều có thể giải mã lưu lượng.",
"verifyPeerCertByName": "Xác minh chứng chỉ peer theo tên",
"verifyPeerCertByNameTip": "Yêu cầu máy khách xác minh chứng chỉ máy chủ theo tên này thay vì theo SNI. Các tên cách nhau bằng dấu phẩy. Chỉ dùng trong bảng điều khiển — được đính kèm trong link chia sẻ (vcn). Đây là giải pháp thay thế hiện đại cho allowInsecure, vốn đã bị Xray gỡ bỏ sau 2026-06-01.",
"pinFromCert": "Điền từ chứng chỉ của inbound này",
"pinFromRemote": "Lấy hash bằng cách ping SNI (xray tls ping)",
"pinFromRemoteNoSni": "Hãy đặt SNI (serverName) trước để ping chứng chỉ từ xa.",
"pinFromRemoteFailed": "Không thể lấy hash chứng chỉ từ xa.",
"limitFallback": "Giới hạn fallback",
"limitFallbackUpload": "Giới hạn fallback tải lên",
"limitFallbackDownload": "Giới hạn fallback tải xuống",
"afterBytes": "Sau số byte",
"afterBytesTip": "Cho phép fallback chạy hết tốc độ trong bấy nhiêu byte này, sau đó mới bắt đầu giới hạn. 0 = giới hạn ngay từ byte đầu tiên.",
"bytesPerSec": "Byte mỗi giây",
"bytesPerSecTip": "Giới hạn tốc độ (byte/giây) áp dụng cho lưu lượng fallback sau ngưỡng, để các đầu dò không thể dùng máy chủ của bạn làm băng thông miễn phí tới đích. 0 = không giới hạn (tắt hướng này).",
"burstBytesPerSec": "Byte bùng phát mỗi giây",
"burstBytesPerSecTip": "Mức cho phép các đợt bùng phát ngắn vượt tốc độ ổn định (kích thước token-bucket). Nếu thấp hơn Byte mỗi giây thì sẽ được nâng lên cho khớp.",
"moveUp": "Lên",
"moveDown": "Xuống",
"addAll": "Thêm tất cả",
"addAllFallbackTooltip": "Thêm hàng fallback cho mỗi inbound đủ điều kiện chưa được nối",
"peers": "Peers",
"addPeer": "Thêm peer",
"keepAlive": "Keep-alive",
"autoSystemRoutesTooltip": "Chỉ Windows. CIDR được tự động thêm vào bảng định tuyến hệ thống để lưu lượng khớp đi qua TUN.",
"autoOutboundsInterface": "Giao diện outbound tự động",
"autoOutboundsInterfaceTooltip": "Giao diện vật lý cho lưu lượng đi. Dùng 'auto' để tự phát hiện; tự bật khi Auto system routes được đặt.",
"rewriteAddress": "Viết lại địa chỉ",
"rewritePort": "Viết lại cổng",
"allowedNetwork": "Mạng cho phép",
"followRedirect": "Theo redirect",
"accounts": "Tài khoản",
"allowTransparent": "Cho phép trong suốt",
"encryptionMethod": "Phương thức mã hóa",
"fakeTlsDomain": "Tên miền FakeTLS (SNI)",
"mtprotoSecret": "Khóa bí mật",
"mtgDomainFrontingIp": "IP domain fronting",
"mtgDomainFrontingPort": "Cổng domain fronting",
"mtgDomainFrontingProxyProtocol": "Giao thức PROXY domain fronting",
"mtgDomainFrontingHint": "Nơi mtg gửi lưu lượng không phải Telegram — ví dụ trang web giả NGINX của bạn. Để trống IP để dùng tên miền FakeTLS qua DNS; cổng mặc định là 443.",
"mtgProxyProtocolListener": "Chấp nhận giao thức PROXY (trình lắng nghe)",
"mtgPreferIp": "Ưu tiên IP",
"mtgDebug": "Nhật ký gỡ lỗi",
"mtgRouteThroughXray": "Định tuyến qua Xray",
"mtgRouteThroughXrayHint": "Gửi lưu lượng Telegram của proxy này qua Xray để tuân theo các quy tắc định tuyến của bạn. Tiến trình phụ mtg đi ra qua một cầu SOCKS loopback mang thẻ của inbound này; tham chiếu thẻ đó trong tab Định tuyến cho các quy tắc nâng cao.",
"mtgRouteOutbound": "Outbound",
"mtgRouteOutboundHint": "Tùy chọn. Buộc lưu lượng Telegram đi ra qua outbound (hoặc bộ cân bằng) này. Để trống để các quy tắc định tuyến của bạn quyết định.",
"mtgRouteOutboundPlaceholder": "Dùng quy tắc định tuyến",
"mtprotoFakeTlsDomainHint": "Tên miền FakeTLS mặc định dùng để tạo secret cho client mới. Mỗi client có thể dùng tên miền riêng.",
"mtgThrottleMaxConnections": "Số kết nối tối đa",
"mtgThrottleMaxConnectionsHint": "Giới hạn kết nối đồng thời của tất cả người dùng theo phân bổ công bằng. 0 để tắt.",
"mtgAdTagInvalid": "Ad-tag phải có đúng 32 ký tự thập lục phân.",
"mtgPublicIpv4": "IPv4 công khai",
"mtgPublicIpv6": "IPv6 công khai",
"mtgPublicIpHint": "Địa chỉ công khai có thể truy cập của máy chủ này, được proxy trung gian ad-tag sử dụng. Để trống để mtg tự phát hiện.",
"visionTestseed": "Vision testseed",
"version": "Phiên bản",
"udpIdleTimeout": "UDP idle timeout (s)",
"masquerade": "Masquerade",
"type": "Loại",
"upstreamUrl": "Upstream URL",
"rewriteHost": "Viết lại Host",
"skipTlsVerify": "Bỏ qua xác minh TLS",
"directory": "Thư mục",
"statusCode": "Mã trạng thái",
"body": "Body",
"headers": "Header",
"proxyProtocol": "Proxy Protocol",
"requestVersion": "Phiên bản yêu cầu",
"requestMethod": "Phương thức yêu cầu",
"requestPath": "Đường dẫn yêu cầu",
"requestHeaders": "Header yêu cầu",
"responseVersion": "Phiên bản phản hồi",
"responseStatus": "Trạng thái phản hồi",
"responseReason": "Lý do phản hồi",
"responseHeaders": "Header phản hồi",
"heartbeatPeriod": "Chu kỳ heartbeat",
"serviceName": "Tên dịch vụ",
"authority": "Authority",
"multiMode": "Multi Mode",
"maxBufferedUpload": "Upload buffered tối đa",
"maxUploadSize": "Kích thước upload tối đa (Byte)",
"streamUpServer": "Stream-Up Server",
"serverMaxHeaderBytes": "Byte header máy chủ tối đa",
"paddingBytes": "Byte Padding",
"uplinkHttpMethod": "Uplink HTTP method",
"paddingObfsMode": "Chế độ obfs Padding",
"paddingKey": "Padding Key",
"paddingHeader": "Padding Header",
"paddingPlacement": "Vị trí Padding",
"paddingMethod": "Phương thức Padding",
"sessionPlacement": "Session Placement",
"sessionKey": "Session Key",
"sessionIDTable": "Bảng Session ID",
"sessionIDTableHint": "Tập ký tự để tạo session ID: một tên định sẵn (ALPHABET, Base62, hex, number, …) hoặc chuỗi ASCII. Để trống để dùng mặc định của xray-core.",
"sessionIDLength": "Độ dài Session ID",
"sessionIDLengthHint": "Độ dài hoặc khoảng (ví dụ 8-16) của session ID được tạo. Chỉ dùng khi đã đặt Bảng Session ID; giá trị nhỏ nhất phải lớn hơn 0.",
"sequencePlacement": "Sequence Placement",
"sequenceKey": "Sequence Key",
"uplinkDataPlacement": "Uplink Data Placement",
"uplinkDataKey": "Uplink Data Key",
"noSseHeader": "Không có header SSE",
"ttiMs": "TTI (ms)",
"uplinkMbps": "Uplink (MB/s)",
"downlinkMbps": "Downlink (MB/s)",
"cwndMultiplier": "Hệ số CWND",
"maxSendingWindow": "Cửa sổ gửi tối đa",
"externalProxy": "Proxy ngoài",
"forceTls": "Bắt buộc TLS",
"fingerprint": "Fingerprint",
"defaultOption": "Mặc định",
"routeMark": "Route Mark",
"tcpKeepAliveInterval": "TCP Keep Alive Interval",
"tcpKeepAliveIdle": "TCP Keep Alive Idle",
"tcpMaxSeg": "TCP Max Seg",
"tcpUserTimeout": "TCP User Timeout",
"tcpWindowClamp": "TCP Window Clamp",
"tcpWindowClampHint": "Để 0 để dùng mặc định của hệ điều hành. Giá trị khác 0 sẽ giới hạn cửa sổ nhận TCP được quảng bá; các giá trị như 600 (theo ví dụ tài liệu Xray) có thể làm sụp thông lượng trên các liên kết độ trễ cao.",
"tcpFastOpen": "TCP Fast Open",
"multipathTcp": "Multipath TCP",
"penetrate": "Penetrate",
"v6Only": "Chỉ V6",
"tcpCongestion": "TCP Congestion",
"dialerProxy": "Dialer Proxy",
"trustedXForwardedFor": "X-Forwarded-For tin cậy",
"trustedXForwardedForHint": "Tin cậy header yêu cầu này để lấy IP thật của client (ví dụ CF-Connecting-IP phía sau CDN của Cloudflare). Chỉ có hiệu lực trên các transport WebSocket, HTTPUpgrade, XHTTP và gRPC. Để trống để bỏ qua các header chuyển tiếp.",
"proxyProtocolHint": "Chấp nhận header PROXY protocol để lấy IP thật của client từ tunnel/relay L4 phía trên (HAProxy, gost, nginx-stream, Xray dokodemo-door) hoặc Cloudflare Spectrum. Phía trên PHẢI gửi PROXY protocol. Hoạt động trên TCP, WebSocket, HTTPUpgrade và gRPC; không hoạt động trên mKCP.",
"realClientIp": "IP thật của client",
"realClientIpHint": "Lấy IP thật của khách khi lưu lượng đến inbound này qua CDN hoặc relay, thay vì ghi lại địa chỉ của trung gian. Chọn một preset để tự điền các trường sockopt tương ứng bên dưới. Các trường này không bao giờ được gửi đến client trong subscription.",
"realClientIpPresetOff": "Tắt / trực tiếp",
"realClientIpPresetCloudflare": "Cloudflare CDN",
"realClientIpPresetProxyProtocol": "Relay L4 / Spectrum (PROXY)",
"realClientIpTrustedHeaderTransportWarn": "Trusted X-Forwarded-For chỉ có hiệu lực trên WebSocket, HTTPUpgrade và XHTTP. Trên transport hiện tại header này bị bỏ qua.",
"realClientIpProxyProtocolTransportWarn": "PROXY protocol không được hỗ trợ trên transport này (mKCP). Hãy dùng TCP/RAW, WebSocket, HTTPUpgrade, gRPC hoặc XHTTP.",
"addressPortStrategy": "Chiến lược địa chỉ+cổng",
"tryDelayMs": "Độ trễ thử (ms)",
"prioritizeIPv6": "Ưu tiên IPv6",
"interleave": "Interleave",
"maxConcurrentTry": "Số thử đồng thời tối đa",
"customSockopt": "Sockopt tùy chỉnh",
"addCustomOption": "Thêm tùy chọn",
"serverNameIndication": "SNI",
"cipherSuites": "Cipher Suites",
"autoOption": "Tự động",
"minMaxVersion": "Phiên bản Min/Max",
"rejectUnknownSni": "Từ chối SNI lạ",
"disableSystemRoot": "Tắt System Root",
"sessionResumption": "Khôi phục phiên",
"oneTimeLoading": "Tải một lần",
"usageOption": "Tùy chọn sử dụng",
"buildChain": "Tạo chuỗi",
"echKey": "ECH key",
"echConfig": "Cấu hình ECH",
"pinnedPeerCertSha256": "SHA-256 chứng chỉ peer đã ghim",
"pinnedPeerCertSha256Tip": "Hash SHA-256 của chứng chỉ peer dưới dạng chuỗi thập lục phân (vd. e8e2d3…), phân tách bằng dấu phẩy. Chỉ panel — không ghi vào cấu hình xray máy chủ, nhưng được đưa vào liên kết chia sẻ để client có thể ghim chứng chỉ.",
"pinnedPeerCertSha256Placeholder": "hash thập lục phân, phân tách bằng dấu phẩy",
"getNewEchCert": "Lấy chứng chỉ ECH mới",
"show": "Hiện",
"xver": "Xver",
"target": "Mục tiêu",
"maxTimeDiff": "Chênh lệch thời gian tối đa (ms)",
"minClientVer": "Phiên bản client tối thiểu",
"maxClientVer": "Phiên bản client tối đa",
"minClientVerHint": "Để trống không có nghĩa là không giới hạn: Xray-core sẽ áp dụng mức tối thiểu tích hợp của bản core đang chạy (26.3.27 ở các bản phát hành hiện tại) và từ chối các client khai báo phiên bản cũ hơn — bao gồm các core bên thứ ba như Mihomo và sing-box. Đặt 1.0.0 để chấp nhận chúng, đổi lại là cho phép các dấu vân tay TLS lỗi thời.",
"maxClientVerHint": "Để trống nghĩa là không có giới hạn trên. Nếu đặt, không được thấp hơn mức tối thiểu đang có hiệu lực — phiên bản client tối thiểu, hoặc mức tối thiểu tích hợp của Xray-core khi ô đó để trống — nếu không mọi client đều bị từ chối.",
"clientVerInvalid": "Phiên bản client phải gồm tối đa ba số cách nhau bằng dấu chấm, mỗi số 0-255 (ví dụ 26.3.27)",
"maxClientVerBelowMin": "Phiên bản client tối đa không được thấp hơn phiên bản client tối thiểu",
"shortIds": "Short IDs",
"realityTargetHint": "Bắt buộc. Phải bao gồm cổng (ví dụ example.com:443). Không có cổng, Xray-core sẽ không khởi động.",
"realityTargetRequired": "Mục tiêu REALITY là bắt buộc",
"realityTargetNeedsPort": "Mục tiêu REALITY phải bao gồm cổng (ví dụ example.com:443)",
"realityTargetInvalidPort": "Mục tiêu REALITY có cổng không hợp lệ",
"scan": "Quét",
"findTargets": "Tìm mục tiêu",
"scanModalTitle": "Trình quét mục tiêu REALITY",
"scanModalDesc": "Xác thực một tên miền, hoặc quét một dải IP / CIDR để khám phá các mục tiêu REALITY mới từ chứng chỉ của chúng. Để trống để quét các ứng viên phổ biến.",
"scanDiscoverPlaceholder": "IP, CIDR hoặc tên miền — để trống cho ứng viên phổ biến",
"scanStatus": "Trạng thái",
"scanFeasible": "Khả dụng",
"scanNotFeasible": "Không khả dụng",
"scanCurve": "Trao đổi khóa",
"scanCert": "Chứng chỉ",
"scanCertInvalid": "Không tin cậy",
"scanCertExpiry": "Chứng chỉ hết hạn",
"scanSniUsed": "SNI đã dùng",
"scanPrivateNote": "Đã kiểm tra qua mạng riêng/nội bộ — địa chỉ này không truy cập được từ internet.",
"scanPrivateConfirmTitle": "Đích trong mạng nội bộ",
"scanPrivateConfirmContent": "\"{target}\" trỏ tới địa chỉ riêng hoặc loopback. Việc kiểm tra sẽ bỏ qua bảo vệ SSRF của panel chỉ cho lần thăm dò này. Tiếp tục?",
"scanLatency": "Độ trễ",
"scanUse": "Dùng",
"scanRescan": "Quét lại",
"spiderX": "SpiderX",
"spiderXHint": "Hạt giống theo từng client — bảng điều khiển suy ra đường dẫn spx riêng cho mỗi client từ đó; tạo lại để xoay đường dẫn của tất cả",
"getNewCert": "Lấy chứng chỉ mới",
"mldsa65Seed": "mldsa65 Seed",
"mldsa65Verify": "mldsa65 Verify",
"getNewSeed": "Lấy Seed mới",
"listenHelp": "Bạn cũng có thể nhập đường dẫn Unix socket (ví dụ /run/xray/in.sock), hoặc tên abstract socket có tiền tố @ (ví dụ @xray/in.sock), để lắng nghe trên socket thay vì cổng TCP — khi đó hãy đặt Port là 0.",
"shareAddrStrategy": "Chiến lược địa chỉ chia sẻ",
"shareAddrStrategyHelp": "Kiểm soát địa chỉ được ghi vào liên kết chia sẻ đã xuất, mã QR và nội dung đăng ký.",
"shareAddr": "Địa chỉ chia sẻ tùy chỉnh",
"shareAddrHelp": "Chỉ dùng khi chiến lược địa chỉ chia sẻ là Tùy chỉnh. Nhập host hoặc IP không kèm giao thức hoặc cổng.",
"subSortIndex": "Thứ tự trong gói đăng ký",
"subSortIndexHelp": "Vị trí liên kết của inbound này trong nội dung gói đăng ký (trang đăng ký và ứng dụng khách). Giá trị nhỏ hơn xếp trước; giá trị bằng nhau giữ thứ tự tạo. Không ảnh hưởng đến danh sách inbound trong bảng điều khiển.",
"disableFlow": "Tắt luồng XTLS",
"disableFlowHelp": "Loại inbound này khỏi việc tự động thêm xtls-rprx-vision, ngay cả khi transport của nó hỗ trợ flow (ví dụ một inbound XHTTP đi qua tunnel với mã hóa VLESS). Client vẫn giữ Vision trên các inbound tương thích khác trong cùng subscription. Chỉ dành cho VLESS.",
"shareAddrStrategyOptions": {
"node": "Địa chỉ node",
"listen": "Địa chỉ listen inbound",
"custom": "Tùy chỉnh"
}
},
"info": {
"mode": "Chế độ",
"grpcServiceName": "grpc serviceName",
"grpcMultiMode": "grpc multiMode",
"interfaceName": "Tên giao diện",
"mtu": "MTU",
"gateway": "Gateway",
"dns": "DNS",
"outboundsInterface": "Giao diện outbound",
"autoSystemRoutes": "Định tuyến hệ thống tự động",
"followRedirect": "FollowRedirect",
"auth": "Auth",
"noKernelTun": "TUN không kernel",
"keepAlive": "Keep alive",
"peerNumber": "Peer {n}",
"peerNumberConfig": "Cấu hình Peer {n}"
},
"sniffingDestOverride": "Ghi đè đích"
},
"clients": {
"tabBasics": "Cơ bản",
"tabCredentials": "Thông tin xác thực",
"tabLinks": "Liên kết",
"wireguardConfig": "Cấu hình WireGuard",
"config": "Cấu hình",
"linksHint": "Thêm liên kết chia sẻ của bên thứ ba và URL đăng ký từ xa để đưa vào đăng ký của khách hàng này.",
"addExternalLink": "Thêm liên kết ngoài",
"addExternalSubscription": "Thêm đăng ký ngoài",
"noExternalLinks": "Chưa có liên kết ngoài.",
"noExternalSubscriptions": "Chưa có đăng ký ngoài.",
"namePrefix": "Tiền tố tên",
"lastFetchAt": "Lần tải gần nhất",
"lastFetchError": "Lỗi tải",
"neverFetched": "Chưa tải",
"submitEdit": "Lưu thay đổi",
"clientCount": "Số lượng khách hàng",
"bulk": "Thêm hàng loạt",
"selectAll": "Chọn tất cả",
"clearAll": "Xóa tất cả",
"method": "Phương thức",
"first": "Đầu",
"last": "Cuối",
"ipLog": "Nhật ký IP",
"prefix": "Tiền tố",
"postfix": "Hậu tố",
"delayedStart": "Bắt đầu sau lần dùng đầu",
"expireDays": "Thời hạn (ngày)",
"renew": "Tự động gia hạn",
"renewDesc": "Tự động gia hạn sau khi hết hạn. (0 = tắt) (đơn vị: ngày)",
"renewDays": "Tự động gia hạn (ngày)",
"searchPlaceholder": "Tìm email, ghi chú, sub ID, UUID, mật khẩu, auth, Telegram ID…",
"filterTitle": "Lọc client",
"clearAllFilters": "Xóa tất cả",
"filters": {
"nodes": "Nút",
"localPanel": "Cục bộ (bảng này)"
},
"showingCount": "Hiển thị {shown} trên {total}",
"sortOldest": "Cũ nhất trước",
"sortNewest": "Mới nhất trước",
"sortRecentlyUpdated": "Gần đây cập nhật",
"sortRecentlyOnline": "Gần đây trực tuyến",
"sortEmailAZ": "Email A→Z",
"sortEmailZA": "Email Z→A",
"sortMostTraffic": "Nhiều lưu lượng nhất",
"sortHighestRemaining": "Còn nhiều nhất",
"sortExpiringSoonest": "Sắp hết hạn",
"has": "Có",
"hasNot": "Không có",
"actions": "Hành động",
"totalGB": "Giới hạn lưu lượng (GB)",
"totalGBDesc": "Hạn mức dữ liệu cho khách hàng này. 0 = không giới hạn.",
"expiryTime": "Hết hạn",
"addClients": "Thêm khách hàng",
"limitIp": "Giới hạn IP",
"limitIpDesc": "Số IP đồng thời tối đa. 0 = không giới hạn.",
"limitHwid": "Giới hạn HWID",
"limitHwidDesc": "Số thiết bị đăng ký tối đa cho yêu cầu đăng ký. 0 = không giới hạn.",
"hwidLog": "Thiết bị HWID",
"hwidDevice": "Thiết bị đã đăng ký",
"noHwids": "Chưa có thiết bị HWID",
"firstSeen": "Lần đầu thấy",
"lastSeen": "Lần cuối thấy",
"deleteHwid": "Xóa thiết bị",
"deleteHwidConfirm": "Xóa thiết bị này? Thiết bị sẽ cần đăng ký lại vào lần lấy gói đăng ký tiếp theo.",
"hwidDeleted": "Đã xóa thiết bị.",
"clearHwidsConfirm": "Xóa tất cả thiết bị đã đăng ký? Mỗi thiết bị sẽ cần đăng ký lại vào lần lấy gói đăng ký tiếp theo.",
"limitIpFail2banMissing": "Fail2ban chưa được cài đặt nên không thể áp dụng giới hạn IP. Hãy cài đặt Fail2ban từ menu bash x-ui để bật tùy chọn này.",
"limitIpFail2banWindows": "Fail2ban không khả dụng trên Windows nên không thể áp dụng giới hạn IP.",
"limitIpDisabled": "Tính năng giới hạn IP đã bị tắt trên máy chủ này.",
"password": "Mật khẩu",
"passwordDesc": "Chỉ được dùng bởi các client Trojan và Shadowsocks; bị bỏ qua đối với VLESS, VMess, Hysteria và WireGuard.",
"subId": "ID đăng ký",
"online": "Trực tuyến",
"email": "Email",
"emailInvalidChars": "Email không được chứa khoảng trắng, '/', '\\' hoặc ký tự điều khiển",
"subIdInvalidChars": "ID đăng ký không được chứa khoảng trắng, '/', '\\' hoặc ký tự điều khiển",
"group": "Nhóm",
"groupDesc": "Nhãn logic để gom các client liên quan (nhóm, khách hàng, khu vực). Có thể lọc từ thanh công cụ.",
"groupPlaceholder": "ví dụ customer-a",
"comment": "Ghi chú",
"traffic": "Lưu lượng",
"speed": "Tốc độ",
"offline": "Ngoại tuyến",
"addClient": "Thêm khách hàng",
"qrCode": "Mã QR",
"clientInfo": "Thông tin khách hàng",
"editClient": "Chỉnh sửa khách hàng",
"client": "Khách hàng",
"enabled": "Đã bật",
"remaining": "Còn lại",
"duration": "Thời hạn",
"attachedInbounds": "Inbound đã gắn",
"selectInbound": "Chọn một hoặc nhiều inbound",
"selectAllInbounds": "Chọn tất cả",
"clearAllInbounds": "Xóa tất cả",
"noSubId": "Khách hàng này không có subId, không có liên kết chia sẻ.",
"noLinks": "Không có liên kết chia sẻ — hãy gắn khách hàng này vào một inbound có giao thức tương thích trước.",
"link": "Liên kết",
"resetNotPossible": "Hãy gắn khách hàng này vào một inbound trước.",
"resetAllTraffics": "Đặt lại lưu lượng của tất cả khách hàng",
"resetAllTrafficsTitle": "Đặt lại lưu lượng của tất cả khách hàng?",
"resetAllTrafficsContent": "Bộ đếm gửi/nhận của mỗi khách hàng về 0. Hạn mức và thời hạn không bị ảnh hưởng. Không thể hoàn tác.",
"deleteConfirmTitle": "Xóa khách hàng {email}?",
"deleteConfirmContent": "Hành động này gỡ khách hàng khỏi mọi inbound đã gắn và xóa bản ghi lưu lượng. Không thể hoàn tác.",
"adjustSelected": "Điều chỉnh ({count})",
"subLinksSelected": "Liên kết sub ({count})",
"addToGroupTitle": "Thêm {count} client vào một nhóm",
"addToGroupTooltip": "Chọn nhóm có sẵn hoặc nhập tên mới. Dùng Ungroup để xóa client khỏi nhóm hiện tại.",
"groupName": "Tên nhóm",
"addToGroupSuccessToast": "Đã thêm {count} client vào {group}",
"ungroupSuccessToast": "Đã xóa nhóm khỏi {count} client",
"ungroup": "Bỏ nhóm",
"ungroupConfirmTitle": "Xóa {count} client khỏi nhóm của họ?",
"ungroupConfirmContent": "Xóa nhãn nhóm trên mỗi client đã chọn. Bản thân client được giữ lại (dùng Delete để xóa hoàn toàn).",
"addToGroup": "Thêm vào nhóm",
"attach": "Gắn",
"adjust": "Điều chỉnh",
"subLinks": "Liên kết sub",
"enable": "Bật",
"disable": "Tắt",
"bulkEnableConfirmTitle": "Bật {count} khách hàng?",
"bulkEnableConfirmContent": "Bật từng khách hàng đã chọn trên mọi inbound được gắn. Những khách hàng đã dùng hết hạn mức hoặc đã hết hạn sẽ tự động bị tắt lại.",
"bulkDisableConfirmTitle": "Tắt {count} khách hàng?",
"bulkDisableConfirmContent": "Tắt từng khách hàng đã chọn trên mọi inbound được gắn. Họ mất quyền truy cập ngay lập tức nhưng hồ sơ và lưu lượng của họ vẫn được giữ lại.",
"selectedCount": "Đã chọn {count}",
"attachToInboundsTitle": "Gắn {count} client vào inbound",
"attachToInboundsDesc": "Gắn {count} client đã chọn (cùng UUID/mật khẩu và lưu lượng chung) vào các inbound đã chọn. Các gắn kết hiện tại được giữ nguyên.",
"attachToInboundsTargets": "Inbound đích",
"attachToInboundsNoTargets": "Không có inbound đa người dùng nào để gắn.",
"detach": "Tách",
"detachFromInboundsTitle": "Tách {count} client khỏi inbound",
"detachFromInboundsDesc": "Xóa {count} client đã chọn khỏi các inbound đã chọn. Các cặp client chưa gắn sẽ được bỏ qua. Hồ sơ client được giữ lại (dùng Delete để xóa hoàn toàn).",
"detachFromInboundsTargets": "Inbound để tách",
"detachFromInboundsNoTargets": "Không có inbound đa người dùng nào.",
"detachFromInboundsResult": "Đã tách {detached}, bỏ qua {skipped}.",
"detachFromInboundsResultMixed": "Đã tách {detached}, bỏ qua {skipped}, lỗi {errors}.",
"subLinksTitle": "Liên kết sub ({count})",
"subLinkColumn": "URL đăng ký",
"subJsonLinkColumn": "URL JSON đăng ký",
"subLinksCopyAll": "Sao chép tất cả",
"subLinksCopiedAll": "Đã sao chép {count} liên kết",
"subLinksEmpty": "Không client nào trong các client đã chọn có ID đăng ký.",
"subLinksDisabled": "Dịch vụ đăng ký đã tắt.",
"subLinksDisabledHint": "Bật đăng ký tại Cài đặt bảng điều khiển → Đăng ký để tạo liên kết.",
"bulkDeleteConfirmTitle": "Xóa {count} khách hàng?",
"bulkDeleteConfirmContent": "Mỗi khách hàng được chọn sẽ bị gỡ khỏi tất cả inbound đã gắn và bản ghi lưu lượng cũng bị xóa. Không thể hoàn tác.",
"bulkAdjustTitle": "Điều chỉnh {count} khách hàng",
"bulkAdjustHint": "Giá trị dương kéo dài, giá trị âm rút ngắn. Khách hàng có hạn hoặc lưu lượng không giới hạn sẽ bị bỏ qua cho trường đó.",
"bulkAdjustNothing": "Đặt số ngày hoặc lưu lượng trước khi áp dụng.",
"addDays": "Thêm ngày",
"addTrafficGB": "Thêm lưu lượng (GB)",
"bulkFlow": "Đặt flow",
"bulkFlowNoChange": "Không thay đổi",
"bulkFlowDisable": "Tắt (xóa flow)",
"delDepleted": "Xóa hết hạn mức",
"delDepletedConfirmTitle": "Xóa khách hàng hết hạn mức?",
"delDepletedConfirmContent": "Gỡ tất cả khách hàng đã dùng hết hạn mức lưu lượng hoặc đã quá hạn. Không thể hoàn tác.",
"exportClients": "Xuất khách hàng",
"importClients": "Nhập khách hàng",
"import": "Nhập",
"delOrphans": "Xóa khách hàng không gắn inbound",
"delOrphansConfirmTitle": "Xóa khách hàng không thuộc inbound nào?",
"delOrphansConfirmContent": "Gỡ tất cả khách hàng không được gắn vào bất kỳ inbound nào, cùng với bản ghi lưu lượng của họ. Không thể hoàn tác.",
"auth": "Auth",
"hysteriaAuth": "Hysteria Auth",
"hysteriaAuthDesc": "Thông tin xác thực chỉ dùng cho client Hysteria. Trojan và Shadowsocks dùng trường \"Mật khẩu\" thay thế.",
"uuid": "UUID",
"flow": "Flow",
"vmessSecurity": "Bảo mật VMess",
"wireguardPrivateKey": "Khóa riêng WireGuard",
"wireguardPublicKey": "Khóa công khai WireGuard",
"wireguardPreSharedKey": "Khóa chia sẻ trước WireGuard",
"wireguardAllowedIPs": "IP được phép WireGuard",
"wireguardAllowedIPsHint": "Để trống để tự động gán; phân tách các mục bằng dấu phẩy",
"amneziaWgPrivateKey": "Khóa riêng AmneziaWG",
"amneziaWgPublicKey": "Khóa công khai AmneziaWG",
"amneziaWgPreSharedKey": "Khóa chia sẻ trước AmneziaWG",
"amneziaWgAllowedIPs": "IP được phép AmneziaWG",
"amneziaWgAllowedIPsHint": "Để trống để tự động gán; phân tách các mục bằng dấu phẩy",
"amneziaWgForwardedPorts": "Cổng chuyển tiếp",
"amneziaWgForwardedPortsHint": "Cổng/dải cổng được chuyển tiếp (DNAT) đến client này, vd. 80, 443, 8000-8100. Để trống nếu không cần.",
"amneziaWgConfig": "Cấu hình AmneziaWG",
"mtprotoSecret": "Secret MTProto",
"mtprotoSecretHint": "Secret FakeTLS của client. Tạo lại để thay đổi.",
"mtprotoAdTag": "Ad-tag (kênh tài trợ)",
"mtprotoAdTagHint": "Thẻ thập lục phân 32 ký tự tùy chọn từ đăng ký proxy của Telegram. Khi được đặt, client này sẽ được định tuyến qua các proxy trung gian của Telegram và một kênh tài trợ xuất hiện ở đầu danh sách trò chuyện.",
"reverseTag": "Reverse tag",
"reverseTagPlaceholder": "Reverse tag tùy chọn",
"telegramId": "ID người dùng Telegram",
"telegramIdPlaceholder": "ID người dùng Telegram dạng số (0 = không có)",
"ipLimit": "Giới hạn IP",
"toasts": {
"deleted": "Đã xóa khách hàng",
"trafficReset": "Đã đặt lại lưu lượng",
"allTrafficsReset": "Đã đặt lại lưu lượng của tất cả khách hàng",
"bulkDeleted": "Đã xóa {count} khách hàng",
"bulkDeletedMixed": "Đã xóa {ok}, thất bại {failed}",
"bulkEnabled": "Đã bật {count} khách hàng",
"bulkEnabledMixed": "Đã bật {ok}, thất bại {failed}",
"bulkDisabled": "Đã tắt {count} khách hàng",
"bulkDisabledMixed": "Đã tắt {ok}, thất bại {failed}",
"bulkCreated": "Đã tạo {count} khách hàng",
"bulkCreatedMixed": "Đã tạo {ok}, thất bại {failed}",
"bulkAdjusted": "Đã điều chỉnh {count} khách hàng",
"bulkAdjustedMixed": "Đã điều chỉnh {ok}, bỏ qua {skipped}",
"delDepleted": "Đã xóa {count} khách hàng hết hạn mức",
"delOrphans": "Đã xóa {count} khách hàng không gắn inbound",
"imported": "Đã nhập {count} khách hàng",
"importedMixed": "Đã nhập {ok}, bỏ qua {failed}"
},
"renewMax": "Số lần gia hạn tối đa",
"renewMaxDesc": "Gia hạn tự động được phép chạy bao nhiêu lần trước khi để khách hàng hết hạn. 0 nghĩa là không giới hạn. Bù lại nhiều kỳ đã bỏ lỡ sẽ tiêu tốn một lần gia hạn cho mỗi kỳ.",
"renewOnDay": "Gia hạn vào ngày",
"renewOnDayDesc": "Gia hạn vào ngày này của mỗi tháng dương lịch, lúc nửa đêm theo múi giờ của bảng điều khiển, thay vì mỗi N ngày. Tháng không có ngày đã chọn sẽ gia hạn vào ngày cuối cùng của tháng. 0 giữ nguyên chế độ khoảng cách theo ngày.",
"renewsUsed": "Số lần gia hạn đã dùng"
},
"groups": {
"name": "Tên",
"clientCount": "Client",
"totalGroups": "Tổng số nhóm",
"totalGroupedClients": "Client có nhóm",
"trafficUsed": "Lưu lượng đã dùng",
"upload": "Tải lên",
"download": "Tải xuống",
"totalTraffic": "Tổng lưu lượng",
"totalUpDown": "Tổng tải lên / tải xuống",
"addGroup": "Thêm nhóm",
"createSuccess": "Đã tạo nhóm «{name}».",
"rename": "Đổi tên",
"renameTitle": "Đổi tên {name}",
"renameCollision": "Nhóm có tên «{name}» đã tồn tại.",
"renameSuccess": "Đã đổi tên nhóm trên {count} client.",
"deleteConfirmTitle": "Xóa nhóm {name}?",
"deleteConfirmContent": "Việc này xóa nhóm và xóa nhãn khỏi {count} client. Bản thân client không bị xóa.",
"deleteSuccess": "Đã xóa nhóm khỏi {count} client.",
"resetTraffic": "Đặt lại lưu lượng",
"resetConfirmTitle": "Đặt lại lưu lượng nhóm {name}?",
"resetConfirmContent": "Việc này chỉ đặt lại bộ đếm lưu lượng của nhóm. Bộ đếm của từng client không bị ảnh hưởng.",
"resetSuccess": "Đã đặt lại lưu lượng nhóm {name}.",
"adjustSuccess": "Đã điều chỉnh {count} client trong {name}.",
"emptyForAction": "Nhóm này chưa có client.",
"deleteGroupOnly": "Xóa nhóm (giữ client)",
"deleteClients": "Xóa client trong nhóm",
"deleteClientsConfirmTitle": "Xóa tất cả client trong {name}?",
"deleteClientsConfirmContent": "Việc này xóa vĩnh viễn {count} client cùng với hồ sơ lưu lượng. Nhãn nhóm cũng được xóa. Không thể hoàn tác.",
"deleteClientsSuccess": "Đã xóa {count} client.",
"deleteClientsMixed": "{ok} đã xóa, {failed} bỏ qua",
"addToGroup": "Thêm client…",
"addToGroupTitle": "Thêm client vào nhóm «{name}»",
"addToGroupDesc": "Chọn client để thêm vào nhóm này. Giữ nguyên gắn kết inbound hiện tại; chỉ thay đổi nhãn nhóm. Client đã ở trong nhóm này sẽ không được liệt kê.",
"addToGroupEmpty": "Không có client khác để thêm.",
"addToGroupResult": "Đã thêm {count} client vào {name}.",
"removeFromGroup": "Xóa client…",
"removeFromGroupTitle": "Xóa client khỏi nhóm «{name}»",
"removeFromGroupDesc": "Chọn thành viên để xóa khỏi nhóm này. Bản thân client được giữ lại (dùng «Xóa client trong nhóm» để xóa hoàn toàn).",
"removeFromGroupResult": "Đã xóa {count} client khỏi {name}."
},
"nodes": {
"addNode": "Thêm nút",
"editNode": "Sửa node",
"totalNodes": "Tổng số nút",
"onlineNodes": "Trực tuyến",
"offlineNodes": "Ngoại tuyến",
"avgLatency": "Độ trễ trung bình",
"name": "Tên",
"namePlaceholder": "vd: de-frankfurt-1",
"addressPlaceholder": "panel.example.com hoặc 1.2.3.4",
"remark": "Chú thích",
"scheme": "Giao thức",
"address": "Địa chỉ",
"port": "Cổng",
"basePath": "Đường dẫn cơ sở",
"apiToken": "Token API",
"apiTokenPlaceholder": "Token từ trang Cài đặt của panel từ xa",
"apiTokenHint": "Panel từ xa hiển thị token API tại Bảo mật → Token API.",
"apiTokenKeepHint": "Để trống để giữ token hiện tại",
"allowPrivateAddress": "Cho phép địa chỉ riêng",
"allowPrivateAddressHint": "Chỉ bật cho các nút trên mạng riêng hoặc VPN.",
"outboundTag": "Outbound kết nối",
"outboundTagHint": "Định tuyến lưu lượng API panel của node này qua outbound Xray đã chọn. Một inbound cầu nối loopback được tự động thêm vào cấu hình đang chạy và áp dụng trực tiếp. Để trống để kết nối trực tiếp.",
"outboundTagPlaceholder": "Kết nối trực tiếp",
"inboundSyncMode": "Nhập inbound",
"inboundSyncModeHint": "Chọn các inbound được nhập từ nút này. Các nút hiện có mặc định nhập tất cả.",
"allInbounds": "Tất cả inbound",
"selectedInbounds": "Inbound đã chọn",
"inboundTags": "Inbound",
"inboundTagsHint": "Lựa chọn được đối chiếu theo tag inbound. Lựa chọn trống sẽ không nhập gì.",
"inboundTagsPlaceholder": "Tải và chọn inbound",
"loadInbounds": "Tải inbound từ nút",
"inboundsLoaded": "Đã tải {{count}} inbound",
"inboundsLoadFailed": "Không thể tải inbound",
"enable": "Kích hoạt",
"status": "Trạng thái",
"cpu": "CPU",
"mem": "Bộ nhớ",
"netUp": "Mạng lên (KB/s)",
"netDown": "Mạng xuống (KB/s)",
"uptime": "Thời gian hoạt động",
"latency": "Độ trễ",
"lastHeartbeat": "Heartbeat gần nhất",
"xrayVersion": "Phiên bản Xray",
"panelVersion": "Phiên bản panel",
"actions": "Hành động",
"probe": "Kiểm tra ngay",
"updatePanel": "Cập nhật bảng điều khiển",
"updateSelected": "Cập nhật đã chọn ({count})",
"updateAvailable": "Có bản cập nhật",
"updateConfirmTitle": "Cập nhật {count} node lên phiên bản mới nhất?",
"updateConfirmContent": "Mỗi node đã chọn sẽ tải bản phát hành mới nhất và khởi động lại. Chỉ các node đang bật và trực tuyến được cập nhật.",
"updateDevChannel": "Cập nhật lên kênh phát triển (commit mới nhất)",
"testConnection": "Kiểm tra kết nối",
"connectionOk": "Kết nối OK ({ms} ms)",
"connectionFailed": "Kết nối thất bại",
"never": "chưa bao giờ",
"justNow": "vừa xong",
"subNode": "Nút con",
"subNodeTip": "Chỉ đọc: một nút phía dưới được kết nối qua {parent}. Quản lý nó từ bảng điều khiển của chính {parent}.",
"deleteConfirmTitle": "Xóa nút \"{name}\"?",
"deleteConfirmContent": "Việc này dừng giám sát nút. Panel từ xa không bị ảnh hưởng.",
"statusValues": {
"online": "Trực tuyến",
"offline": "Ngoại tuyến",
"unknown": "Không xác định",
"xrayError": "Lỗi Xray",
"xrayStopped": "Đã dừng"
},
"toasts": {
"list": "Không tải được danh sách nút",
"obtain": "Không tải được nút",
"add": "Thêm nút",
"update": "Cập nhật nút",
"delete": "Xóa nút",
"deleted": "Đã xóa nút",
"test": "Kiểm tra kết nối",
"fillRequired": "Tên, địa chỉ, cổng và token API là bắt buộc",
"probeFailed": "Kiểm tra thất bại",
"updateStarted": "Đã bắt đầu cập nhật bảng điều khiển",
"updateResult": "Đã kích hoạt cập nhật trên {ok} node, {failed} thất bại",
"updateNoneEligible": "Chọn ít nhất một node trực tuyến và đang bật",
"saveMtls": "Lưu mTLS nút",
"reloadMtls": "Reload master mTLS credential"
},
"tlsVerifyMode": "Xác minh TLS",
"tlsVerifyModeHint": "Cách panel xác thực chứng chỉ HTTPS của node. Ghim hoặc Bỏ qua dành cho chứng chỉ tự ký (chỉ node https).",
"tlsVerify": "Xác minh (CA mặc định)",
"tlsPin": "Ghim chứng chỉ (SHA-256)",
"tlsSkip": "Bỏ qua xác minh",
"tlsMtls": "TLS song phương (chứng chỉ máy khách)",
"mtlsFormHint": "Nút này xác thực bảng điều khiển bằng chứng chỉ máy khách. Sao chép CA của bảng điều khiển này từ mục mTLS nút sang nút, đặt CA tin cậy của nó, rồi khởi động lại.",
"mtls": {
"title": "mTLS nút",
"intro": "TLS song phương bổ sung yếu tố chứng chỉ máy khách bên cạnh token API cho các lệnh gọi giữa các nút. Đây là tùy chọn: để trống để chỉ dùng xác thực bằng token.",
"copyCa": "Sao chép CA của bảng điều khiển này",
"copyCaHint": "Cấp CA này cho các nút mà bảng điều khiển này quản lý, sau đó đặt chế độ xác minh TLS của chúng thành TLS song phương.",
"caCopied": "Đã sao chép chứng chỉ CA vào bộ nhớ tạm",
"caFailed": "Không lấy được chứng chỉ CA",
"trustLabel": "CA tin cậy (bảng điều khiển cha)",
"trustHint": "Khi bảng điều khiển này bản thân là một nút, hãy dán CA của bảng điều khiển quản lý vào đây để yêu cầu chứng chỉ máy khách của nó. Khởi động lại bảng điều khiển để áp dụng.",
"trustPlaceholder": "-----BEGIN CERTIFICATE-----",
"save": "Lưu CA tin cậy",
"saved": "Đã lưu CA tin cậy — khởi động lại bảng điều khiển để áp dụng"
},
"tlsSkipWarning": "Bỏ qua xác minh sẽ loại bỏ bảo vệ trước tấn công xen giữa — token API có thể bị chặn bắt. Nên ghim chứng chỉ thay vì vậy.",
"pinnedCert": "SHA-256 của chứng chỉ đã ghim",
"pinnedCertHint": "SHA-256 của chứng chỉ node ở dạng base64 hoặc hex. Dùng Lấy để đọc trực tiếp từ node.",
"pinnedCertPlaceholder": "SHA-256 base64 hoặc hex",
"fetchPin": "Lấy",
"pinFetched": "Đã lấy chứng chỉ hiện tại của node",
"pinFetchFailed": "Không thể lấy chứng chỉ"
},
"settings": {
"defaultTag": "Mặc định",
"title": "Cài đặt",
"save": "Lưu",
"infoDesc": "Mọi thay đổi được thực hiện ở đây cần phải được lưu. Vui lòng khởi động lại bảng điều khiển để áp dụng các thay đổi.",
"restartPanel": "Khởi động lại bảng điều khiển",
"restartPanelDesc": "Bạn có chắc chắn muốn khởi động lại bảng điều khiển? Nhấn OK để khởi động lại sau 3 giây. Nếu bạn không thể truy cập bảng điều khiển sau khi khởi động lại, vui lòng xem thông tin nhật ký của bảng điều khiển trên máy chủ.",
"restartPanelSuccess": "Đã khởi động lại bảng điều khiển thành công",
"actions": "Hành động",
"resetDefaultConfig": "Đặt lại cấu hình mặc định",
"panelSettings": "Bảng điều khiển",
"securitySettings": "Bảo mật",
"securityWarnings": "Cảnh báo bảo mật",
"panelExposed": "Bảng điều khiển của bạn có thể bị lộ:",
"warnHttp": "Panel đang chạy trên HTTP thuần — thiết lập TLS cho môi trường thật.",
"warnDefaultPort": "Cổng mặc định 2053 đã quá phổ biến — đổi sang cổng ngẫu nhiên.",
"warnDefaultBasePath": "Đường dẫn cơ sở mặc định \"/\" đã quá phổ biến — đổi sang đường dẫn ngẫu nhiên.",
"warnDefaultSubPath": "Đường dẫn đăng ký mặc định \"/sub/\" đã quá phổ biến — đổi nó.",
"warnDefaultJsonPath": "Đường dẫn đăng ký JSON mặc định \"/json/\" đã quá phổ biến — đổi nó.",
"TGBotSettings": "Bot Telegram",
"panelListeningIP": "IP Nghe của bảng điều khiển",
"panelListeningIPDesc": "Mặc định để trống để nghe tất cả các IP.",
"panelListeningDomain": "Tên miền của nghe bảng điều khiển",
"panelListeningDomainDesc": "Mặc định để trống để nghe tất cả các tên miền và IP",
"panelPort": "Cổng bảng điều khiển",
"panelPortDesc": "Cổng được sử dụng để kết nối với bảng điều khiển này",
"publicKeyPath": "Đường dẫn file chứng chỉ bảng điều khiển",
"publicKeyPathDesc": "Điền vào đường dẫn đầy đủ (bắt đầu từ '/')",
"privateKeyPath": "Đường dẫn file khóa của chứng chỉ bảng điều khiển",
"privateKeyPathDesc": "Điền vào đường dẫn đầy đủ (bắt đầu từ '/')",
"panelUrlPath": "Đường dẫn URI",
"panelUrlPathDesc": "Phải bắt đầu và kết thúc bằng '/'",
"pageSize": "Kích thước phân trang",
"pageSizeDesc": "Xác định kích thước trang cho bảng gửi đến. Đặt 0 để tắt",
"panelOutbound": "Outbound cho lưu lượng panel",
"panelOutboundDesc": "Định tuyến các yêu cầu của chính bảng điều khiển — kiểm tra phiên bản và tải xuống panel/Xray, Telegram, và cập nhật tệp geo thông thường — qua outbound Xray này để vượt qua lọc GitHub/Telegram phía máy chủ. Một inbound cầu nối cục bộ được tự động thêm vào cấu hình đang chạy và áp dụng trực tiếp. Tính năng Tự động cập nhật Geodata gốc của Xray không bị ảnh hưởng; nó có outbound tải xuống riêng. Để trống để kết nối trực tiếp.",
"panelOutboundPh": "Kết nối trực tiếp",
"datepicker": "Kiểu lịch",
"datepickerPlaceholder": "Chọn ngày",
"datepickerDescription": "Tác vụ chạy theo lịch trình sẽ chạy theo kiểu lịch này.",
"oldUsername": "Tên người dùng hiện tại",
"currentPassword": "Mật khẩu hiện tại",
"newUsername": "Tên người dùng mới",
"newPassword": "Mật khẩu mới",
"telegramBotEnable": "Bật Bot Telegram",
"telegramBotEnableDesc": "Kết nối với các tính năng của bảng điều khiển này thông qua bot Telegram",
"telegramToken": "Token Telegram",
"telegramTokenDesc": "Bạn phải nhận token từ quản lý bot Telegram {'@'}botfather",
"telegramProxy": "SOCKS Proxy",
"telegramProxyDesc": "Nếu bạn cần socks5 proxy để kết nối với Telegram. Điều chỉnh cài đặt của nó theo hướng dẫn.",
"telegramAPIServer": "Máy chủ API Telegram",
"telegramAPIServerDesc": "Máy chủ API Telegram để sử dụng. Để trống để sử dụng máy chủ mặc định.",
"telegramChatId": "Chat ID Telegram của quản trị viên",
"telegramChatIdDesc": "Nhiều Chat ID phân tách bằng dấu phẩy. Sử dụng {'@'}userinfobot hoặc sử dụng lệnh '/id' trong bot để lấy Chat ID của bạn.",
"telegramNotifyTime": "Thời gian thông báo của bot Telegram",
"telegramNotifyTimeDesc": "Tần suất bot Telegram gửi báo cáo định kỳ. Chọn một khoảng thời gian có sẵn, hoặc chọn Tùy chỉnh để nhập biểu thức crontab.",
"notifyTime": {
"every": "@every — lặp lại theo khoảng thời gian",
"hourly": "@hourly — mỗi giờ",
"daily": "@daily — mỗi ngày lúc 00:00",
"weekly": "@weekly — mỗi tuần",
"monthly": "@monthly — mỗi tháng",
"custom": "Tùy chỉnh (crontab)",
"seconds": "Giây",
"minutes": "Phút",
"hours": "Giờ",
"interval": "Khoảng thời gian",
"unit": "Đơn vị"
},
"tgNotifyBackup": "Sao lưu Cơ sở dữ liệu",
"tgNotifyBackupDesc": "Bao gồm tệp sao lưu cơ sở dữ liệu với thông báo báo cáo.",
"tgNotifyLogin": "Thông báo Đăng nhập",
"tgNotifyLoginDesc": "Hiển thị tên người dùng, địa chỉ IP và thời gian khi ai đó cố gắng đăng nhập vào bảng điều khiển của bạn.",
"sessionMaxAge": "Thời gian tối đa của phiên",
"sessionMaxAgeDesc": "Thời gian của phiên đăng nhập (đơn vị: phút)",
"expireTimeDiff": "Ngưỡng hết hạn cho thông báo",
"expireTimeDiffDesc": "Nhận thông báo về việc hết hạn tài khoản trước ngưỡng này (đơn vị: ngày)",
"trafficDiff": "Ngưỡng lưu lượng cho thông báo",
"trafficDiffDesc": "Nhận thông báo về việc cạn kiệt lưu lượng trước khi đạt đến ngưỡng này (đơn vị: GB)",
"tgNotifyCpu": "Ngưỡng cảnh báo tỷ lệ CPU",
"tgNotifyCpuDesc": "Nhận thông báo nếu tỷ lệ sử dụng CPU vượt quá ngưỡng này (đơn vị: %)",
"timeZone": "Múi giờ",
"timeZoneDesc": "Các tác vụ được lên lịch chạy theo thời gian trong múi giờ này.",
"subSettings": "Gói đăng ký",
"subEnable": "Bật dịch vụ",
"subEnableDesc": "Tính năng gói đăng ký với cấu hình riêng",
"subJsonEnable": "Bật/Tắt điểm cuối đăng ký JSON độc lập.",
"subJsonEnableTitle": "Đăng ký JSON",
"subClashEnableTitle": "Đăng ký Clash / Mihomo",
"subFormatsTipTitle": "Cài đặt đăng ký theo từng định dạng",
"subFormatsTipDesc": "Cấu hình riêng đường dẫn URL, URL proxy ngược và tính năng tự động nhận diện ứng dụng cho JSON và Clash / Mihomo.",
"subFormatsTipAction": "Mở định dạng đăng ký",
"subJsonAutoDetect": "Tự động nhận diện ứng dụng Xray JSON",
"subJsonAutoDetectDesc": "Khi bật, các ứng dụng tương thích được nhận diện khi yêu cầu URL đăng ký tiêu chuẩn sẽ tự động nhận một mảng cấu hình Xray JSON. Các ứng dụng khác tiếp tục nhận phản hồi thô/Base64. Cần bật đăng ký JSON và khởi động lại bảng điều khiển.",
"subJsonAlwaysArray": "Luôn trả về mảng JSON",
"subJsonAlwaysArrayDesc": "Trả endpoint đăng ký JSON tường minh dưới dạng mảng ngay cả khi chỉ có một hồ sơ, theo tiêu chuẩn XTLS. Phản hồi JSON được tự động nhận diện luôn dùng mảng. Tắt để giữ phản hồi một đối tượng kiểu cũ.",
"subJsonUserAgentRegex": "Biểu thức User-Agent Xray JSON",
"subJsonUserAgentRegexDesc": "Biểu thức chính quy Go RE2 được so khớp với User-Agent của ứng dụng để tự động chọn định dạng Xray JSON trên URL đăng ký tiêu chuẩn. Mặc định để trống, nên tính năng tự động nhận diện vẫn tắt cho đến khi bạn đặt mẫu cho các ứng dụng muốn phục vụ. Các ứng dụng khác tiếp tục nhận phản hồi thô/Base64. Khởi động lại bảng điều khiển sau khi thay đổi.",
"subClashAutoDetect": "Tự động nhận diện ứng dụng Clash/Mihomo",
"subClashAutoDetectDesc": "Khi bật, các ứng dụng Clash/Mihomo được nhận diện khi yêu cầu URL đăng ký tiêu chuẩn sẽ tự động nhận cấu hình Clash YAML. Trình duyệt vẫn hiển thị trang đăng ký, các ứng dụng khác tiếp tục nhận phản hồi thô/Base64, còn các URL JSON và Clash riêng vẫn khả dụng. Cần bật đăng ký Clash/Mihomo và khởi động lại bảng điều khiển để áp dụng thay đổi.",
"subClashUserAgentRegex": "Biểu thức User-Agent Clash/Mihomo",
"subClashUserAgentRegexDesc": "Biểu thức chính quy Go RE2 được so khớp với User-Agent của ứng dụng để nhận diện ứng dụng Clash/Mihomo trên URL đăng ký tiêu chuẩn. Để trống để dùng mẫu mặc định. Khởi động lại bảng điều khiển sau khi thay đổi.",
"subTitle": "Tiêu đề Đăng ký",
"subTitleDesc": "Tiêu đề hiển thị trong ứng dụng VPN. Hỗ trợ token định danh khách hàng: {{EMAIL}}, {{ID}}, {{SHORT_ID}}, {{SUB_ID}}, {{TELEGRAM_ID}}.",
"subSupportUrl": "URL Hỗ trợ",
"subSupportUrlDesc": "Liên kết hỗ trợ kỹ thuật hiển thị trong ứng dụng VPN. Hỗ trợ token định danh khách hàng: {{EMAIL}}, {{ID}}, {{SHORT_ID}}, {{SUB_ID}}, {{TELEGRAM_ID}}.",
"subProfileUrl": "URL Hồ sơ",
"subProfileUrlDesc": "Liên kết đến trang web của bạn hiển thị trong ứng dụng VPN. Hỗ trợ token định danh khách hàng: {{EMAIL}}, {{ID}}, {{SHORT_ID}}, {{SUB_ID}}, {{TELEGRAM_ID}}.",
"subAnnounce": "Thông báo",
"subAnnounceDesc": "Văn bản thông báo hiển thị trong ứng dụng VPN. Hỗ trợ token định danh khách hàng: {{EMAIL}}, {{ID}}, {{SHORT_ID}}, {{SUB_ID}}, {{TELEGRAM_ID}}.",
"subThemeDir": "Thư mục giao diện Đăng ký",
"subThemeDirDesc": "Đường dẫn tuyệt đối đến thư mục chứa mẫu tùy chỉnh (index.html/sub.html) cho trang đăng ký (ví dụ: /etc/3x-ui/sub_templates/my-theme/). Để trống để dùng trang mặc định.",
"subThemeDirDocs": "Hướng dẫn mẫu ↗",
"subEnableRouting": "Bật định tuyến",
"subEnableRoutingDesc": "Cài đặt toàn cục để bật định tuyến trong ứng dụng khách VPN. (Chỉ dành cho Happ)",
"subRoutingRules": "Quy tắc định tuyến",
"subRoutingRulesDesc": "Dán deeplink happ:// có sẵn hoặc một URL HTTPS cố định. Bảng điều khiển cập nhật quy tắc từ xa trong nền và giữ giá trị hợp lệ gần nhất, nên yêu cầu đăng ký không phải chờ nguồn. (Chỉ dành cho Happ)",
"subHideSettings": "Ẩn cài đặt máy chủ",
"subHideSettingsDesc": "Ẩn khả năng xem và chỉnh sửa cấu hình máy chủ trong ứng dụng khách VPN. (Chỉ dành cho Happ)",
"subIncyEnableRouting": "Bật định tuyến",
"subIncyEnableRoutingDesc": "Chèn hồ sơ định tuyến vào nội dung đăng ký cho ứng dụng Incy. (Chỉ dành cho Incy)",
"subIncyRoutingRules": "Quy tắc định tuyến",
"subIncyRoutingRulesDesc": "Dán deeplink incy:// có sẵn hoặc URL HTTPS cố định tới JSON. Incy tạo hồ sơ autorouting và tự động cập nhật. (Chỉ dành cho Incy)",
"subClashEnableRouting": "Bật định tuyến",
"subClashEnableRoutingDesc": "Bao gồm quy tắc định tuyến Clash/Mihomo toàn cầu trong các đăng ký YAML được tạo.",
"subClashRoutingRules": "Quy tắc định tuyến toàn cầu",
"subClashRoutingRulesDesc": "Dán quy tắc/YAML hoặc một URL HTTPS cố định. Bảng điều khiển cập nhật trong nền, chỉ nhập nhóm, nhà cung cấp quy tắc và quy tắc, đồng thời giữ các nút VPN đã tạo và giá trị hợp lệ gần nhất.",
"subListen": "Listening IP",
"subListenDesc": "Mặc định để trống để nghe tất cả các IP",
"subPort": "Cổng gói đăng ký",
"subPortDesc": "Số cổng dịch vụ đăng ký phải chưa được sử dụng trên máy chủ. Cũng được dùng để tạo liên kết/QR đăng ký hiển thị trên bảng điều khiển khi \"URI proxy trung gian\" bên dưới để trống — nếu đăng ký được truy cập qua proxy trung gian trên một cổng khác, hãy đặt \"URI proxy trung gian\" thay thế.",
"subCertPath": "Đường dẫn file chứng chỉ gói đăng ký",
"subCertPathDesc": "Điền vào đường dẫn đầy đủ (bắt đầu với '/')",
"subKeyPath": "Đường dẫn file khóa của chứng chỉ gói đăng ký",
"subKeyPathDesc": "Điền vào đường dẫn đầy đủ (bắt đầu với '/')",
"subPath": "Đường dẫn URI",
"subPathDesc": "Phải bắt đầu và kết thúc bằng '/'",
"subDomain": "Tên miền con",
"subDomainDesc": "Mặc định để trống để nghe tất cả các tên miền và IP. Cũng được dùng làm tên miền dự phòng cho liên kết đăng ký hiển thị khi \"URI proxy trung gian\" để trống — hãy đặt \"URI proxy trung gian\" nếu bảng điều khiển và đăng ký được truy cập qua các tên miền khác nhau (ví dụ: đứng sau proxy trung gian).",
"subUpdates": "Khoảng thời gian cập nhật gói đăng ký",
"subUpdatesDesc": "Số giờ giữa các cập nhật trong ứng dụng khách",
"subEncrypt": "Mã hóa",
"subEncryptDesc": "Mã hóa các cấu hình được trả về trong gói đăng ký",
"subURI": "URI proxy trung gian",
"subURIDesc": "URL cơ sở đầy đủ (scheme://tênmiền[:cổng]/đường-dẫn/) cho liên kết đăng ký và mã QR, dùng thay cho Tên miền/Cổng gói đăng ký. Hãy đặt giá trị này khi đăng ký được truy cập qua proxy trung gian hoặc một tên miền/cổng khác với các mục trên.",
"externalTrafficInformEnable": "Thông báo giao thông bên ngoài",
"externalTrafficInformEnableDesc": "Thông báo API ngoài mỗi khi cập nhật lưu lượng.",
"externalTrafficInformURI": "URI thông báo lưu lượng truy cập bên ngoài",
"externalTrafficInformURIDesc": "Cập nhật lưu lượng truy cập được gửi tới URI này.",
"restartXrayOnClientDisable": "Khởi Động Lại Xray Sau Khi Tự Động Vô Hiệu Hóa",
"restartXrayOnClientDisableDesc": "Khi người dùng bị vô hiệu hóa tự động do hết hạn hoặc chạm giới hạn lưu lượng, hãy khởi động lại Xray.",
"fragment": "Sự phân mảnh",
"fragmentDesc": "Kích hoạt phân mảnh cho gói TLS hello",
"fragmentSett": "Cài đặt phân mảnh",
"noisesDesc": "Bật Noises.",
"noisesSett": "Cài đặt Noises",
"trustedProxyCidrs": "CIDR proxy tin cậy",
"trustedProxyCidrsDesc": "IPs/CIDRs cách nhau bằng dấu phẩy được phép đặt header host, proto và IP client chuyển tiếp.",
"ldap": {
"enable": "Bật đồng bộ LDAP",
"host": "LDAP host",
"port": "Cổng LDAP",
"useTls": "Dùng TLS (LDAPS)",
"skipTlsVerify": "Bỏ qua xác minh chứng chỉ TLS",
"skipTlsVerifyDesc": "Không an toàn — tắt xác thực chứng chỉ máy chủ. Chỉ dùng với CA nội bộ/không đáng tin.",
"bindDn": "Bind DN",
"passwordConfigured": "Đã cấu hình; để trống để giữ mật khẩu hiện tại.",
"passwordUnconfigured": "Chưa cấu hình.",
"passwordPlaceholder": "Đã cấu hình — nhập giá trị mới để thay thế",
"baseDn": "Base DN",
"userFilter": "Bộ lọc user",
"userAttr": "Thuộc tính user (username/email)",
"vlessField": "Thuộc tính flag VLESS",
"flagField": "Thuộc tính flag chung (tùy chọn)",
"flagFieldDesc": "Nếu đặt, sẽ ghi đè VLESS flag — ví dụ shadowInactive.",
"truthyValues": "Giá trị truthy",
"truthyValuesDesc": "Cách nhau bằng dấu phẩy; mặc định: true,1,yes,on",
"invertFlag": "Đảo flag",
"invertFlagDesc": "Bật khi thuộc tính có nghĩa «đã tắt» (ví dụ shadowInactive).",
"syncSchedule": "Lịch đồng bộ",
"syncScheduleDesc": "Chuỗi kiểu cron, ví dụ @every 1m",
"inboundTags": "Tag inbound",
"inboundTagsDesc": "Các inbound mà đồng bộ LDAP có thể tự tạo hoặc tự xóa client.",
"noInbounds": "Không tìm thấy inbound. Hãy tạo một inbound trong mục Inbound trước.",
"autoCreate": "Tự động tạo client",
"autoDelete": "Tự động xóa client",
"defaultTotalGb": "Tổng mặc định (GB)",
"defaultExpiryDays": "Hết hạn mặc định (ngày)",
"defaultIpLimit": "Giới hạn IP mặc định"
},
"subFormats": {
"finalMask": "Final Mask",
"finalMaskDesc": "Thêm mask TCP/UDP của Xray finalmask và tham số QUIC vào mỗi hồ sơ Xray JSON được tạo. Yêu cầu ứng dụng hỗ trợ đăng ký Xray JSON và lõi Xray mới.",
"packets": "Gói",
"length": "Độ dài",
"interval": "Khoảng",
"maxSplit": "Chia tối đa",
"noises": "Nhiễu",
"noiseItem": "Nhiễu №{n}",
"type": "Loại",
"packet": "Gói",
"delayMs": "Trễ (ms)",
"applyTo": "Áp dụng cho",
"addNoise": "+ Nhiễu",
"concurrency": "Đồng thời",
"xudpConcurrency": "Đồng thời xudp",
"xudpUdp443": "xudp UDP 443"
},
"mux": "Mux",
"muxDesc": "Truyền nhiều luồng dữ liệu độc lập trong luồng dữ liệu đã thiết lập.",
"muxSett": "Mux Cài đặt",
"direct": "Kết nối trực tiếp",
"directDesc": "Trực tiếp thiết lập kết nối với tên miền hoặc dải IP của một quốc gia cụ thể.",
"notifications": "Thông báo",
"certs": "Chứng chỉ",
"externalTraffic": "Lưu lượng bên ngoài",
"dateAndTime": "Ngày và giờ",
"proxyAndServer": "Proxy và máy chủ",
"intervals": "Khoảng thời gian",
"information": "Thông tin",
"profile": "Hồ sơ",
"language": "Ngôn ngữ",
"telegramBotLanguage": "Ngôn ngữ của Bot Telegram",
"security": {
"admin": "Thông tin đăng nhập quản trị viên",
"twoFactor": "Xác thực hai yếu tố",
"twoFactorEnable": "Bật 2FA",
"twoFactorEnableDesc": "Thêm một lớp bảo mật bổ sung để tăng cường an toàn.",
"twoFactorModalSetTitle": "Bật xác thực hai yếu tố",
"twoFactorModalDeleteTitle": "Tắt xác thực hai yếu tố",
"twoFactorModalSteps": "Để thiết lập xác thực hai yếu tố, hãy thực hiện các bước sau:",
"twoFactorModalFirstStep": "1. Quét mã QR này trong ứng dụng xác thực hoặc sao chép mã token gần mã QR và dán vào ứng dụng",
"twoFactorModalSecondStep": "2. Nhập mã từ ứng dụng",
"twoFactorModalRemoveStep": "Nhập mã từ ứng dụng để xóa xác thực hai yếu tố.",
"twoFactorModalChangeCredentialsTitle": "Thay đổi thông tin xác thực",
"twoFactorModalChangeCredentialsStep": "Nhập mã từ ứng dụng để thay đổi thông tin xác thực quản trị viên.",
"twoFactorModalSetSuccess": "Xác thực hai yếu tố đã được thiết lập thành công",
"twoFactorModalDeleteSuccess": "Xác thực hai yếu tố đã được xóa thành công",
"twoFactorModalError": "Mã sai",
"show": "Hiển thị",
"hide": "Ẩn",
"apiTokenNew": "Token mới",
"apiTokenName": "Tên",
"apiTokenNamePlaceholder": "ví dụ: central-panel-a",
"apiTokenNameRequired": "Tên là bắt buộc",
"apiTokenEmpty": "Chưa có token nào — tạo một token để xác thực bot hoặc panel từ xa.",
"apiTokenDeleteWarning": "Mọi client đang dùng token này sẽ ngừng xác thực ngay lập tức.",
"apiTokenCreatedTitle": "Đã tạo token",
"apiTokenCreatedNotice": "Hãy sao chép token này ngay bây giờ. Vì lý do bảo mật, token không được lưu ở dạng đọc được và sẽ không hiển thị lại."
},
"toasts": {
"modifySettings": "Các tham số đã được thay đổi.",
"getSettings": "Lỗi xảy ra khi truy xuất tham số.",
"modifyUserError": "Đã xảy ra lỗi khi thay đổi thông tin đăng nhập quản trị viên.",
"modifyUser": "Bạn đã thay đổi thông tin đăng nhập quản trị viên thành công.",
"originalUserPassIncorrect": "Tên người dùng hoặc mật khẩu gốc không đúng",
"userPassMustBeNotEmpty": "Tên người dùng mới và mật khẩu mới không thể để trống",
"getOutboundTrafficError": "Lỗi khi lấy lưu lượng truy cập đi",
"resetOutboundTrafficError": "Lỗi khi đặt lại lưu lượng truy cập đi"
},
"smtpSettings": "Cài đặt SMTP",
"smtpEnable": "Bật thông báo qua email",
"smtpEnableDesc": "Bật thông báo qua email bằng SMTP",
"smtpHost": "Máy chủ SMTP",
"smtpHostDesc": "Tên máy chủ SMTP (ví dụ: smtp.gmail.com)",
"smtpPort": "Cổng SMTP",
"smtpPortDesc": "Cổng máy chủ SMTP (mặc định: 587)",
"smtpUsername": "Tên đăng nhập SMTP",
"smtpUsernameDesc": "Tên đăng nhập xác thực SMTP",
"smtpFrom": "Địa chỉ người gửi (From)",
"smtpFromDesc": "Địa chỉ dùng trong tiêu đề From của email. Để trống để dùng tên người dùng.",
"smtpFromName": "Tên người gửi (From)",
"smtpFromNameDesc": "Tên hiển thị tùy chọn trước địa chỉ trong tiêu đề From.",
"smtpPassword": "Mật khẩu SMTP",
"smtpPasswordDesc": "Mật khẩu xác thực SMTP",
"smtpTo": "Người nhận",
"smtpToDesc": "Các địa chỉ email người nhận, phân cách bằng dấu phẩy",
"emailSettings": "Email",
"emailNotifications": "Thông báo",
"smtpEventBusNotify": "Thông báo sự kiện qua email",
"smtpEventBusNotifyDesc": "Chọn những sự kiện nào sẽ kích hoạt thông báo qua email",
"tgEventBusNotify": "Thông báo sự kiện qua Telegram",
"tgEventBusNotifyDesc": "Chọn những sự kiện nào sẽ kích hoạt thông báo qua Telegram",
"testSmtp": "Gửi email thử nghiệm",
"testTgBot": "Gửi tin nhắn thử nghiệm",
"eventGroupOutbound": "Outbound",
"eventGroupXray": "Xray Core",
"eventGroupSystem": "Hệ thống",
"eventGroupSecurity": "Bảo mật",
"eventGroupNode": "Node",
"eventOutboundDown": "Ngừng hoạt động",
"eventOutboundUp": "Hoạt động",
"eventXrayCrash": "Sự cố",
"eventNodeDown": "Ngừng hoạt động",
"eventNodeUp": "Hoạt động",
"eventCPUHigh": "CPU cao (%)",
"requestFailed": "Yêu cầu thất bại",
"smtpEncryption": "Mã hóa",
"smtpEncryptionDesc": "Phương thức mã hóa kết nối SMTP",
"smtpEncryptionNone": "Không (văn bản thuần)",
"smtpEncryptionStartTLS": "STARTTLS",
"smtpEncryptionTLS": "TLS (ngầm định)",
"smtpStageConnect": "Kết nối",
"smtpStageAuth": "Xác thực",
"smtpStageSend": "Gửi",
"smtpTestSuccess": "Đã gửi email thử nghiệm thành công",
"smtpHostNotConfigured": "Chưa cấu hình máy chủ SMTP",
"smtpNoRecipients": "Chưa cấu hình người nhận",
"smtpFromNotConfigured": "Chưa cấu hình địa chỉ người gửi SMTP",
"eventLoginAttempt": "Lần thử đăng nhập",
"telegramTokenConfigured": "Đã cấu hình; để trống để giữ token hiện tại.",
"telegramTokenPlaceholder": "Đã cấu hình - nhập token mới để thay thế",
"smtpPasswordConfigured": "Đã cấu hình; để trống để giữ mật khẩu hiện tại.",
"smtpPasswordPlaceholder": "Đã cấu hình - nhập mật khẩu mới để thay thế",
"smtpNotInitialized": "SMTP chưa được khởi tạo",
"tgBotNotEnabled": "Bot Telegram chưa được bật",
"tgTestFailed": "Thử nghiệm Telegram thất bại",
"tgTestSuccess": "Đã gửi tin nhắn thử nghiệm tới Telegram",
"tgBotNotRunning": "Bot Telegram không hoạt động",
"smtpErrorAuth": "Xác thực thất bại — kiểm tra tên đăng nhập và mật khẩu",
"smtpErrorStarttls": "Máy chủ yêu cầu STARTTLS — thay đổi kiểu mã hóa",
"smtpErrorTls": "Máy chủ yêu cầu TLS — thay đổi kiểu mã hóa",
"smtpErrorRefused": "Kết nối bị từ chối — kiểm tra máy chủ và cổng",
"smtpErrorTimeout": "Hết thời gian kết nối — không thể truy cập máy chủ",
"smtpErrorRelay": "Máy chủ từ chối gửi từ địa chỉ này",
"smtpErrorEof": "Kết nối đã bị máy chủ đóng",
"smtpErrorUnknown": "Lỗi SMTP: {{ .Error }}",
"eventMemoryHigh": "Sử dụng bộ nhớ cao (%)",
"remarkTemplate": "Mẫu ghi chú",
"remarkTemplateDesc": "Khi được đặt, mục này thay thế mô hình ghi chú cho mọi liên kết đăng ký — hãy viết định dạng riêng của bạn bằng các token biến (dùng nút để chèn chúng). Để trống để dùng mô hình ở trên.",
"subShowIdentityOnAllLinks": "Hiện danh tính trên mọi liên kết",
"subShowIdentityOnAllLinksDesc": "Khi bật, {{EMAIL}} và {{USERNAME}} vẫn có trong ghi chú mọi liên kết phần thân đăng ký. Token dung lượng vẫn chỉ ở liên kết đầu tiên.",
"validation": {
"pathLeadingSlash": "Đường dẫn phải bắt đầu bằng /"
},
"secretClear": "Xóa",
"secretClearUndo": "Hoàn tác xóa",
"calendarGregorian": "Gregorian (Standard)",
"calendarJalalian": "Jalalian (شمسی)",
"ipLimitAllowlist": "Danh sách cho phép của giới hạn IP",
"ipLimitAllowlistDesc": "Các địa chỉ và mạng mà giới hạn IP không bao giờ tính và không bao giờ chặn, để một địa chỉ dùng chung của văn phòng hoặc trường học không dùng hết giới hạn của người dùng. IPs/CIDRs cách nhau bằng dấu phẩy.",
"subBalancers": {
"menu": "Bộ cân bằng đăng ký",
"title": "Bộ cân bằng đăng ký",
"add": "Thêm bộ cân bằng",
"desc": "Mỗi bộ cân bằng đang bật được thêm vào đăng ký JSON như một hồ sơ riêng, tự động chọn điểm cuối tốt nhất trong các inbound đã chọn.",
"remark": "Ghi chú",
"remarkPlaceholder": "Tự động · nhanh nhất",
"strategy": "Chiến lược",
"strategyLeastLoad": "Tải thấp nhất",
"strategyLeastPing": "Ping thấp nhất",
"strategyRandom": "Ngẫu nhiên",
"strategyRoundRobin": "Luân phiên",
"sortOrder": "Thứ tự",
"sortOrderHelp": "Vị trí trong danh sách đăng ký, xen kẽ với thứ tự inbound; khi cùng số, bộ cân bằng đứng sau inbound.",
"inbounds": "Inbound",
"inboundsCount": "{count} Inbound",
"enabled": "Đã bật",
"empty": "Chưa có bộ cân bằng nào",
"deleteConfirm": "Xóa bộ cân bằng này?",
"errRemarkRequired": "Cần nhập ghi chú",
"errInboundsRequired": "Chọn ít nhất một inbound",
"errSortOrder": "Thứ tự phải là số nguyên ≥ 1",
"toasts": {
"list": "Không thể liệt kê các bộ cân bằng đăng ký",
"create": "Không thể tạo bộ cân bằng đăng ký",
"update": "Không thể cập nhật bộ cân bằng đăng ký",
"delete": "Không thể xóa bộ cân bằng đăng ký",
"invalidId": "Id không hợp lệ"
},
"tabBalancers": "Cân bằng",
"tabObservatory": "Observatory",
"observatory": {
"title": "Đài quan sát bộ cân bằng",
"desc": "Tham số probe cho burstObservatory nhúng vào mỗi hồ sơ leastPing/leastLoad. random/roundRobin không có đài quan sát. Lưu thành cài đặt chung của đăng ký JSON.",
"destination": "URL probe",
"destinationDesc": "Địa chỉ client thăm dò để đo mỗi outbound thành viên.",
"connectivity": "URL kết nối",
"connectivityDesc": "Địa chỉ tuỳ chọn để kiểm tra một lần thành viên có tới đích được không. Để trống để bỏ qua.",
"interval": "Khoảng probe",
"intervalDesc": "Thời gian giữa các vòng probe, vd. 1m.",
"timeout": "Hết giờ probe",
"timeoutDesc": "Hết giờ cho mỗi probe, vd. 5s.",
"sampling": "Lấy mẫu",
"samplingDesc": "Số lần probe liên tiếp để trung bình độ ổn định.",
"httpMethod": "Phương thức HTTP",
"httpMethodDesc": "Phương thức dùng cho yêu cầu probe.",
"note": "Các bộ cân bằng leastPing/leastLoad luôn mang một burstObservatory. Công tắc này tùy chỉnh các tham số probe — tắt nó để dùng mặc định tích hợp. Các thay đổi áp dụng sau khi khởi động lại bảng điều khiển."
}
}
},
"xray": {
"importRules": "Nhập quy tắc",
"exportRules": "Xuất quy tắc",
"importOutbounds": "Nhập outbound",
"exportOutbounds": "Xuất outbound",
"importInvalidJson": "JSON không hợp lệ — cần một mảng hoặc một đối tượng có khóa khớp.",
"metricsListen": "Điểm cuối Metrics",
"metricsListenDesc": "Hiển thị các chỉ số kiểu Prometheus của Xray tại địa chỉ:cổng này (ví dụ 127.0.0.1:11111). Để trống để tắt. Hãy gắn vào localhost và reverse-proxy nó — vì nó không có xác thực.",
"metricsTag": "Metrics Tag",
"save": "Lưu cài đặt",
"restartSuccess": "Đã khởi động lại Xray thành công",
"stopSuccess": "Xray đã được dừng thành công",
"restartError": "Đã xảy ra lỗi khi khởi động lại Xray.",
"stopError": "Đã xảy ra lỗi khi dừng Xray.",
"basicTemplate": "Mẫu Cơ bản",
"advancedTemplate": "Mẫu Nâng cao",
"generalConfigs": "Cấu hình Chung",
"generalConfigsDesc": "Những tùy chọn này sẽ cung cấp điều chỉnh tổng quát.",
"logConfigs": "Nhật ký",
"logConfigsDesc": "Nhật ký có thể ảnh hưởng đến hiệu suất máy chủ của bạn. Bạn chỉ nên kích hoạt nó một cách khôn ngoan trong trường hợp bạn cần",
"basicRouting": "Định tuyến Cơ bản",
"blockConnectionsConfigsDesc": "Các tùy chọn này sẽ chặn lưu lượng truy cập dựa trên quốc gia được yêu cầu cụ thể.",
"directConnectionsConfigsDesc": "Kết nối trực tiếp đảm bảo rằng lưu lượng truy cập cụ thể không được định tuyến qua máy chủ khác.",
"blockips": "Chặn IP",
"blockdomains": "Chặn Tên Miền",
"directips": "IP Trực Tiếp",
"directdomains": "Tên Miền Trực Tiếp",
"ipv4Routing": "Định tuyến IPv4",
"ipv4RoutingDesc": "Những tùy chọn này sẽ chỉ định kết nối đến các tên miền mục tiêu qua IPv4.",
"Template": "Mẫu Cấu hình Xray",
"TemplateDesc": "Tạo tệp cấu hình Xray cuối cùng dựa trên mẫu này.",
"FreedomStrategy": "Cấu hình Chiến lược cho Giao thức Freedom",
"FreedomStrategyDesc": "Đặt chiến lược đầu ra của mạng trong Giao thức Freedom.",
"FreedomHappyEyeballs": "Freedom Happy Eyeballs (IPv4/IPv6)",
"FreedomHappyEyeballsDesc": "Quay số dual-stack cho outbound trực tiếp (freedom) — hữu ích trên máy chủ thoát có cả IPv4 và IPv6.",
"FreedomHappyEyeballsTryDelayDesc": "Số mili-giây trước khi thử họ địa chỉ còn lại. 150–250 ms là điểm khởi đầu tốt.",
"RoutingStrategy": "Cấu hình Chiến lược Định tuyến Tên miền",
"RoutingStrategyDesc": "Đặt chiến lược định tuyến tổng thể cho việc giải quyết DNS.",
"outboundTestUrl": "URL kiểm tra outbound",
"outboundTestUrlDesc": "URL dùng khi kiểm tra kết nối outbound",
"Torrent": "Cấu hình sử dụng BitTorrent",
"Inbounds": "Inbound",
"Outbounds": "Outbound",
"Balancers": "Cân bằng",
"balancerTagRequired": "Tag là bắt buộc",
"balancerSelectorRequired": "Chọn ít nhất một outbound",
"balancerLive": "Mục tiêu hiện tại",
"balancerOverride": "Ghi đè đích",
"balancerOverridePh": "Tự động (chiến lược)",
"balancerLiveRefresh": "Làm mới trạng thái bộ cân bằng tải",
"balancerNotRunning": "Bộ cân bằng này không hoạt động trong Xray đang chạy — hãy lưu thay đổi hoặc khởi động Xray trước",
"routeTester": "Kiểm tra tuyến đường",
"routeTesterDesc": "Hỏi Xray đang chạy outbound nào sẽ xử lý kết nối. Không có lưu lượng nào được gửi — quyết định đến thẳng từ công cụ định tuyến trực tiếp.",
"routeTesterDest": "Tên miền hoặc IP",
"routeTesterPort": "Cổng",
"routeTesterInbound": "Inbound",
"routeTesterProtocol": "Giao thức nhận diện",
"routeTesterTest": "Kiểm tra tuyến",
"routeTesterMatchedOutbound": "Outbound phù hợp",
"routeTesterViaBalancer": "qua bộ cân bằng tải",
"routeTesterDefaultOutbound": "Không có quy tắc định tuyến nào khớp — lưu lượng đến outbound mặc định (đầu tiên).",
"Routings": "Quy tắc định tuyến",
"completeTemplate": "Tất cả",
"logLevel": "Mức đăng nhập",
"logLevelDesc": "Cấp độ nhật ký cho nhật ký lỗi, cho biết thông tin cần được ghi lại.",
"accessLog": "Nhật ký truy cập",
"accessLogDesc": "Đường dẫn tệp cho nhật ký truy cập. Nhật ký truy cập bị vô hiệu hóa có giá trị đặc biệt 'không'",
"errorLog": "Nhật ký lỗi",
"errorLogDesc": "Đường dẫn tệp cho nhật ký lỗi. Nhật ký lỗi bị vô hiệu hóa có giá trị đặc biệt 'không'",
"dnsLog": "Nhật ký DNS",
"dnsLogDesc": "Có bật nhật ký truy vấn DNS không",
"maskAddress": "Ẩn Địa Chỉ",
"maskAddressDesc": "Mặt nạ địa chỉ IP, khi được bật, sẽ tự động thay thế địa chỉ IP xuất hiện trong nhật ký.",
"statistics": "Thống kê",
"statsInboundUplink": "Thống kê tải lên đầu vào",
"statsInboundDownlink": "Thống kê tải xuống đầu vào",
"statsOutboundUplink": "Thống kê tải lên đầu ra",
"statsOutboundDownlink": "Thống kê tải xuống đầu ra",
"connectionLimits": "Giới hạn kết nối",
"connectionLimitsDesc": "Chính sách cấp kết nối cho người dùng cấp 0. Để trống một trường để sử dụng giá trị mặc định của Xray.",
"connIdle": "Thời gian chờ nhàn rỗi",
"connIdleDesc": "Đóng kết nối sau khi nó ở trạng thái nhàn rỗi trong số giây này. Giảm giá trị này giúp giải phóng bộ nhớ và file descriptor nhanh hơn trên các máy chủ bận (mặc định của Xray: 300).",
"bufferSize": "Kích thước bộ đệm",
"bufferSizeDesc": "Kích thước bộ đệm nội bộ trên mỗi kết nối tính bằng KB. Đặt thành 0 để giảm thiểu mức sử dụng bộ nhớ trên các máy chủ ít RAM (giá trị mặc định của Xray tùy thuộc vào nền tảng).",
"bufferSizePlaceholder": "tự động",
"seconds": "giây",
"rules": {
"source": "Nguồn",
"dest": "Đích",
"inbound": "Vào",
"balancer": "Cân bằng",
"useComma": "Các mục được phân tách bằng dấu phẩy"
},
"routing": {
"dragToReorder": "Kéo để sắp xếp lại"
},
"geoBrowser": {
"title": "Danh mục geo",
"openTooltip": "Duyệt danh mục geo",
"database": "Cơ sở dữ liệu",
"searchCategory": "Tìm danh mục",
"searchEntries": "Lọc trong danh mục",
"selectFound": "Chọn các kết quả",
"selected": "Đã chọn {count}",
"clearAll": "Xóa tất cả",
"apply": "Áp dụng",
"emptySelection": "Đánh dấu danh mục — chúng sẽ trở thành token của quy tắc",
"pickCategory": "Chọn một danh mục ở bên trái để xem nội dung",
"noMatches": "Không tìm thấy gì",
"noFiles": "Không có cơ sở dữ liệu geo trong thư mục Xray",
"noFilesHint": "Chúng sẽ xuất hiện sau khi Xray tải geosite.dat và geoip.dat",
"fileMeta": "{count} danh mục · {size} · cập nhật {date}",
"entriesCount": "{count} mục",
"subnetsCount": "{count} dải mạng",
"shownRange": "Hiển thị {from}–{to} trong {total}",
"loadFailed": "Không thể tải cơ sở dữ liệu geo",
"checkFailed": "Không thể kiểm tra các giá trị này với cơ sở dữ liệu geo",
"parseFailed": "Tệp bị hỏng hoặc không phải cơ sở dữ liệu geosite/geoip",
"tooLarge": "Tệp quá lớn để duyệt",
"unknownCategories": "Không có trong cơ sở dữ liệu: {tokens}",
"missingDatabase": "Không tìm thấy tệp cơ sở dữ liệu: {tokens} — hãy thêm trong mục Geodata",
"unknownAttribute": "Không tìm thấy thuộc tính, quy tắc sẽ không khớp với bất kỳ thứ gì: {tokens}",
"invalidToken": "Xray sẽ không chấp nhận mục này: {tokens}",
"wrongKind": "Sai loại cơ sở dữ liệu cho trường này: {tokens}"
},
"ruleForm": {
"sourceIps": "IP nguồn",
"sourcePort": "Cổng nguồn",
"vlessRoute": "Đường VLESS",
"attributes": "Thuộc tính",
"value": "Giá trị",
"user": "Người dùng",
"userPlaceholder": "Chọn người dùng",
"userEmpty": "Không có người dùng khả dụng",
"userLoadError": "Không thể tải người dùng",
"inboundTags": "Tag inbound",
"outboundTag": "Tag outbound",
"balancerTag": "Tag balancer",
"balancerTagTooltip": "Định tuyến lưu lượng qua một trong các bộ cân bằng tải đã cấu hình"
},
"outboundForm": {
"tagDuplicate": "Tag đã được dùng bởi outbound khác",
"tagRequired": "Tag là bắt buộc",
"tagPlaceholder": "tag-duy-nhất",
"localIpPlaceholder": "IP nội bộ",
"dialerProxyPlaceholder": "Chọn một outbound để nối chuỗi",
"dialerProxyHint": "Kết nối outbound này qua một outbound khác (theo tag) để tạo chuỗi proxy. Để trống để kết nối trực tiếp.",
"targetStrategyHint": "Cách phân giải tên miền đích trước khi kết nối: AsIs (mặc định) gửi nguyên trạng, UseIP… phân giải kèm dự phòng, ForceIP… bắt buộc phân giải thành công.",
"addressRequired": "Địa chỉ là bắt buộc",
"portRequired": "Cổng là bắt buộc",
"optional": "tùy chọn",
"udpOverTcp": "UDP over TCP",
"uotVersion": "Phiên bản UoT",
"inboundTag": "Tag inbound",
"inboundTagPlaceholder": "tag inbound dùng trong quy tắc định tuyến",
"responseType": "Loại phản hồi",
"rewriteNetwork": "Viết lại mạng",
"unchanged": "(không đổi)",
"unchangedAddress": "(không đổi) ví dụ 1.1.1.1",
"rules": "Quy tắc",
"ruleN": "Quy tắc {n}",
"action": "Hành động",
"redirect": "Redirect",
"finalRules": "Quy tắc cuối",
"overrideXrayPrivateIp": "Ghi đè chặn IP riêng mặc định của Xray",
"blockDelay": "Trễ chặn (ms)",
"reverseSniffing": "Sniffing ngược",
"reserved": "Đã đặt trước",
"minUploadInterval": "Khoảng upload tối thiểu (ms)",
"maxUploadSizeBytes": "Kích thước upload tối đa (byte)",
"uplinkChunkSize": "Kích thước chunk Uplink",
"noGrpcHeader": "Không có header gRPC",
"maxConcurrency": "Đồng thời tối đa",
"maxConnections": "Kết nối tối đa",
"maxReuseTimes": "Số lần tái sử dụng tối đa",
"maxRequestTimes": "Số yêu cầu tối đa",
"maxReusableSecs": "Số giây tái sử dụng tối đa",
"keepAlivePeriod": "Chu kỳ keep alive",
"authPassword": "Mật khẩu auth",
"visionTestpre": "Vision testpre",
"serverNamePlaceholder": "tên máy chủ",
"verifyPeerName": "Xác minh tên peer",
"pinnedSha256": "SHA256 pinned",
"shortId": "Short ID",
"sockopts": "Sockopts",
"keepAliveInterval": "Khoảng keep alive",
"markFwmark": "Mark (fwmark)",
"interface": "Giao diện",
"proxyProtocol": "Proxy protocol",
"tcpUserTimeoutMs": "TCP user timeout (ms)",
"tcpKeepAliveIdleS": "TCP keep-alive idle (s)"
},
"outbound": {
"tag": "Tag",
"egress": "Egress",
"egressHint": "Run an HTTP test to show egress IP and country.",
"outboundStatus": "Trạng thái đầu ra",
"sendThrough": "Gửi qua",
"targetStrategy": "Chiến lược đích",
"modeRealDelay": "Độ trễ thực",
"testModeTooltip": "TCP: probe dial nhanh. HTTP: yêu cầu đầy đủ qua xray. Độ trễ thực: tổng thời gian gồm cả thiết lập kết nối.",
"testAll": "Kiểm tra tất cả",
"httpStatus": "Trạng thái HTTP",
"breakdownConnect": "Kết nối proxy",
"breakdownTls": "TLS qua outbound",
"breakdownTtfb": "Byte đầu tiên",
"country": "Quốc gia",
"server": "Máy chủ",
"city": "Thành phố",
"allCities": "Tất cả thành phố",
"moveToTop": "Chuyển lên đầu"
},
"outboundSub": {
"manage": "Đăng ký",
"title": "Đăng ký Outbound",
"remark": "Ghi chú (tùy chọn)",
"remarkPlaceholder": "ví dụ node HK",
"url": "URL đăng ký",
"urlPlaceholder": "https://... (danh sách liên kết base64)",
"tagPrefix": "Tiền tố tag",
"tagPrefixPlaceholder": "hk-",
"interval": "Khoảng cập nhật",
"hours": "giờ",
"minutes": "phút",
"intervalHint": "Mặc định 10 phút. Tác vụ nền kiểm tra thường xuyên; mỗi đăng ký chỉ tải lại khi khoảng thời gian riêng của nó đã trôi qua.",
"enabled": "Đã kích hoạt",
"allowPrivate": "Cho phép địa chỉ riêng tư",
"allowPrivateHint": "Cho phép localhost / mạng LAN / IP riêng tư đối với URL của đăng ký này. Mặc định tắt vì lý do bảo mật — chỉ bật khi nguồn cục bộ đáng tin cậy.",
"prepend": "Trước các outbound thủ công",
"prependHint": "Đặt các outbound của đăng ký này trước các outbound bạn cấu hình thủ công, để một trong số đó có thể trở thành mặc định.",
"preview": "Xem trước",
"previewEmpty": "Không tìm thấy outbound nào tại URL này.",
"refreshAll": "Cập nhật tất cả",
"statusOk": "OK",
"toastUpdated": "Đã cập nhật đăng ký",
"addButton": "Thêm",
"active": "Đăng ký đang hoạt động",
"empty": "Chưa có đăng ký nào. Hãy thêm một mục ở trên.",
"colRemark": "Ghi chú",
"colLastFetch": "Lần tải gần nhất",
"colEnabled": "Đã kích hoạt",
"auto": "tự động",
"never": "không bao giờ",
"refreshNow": "Cập nhật ngay",
"deleteConfirm": "Xóa đăng ký này?",
"restartHint": "Sau khi thêm hoặc cập nhật, hãy khởi động lại Xray (hoặc chờ lần tự động tải lại tiếp theo) để kích hoạt các outbound.",
"fromSubsTitle": "Từ đăng ký outbound (chỉ đọc)",
"fromSubsDesc": "Được nhập từ các đăng ký đang hoạt động của bạn. Hãy quản lý chúng trong bảng Đăng ký ở trên.",
"toastLoadFailed": "Không thể tải danh sách đăng ký",
"toastUrlRequired": "URL đăng ký là bắt buộc",
"toastAdded": "Đã thêm đăng ký",
"toastAddFailed": "Không thể thêm đăng ký",
"toastRefreshed": "Đã cập nhật",
"toastRefreshFailed": "Cập nhật thất bại",
"toastDeleted": "Đã xóa",
"toastDeleteFailed": "Xóa thất bại"
},
"pia": {
"menu": "PIA",
"username": "Tên người dùng PIA",
"password": "Mật khẩu PIA",
"account": "Tài khoản",
"region": "Khu vực",
"allRegions": "Tất cả khu vực",
"noServers": "Không có máy chủ cho quốc gia đã chọn",
"outboundAdded": "Đã thêm outbound PIA",
"outboundUpdated": "Đã cập nhật outbound PIA",
"addedServers": "Máy chủ đã thêm",
"alreadyAdded": "Máy chủ này đã có trong danh sách outbound. Dùng {reset} để gia hạn khóa.",
"provisionFailed": "Không tạo được outbound PIA. Hãy thử lại."
},
"tabBalancerSettings": "Cài đặt Balancer",
"tabObservatory": "Observatory",
"observatory": {
"autoManaged": "Observer được quản lý tự động từ các balancer của bạn. Điều chỉnh cách chúng dò ở bên dưới; các outbound được theo dõi sẽ tuân theo selector của balancer.",
"emptyHint": "Không có observer kết nối nào đang hoạt động. Một observer sẽ được thêm tự động khi bạn tạo balancer Least Ping hoặc Least Load — hoặc balancer Random / Round-robin có fallback — để các balancer dùng observer có thể kiểm tra sức khỏe outbound trước khi chọn mục tiêu.",
"mixedLegacy": "Cấu hình này có cả Observatory và Burst Observatory. Xray chỉ dùng một observer toàn cục, nên trạng thái hỗn hợp cũ này không được hỗ trợ; khi lưu balancer, nó sẽ được chuẩn hóa về một observer.",
"subjectSelector": "Outbound được theo dõi",
"subjectSelectorDesc": "Các thẻ outbound mà observer này dò. Được quản lý tự động từ các balancer của bạn.",
"probeURL": "URL dò",
"probeURLDesc": "URL được yêu cầu để đo mỗi outbound. Phải trả về HTTP 204.",
"probeInterval": "Khoảng thời gian dò",
"probeIntervalDesc": "Tần suất dò mỗi outbound, ví dụ 30s, 1m, 2h45m.",
"enableConcurrency": "Dò đồng thời",
"enableConcurrencyDesc": "Dò tất cả outbound được theo dõi cùng lúc thay vì lần lượt. Nhanh hơn nhưng dễ bị phát hiện trên mạng hơn.",
"destination": "Đích dò",
"destinationDesc": "URL được yêu cầu để đo mỗi outbound. Phải trả về HTTP 204.",
"connectivity": "Kiểm tra kết nối",
"connectivityDesc": "URL kiểm tra mạng cục bộ tùy chọn, chỉ thử sau khi đích thất bại. Để trống để bỏ qua.",
"interval": "Khoảng thời gian dò",
"intervalDesc": "Thời gian trung bình giữa các lần dò cho mỗi outbound, ví dụ 1m. Tối thiểu 10s.",
"timeout": "Thời gian chờ dò",
"timeoutDesc": "Thời gian chờ một lần dò trước khi coi là thất bại, ví dụ 5s.",
"sampling": "Số mẫu",
"samplingDesc": "Số kết quả dò gần đây được giữ để chấm điểm mỗi outbound.",
"httpMethod": "Phương thức HTTP",
"httpMethodDesc": "Phương thức HTTP dùng cho việc dò.",
"deleteAlsoObservatory": "Đây là balancer cuối cùng dùng Observatory, nên nó cũng sẽ bị xóa.",
"deleteAlsoBurst": "Đây là balancer cuối cùng dùng Burst Observatory, nên nó cũng sẽ bị xóa."
},
"refCleanup": {
"header": "Xóa mục này cũng cập nhật định tuyến của bạn:",
"ruleRemoved": "Quy tắc {label} — đã xóa (không còn đích đến)",
"ruleModified": "Quy tắc {label} — giữ lại (giờ dùng {keeps})",
"balancerRemoved": "Balancer {tag} — đã xóa (không còn mục tiêu)"
},
"balancer": {
"balancerStrategy": "Chiến lược",
"tag": "Tag",
"tagDuplicate": "Tag đã được dùng bởi balancer khác",
"tagPlaceholder": "tag balancer duy nhất",
"selector": "Selector",
"fallback": "Fallback",
"cycleTooltip": "Vòng lặp: {path} → (quay lại {start})",
"expected": "Kỳ vọng",
"expectedPlaceholder": "số node tối ưu",
"maxRtt": "RTT tối đa",
"tolerance": "Dung sai",
"baselines": "Baselines",
"costs": "Costs",
"costMatch": "Mẫu thẻ",
"costValue": "Trọng số",
"costRegexp": "Khớp biểu thức chính quy",
"balancerDeleteInUse": "Không thể xóa load balancer này — nó được sử dụng làm dự phòng cho: {names}",
"balancerFallbackCycle": "Không thể đặt load balancer này làm dự phòng — sẽ tạo ra phụ thuộc vòng.",
"balancerFallbackInfo": "Lưu lượng sẽ được định tuyến qua: Load Balancer → Loopback → Máy chủ → Load Balancer mục tiêu → kết nối ra ngoài. Điều này thêm một hop bổ sung qua máy chủ, có thể gây ra độ trễ nhẹ.",
"fallbackBalancerHint": "Chọn một load balancer khác làm dự phòng",
"reservedPrefix": "Tiền tố _bl_ được dành riêng cho các đối tượng loopback nội bộ của bộ cân bằng"
},
"wireguard": {
"secretKey": "Khoá bí mật",
"publicKey": "Khóa công khai",
"subnetIp": "Mạng con",
"subnetCidr": "CIDR mạng con",
"allowedIPs": "IP được phép",
"endpoint": "Điểm cuối",
"domainStrategy": "Chiến lược tên miền"
},
"amneziawg": {
"privateKey": "Khóa riêng",
"publicKey": "Khóa công khai",
"subnetIp": "Mạng con",
"subnetCidr": "CIDR mạng con",
"mtu": "MTU",
"primaryDns": "DNS chính",
"secondaryDns": "DNS phụ",
"externalInterface": "Giao diện ngoài",
"externalInterfaceHint": "Card mạng của host dùng cho NAT (PostUp/PostDown). Để trống để tự động phát hiện.",
"ipv6Enabled": "Bật IPv6",
"ipv6Subnet": "Subnet IPv6",
"ipv6SubnetHint": "vd. fd86:ea04:1115::/64. Bắt buộc khi bật IPv6.",
"ipv6ExternalInterface": "Card mạng ngoài IPv6",
"ipv6ExternalInterfaceHint": "Card mạng của host dùng cho các mục NDP proxy. Để trống để dùng lại Card mạng ngoài.",
"obfuscation": "Tham số làm rối (obfuscation)",
"regenerateObfuscation": "Tạo lại",
"jc": "Jc (số lượng gói rác)",
"jmin": "Jmin (kích thước tối thiểu gói rác)",
"jmax": "Jmax (kích thước tối đa gói rác)",
"s1": "S1 (đệm gói init)",
"s2": "S2 (đệm gói response)",
"s3": "S3 (đệm cookie reply)",
"s4": "S4 (đệm gói transport)",
"h1": "H1 (tiêu đề ma thuật)",
"h2": "H2 (tiêu đề ma thuật)",
"h3": "H3 (tiêu đề ma thuật)",
"h4": "H4 (tiêu đề ma thuật)",
"hHint": "Một số nguyên hoặc một khoảng. Để trống để dùng giá trị mặc định cổ điển 1/2/3/4.",
"i1": "I1 (gói chữ ký)",
"i1Hint": "Gói chữ ký tùy chọn. Để trống để bỏ qua.",
"i2": "I2 (gói chữ ký)",
"i3": "I3 (gói chữ ký)",
"i4": "I4 (gói chữ ký)",
"i5": "I5 (gói chữ ký)",
"headerProtectionKey": "HeaderProtectionKey (bảo vệ header)",
"headerProtectionKeyHint": "Khóa Base64 dài 32 byte; phải trùng khớp trong cấu hình của mọi client. Để trống để tắt bảo vệ header.",
"contentPaddingAddition": "ContentPaddingAddition (đệm nội dung)",
"contentPaddingAdditionHint": "Một số nguyên hoặc khoảng byte được thêm vào các gói nội dung. Để trống để tắt.",
"rekeyAfterTime": "RekeyAfterTime (giây)",
"rekeyTimeout": "RekeyTimeout (giây)",
"rejectAfterTime": "RejectAfterTime (giây)",
"keepaliveTimeout": "KeepaliveTimeout (giây)",
"maxHandshakeAttempts": "MaxHandshakeAttempts",
"timingRangeHint": "Một số nguyên hoặc một khoảng. Để trống để dùng giá trị mặc định của WireGuard.",
"maxHandshakeAttemptsHint": "Số lần thử lại bắt tay trước khi bỏ cuộc. Để trống để dùng giá trị mặc định.",
"randomTrailers": "RandomTrailers",
"randomTrailersHint": "Thêm các byte ngẫu nhiên vào cuối mỗi gói. Cả hai đầu cần AmneziaWG 3.1+.",
"disableCookies": "DisableCookies",
"disableCookiesHint": "Không bao giờ gửi cookie reply — xóa một dấu vết DPI nhưng làm yếu khả năng chống flood."
},
"tun": {
"userLevel": "Mức Người Dùng"
},
"nord": {
"accessToken": "Access token",
"privateKey": "Khóa riêng",
"noServers": "Không tìm thấy máy chủ cho quốc gia đã chọn",
"noPublicKey": "Máy chủ đã chọn không công bố khóa công khai NordLynx.",
"outboundAdded": "Đã thêm outbound NordVPN",
"outboundUpdated": "Đã cập nhật outbound NordVPN"
},
"warp": {
"changeIp": "Đổi IP",
"changeIpSuccess": "Đã đổi IP WARP thành công!",
"autoUpdateIp": "Tự động cập nhật địa chỉ IP",
"intervalDays": "Khoảng thời gian (ngày)",
"intervalDesc": "0 để tắt. Tự động đổi địa chỉ IP.",
"licenseError": "Không thiết lập được giấy phép WARP.",
"fetchFirst": "Hãy lấy cấu hình WARP trước.",
"createAccount": "Tạo tài khoản WARP",
"accessToken": "Access token",
"deviceId": "ID thiết bị",
"licenseKey": "Khóa giấy phép",
"privateKey": "Khóa riêng",
"deleteAccount": "Xóa tài khoản",
"settings": "Cài đặt",
"licenseKeyLabel": "Khóa giấy phép WARP / WARP+",
"key": "Khóa",
"keyPlaceholder": "khóa WARP+ 26 ký tự",
"accountInfo": "Thông tin tài khoản",
"deviceName": "Tên thiết bị",
"deviceModel": "Kiểu thiết bị",
"deviceEnabled": "Thiết bị đã bật",
"accountType": "Loại tài khoản",
"role": "Vai trò",
"warpPlusData": "Dữ liệu WARP+",
"quota": "Hạn ngạch",
"usage": "Sử dụng",
"addOutbound": "Thêm outbound"
},
"dns": {
"enable": "Kích hoạt DNS",
"enableDesc": "Kích hoạt máy chủ DNS tích hợp",
"tag": "Thẻ gửi đến DNS",
"tagDesc": "Thẻ này sẽ có sẵn dưới dạng thẻ Gửi đến trong quy tắc định tuyến.",
"clientIp": "IP khách hàng",
"clientIpDesc": "Được sử dụng để thông báo cho máy chủ về vị trí IP được chỉ định trong các truy vấn DNS",
"disableCache": "Tắt bộ nhớ đệm",
"disableCacheDesc": "Tắt bộ nhớ đệm DNS",
"disableFallback": "Tắt Fallback",
"disableFallbackDesc": "Tắt các truy vấn DNS Fallback",
"disableFallbackIfMatch": "Tắt Fallback Nếu Khớp",
"disableFallbackIfMatchDesc": "Tắt các truy vấn DNS Fallback khi danh sách tên miền khớp của máy chủ DNS được kích hoạt",
"enableParallelQuery": "Bật Truy vấn Song song",
"enableParallelQueryDesc": "Bật truy vấn DNS song song đến nhiều máy chủ để phân giải nhanh hơn",
"strategy": "Chiến lược truy vấn",
"strategyDesc": "Chiến lược tổng thể để phân giải tên miền",
"add": "Thêm máy chủ",
"edit": "Chỉnh sửa máy chủ",
"domains": "Tên miền",
"expectIPs": "Các IP Dự Kiến",
"unexpectIPs": "IP không mong muốn",
"useSystemHosts": "Sử dụng Hosts hệ thống",
"useSystemHostsDesc": "Sử dụng file hosts từ hệ thống đã cài đặt",
"serveStale": "Phục vụ kết quả hết hạn",
"serveStaleDesc": "Trả về kết quả cache đã hết hạn trong khi làm mới ở chế độ nền",
"serveExpiredTTL": "TTL hết hạn",
"serveExpiredTTLDesc": "Thời gian hiệu lực (giây) của các mục cache hết hạn; 0 = không bao giờ hết hạn",
"timeoutMs": "Thời gian chờ (ms)",
"skipFallback": "Bỏ qua Fallback",
"finalQuery": "Truy vấn cuối",
"hosts": "Hosts",
"hostsAdd": "Thêm Host",
"hostsEmpty": "Chưa có Host nào",
"hostsDomain": "Tên miền (vd. domain:example.com)",
"hostsValues": "IP hoặc tên miền — nhập và nhấn Enter",
"usePreset": "Dùng mẫu",
"dnsPresetTitle": "Mẫu DNS",
"dnsPresetFamily": "Gia đình",
"clearAll": "Xóa tất cả",
"clearAllTitle": "Xóa tất cả máy chủ DNS?",
"clearAllConfirm": "Thao tác này sẽ xóa toàn bộ máy chủ DNS khỏi danh sách. Không thể hoàn tác.",
"dnsLeakWarning": "DNS có thể rò rỉ qua localhost, UDP/TCP không mã hóa, DoH/DoQ chế độ cục bộ, truy vấn fallback hoặc EDNS client IP. Hãy dùng DoH được định tuyến, ghim resolver trong hosts và tắt fallback khi cần riêng tư."
},
"fakedns": {
"add": "Thêm DNS giả",
"ipPool": "Mạng con nhóm IP",
"poolSize": "Kích thước bể bơi"
},
"defaultOutbound": "Outbound mặc định",
"defaultOutboundDesc": "Lưu lượng không khớp quy tắc định tuyến dùng outbound này (mục đầu danh sách)."
},
"hosts": {
"addHost": "Thêm Host",
"editHost": "Sửa Host",
"selectInbound": "Chọn một inbound",
"selectedCount": "Đã chọn {count}",
"summary": {
"total": "Tổng",
"enabled": "Đã kích hoạt",
"disabled": "Đã tắt"
},
"moveUp": "Lên",
"moveDown": "Xuống",
"bulkEnable": "Kích hoạt",
"bulkDisable": "Tắt",
"bulkDelete": "Xóa",
"bulkDeleteConfirm": "Xóa {count} host đã chọn?",
"deleteConfirmTitle": "Xóa host \"{name}\"?",
"sections": {
"basic": "Cơ bản",
"security": "Bảo mật",
"advanced": "Nâng cao",
"general": "Chung",
"clash": "Clash (mihomo)"
},
"fields": {
"remark": "Ghi chú",
"serverDescription": "Mô tả",
"inbound": "Inbounds",
"address": "Địa chỉ",
"port": "Cổng",
"endpoint": "Endpoint",
"enable": "Kích hoạt",
"actions": "Hành động",
"security": "Bảo mật",
"sni": "SNI",
"overrideSniFromAddress": "Dùng địa chỉ làm SNI",
"keepSniBlank": "Để trống SNI",
"hostHeader": "Host header",
"path": "Đường dẫn",
"alpn": "ALPN",
"fingerprint": "Fingerprint",
"pins": "SHA-256 chứng chỉ đã ghim",
"verifyPeerCertByName": "Xác minh chứng chỉ peer theo tên",
"allowInsecure": "Cho phép không an toàn",
"echConfigList": "Danh sách cấu hình ECH",
"muxParams": "Mux",
"sockoptParams": "Sockopt",
"finalMask": "Final Mask",
"vlessRoute": "Đường VLESS",
"mihomoIpVersion": "Phiên bản IP",
"mihomoX25519": "Mihomo X25519",
"shuffleHost": "Xáo trộn host",
"tags": "Tag",
"nodeGuids": "Nút",
"excludeFromSubTypes": "Loại trừ khỏi định dạng",
"inheritAddress": "Kế thừa địa chỉ"
},
"hints": {
"address": "Để trống để kế thừa địa chỉ của chính inbound.",
"port": "0 sẽ kế thừa cổng của inbound.",
"tags": "Không hiển thị cho người dùng cuối; chỉ gửi kèm đăng ký RAW. Chỉ chữ in hoa, chữ số, _ và :.",
"nodeGuids": "Chọn các nút được phân giải từ host này. Chỉ là gán trực quan.",
"serverDescription": "Ghi chú tùy chọn hiển thị bên dưới ghi chú.",
"allowInsecure": "Bỏ qua xác minh chứng chỉ TLS (allowInsecure / skip-cert-verify).",
"vlessRoute": "Một giá trị định tuyến VLESS (0-65535) được nhúng vào UUID, ví dụ 443. Để trống nếu không dùng.",
"remark": "Nhãn đơn giản cho host này. Chỉ hiển thị làm tên cấu hình khi inbound không có ghi chú riêng."
},
"remarkVars": {
"title": "Biến mẫu",
"intro": "Nhấp vào một biến để thêm. Biến được thay thế cho từng client khi tạo đăng ký.",
"preview": "Xem trước",
"groups": {
"client": "Khách hàng",
"traffic": "Lưu lượng",
"time": "Thời gian & trạng thái",
"connection": "Kết nối"
},
"descEMAIL": "Email khách hàng",
"descINBOUND": "Ghi chú của chính inbound (tên cấu hình)",
"descHOST": "Ghi chú host",
"descID": "UUID khách hàng",
"descSHORT_ID": "8 ký tự đầu của UUID",
"descTELEGRAM_ID": "ID Telegram của khách hàng (rỗng nếu chưa đặt)",
"descSUB_ID": "ID đăng ký",
"descCOMMENT": "Bình luận khách hàng",
"descTRAFFIC_USED": "Lưu lượng đã dùng (dễ đọc)",
"descTRAFFIC_LEFT": "Lưu lượng còn lại (ẩn nếu không giới hạn)",
"descTRAFFIC_TOTAL": "Tổng lưu lượng (ẩn nếu không giới hạn)",
"descTRAFFIC_USED_BYTES": "Lưu lượng đã dùng tính bằng byte",
"descTRAFFIC_LEFT_BYTES": "Lưu lượng còn lại tính bằng byte",
"descTRAFFIC_TOTAL_BYTES": "Tổng lưu lượng tính bằng byte",
"descUP": "Lưu lượng tải lên",
"descDOWN": "Lưu lượng tải xuống",
"descSTATUS": "active / expired / disabled / depleted",
"descSTATUS_EMOJI": "Trạng thái dạng biểu tượng cảm xúc (✅ ⏳ 🚫)",
"descDAYS_LEFT": "Số ngày đến khi hết hạn (ẩn nếu không giới hạn)",
"descTIME_LEFT": "Thời gian còn lại (ví dụ 12d 4h 30m)",
"descUSAGE_PERCENTAGE": "Lưu lượng đã dùng tính theo phần trăm (ẩn nếu không giới hạn)",
"descEXPIRE_DATE": "Ngày hết hạn (YYYY-MM-DD)",
"descJALALI_EXPIRE_DATE": "Ngày hết hạn theo lịch Jalali (YYYY/MM/DD)",
"descEXPIRE_UNIX": "Hết hạn dạng dấu thời gian Unix (giây)",
"descCREATED_UNIX": "Thời điểm tạo dạng dấu thời gian Unix (giây)",
"descRESET_DAYS": "Chu kỳ đặt lại lưu lượng tính theo ngày",
"descRESET_DAY": "Ngày trong tháng để gia hạn",
"descPROTOCOL": "Giao thức inbound (VLESS, VMess, Trojan, …)",
"descTRANSPORT": "Mạng truyền tải (tcp, ws, grpc, …)",
"descSECURITY": "Bảo mật truyền tải (TLS, REALITY, NONE)"
},
"toasts": {
"list": "Không tải được danh sách host",
"obtain": "Không tải được host",
"add": "Thêm host",
"update": "Cập nhật host",
"delete": "Xóa host",
"badTag": "Tag không hợp lệ",
"badVlessRoute": "Nhập một số duy nhất từ 0 đến 65535"
}
}
},
"tgbot": {
"keyboardClosed": "❌ Bàn phím đã đóng!",
"noResult": "❗ Không có kết quả!",
"noQuery": "❌ Không tìm thấy truy vấn! Vui lòng sử dụng lại lệnh!",
"wentWrong": "❌ Đã xảy ra lỗi!",
"noIpRecord": "❗ Không có bản ghi IP!",
"noInbounds": "❗ Không tìm thấy inbound!",
"unlimited": "♾ Không giới hạn (Đặt lại)",
"add": "Thêm",
"month": "Tháng",
"months": "Tháng",
"days": "Ngày",
"hours": "Giờ",
"minutes": "Phút",
"unknown": "Không xác định",
"inbounds": "Inbound",
"clients": "Client",
"offline": "🔴 Ngoại tuyến",
"online": "🟢 Trực tuyến",
"commands": {
"unknown": "❗ Lệnh không rõ",
"pleaseChoose": "👇 Vui lòng chọn:\r\n",
"help": "🤖 Chào mừng bạn đến với bot này! Bot được thiết kế để cung cấp cho bạn dữ liệu cụ thể từ máy chủ và cho phép bạn thực hiện các thay đổi cần thiết.\r\n\r\n",
"start": "👋 Xin chào <i>{{ .Firstname }}</i>.\r\n",
"welcome": "🤖 Chào mừng đến với bot quản lý của <b>{{ .Hostname }}</b>.\r\n",
"status": "✅ Bot hoạt động bình thường!",
"usage": "❗ Vui lòng cung cấp văn bản để tìm kiếm!",
"getID": "🆔 ID của bạn: <code>{{ .ID }}</code>",
"helpAdminCommands": "Để khởi động lại Xray Core:\r\n<code>/restart</code>\r\n\r\nĐể tìm kiếm email của khách hàng:\r\n<code>/usage [Email]</code>\r\n\r\nĐể tìm kiếm các nhập (với số liệu thống kê của khách hàng):\r\n<code>/inbound [Ghi chú]</code>\r\n\r\nID Trò chuyện Telegram:\r\n<code>/id</code>",
"helpClientCommands": "Để tìm kiếm thống kê, sử dụng lệnh sau:\r\n<code>/usage [Email]</code>\r\n\r\nID Trò chuyện Telegram:\r\n<code>/id</code>",
"restartUsage": "\r\n\r\n<code>/restart</code>",
"restartSuccess": "✅ Hoạt động thành công!",
"restartFailed": "❗ Lỗi trong quá trình hoạt động.\r\n\r\n<code>Lỗi: {{ .Error }}</code>.",
"xrayNotRunning": "❗ Xray Core không chạy.",
"startDesc": "Hiển thị menu chính",
"helpDesc": "Trợ giúp bot",
"statusDesc": "Kiểm tra trạng thái bot",
"idDesc": "Hiển thị ID Telegram của bạn",
"usageDesc": "Xem mức dùng của khách: /usage email",
"inboundDesc": "Tìm inbound: /inbound tên (quản trị)",
"restartDesc": "Khởi động lại lõi Xray (quản trị)",
"clearallDesc": "Đặt lại lưu lượng mọi khách hàng (quản trị)"
},
"messages": {
"cpuThreshold": "Sử dụng CPU {{ .Percent }}% vượt quá ngưỡng {{ .Threshold }}%",
"selectUserFailed": "❌ Lỗi khi chọn người dùng!",
"userSaved": "✅ Người dùng Telegram đã được lưu.",
"loginSuccess": "✅ Đăng nhập thành công vào bảng điều khiển.\r\n",
"loginFailed": "❗️ Đăng nhập vào bảng điều khiển thất bại.\r\n",
"report": "🕰 Báo cáo định kỳ: {{ .RunTime }}\r\n",
"datetime": "⏰ Ngày-Giờ: {{ .DateTime }}\r\n",
"hostname": "💻 Host: {{ .Hostname }}\r\n",
"version": "🚀 Phiên bản X-UI: {{ .Version }}\r\n",
"xrayVersion": "📡 Phiên bản Xray: {{ .XrayVersion }}\r\n",
"ipv6": "🌐 IPv6: {{ .IPv6 }}\r\n",
"ipv4": "🌐 IPv4: {{ .IPv4 }}\r\n",
"ip": "🌐 IP: {{ .IP }}\r\n",
"ips": "🔢 IPs:\r\n{{ .IPs }}\r\n",
"serverUpTime": "⏳ Thời gian hoạt động của máy chủ: {{ .UpTime }} {{ .Unit }}\r\n",
"serverLoad": "📈 Tải máy chủ: {{ .Load1 }}, {{ .Load2 }}, {{ .Load3 }}\r\n",
"serverMemory": "📋 RAM: {{ .Current }}/{{ .Total }}\r\n",
"tcpCount": "🔹 TCP: {{ .Count }}\r\n",
"udpCount": "🔸 UDP: {{ .Count }}\r\n",
"traffic": "🚦 Lưu lượng: {{ .Total }} (↑{{ .Upload }},↓{{ .Download }})\r\n",
"xrayStatus": "ℹ️ Trạng thái: {{ .State }}\r\n",
"username": "👤 Tên người dùng: {{ .Username }}\r\n",
"reason": "❗️ Lý do: {{ .Reason }}\r\n",
"time": "⏰ Thời gian: {{ .Time }}\r\n",
"inbound": "📍 Inbound: {{ .Remark }}\r\n",
"port": "🔌 Cổng: {{ .Port }}\r\n",
"expire": "📅 Ngày hết hạn: {{ .Time }}\r\n",
"expireIn": "📅 Hết hạn sau: {{ .Time }}\r\n",
"active": "💡 Đang hoạt động: {{ .Enable }}\r\n",
"enabled": "🚨 Đã bật: {{ .Enable }}\r\n",
"online": "🌐 Trạng thái kết nối: {{ .Status }}\r\n",
"lastOnline": "🔙 Lần online gần nhất: {{ .Time }}\r\n",
"email": "📧 Email: {{ .Email }}\r\n",
"upload": "🔼 Tải lên: ↑{{ .Upload }}\r\n",
"download": "🔽 Tải xuống: ↓{{ .Download }}\r\n",
"total": "📊 Tổng: ↑↓{{ .UpDown }} / {{ .Total }}\r\n",
"TGUser": "👤 Người dùng Telegram: {{ .TelegramID }}\r\n",
"exhaustedCount": "🚨 Số lần cạn kiệt {{ .Type }}:\r\n",
"onlinesCount": "🌐 Khách hàng trực tuyến: {{ .Count }}\r\n",
"disabled": "🛑 Vô hiệu hóa: {{ .Disabled }}\r\n",
"depleteSoon": "🔜 Sắp cạn kiệt: {{ .Deplete }}\r\n\r\n",
"backupTime": "🗄 Thời gian sao lưu: {{ .Time }}\r\n",
"refreshedOn": "\r\n📋🔄 Đã cập nhật lần cuối vào: {{ .Time }}\r\n\r\n",
"yes": "✅ Có",
"no": "❌ Không",
"received_email": "📧📥 Email đã được cập nhật.",
"received_comment": "💬📥 Bình luận đã được cập nhật.",
"email_prompt": "📧 Email mặc định: {{ .ClientEmail }}\n\nVui lòng nhập email của bạn.",
"comment_prompt": "💬 Bình luận mặc định: {{ .ClientComment }}\n\nVui lòng nhập bình luận của bạn.",
"cancel": "❌ Quá trình đã bị hủy! \n\nBạn có thể bắt đầu lại bất cứ lúc nào bằng cách nhập /start. 🔄",
"error_add_client": "⚠️ Lỗi:\n\n {{ .error }}",
"using_default_value": "Được rồi, tôi sẽ sử dụng giá trị mặc định. 😊",
"incorrect_input": "Dữ liệu bạn nhập không hợp lệ.\nCác chuỗi phải liền mạch và không có dấu cách.\nVí dụ đúng: aaaaaa\nVí dụ sai: aaa aaa 🚫",
"AreYouSure": "Bạn có chắc không? 🤔",
"SuccessResetTraffic": "📧 Email: {{ .ClientEmail }}\n🏁 Kết quả: ✅ Thành công",
"FailedResetTraffic": "📧 Email: {{ .ClientEmail }}\n🏁 Kết quả: ❌ Thất bại \n\n🛠️ Lỗi: [ {{ .ErrorMessage }} ]",
"FinishProcess": "🔚 Quá trình đặt lại lưu lượng đã hoàn tất cho tất cả khách hàng.",
"eventOutboundDown": "Outbound {{ .Tag }} đã NGỪNG HOẠT ĐỘNG",
"eventOutboundUp": "Outbound {{ .Tag }} đã HOẠT ĐỘNG",
"eventErrorDetail": "Lỗi: {{ .Error }}",
"eventDelayDetail": "Độ trễ: {{ .Delay }}ms",
"eventXrayCrash": "Xray GẶP SỰ CỐ",
"eventXrayCrashError": "Lỗi: {{ .Error }}",
"eventNodeDown": "Node {{ .Name }} đã NGỪNG HOẠT ĐỘNG",
"eventNodeUp": "Node {{ .Name }} đã HOẠT ĐỘNG",
"eventLoginFallback": "Đăng nhập thất bại từ {{ .Source }}",
"memoryThreshold": "Sử dụng bộ nhớ {{ .Percent }}% vượt quá ngưỡng {{ .Threshold }}%"
},
"buttons": {
"closeKeyboard": "❌ Đóng Bàn Phím",
"cancel": "❌ Hủy",
"cancelReset": "❌ Hủy Đặt Lại",
"cancelIpLimit": "❌ Hủy Giới Hạn IP",
"confirmResetTraffic": "✅ Xác Nhận Đặt Lại Lưu Lượng?",
"confirmClearIps": "✅ Xác Nhận Xóa Các IP?",
"confirmRemoveTGUser": "✅ Xác Nhận Xóa Người Dùng Telegram?",
"confirmToggle": "✅ Xác nhận Bật/Tắt người dùng?",
"dbBackup": "Tải bản sao lưu cơ sở dữ liệu",
"serverUsage": "Sử Dụng Máy Chủ",
"getInbounds": "Lấy cổng vào",
"depleteSoon": "Depleted Soon",
"clientUsage": "Lấy Sử Dụng",
"onlines": "Khách hàng trực tuyến",
"commands": "Lệnh",
"refresh": "🔄 Cập Nhật",
"clearIPs": "❌ Xóa IP",
"removeTGUser": "❌ Xóa Người Dùng Telegram",
"selectTGUser": "👤 Chọn Người Dùng Telegram",
"selectOneTGUser": "👤 Chọn một người dùng telegram:",
"resetTraffic": "📈 Đặt Lại Lưu Lượng",
"resetExpire": "📅 Thay đổi ngày hết hạn",
"ipLog": "🔢 Nhật ký địa chỉ IP",
"ipLimit": "🔢 Giới Hạn địa chỉ IP",
"setTGUser": "👤 Đặt Người Dùng Telegram",
"toggle": "🔘 Bật / Tắt",
"custom": "🔢 Tùy chỉnh",
"confirmNumber": "✅ Xác nhận: {{ .Num }}",
"confirmNumberAdd": "✅ Xác nhận thêm: {{ .Num }}",
"limitTraffic": "🚧 Giới hạn lưu lượng",
"getBanLogs": "Cấm nhật ký",
"allClients": "Tất cả Khách hàng",
"addClient": "Thêm Khách Hàng",
"submitDisable": "Gửi Dưới Dạng Vô Hiệu ☑️",
"submitEnable": "Gửi Dưới Dạng Kích Hoạt ✅",
"use_default": "🏷️ Sử Dụng Mặc Định",
"change_email": "⚙️📧 Email",
"change_comment": "⚙️💬 Bình Luận",
"ResetAllTraffics": "Đặt lại tất cả lưu lượng",
"SortedTrafficUsageReport": "Báo cáo sử dụng lưu lượng đã sắp xếp"
},
"answers": {
"successfulOperation": "✅ Thành công!",
"errorOperation": "❗ Lỗi Trong Quá Trình Thực Hiện.",
"getInboundsFailed": "❌ Không Thể Lấy Được Inbounds",
"getClientsFailed": "❌ Không thể lấy khách hàng.",
"canceled": "❌ {{ .Email }} : Thao Tác Đã Bị Hủy.",
"clientRefreshSuccess": "✅ {{ .Email }} : Cập Nhật Thành Công Cho Khách Hàng.",
"IpRefreshSuccess": "✅ {{ .Email }} : Cập Nhật Thành Công Cho IPs.",
"TGIdRefreshSuccess": "✅ {{ .Email }} : Cập Nhật Thành Công Cho Người Dùng Telegram.",
"resetTrafficSuccess": "✅ {{ .Email }} : Đặt Lại Lưu Lượng Thành Công.",
"setTrafficLimitSuccess": "✅ {{ .Email }} : Đã lưu thành công giới hạn lưu lượng.",
"expireResetSuccess": "✅ {{ .Email }} : Đặt Lại Ngày Hết Hạn Thành Công.",
"resetIpSuccess": "✅ {{ .Email }} : Giới Hạn IP {{ .Count }} Đã Được Lưu Thành Công.",
"clearIpSuccess": "✅ {{ .Email }} : IP Đã Được Xóa Thành Công.",
"getIpLog": "✅ {{ .Email }} : Lấy nhật ký IP Thành Công.",
"getUserInfo": "✅ {{ .Email }} : Lấy Thông Tin Người Dùng Telegram Thành Công.",
"removedTGUserSuccess": "✅ {{ .Email }} : Người Dùng Telegram Đã Được Xóa Thành Công.",
"enableSuccess": "✅ {{ .Email }} : Đã Bật Thành Công.",
"disableSuccess": "✅ {{ .Email }} : Đã Tắt Thành Công.",
"askToAddUserId": "Cấu hình của bạn không được tìm thấy!\r\nVui lòng yêu cầu Quản trị viên sử dụng ID người dùng telegram của bạn trong cấu hình của bạn.\r\n\r\nID người dùng của bạn: <code>{{ .TgUserID }}</code>",
"chooseClient": "Chọn một Khách hàng cho Inbound {{ .Inbound }}",
"chooseInbound": "Chọn một Inbound"
}
},
"email": {
"labelStatus": "Trạng thái",
"labelOutbound": "Outbound",
"labelNode": "Node",
"labelError": "Lỗi",
"labelDelay": "Độ trễ",
"labelUsername": "Tên đăng nhập",
"labelIP": "IP",
"labelReason": "Lý do",
"labelSource": "Nguồn",
"statusCrashed": "GẶP SỰ CỐ",
"statusHigh": "CAO",
"statusSuccess": "THÀNH CÔNG",
"statusFailed": "THẤT BẠI",
"statusDown": "NGỪNG HOẠT ĐỘNG",
"statusUp": "HOẠT ĐỘNG"
}
}
Reference in New Issue View Git Blame Copy Permalink