Zugriffsrechte des Benutzers

Berechtigungsflags für Anmeldeklassen

Sie verwenden Berechtigungsflags, um einem Benutzer Zugriff auf Betriebsmodusbefehle und Konfigurationshierarchieebenen und -anweisungen zu gewähren. Sie konfigurieren Berechtigungsflags für die Anmeldeklasse des Benutzers auf Hierarchieebene .[edit system login class] Wenn Sie ein bestimmtes Berechtigungsflag angeben, erhält der Benutzer Zugriff auf die Befehle sowie auf die Konfigurationshierarchieebenen und -anweisungen, die diesem Flag entsprechen. Um Zugriff auf alle Befehle und Konfigurationsanweisungen zu gewähren, verwenden Sie das Berechtigungsflag.all

Die Anweisung gibt eines oder mehrere der Berechtigungsflags an, die in aufgeführt sind .permissionsTabelle 1 Berechtigungsflags sind nicht kumulativ. Für jede Klasse müssen Sie alle erforderlichen Berechtigungsflags auflisten, einschließlich der Anzeige von Informationen und des Zugriffs in den Konfigurationsmodus.viewconfigure Zwei Arten von Berechtigungen steuern den Zugriff eines Benutzers auf die einzelnen Teile der Konfiguration:

• "Einfaches" Formular: Bietet schreibgeschützte Funktionen für diesen Berechtigungstyp. Ein Beispiel ist .interface

• -control form: Bietet Lese- und Schreibfunktionen für diesen Berechtigungstyp. Ein Beispiel ist .interface-control

Bei Berechtigungsflags, die Zugriff auf Konfigurationshierarchieebenen und -anweisungen gewähren, gewähren die einfachen Formularflags Leseberechtigung für diese Konfiguration. Das Berechtigungskennzeichen gewährt z.B . schreibgeschützten Zugriff auf die Hierarchieebene .interface[edit interfaces] Die Form des Flags gewährt Lese-/Schreibzugriff auf diese Konfiguration.-control Das Kennzeichen gewährt z.B. Lese-/Schreibzugriff auf die Hierarchieebene .interface-control[edit interfaces]

Listet die Berechtigungsflags der Anmeldeklasse auf, die Sie konfigurieren können, indem Sie die Anweisung auf Hierarchieebene einschließen.Tabelle 1permissions[edit system login class class-name]

Die Berechtigungsflags gewähren einen bestimmten Satz von Zugriffsberechtigungen. Jedes Berechtigungsflag wird mit den Befehlen für den Betriebsmodus oder Konfigurationsmodus sowie den Konfigurationshierarchieebenen und -anweisungen aufgeführt, für die dieses Flag Zugriff gewährt.

Zulassen und Verweigern einzelner Befehle und Anweisungshierarchien für Anmeldeklassen

Standardmäßig verfügen alle CLI-Befehle und Konfigurationshierarchieebenen der obersten Ebene über zugeordnete Zugriffsberechtigungsebenen. Benutzer können nur die Befehle ausführen und nur die Anweisungen anzeigen und konfigurieren, für die sie über Zugriffsrechte verfügen. Für jede Anmeldeklasse können Sie die Verwendung von Befehlen und Anweisungshierarchien für den Betriebsmodus und Konfigurationsmodus, die andernfalls durch eine in der Anweisung angegebene Berechtigungsstufe zugelassen oder verweigert würden, explizit zulassen oder verweigern.permissions

Berechtigungsflags gewähren einem Benutzer Zugriff auf Betriebsmodus- und Konfigurationsmodusbefehle sowie auf Konfigurationshierarchieebenen und -anweisungen. Durch die Angabe eines bestimmten Berechtigungsflags für die Anmeldeklasse des Benutzers auf Hierarchieebene gewähren Sie dem Benutzer Zugriff auf die entsprechenden Befehle und Konfigurationshierarchieebenen und -anweisungen.[edit system login class] Um Zugriff auf alle Befehle und Konfigurationsanweisungen zu gewähren, verwenden Sie das Berechtigungsflag.all

