// Erzeugt aus den Messdaten den veröffentlichungsfähigen Studienordner. // Die Daten enthalten keine Gemeindenamen, Schlüssel oder Adressen. Die Zeilen werden mit einem // einmaligen, nicht gespeicherten Zufallswert gemischt, damit sich keine Zeile einer Gemeinde zuordnen lässt. // Aufruf: node 14-studie.mjs [--endfassung] import { createHash, randomBytes } from 'node:crypto'; import { copyFileSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'; import { dirname, join } from 'node:path'; import { fileURLToPath } from 'node:url'; const hier = dirname(fileURLToPath(import.meta.url)); const pfad = (d) => join(hier, 'daten', d); const ziel = join(hier, 'studie', 'gemeinden-website-hosting'); mkdirSync(ziel, { recursive: true }); const jsonl = (d) => readFileSync(pfad(d), 'utf8').trim().split('\n').filter(Boolean).map((z) => JSON.parse(z)); const json = (d) => JSON.parse(readFileSync(pfad(d), 'utf8')); const EU = new Set('AT BE BG HR CY CZ DK EE FI FR DE GR HU IE IT LV LT LU MT NL PL PT RO SK SI ES SE'.split(' ')); const LAENDER = { '01': 'Schleswig-Holstein', '03': 'Niedersachsen', '05': 'Nordrhein-Westfalen', '06': 'Hessen', '07': 'Rheinland-Pfalz', '08': 'Baden-Württemberg', '09': 'Bayern', 12: 'Brandenburg', 13: 'Mecklenburg-Vorpommern', 14: 'Sachsen', 15: 'Sachsen-Anhalt', 16: 'Thüringen' }; // Die vier Gemeinden der Stadtstaaten werden mit dem Saarland zusammengefasst, damit keine Einzelwerte erkennbar sind. const landName = (l) => (['02', '04', '10', '11'].includes(l) ? 'Berlin, Bremen, Hamburg, Saarland' : LAENDER[l] ?? LAENDER[Number(l)]); const klasse = (e) => (e == null ? 'unbekannt' : e < 1000 ? '1 unter 1.000' : e < 5000 ? '2 1.000 bis 4.999' : e < 20000 ? '3 5.000 bis 19.999' : e < 100000 ? '4 20.000 bis 99.999' : '5 ab 100.000'); const region = (l) => (l === 'US' ? 'USA' : l === 'GB' || l === 'GB/GG' ? 'UK/Kanalinseln' : 'Sonstige'); const rolleKurz = (r) => (r === 'betreiber_ist_konzern' ? 'konzern' : r === 'finanzinvestor' ? 'finanzinvestor' : ''); const rund = (x, n = 2) => Number(x.toFixed(n)); const de = (x, n = 1) => x.toLocaleString('de-DE', { minimumFractionDigits: n, maximumFractionDigits: n }); const pz = (a, b) => (b ? 100 * a / b : 0); const DIENST = new Set(['hoster', 'cloud', 'cdn']); // Festlegungen aus der Kritik: Transitnetz mit fremdem Adressblock zählt nicht, eine Eigentümergruppe wird einheitlich gewertet. const NICHT_WERTEN = new Set(json('netze/festlegungen.json').nicht_werten); const BELEG_AUSSCHLUSS = new RegExp(json('netze/festlegungen.json').beleg_ausschluss, 'i'); const GRUPPE_CINVEN = new Set(['8648', '51468', '45012', '47215', '197495']); const QUELLENSTAND = { 51167: '2022-06-08 (Portfolioseite undatiert, abgerufen 2026-11-21)', 13246: 'undatiert, abgerufen 2026-11-21', 8648: '2025-11-14 (Portfolioseite undatiert, abgerufen 2026-11-21)', 51468: '2025-11-14 (Portfolioseite undatiert, abgerufen 2026-11-21)', 45012: '2025-11-14 (Portfolioseite undatiert, abgerufen 2026-11-21)', 47215: '2025-11-14 (Portfolioseite undatiert, abgerufen 2026-11-21)', 197495: '2025-11-14 (Portfolioseite undatiert, abgerufen 2026-11-21)', 34011: '2026-02-25', 21499: '2026-02-25', 8972: '2026-02-25', 60253: '2026-02-25', 20773: '2026-02-25', 44273: '2026-02-25', }; const nachweis = new Map(); const kritik = []; for (const n of [1, 2, 3, 4]) { for (const x of json(`netze/nichteu-nachweis-${n}.json`)) nachweis.set(String(x.asn), x); kritik.push(...json(`netze/nichteu-kritik-${n}.json`)); } const gehalten = new Map(); for (const k of kritik) { const asn = String(k.asn); if (NICHT_WERTEN.has(asn) || !(k.haelt === true || GRUPPE_CINVEN.has(asn))) continue; const v = nachweis.get(asn); const cinven = GRUPPE_CINVEN.has(asn); gehalten.set(asn, { asn, land: cinven ? 'GB/GG' : k.kontroll_land ?? v.kontroll_land, rolle: cinven ? 'finanzinvestor' : k.rolle ?? v.rolle, funktion: k.funktion ?? v.funktion, stand: QUELLENSTAND[asn] ?? v.stand, // Beleg-Adressen mit dem Namen einer Gemeinde werden nicht veröffentlicht. belege: [...new Set([...(v.belege ?? []), ...(k.gegenbelege ?? [])].map((b) => b.url).filter((u) => u && !BELEG_AUSSCHLUSS.test(u)))], }); } const cinvenBelege = [...new Set(['8648', '51468'].flatMap((a) => gehalten.get(a)?.belege ?? []))]; for (const a of GRUPPE_CINVEN) if (gehalten.has(a)) gehalten.get(a).belege = [...new Set([...gehalten.get(a).belege, ...cinvenBelege])]; for (const x of gehalten.values()) if (!x.land || EU.has(x.land) || !x.belege.length || !x.funktion) throw new Error(`Netz ${x.asn} ist nicht belegt`); const asNamen = json('as-namen.json'); const alle = jsonl('gemeinden-hosting.jsonl'); const salz = randomBytes(32); const zeilen = alle.map((g) => { const best = g.inhalt === 'bestaetigt'; const web = best && Boolean(g.asn); const dns = best && g.nsAsn.length > 0; const netz = web ? gehalten.get(String(g.asn)) : null; const regLand = web ? asNamen[g.asn]?.land : null; const dnsNetze = dns ? g.nsAsn.map((a) => gehalten.get(String(a))).filter(Boolean) : []; return { sort: createHash('sha256').update(salz).update(g.ags).digest('hex'), land: g.land, klasse: klasse(g.einwohner), host: g.host, ziel: g.ziel, asn: g.asn, inhalt: g.inhalt, web_auswertbar: web ? 'ja' : 'nein', netz_register: !web ? '' : !regLand ? 'unbekannt' : regLand === 'DE' ? 'DE' : EU.has(regLand) ? 'EU' : 'nicht_EU', web_kontrolle: !web ? '' : !netz ? 'kein_nachweis' : DIENST.has(netz.funktion) ? 'dienst' : 'netz', web_region: netz ? region(netz.land) : '', web_rolle: netz ? rolleKurz(netz.rolle) : '', web_funktion: netz ? netz.funktion : '', dns_auswertbar: dns ? 'ja' : 'nein', dns_nicht_eu: !dns ? '' : dnsNetze.length ? 'ja' : 'nein', dns_usa: !dns ? '' : dnsNetze.some((x) => x.land === 'US') ? 'ja' : 'nein', ipv6: best ? (g.ipv6 ? 'ja' : 'nein') : '', }; }).sort((a, b) => a.sort.localeCompare(b.sort)); const csv = (kopf, reihen) => `${kopf.join(',')}\n${reihen.map((r) => kopf.map((k) => { const s = String(r[k] ?? ''); return /[",\n]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s; }).join(',')).join('\n')}\n`; // Merkmalskombinationen mit weniger als 5 Gemeinden werden vergröbert, ohne die Kernzahlen zu verändern. const MIN_ZELLE = 5; const merkmal = (x) => [x.netz_register, x.web_kontrolle, x.web_region, x.web_rolle, x.web_funktion].join('|'); const zellen = () => { const m = new Map(); for (const x of zeilen) if (x.web_auswertbar === 'ja') m.set(merkmal(x), (m.get(merkmal(x)) ?? 0) + 1); return m; }; for (const schritt of [(x) => { x.web_funktion = 'zusammengefasst'; }, (x) => { if (x.web_region !== 'USA') x.web_region = 'Sonstige'; }]) { const m = zellen(); for (const x of zeilen) if (x.web_auswertbar === 'ja' && x.web_kontrolle !== 'kein_nachweis' && m.get(merkmal(x)) < MIN_ZELLE) schritt(x); } // Bei deutsch registrierten Transit- und Stadtnetzen gehen Region und Rolle in keine Kernzahl ein. if ([...zellen().entries()].some(([k, n]) => k.startsWith('DE|netz|') && n < MIN_ZELLE)) { for (const x of zeilen) if (x.netz_register === 'DE' && x.web_kontrolle === 'netz') { x.web_region = 'zusammengefasst'; x.web_rolle = 'zusammengefasst'; x.web_funktion = 'zusammengefasst'; } } const kleinsteZelle = Math.min(...zellen().values()); if (kleinsteZelle < MIN_ZELLE) throw new Error(`Zelle mit nur ${kleinsteZelle} Gemeinden`); const DATEN = ['inhalt', 'web_auswertbar', 'netz_register', 'web_kontrolle', 'web_region', 'web_rolle', 'web_funktion', 'dns_auswertbar', 'dns_nicht_eu', 'dns_usa', 'ipv6']; writeFileSync(join(ziel, 'daten.csv'), csv(DATEN, zeilen)); function gruppe(name, liste) { const web = liste.filter((z) => z.web_auswertbar === 'ja'); const dns = liste.filter((z) => z.dns_auswertbar === 'ja'); const anteil = (l, f) => rund(pz(l.filter(f).length, l.length), 4); // Weitere Spalten würden per Differenz einzelne Gemeinden in kleinen Gruppen erkennbar machen. return { gruppe: name, gemeinden: liste.length, bestaetigt: liste.filter((z) => z.inhalt === 'bestaetigt').length, web_basis: web.length, dns_basis: dns.length, anteil_dienst: anteil(web, (z) => z.web_kontrolle === 'dienst'), anteil_dns: anteil(dns, (z) => z.dns_nicht_eu === 'ja'), }; } const nach = (f) => { const m = new Map(); for (const z of zeilen) { const k = f(z); if (!m.has(k)) m.set(k, []); m.get(k).push(z); } return m; }; const GRUPPE = ['gruppe', 'gemeinden', 'bestaetigt', 'web_basis', 'dns_basis', 'anteil_dienst', 'anteil_dns']; const laender = [...nach((z) => landName(z.land)).entries()].map(([n, l]) => gruppe(n, l)).sort((a, b) => a.gruppe.localeCompare(b.gruppe, 'de')); writeFileSync(join(ziel, 'laender.csv'), csv(GRUPPE, laender)); const groessen = [...nach((z) => z.klasse).entries()].sort((a, b) => a[0].localeCompare(b[0])).map(([n, l]) => gruppe(n.replace(/^\d /, ''), l)); writeFileSync(join(ziel, 'groessen.csv'), csv(GRUPPE, groessen)); const best = alle.filter((g) => g.inhalt === 'bestaetigt'); const netzRoh = [...gehalten.values()].map((x) => ({ asn: x.asn, region: region(x.land), kontroll_land: x.land, rolle: rolleKurz(x.rolle), funktion: x.funktion, gemeinden_web: best.filter((g) => String(g.asn) === x.asn).length, gemeinden_dns: best.filter((g) => g.nsAsn.map(String).includes(x.asn)).length, quellenstand: x.stand ?? '', belege: x.belege.join(' '), })).filter((x) => x.gemeinden_web + x.gemeinden_dns > 0).sort((a, b) => (b.gemeinden_web + b.gemeinden_dns) - (a.gemeinden_web + a.gemeinden_dns)); // Netze mit nur wenigen Gemeinden werden zusammengefasst, kleine Einzelwerte nicht ausgewiesen. const zelle = (n) => (n > 0 && n < MIN_ZELLE ? 'unter 5' : n); const netzGross = netzRoh.filter((x) => x.gemeinden_web >= MIN_ZELLE || x.gemeinden_dns >= MIN_ZELLE); const netzKlein = netzRoh.filter((x) => !netzGross.includes(x)); const netzZeilen = netzGross.map((x) => ({ ...x, gemeinden_web: zelle(x.gemeinden_web), gemeinden_dns: zelle(x.gemeinden_dns) })); if (netzKlein.length) { netzZeilen.push({ asn: `weitere ${netzKlein.length} Netze`, region: 'gemischt', kontroll_land: 'mehrere', rolle: 'gemischt', funktion: 'gemischt', gemeinden_web: zelle(netzKlein.reduce((s, x) => s + x.gemeinden_web, 0)), gemeinden_dns: zelle(netzKlein.reduce((s, x) => s + x.gemeinden_dns, 0)), quellenstand: 'je Netz unterschiedlich', belege: '', }); } // Die öffentliche Netztabelle zeigt Klartext statt interner Kennungen. const KLARTEXT = { konzern: 'Konzern', finanzinvestor: 'Finanzinvestor', gemischt: 'Gemischt', mehrere: 'Mehrere', hoster: 'Hoster', cloud: 'Cloud', cdn: 'Auslieferungsnetz', netz_rechenzentrum: 'Transit, Stadtnetz oder Rechenzentrum', dns_domain: 'DNS und Domains' }; for (const r of netzZeilen) for (const k of ['region', 'kontroll_land', 'rolle', 'funktion']) r[k] = KLARTEXT[r[k]] ?? r[k]; writeFileSync(join(ziel, 'netze.csv'), csv(['asn', 'region', 'kontroll_land', 'rolle', 'funktion', 'gemeinden_web', 'gemeinden_dns', 'quellenstand', 'belege'], netzZeilen)); const audit = [1, 2, 3].flatMap((n) => json(`audit/ergebnis-${n}.json`)).map((a) => ({ s: createHash('sha256').update(salz).update(a.ags).digest('hex'), pruefurteil: a.urteil })).sort((a, b) => a.s.localeCompare(b.s)); writeFileSync(join(ziel, 'stichprobe.csv'), csv(['pruefurteil'], audit)); for (const d of readdirSync(ziel)) if (/^\d\d-.*\.mjs$/.test(d)) rmSync(join(ziel, d)); const skripte = readdirSync(hier).filter((d) => /^\d\d-.*\.mjs$/.test(d)).sort(); for (const d of skripte) copyFileSync(join(hier, d), join(ziel, d)); const z = (f) => zeilen.filter(f).length; const webN = z((x) => x.web_auswertbar === 'ja'); const dnsN = z((x) => x.dns_auswertbar === 'ja'); const bestN = z((x) => x.inhalt === 'bestaetigt'); const wWeb = { web_auswertbar: 'ja' }; const wDns = { dns_auswertbar: 'ja' }; const anteil = (wo, basis, teil, nk = 1) => ({ datei: 'daten.csv', rechnung: 'anteil', wo: { ...basis, ...wo }, basis, nachkomma: nk, ergebnis: rund(pz(teil, z((x) => Object.entries(basis).every(([k, v]) => x[k] === v))), nk) }); const istDienst = (x) => x.web_kontrolle === 'dienst'; const nDe = z((x) => x.netz_register === 'DE'); const nDienst = z(istDienst); const nNetz = z((x) => x.web_kontrolle === 'netz'); const nGesamt = nDienst + nNetz; const nUs = z((x) => istDienst(x) && x.web_region === 'USA'); const nFi = z((x) => istDienst(x) && x.web_rolle === 'finanzinvestor'); const nUsFi = z((x) => istDienst(x) && x.web_region === 'USA' && x.web_rolle === 'finanzinvestor'); const nDns = z((x) => x.dns_nicht_eu === 'ja'); const nV6 = z((x) => x.ipv6 === 'ja'); const nDeDienst = z((x) => x.netz_register === 'DE' && istDienst(x)); const nDeGesamt = z((x) => x.netz_register === 'DE' && (x.web_kontrolle === 'dienst' || x.web_kontrolle === 'netz')); const adressen = new Set(zeilen.filter((x) => x.inhalt === 'bestaetigt').map((x) => x.host)).size; const zielAdressen = new Map(); for (const x of zeilen) if (x.web_auswertbar === 'ja') zielAdressen.set(x.ziel, x.web_kontrolle); const zieleDienst = [...zielAdressen.values()].filter((k) => k === 'dienst').length; const auditOk = audit.filter((a) => a.pruefurteil.startsWith('offiziell')).length; const auditNein = audit.filter((a) => a.pruefurteil === 'nicht_offiziell').length; const auditOffen = audit.filter((a) => a.pruefurteil === 'nicht_entscheidbar').length; const ausschluss = (k) => z((x) => x.inhalt === k); const klassifiziert = json('netze/netze-klassifiziert.json'); const recherchiert = new Set(klassifiziert.map((x) => String(x.asn))); const nachtrag = new Set(best.flatMap((g) => [g.asn, ...g.nsAsn]).filter(Boolean).map(String).filter((a) => !recherchiert.has(a))).size; const mitEigentum = klassifiziert.filter((x) => ['hoch', 'mittel'].includes(x.sicherheit)).length; const ohneEigentumNetze = new Set(klassifiziert.filter((x) => x.sicherheit === 'niedrig').map((x) => String(x.asn))); const inOhneEigentum = z((x) => x.web_auswertbar === 'ja' && ohneEigentumNetze.has(String(x.asn))); const start = new Map(jsonl('startseiten.jsonl').map((s) => [s.host, s])); const nachpr = new Map(jsonl('nachpruefung.jsonl').map((s) => [s.host, s])); const robotsZeilen = best.filter((g) => g.gesperrt ?? (start.get(g.host)?.robotsGesperrt || nachpr.get(g.host)?.klasse === 'robots')); const robotsBest = robotsZeilen.length; const robotsAmtlich = robotsZeilen.filter((g) => g.einzelurteil).length; const robotsStart = robotsBest - robotsAmtlich; // Exakte zweiseitige 95-%-Obergrenze nach Clopper-Pearson. function obergrenze(k, n) { const cdf = (p) => { let t = (1 - p) ** n; let s = t; for (let i = 1; i <= k; i++) { t *= ((n - i + 1) / i) * (p / (1 - p)); s += t; } return s; }; let a = k / n; let b = 1; for (let i = 0; i < 80; i++) { const m = (a + b) / 2; if (cdf(m) > 0.025) a = m; else b = m; } return 100 * b; } const q = { destatis: 1, wikidata: 2, cymru: 3, ripe: 4, arin: 5, ripestat: 6, sec: 7, companies: 8, mxmap: 9, idw: 10 }; const heute = '2026-11-21'; const endfassung = process.argv.includes('--endfassung'); // Untergrenzen werden als Anzahl genannt, damit keine Rundung sie über den belegten Wert hebt. const mind = (n, b) => `mindestens ${de(n, 0)} von ${de(b, 0)}`; const rundP = (n, b) => `rund ${de(pz(n, b), 1)} %`; const belegMind = (wo, basis, n) => [{ datei: 'daten.csv', rechnung: 'anzahl', wo: { ...basis, ...wo }, nachkomma: 0, ergebnis: n }, anteil(wo, basis, n, 1)]; const kurz = `Bei ${mind(nDienst, webN)} ausgewerteten Gemeinden läuft die Website über Hoster, Cloud- oder Auslieferungsdienste mit Kontrolle außerhalb der EU.`; if (kurz.length > 165) throw new Error(`Kurzfassung zu lang: ${kurz.length}`); const belegNetze = { datei: 'netze.csv', rechnung: 'anzahl', nachkomma: 0, ergebnis: netzZeilen.length }; const eigentumsQuellen = [belegNetze, { quelle: q.sec }, { quelle: q.companies }, { quelle: q.ripe }]; const zahlSpalten = [ { feld: 'gemeinden', titel: 'Gemeinden', format: 'zahl' }, { feld: 'web_basis', titel: 'Ausgewertet Web', format: 'zahl' }, { feld: 'dns_basis', titel: 'Ausgewertet DNS', format: 'zahl' }, { feld: 'anteil_dienst', titel: 'Mind. Dienst, Kontrolle außerhalb EU', format: 'zahl', nachkomma: 1, einheit: '%' }, { feld: 'anteil_dns', titel: 'Mind. Nameserver, Kontrolle außerhalb EU', format: 'zahl', nachkomma: 1, einheit: '%' }, ]; const studie = { format: 1, slug: 'gemeinden-website-hosting', status: 'entwurf', kategorie: 'oeffentliche-hand', art: 'eigene-messung', titel: 'Wem gehören die Netze hinter den Websites der deutschen Gemeinden?', untertitel: `Prüfung aller ${de(zeilen.length, 0)} amtlichen Gemeinden, ${de(webN, 0)} ausgewertet`, kurzfassung: kurz, fragestellung: 'Über welche Netze werden die offiziellen Websites der deutschen Gemeinden ausgeliefert, und bei welchem Anteil der Gemeinden liegt der Dienst nachweislich unter der Kontrolle von Unternehmen oder Investoren außerhalb der EU?', schlagwoerter: ['Digitale Souveränität', 'Kommunen', 'Webhosting', 'Nameserver', 'Öffentliche Verwaltung', 'Internet-Infrastruktur'], version: '1.0.0', stand: heute, erstveroeffentlichung: endfassung ? '2026-11-22' : null, naechste_aktualisierung: null, vorlaeufig: !endfassung, zeitraum: { von: heute, bis: heute }, stichprobe: { umfang: zeilen.length, ausgewertet: webN, einheit: 'Gemeinden', auswahl: 'Vollerhebung aller politisch selbständigen Gemeinden laut amtlichem Gemeindeverzeichnis, Stand 30.09.2026. Ausgewertet sind Gemeinden, deren Website inhaltlich oder über eine amtliche Quelle als Seite der Gemeinde oder ihrer Verwaltung bestätigt wurde und deren Netz bestimmbar war.' }, autoren: [{ name: 'Erik Friedl', typ: 'person' }, { name: 'Nexthosting', typ: 'organisation' }], autoren_freigegeben: endfassung, lizenz: { kennung: 'CC-BY-4.0', name: 'CC BY 4.0', url: 'https://creativecommons.org/licenses/by/4.0/deed.de' }, anbieternamen: false, eigeninteresse: 'Nexthosting verkauft selbst Hosting in Deutschland, steht damit im Wettbewerb zu Unternehmen in dieser Auswertung und nutzt Rechenzentren und Netze anderer Unternehmen. Dazu gehören auch Dienste von Netzbetreibern, die hier als außerhalb der EU kontrolliert geführt werden, darunter ein Auslieferungsnetz. Methode, Auswertungsskripte, Daten und die Eigentumsbelege der ausgewiesenen Netze sind deshalb offengelegt.', kernergebnisse: [ { wert: `${de(bestN, 0)} von ${de(zeilen.length, 0)}`, titel: 'Bestätigte Gemeinden', text: `Für ${de(bestN, 0)} der ${de(zeilen.length, 0)} amtlichen Gemeinden wurde die Website inhaltlich oder über eine amtliche Quelle als Seite der Gemeinde oder ihrer Verwaltung bestätigt.`, belege: [{ datei: 'daten.csv', rechnung: 'anzahl', wo: { inhalt: 'bestaetigt' }, nachkomma: 0, ergebnis: bestN }, { quelle: q.destatis }] }, { wert: `${de(pz(nDe, webN))} %`, titel: 'Netz in Deutschland registriert', text: `Bei ${de(pz(nDe, webN))} % der ausgewerteten Gemeinden liegt die Website in einem Netz mit deutschem Registereintrag. Dieser nennt den Netzinhaber, aber weder dessen Konzernmutter oder Investor noch den Serverstandort.`, belege: [anteil({ netz_register: 'DE' }, wWeb, nDe), { quelle: q.cymru }, { quelle: q.ripe }] }, { wert: mind(nDienst, webN), titel: 'Dienst unter Kontrolle außerhalb der EU', text: `Bei ${mind(nDienst, webN)} ausgewerteten Gemeinden (${rundP(nDienst, webN)}) läuft die Website über einen Hoster, Cloud- oder Auslieferungsdienst, der nachweislich von einem Unternehmen oder Investor außerhalb der EU kontrolliert wird.`, belege: [...belegMind({ web_kontrolle: 'dienst' }, wWeb, nDienst), ...eigentumsQuellen] }, { wert: mind(nGesamt, webN), titel: 'Einschließlich Transit- und Stadtnetzen', text: `Zählt man Transit-, Stadtnetz- und Rechenzentrumsbetreiber hinzu, liegt die Website bei ${mind(nGesamt, webN)} ausgewerteten Gemeinden (${rundP(nGesamt, webN)}) in einem Netz mit belegter Kontrolle außerhalb der EU. Die Website kann dort von einem anderen Dienstleister betrieben werden.`, belege: [...belegMind({ web_kontrolle: ['dienst', 'netz'] }, wWeb, nGesamt), ...eigentumsQuellen] }, { wert: mind(nUs, webN), titel: 'Dienst unter Kontrolle aus den USA', text: `Bei ${mind(nUs, webN)} ausgewerteten Gemeinden (${rundP(nUs, webN)}) läuft die Website über einen Hoster, Cloud- oder Auslieferungsdienst unter Kontrolle eines Unternehmens oder Investors aus den USA.`, belege: [...belegMind({ web_kontrolle: 'dienst', web_region: 'USA' }, wWeb, nUs), ...eigentumsQuellen] }, { wert: mind(nFi, webN), titel: 'Finanzinvestoren', text: `Bei ${mind(nFi, webN)} ausgewerteten Gemeinden (${rundP(nFi, webN)}) liegt die Kontrolle über den Hoster, Cloud- oder Auslieferungsdienst bei einem Finanzinvestor außerhalb der EU.`, belege: [...belegMind({ web_kontrolle: 'dienst', web_rolle: 'finanzinvestor' }, wWeb, nFi), ...eigentumsQuellen] }, { wert: mind(nDns, dnsN), titel: 'Nameserver', text: `Bei ${mind(nDns, dnsN)} Gemeinden mit bestätigter Website und bestimmbarem Nameserver-Netz (${rundP(nDns, dnsN)}) liegt mindestens ein Nameserver der Website-Domain in einem Netz mit belegter Kontrolle außerhalb der EU.`, belege: [...belegMind({ dns_nicht_eu: 'ja' }, wDns, nDns), ...eigentumsQuellen] }, { wert: `${de(pz(nV6, bestN))} %`, titel: 'IPv6-Adresse im DNS', text: `Für die Website von ${de(pz(nV6, bestN))} % der bestätigten Gemeinden ist im DNS eine IPv6-Adresse eingetragen.`, belege: [anteil({ ipv6: 'ja' }, { inhalt: 'bestaetigt' }, nV6)] }, ], zusammenfassung: [ `Die Studie prüft für alle ${de(zeilen.length, 0)} amtlichen Gemeinden Deutschlands, über welche Netze ihre Website ausgeliefert wird. Ausgewertet wurden ${de(webN, 0)} Gemeinden mit bestätigter Website und bestimmbarem Netz.`, `${de(pz(nDe, webN))} % dieser Gemeinden nutzen eine Website in einem Netz mit deutschem Registereintrag. Dieser nennt den Netzinhaber, aber weder dessen Konzernmutter oder Investor noch den Serverstandort. Bei ${de(nDeDienst, 0)} Gemeinden liegt die Website im Netz eines deutsch registrierten Hosters, der nachweislich von außerhalb der EU kontrolliert wird.`, `Zählt man auch Dienste mit ausländischem Registereintrag hinzu, sind es ${mind(nDienst, webN)} ausgewerteten Gemeinden (${rundP(nDienst, webN)}), davon mindestens ${de(nUs, 0)} mit Kontrolle aus den USA. Mit Transit-, Stadtnetz- und Rechenzentrumsbetreibern steigt die Zahl auf mindestens ${de(nGesamt, 0)} Gemeinden (${rundP(nGesamt, webN)}). Gezählt wurde nur, was mit gelesenen Eigentumsquellen belegt ist und von einem zweiten KI-Agenten gegengeprüft wurde. Die tatsächlichen Anteile können deshalb höher liegen.`, 'Über Serverstandorte, Datenabflüsse oder Rechtsverstöße sagt die Studie nichts aus. Für E-Mail haben Forschende der Universität Fribourg, der Hochschule Luzern, der TH Ingolstadt und der TH Nürnberg die Gemeinden in Deutschland, Österreich und der Schweiz bereits untersucht. Diese Studie ergänzt das um die Websites und ihre Nameserver.', ], methode: { schritte: [ { titel: 'Grundgesamtheit', text: 'Alle politisch selbständigen Gemeinden laut Gemeindeverzeichnis des Statistischen Bundesamts, Stand 30.09.2026. Gemeindefreie Gebiete zählen nicht.' }, { titel: 'Website je Gemeinde', text: 'Die Adressen stammen aus Wikidata und wurden über den amtlichen Gemeindeschlüssel zugeordnet. 33 fehlende Adressen wurden einzeln recherchiert. Hat eine Gemeinde keine eigene Seite, zählt die Seite ihres Amts oder ihrer Verbandsgemeinde.' }, { titel: 'Inhaltliche Prüfung', text: `Die Startseiten wurden einmal abgerufen, Weiterleitungen wurden verfolgt und robots.txt beachtet. Automatisch bestätigt ist eine Seite, wenn sie den Gemeindenamen und typische Begriffe einer Verwaltung enthält. Unklare Fälle wurden zusätzlich anhand von Startseite und Impressum geprüft. Alle 794 danach noch offenen Adressen wurden einzeln geprüft, die 311 weiter unklaren in einer zweiten Runde über Gemeindelisten von Landkreisen und Landesportalen. Falsche Adressen wurden durch die belegte offizielle Adresse ersetzt und neu gemessen. Inhalte von Seiten, die robots.txt sperrt, gingen nicht als Beleg in die Auswertung ein. Für ${de(robotsBest, 0)} bestätigte Gemeinden war die hinterlegte Adresse gesperrt: ${de(robotsAmtlich, 0)} wurden über eine amtliche Drittquelle bestätigt, ${de(robotsStart, 0)} über eine nicht gesperrte Startseite. Park- und Standardseiten gelten nie als bestätigte Website.` }, { titel: 'Netzmessung', text: 'Für die Zieladresse wurden per DNS CNAME-, A-, AAAA- und NS-Einträge abgefragt. Die erste Adresse wurde über öffentliche Routing- und Registerdaten dem Netz (Autonomes System) zugeordnet, das ihren spezifischsten Adressblock ankündigt.' }, { titel: 'Kontrolle der Netze', text: `Für 306 Netze wurden Inhaber und Sitz erfasst, für ${mitEigentum} davon liegt eine Eigentumsangabe mit mindestens mittlerer Beleglage vor. Von 47 Netzen mit möglicher Kontrolle außerhalb der EU wurden die 40 mit mindestens mittlerer Beleglage einzeln anhand von Pflichtmitteilungen, Geschäftsberichten, Impressen und Registerdaten geprüft und einem Widerlegungsversuch unterzogen. Netze derselben Eigentümergruppe wurden einheitlich gewertet. Ein großes Transitnetz wurde herausgenommen, weil die eingetragene Inhaberin des dort genutzten Adressblocks seit dem Verkauf des Europageschäfts nicht mehr zum Konzern gehört. Ein Netz mit nur einer Gemeinde und eigenem Kontrollland zählt zum Schutz dieser Gemeinde nicht mit. In den Ergebnissen zählen ${netzRoh.length} Netze. ${nachtrag} weitere Netze kamen erst durch die Einzelprüfung oder die erneute Netzzuordnung hinzu, wurden nicht auf ihre Eigentümer geprüft und zählen deshalb nicht mit. Die Eigentumsangaben von 13 Netzen mit gemeldeten Verkaufsvorgängen oder älteren Quellen wurden am 22.11.2026 erneut geprüft und blieben unverändert.` }, { titel: 'Kontrollprüfung', text: `Eine feste Zufallsstichprobe von ${audit.length} automatisch bestätigten Gemeindeseiten wurde ohne Kenntnis des automatischen Ergebnisses geprüft: ${auditOk} waren offizielle Seiten, ${auditNein} waren falsch zugeordnet und ${auditOffen} ließen sich nicht entscheiden. Bei 95 % Vertrauen bleibt für die automatisch bestätigten Seiten eine Fehlerquote von bis zu rund ${de(obergrenze(auditNein, audit.length))} % möglich, zählt man die nicht entscheidbaren Fälle als Fehler, bis zu rund ${de(obergrenze(auditNein + auditOffen, audit.length))} %. Die einzeln geprüften Gemeinden sind von dieser Stichprobe nicht erfasst.` }, { titel: 'Einsatz von KI', text: 'Recherche, Einzelprüfung, Quellenprüfung und Kontrollprüfung wurden von KI-Agenten durchgeführt. Eigentumszuordnung und Hochstufungen der zweiten Runde prüfte ein zweiter Agent gegen. Die Ergebniskennzahlen werden per Skript aus den Daten berechnet.' }, ], aufbau: [ { name: 'Messtag', wert: '21.11.2026' }, { name: 'Gemeinden', wert: de(zeilen.length, 0) }, { name: 'Bestätigte Gemeinden', wert: de(bestN, 0) }, { name: 'Eingangsadressen', wert: de(adressen, 0) }, { name: 'Verschiedene Zieladressen mit Netz', wert: de(zielAdressen.size, 0) }, { name: 'Ausgewertete Gemeinden (Web)', wert: de(webN, 0) }, { name: 'Ausgewertete Gemeinden (Nameserver)', wert: de(dnsN, 0) }, { name: 'Netze mit erfasstem Inhaber', wert: '306' }, { name: 'Netze mit belegter Kontrolle außerhalb der EU', wert: String(netzRoh.length) }, { name: 'DNS-Resolver', wert: '1.1.1.1 und 8.8.8.8' }, ], }, grenzen: [ { titel: 'Mindestwerte', text: `Ein Netz zählt nur dann als außerhalb der EU kontrolliert, wenn die Eigentumsquelle gelesen wurde und die Zuordnung einen Widerlegungsversuch überstanden hat. Drei Netze einer Eigentümergruppe bestanden diese Prüfung nicht, weil das Verwalterland strittig war (Vereinigtes Königreich oder Guernsey), und zählen durch die einheitliche Gruppenwertung mit. Bei ${ohneEigentumNetze.size} der 306 Netze mit ${de(pz(inOhneEigentum, webN))} % der ausgewerteten Gemeinden ist der Eigentümer nicht geklärt. Sie zählen nicht mit. Die Anteile sind deshalb Untergrenzen für die ausgewerteten Gemeinden. Bezogen auf alle ${de(zeilen.length, 0)} Gemeinden entsprechen die ${de(nDienst, 0)} Gemeinden mit einem solchen Dienst ${rundP(nDienst, zeilen.length)}. Einen Anteil deutscher oder europäischer Eigentümer weist die Studie bewusst nicht aus.` }, { titel: 'Kein Serverstandort', text: 'Gemessen wurde, zu welchem Netz eine Adresse gehört, nicht wo der Server steht. Ein Netz unter ausländischer Kontrolle kann Server in Deutschland betreiben. Aussagen über Datenabflüsse oder Rechtsverstöße lassen sich aus den Daten nicht ableiten.' }, { titel: 'Netz und Website-Betreiber', text: `Von den ${de(nGesamt, 0)} Gemeinden mit belegter Kontrolle außerhalb der EU liegen ${de(nNetz, 0)} in Transit-, Stadtnetz- oder Rechenzentrumsnetzen. Sie stehen deshalb getrennt von den Hostern, Cloud- und Auslieferungsdiensten. Bei Transitnetzen kann der Adressblock einem anderen, auch deutschen Unternehmen gehören, gezählt wird das Netz, das die Adresse im Routing ankündigt. Bei vorgeschalteten Auslieferungsnetzen ist nur dieses Netz sichtbar, nicht der Ursprungsserver.` }, { titel: 'Ausgeschlossene Gemeinden', text: `${de(zeilen.length - bestN, 0)} Gemeinden fließen nicht in die Anteile ein: Bei ${de(ausschluss('nicht_offiziell'), 0)} führt die bekannte Adresse nicht zu einer offiziellen Seite, bei ${de(ausschluss('nicht_entscheidbar'), 0)} war die Zuordnung der Adresse nicht eindeutig. Bei weiteren ${de(bestN - webN, 0)} bestätigten Gemeinden war kein Netz bestimmbar.` }, { titel: 'Gemeinsame Websites', text: `Viele kleine Gemeinden teilen sich die Seite ihrer Verwaltung. Die ${de(webN, 0)} ausgewerteten Gemeinden führen zu ${de(zielAdressen.size, 0)} verschiedenen Zieladressen. Jede Gemeinde zählt einmal, eine gemeinsame Seite wirkt also mehrfach. Je Zieladresse gerechnet läuft die Website bei mindestens ${de(zieleDienst, 0)} von ${de(zielAdressen.size, 0)} Adressen (${rundP(zieleDienst, zielAdressen.size)}) über einen solchen Dienst.` }, { titel: 'Unterschiede zwischen Ländern', text: 'Unterschiede zwischen Bundesländern und Größenklassen gehen häufig auf einzelne gemeinsame IT-Dienstleister zurück und sind keine Bewertung der Länder oder Gemeinden.' }, { titel: 'Momentaufnahme', text: 'Die Messung stammt von einem Tag und einem Messpunkt. Eigentumsverhältnisse und Hosting können sich jederzeit ändern. Der Stand der jeweiligen Eigentumsquelle steht in den Daten, bei einzelnen Netzen liegt die jüngste ausdrückliche Quelle mehrere Jahre zurück.' }, { titel: 'Kontrollbegriff', text: 'Kontrolle bedeutet hier: Das Netz gehört dem Unternehmen, einer belegten Konzerntochter oder einem Investor mit belegtem beherrschendem Einfluss. Bei Finanzinvestoren gilt das Land des Verwalters, nicht der Sitz einzelner Fonds. Die Gruppe außerhalb der EU umfasst Länder mit unterschiedlicher datenschutzrechtlicher Stellung gegenüber der EU. Die Studie bewertet das nicht.' }, ], ergebnisse: [ { typ: 'text', titel: 'Registereintrag und Eigentum sind zwei verschiedene Dinge', absaetze: [`${de(pz(nDe, webN))} % der ausgewerteten Gemeinden nutzen eine Website in einem deutsch registrierten Netz. Bei ${de(nDeGesamt, 0)} dieser Gemeinden gehört das Netz nachweislich zu einem Unternehmen oder Investor außerhalb der EU, ${de(nDeDienst, 0)} davon entfallen auf Hoster.`, `Von den ${de(nDienst, 0)} Gemeinden mit einem solchen Dienst entfallen ${de(nUs, 0)} auf die USA und ${de(nFi, 0)} auf Finanzinvestoren. ${de(nUsFi, 0)} Gemeinden gehören zu beiden Gruppen.`] }, { typ: 'balken', titel: 'Mindestanteil mit Dienst unter Kontrolle außerhalb der EU nach Bundesland', beschreibung: 'Anteil der ausgewerteten Gemeinden in Prozent. Berlin, Bremen, Hamburg und das Saarland sind zusammengefasst. Unterschiede gehen häufig auf einzelne gemeinsame IT-Dienstleister zurück und sind keine Bewertung der Länder.', datei: 'laender.csv', beschriftung: 'gruppe', wert: 'anteil_dienst', nachkomma: 1, einheit: '%', max: Math.ceil(Math.max(...laender.map((l) => l.anteil_dienst)) / 5) * 5 }, { typ: 'tabelle', titel: 'Ergebnisse nach Bundesland', beschreibung: 'Unterschiede gehen häufig auf einzelne gemeinsame IT-Dienstleister zurück und sind keine Bewertung der Länder.', datei: 'laender.csv', sortierung: { feld: 'anteil_dienst', richtung: 'absteigend' }, suche: true, spalten: [{ feld: 'gruppe', titel: 'Bundesland', kopf: true }, ...zahlSpalten] }, { typ: 'tabelle', titel: 'Ergebnisse nach Einwohnerzahl', datei: 'groessen.csv', spalten: [{ feld: 'gruppe', titel: 'Einwohner', kopf: true }, ...zahlSpalten] }, { typ: 'tabelle', titel: 'Netze mit belegter Kontrolle außerhalb der EU', beschreibung: 'Die Eigentumsbelege je Netz stehen in der Datei netze.csv. Netze mit weniger als 5 Gemeinden sind zusammengefasst, kleine Einzelwerte werden als unter 5 ausgewiesen.', datei: 'netze.csv', sortierung: { feld: 'gemeinden_web', richtung: 'absteigend' }, suche: true, filter: ['region', 'funktion'], spalten: [{ feld: 'asn', titel: 'Netz (AS)', kopf: true }, { feld: 'kontroll_land', titel: 'Kontrollland' }, { feld: 'rolle', titel: 'Kontrolle durch' }, { feld: 'funktion', titel: 'Funktion' }, { feld: 'gemeinden_web', titel: 'Gemeinden Web' }, { feld: 'gemeinden_dns', titel: 'Gemeinden DNS' }, { feld: 'quellenstand', titel: 'Quellenstand' }] }, ], dateien: [ { datei: 'daten.csv', art: 'daten', titel: 'Messwerte je Gemeinde (anonymisiert, CSV)', beschreibung: 'Eine Zeile je Gemeinde in zufälliger Reihenfolge, ohne Name, Schlüssel und Adresse.', sha256: '' }, { datei: 'laender.csv', art: 'daten', titel: 'Ergebnisse nach Bundesland (CSV)', beschreibung: 'Berlin, Bremen, Hamburg und das Saarland sind zusammengefasst.', sha256: '' }, { datei: 'groessen.csv', art: 'daten', titel: 'Ergebnisse nach Einwohnerzahl (CSV)', beschreibung: 'Fünf Größenklassen.', sha256: '' }, { datei: 'netze.csv', art: 'daten', titel: 'Netze mit Eigentumsbelegen (CSV)', beschreibung: 'Je Netz Kontrollland, Rolle, Funktion, Quellenstand und Beleg-Adressen.', sha256: '' }, { datei: 'stichprobe.csv', art: 'daten', titel: 'Ergebnis der Kontrollprüfung (CSV)', beschreibung: `Urteile zu ${audit.length} zufällig gezogenen Gemeindeseiten in zufälliger Reihenfolge.`, sha256: '' }, ...skripte.map((d) => ({ datei: d, art: 'skript', titel: `Skript ${d}`, beschreibung: 'Teil der Mess- und Auswertungskette, in Reihenfolge der Nummer.', sha256: '' })), ], felder: [ ['inhalt', 'Text', 'Ergebnis der Prüfung der Website: bestaetigt, nicht_offiziell oder nicht_entscheidbar'], ['web_auswertbar', 'ja/nein', 'Website bestätigt und Netz bestimmbar'], ['netz_register', 'Text', 'Registerland des Netzes: DE, EU, nicht_EU oder unbekannt'], ['web_kontrolle', 'Text', 'dienst: Hoster, Cloud oder Auslieferungsdienst mit belegter Kontrolle außerhalb der EU; netz: Transit-, Stadtnetz- oder Rechenzentrumsbetreiber mit belegter Kontrolle; kein_nachweis: zählt nicht mit'], ['web_region', 'Text', 'Region der belegten Kontrolle: USA, UK/Kanalinseln, Sonstige oder zusammengefasst'], ['web_rolle', 'Text', 'Art der Kontrolle: konzern, finanzinvestor oder zusammengefasst'], ['web_funktion', 'Text', 'Funktion des Netzes: hoster, cloud, cdn, netz_rechenzentrum, dns_domain oder zusammengefasst bei weniger als 5 Gemeinden'], ['dns_auswertbar', 'ja/nein', 'Website bestätigt und mindestens ein Nameserver-Netz bestimmbar'], ['dns_nicht_eu', 'ja/nein', 'Mindestens ein Nameserver in einem Netz mit belegter Kontrolle außerhalb der EU'], ['dns_usa', 'ja/nein', 'Mindestens ein Nameserver in einem Netz mit belegter Kontrolle aus den USA'], ['ipv6', 'ja/nein', 'Die Zieladresse hat einen AAAA-Eintrag im DNS'], ['gruppe', 'Text', 'Bundesland oder Einwohnerklasse'], ['gemeinden', 'Zahl', 'Zahl der amtlichen Gemeinden'], ['bestaetigt', 'Zahl', 'Gemeinden mit bestätigter Website'], ['web_basis', 'Zahl', 'Ausgewertete Gemeinden für Website-Anteile'], ['dns_basis', 'Zahl', 'Ausgewertete Gemeinden für den Nameserver-Anteil'], ['anteil_dienst', 'Zahl', 'Mindestanteil mit Hoster, Cloud- oder Auslieferungsdienst unter Kontrolle außerhalb der EU in Prozent'], ['anteil_dns', 'Zahl', 'Mindestanteil mit Nameserver unter Kontrolle außerhalb der EU in Prozent, bezogen auf dns_basis'], ['asn', 'Text', 'Nummer des Autonomen Systems oder Sammelzeile für Netze mit weniger als 5 Gemeinden'], ['region', 'Text', 'USA, UK/Kanalinseln, Sonstige oder Gemischt'], ['kontroll_land', 'Text', 'Land der Kontrolle als ISO-Code oder Mehrere. GB/GG: Verwalter im Vereinigten Königreich, Fondsstruktur auf Guernsey, teils gemeinsam mit einem kanadischen Investor'], ['rolle', 'Text', 'Konzern, Finanzinvestor oder Gemischt'], ['funktion', 'Text', 'Funktion des Netzes: Hoster, Cloud, Auslieferungsnetz, Transit, Stadtnetz oder Rechenzentrum, DNS und Domains oder Gemischt'], ['gemeinden_web', 'Text', 'Bestätigte Gemeinden, deren Website in diesem Netz liegt, Werte von 1 bis 4 als unter 5'], ['gemeinden_dns', 'Text', 'Bestätigte Gemeinden mit Nameserver in diesem Netz, Werte von 1 bis 4 als unter 5'], ['quellenstand', 'Text', 'Datum des jüngsten datierten Dokuments zur Eigentumsbeziehung, bei undatierten Quellen mit Vermerk'], ['belege', 'Text', 'Adressen der gelesenen Eigentumsbelege, durch Leerzeichen getrennt'], ['pruefurteil', 'Text', 'Urteil der Kontrollprüfung: offiziell_eigen, offiziell_verwaltung, nicht_offiziell oder nicht_entscheidbar'], ].map(([name, typ, beschreibung]) => ({ name, typ, beschreibung })), reproduzierbarkeit: `Die nummerierten Skripte dokumentieren Messung und Auswertung. Die Eigentums- und Einzelprüfung wurde von KI-Agenten vorgenommen, ihre Ergebnisse sind in netze.csv und stichprobe.csv zusammengefasst. Die Einzelurteile je Gemeinde werden nicht veröffentlicht, damit keine Gemeinde bloßgestellt wird. Für die ${netzKlein.length} zusammengefassten Netze werden die Belege zum Schutz der Gemeinden nicht genannt. Ein vollständiger Neulauf aus den veröffentlichten Dateien ist deshalb nicht möglich. Die Kernergebnisse lassen sich aus daten.csv nachrechnen, die Eigentumsangaben über die Beleg-Adressen prüfen. Tabellen nach Land und Größe sowie Angaben je Zieladresse beruhen auf den nicht veröffentlichten Zuordnungen.`, quellen: [ { nr: 1, titel: 'Gemeindeverzeichnis, Alle politisch selbständigen Gemeinden, Stand 30.09.2026', herausgeber: 'Statistisches Bundesamt', jahr: '2026', url: 'https://www.destatis.de/DE/Themen/Laender-Regionen/Regionales/Gemeindeverzeichnis/Administrativ/Archiv/GVAuszugQ/AuszugGV3QAktuell.html', abgerufen: heute }, { nr: 2, titel: 'Wikidata Query Service', herausgeber: 'Wikimedia Foundation', jahr: '2026', url: 'https://query.wikidata.org/', abgerufen: heute }, { nr: 3, titel: 'IP to ASN Mapping', herausgeber: 'Team Cymru', jahr: '2026', url: 'https://www.team-cymru.com/ip-asn-mapping', abgerufen: heute }, { nr: 4, titel: 'RIPE Database, Registration Data Access Protocol', herausgeber: 'RIPE NCC', jahr: '2026', url: 'https://apps.db.ripe.net/db-web-ui/query', abgerufen: heute }, { nr: 5, titel: 'ARIN Registration Data Access Protocol', herausgeber: 'American Registry for Internet Numbers', jahr: '2026', url: 'https://search.arin.net/rdap/', abgerufen: heute }, { nr: 6, titel: 'RIPEstat', herausgeber: 'RIPE NCC', jahr: '2026', url: 'https://stat.ripe.net/', abgerufen: heute }, { nr: 7, titel: 'EDGAR, Unternehmensmeldungen', herausgeber: 'U.S. Securities and Exchange Commission', jahr: '2026', url: 'https://www.sec.gov/edgar/search/', abgerufen: heute }, { nr: 8, titel: 'Companies House, Unternehmensregister', herausgeber: 'UK Companies House', jahr: '2026', url: 'https://find-and-update.company-information.service.gov.uk/', abgerufen: heute }, { nr: 9, titel: 'Email Provider Dependencies and Email Security in Municipalities Across Germany, Austria, and Switzerland. In: Computer Security. ESORICS 2026 International Workshops (SecAssure 2026), Lecture Notes in Computer Science (angenommenes Manuskript)', herausgeber: 'Bischof, Huser, Ochsner, Petrlic, Portmann; Springer Nature', jahr: '2026', url: 'https://secassure2026.mxmap-project.org/', abgerufen: heute }, { nr: 10, titel: 'Sicherheits-Check: Forschungsteam untersucht kommunale E-Mail-Server im DACH-Raum (Pressemitteilung vom 26.10.2026)', herausgeber: 'Technische Hochschule Nürnberg Georg Simon Ohm, idw', jahr: '2026', url: 'https://idw-online.de/de/news879675', abgerufen: heute }, ], aenderungen: [{ version: '1.0.0', datum: endfassung ? '2026-11-22' : heute, art: 'fassung', text: 'Erste Fassung.' }], begriffe_belegt: {}, }; writeFileSync(join(ziel, 'studie.json'), `${JSON.stringify(studie, null, 2)}\n`); console.log(JSON.stringify({ kleinsteZelle, robotsAmtlich, robotsStart, netzZeilen: netzZeilen.length, gemeinden: zeilen.length, bestaetigt: bestN, web: webN, dns: dnsN, eingang: adressen, ziele: zielAdressen.size, netze: netzRoh.length, de: rund(pz(nDe, webN)), dienst: rund(pz(nDienst, webN)), gesamt: rund(pz(nGesamt, webN)), usa: rund(pz(nUs, webN)), fi: rund(pz(nFi, webN)), dns_: rund(pz(nDns, dnsN)), ipv6: rund(pz(nV6, bestN)), nDienst, nNetz, nUs, nFi, nUsFi, nDeDienst, nDeGesamt, jeZiel: rund(pz(zieleDienst, zielAdressen.size)), aufAlle: rund(pz(nDienst, zeilen.length)), robotsBest, nachtrag, mitEigentum, ohneEigentum: ohneEigentumNetze.size, inOhneEigentum: rund(pz(inOhneEigentum, webN)), kurz: kurz.length })); for (const g of [...laender, ...groessen]) console.log(g.gruppe, g.web_basis, rund(g.anteil_dienst, 1), rund(g.anteil_dns, 1));