Dawnline 0.6.0

- Access rules fail closed: when the table cannot load, no device is loaded
  into the tunnels (the firewall alone would let every loaded device reach
  everything); an older table that survived a failed rebuild keeps its rules
  and a revoked device still leaves. The agent re-syncs within a minute when
  the table is gone
- A change the router saved but could not put into effect (access rules that
  did not load, a server that refused its devices) is said in the admin UI
  instead of a plain "Saved"
- The guard judges every packet, not only a connection's first: a change of
  access, a pause or a limit now cuts open connections too
- Each server's home networks are its own: with several servers, "all home"
  on one no longer reaches the other's networks where firewall zones overlap
- People limited to some home networks reach the router only on the
  addresses in those networks (LuCI and SSH on the main LAN stay closed)
- Internet-only people can open their personal portal with the VPN on
- Tunnel DNS reaches the resolver and the LAN's DNS from servers that do not
  forward to those zones on their own (Home-only names on servers without
  "like a home device", LAN DNS on servers with no home network)
- A new personal link offers to remove the devices added through the old one,
  so a leaked link is really contained
- Import and restore refuse an inconsistent file (devices with addresses
  outside their server, shared addresses, malformed keys, broken references);
  Health reports one, and the sync leaves such a device out instead of
  failing its server. A config write that did not reach flash is an error,
  not a silent success
- Backups are kept per kind (nightly ones no longer push out manual or
  pre-delete ones), nightly and pre-change backups hold the config only,
  archives are written whole or not at all, and a failed nightly backup is
  logged. A restore no longer has its history overwritten by the agent's
  in-memory counters
- Settings defaults and ranges come from one place (dawnline.schema)
- Portal: anything not shaped like a personal link is answered by a shell
  before ucode starts (a scan on the root costs nothing); 4 portal processes
  at once instead of 16; a link may make 40 changes a quarter hour; over
  plain HTTP the page shows but configurations, new devices and new keys are
  refused with the HTTPS twin of the link; the connect sheet polls only while
  the first connection is awaited, with backoff, and stops once the link
  stopped working
- Updates: after Dawnline's own package changes, a shell checks that LuCI
  reaches it and the agent runs, and puts the kept previous version back when
  they do not (automatic runs always keep it); the AmneziaWG module reload
  verifies rmmod and modprobe; installs check free space; on apk a reinstall
  that changed nothing is an error; uninstall.sh hands the update lock to the
  removal it calls; an upgrade restarts the service only where it was
  enabled; the release workflow pins the SDK images by digest and the actions
  by commit
- AmneziaWG: features count only when both the tools and the kernel module
  have them; a server whose disguise this build cannot run (a 3.1 preset
  after a rollback to 2.0) is kept down and reported; Components tells 1.0
  builds from 2.0 ones; `awg show dump` is parsed by shape; Maximum's
  DNS-shaped signature packets are made for each server and its keep-alive
  is a 25-35 s range
- CI compiles every ucode file and runs the new tests/ucode unit tests (54
  tests on the real libuci) in OpenWrt 24.10 and 25.12 rootfs containers;
  scripts/compile-ucode.sh does the same wherever ucode runs and
  scripts/ucode-container.sh locally with docker; lint-ucode checks POSIX
  regexes and module layering; a tag builds only after CI passes
This commit is contained in:
Aemeath committed 2026-10-18 15:32:27 +03:00
1 parent 2b98abdba4
commit 31a2065f05
70 files changed
+2008 -307

No files matched your search