Sie können die Verwendung von Befehlen und Anweisungen explizit zulassen oder verweigern, indem Sie die , , und -Anweisungen für eine login-Klasse konfigurieren.allow-commandsdeny-commandsallow-configurationdeny-configuration In den Anweisungen verwenden Sie erweiterte reguläre Ausdrücke, um zu definieren, welche Befehle und Anweisungen für Benutzer, die der Klasse zugewiesen sind, zugelassen oder verweigert werden sollen.

Grundlegendes zu den allow- und deny-Anweisungen

Jeder CLI-Befehls- und Konfigurationsanweisungshierarchie der obersten Ebene ist eine Zugriffsberechtigungsebene zugeordnet. Jede Anmeldeklasse kann die Verwendung von Befehlen für den Betriebsmodus und Konfigurationsmodus sowie von Konfigurationshierarchien und -anweisungen, die andernfalls durch eine Berechtigungsstufe zugelassen oder verweigert würden, explizit zulassen oder verweigern. Benutzer können nur die Befehle ausführen und nur die Anweisungen anzeigen und konfigurieren, für die sie über Zugriffsrechte verfügen.

Die Zugriffsrechte für jede Anmeldeklasse werden durch ein oder mehrere Berechtigungsflags definiert, die in der Anweisung auf Hierarchieebene angegeben sind.permissions[edit system login class class-name] Darüber hinaus können Sie die Verwendung bestimmter Befehle und Konfigurationshierarchien zulassen oder verweigern, indem Sie erweiterte reguläre Ausdrücke definieren. Sie können die regulären Ausdrücke angeben, indem Sie die folgenden Anweisungen für eine login-Klasse konfigurieren:

• and —Erlauben oder verweigern Sie den Zugriff auf Befehle für den Betriebsmodus und den Konfigurationsmodus.allow-commandsdeny-commands

• and —Erlauben oder verweigern Sie den Zugriff auf bestimmte Konfigurationshierarchien.allow-configurationdeny-configuration

  HINWEIS:

  Diese Anweisungen führen einen langsameren Abgleich mit mehr Flexibilität durch, insbesondere beim Platzhalterabgleich. Es kann jedoch sehr lange dauern, alle möglichen Anweisungen auszuwerten, wenn eine große Anzahl von regulären Ausdrücken für den gesamten Pfad oder Platzhalterausdrücke konfiguriert sind, was sich möglicherweise negativ auf die Leistung auswirkt.

• and —Erlaubt oder verweigert den Zugriff auf bestimmte Befehle mithilfe von Zeichenketten regulärer Ausdrücke.allow-commands-regexpsdeny-commands-regexps

• and —Erlaubt oder verweigert den Zugriff auf bestimmte Konfigurationshierarchien mithilfe von Zeichenketten regulärer Ausdrücke.allow-configuration-regexpsdeny-configuration-regexps

Durch das explizite Zulassen von Befehlen und Konfigurationsanweisungshierarchien mithilfe der Anweisungen werden die bereits in der Anweisung definierten Berechtigungen erweitert.allow/deny-*permissions Ebenso werden durch das explizite Verweigern von Befehlen und Konfigurationsanweisungshierarchien mithilfe der Anweisungen Berechtigungen entfernt, die in der Anweisung bereits definiert sind.allow/deny-*permissions

In der folgenden Konfiguration ermöglicht die Berechtigung Benutzern in der login-Klasse beispielsweise, in den Konfigurationsmodus zu wechseln.configure Darüber hinaus ermöglicht der Ausdruck Benutzern, die Konfiguration auf Hierarchieebene zu ändern und zu bestätigen.allow-configuration[edit system services]

In ähnlicher Weise kann der Benutzer der Anmeldeklasse in der folgenden Konfiguration alle Vorgänge ausführen, die das Berechtigungsflag zulässt, mit der Ausnahme, dass der Benutzer die Konfiguration auf Hierarchieebene nicht anzeigen oder ändern kann:all[edit system services]

Grundlegendes zur Syntax von Allow- und Deny-Anweisungen

Sie können eine Anweisung nur einmal in jeder Anmeldeklasse konfigurieren.allow/deny-* Wenn Sie eine Anweisung konfigurieren:

• Sie können beliebig viele reguläre Ausdrücke konfigurieren.

