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

+88 -8
View File
@@ -34,6 +34,8 @@ interface State {
can_add: boolean;
/** The admin stopped the person (paused, access ended): the page only shows. */
locked?: boolean;
/** Over plain HTTP: the same link over HTTPS, where the connection settings are. */
https_url?: string | null;
kinds: Kind[];
version: string;
/** The router's day (YYYY-MM-DD) when it sends one; the browser's otherwise. */
@@ -87,6 +89,8 @@ class ApiError extends Error {
constructor(
public status: number,
message: string,
/** The HTTPS twin of this link, when the answer was "not over plain HTTP". */
public httpsUrl?: string,
) {
super(message);
}
@@ -106,7 +110,7 @@ async function call<T>(path: string, body?: unknown): Promise<T> {
} catch {
/* empty */
}
if (!res.ok) throw new ApiError(res.status, data?.error ?? `Request failed (${res.status})`);
if (!res.ok) throw new ApiError(res.status, data?.error ?? `Request failed (${res.status})`, data?.https_url || undefined);
return data as T;
}
@@ -682,11 +686,44 @@ function main(st: State) {
/* ---------- device flows ---------- */
/**
* A plain-HTTP link (an IP address) shows the page, but keys only travel
* encrypted: the connection settings are on the HTTPS twin. Its certificate
* is the router's own, so the browser warns once; say so.
*/
function secureSheet(url: string) {
sheet(
'Open the link securely',
'Connection settings only travel encrypted',
h(
'div',
{ class: 'stack gap' },
h('p', { class: 'muted' }, 'This page is open without encryption. To add or set up a device, open the same link over HTTPS:'),
h('a', { class: 'btn primary block big', href: url }, ic('lock'), h('span', {}, 'Open securely')),
h(
'p',
{ class: 'faint s' },
'The browser may warn that the certificate is not trusted: it is this router’s own. Choose to continue (“Advanced” → “Proceed”).',
),
),
);
}
/** The secure twin when this page is plain HTTP, else null. */
const httpsTwin = () => state?.https_url || null;
async function getConfig(d: Device): Promise<ClientConfig | null> {
const twin = httpsTwin();
if (twin) {
secureSheet(twin);
return null;
}
try {
return await call<ClientConfig>(`devices/${d.id}/config`);
} catch (e) {
toast((e as Error).message, true);
const er = e as ApiError;
if (er.httpsUrl) secureSheet(er.httpsUrl);
else toast(er.message, true);
return null;
}
}
@@ -844,15 +881,47 @@ async function connect(d: Device, initial?: 'app' | 'qr' | 'key' | 'file', cfgIn
else live.replaceChildren(h('span', { class: 'warn' }, 'Waiting for the first connection…'));
};
paintLive(d);
const watch = window.setInterval(async () => {
// Only while the first connection is awaited (every poll is a process on
// the router): 5 s at first, then slower, for ten minutes at most, not
// while the tab is hidden, and never again once the link stopped working
// (a replaced link would otherwise count as guesses from this network).
let timer = 0,
polls = 0,
done = !!d.handshake || d.disabled;
const started = Date.now();
const poll = async () => {
timer = 0;
if (done || Date.now() - started > 600_000) return;
if (document.hidden) {
schedule();
return;
}
try {
const st = await call<State>('state');
state = st;
paintLive(st.person.devices.find((x) => x.id === d.id));
} catch {
/* ignore */
const dev = st.person.devices.find((x) => x.id === d.id);
paintLive(dev);
if (dev?.online || dev?.handshake) {
done = true;
return;
}
} catch (e) {
if ((e as ApiError).status === 404 || (e as ApiError).status === 401) {
done = true;
return;
}
}
}, 5000);
polls++;
schedule();
};
const schedule = () => {
if (!done && !timer) timer = window.setTimeout(poll, polls < 6 ? 5000 : polls < 12 ? 15000 : 30000);
};
const onVisible = () => {
if (!document.hidden && !done && !timer) void poll();
};
document.addEventListener('visibilitychange', onVisible);
schedule();
sheet(
d.handshake ? `Connect ${d.name}` : `${d.name} is ready`,
mobile ? 'Add it to AmneziaVPN on this phone' : 'Scan with the phone’s camera or AmneziaVPN',
@@ -861,7 +930,9 @@ async function connect(d: Device, initial?: 'app' | 'qr' | 'key' | 'file', cfgIn
live,
);
sheetClosed = () => {
clearInterval(watch);
done = true;
if (timer) clearTimeout(timer);
document.removeEventListener('visibilitychange', onVisible);
if (state) main(state);
};
}
@@ -1023,6 +1094,11 @@ function guessName(kind: Kind): string {
function addDevice() {
if (!state) return;
const twin = httpsTwin();
if (twin) {
secureSheet(twin);
return;
}
let kind: Kind = guessKind();
const taken = new Set(state.person.devices.map((d) => d.name.toLowerCase()));
const suggest = (k: Kind) => {
@@ -1084,6 +1160,10 @@ function addDevice() {
const dev = r.state.person.devices.find((d) => d.id === r.id)!;
await connect(dev, undefined, r.config);
} catch (er) {
if ((er as ApiError).httpsUrl) {
secureSheet((er as ApiError).httpsUrl as string);
return;
}
err.textContent = (er as Error).message;
submit.disabled = false;
}