KeyHelp: DNS und Verzeichnisschutz lesend, Ausbau zerlegt (#74)

- Neue nur-lesende Unterobjekt-Arten dns und dirprotect: DNS-Einträge der
  Hauptdomains des Kunden (ohne DKIM), Verzeichnisschutz gefiltert auf den
  Kunden (ohne Passwort/Hash). Ändern wird abgewiesen.
- Reiter in der Ressourcenansicht, API-Validierung erweitert.
- docs/connector-keyhelp.md: Teilschritte mit API-Endpunkt und Stand
  (Cronjobs = /scheduled-tasks, Schreibzugriffe erst mit Testkonto #73,
  Fail2Ban/Backups nur Personal).
Tests: Fake um /dns und /directory-protections erweitert, Mandanten-
trennung trotz Leck, keine Geheimnisse in der Ausgabe.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Claude (KI) 2026-10-06 13:36:33 +02:00
parent 03cf2b00c4
commit 6c70465e2c
7 changed files with 78 additions and 13 deletions

View file

@ -202,12 +202,12 @@ export const resourcesModule: KcModule = {
});
// ---- Hosting: Unterobjekte (Domains, Postfächer, Datenbanken, FTP, SSL) und Panel-Login ----------
const KINDS = ['domain', 'email', 'database', 'ftp', 'certificate'] as const;
const KINDS = ['domain', 'email', 'database', 'ftp', 'certificate', 'dns', 'dirprotect'] as const;
const kindParam = z.object({ id: z.string().uuid(), kind: z.enum(KINDS) });
const childCaps = (r: any): string[] => json<string[]>(r.capabilities_json, []);
/** Schreiben erlaubt: Personal mit Schreibrecht ODER Inhaber/Admin der Organisation, wenn das Produkt es für diese Art freigibt. */
const canManageKind = (r: any, a: AuthContext, kind: string): boolean => {
if (kind === 'certificate') return false;
if (kind === 'certificate' || kind === 'dns' || kind === 'dirprotect') return false; // nur lesend (#74)
if (r.health !== 'ok' || !r.enabled || !childCaps(r).includes('children.write')) return false;
if (can(a.principal, 'resources.write')) return true;
const need = CHILD_MANAGE[kind];

View file

@ -5,10 +5,10 @@ import { copyText } from '@/lib/clipboard';
import { generatePassword, MIN_CHILD_PASSWORD } from '@/lib/password';
import { Alert, Empty, Field, fmt, fmtDate } from '@/components/ui';
type Kind = 'domain' | 'email' | 'database' | 'ftp' | 'certificate';
type Kind = 'domain' | 'email' | 'database' | 'ftp' | 'certificate' | 'dns' | 'dirprotect';
interface Child { id: string; kind: Kind; name: string; state: string; validUntil?: string | null; details: Record<string, any> }
interface Kinds { kinds: { kind: Kind; canWrite: boolean }[]; panelLogin: boolean }
const LABEL: Record<Kind, string> = { domain: 'Domains', email: 'E-Mail', database: 'Datenbanken', ftp: 'FTP', certificate: 'SSL-Zertifikate' };
const LABEL: Record<Kind, string> = { domain: 'Domains', email: 'E-Mail', database: 'Datenbanken', ftp: 'FTP', certificate: 'SSL-Zertifikate', dns: 'DNS', dirprotect: 'Verzeichnisschutz' };
const STATE: Record<string, [string, string, string]> = { active: ['ok', '●', 'Aktiv'], disabled: ['lock', '⊘', 'Deaktiviert'], pending: ['info', '◐', 'Wird eingerichtet'], error: ['err', '✕', 'Fehler'], expired: ['warn', '▲', 'Abgelaufen'] };
const bytes = (b?: number | null) => (b == null ? '–' : b < 1024 ** 2 ? `${Math.max(0, Math.round(b / 1024))} KB` : b < 1024 ** 3 ? `${(b / 1024 ** 2).toFixed(1)} MB` : `${(b / 1024 ** 3).toFixed(1)} GB`);
const USAGE: Record<string, { label: string; bytes?: boolean }> = { disk_space: { label: 'Speicher', bytes: true }, traffic: { label: 'Traffic', bytes: true }, domains: { label: 'Domains' }, email_accounts: { label: 'Postfächer' }, databases: { label: 'Datenbanken' }, ftp_users: { label: 'FTP-Benutzer' }, subdomains: { label: 'Subdomains' } };
@ -92,7 +92,7 @@ export function HostingPanel({ resourceId, canLogin }: { resourceId: string; can
{kinds.kinds.map((k) => <button key={k.kind} role="tab" aria-selected={kind === k.kind} className="btn" style={kind === k.kind ? { background: 'var(--surface-2)', fontWeight: 600, borderColor: 'var(--accent)' } : undefined} onClick={() => { setKind(k.kind); setAdding(false); setMsg(null); setDel(null); }}>{LABEL[k.kind]}</button>)}</div>
{msg && <Alert kind={msg.k}>{msg.t}</Alert>}
{err && <Alert kind="err">{err}</Alert>}
{canWrite && kind !== 'certificate' && <div style={{ marginBottom: 12 }}><button className="btn primary" aria-expanded={adding} onClick={() => { setAdding(!adding); setPw(''); }}>{{ domain: 'Domain hinzufügen', email: 'Postfach anlegen', database: 'Datenbank anlegen', ftp: 'FTP-Zugang anlegen', certificate: '' }[kind]}</button></div>}
{canWrite && kind !== 'certificate' && <div style={{ marginBottom: 12 }}><button className="btn primary" aria-expanded={adding} onClick={() => { setAdding(!adding); setPw(''); }}>{{ domain: 'Domain hinzufügen', email: 'Postfach anlegen', database: 'Datenbank anlegen', ftp: 'FTP-Zugang anlegen', certificate: '', dns: '', dirprotect: '' }[kind]}</button></div>}
{adding && canWrite && <form onSubmit={create} style={{ borderBottom: '1px solid var(--border)', marginBottom: 16, paddingBottom: 8 }}>
{kind === 'domain' && <div className="cols"><Field id="hp-dom" label="Domainname"><input id="hp-dom" name="domain" required placeholder="beispiel.de oder www.beispiel.de" /></Field><Field id="hp-php" label="PHP-Version (leer = Standard)"><input id="hp-php" name="php" placeholder="z. B. 8.3" /></Field><label className="row" style={{ alignSelf: 'end', minHeight: 44 }}><input type="checkbox" name="le" defaultChecked style={{ width: 20, minHeight: 20 }} />Let’s Encrypt und HTTPS</label></div>}
{kind === 'email' && <><div className="cols"><Field id="hp-loc" label="Postfach"><input id="hp-loc" name="local" required placeholder="info" /></Field><Field id="hp-md" label="Domain"><select id="hp-md" name="mdomain" required>{domains.filter((d) => d.details.emailDomain || true).map((d) => <option key={d.id} value={d.name}>{d.name}</option>)}</select></Field><Field id="hp-sz" label="Größe in MB (optional)"><input id="hp-sz" name="size" type="number" min={0} /></Field></div><PasswordField id="hp-pw" value={pw} onChange={setPw} /></>}
@ -107,6 +107,8 @@ export function HostingPanel({ resourceId, canLogin }: { resourceId: string; can
{r.kind === 'email' && <>{bytes(d.sizeBytes)} von {d.maxSizeBytes ? bytes(d.maxSizeBytes) : 'unbegrenzt'}{d.forwardings?.length ? ` · Weiterleitung an ${d.forwardings.join(', ')}` : ''}</>}
{r.kind === 'database' && <>Benutzer <span className="mono">{d.user}</span> · {bytes(d.sizeBytes)}</>}
{r.kind === 'ftp' && <>Verzeichnis <span className="mono">{d.home}</span></>}
{r.kind === 'dns' && <><span className="mono">{d.type}</span> → <span className="mono">{d.value}</span>{d.ttl ? ` · TTL ${d.ttl}` : ''}</>}
{r.kind === 'dirprotect' && <>Benutzer <span className="mono">{d.username ?? '–'}</span>{d.realm ? ` · „${d.realm}“` : ''}{d.exceptions?.length ? ` · Ausnahmen: ${d.exceptions.join(', ')}` : ''}</>}
{r.kind === 'certificate' && <>{d.issuer ?? '–'} · gültig bis {r.validUntil ? fmtDate(r.validUntil) : '–'} · {(d.securedDomains ?? []).join(', ')}</>}</td>
<td><span className={`badge ${c}`}><span aria-hidden="true">{i}</span>{l}</span></td>
{canWrite && <td>{del === r.id ? <div role="alertdialog" aria-label="Löschen bestätigen"><p className="small" style={{ margin: '0 0 8px' }}><strong>„{r.name}“ endgültig löschen?</strong>{r.kind !== 'domain' ? ' Die Daten gehen verloren.' : ' Zugehörige Inhalte können verloren gehen.'}</p><div className="row"><button className="btn small danger" disabled={busy} onClick={() => submit('delete', {}, { id: r.id, okText: 'Wurde gelöscht.' })}>Ja, löschen</button><button className="btn small" onClick={() => setDel(null)}>Abbrechen</button></div></div>

View file

@ -21,7 +21,22 @@ Paket `packages/connector-keyhelp`, getestet gegen einen nach der Definition nac
7. Listen liefern alles (kein Paging): bei sehr vielen Kunden dauert der Abgleich (Statistik je Kunde, 4 parallel).
### Noch nicht umgesetzt
DNS-Editor, Cronjobs, Verzeichnisschutz, PHP-Einstellungen je Kunde, Zertifikate hochladen, Fail2Ban-Entsperren, Backup-Liste anzeigen; Hauptdomain bei der Bestellung erfragen; Kündigung mit `delete_on` statt Sperre; Tarifwechsel in der Oberfläche.
Ausbau in Teilschritten (#74) – Stufe 1 **umgesetzt (nur lesend)**: DNS-Einträge der Hauptdomains des Kunden (`GET /dns/{id}`, DKIM wird nicht ausgegeben) und Verzeichnisschutz (`GET /directory-protections`, gefiltert auf den Kunden, ohne Passwort/Hash) als Reiter „DNS“ und „Verzeichnisschutz“ in der Ressourcenansicht.
| Teilschritt | API | Stand |
|---|---|---|
| DNS lesen | `GET /dns/{id}` | umgesetzt |
| Verzeichnisschutz lesen | `GET /directory-protections` | umgesetzt |
| Cronjobs lesen | `GET /scheduled-tasks` | offen (nächster Schritt) |
| DNS ändern | `PUT /dns/{id}` (ersetzt die Zone) | offen – erst mit Testkonto (#73), da Fehler Mail/Web des Kunden lahmlegen |
| Verzeichnisschutz anlegen/ändern | `POST/PUT /directory-protections` | offen (Passwort als Secret wie bei FTP) |
| Cronjobs anlegen/ändern | `/scheduled-tasks` | offen |
| Zertifikat hochladen | `POST /certificates` | offen (privater Schlüssel nur als Secret, nie gespeichert) |
| Fail2Ban-Liste / Entsperren | `/fail2ban/banned-ips` | nur Personal (serverweit, enthält fremde IPs) – offen |
| Backup-Liste | `/backups/operations` | nur Personal (serverweit) – offen; Wiederherstellung per API nicht möglich |
| Kündigung mit `delete_on`, Tarifwechsel in der Oberfläche | `PUT /clients/{id}` | offen |
Schreibende Schritte werden einzeln mit Eigentums-/Rollenprüfung und Fake-Tests gebaut; die Live-Abnahme bindet an ein freigegebenes Testkonto (#73).
# (Auswertung der API-Definition)

View file

@ -120,27 +120,52 @@ export function createKeyHelpConnector(deps: KeyHelpDeps = {}): Connector {
const until = iso(r.valid_till);
return { id: String(r.id), kind, name: r.name, state: until && new Date(until) < now() ? 'expired' : 'active', validUntil: until, details: { issuer: r.issuer ?? null, securedDomains: r.secured_domains ?? [], usedByDomains: r.usage?.domain_count ?? null } };
}
const PATH: Record<ChildKind, string> = { domain: 'domains', email: 'emails', database: 'databases', ftp: 'ftp-users', certificate: 'certificates' };
const LISTKEY: Record<ChildKind, string> = { domain: 'domains', email: 'emails', database: 'databases', ftp: 'ftp_users', certificate: 'certificates' };
const NAMEKEY: Record<ChildKind, string> = { domain: 'domain', email: 'email', database: 'database_name', ftp: 'username', certificate: 'name' };
const PATH: Record<ChildKind, string> = { domain: 'domains', email: 'emails', database: 'databases', ftp: 'ftp-users', certificate: 'certificates', dns: 'dns', dirprotect: 'directory-protections' };
const LISTKEY: Record<ChildKind, string> = { domain: 'domains', email: 'emails', database: 'databases', ftp: 'ftp_users', certificate: 'certificates', dns: '', dirprotect: '' };
const NAMEKEY: Record<ChildKind, string> = { domain: 'domain', email: 'email', database: 'database_name', ftp: 'username', certificate: 'name', dns: '', dirprotect: '' };
async function getClient(ctx: ConnectorContext, id: string): Promise<RawClient> { return call<RawClient>(ctx, 'GET', `/clients/${encodeURIComponent(id)}`); }
async function plansMap(ctx: ConnectorContext): Promise<Map<number, string>> { try { return new Map((await call<RawPlan[]>(ctx, 'GET', '/hosting-plans')).map((p) => [p.id, p.name])); } catch { return new Map(); } }
// ---- Unterobjekte ------------------------------------------------------------------
/** DNS-Einträge aller (Haupt-)Domains des Kunden – nur lesend. Pro Domain ein Aufruf, höchstens 50 Domains. */
async function listDns(ctx: ConnectorContext, cid: string): Promise<NormalizedChild[]> {
const res = await call<Record<string, Row[]>>(ctx, 'GET', `/clients/${encodeURIComponent(cid)}/resources`);
const doms = (res?.domains ?? []).filter((d) => (String(d.id_user) === cid || d.id_user === undefined) && !d.id_parent_domain).slice(0, 50);
const out: NormalizedChild[] = [];
for (const d of doms) {
const z = await optional(call<Row>(ctx, 'GET', `/dns/${encodeURIComponent(String(d.id))}`)); if (!z) continue;
const recs = Array.isArray((z.records as Row | undefined)?.other) ? ((z.records as Row).other as Row[]) : [];
recs.forEach((r, i) => {
const host = String(r.host ?? '@'); const fq = host === '@' || host === '' ? String(d.domain) : `${host}.${d.domain}`;
out.push({ id: `${d.id}:${i}`, kind: 'dns', name: fq, state: z.is_dns_disabled ? 'disabled' : 'active', details: { domain: d.domain, type: r.type ?? null, value: r.value ?? null, ttl: r.ttl ?? null, customZone: !!z.is_custom_dns } });
});
}
return out;
}
/** Verzeichnisschutz des Kunden – nur lesend; Benutzername ja, Passwort/Hash nie. */
async function listDirProtect(ctx: ConnectorContext, cid: string): Promise<NormalizedChild[]> {
const rows = await call<Row[]>(ctx, 'GET', '/directory-protections');
if (!Array.isArray(rows)) throw new ConnectorError('INVALID_RESPONSE');
return rows.filter((r) => String(r.id_user) === cid).map((r) => ({ id: String(r.id), kind: 'dirprotect' as const, name: String(r.path ?? ''), state: Number(r.status ?? 1) === 0 ? 'disabled' as const : 'active' as const,
details: { username: r.username ?? null, realm: r.auth_name ?? null, exceptions: Array.isArray(r.exceptions) ? r.exceptions : [] } }));
}
const children: ChildAccess = {
async kinds(ctx, parentRef) {
const c = await getClient(ctx, parentRef); const p = c.permissions ?? {};
return [{ kind: 'domain', canWrite: true }, { kind: 'email', canWrite: true }, { kind: 'database', canWrite: true }, { kind: 'ftp', canWrite: p.ftp !== false }, { kind: 'certificate', canWrite: false }];
return [{ kind: 'domain', canWrite: true }, { kind: 'email', canWrite: true }, { kind: 'database', canWrite: true }, { kind: 'ftp', canWrite: p.ftp !== false }, { kind: 'certificate', canWrite: false },
{ kind: 'dns', canWrite: false }, { kind: 'dirprotect', canWrite: false }];
},
async list(ctx, parentRef, kind) {
if (kind === 'dns') return listDns(ctx, parentRef);
if (kind === 'dirprotect') return listDirProtect(ctx, parentRef);
const res = await call<Record<string, Row[]>>(ctx, 'GET', `/clients/${encodeURIComponent(parentRef)}/resources`);
const rows = res?.[LISTKEY[kind]]; if (!Array.isArray(rows)) throw new ConnectorError('INVALID_RESPONSE');
return rows.filter((r) => String(r.id_user) === parentRef || r.id_user === undefined).map((r) => mapChild(kind, r)); // doppelt abgesichert: nur Objekte dieses Kunden
},
async act(ctx, req) {
const { parentRef: cid, kind, op, id } = req; const d = req.data ?? {}; const path = PATH[kind];
if (kind === 'certificate') throw new ConnectorError('UNSUPPORTED', 'Zertifikate sind nur lesbar');
if (kind === 'certificate' || kind === 'dns' || kind === 'dirprotect') throw new ConnectorError('UNSUPPORTED', 'Diese Angaben sind nur lesbar');
const fetchOwned = async (): Promise<Row> => owned(await optional(call<Row>(ctx, 'GET', `/${path}/${encodeURIComponent(str(id, 'id', 40))}`)), cid);
if (op === 'delete') {
const row = await optional(call<Row>(ctx, 'GET', `/${path}/${encodeURIComponent(str(id, 'id', 40))}`)); if (!row) return {}; // schon weg: Ziel erreicht (idempotent)

View file

@ -41,6 +41,11 @@ export function createFake(apiKey = 'test-key'): Fake {
calls.push({ method, path, body, key: h['x-api-key'] });
if (h['x-api-key'] !== apiKey) return err(401, 'Unauthorized');
if (method === 'GET' && opts.failGet503 > 0) { opts.failGet503--; return err(503, 'Webserver wird neu geladen'); }
{ const dm = /^\/dns\/(\d+)$/.exec(path); if (dm && method === 'GET') { const d = byId(state.domains, dm[1]!); if (!d) return err(404, 'not found');
return json({ is_custom_dns: false, is_dns_disabled: false, dkim_record: 'v=DKIM1; GEHEIM?', records: { soa: { ttl: 3600, primary_ns: 'ns3.example.test' }, other: [{ host: '@', ttl: 3600, type: 'A', value: '203.0.113.10' }, { host: 'www', ttl: 3600, type: 'CNAME', value: String(d.domain) }] } }); } }
if (path === '/directory-protections' && method === 'GET') return json([
{ id: 70, id_user: 1, status: 1, path: '/www/intern', exceptions: ['/www/intern/public'], auth_name: 'Intern', username: 'chef', password: 'KLARTEXT-GEHEIM', password_hash: '$apr1$GEHEIM' },
{ id: 71, id_user: 2, status: 1, path: '/www/beta', exceptions: [], auth_name: 'Beta', username: 'beta', password_hash: '$apr1$X' }]);
if (path === '/ping') return json({ response: 'pong' });
if (path === '/server') return json({ meta: { hostname: 'kh.test', panel_version: '26.0', api_version: '2.15', keyhelp_pro: false } });
if (path === '/hosting-plans' && method === 'GET') return json(state.plans);

View file

@ -100,7 +100,7 @@ describe('KeyHelp-Connector: Konto anlegen und ändern', () => {
describe('KeyHelp-Connector: Unterobjekte und Mandantentrennung', () => {
it('listet alle Arten, liefert nie Passwörter und nie Objekte fremder Kunden', async () => {
const f = createFake(); f.opts.leakForeign = true; const ch = mk(f).children!;
expect((await ch.kinds(ctx(), '1')).map((k) => [k.kind, k.canWrite])).toEqual([['domain', true], ['email', true], ['database', true], ['ftp', true], ['certificate', false]]);
expect((await ch.kinds(ctx(), '1')).map((k) => [k.kind, k.canWrite])).toEqual([['domain', true], ['email', true], ['database', true], ['ftp', true], ['certificate', false], ['dns', false], ['dirprotect', false]]);
expect((await ch.kinds(ctx(), '2')).find((k) => k.kind === 'ftp')!.canWrite).toBe(false); // Recht "ftp" fehlt
const doms = await ch.list(ctx(), '1', 'domain'); expect(doms.map((d) => d.name)).toEqual(['alpha.example.test', 'alpha.sys.example.test']); // beta.example.test wurde trotz "Leck" gefiltert
expect(doms[0]!.details).toMatchObject({ letsEncrypt: true, forceHttps: true, emailDomain: true, system: false });
@ -185,3 +185,20 @@ describe('KeyHelp-Connector: Kunden übernehmen und Tarife anlegen', () => {
expect(fresh.calls.some((x) => x.method === 'POST')).toBe(false);
});
});
describe('KeyHelp-Connector: DNS und Verzeichnisschutz nur lesend (#74)', () => {
it('DNS: Einträge nur der Hauptdomains dieses Kunden; Verzeichnisschutz ohne Passwort/Hash; Ändern abgewiesen', async () => {
const f = createFake(); f.opts.leakForeign = true; const ch = mk(f).children!;
const dns = await ch.list(ctx(), '1', 'dns');
expect(dns.map((r) => [r.name, r.details.type, r.details.value])).toEqual([
['alpha.example.test', 'A', '203.0.113.10'], ['www.alpha.example.test', 'CNAME', 'alpha.example.test'],
['alpha.sys.example.test', 'A', '203.0.113.10'], ['www.alpha.sys.example.test', 'CNAME', 'alpha.sys.example.test']]);
expect(dns.some((r) => String(r.details.domain).startsWith('beta'))).toBe(false); // fremde Domain trotz Leck gefiltert
expect(JSON.stringify(dns)).not.toMatch(/DKIM|GEHEIM/);
const dp = await ch.list(ctx(), '1', 'dirprotect');
expect(dp.map((d) => [d.name, d.details.username])).toEqual([['/www/intern', 'chef']]);
expect(JSON.stringify(dp)).not.toMatch(/GEHEIM|apr1|password/i);
await expect(ch.act(ctx(), { parentRef: '1', kind: 'dns', op: 'delete', id: '10:0', data: {}, idempotencyKey: 'k' })).rejects.toMatchObject({ code: 'UNSUPPORTED' });
});
});

View file

@ -73,7 +73,8 @@ export interface NewCatalogSpec {
}
// ---- Unterobjekte (z. B. Domains, Postfächer, Datenbanken eines Hosting-Kontos) ----
export type ChildKind = 'domain' | 'email' | 'database' | 'ftp' | 'certificate';
/** Lesend-only-Arten: dns, dirprotect (Verzeichnisschutz) – ändern erst in einer späteren Ausbaustufe (#74). */
export type ChildKind = 'domain' | 'email' | 'database' | 'ftp' | 'certificate' | 'dns' | 'dirprotect';
export type ChildOp = 'create' | 'update' | 'delete';
export interface NormalizedChild {
id: string; kind: ChildKind; name: string; state: 'active' | 'disabled' | 'pending' | 'error' | 'expired';