• Bei regulären Ausdrücken wird nicht zwischen Groß- und Kleinschreibung unterschieden

Die Aussagen schließen sich gegenseitig mit den Anweisungen aus, und die Aussagen schließen sich gegenseitig mit den Anweisungen aus.allow/deny-commandsallow/deny-commands-regexpsallow/deny-configurationallow/deny-configuration-regexps Sie können z. B. nicht sowohl als auch in derselben Anmeldeklasse konfigurieren.allow-configurationallow-configuration-regexps

Um Zugriffsrechte für Befehle zu definieren, geben Sie erweiterte reguläre Ausdrücke mit der and-Anweisung an.allow-commandsdeny-commands Schließen Sie jeden vollständigen eigenständigen Ausdruck in Klammern ( ) ein, und verwenden Sie das Pipe-Symbol ( | ), um die Ausdrücke zu trennen. Verwenden Sie keine Leerzeichen zwischen regulären Ausdrücken, die mit dem Pipe-Symbol verbunden sind. Der vollständige Ausdruck wird in doppelte Anführungszeichen gesetzt.

Hier einige Zahlen zum Generationswechsel:

Sie müssen Anker verwenden, wenn Sie komplexe reguläre Ausdrücke mit der Anweisung angeben.allow-commands Hier einige Zahlen zum Generationswechsel:

Um Zugriffsrechte für Teile der Konfigurationshierarchie zu definieren, geben Sie erweiterte reguläre Ausdrücke in der and-Anweisung an.allow-configurationdeny-configuration Schließen Sie die vollständigen Pfade in Klammern ( ) ein, und verwenden Sie das Pipe-Symbol ( | ), um die Ausdrücke zu trennen. Verwenden Sie keine Leerzeichen zwischen regulären Ausdrücken, die mit dem Pipe-Symbol verbunden sind. Der vollständige Ausdruck wird in doppelte Anführungszeichen gesetzt.

Hier einige Zahlen zum Generationswechsel:

Wenn Sie erweiterte reguläre Ausdrücke mit der oder-Anweisung angeben, schließen Sie jeden Ausdruck in Anführungszeichen (" ") ein, und trennen Sie die Ausdrücke durch ein Leerzeichen.allow/deny-commands-regexpsallow/deny-configuration-regexps Schließen Sie mehrere Ausdrücke in eckige Klammern [ ] ein. Hier einige Zahlen zum Generationswechsel:

Modifizierer wie , und werden in der Zeichenfolge für reguläre Ausdrücke, die abgeglichen werden soll, nicht unterstützt.setlogcount Wenn Sie einen Modifikator verwenden, wird nichts abgeglichen.

Korrekte Konfiguration:

Falsche Konfiguration:

Grundlegendes zur Rangfolge und zum Abgleich von allow- und deny-Anweisungen

Standardmäßig haben die regulären Ausdrücke und Vorrang vor und Ausdrücken.allow-commandsallow-configurationdeny-commandsdeny-configuration Wenn Sie also denselben Befehl für die and-Anweisung konfigurieren, hat der allow-Vorgang Vorrang vor dem deny-Vorgang.allow-commandsdeny-commands Wenn Sie dieselbe Anweisung für die and-Anweisung konfigurieren, hat der allow-Vorgang Vorrang vor dem deny-Vorgang.allow-configurationdeny-configuration

Die folgende Konfiguration ermöglicht es z. B. einem Benutzer in der login-Klasse, Software mit dem Befehl zu installieren, obwohl die Anweisung denselben Befehl enthält:testrequest system software adddeny-commands

Auf ähnliche Weise ermöglicht die folgende Konfiguration einem Benutzer im Anmeldeklassentest, die Konfigurationshierarchie anzuzeigen und zu ändern, obwohl die Anweisung dieselbe Hierarchie enthält:test[edit system services]deny-configuration

Wenn die and-Anweisungen zwei verschiedene Varianten eines Befehls haben, wird immer die längste Übereinstimmung ausgeführt.allow-commandsdeny-commands Die folgende Konfiguration ermöglicht es einem Benutzer in der login-Klasse, den Befehl, aber nicht den Befehl auszuführen.testcommit synchronizecommit Dies liegt daran, dass die längste Übereinstimmung zwischen und ist und für angegeben ist.commit synchronizecommitcommit synchronizeallow-commands

