Dawnline 0.20.0
Build packages / CI (push) Blocked by required conditions
Build packages / Version (push) Waiting to run
CI / Web (format, types, tests, bundles) (push) Blocked by required conditions
CI / ShellCheck (push) Blocked by required conditions
CI / Backend (Go: vet, tests, a real ubusd and uhttpd) (push) Blocked by required conditions
CI / Package files (push) Blocked by required conditions
Build packages / CI (push) Blocked by required conditions
Build packages / Version (push) Waiting to run
CI / Web (format, types, tests, bundles) (push) Blocked by required conditions
CI / ShellCheck (push) Blocked by required conditions
CI / Backend (Go: vet, tests, a real ubusd and uhttpd) (push) Blocked by required conditions
CI / Package files (push) Blocked by required conditions
- **Backend rewritten in Go.** One daemon, `dawnlined`, replaces the whole ucode backend: the rpcd plugin, the agent, the CLI and the updater. The package no longer depends on ucode. - **Per-architecture builds.** The release carries the backend for arm64, ARMv7, mips, mipsle and amd64; the router fetches its own after the package is installed and checks its sha256. Dawnline does not run on other architectures (older ARM, 32-bit x86, RISC-V). - **Faster on the router.** A firewall sync takes 0.06 s instead of 0.9 s; a full apply takes about 300 ms. The portal is served by the daemon itself, without a CGI process per request. - **Live pages.** The admin and the portal follow a live stream from the router instead of re-fetching the whole state every 30 seconds. - **Admin redesigned in the portal's style.** Three sections (Overview · Log · Settings); a server is a page of its own with People, Places and Settings; a device opens as a dialog over its person. - **Changes wait for «Apply».** Every setting, and a person's access, is staged in one dock before it reaches the router. - **Configuration rollout.** After a change that makes devices fetch their configuration again, the admin shows how many have fetched it and who has not. Every setting shows beforehand (⟳N) how many devices it will touch. - **Waiting for a decision.** Overview and People put first the people who need one (access ended, limit reached, a device that does not connect), each with its one action a tap away. - **Bulk actions on people.** «Select» (or a long press on a card) picks several people to extend by a month, pause or resume at once. - **Undo.** An action done from a card or a request is undone from its toast. - **Update dialogs redesigned.** An update is one view from its question to its result; Dawnline's own update runs in it like every other, and the page reloads itself once the new version answers. Other versions are a list, each with its notes and Install on a page of its own. - **Site to site: networks behind a router.** A router connected as a device can have networks behind it (up to eight, /16 to /30): the server routes them and applies the router's access to them. A network that shares addresses with a tunnel, the router's own networks or another site is refused by name. - **Routers from the portal.** People can add a router and name its networks on their own page; the admin accepts or declines with a reason, or lets them through without asking. - **Check access and Health know the networks behind routers.** - **Usage limits reworked.** A monthly limit no longer follows the calendar. A person's month starts with their first traffic and ends a month later; the next one starts only when they connect again, so time away uses up none of it. Before, everyone's limit reset on the 1st. - Extra data lasts until that person's month ends; «Reset usage» starts the month anew. - A limit is for a month or for the whole term; the admin and the portal show when it resets. - Charts that said «this month» show the last 30 days. - After the update nobody loses what was counted: the month that was running becomes the person's first and ends on the 1st. - **Access by time of day removed.** The Hours limit is gone from the admin, the portal and the backend; saved hours are dropped. - **Expiry simplified.** An end date always stops access, with a heads-up three days before; the per-person choice is gone. - **No false disconnects from sleeping phones.** A phone or a tablet stays online through ten minutes of silence. - **Mobile Safari fixes.** Pressing a control no longer sends the page to its top; tab tracks that do not fit scroll; switches animate after a press.
This commit is contained in:
1 parent
f8130e39a8
commit
ac90575b0b
788 files changed
+139244
-41720
No files matched your search
@@ -0,0 +1,349 @@
|
||||
// Package handout is what a device is given: its configuration (the .conf and what the AmneziaVPN key is
|
||||
// made of) and the fingerprint that tells whether the one it holds is still the one it would get. As
|
||||
// dawnline.awg client_config, allowed_ips and config_fingerprint make them, character for character: a
|
||||
// fingerprint that differed between the two backends would tell every device to import again.
|
||||
//
|
||||
// Pure: the settings and the home networks in, text out. The home networks are the router's own (which
|
||||
// interfaces are home, and what they reach): the caller reads them and hands them in.
|
||||
package handout
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"github.com/tickcount/luci-app-dawnline/backend/ipnet"
|
||||
"github.com/tickcount/luci-app-dawnline/backend/model"
|
||||
)
|
||||
|
||||
// ObfKeys is the disguise's settings in the order a configuration lists them (dawnline.core OBF_KEYS).
|
||||
var ObfKeys = []string{"jc", "jmin", "jmax", "s1", "s2", "s3", "s4", "h1", "h2", "h3", "h4", "i1", "i2", "i3", "i4", "i5",
|
||||
"header_protection_key", "content_padding_addition", "rekey_after_time", "rekey_timeout", "reject_after_time",
|
||||
"keepalive_timeout", "max_handshake_attempts", "random_trailers", "disable_cookies"}
|
||||
|
||||
// What each is called in a .conf (dawnline.awg OBF_CONF).
|
||||
var obfConf = map[string]string{
|
||||
"jc": "Jc", "jmin": "Jmin", "jmax": "Jmax", "s1": "S1", "s2": "S2", "s3": "S3", "s4": "S4",
|
||||
"h1": "H1", "h2": "H2", "h3": "H3", "h4": "H4", "i1": "I1", "i2": "I2", "i3": "I3", "i4": "I4", "i5": "I5",
|
||||
"header_protection_key": "HeaderProtectionKey", "content_padding_addition": "ContentPaddingAddition",
|
||||
"rekey_after_time": "RekeyAfterTime", "rekey_timeout": "RekeyTimeout", "reject_after_time": "RejectAfterTime",
|
||||
"keepalive_timeout": "KeepaliveTimeout", "max_handshake_attempts": "MaxHandshakeAttempts",
|
||||
"random_trailers": "RandomTrailers", "disable_cookies": "DisableCookies",
|
||||
}
|
||||
|
||||
// Bypass4 is every IPv4 address but the private ranges, and Bypass6 every IPv6 one outside fc00::/7,
|
||||
// fe80::/10 and ff00::/8: what a device with its own local network kept outside sends into the tunnel
|
||||
// (tests/ucode/awg.test.uc proves each is exactly that complement).
|
||||
var Bypass4 = []string{
|
||||
"0.0.0.0/5", "8.0.0.0/7", "11.0.0.0/8", "12.0.0.0/6", "16.0.0.0/4", "32.0.0.0/3", "64.0.0.0/3", "96.0.0.0/6",
|
||||
"100.0.0.0/10", "100.128.0.0/9", "101.0.0.0/8", "102.0.0.0/7", "104.0.0.0/5", "112.0.0.0/4", "128.0.0.0/3", "160.0.0.0/5",
|
||||
"168.0.0.0/8", "169.0.0.0/9", "169.128.0.0/10", "169.192.0.0/11", "169.224.0.0/12", "169.240.0.0/13", "169.248.0.0/14",
|
||||
"169.252.0.0/15", "169.255.0.0/16", "170.0.0.0/7", "172.0.0.0/12", "172.32.0.0/11", "172.64.0.0/10", "172.128.0.0/9",
|
||||
"173.0.0.0/8", "174.0.0.0/7", "176.0.0.0/4", "192.0.0.0/9", "192.128.0.0/11", "192.160.0.0/13", "192.169.0.0/16",
|
||||
"192.170.0.0/15", "192.172.0.0/14", "192.176.0.0/12", "192.192.0.0/10", "193.0.0.0/8", "194.0.0.0/7", "196.0.0.0/6",
|
||||
"200.0.0.0/5", "208.0.0.0/4",
|
||||
}
|
||||
var Bypass6 = []string{"::/1", "8000::/2", "c000::/3", "e000::/4", "f000::/5", "f800::/6", "fe00::/9", "fec0::/10"}
|
||||
|
||||
// AllowedIPs is what a device sends into the tunnel. Home only: the person's home networks, the tunnel
|
||||
// network or the router's address, and the DNS. Internet: everything, or with the device's own local
|
||||
// network kept outside everything but that, every DNS server it is given and for home access what Home
|
||||
// only gets. `home` is the home networks the person reaches; dev may be nil.
|
||||
//
|
||||
// What is behind other people's routers is part of what a device reaches: a device that sends only some
|
||||
// networks into the tunnel gets those too (as the settings have them: which of them the router has taken
|
||||
// is the router's to know, and a network it has not is dropped there).
|
||||
func AllowedIPs(m *model.Model, srv *model.Server, p *model.Person, dev *model.Device, home []string) []string {
|
||||
if p.Access != "lan" && (dev == nil || !dev.LanBypass) {
|
||||
return []string{"0.0.0.0/0", "::/0"}
|
||||
}
|
||||
reach := func() []string {
|
||||
nets := append([]string{}, home...)
|
||||
// With devices reaching each other, the whole tunnel network (the router's address is in it);
|
||||
// otherwise only the router's own address.
|
||||
if srv.DeviceMesh && srv.Subnet != "" {
|
||||
nets = append(nets, srv.Subnet)
|
||||
} else if a := model.ServerAddress(srv); a != "" {
|
||||
nets = append(nets, a+"/32")
|
||||
}
|
||||
id := ""
|
||||
if dev != nil {
|
||||
id = dev.ID
|
||||
}
|
||||
return append(nets, m.BehindReach(p, id, m.BehindOf(nil))...)
|
||||
}
|
||||
dns := m.ClientDNS(srv, p)
|
||||
if p.Access == "lan" {
|
||||
nets := reach()
|
||||
if len(dns) > 0 && dns[0] != "" {
|
||||
nets = append(nets, dns[0]+"/32")
|
||||
}
|
||||
return ipnet.Collapse(nets)
|
||||
}
|
||||
// Every DNS server stays in the tunnel: a private one left out would be asked on whatever network
|
||||
// the device is on (a public one is in the rest).
|
||||
nets := append([]string{}, Bypass4...)
|
||||
var nets6 []string
|
||||
seen6 := map[string]bool{}
|
||||
for _, a := range dns {
|
||||
if _, ok := ipnet.IP(a); ok {
|
||||
nets = append(nets, a+"/32")
|
||||
} else if ipnet.Private6(a) && !seen6[a] {
|
||||
seen6[a] = true
|
||||
nets6 = append(nets6, a+"/128")
|
||||
}
|
||||
}
|
||||
if p.Access == "both" {
|
||||
nets = append(nets, reach()...)
|
||||
}
|
||||
out := append(ipnet.Collapse(nets), Bypass6...)
|
||||
return append(out, nets6...)
|
||||
}
|
||||
|
||||
// ObfNeutral tells whether the disguise's settings change nothing on the wire (plain WireGuard).
|
||||
func ObfNeutral(o map[string]string) bool {
|
||||
for _, k := range ObfKeys {
|
||||
v := o[k]
|
||||
if v == "" {
|
||||
continue
|
||||
}
|
||||
want := "0"
|
||||
switch k {
|
||||
case "h1":
|
||||
want = "1"
|
||||
case "h2":
|
||||
want = "2"
|
||||
case "h3":
|
||||
want = "3"
|
||||
case "h4":
|
||||
want = "4"
|
||||
}
|
||||
if v != want {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// clientObf is the disguise a device's configuration carries. The junk a device sends is its own: within
|
||||
// the preset's ranges the count and sizes are shifted a little by the device (the same way every time, so
|
||||
// the configuration keeps its fingerprint), so two phones of one family do not share one profile. What
|
||||
// the server must agree on stays the server's.
|
||||
func clientObf(srv *model.Server, dev *model.Device) map[string]string {
|
||||
o := map[string]string{}
|
||||
for k, v := range srv.Obf {
|
||||
o[k] = v
|
||||
}
|
||||
num := func(s string) (int64, bool) {
|
||||
f, ok := model.Number(s)
|
||||
return int64(f), ok && s != ""
|
||||
}
|
||||
jc, ok := num(o["jc"])
|
||||
if ObfNeutral(o) || !ok || jc <= 0 {
|
||||
return o
|
||||
}
|
||||
key := srv.ID + "/" + dev.ID + "/" + srv.Obf["h1"]
|
||||
seed := int64(2166136261)
|
||||
for i := 0; i < len(key); i++ {
|
||||
seed = ((seed ^ int64(key[i])) * 16777619) & 0x7fffffff
|
||||
}
|
||||
pick := func(n int64) int64 {
|
||||
seed = (seed*1103515245 + 12345) & 0x7fffffff
|
||||
return seed % n
|
||||
}
|
||||
jmin, _ := num(o["jmin"])
|
||||
jmax, _ := num(o["jmax"])
|
||||
o["jc"] = strconv.FormatInt(max(1, min(10, jc+pick(3)-1)), 10)
|
||||
if jmax > jmin+32 {
|
||||
lo := jmin + pick(17)
|
||||
hi := jmax - pick(17)
|
||||
if hi <= lo {
|
||||
hi = lo + 32
|
||||
}
|
||||
o["jmin"], o["jmax"] = strconv.FormatInt(lo, 10), strconv.FormatInt(hi, 10)
|
||||
}
|
||||
return o
|
||||
}
|
||||
|
||||
// Amnezia is what the AmneziaVPN key is made of.
|
||||
type Amnezia struct {
|
||||
Host string `json:"host"`
|
||||
Port int `json:"port"`
|
||||
MTU string `json:"mtu"`
|
||||
DNS []string `json:"dns"`
|
||||
AllowedIPs []string `json:"allowed_ips"`
|
||||
ClientIP string `json:"client_ip"`
|
||||
ClientPrivKey string `json:"client_priv_key"`
|
||||
ClientPubKey string `json:"client_pub_key"`
|
||||
PSKKey string `json:"psk_key"`
|
||||
ServerPubKey string `json:"server_pub_key"`
|
||||
PersistentKeepAlive string `json:"persistent_keep_alive"`
|
||||
Obfuscation map[string]string `json:"obfuscation"`
|
||||
}
|
||||
|
||||
// Config is a device's configuration.
|
||||
type Config struct {
|
||||
Name string `json:"name"`
|
||||
Person string `json:"person"`
|
||||
Server string `json:"server"`
|
||||
Filename string `json:"filename"`
|
||||
Conf string `json:"conf"`
|
||||
HasPrivateKey bool `json:"has_private_key"`
|
||||
Amnezia Amnezia `json:"amnezia"`
|
||||
}
|
||||
|
||||
// ClientConfig is the configuration a device gets now, or nil when it has no server.
|
||||
func ClientConfig(m *model.Model, dev *model.Device, home []string) *Config {
|
||||
p := m.People[dev.Person]
|
||||
if p == nil {
|
||||
return nil
|
||||
}
|
||||
srv := m.Servers[p.Server]
|
||||
if srv == nil {
|
||||
return nil
|
||||
}
|
||||
host := m.EndpointHost(srv)
|
||||
ep := host
|
||||
if strings.Contains(host, ":") && !strings.HasPrefix(host, "[") {
|
||||
ep = "[" + host + "]"
|
||||
}
|
||||
allowed := AllowedIPs(m, srv, p, dev, home)
|
||||
dns := m.ClientDNS(srv, p)
|
||||
mtu := model.DeviceMTU(srv, dev)
|
||||
priv := dev.PrivateKey
|
||||
if priv == "" {
|
||||
priv = "<private key stays on your device>"
|
||||
}
|
||||
lines := []string{"[Interface]", "PrivateKey = " + priv, "Address = " + dev.Address + "/32"}
|
||||
if len(dns) > 0 {
|
||||
lines = append(lines, "DNS = "+strings.Join(dns, ", "))
|
||||
}
|
||||
lines = append(lines, fmt.Sprintf("MTU = %d", mtu))
|
||||
// "Off" is plain WireGuard: neutral values are left out, so any WireGuard app accepts the file.
|
||||
obf := clientObf(srv, dev)
|
||||
if !ObfNeutral(obf) {
|
||||
for _, k := range ObfKeys {
|
||||
if obf[k] != "" {
|
||||
lines = append(lines, obfConf[k]+" = "+obf[k])
|
||||
}
|
||||
}
|
||||
}
|
||||
lines = append(lines, "", "[Peer]", "PublicKey = "+srv.PublicKey)
|
||||
if dev.PresharedKey != "" {
|
||||
lines = append(lines, "PresharedKey = "+dev.PresharedKey)
|
||||
}
|
||||
lines = append(lines, "AllowedIPs = "+strings.Join(allowed, ", "), fmt.Sprintf("Endpoint = %s:%d", ep, srv.Port))
|
||||
keepalive := ""
|
||||
if lo, hi, on := model.KeepaliveRange(srv, dev); on {
|
||||
keepalive = strconv.Itoa(lo)
|
||||
if hi != lo {
|
||||
keepalive = fmt.Sprintf("%d-%d", lo, hi)
|
||||
}
|
||||
lines = append(lines, "PersistentKeepalive = "+keepalive)
|
||||
}
|
||||
alive := keepalive
|
||||
if alive == "" {
|
||||
alive = "0"
|
||||
}
|
||||
return &Config{
|
||||
Name: dev.Name, Person: p.Name, Server: srv.Name,
|
||||
// The file name is the tunnel's name in WireGuard apps: the server's.
|
||||
Filename: TunnelName(srv.Name) + ".conf",
|
||||
Conf: strings.Join(lines, "\n") + "\n",
|
||||
HasPrivateKey: dev.PrivateKey != "",
|
||||
Amnezia: Amnezia{
|
||||
Host: host, Port: srv.Port, MTU: strconv.Itoa(mtu), DNS: dns, AllowedIPs: allowed,
|
||||
ClientIP: dev.Address, ClientPrivKey: dev.PrivateKey, ClientPubKey: dev.PublicKey,
|
||||
PSKKey: dev.PresharedKey, ServerPubKey: srv.PublicKey, PersistentKeepAlive: alive, Obfuscation: obf,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// Fingerprint is what a device holds, minus what is its own alone (its private key, its junk's count and
|
||||
// sizes): it changes when the device must import again. "" for a device with no server.
|
||||
func Fingerprint(m *model.Model, dev *model.Device, home []string) string {
|
||||
c := ClientConfig(m, dev, home)
|
||||
if c == nil {
|
||||
return ""
|
||||
}
|
||||
var keep []string
|
||||
for _, l := range strings.Split(c.Conf, "\n") {
|
||||
own := false
|
||||
for _, k := range []string{"PrivateKey ", "Jc ", "Jmin ", "Jmax "} {
|
||||
own = own || strings.HasPrefix(l, k)
|
||||
}
|
||||
if !own {
|
||||
keep = append(keep, l)
|
||||
}
|
||||
}
|
||||
h := uint32(2166136261)
|
||||
for _, b := range []byte(strings.Join(keep, "\n")) {
|
||||
h = (h ^ uint32(b)) * 16777619
|
||||
}
|
||||
return fmt.Sprintf("%08x", h)
|
||||
}
|
||||
|
||||
// Cyrillic letters written in Latin, from а (dawnline.util translit).
|
||||
var cyrillic = []string{"a", "b", "v", "g", "d", "e", "zh", "z", "i", "y", "k", "l", "m", "n", "o", "p", "r", "s", "t", "u",
|
||||
"f", "kh", "ts", "ch", "sh", "shch", "", "y", "", "e", "yu", "ya"}
|
||||
var cyrillicMore = map[rune]string{0x451: "yo", 0x456: "i", 0x457: "yi", 0x454: "ye", 0x491: "g"}
|
||||
|
||||
// Translit writes Cyrillic letters in Latin ("Мама" → "mama"); other characters are left alone.
|
||||
func Translit(s string) string {
|
||||
var b strings.Builder
|
||||
for _, r := range s {
|
||||
switch {
|
||||
case r >= 0x410 && r <= 0x42f:
|
||||
r += 0x20
|
||||
case r == 0x401:
|
||||
r = 0x451
|
||||
case r == 0x406:
|
||||
r = 0x456
|
||||
case r == 0x407:
|
||||
r = 0x457
|
||||
case r == 0x404:
|
||||
r = 0x454
|
||||
case r == 0x490:
|
||||
r = 0x491
|
||||
}
|
||||
if r >= 0x430 && int(r-0x430) < len(cyrillic) {
|
||||
b.WriteString(cyrillic[r-0x430])
|
||||
} else if t, ok := cyrillicMore[r]; ok {
|
||||
b.WriteString(t)
|
||||
} else {
|
||||
b.WriteRune(r)
|
||||
}
|
||||
}
|
||||
return b.String()
|
||||
}
|
||||
|
||||
// Names Windows keeps for devices: no file may be called that.
|
||||
var winDevices = map[string]bool{"con": true, "prn": true, "aux": true, "nul": true}
|
||||
|
||||
// TunnelName is a server's name as a tunnel's (a file's) name: Latin letters and digits, at most 15.
|
||||
func TunnelName(name string) string {
|
||||
var b strings.Builder
|
||||
gap := false
|
||||
for _, c := range []byte(Translit(name)) {
|
||||
if c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9' {
|
||||
if gap {
|
||||
b.WriteByte('-')
|
||||
}
|
||||
gap = false
|
||||
b.WriteByte(c)
|
||||
} else {
|
||||
gap = true
|
||||
}
|
||||
}
|
||||
// a gap at either end is trimmed: one before the first letter was written as a dash above
|
||||
l := strings.Trim(b.String(), "-")
|
||||
if len(l) > 15 {
|
||||
l = l[:15]
|
||||
}
|
||||
l = strings.TrimRight(l, "-")
|
||||
low := strings.ToLower(l)
|
||||
if l == "" || winDevices[low] || (len(low) == 4 && (strings.HasPrefix(low, "com") || strings.HasPrefix(low, "lpt")) && low[3] >= '1' && low[3] <= '9') {
|
||||
return "dawnline"
|
||||
}
|
||||
return l
|
||||
}
|
||||
Reference in new issue
Block a user