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:
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;
|
||||
};
|
||||
|
||||
Reference in new issue
Block a user