Die folgende Konfiguration ermöglicht es einem Benutzer in der login-Klasse, den Befehl, aber nicht den Befehl auszuführen.testcommitcommit synchronize Dies liegt daran, dass die längste Übereinstimmung zwischen und ist und für angegeben ist.commit synchronizecommitcommit synchronizedeny-commands

Im Gegensatz zu den anderen Anweisungen besteht das Standardverhalten für die Anweisungen darin, dass die regulären Ausdrücke und Vorrang vor den Ausdrücken und haben.*-regexpsdeny-commands-regexpsdeny-configuration-regexpsallow-commands-regexpsallow-configuration-regexps Sie können die Anweisung auf Hierarchieebene konfigurieren, um zu erzwingen, dass die regulären Ausdrücke Vorrang vor den Anweisungen haben.regex-additive-logic[edit system]allow-configuration-regexpsdeny-configuration-regexps Wenn Sie die Anweisung konfigurieren, können Sie Konfigurationshierarchien auf einer höheren Ebene ablehnen und dem Benutzer dann nur den Zugriff auf bestimmte Unterhierarchien gewähren.

Grundlegendes zu den Regeln für die Anweisung "Zulassen" und "Verweigern"

Die , , und -Anweisungen haben Vorrang vor den Berechtigungen der Anmeldeklasse.allow/deny-commandsallow/deny-configurationallow/deny-commands-regexpsallow/deny-configuration-regexps Wenn Sie diese Anweisungen konfigurieren, gelten die folgenden Regeln:

• Reguläre Ausdrücke für and-Anweisungen können auch die Befehle , , , , und enthalten.allow-commandsdeny-commandscommitloadrollbacksavestatusupdate

• Die Berechtigungsbits der Anmeldeklasse haben Vorrang vor erweiterten regulären Ausdrücken, wenn ein Benutzer den Befehl mit aktiviertem Berechtigungsflag ausgibt.allrollbackrollback

• Benutzer können den Befehl nicht ausgeben, wenn sie einen erweiterten regulären Ausdruck angeben.load override Benutzer können nur die Konfigurationsbefehle , und ausführen.mergereplacepatch