@@ -154,12 +154,20 @@ function from_device(m, d, t, states, dmp, snap) {
// The router itself.
if (index(router_addrs(snap), t.ip) >= 0) {
if (home_access(p))
push(steps, step(true, `${t.ip} is this router`, 'Home access includes the router.'));
else if (t.port == 53)
let portal = m.settings.portal_enabled && (t.port == m.settings.portal_port || (core.portal_http(m) && t.port == core.portal_http_port(m)));
if (t.port == 53)
push(steps, step(true, `${t.ip} is this router: DNS is open to everyone`, ''));
else
return stop(steps, step(false, `${t.ip} is this router`, `${p.name} has ${ACCESS_TEXT[p.access]}: only DNS on the router.`));
else if (portal)
push(steps, step(true, `${t.ip} is this router: the personal portal is open to everyone`, ''));
else if (!home_access(p))
return stop(steps, step(false, `${t.ip} is this router`, `${p.name} has ${ACCESS_TEXT[p.access]}: only DNS and the portal on the router.`));
else {
// Like any home address: only on the networks the person reaches.
let h = core.person_home(srv, p, snap);
if (!h.all && !in_nets(t.ip, h.nets))
return stop(steps, step(false, `${t.ip} is this router on a network ${p.name} doesn't reach`, `${p.name} reaches ${join(', ', h.devs) || 'no home network'}.`));
push(steps, step(true, `${t.ip} is this router`, h.all ? 'Home access includes the router.' : `On one of the networks ${p.name} reaches.`));
}
push(steps, via(t.ip));
return steps;
}
@@ -82,37 +82,44 @@ export function access_sets(m, usage, states) {
return nft.access_sets(m, usage, states);
};
/** Log an access-table failure once per distinct error; true when the table is in place. */
function nft_result(err) {
/**
* Log an access-table failure once per distinct error (with what it means
* for the devices: none loaded while the table is missing, the previous rules
* kept when an older one survived the failed rebuild); the error, or null.
*/
function nft_result(err, present) {
let was = readfile(NFT_ERR);
if (err == null) {
if (was != null)
unlink(NFT_ERR);
return true;
return null;
}
if (was != err) {
log('Access rules', "couldn't load — devices aren't loaded into the tunnels until they do", 'error', err);
log('Access rules', present
? "couldn't be updated — the previous rules stay, and changes to access wait until they load"
: "couldn't load — no device is loaded into the tunnels until they do", 'error', err);
ensure_dir(RUN_DIR);
writefile(NFT_ERR, err);
}
return false;
return err;
}
/**
* The table in place: rebuilt with `full`, otherwise members only, rebuilt
* when that fails (no table yet at boot, or an older shape) — an error only
* when the rebuild fails too.
* when that fails (no table yet at boot, or an older shape). Null, or the
* error when the rebuild fails too.
*/
function load_table(m, sets, full) {
let err = full ? nft.rebuild(m, sets) : nft.update(sets);
if (err != null && !full)
err = nft.rebuild(m, sets);
return nft_result(err);
return nft_result(err, err != null && nft.present());
}
/** Full table rebuild (structure changes: servers, LAN subnets). */
/** Full table rebuild (structure changes: servers, LAN subnets); true when it loaded. */
export function rebuild_nft(m, sets) {
return nft_result(nft.rebuild(m, sets));
let err = nft.rebuild(m, sets);
return nft_result(err, err != null && nft.present()) == null;
};
/** Atomically replace set contents only. */
@@ -131,32 +138,57 @@ export function firewall_drift(m) {
/* ---------- runtime sync ---------- */
/**
* What an admin should hear when a sync did not fully take: the access table
* failed, or a server did not accept its devices. Null when all went in.
*/
function sync_warning(m, table, peers) {
let out = [];
if (table != null)
push(out, nft.present()
? `Access rules couldn't be updated (${table}): the previous rules stay, so this change isn't in effect yet.`
: `Access rules couldn't load (${table}): no device is loaded into the tunnels until they do.`);
for (let id, r in peers)
if (r != 'ok' && r != 'down')
push(out, `Couldn't load devices into ${m.servers[id]?.name ?? id}: ${r}.`);
return length(out) ? join(' ', out) + ' Open Diagnostics → Health.' : null;
}
/*
* With the lock held: access sets first, and devices into the tunnels only
* once the table that limits them is in place.
* With the lock held: access sets first, then devices into the tunnels.
* Fail closed: without the table the firewall would let every loaded device
* reach everything, so while it is missing no device is loaded at all. An
* older table that survived a failed rebuild keeps limiting them with the
* sets it has, and the devices still follow people's states (a revoked one
* leaves).
*/
function locked_sync(m, usage, full) {
let states = states_for(m, usage);
let sets = nft.access_sets(m, usage, states);
let peers = {};
if (load_table(m, sets, full))
peers = awg.sync_peers(m, states);
let table = load_table(m, sets, full);
let peers = awg.sync_peers(m, table == null || nft.present() ? states : {});
sync_hosts(m);
ensure_dir(RUN_DIR);
write_json(`${RUN_DIR}/states.json`, states, 0o644);
return { peers, states };
return { peers, states, table, warning: sync_warning(m, table, peers) };
}
/**
* Runtime sync: devices into the tunnels (AmneziaWG peers), access sets,
* hostnames. Cheap; safe to call often. The model is always read again under
* the lock (`m` is accepted for older callers and not used); `usage` is the
* caller's (the agent holds the live counters).
* caller's (the agent holds the live counters). The result carries `warning`
* (a sentence for the admin) when the sync did not fully take.
*/
export function sync(m, usage) {
return with_lock('apply', () => locked_sync(core.load(), usage ?? core.load_usage()));
};
/** Is the access table loaded (the agent's tick re-syncs when it is not). */
export function table_present() {
return nft.present();
};
/**
* Everything on the router that Dawnline's state is derived from: WAN and
* LAN, the home networks and zones of each server, the netns address and the
@@ -209,10 +241,10 @@ export function apply(opts) {
let s = locked_sync(m, usage, true);
ensure_dir(RUN_DIR);
write_file(NET_SIG, net_signature(m), 0o644);
return { network, firewall, lp, peers: s.peers };
return { network, firewall, lp, peers: s.peers, warning: s.warning };
});
loop.remember(r.lp);
return { network: r.network, firewall: r.firewall, like_home: r.lp.error ? { error: r.lp.error } : !r.lp.off, peers: r.peers };
return { network: r.network, firewall: r.firewall, like_home: r.lp.error ? { error: r.lp.error } : !r.lp.off, peers: r.peers, warning: r.warning };
};
/** Remove everything Dawnline created (used by the uninstaller). */
@@ -6,11 +6,13 @@
import { readfile, stat, unlink } from 'fs';
import {
q, sh, sh_out, rand_int, rand_bytes, valid_key, ensure_dir, write_file, read_json, write_json, lock, unlock,
q, sh, sh_out, rand_int, rand_bytes, valid_key, ip2int, ensure_dir, write_file, read_json, write_json, lock, unlock,
slog, iface_status, DATA_DIR, RUN_DIR
} from 'dawnline.util';
import * as core from 'dawnline.core';
import * as net from 'dawnline.net';
import * as pkg from 'dawnline.pkg';
import * as builds from 'dawnline.awg_builds';
/** Names in .conf files (and AmneziaVPN keys); netifd uses `awg_<key>`. */
export const OBF_CONF = {
@@ -132,22 +134,94 @@ function rand_h(used) {
}
}
// caps() answers from here while the tool, the protocol script and the module file are the same.
const CAPS = `${RUN_DIR}/awg-caps.json`;
/**
* What the installed AmneziaWG can do, from the netifd protocol script (the
* options it passes on) and the `awg` tool (the keys it accepts):
* What the installed AmneziaWG can do: the netifd protocol script (the
* options it passes on) and the `awg` tool (the keys it accepts) say what the
* tools know, the kernel module's package version what the kernel runs, and
* a feature counts only when both have it (tools 3.1 over a 2.0 module would
* configure header protection that the kernel silently lacks):
* v2 — S3/S4, I1-I5, header ranges (AWG 1.5/2.0)
* v3 — header protection, trailers, padding, timing (AWG 3.1)
* tools / kmod — their generations ('1.0', '2.0', '3.1'; null unknown)
* mismatch — the two differ
*/
export function caps() {
let script = readfile('/lib/netifd/proto/amneziawg.sh') ?? '';
let rel = trim(readfile('/proc/sys/kernel/osrelease') ?? '');
let key = `${stat(`/lib/modules/${rel}/amneziawg.ko`)?.mtime ?? 0}/${stat(TOOL)?.mtime ?? 0}/${stat(PROTO)?.mtime ?? 0}`;
let cached = read_json(CAPS, null);
if (cached?.key == key && cached.caps)
return cached.caps;
let script = readfile(PROTO) ?? '';
let tool = sh_out("grep -a -o -m1 'HeaderProtectionKey' /usr/bin/awg 2>/dev/null") ?? '';
let v2 = index(script, 'awg_s3') >= 0 && index(script, 'awg_i1') >= 0;
let v3 = v2 && index(script, 'awg_header_protection_key') >= 0 && tool != '';
return { v2, v3 };
let t2 = index(script, 'awg_s3') >= 0 && index(script, 'awg_i1') >= 0;
let t3 = t2 && index(script, 'awg_header_protection_key') >= 0 && tool != '';
let tools = !stat(TOOL) ? null : t3 ? '3.1' : t2 ? '2.0' : '1.0';
// A module installed by hand has no package: then the tools are believed.
let kmod = builds.gen(pkg.version('kmod-amneziawg'));
let out = {
v2: t2 && (kmod == null || kmod != '1.0'),
v3: t3 && (kmod == null || kmod == '3.1'),
tools, kmod, mismatch: tools != null && kmod != null && tools != kmod,
};
ensure_dir(RUN_DIR);
write_json(CAPS, { key, caps: out }, 0o644);
return out;
};
/** First junk packet shaped like a DNS answer (AmneziaVPN's own default for 3.1). */
const DNS_MIMIC = '<r 2><b 0x858000010001000000000669636c6f756403636f6d0000010001c00c000100010000105a00044d583737>';
/**
* Why this AmneziaWG cannot run a server's disguise values, or null: a 3.1
* preset after a rollback to a 2.0 build would come up without the header
* protection every device expects, so such a server is kept down instead
* (dawnline.netifd).
*/
export function obf_unsupported(o) {
let c = caps();
let has = (keys) => length(filter(keys, (k) => o?.[k] != null && o[k] != '')) > 0;
let v3 = [ 'header_protection_key', 'content_padding_addition', 'rekey_after_time', 'rekey_timeout', 'reject_after_time',
'keepalive_timeout', 'max_handshake_attempts', 'random_trailers', 'disable_cookies' ];
let v2 = [ 's3', 's4', 'i1', 'i2', 'i3', 'i4', 'i5' ];
let ranged = length(filter([ 'h1', 'h2', 'h3', 'h4' ], (k) => match(`${o?.[k] ?? ''}`, /-/))) > 0;
if (has(v3) && !c.v3)
return `its disguise needs AmneziaWG 3.1 (installed: ${c.kmod ?? c.tools ?? 'none'})`;
if ((has(v2) || ranged) && !c.v2)
return `its disguise needs AmneziaWG 2.0 (installed: ${c.kmod ?? c.tools ?? 'none'})`;
return null;
};
/**
* Signature packets shaped like DNS, made fresh for each server: the same
* fixed bytes on every router (AmneziaVPN's own 3.1 default is one constant
* answer about icloud.com) would be one rule for a DPI to match. A query and
* an answer about a name of this server's own, with its own TTL and address.
* <r N> random bytes, <rc N> random letters, <b 0x..> fixed bytes
*/
function dns_name_hex() {
let hex = (s) => {
let out = '';
for (let i = 0; i < length(s); i++)
out += sprintf('%02x', ord(s, i));
return out;
};
let tld = [ 'com', 'net', 'org', 'io' ][rand_int(0, 3)];
let n = rand_int(5, 9);
return { labels: `<b 0x${sprintf('%02x', n)}><rc ${n}><b 0x${sprintf('%02x', length(tld))}${hex(tld)}00>`, len: n + length(tld) + 2 };
}
function dns_query() {
let name = dns_name_hex();
// id, flags (standard query, recursion desired), 1 question, name, type A, class IN
return `<r 2><b 0x01000001000000000000>${name.labels}<b 0x00010001>`;
}
function dns_answer() {
let name = dns_name_hex();
let ttl = sprintf('%08x', rand_int(300, 86400));
// id, flags (answer, authoritative, recursion), 1 question, 1 answer, name, A IN, pointer, A IN, ttl, 4 bytes
return `<r 2><b 0x85800001000100000000>${name.labels}<b 0x00010001c00c00010001${ttl}0004><r 4>`;
}
/**
* Generate obfuscation parameters for a method:
@@ -164,7 +238,7 @@ export function obf_preset(name) {
jc: `${rand_int(4, 6)}`, jmin: '10', jmax: '50',
s1: '12', s2: '12', s3: '12', s4: '12',
h1: '1', h2: '2', h3: '3', h4: '4',
i1: DNS_MIMIC,
i1: dns_query(), i2: dns_answer(),
header_protection_key: sh_out('awg genkey'),
content_padding_addition: '10-100',
rekey_after_time: '100-120', rekey_timeout: '3-7', reject_after_time: '150-180',
@@ -299,8 +373,10 @@ export function client_config(m, dev) {
push(lines, `PresharedKey = ${dev.preshared_key}`);
push(lines, `AllowedIPs = ${join(', ', allowed)}`);
push(lines, `Endpoint = ${ep}:${srv.port}`);
// With 3.1 (its apps take ranges) the keep-alive is jittered like the
// other timers; a fixed beat would be the one regular thing left.
if (srv.keepalive > 0)
push(lines, `PersistentKeepalive = ${srv.keepalive}`);
push(lines, `PersistentKeepalive = ${srv.obf.header_protection_key ? `${srv.keepalive}-${srv.keepalive + 10}` : srv.keepalive}`);
return {
name: dev.name,
person: p.name,
@@ -361,7 +437,9 @@ export function sync_peers(m, states) {
let lines = [ '[Interface]', `PrivateKey = ${srv.private_key}`, `ListenPort = ${srv.port}`, '' ];
for (let did, d in m.devices) {
let p = m.people[d.person];
if (!p || p.server != id || d.disabled || states[p.id] != 'active' || !d.public_key || !d.address)
// One malformed line makes syncconf refuse the whole server: such a device
// stays out (Health's Data check names it).
if (!p || p.server != id || d.disabled || states[p.id] != 'active' || !valid_key(d.public_key) || ip2int(d.address) == null)
continue;
push(lines, '[Peer]', `PublicKey = ${d.public_key}`);
if (d.preshared_key)
@@ -381,17 +459,24 @@ export function sync_peers(m, states) {
/**
* Parse `awg show all dump`. Returns { ok, ifaces: { ifname: {...} }, peers: { pubkey: {...} } }.
* Interface lines have many fields (AmneziaWG adds obfuscation values); peer
* lines always have 9. The tool fails when any one interface can't be read,
* but still prints the others: those are kept and `ok` is false, so only the
* interfaces listed in `ifaces` are known.
* Lines are told apart by their shape, not their length (each AmneziaWG
* generation adds fields to the interface line): an interface line carries
* its private and public key and a port, a peer line the peer's key, a
* preshared key or "(none)" and an endpoint. The tool fails when any one
* interface can't be read, but still prints the others: with `wanted` (the
* ifnames that matter) `ok` means those were all read, so another tunnel's
* trouble is not ours.
*/
export function dump() {
export function dump(wanted) {
let r = sh('awg show all dump');
let out = { ok: r.code == 0, ifaces: {}, peers: {} };
for (let line in split(r.out, '\n')) {
let f = split(line, '\t');
if (length(f) == 9) {
if (length(f) < 5 || !valid_key(f[1]))
continue;
if (valid_key(f[2]) && match(f[3] ?? '', /^[0-9]+$/))
out.ifaces[f[0]] = { public_key: f[2], port: +f[3] };
else if (length(f) >= 9 && (f[2] == '(none)' || valid_key(f[2]))) {
let ep = f[3] == '(none)' ? '' : f[3];
out.peers[f[1]] = {
ifname: f[0],
@@ -401,10 +486,9 @@ export function dump() {
tx: +f[7],
};
}
else if (length(f) >= 5) {
out.ifaces[f[0]] = { public_key: f[2], port: +f[3] };
}
}
if (!out.ok && type(wanted) == 'array')
out.ok = length(filter(wanted, (n) => !out.ifaces[n])) == 0;
return out;
};
@@ -41,9 +41,21 @@ export function for_tag(fw, tag) {
return { ...fw, tag, postfix: replace(fw.postfix, fw.tag, tag) };
};
/** AmneziaWG generation of a tools version: 3.x packages carry 3.1, older ones (1.0.x) 2.0. */
/**
* AmneziaWG generation of a package version: 3.x packages carry 3.1; 1.0.x
* ones are 2.0 (S3/S4, I1-I5, header ranges) from July 2025 on, and the
* first generation before that. A kernel module's version carries the kernel
* release in front (6.12.94.3.1.20260906): the AmneziaWG part is at the end.
*/
export function gen(version) {
return version == null ? null : match(version, /^3\./) ? '3.1' : '2.0';
if (version == null)
return null;
let v = match(`${version}`, /([0-9]+\.[0-9]+\.[0-9]{8})(-r?[0-9]+)?$/)?.[1] ?? `${version}`;
if (match(v, /^3\./))
return '3.1';
if (match(v, /^1\.0\.2024/) || match(v, /^1\.0\.20250[1-6]/))
return '1.0';
return '2.0';
};
/** The installed AmneziaWG packages: { name: version | null }. */
@@ -3,7 +3,7 @@
// only Dawnline's own regular files, and servers that cannot take over one of
// the router's own interfaces or networks.
import { readfile, stat, unlink, lsdir } from 'fs';
import { readfile, stat, unlink, lsdir, rename } from 'fs';
import { cursor } from 'uci';
import {
q, sh, ensure_dir, read_json, write_json, write_file, file_exists, rand_hex, lock, unlock, DATA_DIR, RUN_DIR, VERSION
@@ -15,24 +15,36 @@ import * as net from 'dawnline.net';
import * as health from 'dawnline.health';
const BACKUP_DIR = `${DATA_DIR}/backups`;
const KEEP_BACKUPS = 10;
/**
* How many backups of each kind stay (the newest): the nightly ones must not
* push out what the admin made by hand or what a removal left behind.
*/
const KEEP = { manual: 10, auto: 7, 'pre-delete': 5, 'pre-remove': 3, 'pre-update': 3, 'pre-restore': 3, 'pre-import': 3 };
const NAME = /^dawnline-([0-9]{8}-[0-9]{6})(-([a-z0-9-]+))?\.tar\.gz$/;
/** What a backup holds (paths inside the archive, relative to /). */
const FILES = [ 'etc/config/dawnline', 'etc/dawnline/usage.json', 'etc/dawnline/events.json' ];
/**
* Kinds that hold the config alone (about 20 KB): the history can be a
* megabyte or more, and these are made often and never to bring history
* back. Manual, pre-restore and pre-import backups protect the data that is
* about to be replaced, so they take everything.
*/
const CONFIG_ONLY = [ 'auto', 'pre-delete', 'pre-remove', 'pre-update' ];
/** The unpacked size a backup may have (the upload itself is limited to 4 MB). */
const MAX_UNPACKED = 16 * 1024 * 1024;
/* ---------- checking a configuration before it is used ---------- */
/**
* What is wrong with the servers of a configuration about to replace the
* current one (cursor `c` holds it): each must have a valid, unique interface
* What is wrong with a configuration about to replace the current one
* (cursor `c` holds it): each server must have a valid, unique interface
* name that is not one of the router's own interfaces, a free subnet and a
* unique port. [] when it can be used.
* unique port, and the people and devices must be consistent
* (core.model_errors). [] when it can be used.
*/
export function config_errors(c) {
let m = core.load(c);
let errs = [];
let errs = core.model_errors(m);
let nc = cursor();
nc.load('network');
let foreign = health.foreign_subnets();
@@ -92,30 +104,41 @@ export function backup_list() {
};
/**
* Make a backup now; returns its name. The oldest beyond KEEP_BACKUPS are
* removed, except `keep` (the backup being restored, which must survive the
* backup made just before restoring it).
* Make a backup now; returns its name. Written whole or not at all (a half
* archive from a full flash never shows up as a backup). Of each kind the
* oldest beyond KEEP are removed, except `keep` (the backup being restored,
* which must survive the backup made just before restoring it).
*/
export function backup_create(reason, keep) {
let kind = reason && match(reason, /^[a-z0-9-]{1,24}$/) ? reason : 'manual';
let config_only = index(CONFIG_ONLY, kind) >= 0;
// Flush live counters first so the backup has current usage.
let u = read_json(`${RUN_DIR}/usage.json`, null);
if (u)
write_json(`${DATA_DIR}/usage.json`, u, 0o600);
live.persist_events();
if (!config_only) {
let u = read_json(`${RUN_DIR}/usage.json`, null);
if (u)
write_json(`${DATA_DIR}/usage.json`, u, 0o600);
live.persist_events();
}
ensure_dir(BACKUP_DIR, 0o700);
let t = localtime();
let tag = reason && match(reason, /^[a-z0-9-]{1,24}$/) ? `-${reason}` : '';
let name = sprintf('dawnline-%04d%02d%02d-%02d%02d%02d%s.tar.gz', t.year, t.mon, t.mday, t.hour, t.min, t.sec, tag);
let files = join(' ', map(filter(FILES, (f) => file_exists(`/${f}`)), q));
let r = sh(`tar -czf ${q(BACKUP_DIR + '/' + name)} -C / ${files}`);
if (r.code != 0)
die(`Backup failed: ${trim(r.out)}`);
let name = sprintf('dawnline-%04d%02d%02d-%02d%02d%02d%s.tar.gz', t.year, t.mon, t.mday, t.hour, t.min, t.sec, kind == 'manual' ? '' : `-${kind}`);
let want = config_only ? [ FILES[0] ] : FILES;
let files = join(' ', map(filter(want, (f) => file_exists(`/${f}`)), q));
// Not a NAME until it is complete.
let tmp = `${BACKUP_DIR}/.${name}.tmp`;
let r = sh(`tar -czf ${q(tmp)} -C / ${files}`);
if (r.code != 0 || !rename(tmp, `${BACKUP_DIR}/${name}`)) {
unlink(tmp);
die(`Backup failed: ${trim(r.out) || 'the archive could not be written (is the flash full?)'}`);
}
system(`chmod 600 ${q(BACKUP_DIR + '/' + name)}`);
let all = backup_list();
let old = filter(all, (b) => b.name != keep && b.name != name);
let room = KEEP_BACKUPS - 1 - (length(old) < length(all) - 1 ? 1 : 0);
for (let i = room; i < length(old); i++)
unlink(`${BACKUP_DIR}/${old[i].name}`);
let by_kind = {};
for (let b in backup_list())
if (b.name != keep && b.name != name)
push(by_kind[b.reason] ??= [], b);
for (let k, list in by_kind)
for (let i = KEEP[k] ?? 3; i < length(list); i++)
unlink(`${BACKUP_DIR}/${list[i].name}`);
return name;
};
@@ -155,14 +178,24 @@ function check_archive(path) {
die('Backup is too large.');
}
/** Put the files unpacked in `dir` in place, under the config lock. */
/**
* Put the files unpacked in `dir` in place, under the config lock. The
* config goes first: when it cannot be written nothing else is touched, and
* a data file that fails afterwards is reported, not ignored.
*/
function install_files(dir) {
ensure_dir(DATA_DIR, 0o700);
let l = lock('config');
for (let f in FILES) {
let data = readfile(`${dir}/${f}`);
if (data != null)
write_file(`/${f}`, data, 0o600);
try {
for (let f in FILES) {
let data = readfile(`${dir}/${f}`);
if (data != null && !write_file(`/${f}`, data, 0o600))
die(`Couldn't write /${f}. Is the flash full?`);
}
}
catch (e) {
unlock(l);
die(e.message);
}
unlock(l);
system('chmod 600 /etc/config/dawnline');
@@ -185,9 +218,11 @@ export function backup_restore(name, path) {
die(e.message);
}
system(`rm -rf ${q(dir)}`);
// Live counters must follow the restored file.
// Live counters must follow the restored file: the agent reloads them from
// flash on its next tick (its watcher may write the old ones again before).
unlink(`${RUN_DIR}/usage.json`);
unlink(`${RUN_DIR}/events.json`);
write_file(live.USAGE_RELOAD, `${time()}`, 0o600);
return apply.apply();
};
@@ -279,7 +314,9 @@ export function import_json(data) {
system(`rm -rf ${q(dir)}`);
backup_create('pre-import');
let l = lock('config');
write_file('/etc/config/dawnline', text, 0o600);
let ok = write_file('/etc/config/dawnline', text, 0o600);
unlock(l);
if (!ok)
die("Couldn't write /etc/config/dawnline. Is the flash full?");
return apply.apply();
};
@@ -8,6 +8,7 @@ import {
rand_hex, rand_bytes, date_end, month_key, read_json, DATA_DIR, RUN_DIR, uniq
} from 'dawnline.util';
import * as net from 'dawnline.net';
import * as schema from 'dawnline.schema';
import { policy as updates_policy } from 'dawnline.updates';
export const CONFIG = 'dawnline';
@@ -68,28 +69,31 @@ export function open_cursor() {
export function load(c) {
c ??= open_cursor();
let s = c.get_all(CONFIG, 'settings') ?? {};
// Types, defaults and ranges of the settings live in dawnline.schema (one
// place): what is read here is what settings_update would have accepted.
let g = (k) => schema.get(s, k);
let m = {
settings: {
portal_enabled: bool(s.portal_enabled, false),
portal_port: toint(s.portal_port, 8443),
portal_host: s.portal_host ?? '',
portal_enabled: g('portal_enabled'),
portal_port: g('portal_port'),
portal_host: g('portal_host'),
// More addresses for the same links (the main one is portal_host).
portal_alt: filter(type(s.portal_alt) == 'array' ? s.portal_alt : s.portal_alt ? [ s.portal_alt ] : [], (x) => x != ''),
portal_cert: s.portal_cert ?? '',
portal_key: s.portal_key ?? '',
portal_title: s.portal_title ?? 'Dawnline',
portal_alt: g('portal_alt'),
portal_cert: g('portal_cert'),
portal_key: g('portal_key'),
portal_title: g('portal_title'),
// Where unknown portal links go instead of a bare 404 (empty = 404).
portal_redirect: s.portal_redirect ?? '',
default_device_limit: toint(s.default_device_limit, 3),
geo_enabled: bool(s.geo_enabled, false),
geo_provider: s.geo_provider == 'ipapi.co' ? 'ipapi.co' : 'ipwho.is',
hostnames: bool(s.hostnames, true),
domain: s.domain ?? 'lan',
log_connections: bool(s.log_connections, true),
portal_redirect: g('portal_redirect'),
default_device_limit: g('default_device_limit'),
geo_enabled: g('geo_enabled'),
geo_provider: g('geo_provider'),
hostnames: g('hostnames'),
domain: g('domain'),
log_connections: g('log_connections'),
// Repair tunnels and services on its own (the agent, every minute).
watchdog: bool(s.watchdog, true),
watchdog: g('watchdog'),
// Second DNS for "home names" devices, used by the device when the tunnel is down.
home_dns_fallback: s.home_dns_fallback == 'none' ? '' : (s.home_dns_fallback ?? '1.1.1.1'),
home_dns_fallback: g('home_dns_fallback'),
// Settings → Updates (automatic checks and updates of the components).
updates: updates_policy(s),
// Raw retention values; dawnline.live policy() interprets them.
@@ -158,6 +162,8 @@ export function load(c) {
access: index(ACCESS, r.access) >= 0 ? r.access : 'internet',
device_limit: toint(r.device_limit, m.settings.default_device_limit),
code: r.code ?? '',
// When the personal link was last made (0 for links from before this was kept).
code_set: toint(r.code_set, 0),
expires: r.expires ?? '',
quota_gb: num(r.quota_gb, 0),
quota_period: r.quota_period == 'total' ? 'total' : 'month',
@@ -236,23 +242,23 @@ function within_hours(h, ts) {
return h[0] < h[1] ? (cur >= h[0] && cur < h[1]) : (cur >= h[0] || cur < h[1]);
}
/** Bytes used in the person's quota period. */
export function person_usage(p, usage) {
/** Bytes used in the person's quota period (the month of `ts`, default now). */
export function person_usage(p, usage, ts) {
let u = usage?.people?.[p.id];
if (!u)
return 0;
if (p.quota_period == 'total')
return (u.total?.[0] ?? 0) + (u.total?.[1] ?? 0);
let mm = u.months?.[month_key()];
let mm = u.months?.[month_key(ts)];
return mm ? mm[0] + mm[1] : 0;
};
/** Quota in bytes for the current period (base + this month's bonus), 0 = unlimited. */
export function person_quota(p) {
/** Quota in bytes for the period of `ts` (default now): base + that month's bonus, 0 = unlimited. */
export function person_quota(p, ts) {
if (!(p.quota_gb > 0))
return 0;
let gb = p.quota_gb;
if (p.bonus_gb > 0 && p.bonus_month == month_key())
if (p.bonus_gb > 0 && p.bonus_month == month_key(ts))
gb += p.bonus_gb;
return gb * 1073741824;
};
@@ -272,8 +278,8 @@ export function own_state(m, p, usage, ts) {
// "notify" keeps access after the end date (shown in Overview and People).
if (person_expired(p, ts) && p.expire_action != 'notify')
return 'expired';
let quota = person_quota(p);
if (quota > 0 && person_usage(p, usage) >= quota)
let quota = person_quota(p, ts);
if (quota > 0 && person_usage(p, usage, ts) >= quota)
return 'quota';
let h = parse_hours(p.hours);
if (h && !within_hours(h, ts))
@@ -512,6 +518,7 @@ export function create_person(c, m, a) {
c.set(CONFIG, slug, 'access', access);
c.set(CONFIG, slug, 'device_limit', `${limit}`);
c.set(CONFIG, slug, 'code', new_code());
c.set(CONFIG, slug, 'code_set', `${time()}`);
c.set(CONFIG, slug, 'created', `${time()}`);
if (a.expires)
c.set(CONFIG, slug, 'expires', a.expires);
@@ -750,6 +757,69 @@ export function server_errors(m, srv, others_subnets) {
return errs;
};
/**
* What is wrong inside a model as a whole, beyond each server: devices with
* an address outside their server's subnet, the server's own address, a
* prefix on it or one shared with another device (the access sets are keyed
* by address, and one bad peer line makes `awg syncconf` refuse the whole
* server), malformed keys, people and devices pointing at servers, people,
* circles or services that do not exist, and two people with one link. [] when
* it is consistent. Import, restore and Health check it; the runtime sync
* skips what it would reject (dawnline.awg, dawnline.nft).
*/
export function model_errors(m) {
let errs = [];
let codes = {}, addrs = {};
for (let id, p in m.people) {
let who = `Person ${p.name}`;
if (p.server != '' && !m.servers[p.server])
push(errs, `${who}: server ${p.server} does not exist.`);
if (p.circle != '' && !m.circles[p.circle])
push(errs, `${who}: circle ${p.circle} does not exist.`);
for (let sid in p.services)
if (!m.services[sid])
push(errs, `${who}: home service ${sid} does not exist.`);
if (p.code != '') {
if (codes[p.code])
push(errs, `${who}: has the same personal link as ${codes[p.code]}.`);
codes[p.code] = p.name;
}
}
for (let id, d in m.devices) {
let p = m.people[d.person];
let who = `Device ${d.name}${p ? ` of ${p.name}` : ''}`;
if (!p) {
push(errs, `${who}: person ${d.person} does not exist.`);
continue;
}
if (!valid_key(d.public_key))
push(errs, `${who}: the public key is not a key.`);
if (d.private_key != '' && !valid_key(d.private_key))
push(errs, `${who}: the private key is not a key.`);
if (d.preshared_key != '' && !valid_key(d.preshared_key))
push(errs, `${who}: the preshared key is not a key.`);
let n = ip2int(d.address);
if (n == null) {
push(errs, `${who}: address ${d.address || '(none)'} is not a plain IPv4 address.`);
continue;
}
let srv = m.servers[p.server];
let t = srv ? parse_cidr(srv.subnet) : null;
if (t && (n < t.first || n > t.last))
push(errs, `${who}: address ${d.address} is outside ${srv.name}'s tunnel ${srv.subnet}.`);
else if (t && n == t.first)
push(errs, `${who}: address ${d.address} is the router's own address on ${srv.name}.`);
let key = `${p.server} ${d.address}`;
if (addrs[key])
push(errs, `${who}: address ${d.address} is also used by ${addrs[key]}.`);
addrs[key] = who;
}
for (let id, ci in m.circles)
if (!m.servers[ci.server])
push(errs, `Circle ${ci.name}: server ${ci.server} does not exist.`);
return errs;
};
/**
* Port forwards from `zone` for `proto` that aren't Dawnline's: [{ from, to, name }].
* A forwarded port never reaches the router itself, so nothing here can listen on it.
@@ -42,11 +42,11 @@ export function add(person, name, kind, opts) {
opts ??= {};
let by = opts.by ?? 'admin';
let id = store.transact((c, m) => core.create_device(c, m, person, name, kind, { by, keys: awg.new_keys(opts.public_key || null) }));
apply.sync();
let s = apply.sync();
let m = core.load();
live.add_event({ type: 'device_added', person, device: id, detail: m.devices[id].name, by });
awg.mark_issued(m, id);
return { id, config: awg.client_config(m, m.devices[id]) };
return { id, config: awg.client_config(m, m.devices[id]), warning: s.warning };
};
/**
@@ -89,15 +89,19 @@ export function rotate(id, opts) {
});
// The device a portal page came through would lose its tunnel before the
// answer gets out: load the new key a moment after answering.
let s = null;
if (opts.defer)
sh_bg('sleep 3; /usr/bin/dawnline sync');
else
apply.sync();
s = apply.sync();
let m = core.load();
let d = m.devices[id];
live.add_event({ type: 'device_keys', person: d.person, device: id, detail: d.name, by });
awg.mark_issued(m, id);
return awg.client_config(m, d);
let cfg = awg.client_config(m, d);
if (s?.warning)
cfg.warning = s.warning;
return cfg;
};
/** Remove a device. Returns the runtime sync. */
@@ -5,11 +5,12 @@
// named dawnline_* are ever changed.
import { readfile, unlink } from 'fs';
import { q, sh, sh_out, uniq, uci_put, uci_section, ack_config, write_file, RUN_DIR } from 'dawnline.util';
import { q, sh, sh_out, uniq, in_nets, uci_put, uci_section, ack_config, write_file, RUN_DIR } from 'dawnline.util';
import { cursor } from 'uci';
import * as core from 'dawnline.core';
import * as net from 'dawnline.net';
import * as nft from 'dawnline.nft';
import * as loop from 'dawnline.loop';
const LOOP_ZONE = 'dl_loop';
/*
@@ -42,12 +43,33 @@ export function sync(m, dry) {
let snap = net.snapshot(true);
let portal_zone = null, want_loop = false;
// Where tunnel DNS is sent (dawnline.nft): into the netns for home names
// while any server runs "like a home device", and to the LAN's DNS for
// everyone else. A server that does not forward to those zones on its own
// gets a rule for port 53 alone.
let any_loop = length(filter(values(m.servers), (s) => s.lan_like && length(core.tunnels(s)))) > 0;
let lan_dns = loop.lan_dns();
let lan_dns_zone = null;
if (lan_dns)
for (let dev, d in snap.devices)
if (d.zone && in_nets(lan_dns, d.nets ?? []))
lan_dns_zone ??= d.zone;
for (let id, srv in m.servers) {
if (!length(core.tunnels(srv)))
continue;
let z = `dawnline_${id}`;
let sn = net.server_net(srv, snap);
portal_zone ??= sn.wan.zone;
if (!srv.lan_like && any_loop)
sec(`${z}_loopdns`, 'rule', {
name: `Dawnline-${srv.ifname}-names`, src: srv.ifname, dest: LOOP_ZONE,
proto: 'tcp udp', dest_port: 53, target: 'ACCEPT',
});
if (lan_dns_zone && lan_dns_zone != srv.ifname && index(sn.zones, lan_dns_zone) < 0)
sec(`${z}_landns`, 'rule', {
name: `Dawnline-${srv.ifname}-dns`, src: srv.ifname, dest: lan_dns_zone, dest_ip: lan_dns,
proto: 'tcp udp', dest_port: 53, target: 'ACCEPT',
});
sec(`${z}_zone`, 'zone', {
// Forward within the zone (device to device) is decided by the inet dawnline table.
name: srv.ifname, network: [ srv.ifname ],
@@ -403,9 +403,16 @@ export function health(m) {
let nft_ok = system('nft list table inet dawnline >/dev/null 2>&1') == 0;
push(out, check('nft', 'Access rules loaded', nft_ok ? 'ok' : 'error',
nft_ok ? 'Table inet dawnline enforces who may reach LAN and the internet.' : 'Table inet dawnline is missing: access is not enforced.',
nft_ok ? 'Table inet dawnline enforces who may reach LAN and the internet.'
: 'Table inet dawnline is missing: no device is loaded into the tunnels until it is back.',
nft_ok ? null : 'apply'));
// A device the sync has to leave out (a merged import, a hand-edited config).
let data = core.model_errors(m);
push(out, check('data', 'People and devices consistent', length(data) ? 'error' : 'ok',
length(data) ? `${join(' ', slice(data, 0, 4))}${length(data) > 4 ? ` (${length(data) - 4} more)` : ''} Such devices are left out of the tunnels: fix or remove them.`
: 'Every device has a key and an address of its own inside its server.'));
let fwc = cursor();
fwc.load('firewall');
@@ -11,14 +11,14 @@ import {
iface_status as util_iface_status, RUN_DIR, DATA_DIR
} from 'dawnline.util';
import * as awg from 'dawnline.awg';
import * as schema from 'dawnline.schema';
// Online while the WireGuard session lives: it is dropped 180 s after its
// handshake, and a device that is there renews it every 2 min (a little slack
// for a renewal that needs a retry). One that left goes offline 1-3 min later.
export const ONLINE_WINDOW = 190;
const KEEP_DAYS = 62;
const KEEP_MONTHS = 24;
const KEEP_EVENTS = 2000;
/** A restore put other counters on flash: the agent reloads from there (dawnline.backup writes it). */
export const USAGE_RELOAD = `${RUN_DIR}/usage.reload`;
/* ---------- retention policy ---------- */
@@ -38,9 +38,6 @@ export function category_of(type) {
return CATEGORY[type] ?? 'problems';
};
function int_or(v, d) {
return (v == null || v == '' || match(`${v}`, /[^0-9]/)) ? d : +v;
}
/**
* Log and history retention from /etc/config/dawnline (read fresh, the
@@ -62,13 +59,14 @@ export function policy(s) {
else if (type(cats) != 'array')
cats = split(cats, /[ ,]+/);
cats = uniq(filter(map(cats, (x) => x == 'devices' ? 'people' : x), (x) => index(CATEGORIES, x) >= 0));
// Defaults and ranges come from dawnline.schema, like every other setting.
return {
keep_days: int_or(s.log_keep_days, 30),
max: min(max(int_or(s.log_max, KEEP_EVENTS), 100), 20000),
keep_days: schema.get(s, 'log_keep_days'),
max: schema.get(s, 'log_max'),
categories: cats,
persist: index([ '10min', 'hourly', 'off' ], s.log_persist) >= 0 ? s.log_persist : 'hourly',
usage_days: min(max(int_or(s.usage_keep_days, KEEP_DAYS), 7), 1830),
usage_months: min(max(int_or(s.usage_keep_months, KEEP_MONTHS), 1), 120),
persist: schema.get(s, 'log_persist'),
usage_days: schema.get(s, 'usage_keep_days'),
usage_months: schema.get(s, 'usage_keep_months'),
};
};
@@ -110,7 +108,10 @@ export function presence() {
* handshake, rx, tx } }, presence }. See dawnline.awg.
*/
export function dump(m) {
let d = awg.dump();
// Only Dawnline's own tunnels decide `ok`: another AmneziaWG interface on
// the router that cannot be read is not our trouble.
let mine = m ? map(filter(values(m.servers), (s) => s.private_key && s.enabled), (s) => s.ifname) : null;
let d = awg.dump(mine);
d.presence = presence();
return d;
};
@@ -134,8 +135,13 @@ function empty_usage() {
return { devices: {}, people: {}, updated: 0, flushed: 0 };
}
export function load_usage() {
let u = read_json(`${RUN_DIR}/usage.json`, null) ?? read_json(`${DATA_DIR}/usage.json`, null) ?? empty_usage();
/**
* The usage counters: the live copy in RUN_DIR, else what flash holds. With
* `from_flash` only flash counts (a restore put new counters there, and the
* watcher may have written the old live ones again since).
*/
export function load_usage(from_flash) {
let u = (from_flash ? null : read_json(`${RUN_DIR}/usage.json`, null)) ?? read_json(`${DATA_DIR}/usage.json`, null) ?? empty_usage();
// Per-app counters of earlier test builds are not kept.
delete u.clients;
return u;
@@ -9,8 +9,8 @@
// lan_device extra interfaces that count as the home network (list)
//
// Home access is enforced by destination: the networks routed out of the
// chosen interfaces form the nft `lan_nets` set, and the tunnel's firewall
// zone gets a forwarding to each of their zones.
// chosen interfaces form the server's nft `home_<id>` set, and the tunnel's
// firewall zone gets a forwarding to each of their zones.
import { readfile, readlink, lsdir, stat } from 'fs';
import { cursor } from 'uci';
@@ -68,6 +68,15 @@ export function sync(m) {
'Dawnline never changes interfaces it did not create. Choose another interface name for this server.');
continue;
}
// A disguise this build cannot run (a 3.1 preset after a rollback to
// 2.0): the kernel would drop those options silently and run a tunnel
// no device can reach. Down, and said so, until the build or the
// disguise is changed.
let why = tools ? awg.obf_unsupported(srv.obf) : null;
if (why) {
block(srv, `is kept down: ${why}`, 'Install that AmneziaWG build in Dawnline → Components, or switch the disguise on the Server page.');
continue;
}
delete srv.blocked;
want[ifn] = true;
if (!tools)
@@ -5,7 +5,7 @@
// changes often (update, one atomic transaction).
import { unlink } from 'fs';
import { sh, ensure_dir, write_file, rand_hex, ip2int, RUN_DIR } from 'dawnline.util';
import { sh, ensure_dir, write_file, rand_hex, ip2int, uniq, RUN_DIR } from 'dawnline.util';
import * as core from 'dawnline.core';
import * as net from 'dawnline.net';
import * as loop from 'dawnline.loop';
@@ -74,17 +74,33 @@ export function access_sets(m, usage, states) {
return sets;
};
// Duplicate members (two devices with one address) would make the whole load fail.
function set_elems(arr) {
arr = uniq(arr);
return length(arr) ? `elements = { ${join(', ', arr)} }` : '';
}
/** The portal's TCP ports people may reach through the tunnel (never SSH, DNS or LuCI, whatever is stored). */
function portal_ports(m) {
if (!m.settings.portal_enabled)
return [];
let ok = (p) => p >= 1 && p <= 65535 && index([ 22, 53, 80, 443 ], p) < 0;
let ports = filter([ m.settings.portal_port ], ok);
if (core.portal_http(m) && ok(core.portal_http_port(m)))
push(ports, core.portal_http_port(m));
return ports;
}
function table(m, sets) {
let ifs = [], lan = [], tun = [];
let ifs = [], tun = [];
let dns_addr = loop.client_dns();
if (!ip4(dns_addr))
dns_addr = null;
let rt = loop.resolver_target();
let snap = net.snapshot();
// Each server's home networks are its own: with several servers, "all
// home" on one never reaches the other's networks (set lan_<id>).
let homes = {};
for (let id, srv in m.servers) {
// Only valid interface names reach here (core.tunnels): they are written into the rules as strings.
let tns = core.tunnels(srv);
@@ -93,13 +109,13 @@ function table(m, sets) {
push(tun, t.subnet);
}
if (length(tns))
push(lan, ...net.server_net(srv, snap).nets);
homes[id] = net.collapse(net.server_net(srv, snap).nets);
}
lan = net.collapse(lan);
tun = net.collapse(tun);
let t = [];
push(t, 'table inet dawnline {');
push(t, ` set lan_nets { type ipv4_addr; flags interval; auto-merge; ${set_elems(lan)} }`);
for (let id, nets in homes)
push(t, ` set home_${id} { type ipv4_addr; flags interval; auto-merge; ${set_elems(nets)} }`);
// Tunnel subnets are never "home", even inside a wider route to the LAN.
push(t, ` set tun_nets { type ipv4_addr; flags interval; auto-merge; ${set_elems(tun)} }`);
push(t, ` set lan_ok { type ipv4_addr; ${set_elems(sets.lan_ok)} }`);
@@ -118,15 +134,30 @@ function table(m, sets) {
push(t, ' }');
push(t, ' chain guard {');
push(t, ' meta nfproto ipv6 drop');
push(t, ' ct state established,related accept');
push(t, ' icmp type echo-request fib daddr type local accept');
// Every packet is judged by the rules below, not only the first of a
// connection: a change of access cuts open connections too, instead of
// letting a session or a long UDP flow run on for days. Only what has no
// rule of its own passes on its connection: errors and the like, answers
// to the admin's port forwards, and the router's own pings.
push(t, ' ct state related accept');
push(t, ' ct status dnat accept');
push(t, ' icmp type { echo-request, echo-reply } fib daddr type local accept');
push(t, ' fib daddr type local meta l4proto { tcp, udp } th dport 53 accept');
push(t, ' fib daddr type local ip saddr @lan_ok accept');
let pp = portal_ports(m);
if (length(pp))
// Their own portal, also with the VPN on (the address may be this router's).
push(t, ` fib daddr type local tcp dport { ${join(', ', pp)} } accept`);
// The router itself is part of home: for everyone with all of it, and for
// people limited to some networks only on the addresses in those.
push(t, ' fib daddr type local ip saddr @lan_all accept');
push(t, ' fib daddr type local ip saddr . ip daddr @lan_part accept');
push(t, ' fib daddr type local counter drop');
if (dns_addr)
// DNS through the netns (it forwards to the LAN's DNS), for everyone.
push(t, ` ip daddr ${dns_addr} meta l4proto { tcp, udp } th dport 53 accept`);
push(t, ' ip daddr @lan_nets ip daddr != @tun_nets ip saddr @lan_all accept');
for (let id, nets in homes)
for (let tn in core.tunnels(m.servers[id]))
push(t, ` iifname "${tn.ifname}" ip daddr @home_${id} ip daddr != @tun_nets ip saddr @lan_all accept`);
push(t, ' ip saddr . ip daddr @lan_part ip daddr != @tun_nets accept');
// Devices with home access are part of home: they reach each other, where the
// server allows it (everyone, or within circles). Within one server: the
@@ -155,7 +186,9 @@ function table(m, sets) {
push(t, ' chain to_device {');
push(t, ' meta nfproto ipv6 drop');
push(t, ' ct status dnat accept');
push(t, ' ip saddr @lan_nets ip saddr != @tun_nets ip daddr @lan_all accept');
for (let id, nets in homes)
for (let tn in core.tunnels(m.servers[id]))
push(t, ` oifname "${tn.ifname}" ip saddr @home_${id} ip saddr != @tun_nets ip daddr @lan_all accept`);
push(t, ' ip daddr . ip saddr @lan_part ip saddr != @tun_nets accept');
push(t, ' counter reject with icmpx admin-prohibited');
push(t, ' }');
@@ -195,6 +228,11 @@ export function load(script) {
return replace(trim(r.out), f, 'rules') || `nft exited with ${r.code}`;
};
/** The table as text, for a check (`nft -c -f`) or a test; nothing is loaded. */
export function render(m, sets) {
return table(m, sets);
};
/** Full table rebuild (structure changes: servers, home networks, DNS paths); null or the error. */
export function rebuild(m, sets) {
return load('table inet dawnline\ndelete table inet dawnline\n' + table(m, sets));
@@ -208,9 +246,10 @@ export function rebuild(m, sets) {
export function update(sets) {
let s = '';
for (let name in SETS) {
let members = uniq(sets[name]);
s += `flush set inet dawnline ${name}\n`;
if (length(sets[name]))
s += `add element inet dawnline ${name} { ${join(', ', sets[name])} }\n`;
if (length(members))
s += `add element inet dawnline ${name} { ${join(', ', members)} }\n`;
}
return load(s);
};
@@ -2,7 +2,7 @@
// OpenWrt 24.10, apk on 25.12. Commands that change packages take a log(line)
// callback, which gets their output line by line.
import { access, popen } from 'fs';
import { access, popen, stat } from 'fs';
import { q } from 'dawnline.util';
function run(cmd) {
@@ -79,20 +79,56 @@ export function refresh(log) {
return logged(is_apk() ? 'apk update' : 'opkg update', log).code == 0;
};
/** Free space on the overlay in KB (null when unknown). */
function overlay_free_kb() {
let out = run('df -Pk /overlay 2>/dev/null || df -Pk / 2>/dev/null').out;
let m = match(out, /\n\S+\s+[0-9]+\s+[0-9]+\s+([0-9]+)\s/);
return m ? +m[1] : null;
}
/**
* Room for `files` (or `need_kb` from the feeds): the package manager
* unpacks before it removes, so a full flash leaves half an install behind.
* Dies with the numbers.
*/
function preflight(files, need_kb, log) {
let free = overlay_free_kb();
if (free == null)
return;
let need = need_kb ?? 512;
for (let f in files ?? [])
need += int(((stat(f)?.size ?? 0) * 3) / 1024);
if (free < need)
die(`Not enough free space on the router: ${int(free / 1024)} MB free, about ${int(need / 1024) + 1} MB needed. Remove old backups or packages first`);
log?.(` ${int(free / 1024)} MB free on the overlay`);
}
/** Package files (from a release): force also reinstalls the same version or goes back to an older one. */
export function install_files(files, force, log) {
preflight(files, 0, log);
let args = join(' ', map(files, q));
return logged(is_apk()
? `apk add --allow-untrusted ${args}`
: `opkg install ${force ? '--force-reinstall --force-downgrade ' : ''}${args}`, log).code == 0;
if (!is_apk())
return logged(`opkg install ${force ? '--force-reinstall --force-downgrade ' : ''}${args}`, log).code == 0;
// apk leaves an installed version alone, whatever the file: a reinstall
// that changed nothing is a failure, not a silent "done".
let marker = '/usr/share/ucode/dawnline/util.uc';
let before = force ? stat(marker)?.mtime : null;
let ok = logged(`apk add --allow-untrusted ${args}`, log).code == 0;
if (ok && force && before != null && stat(marker)?.mtime == before) {
log?.(' apk did not reinstall the version that is already installed');
die("apk doesn't reinstall an installed version. Install a different release, or run install.sh on the router");
}
return ok;
};
/** Packages by name from the feeds. */
export function add(names, log) {
preflight(null, 2048, log);
return logged(is_apk() ? `apk add ${join(' ', map(names, q))}` : `opkg install ${join(' ', map(names, q))}`, log).code == 0;
};
export function upgrade(names, log) {
preflight(null, 2048, log);
return logged(is_apk() ? `apk upgrade ${join(' ', map(names, q))}` : `opkg upgrade ${join(' ', map(names, q))}`, log).code == 0;
};
@@ -105,7 +141,9 @@ export function upgradable() {
let up = {};
if (is_apk()) {
for (let line in split(run('apk version -l "<"').out, '\n')) {
let m = match(line, /^(\S+?)-([0-9][^ ]*)\s+<\s+(\S+)/);
// "name-version-rN < newer": the version is what follows the last dash
// before the release suffix (a name may hold digits, a version no dash).
let m = match(line, /^(\S+)-([^- ]+-r[0-9]+)\s+<\s+(\S+)/);
if (m)
up[m[1]] = m[3];
}
@@ -19,8 +19,14 @@
// other sites' logs. The portal can only manage the person's own devices
// within their limits, and not those the admin turned off (dawnline.devices).
//
// Changes through a link are limited too (a link is not a terminal: a few
// dozen every quarter hour), and the configurations themselves (keys, the
// disguise) only go over HTTPS: a plain-HTTP link (an IP address in Settings)
// shows the page, but gets them from its HTTPS twin.
//
// handle() serves one request: `io` = { env, headers, read(n), write(s) }; the
// CGI script (www/cgi-bin/portal) is its wrapper.
// CGI script (cgi.uc) is its wrapper, behind the shell door www/cgi-bin/portal
// that answers anything not shaped like a link (its not_found() twin).
import { stat, readfile } from 'fs';
import { read_json, write_json, ensure_dir, lock, unlock, cloudflare_ip, ip2int, today, VERSION, RUN_DIR } from 'dawnline.util';
@@ -41,6 +47,8 @@ const SHARED_LIMIT = FAIL_LIMIT * 25;
const SHARED_KEY = 'cloudflare';
// Clients remembered at most (the oldest go first).
const RATE_MAX = 2000;
// Changes one link may make within FAIL_WINDOW (each one writes flash and syncs the tunnels).
const ACTION_LIMIT = 40;
const BODY_MAX = 8192;
// The early end of a request (a response was written).
const DONE = '__dawnline_done__';
@@ -216,6 +224,21 @@ function rate_fail(r) {
live.add_event({ type: 'portal_blocked', detail: k == SHARED_KEY ? 'all Cloudflare visitors' : k });
}
/** One more change through this link; refused beyond ACTION_LIMIT per window. */
function rate_action(r) {
let key = `act:${r.person.id}`;
let l = lock('portal-rate');
let st = rate_state();
let v = st[key] ?? { first: time(), count: 0 };
v.count++;
st[key] = v;
ensure_dir(RUN_DIR);
write_json(RATE, st, 0o600);
unlock(l);
if (v.count > ACTION_LIMIT)
fail(r, '429 Too Many Requests', 'Too many changes in a short time. Try again in a few minutes.');
}
/* ---------- pages ---------- */
/** The app shell; it reads the code from its own URL and sends it along. */
@@ -295,6 +318,26 @@ function need_open(r) {
fail(r, '403 Forbidden', why);
}
/** The same link over HTTPS (for a plain-HTTP visitor), or null when this is it. */
function https_url(r) {
if (r.https)
return null;
let host = r.host;
let h = match(host, /^\[/) ? match(host, /^(\[[^\]]*\])/)?.[1] : split(host, ':')[0];
let port = r.m.settings.portal_port;
return `https://${h}${port == 443 ? '' : `:${port}`}${r.base}`;
}
/**
* Keys and the disguise never travel in the clear: over plain HTTP a
* configuration is refused, and the answer names the HTTPS link to use.
*/
function need_https(r) {
let u = https_url(r);
if (u)
send_json(r, '403 Forbidden', { error: 'Open this link over HTTPS to get the connection settings.', https_url: u });
}
/** Everything the page shows. */
function state(r) {
let m = r.m, person = r.person;
@@ -318,6 +361,8 @@ function state(r) {
},
can_add: length(person.devices) < person.device_limit,
locked: LOCKED[v.state] != null,
// Over plain HTTP: where the configurations are (keys only travel encrypted).
https_url: https_url(r),
kinds: core.KINDS,
// The router's day: access ends and usage days follow its clock, not the browser's.
today: today(),
@@ -339,9 +384,11 @@ function api_state(r) {
function api_add(r) {
need_open(r);
need_https(r);
let b = body(r);
if (!devices.ready())
fail(r, '503 Service Unavailable', NOT_READY);
rate_action(r);
let res = guard(r, () => devices.add(r.person.id, b.name, b.kind, { by: 'portal', public_key: b.public_key }));
reload(r);
send_json(r, '200 OK', { id: res.id, config: res.config, state: state(r) });
@@ -350,6 +397,7 @@ function api_add(r) {
function api_config(r, id) {
let d = own_device(r, id);
need_open(r);
need_https(r);
awg.mark_issued(r.m, d.id);
send_json(r, '200 OK', awg.client_config(r.m, d));
}
@@ -361,6 +409,7 @@ const ACTIONS = {
return {};
},
rotate: (r, d, b) => {
need_https(r);
if (!devices.ready())
fail(r, '503 Service Unavailable', NOT_READY);
let config = guard(r, () => devices.rotate(d.id, { by: 'portal', person: r.person.id, defer: d.address == r.peer }));
@@ -379,6 +428,7 @@ function api_device(r, id) {
let act = ACTIONS[b.action];
if (!act)
fail(r, '400 Bad Request', 'Unknown action.');
rate_action(r);
let res = act(r, d, b);
reload(r);
send_json(r, '200 OK', { ok: true, ...res, state: state(r) });
@@ -425,7 +475,7 @@ export function handle(io) {
let host = header('host') ?? '';
let m = core.load();
let r = {
io, env, m, path, https,
io, env, m, path, https, host,
method: env.REQUEST_METHOD ?? 'GET',
peer: env.REMOTE_ADDR ?? '',
buckets: buckets(env),
@@ -54,8 +54,8 @@ function service_set(a) {
c.delete(core.CONFIG, id, 'port');
return id;
});
apply.sync();
return { id };
let s = apply.sync();
return { id, warning: s.warning };
}
function service_delete(a) {
@@ -72,8 +72,8 @@ function service_delete(a) {
c.delete(core.CONFIG, pid, 'service');
}
});
apply.sync();
return { ok: true };
let s = apply.sync();
return { ok: true, warning: s.warning };
}
/* ---------- circles ---------- */
@@ -112,9 +112,9 @@ function circle_set(a) {
}
return { id, edit: !!ci, server: m.servers[server].name };
});
apply.sync();
let s = apply.sync();
admin_log('awg', res.edit ? 'changed' : 'added', 'circle', name, res.server);
return { id: res.id, circles: values(core.load().circles) };
return { id: res.id, circles: values(core.load().circles), warning: s.warning };
}
function circle_delete(a) {
@@ -128,9 +128,9 @@ function circle_delete(a) {
c.delete(core.CONFIG, pid, 'circle');
return { name: ci.name, server: m.servers[ci.server]?.name };
});
apply.sync();
let s = apply.sync();
admin_log('awg', 'removed', 'circle', res.name, res.server);
return { circles: values(core.load().circles) };
return { circles: values(core.load().circles), warning: s.warning };
}
/* ---------- devices at home ---------- */
@@ -48,10 +48,10 @@ function person_update(a) {
if (changes)
live.add_event_merged({ type: 'person_changed', person: a.id, detail: changes, by: 'admin' }, 120);
// Access changes affect the nft sets and client AllowedIPs.
apply.sync();
let s = apply.sync();
let m = core.load();
let u = core.load_usage();
return { person: view.person_view(m, m.people[a.id], u, live.dump(m), view.states(m, u), { admin: true }), was: before?.access };
return { person: view.person_view(m, m.people[a.id], u, live.dump(m), view.states(m, u), { admin: true }), was: before?.access, warning: s.warning };
}
function person_pause(a) {
@@ -67,16 +67,34 @@ function person_pause(a) {
return apply.sync();
}
/** A new personal link: the old one stops working at once (every portal request carries the code). */
/**
* A new personal link: the old one stops working at once (every portal
* request carries the code). What the old link already handed out stays
* unless asked: `remove` lists the person's devices to take away with it.
*/
function person_regen(a) {
store.transact((c, m) => {
let gone = store.transact((c, m) => {
if (!m.people[a.id])
die('Unknown person.');
c.set(core.CONFIG, a.id, 'code', core.new_code());
c.set(core.CONFIG, a.id, 'code_set', `${time()}`);
let gone = [];
for (let id in (type(a.remove) == 'array' ? a.remove : []))
if (m.devices[id]?.person == a.id) {
push(gone, m.devices[id]);
core.delete_device(c, m, id);
}
return gone;
});
live.add_event({ type: 'link_changed', person: a.id, by: 'admin' });
let s = null;
if (length(gone)) {
for (let d in gone)
live.add_event({ type: 'device_removed', person: a.id, device: d.id, detail: d.name, dname: d.name, dkind: d.kind, by: 'admin' });
s = apply.sync();
}
let m = core.load();
return { link: core.portal_url(m, m.people[a.id]) };
return { link: core.portal_url(m, m.people[a.id]), removed: length(gone), warning: s?.warning };
}
/** The personal code and links (Copy link, QR, invite): admins only, unlike status. */
@@ -142,7 +160,7 @@ export const methods = {
call: wrap(person_update),
},
person_pause: { args: { id: '', paused: false }, call: wrap(person_pause) },
person_regen: { args: { id: '' }, call: wrap(person_regen) },
person_regen: { args: { id: '', remove: [] }, call: wrap(person_regen) },
person_links: { args: { id: '' }, call: wrap(person_links) },
person_delete: { args: { id: '' }, call: wrap(person_delete) },
person_usage: { args: { id: '', days: 30 }, call: wrap(person_usage) },
@@ -312,7 +312,7 @@ function server_create(a) {
// after that (by hand, or by an older installer) needs a network restart.
let network_restart = !awg.state().handler;
sh_bg(network_restart ? '/etc/init.d/network restart; /etc/init.d/dawnline restart' : '/etc/init.d/dawnline restart');
return { id, applied: r, network_restart };
return { id, applied: r, network_restart, warning: r.warning };
}
/* ---------- interfaces ---------- */
@@ -115,10 +115,11 @@ function settings_update(a) {
check_portal(core.load(c), m);
return { restart, was: m.settings };
});
let s = null;
if (res.restart)
system('/etc/init.d/dawnline reload >/dev/null 2>&1');
else
apply.sync();
s = apply.sync();
// The changes worth a line: the portal and the watchdog (other settings are housekeeping).
let now = core.load().settings, was = res.was;
if (now.portal_enabled != was.portal_enabled)
@@ -140,7 +141,10 @@ function settings_update(a) {
}
if (now.watchdog != was.watchdog)
admin_log('dawnline', now.watchdog ? 'turned on' : 'turned off', null, 'the watchdog', now.watchdog ? null : 'problems are only logged, nothing is repaired');
return settings_get({});
let out = settings_get({});
if (s?.warning)
out.warning = s.warning;
return out;
}
export const methods = {
@@ -9,9 +9,14 @@ import * as core from 'dawnline.core';
/** Section names that are never ids of people, devices, servers, services or circles. */
export const RESERVED_IDS = [ 'settings', 'main', 'global', 'defaults' ];
/** Commit the dawnline config and keep it readable by root only. */
/**
* Commit the dawnline config and keep it readable by root only. A commit
* that did not reach flash (full or read-only overlay) is an error: the
* caller's change never happened, and nothing downstream may act on it.
*/
export function commit(c) {
c.commit(core.CONFIG);
if (!c.commit(core.CONFIG))
die(`Couldn't save /etc/config/dawnline: ${c.error() ?? 'the write failed'}. Is the flash full?`);
system('chmod 600 /etc/config/dawnline');
};
@@ -115,8 +115,11 @@ export function install(ctx, arg) {
out.to = replace(tag, /^v/, '');
ctx.versions(VERSION, out.to);
let f = fetch(ctx, tag, ctx.work);
// The version being replaced, for Roll back (downloaded again: opkg keeps no package files).
if (ctx.pol.keep && out.to != VERSION && upd.kept('app')?.version != VERSION) {
// The version being replaced, for Roll back (downloaded again: opkg keeps
// no package files). Always for an automatic run: nobody is there to
// recover a router whose new version does not come up (postupdate rolls
// back to it on its own).
if ((ctx.pol.keep || ctx.auto?.()) && out.to != VERSION && upd.kept('app')?.version != VERSION) {
ctx.phase(`Keeping Dawnline ${VERSION} for rollback`);
try {
system(`mkdir -p '${ctx.work}/keep'`);
@@ -114,8 +114,14 @@ function reload_module(ctx, before, after) {
iface_intent(i, 'update', c.get('network', i, '_dawnline_name') ?? i);
sh(`ifdown '${i}'`);
}
sh('rmmod amneziawg');
// Both steps must really happen: the new tools against the old module (or
// no module at all) leave every tunnel down while the job says "done".
ctx.run('rmmod amneziawg');
if (stat('/sys/module/amneziawg'))
die('The old AmneziaWG kernel module is still loaded (another AmneziaWG interface may use it): reboot the router to finish the update');
ctx.run('modprobe amneziawg');
if (!stat('/sys/module/amneziawg'))
die("The new AmneziaWG kernel module doesn't load on this firmware: the tunnels stay down until it does (see the log above)");
for (let i in ifaces)
sh(`ifup '${i}'`);
}
@@ -4,7 +4,7 @@
import { open, readfile, writefile, rename, mkdir, stat, unlink, popen, lsdir } from 'fs';
export const VERSION = '0.5.2';
export const VERSION = '0.6.0';
/** GitHub repository with Dawnline releases (updates and the installer). */
export const REPO = 'tickcount/luci-app-dawnline';
export const RUN_DIR = '/var/run/dawnline';
@@ -96,6 +96,7 @@ export function person_view(m, p, usage, dmp, states, opts) {
v.home_nets = p.home_nets;
v.circle = p.circle;
v.created = p.created;
v.code_set = p.code_set;
}
return v;
};