Salt Fiber Box X6: Firewall-Regeln lassen sich nicht sortieren – Bug und Workaround
Was ist die Salt Fiber Box X6?
Die Salt Fiber Box X6 ist ein XGS-PON-Home-Gateway von Salt für Glasfaseranschlüsse. Das Gerät kombiniert unter anderem Routing, Wi-Fi 6, NAT sowie eine IPv4-/IPv6-Firewall. Salt dokumentiert für die Firewall Stateful Packet Inspection sowie die Filterung nach Diensten, Ports und Adressen. Dieser Artikel bezieht sich auf die von uns geprüfte grafische Oberfläche (GUI) mit Firmware SGCk10005062.
Screenshot 1: Die Firewall-Konfiguration befindet sich in der grafischen Oberfläche im Expertenmodus unter Netzwerk-Einstellungen > Firewall. Dort lassen sich die Firewall-Stufe sowie die Standardrichtlinien für LAN → WAN und WAN → LAN verwalten.
Was genau funktioniert bei der Regel-Sortierung nicht?
Der Fehler tritt beim Erstellen beziehungsweise Verwalten von Firewall-Regeln auf, wenn für eine Regel eine vordefinierte Dienstbezeichnung wie DNS, FTP oder FTP-DATA aus der Vorauswahl verwendet wird. In dieser Konstellation lässt sich die Regel im GUI nicht auf die gewünschte Position verschieben; sie bleibt am Ende der Regelliste. Das Verhalten ist mit der hier geprüften Firmware reproduzierbar. Die Beobachtung und der weiter unten beschriebene JavaScript-Workaround sprechen dafür, dass das Problem im GUI beziehungsweise in dessen JavaScript-Regelverwaltung liegt. Eine offizielle Ursachenanalyse von Salt liegt uns nicht vor.
Screenshot 2: Unter Ausnahmen von der Standardrichtlinie wird eine neue IPv4- oder IPv6-Regel angelegt. Die Oberfläche bietet neben dem Feld Benutzerdefinierter Name eine Vorauswahl für Dienst mit Einträgen wie DNS, FTP, HTTP oder HTTPS. Für den beschriebenen Workaround wird im Feld Dienst Anderes gewählt und im Feld Benutzerdefinierter Name ein eigener, eindeutiger Name vergeben.
Warum ist die Reihenfolge von Firewall-Regeln wichtig?
Firewall-Regeln können sich überschneiden. Eine Regel kann beispielsweise einen grossen Bereich blockieren, während eine andere Regel eine gezielte Ausnahme erlaubt. Bei Regelsätzen mit einer prioritätsabhängigen beziehungsweise «First Match»-Auswertung entscheidet die Reihenfolge darüber, welche passende Regel zuerst greift. Deshalb ist die Möglichkeit, Regeln bewusst zu sortieren, ein zentraler Bestandteil einer nachvollziehbaren Firewall-Konfiguration.
Beispiel: allgemeine Sperre und gezielte Freigabe
Angenommen, eine Konfiguration soll eingehende Verbindungen grundsätzlich blockieren, aber HTTPS-Verkehr zu einem bestimmten internen Ziel auf TCP-Port 443 erlauben. Vereinfacht könnten dafür zwei Regeln existieren:
- Erlauben: TCP-Port 443 zum vorgesehenen Ziel.
- Blockieren: übrigen passenden eingehenden Verkehr sperren.
Wird bei einer «First Match»-Auswertung zuerst die allgemeine Blockierregel angewendet, kann die nachfolgende Freigabe für TCP-Port 443 wirkungslos werden. Steht dagegen die spezifische Freigabe vor der allgemeineren Sperre, kann die gewünschte Ausnahme greifen. Das gleiche Prinzip gilt auch umgekehrt: Eine zu weit oben platzierte Freigabe kann eine darunterliegende, spezifischere Sperre aushebeln. Genau deshalb ist der beobachtete GUI-Bug problematisch: Wenn sich eine Firewall-Regel nicht an die gewünschte Position verschieben lässt, kann der Nutzer die beabsichtigte Priorität der Regeln nicht zuverlässig in der Oberfläche abbilden. Das erschwert die Konfiguration erheblich.
Workaround: eigenen Regelnamen statt Vorauswahl verwenden
Der gefundene Workaround ist einfach und reproduzierbar: Beim Erstellen der Firewall-Regel einen eigenen Regelnamen vergeben und im Dropdownmenü Dienst die Option Anderes wählen, anstatt eine vordefinierte Dienstbezeichnung wie DNS, FTP oder FTP-DATA zu verwenden.
Mit dieser Kombination tritt das beschriebene Sortierungsproblem nach unseren Beobachtungen nicht auf. Die Firewall-Regel lässt sich anlegen und anschliessend in der Regelverwaltung auf die gewünschte Position verschieben. Entscheidend ist dabei nicht ein bestimmtes Namensschema, sondern dass der Name frei eingegeben und nicht aus der problematischen Vorauswahl übernommen wird.
Schritt für Schritt: Firewall-Regel mit funktionierender Sortierung anlegen
- Die Administrationsoberfläche der Salt Fiber Box X6 öffnen und zu den Firewall-Einstellungen wechseln.
- Eine neue Firewall-Regel mit den gewünschten Netzwerkparametern erstellen.
- Im Dropdownmenü Dienst Anderes auswählen, statt einen vordefinierten Dienst zu übernehmen.
- Im Feld Benutzerdefinierter Name einen eigenen, eindeutigen Regelnamen eingeben.
- Die Regel speichern.
- In der Regelübersicht prüfen, ob sich die Regel nun an die gewünschte Position verschieben beziehungsweise korrekt verwalten lässt.
- Bei sicherheitsrelevanten Regeln zusätzlich praktisch testen, ob die erwartete Verbindung erlaubt beziehungsweise blockiert wird.
Warum der Bug mehr als ein Darstellungsfehler ist
Eine nicht änderbare Regelreihenfolge ist nicht nur ein kosmetisches Problem. Die Reihenfolge dient bei priorisierten Regelsätzen dazu, allgemeine Regeln und spezifische Ausnahmen kontrolliert gegeneinander abzugrenzen. Kann der Nutzer die gewünschte Reihenfolge im GUI nicht herstellen, besteht das Risiko, dass die sichtbare Konfiguration nicht der geplanten Sicherheitslogik entspricht oder zumindest nicht zuverlässig nachvollziehbar ist.
Einordnung: reproduzierbarer GUI-Bug mit Firmware SGCk10005062
Der hier beschriebene Fehler wurde mit der grafischen Oberfläche der Salt Fiber Box X6 und Firmware SGCk10005062 beobachtet. Das reproduzierbare Verhalten spricht für ein Problem der Weboberfläche beziehungsweise der Verwaltung und Zuordnung von Firewall-Regeln. Eine offizielle Bestätigung von Salt, dass dieser konkrete Fehler anerkannt oder bereits behoben wurde, liegt uns nicht vor.
Empfehlung für Salt-X6-Nutzer
Wer mit der Salt Fiber Box X6 und Firmware SGCk10005062 Firewall-Regeln anlegt und eine Regel nicht an die gewünschte Position verschieben kann, sollte die betroffene Regel mit einem frei eingegebenen Regelnamen neu erstellen. Danach sollte die Reihenfolge im GUI erneut geprüft werden. Bei sicherheitskritischen Regeln ist zusätzlich ein praktischer Funktionstest sinnvoll.
Technischer Hintergrund für Experten
Dieser technische Abschnitt dient als ergänzende Hilfestellung für erfahrene Nutzer und soll insbesondere dabei helfen, die Ursache des GUI-Bugs nachzuvollziehen und eine Behebung in einer späteren Firmwareversion zu erleichtern. Wer nur den praktischen Workaround benötigt, kann direkt zum Fazit springen.
Bei unseren Tests mit Firmware SGCk10005062 konnten wir zwei Probleme im JavaScript der Weboberfläche nachvollziehen: Beim Drag&Drop nummeriert der originale GUI-Code die Regeln neu mit fortlaufenden Order-Werten von 1..N, anstatt die bereits vorhandenen Order-Slots der sichtbaren Positionen beizubehalten. Zusätzlich wird Description beim Speichern nicht in jedem Fall aktualisiert. Insbesondere eine leere Beschreibung kann dazu führen, dass der für die Reihenfolge relevante Wert nicht in der benötigten Form, beispielsweise 43#, geschrieben wird.
JavaScript-Workaround für die Weboberfläche
Der folgende Patch korrigiert das Verhalten direkt in der bereits geladenen Weboberfläche. Er verändert keine Firmware und keine Dateien auf der Salt Fiber Box X6. Der Patch existiert ausschliesslich im Arbeitsspeicher des Browsers und ersetzt während der aktuellen Sitzung die problematischen JavaScript-Funktionen für Drag&Drop und das Speichern der Reihenfolge.
Der Patch führt dabei vier wesentliche Korrekturen durch:
- Die vorhandenen
Order-Slots bleiben beim Drag&Drop erhalten, statt alle Regeln neu mit1..Nzu nummerieren. - Nur tatsächlich verschobene Regeln werden beim Speichern berücksichtigt.
Descriptionwird immer alsOrder#Beschreibunggeschrieben. Bei leerer Beschreibung wird beispielsweise43#gespeichert.- Die XMO-Schreibvorgänge werden in kleine Batches mit maximal 75 Actions aufgeteilt, damit umfangreichere Änderungen nicht an der bei unseren Tests problematischen Grössenordnung von rund 90 Actions scheitern.
Wichtig: Der folgende Workaround richtet sich an erfahrene Nutzer. Vor dem Eingriff sollte die bestehende Firewall-Konfiguration als Backup gespeichert werden. Anschliessend müssen sowohl die gespeicherte Reihenfolge als auch die tatsächliche Funktion der betroffenen Firewall-Regeln geprüft werden.
Patch in Firefox ausführen
Zuerst sollte die Router-Weboberfläche mit F5 neu geladen werden. Dadurch werden eventuell zuvor ausgeführte Test-Patches aus dem Browser entfernt. Anschliessend in Firefox F12 → Konsole öffnen und den folgenden JavaScript-Block vollständig auf einmal einfügen:
(() => {
let fwScope = null;
let fwElement = null;
/*
* FirewallController finden
*/
for (const el of document.querySelectorAll('*')) {
try {
const s = angular.element(el).scope();
if (
s &&
s.fields &&
Array.isArray(s.fields.rules) &&
Array.isArray(s.originalRules) &&
typeof s.dropCallback === 'function' &&
typeof s.saveOrder === 'function'
) {
fwScope = s;
fwElement = el;
break;
}
} catch (e) {}
}
if (!fwScope) {
console.error(
'Salt X6 Patch: FirewallController wurde nicht gefunden.'
);
return;
}
/*
* Die Order-Werte gehören zu den sichtbaren POSITIONEN.
*
* Diese Liste darf beim Drag&Drop nicht einfach durch 1..N
* ersetzt werden.
*/
const positionOrders = fwScope.fields.rules.map(function (rule) {
return Number(rule.Order);
});
/*
* Persistierten Ausgangszustand nach UID merken.
*/
let savedState = new Map();
function rememberCurrentState() {
savedState = new Map();
fwScope.fields.rules.forEach(function (rule) {
savedState.set(String(rule.uid), {
Order: Number(rule.Order),
Description:
rule.Description === undefined ||
rule.Description === null
? ''
: String(rule.Description)
});
});
}
rememberCurrentState();
/*
* Tatsächlich umsortierte sichtbare Regeln bestimmen.
*/
function getChangedRules() {
return fwScope.fields.rules.filter(function (rule) {
const old = savedState.get(String(rule.uid));
if (!old) {
return true;
}
return Number(rule.Order) !== Number(old.Order);
});
}
/*
* Repariertes Drop-Verhalten.
*
* Die Reihenfolge der RULE-Objekte wurde vom Drag&Drop bereits
* verändert. Wir geben jetzt jeder neuen Position den Order-Slot,
* der vor dem Drag zu dieser Position gehörte.
*/
fwScope.dropCallback = function (event) {
try {
$(event.target).removeClass('dashed-border');
} catch (e) {}
if (!fwScope.orderChanged) {
return;
}
fwScope.orderChanged = false;
fwScope.blockEdit = true;
fwScope.hasDragged = true;
if (fwScope.fields.rules.length !== positionOrders.length) {
console.error(
'Salt X6 Patch: Anzahl der Regeln hat sich geändert. ' +
'Bitte F5 drücken und den Patch neu laden.'
);
return;
}
fwScope.fields.rules.forEach(function (rule, index) {
rule.Order = positionOrders[index];
const old = savedState.get(String(rule.uid));
rule.Edited =
!old ||
Number(old.Order) !== Number(rule.Order);
});
const changed = getChangedRules();
console.log(
'Salt X6 Patch:',
changed.length,
'Regel(n) tatsächlich umsortiert.'
);
console.table(
changed.map(function (rule) {
const old = savedState.get(String(rule.uid));
return {
uid: rule.uid,
Description: rule.Description || '',
oldOrder: old ? old.Order : '-',
newOrder: rule.Order
};
})
);
};
/*
* XMO-Pfad für eine einzelne Firewall-Regel.
*/
function getChainName() {
let level = String(fwScope.fields.level || 'CUSTOM');
level = level.toLowerCase();
return level.charAt(0).toUpperCase() + level.slice(1);
}
function rulePath(uid) {
return (
'Device/Firewall/Chains/Chain[Name="' +
getChainName() +
'"]/Rules/Rule[@uid="' +
uid +
'"]'
);
}
/*
* Einen kleinen XMO-Batch schreiben.
*/
function sendBatch(values) {
return new Promise(function (resolve, reject) {
try {
$.xmo.setValuesFlat(values, {
sync: false,
success: function () {
resolve();
},
error: function (err) {
console.error(
'Salt X6 Patch: XMO-Schreibfehler',
err
);
reject(err);
}
});
} catch (e) {
reject(e);
}
});
}
/*
* Repariertes saveOrder().
*/
fwScope.saveOrder = function () {
const changed = getChangedRules();
if (changed.length === 0) {
console.log(
'Salt X6 Patch: Keine Order-Änderungen zu speichern.'
);
return Promise.resolve(false);
}
/*
* Pro sichtbarer Regel können mehrere interne UIDs existieren.
* Jede UID bekommt:
*
* Enable
* Order
* Description
*
* WICHTIG:
* Description wird auch bei leerem sichtbaren Text geschrieben.
*
* Beispiel:
* Order 43 + leere Description -> "43#"
*/
const groups = [];
changed.forEach(function (rule) {
const uids = String(rule.uid).split(',');
uids.forEach(function (uid) {
uid = uid.trim();
if (!uid) {
return;
}
const base = rulePath(uid);
const values = {};
values[base + '/Enable'] = !!rule.Enable;
values[base + '/Order'] = Number(rule.Order);
const description =
rule.Description === undefined ||
rule.Description === null
? ''
: String(rule.Description);
values[base + '/Description'] =
String(rule.Order) + '#' + description;
groups.push(values);
});
});
/*
* Unter dem XMO-Limit bleiben.
*
* Jede interne Rule hat 3 Actions.
* Wir lassen pro Batch maximal 75 Actions zu.
*/
const batches = [];
let currentBatch = {};
let currentActions = 0;
groups.forEach(function (group) {
const actionCount = Object.keys(group).length;
if (
currentActions > 0 &&
currentActions + actionCount > 75
) {
batches.push(currentBatch);
currentBatch = {};
currentActions = 0;
}
Object.assign(currentBatch, group);
currentActions += actionCount;
});
if (currentActions > 0) {
batches.push(currentBatch);
}
console.log(
'Salt X6 Patch: Speichere',
changed.length,
'sichtbare Regel(n) in',
batches.length,
'XMO-Batch(es).'
);
/*
* Batches absichtlich nacheinander ausführen.
*/
let sequence = Promise.resolve();
batches.forEach(function (batch, index) {
sequence = sequence.then(function () {
console.log(
'Salt X6 Patch: Batch',
index + 1,
'/',
batches.length,
'-',
Object.keys(batch).length,
'Actions'
);
return sendBatch(batch);
});
});
return sequence.then(function () {
/*
* Aktuellen Zustand als neue Baseline übernehmen.
*/
rememberCurrentState();
fwScope.hasDragged = false;
fwScope.hasRuleModified = false;
fwScope.blockEdit = false;
console.log(
'Salt X6 Patch: Reihenfolge erfolgreich gespeichert.'
);
return true;
});
};
/*
* Kleine Diagnose-Hilfe
*/
window.saltX6ReorderPatch = {
scope: fwScope,
changed: function () {
const changed = getChangedRules();
console.table(
changed.map(function (rule) {
const old = savedState.get(String(rule.uid));
return {
uid: rule.uid,
Description: rule.Description || '',
oldOrder: old ? old.Order : '-',
newOrder: rule.Order
};
})
);
return changed;
},
positionOrders: positionOrders,
info: function () {
console.log(
'Salt X6 Reorder-Patch aktiv.',
'Sichtbare Regeln:',
fwScope.fields.rules.length,
'Chain:',
getChainName()
);
}
};
console.log(
'Salt X6 Firewall-Reorder-Patch AKTIV.',
'Sichtbare Regeln:',
fwScope.fields.rules.length
);
console.log(
'Du kannst jetzt per Drag&Drop umsortieren und danach normal auf Speichern klicken.'
);
})();Wenn der Patch den Firewall-Controller erfolgreich gefunden hat, erscheint in der Konsole beispielsweise:
Salt X6 Firewall-Reorder-Patch AKTIV. Sichtbare Regeln: 44
Du kannst jetzt per Drag&Drop umsortieren und danach normal auf Speichern klicken.Firewall-Regeln danach normal per Drag&Drop sortieren
Nach Aktivierung des Patches kann die Weboberfläche wieder normal bedient werden: Regel per Drag&Drop verschieben und anschliessend auf Speichern klicken. Der Patch greift im Hintergrund in die beiden problematischen GUI-Funktionen ein.
Vor dem Speichern lässt sich optional kontrollieren, welche Regeln tatsächlich als geändert erkannt wurden:
saltX6ReorderPatch.changed()Beim Tausch zweier benachbarter Regeln können beispielsweise zwei Einträge erscheinen:
uid oldOrder newOrder
103 68 43
98 43 68
Das Beispiel zeigt einen wichtigen Teil des Workarounds: Die beiden Regeln tauschen ihre bereits vorhandenen Order-Slots 68 und 43. Der Patch erzeugt nicht einfach eine neue fortlaufende Nummerierung.
Beim anschliessenden Speichern sollte die Konsole beispielsweise folgende Meldungen ausgeben:
Salt X6 Patch: Speichere 2 sichtbare Regel(n) in 1 XMO-Batch(es).
Salt X6 Patch: Batch 1 / 1 - 6 Actions
Salt X6 Patch: Reihenfolge erfolgreich gespeichert.Warum Description für die Sortierung entscheidend ist
Besonders relevant ist das Feld Description. Für jede geänderte interne Regel schreibt der Patch drei Werte: Enable, Order und Description. Die Beschreibung erhält dabei immer die Form:
Order#Beschreibung
Ist keine sichtbare Beschreibung vorhanden, muss der Trenner trotzdem geschrieben werden. Für eine Regel mit Order = 43 entsteht deshalb:
Order = 43
Description = 43#
Genau dieses Verhalten war in unseren Tests entscheidend: Wurde Description konsistent mit dem neuen Order-Wert gespeichert, blieb die geänderte Position auch nach einem Neuladen der Router-Oberfläche mit F5 erhalten. Die X6 verwendet beim erneuten Einlesen der Regeln die Zahl vor dem Zeichen # wieder als Order-Information.
Warum der Patch die vorhandenen Order-Slots erhält
Der originale Drag&Drop-Code behandelt die sichtbare Listenposition und den internen Order-Wert offenbar zu einfach und weist den Regeln nach dem Verschieben neue fortlaufende Werte zu. Der Patch geht anders vor: Beim Start merkt er sich die vorhandenen Order-Werte aller sichtbaren Positionen. Nach dem Drag&Drop werden diese vorhandenen Slots den nun an diesen Positionen liegenden Regelobjekten zugewiesen.
Dadurch wird beispielsweise nicht aus einer Liste mit Order-Slots 12, 19, 43, 68 plötzlich 1, 2, 3, 4. Stattdessen bleiben 12, 19, 43, 68 erhalten; lediglich die Regeln werden den gewünschten Slots neu zugeordnet.
Warum der Patch XMO-Batches verwendet
Eine sichtbare Firewall-Regel kann intern mehrere UIDs besitzen. Für jede interne UID schreibt der Patch bis zu drei Werte. Bei vielen gleichzeitig verschobenen Regeln kann dadurch eine grosse Anzahl von XMO-Actions entstehen. In unseren Tests erwiesen sich grössere Schreibvorgänge im Bereich von ungefähr 90 Actions als problematisch. Der Patch verwendet deshalb bewusst kleinere Pakete und begrenzt einen Schreibvorgang auf maximal 75 Actions. Mehrere Batches werden nacheinander und nicht parallel an die Fiber Box gesendet.
Patch ist nach F5 wieder entfernt
Der JavaScript-Patch ist bewusst nicht persistent. Er befindet sich ausschliesslich im Arbeitsspeicher des Browsers. Nach einem Neuladen der Weboberfläche mit F5, nach dem Schliessen des Browsers oder nach einem erneuten Login ist der Patch nicht mehr aktiv und muss bei Bedarf erneut über die Entwicklerkonsole geladen werden.
Der Patch verändert weder die Firmware noch JavaScript-Dateien auf dem Router. Beim Betätigen von Speichern verändert er jedoch die betreffenden Firewall-Konfigurationswerte auf der Fiber Box – genau das ist der Zweck des Workarounds.
Nach einer Änderung empfehlen wir zunächst einen kontrollierten Test: Eine Regel nur um eine Position verschieben, speichern und die Seite mit F5 neu laden. Bleibt die Position erhalten, kann anschliessend eine grössere Verschiebung getestet werden. Abschliessend sollte immer geprüft werden, ob die betroffenen Firewall-Regeln den Netzwerkverkehr tatsächlich wie vorgesehen erlauben oder blockieren.
Fazit
Bei der Salt Fiber Box X6 mit Firmware SGCk10005062 verhindert ein reproduzierbarer Bug der grafischen Oberfläche unter den beschriebenen Umständen das Ändern der Sortierung von Firewall-Regeln. Das ist relevant, weil sich Firewall-Regeln überschneiden können und ihre Priorität bei geordnet ausgewerteten Regelsätzen darüber entscheidet, welche Freigabe oder Sperre zuerst angewendet wird. Der praktikable Workaround besteht darin, beim Anlegen der Regel einen eigenen Regelnamen statt einer vordefinierten Bezeichnung zu verwenden. Damit lässt sich die Firewall-Regel nach den vorliegenden Beobachtungen korrekt anlegen und verwalten. Der Abschnitt "Technischer Hintergrund für Experten" dokumentiert zusätzlich die technische Analyse und den JavaScript-Workaround.