• Sie können das Platzhalterzeichen * verwenden, wenn Sie reguläre Ausdrücke kennzeichnen. Sie müssen es jedoch als Teil eines regulären Ausdrucks verwenden. Sie können oder nicht als einzigen Ausdruck verwenden.[ * ][ .* ] Darüber hinaus können Sie die Anweisung nicht mit einem Ausdruck wie , konfigurieren, da dies zu .allow-configuration(interfaces (description (|.*))allow-configuration .*

Grundlegendes zu den Unterschieden für die *-regexps-Anweisungen

In diesem Abschnitt werden die Unterschiede zwischen den Anweisungen und den Anweisungen beschrieben.allow/deny-configurationallow/deny-configuration-regexps

Die Anweisungen teilen den regulären Ausdruck in Token auf und gleichen jedes Teil mit jedem Teil des vollständigen Pfads der angegebenen Konfiguration ab, während die Anweisungen mit der vollständigen Zeichenfolge übereinstimmen.allow/deny-configuration-regexpsallow/deny-configuration Für Anweisungen konfigurieren Sie einen Satz von Zeichenfolgen, in denen jede Zeichenfolge ein regulärer Ausdruck mit Leerzeichen zwischen den Begriffen der Zeichenfolge ist.allow/deny-configuration-regexps Diese Syntax ermöglicht einen sehr schnellen Abgleich, bietet jedoch weniger Flexibilität. Zum Angeben von Platzhalterausdrücken müssen Sie Platzhalter für jedes Token der durch Leerzeichen getrennten Zeichenfolge einrichten, die Sie abgleichen möchten, wodurch die Verwendung von Platzhalterausdrücken für diese Anweisungen erschwert wird.

Hier einige Zahlen zum Generationswechsel:

• Reguläre Ausdrücke, die mit einem Token übereinstimmen, indem sie allow-configuration-regexps verwenden

  Dieses Beispiel zeigt, dass dies der einzige übereinstimmende Ausdruck für das erste Token der Anweisung ist.options

  Die obige Konfiguration stimmt mit den folgenden Anweisungen überein:

  • Bedingung für Richtlinienoptionen festlegen dynamic-dbcondition

  • set routing-options static route next-hop static-routenext-hop

  • set event-options generate-event time-interval eventseconds

  Die obige Konfiguration stimmt nicht mit den folgenden Anweisungen überein:

  • host-optionen für den System-Hostnamen

  • Schnittstellenbeschreibungsoptioneninterface-name

• Regulärer Ausdruck, der mit drei Token übereinstimmt, indem allow-configuration-regexps verwendet wird

  Dieses Beispiel zeigt, dass dies der einzige übereinstimmende Ausdruck für das dritte Token der Anweisung ist.ssh

  Im vorherigen Beispiel enthalten die drei Token , bzw. . . . und ..*.*.*ssh

  Die obige Konfiguration stimmt mit den folgenden Anweisungen überein:

  • System-Hostname Hostname-SSH

  • Systemdienste SSH

  • Systemdienste ausgehend-ssh

  Die obige Konfiguration stimmt nicht mit der folgenden Anweisung überein:

  • Schnittstellen Beschreibung SSHinterface-name

Es ist einfacher, die Anweisung zum Einschränken des Konfigurationszugriffs zu verwenden, als die Anweisung zu verwenden. veranschaulicht die Verwendung der and-Anweisung in verschiedenen Konfigurationen, um das gleiche Ergebnis der Beschränkung des Zugriffs auf eine bestimmte Konfiguration zu erzielen. deny-configurationdeny-configuration-regexpsTabelle 2deny-configurationdeny-configuration-regexps

[edit system]
login {
    class test {
        permissions configure;
         allow-configuration .*;
        deny-configuration .*xnm-ssl;
    }
}

[edit system]
login {
    class test {
        permissions configure;
         allow-configuration .*;
        deny-configuration-regexps ".* .* .*-ssl"";
    }
}

[edit system]
login {
    class test {
        permissions configure;
        allow-configuration .*;
        deny-configuration ".*ssh";
    }
}

[edit system]
login {
    class test {
        permissions configure;
        allow-configuration .*;
        deny-configuration-regexps ".*ssh";
        deny-configuration-regexps ".* .*ssh";
        deny-configuration-regexps ".* .* .*ssh";
    }
}

Obwohl die Anweisungen auch nützlich sind, wenn Sie eine einfache Konfiguration wünschen, bieten die Anweisungen eine bessere Leistung und überwinden die Mehrdeutigkeit, die beim Kombinieren von Ausdrücken in den Anweisungen bestand.allow/deny-configurationallow/deny-configuration-regexpsallow/deny-configuration

Verwenden regulärer Ausdrücke auf Remoteautorisierungsservern

Sie können erweiterte reguläre Ausdrücke verwenden, um anzugeben, welche Befehle im Betriebsmodus und Konfigurationsmodus sowie Konfigurationsanweisungen und -hierarchien für bestimmte Benutzer zulässig oder verweigert werden. Diese regulären Ausdrücke geben Sie lokal in den Anweisungen , und auf Hierarchieebene an.allow/deny-commandsallow/deny-configurationallow/deny-commands-regexpsallow/deny-configuration-regexps[edit system login class class-name] Sie können diese regulären Ausdrücke remote angeben, indem Sie in der Konfiguration Ihres Autorisierungsservers herstellerspezifische TACACS+- oder RADIUS-Attribute von Juniper Networks angeben. Wenn Sie Autorisierungsparameter sowohl lokal als auch remote konfigurieren, führt das Gerät die regulären Ausdrücke, die während der TACACS+- oder RADIUS-Autorisierung empfangen wurden, mit allen regulären Ausdrücken zusammen, die auf dem lokalen Gerät definiert sind.

Wenn Sie mehrere reguläre Ausdrücke in einer lokalen Konfiguration mit der , , oder -Anweisung angeben, konfigurieren Sie reguläre Ausdrücke in Klammern und trennen sie durch das Pipe-Symbol.allow-commandsdeny-commandsallow-configurationdeny-configuration Sie schließen den vollständigen Ausdruck in doppelte Anführungszeichen ein. Sie können z. B. mehrere Parameter mit der folgenden Syntax angeben:allow-commands

Der RADIUS-Autorisierungsserver verwendet die folgenden Attribute und Syntax:

Der TACACS+-Autorisierungsserver verwendet die folgenden Attribute und Syntax:

Wenn Sie mehrere reguläre Ausdrücke in einer lokalen Konfiguration mit der , , oder -Anweisung angeben, konfigurieren Sie reguläre Ausdrücke in doppelten Anführungszeichen und trennen sie mit dem Leerzeichenoperator.allow-commands-regexpsdeny-commands-regexpsallow-configuration-regexpsdeny-configuration-regexps Sie schließen den vollständigen Ausdruck in eckige Klammern ein. Sie können z. B. mehrere Parameter für Zulassungsbefehle mit der folgenden Syntax angeben:

Der RADIUS-Autorisierungsserver verwendet die folgenden Attribute und Syntax:

Der TACACS+-Autorisierungsserver verwendet die folgenden Attribute und Syntax:

RADIUS- und TACACS+-Server unterstützen auch eine vereinfachte Syntax, bei der Sie jeden einzelnen Ausdruck in einer separaten Zeile angeben. Die vereinfachte Syntax des RADIUS-Servers lautet beispielsweise:

In ähnlicher Weise lautet die vereinfachte Syntax des TACACS+-Servers:

Tabelle 3 unterscheidet die lokale Autorisierungskonfiguration und die TACACS+-Serverautorisierungskonfiguration mithilfe regulärer Ausdrücke.

login {
    class local {
        permissions configure;
        allow-commands "(ping .*)|(traceroute .*)|(show .*)|(configure .*)|(edit)|(exit)|(commit)|(rollback .*)";
        deny-commands .*;
        allow-configuration "(interfaces .* unit 0 family ethernet-switching vlan mem.* .*)|(interfaces .* native.* .*)|(interfaces .* unit 0 family ethernet-switching interface-mo.* .*)|(interfaces .* unit .*)|(interfaces .* disable)|(interfaces .* description .*)|(vlans .* vlan-.* .*)"
        deny-configuration .*;
    }
}

user = remote {
    login = username
    service = junos-exec {
        allow-commands1 = "ping .*"
        allow-commands2 = "traceroute .*"
        allow-commands3 = "show .*"
        allow-commands4 = "configure"
        allow-commands5 = "edit"
        allow-commands6 = "exit"
        allow-commands7 = "commit"
        allow-commands8 = ".*xml-mode"
        allow-commands9 = ".*netconf.*"
        allow-commands10 = ".*need-trailer"
        allow-commands11 = "rollback.*"
        allow-commands12 = "junoscript"
        deny-commands1 = ".*"
        allow-configuration1 = "interfaces .* unit 0 family ethernet-switching vlan mem.* .*"
        allow-configuration2 = "interfaces .* native.* .*"
        allow-configuration3 = "interfaces .* unit 0 family ethernet-switching interface-mo.* .*"
        allow-configuration4 = "interfaces .* unit .*"
        allow-configuration5 = "interfaces .* disable"
        allow-configuration6 = "interfaces .* description .*"
        allow-configuration7 = "interfaces .*"
        allow-configuration8 = "vlans .* vlan-.* .*"
        deny-configuration1 = ".*"
        local-user-name = local-username
        user-permissions = "configure"
    }
}

Reguläre Ausdrücke angeben

Sie sollten reguläre Ausdrücke für Befehle und Konfigurationsanweisungen auf die gleiche Weise angeben wie beim Ausführen des vollständigen Befehls oder der vollständigen Anweisung. Listet die regulären Ausdrücke zum Konfigurieren von Zugriffsrechten für die AND-Anweisungshierarchien auf.Tabelle 4[edit interfaces][edit vlans]

[edit]
user@host# set interfaces interface-name unit interface-unit-number

[edit system login class class-name]
user@host# set permissions configure
user@host# set deny-configuration "interfaces .* unit .*"

[edit]
user@host# set vlans vlan-name vlan-id vlan-id

[edit system login class class-name]
user@host# set permissions configure
user@host# set allow-configuration "vlans .* vlan-id .*"

Operatoren für reguläre Ausdrücke

Tabelle 5 Listet allgemeine Operatoren für reguläre Ausdrücke auf, die Sie zum Zulassen oder Verweigern von Betriebs- und Konfigurationsmodi verwenden können.

Reguläre Ausdrücke für Befehle implementieren die erweiterten (modernen) regulären Ausdrücke, wie sie in POSIX 1003.2 definiert sind.

[edit system login class test]
user@host# set permissions configure
user@host# set allow-commands "(ping)|(traceroute)|(show system alarms)|(show system software)"
user@host# set deny-configuration "(access)|(access-profile)|(accounting-options)|(applications)|(apply-groups)|(bridge-domains)|(chassis)|(class-of-service)"

[edit system login class test]
user@host# set permissions interface
user@host# set permissions interface-control
user@host# set allow-commands "(^show) (log|interfaces|policer))|(^monitor)"

[edit system login class test]
user@host# set permissions interface
user@host# set allow-commands "(show interfaces$)"

[edit system login class test]
user@host# set permissions clear
user@host# set permissions configure
user@host# set permissions network
user@host# set permissions trace
user@host# set permissions view
user@host# set allow-configuration-regexps [ "interfaces [gx]e-.* unit [0-9]* description .*" ]

[edit system login class test]
user@host# set permissions all
user@host# set allow-commands "(clear)|(configure)"
user@host# deny-commands "(mtrace)|(start)|(delete)"

[edit system login class test]
user@host# set permissions configure
user@host# set deny-configuration "(system login class m*)"

[edit system login class test]
user@host# set permissions configure
user@host# set deny-configuration "(system login class m+)"

[edit system login class test]
user@host# set permissions configure
user@host# set deny-configuration "(system login class m.)"

[edit system login class test]
user@host# set permissions configure
user@host# set deny-configuration "(system login class m .*)"

Beispiele für reguläre Ausdrücke

Listet die regulären Ausdrücke auf, die verwendet werden, um Konfigurationsoptionen unter zwei Konfigurationshierarchien zuzulassen – und – als Beispiel für die Angabe regulärer Ausdrücke.Tabelle 6[edit system ntp server][edit protocols rip]

[edit system login class test]
set permissions configure
set allow-configuration-regexps [ "system ntp server .*" "system ntp server .* key .*" ]
set deny-configuration-regexps [ "system ntp server .* version .*" "system ntp server .* prefer" ]

[edit system login class test]
set permissions configure
set allow-configuration-regexps [ "system ntp server .*" "system ntp server .* version .*" ]
set deny-configuration-regexps [ "system ntp server .* key .*" "system ntp server .* prefer" ]

[edit system login class test]
set permissions configure
set allow-configuration-regexps [ "system ntp server .*" "system ntp server .* prefer" ];
set deny-configuration-regexps [ "system ntp server .* key .*" "system ntp server .* version .*" ]

[edit system login class test]
set permissions configure
set allow-configuration-regexps "protocols rip message-size .*"
set deny-configuration-regexps [ "protocols rip metric-in .*" "protocols rip route-timeout .*" "protocols rip update-interval .*" ]

[edit system login class test]
set permissions configure
set  allow-configuration-regexps "protocols rip metric-in .*"
set  deny-configuration-regexps [ "protocols rip message-size .*" "protocols rip route-timeout .*" "protocols rip update-interval .*" ]

[edit system login class test]
set permissions configure
set allow-configuration-regexps "protocols rip route-timeout .*"
set deny-configuration-regexps [ "protocols rip metric-in .*" "protocols rip message-size .*" "protocols rip update-interval .*" ]

[edit system login class test]
set permissions configure
set allow-configuration-regexps "protocols rip update-interval .*"
set deny-configuration-regexps [ "protocols rip metric-in .*" "protocols rip route-timeout .*" "protocols rip message-size .*" ]