Ansprüche Transformation Regeln SpracheClaims Transformation Rules Language

Gilt für: Windows Server 2016, Windows Server 2012 R2, Windows Server 2012Applies To: Windows Server 2016, Windows Server 2012 R2, Windows Server 2012

Die Gesamtstruktur übergreifende Anspruchs Transformations Funktion ermöglicht es Ihnen, Ansprüche für dynamische Access Control über Gesamtstruktur Grenzen hinweg durch Festlegen von Anspruchs Transformations Richtlinien auf Gesamtstruktur übergreifende Vertrauens Stellungen zu überbrücken.The across-forest claims transformation feature enables you to bridge claims for Dynamic Access Control across forest boundaries by setting claims transformation policies on across-forest trusts. Die primäre Komponente aller Richtlinien sind Regeln, die in der Sprache der Anspruchs Transformationsregeln geschrieben sind.The primary component of all policies is rules that are written in claims transformation rules language. Dieses Thema enthält ausführliche Informationen zu dieser Sprache und enthält Anleitungen zum Erstellen von Anspruchs Transformationsregeln.This topic provides details about this language and provides guidance about authoring claims transformation rules.

Die Windows PowerShell-Cmdlets für Transformations Richtlinien für Gesamtstruktur übergreifende Vertrauens Stellungen haben Optionen zum Festlegen einfacher Richtlinien, die in gängigen Szenarien erforderlich sind.The Windows PowerShell cmdlets for transformation policies on across-forest trusts have options to set simple policies that are required in common scenarios. Diese Cmdlets übersetzen die Benutzereingaben in Richtlinien und Regeln in der Sprache der Anspruchs Transformationsregeln und speichern Sie dann im vorgeschriebenen Format in Active Directory.These cmdlets translate the user input into policies and rules in the claims transformation rules language, and then store them in Active Directory in the prescribed format. Weitere Informationen zu Cmdlets für die Transformation von Ansprüchen finden Sie in den AD DS Cmdlets für dynamisches Access Control.For more information about cmdlets for claims transformation, see the AD DS Cmdlets for Dynamic Access Control.

Abhängig von der Anspruchs Konfiguration und den Anforderungen, die für die Gesamtstruktur übergreifende Vertrauensstellung in Ihren Active Directory Gesamtstrukturen gelten, müssen ihre Anspruchs Transformations Richtlinien möglicherweise komplexer sein als die Richtlinien, die von den Windows PowerShell-Cmdlets für Active Directory unterstützt werden.Depending on the claims configuration and the requirements placed on the across-forest trust in your Active Directory forests, your claims transformation policies may have to be more complex than the policies supported by the Windows PowerShell cmdlets for Active Directory. Um solche Richtlinien effektiv zu verfassen, ist es von entscheidender Bedeutung, die Sprachsyntax und die Semantik der Anspruchs Transformationsregeln zu verstehen.To effectively author such policies, it is essential to understand the claims transformation rules language syntax and semantics. Diese Anspruchs Transformations Regel-Sprache ("die Sprache") in Active Directory ist eine Teilmenge der Sprache, die von Active Directory-Verbunddienste (AD FS) zu ähnlichen Zwecken verwendet wird, und Sie weist eine sehr ähnliche Syntax und Semantik auf.This claims transformation rules language ("the language") in Active Directory is a subset of the language that is used by Active Directory Federation Services for similar purposes, and it has a very similar syntax and semantics. Es sind jedoch weniger Vorgänge zulässig, und zusätzliche Syntax Einschränkungen werden in der Active Directory Version der Sprache platziert.However, there are fewer operations allowed, and additional syntax restrictions are placed in the Active Directory version of the language.

In diesem Thema wird die Syntax und Semantik der Anspruchs Transformations Regel-Sprache in Active Directory erläutert, und es werden Überlegungen zum Erstellen von Richtlinien erläutert.This topic briefly explains the syntax and semantics of the claims transformation rules language in Active Directory and considerations to be made when authoring policies. Sie enthält mehrere Sätze von Beispiel Regeln, um Ihnen den Einstieg zu erleichtern, sowie Beispiele falscher Syntax und der von Ihnen generierten Meldungen, um beim Erstellen der Regeln Fehlermeldungen zu entschlüsseln.It provides several sets of example rules to get you started, and examples of incorrect syntax and the messages they generate, to help you decipher error messages when you author the rules.

Tools zum Erstellen von Anspruchs Transformations RichtlinienTools for authoring claims transformation policies

Windows PowerShell-Cmdlets für Active Directory: Dies ist die bevorzugte und empfohlene Methode zum Erstellen und Festlegen von Anspruchs Transformations Richtlinien.Windows PowerShell cmdlets for Active Directory: This is the preferred and recommended way to author and set claims transformation policies. Diese Cmdlets bieten Schalter für einfache Richtlinien und überprüfen Regeln, die für komplexere Richtlinien festgelegt sind.These cmdlets provide switches for simple policies and verify rules that are set for more complex policies.

LDAP: Anspruchs Transformations Richtlinien können in Active Directory mithilfe von LDAP (Lightweight Directory Access Protocol) bearbeitet werden.LDAP: Claims transformation policies can be edited in Active Directory through Lightweight Directory Access Protocol (LDAP). Dies wird jedoch nicht empfohlen, da die Richtlinien mehrere komplexe Komponenten aufweisen und die von Ihnen verwendeten Tools die Richtlinie möglicherweise nicht validieren, bevor Sie Sie in Active Directory schreiben.However, this is not recommended because the policies have several complex components, and the tools you use may not validate the policy before writing it to Active Directory. Dies kann später eine beträchtliche Zeit für die Diagnose von Problemen erfordern.This may subsequently require a considerable amount of time to diagnose problems.

Active Directory Anspruchs Transformationsregeln-SpracheActive Directory claims transformation rules language

SyntaxübersichtSyntax overview

Im folgenden finden Sie eine kurze Übersicht über die Syntax und die Semantik der Sprache:Here is a brief overview of the syntax and semantics of the language:

  • Der Regelsatz der Anspruchs Transformation besteht aus null oder mehr Regeln.The claims transformation rule set consists of zero or more rules. Jede Regel verfügt über zwei aktive Teile: Wählen Sie Bedingungs Liste und Regel Aktion aus.Each rule has two active parts: Select Condition List and Rule Action. Wenn die Liste Bedingung auswählen als true ausgewertet wird, wird die entsprechende Regel Aktion ausgeführt.If the Select Condition List evaluates to TRUE, the corresponding rule action is executed.

  • Die Auswahl Bedingungs Liste enthält keine oder mehrere SELECT- Bedingungen.Select Condition List has zero or more Select Conditions. Alle SELECT- Bedingungen müssen als true ausgewertet werden, damit die Liste Bedingung auswählen als true ausgewertet wird.All of the Select Conditions must evaluate to TRUE for the Select Condition List to evaluate to TRUE.

  • Jede Select-Bedingung hat einen Satz von NULL oder mehr übereinstimmenden Bedingungen.Each Select Condition has a set of zero or more Matching Conditions. Alle übereinstimmenden Bedingungen müssen als true ausgewertet werden, damit die Select-Bedingung als true ausgewertet wird.All the Matching Conditions must evaluate to TRUE for the Select Condition to evaluate to TRUE. Alle diese Bedingungen werden anhand eines einzelnen Anspruchs ausgewertet.All of these conditions are evaluated against a single claim. Ein Anspruch, der einer Select-Bedingung entspricht, kann durch einen Bezeichner gekennzeichnet werden und in der Regel Aktion darauf verwiesen werden.A claim that matches a Select Condition can be tagged by an Identifier and referred to in the Rule Action.

  • Jede übereinstimmende Bedingung gibt die Bedingung an, mit der der Typ oder Wert oder ValueType eines Anspruchs mithilfe verschiedener Bedingungs Operatoren und Zeichen folgen Literale übereinstimmen.Each Matching Condition specifies the condition to match the Type or Value or ValueType of a claim by using different Condition Operators and String Literals.

    • Wenn Sie eine abgleichsbedingung für einen Wert angeben, müssen Sie auch eine entsprechende Bedingung für einen bestimmten ValueType angeben und umgekehrt.When you specify a Matching Condition for a Value, you must also specify a Matching Condition for a specific ValueType and vice versa. Diese Bedingungen müssen in der-Syntax nebeneinander liegen.These conditions must be next to each other in the syntax.

    • ValueType -Übereinstimmungs Bedingungen müssen nur bestimmte ValueType -Literale verwenden.ValueType matching conditions must use specific ValueType literals only.

  • Eine Regel Aktion kann einen Anspruch kopieren, der mit einem Bezeichner gekennzeichnet ist, oder einen Anspruch auf der Grundlage eines Anspruchs, der mit einem Bezeichner und/oder angegebenen Zeichenfolgenliteralen gekennzeichnet ist, ausstellen.A Rule Action can copy one claim that is tagged with an Identifier or issue one claim based on a claim that is tagged with an Identifier and/or given String Literals.

Beispiel RegelExample rule

Dieses Beispiel zeigt eine Regel, die verwendet werden kann, um den Anspruchstyp zwischen zwei Gesamtstrukturen zu übersetzen, vorausgesetzt, Sie verwenden die gleichen Anspruchs ValueTypes und weisen die gleichen Interpretationen für Anspruchs Werte für diesen Typ auf.This example shows a rule that can be used to translate the claims Type between two forests, provided that they use the same claims ValueTypes and have the same interpretations for claims Values for this type. Die Regel verfügt über eine übereinstimmende Bedingung und eine Issue-Anweisung, die Zeichen folgen Literale und einen übereinstimmenden Anspruchs Verweis verwendet.The rule has one matching condition and an Issue statement that uses String Literals and a matching claims reference.

C1: [TYPE=="EmployeeType"]
                 => ISSUE (TYPE= "EmpType", VALUE = C1.VALUE, VALUETYPE = C1.VALUETYPE);
[TYPE=="EmployeeType"] == Select Condition List with one Matching Condition for claims Type.
ISSUE (TYPE= "EmpType", VALUE = C1.VALUE, VALUETYPE = C1.VALUETYPE) == Rule Action that issues a claims using string literal and matching claim referred with the Identifier.

Lauf Zeit VorgangRuntime operation

Es ist wichtig, den Lauf Zeit Vorgang von Anspruchs Transformationen zu verstehen, um die Regeln effektiv zu verfassen.It is important to understand the runtime operation of claims transformations to author the rules effectively. Der Lauf Zeit Vorgang verwendet drei Sätze von Ansprüchen:The runtime operation uses three sets of claims:

  1. Eingabe Anspruchssatz: der Eingabe Satz der Ansprüche, die an den Anspruchs Transformations Vorgang übergeben werden.Input claims set: The input set of claims that are given to the claims transformation operation.

  2. Funktionierender Anspruchssatz: zwischen Ansprüche, die während der Anspruchs Transformation gelesen und geschrieben werden.Working claims set: Intermediate claims that are read from and written to during the claims transformation.

  3. Ausgabe Anspruchssatz: Ausgabe des Anspruchs Transformations Vorgangs.Output claims set: Output of the claims transformation operation.

Im folgenden finden Sie eine kurze Übersicht über den Vorgang der Transformation für Lauf Zeit Ansprüche:Here is a brief overview of the runtime claims transformation operation:

  1. Die Eingabe Ansprüche für die Transformation von Ansprüchen werden verwendet, um den Arbeits Anspruchssatz zu initialisieren.Input claims for claims transformation are used to initialize the working claims set.

    1. Beim Verarbeiten jeder Regel wird der Arbeits Anspruchssatz für die Eingabe Ansprüche verwendet.When processing each rule, the working claims set is used for the input claims.

    2. Die Auswahl Bedingungs Liste in einer Regel wird mit allen möglichen Sätzen von Ansprüchen aus dem Arbeits Anspruchssatz verglichen.The Selection Condition List in a rule is matched against all possible sets of claims from the working claims set.

    3. Jeder Satz übereinstimmender Ansprüche wird verwendet, um die Aktion in dieser Regel auszuführen.Each set of matching claims is used to run the action in that rule.

    4. Das Ausführen einer Regel Aktion führt zu einem Anspruch, der an den Ausgabe Anspruchssatz und den funktionierenden Anspruchssatz angefügt wird.Running a rule action results in one claim, which is appended to the output claims set and the working claims set. Daher wird die Ausgabe einer Regel als Eingabe für nachfolgende Regeln im Regelsatz verwendet.Thus, the output from a rule is used as input for subsequent rules in the rule set.

  2. Die Regeln im Regelsatz werden in sequenzieller Reihenfolge verarbeitet, beginnend mit der ersten Regel.The rules in the rule set are processed in sequential order starting with the first rule.

  3. Wenn der gesamte Regelsatz verarbeitet wird, wird der Ausgabe Anspruchssatz verarbeitet, um doppelte Ansprüche und andere Sicherheitsprobleme zu entfernen. Die resultierenden Ansprüche sind die Ausgabe des Anspruchs Transformationsprozesses.When the entire rule set is processed, the output claims set is processed to remove duplicate claims and for other security issues.The resulting claims are the output of the claims transformation process.

Komplexe Anspruchs Transformationen können basierend auf dem vorherigen Laufzeitverhalten geschrieben werden.It is possible to write complex claims transformations based on the previous runtime behavior.

Beispiel: Lauf Zeit VorgangExample: Runtime operation

Dieses Beispiel zeigt den Lauf Zeit Vorgang einer Anspruchs Transformation, die zwei Regeln verwendet.This example shows the runtime operation of a claims transformation that uses two rules.


     C1:[Type=="EmpType", Value=="FullTime",ValueType=="string"] =>
                Issue(Type=="EmployeeType", Value=="FullTime",ValueType=="string");
     [Type=="EmployeeType"] =>
               Issue(Type=="AccessType", Value=="Privileged", ValueType=="string");
Input claims and Initial Evaluation Context:
  {(Type= "EmpType"),(Value="FullTime"),(ValueType="String")}
{(Type= "Organization"),(Value="Marketing"),(ValueType="String")}
After Processing Rule 1:
 Evaluation Context:
  {(Type= "EmpType"),(Value="FullTime"),(ValueType="String")}
{(Type= "Organization"), (Value="Marketing"),(ValueType="String")}
  {(Type= "EmployeeType"),(Value="FullTime"),(ValueType="String")}
Output Context:
  {(Type= "EmployeeType"),(Value="FullTime"),(ValueType="String")}

After Processing Rule 2:
Evaluation Context:
  {(Type= "EmpType"),(Value="FullTime"),(ValueType="String")}
{(Type= "Organization"),(Value="Marketing"),(ValueType="String")}
  {(Type= "EmployeeType"),(Value="FullTime"),(ValueType="String")}
  {(Type= "AccessType"),(Value="Privileged"),(ValueType="String")}
Output Context:
  {(Type= "EmployeeType"),(Value="FullTime"),(ValueType="String")}
  {(Type= "AccessType"),(Value="Privileged"),(ValueType="String")}

Final Output:
  {(Type= "EmployeeType"),(Value="FullTime"),(ValueType="String")}
  {(Type= "AccessType"),(Value="Privileged"),(ValueType="String")}

Semantik für spezielle RegelnSpecial rules semantics

Im folgenden finden Sie eine spezielle Syntax für Regeln:The following are special syntax for rules:

  1. Leerer Regelsatz = = keine Ausgabe AnsprücheEmpty Rule Set == No Output Claims

  2. Leere Auswahl Bedingungs Liste = = jeder Anspruch stimmt mit der Liste der SELECT-Bedingungen überein.Empty Select Condition List == Every Claim matches the Select Condition List

    Beispiel: leere Auswahl Bedingungs ListeExample: Empty Select Condition List

    Die folgende Regel gleicht jeden Anspruch im Workingset ab.The following rule matches every claim in the working set.

    => Issue (Type = "UserType", Value = "External", ValueType = "string")
    
  3. Leere SELECT Match List = = jeder Anspruch stimmt mit der Liste der ausgewählten Bedingungen übereinEmpty Select Matching List == Every claim matches the Select Condition List

    Beispiel: leere übereinstimmende BedingungenExample: Empty Matching Conditions

    Die folgende Regel gleicht jeden Anspruch im Workingset ab.The following rule matches every claim in the working set. Dies ist die grundlegende "allow-all"-Regel, wenn Sie allein verwendet wird.This is the basic "Allow-all" rule if it is used alone.

    C1:[] => Issule (claim = C1);
    

SicherheitshinweiseSecurity considerations

Ansprüche, die in eine Gesamtstruktur eintretenClaims that enter a forest

Die Ansprüche, die von Prinzipale vorgelegt werden, die in einer Gesamtstruktur eingehenden werden, müssen gründlich geprüft werden, um sicherzustellen, dass wir nur die richtigen Ansprüche zulassen oder ausstellen.The claims presented by principals that are incoming to a forest need to be inspected thoroughly to ensure that we allow or issue only the correct claims. Nicht ordnungsgemäße Ansprüche können die Gesamtstruktur Sicherheit beeinträchtigen, und dies sollte bei der Erstellung von Transformations Richtlinien für Ansprüche, die eine Gesamtstruktur eintreten, eine hohe Priorität haben.Improper claims can compromise the forest security, and this should be a top consideration when authoring transformation policies for claims that enter a forest.

Active Directory verfügt über die folgenden Funktionen, um eine Fehlkonfiguration von Ansprüchen zu verhindern, die in eine Gesamtstruktur eintreten:Active Directory has the following features to prevent misconfiguration of claims that enter a forest:

  • Wenn für eine Gesamtstruktur-Vertrauensstellung für die Ansprüche, die in eine Gesamtstruktur eintreten, keine Anspruchs Transformations Richtlinie festgelegt ist, werden aus Sicherheits Active Directory Gründen alle Prinzipal Ansprüche gelöscht, die in die Gesamtstruktur eintreten.If a forest trust has no claims transformation policy set for the claims that enter a forest, for security purposes, Active Directory drops all the principal claims that enter the forest.

  • Wenn die Ausführung des Regelsatzes für Ansprüche, die in eine Gesamtstruktur eintritt, zu Ansprüchen führt, die nicht in der Gesamtstruktur definiert sind, werden die nicht definierten Ansprüche aus den Ausgabe Ansprüchen gelöscht.If running the rule set on claims that enters a forest results in claims that are not defined in the forest, the undefined claims are dropped from the output claims.

Ansprüche, die eine Gesamtstruktur verlassenClaims that leave a forest

Ansprüche, die eine Gesamtstruktur verlassen, stellen für die Gesamtstruktur weniger Sicherheitsbedenken dar als die Ansprüche, die in die Gesamtstruktur eintreten.Claims that leave a forest present a lesser security concern for the forest than the claims that enter the forest. Ansprüche dürfen die Gesamtstruktur unverändert belassen, auch wenn keine entsprechende Anspruchs Transformations Richtlinie vorhanden ist.Claims are allowed to leave the forest as-is even when there is no corresponding claims transformation policy in place. Es ist auch möglich, Ansprüche auszugeben, die nicht in der Gesamtstruktur als Teil der Transformation von Ansprüchen definiert sind, die die Gesamtstruktur verlassen.It is also possible to issue claims that are not defined in the forest as part of transforming claims that leave the forest. Dies dient zum einfachen Einrichten von Gesamtstruktur übergreifenden Vertrauens Stellungen mit Ansprüchen.This is to easily set up across-forest trusts with claims. Ein Administrator kann ermitteln, ob Ansprüche, die in die Gesamtstruktur eintreten, transformiert werden müssen, und die entsprechende Richtlinie einrichten.An administrator can determine if claims that enter the forest need to be transformed, and set up the appropriate policy. Beispielsweise könnte ein Administrator eine Richtlinie festlegen, wenn es erforderlich ist, einen Anspruch auszublenden, um die Offenlegung von Informationen zu verhindern.For example, an administrator could set a policy if there is a need to hide a claim to prevent information disclosure.

Syntax Fehler in Anspruchs TransformationsregelnSyntax errors in claims transformation rules

Wenn für eine bestimmte Anspruchs Transformations Richtlinie ein Regelsatz vorliegt, der syntaktisch falsch ist, oder wenn andere Syntax-oder Speicherprobleme vorliegen, wird die Richtlinie als ungültig eingestuft.If a given claims transformation policy has a rules set that is syntactically incorrect or if there are other syntax or storage issues, the policy is considered invalid. Dies wird anders behandelt als die zuvor erwähnten Standardbedingungen.This is treated differently than the default conditions mentioned earlier.

Active Directory kann die Absicht in diesem Fall nicht ermitteln und wechselt in einen ausfallsicheren Modus, in dem keine Ausgabe Ansprüche für diese Vertrauensstellung und Richtung des Durchlaufs generiert werden.Active Directory is unable to determine the intent in this case and goes into a fail-safe mode, where no output claims are generated on that trust+direction of traversal. Zum Beheben des Problems ist ein Administrator Eingriff erforderlich.Administrator intervention is required to correct the issue. Dies kann vorkommen, wenn LDAP zum Bearbeiten der Anspruchs Transformations Richtlinie verwendet wird.This could happen if LDAP is used to edit the claims transformation policy. Windows PowerShell-Cmdlets für Active Directory Überprüfung durchgeführt werden, um das Schreiben einer Richtlinie mit Syntax Problemen zu verhindern.Windows PowerShell cmdlets for Active Directory have validation in place to prevent writing a policy with syntax issues.

Weitere Überlegungen zur SpracheOther language considerations

  1. Es gibt mehrere Schlüsselwörter oder Sonderzeichen, die in dieser Sprache spezifisch sind (als Terminals bezeichnet).There are several key words or characters that are special in this language (referred to as terminals). Diese werden in der Tabelle " sprach Terminals " weiter unten in diesem Thema angezeigt.These are presented in the Language terminals table later in this topic. In den Fehlermeldungen werden die Tags für diese Terminals für die Mehrdeutigkeit verwendet.The error messages use the tags for these terminals for disambiguation.

  2. Terminals können mitunter als Zeichenfolgenliterale verwendet werden.Terminals can sometimes be used as string literals. Diese Verwendung kann jedoch mit der Sprachdefinition in Konflikt stehen oder unbeabsichtigte Folgen haben.However, such usage may conflict with the language definition or have unintended consequences. Diese Art der Verwendung wird nicht empfohlen.This kind of usage is not recommended.

  3. Von der Regel Aktion können keine Typkonvertierungen für Anspruchs Werte ausgeführt werden, und ein Regelsatz, der eine solche Regel Aktion enthält, wird als ungültig angesehen.The rule action cannot perform any type conversions on claim Values, and a rule set that contains such a rule action is considered invalid. Dies führt zu einem Laufzeitfehler, und es werden keine Ausgabe Ansprüche erzeugt.This would cause a runtime error, and no output claims are produced.

  4. Wenn eine Regel Aktion auf einen Bezeichner verweist, der nicht im Abschnitt Select Condition List der Regel verwendet wurde, handelt es sich um eine ungültige Verwendung.If a rule action refers to an Identifier that was not used in the Select Condition List portion of the rule, it is an invalid usage. Dies würde einen Syntax Fehler verursachen.This would cause a syntax error.

    Beispiel: falscher bezeichnerverweis Die folgende Regel veranschaulicht einen falschen Bezeichner, der in der Regel Aktion verwendet wird.Example: Incorrect Identifier reference The following rule illustrates an incorrect Identifier used in rule action.

    C1:[] => Issue (claim = C2);
    

Beispiele für TransformationsregelnSample transformation rules

  • Alle Ansprüche eines bestimmten Typs zulassenAllow all claims of a certain type

    Genauer TypExact type

    C1:[type=="XYZ"] => Issue (claim = C1);
    

    Verwenden von RegexUsing Regex

    C1: [type =~ "XYZ*"] => Issue (claim = C1);
    
  • Einen bestimmten Anspruchstyp nicht zulassen Genauer TypDisallow a certain claim type Exact type

    C1:[type != "XYZ"] => Issue (claim=C1);
    

    Verwenden von RegexUsing Regex

    C1:[Type !~ "XYZ?"] => Issue (claim=C1);
    

Beispiele für Regel Parser-FehlerExamples of rules parser errors

Anspruchs Transformationsregeln werden von einem benutzerdefinierten Parser analysiert, um auf Syntax Fehler zu überprüfen.Claims transformation rules are parsed by a custom parser to check for syntax errors. Dieser Parser wird von zugehörigen Windows PowerShell-Cmdlets ausgeführt, bevor Regeln in Active Directory gespeichert werden.This parser is run by related Windows PowerShell cmdlets before storing rules in Active Directory. Alle Fehler beim Parsen der Regeln, einschließlich Syntax Fehlern, werden in der Konsole gedruckt.Any errors in parsing the rules, including syntax errors, are printed on the console. Domänen Controller führen auch den Parser aus, bevor Sie die Regeln zum Transformieren von Ansprüchen verwenden, und protokollieren Fehler im Ereignisprotokoll (Ereignisprotokoll Nummern hinzufügen).Domain controllers also run the parser before using the rules for transforming claims, and they log errors in the event log (add event log numbers).

In diesem Abschnitt werden einige Beispiele für Regeln veranschaulicht, die mit falscher Syntax geschrieben werden, sowie die entsprechenden Syntax Fehler, die vom Parser generiert werden.This section illustrates some examples of rules that are written with incorrect syntax and the corresponding syntax errors that are generated by the parser.

  1. Beispiel:Example:

    c1;[]=>Issue(claim=c1);
    

    In diesem Beispiel ist ein Semikolon anstelle eines Doppelpunkts falsch verwendet.This example has an incorrectly used semicolon in place of a colon. Fehlermeldung: POLICY0002: die Richtlinien Daten konnten nicht analysiert werden. Zeilennummer: 1, Spaltennummer: 2, Fehler Token:;. Zeile: ' C1; [] =>Problem (Claim = C1); '. Parserfehler: ' POLICY0030: Syntax Fehler, unerwartetes '; ', es wird eine der folgenden voraussichtlich erwartet: ': '. 'Error message: POLICY0002: Could not parse policy data. Line number: 1, Column number: 2, Error token: ;. Line: 'c1;[]=>Issue(claim=c1);'. Parser error: 'POLICY0030: Syntax error, unexpected ';', expecting one of the following: ':' .'

  2. Beispiel:Example:

    c1:[]=>Issue(claim=c2);
    

    In diesem Beispiel ist das bezeichnertag in der Copy-Ausstellungs Anweisung nicht definiert.In this example, the Identifier tag in the copy issuance statement is undefined. Fehlermeldung: POLICY0011: keine Bedingungen in der Anspruchs Regel entsprechen dem Bedingungs Tag, das in der copyissuancestatement: ' C2 ' angegeben ist.Error message: POLICY0011: No conditions in the claim rule match the condition tag specified in the CopyIssuanceStatement: 'c2'.

  3. Beispiel:Example:

    c1:[type=="x1", value=="1", valuetype=="bool"]=>Issue(claim=c1)
    

    "bool" ist kein Terminal in der Sprache und kein gültiger ValueType."bool" is not a Terminal in the language, and it is not a valid ValueType. Gültige Terminals sind in der folgenden Fehlermeldung aufgeführt.Valid terminals are listed in the following error message. Fehlermeldung: POLICY0002: die Richtlinien Daten konnten nicht analysiert werden.Error message: POLICY0002: Could not parse policy data. Zeilennummer: 1, Spaltennummer: 39, Fehler Token: "bool".Line number: 1, Column number: 39, Error token: "bool". Zeile: ' C1: [Type = = "x1", Value = = "1", ValueType = = "bool"] =>Issue (Claim = C1); ".Line: 'c1:[type=="x1", value=="1",valuetype=="bool"]=>Issue(claim=c1);'. Parserfehler: ' POLICY0030: Syntax Fehler, unerwartete ' Zeichenfolge ', erwartet wurde eine der folgenden Elemente: ' INT64_TYPE ' ' UINT64_TYPE ' ' STRING_TYPE ' ' BOOLEAN_TYPE ' ' Bezeichner 'Parser error: 'POLICY0030: Syntax error, unexpected 'STRING', expecting one of the following: 'INT64_TYPE' 'UINT64_TYPE' 'STRING_TYPE' 'BOOLEAN_TYPE' 'IDENTIFIER'

  4. Beispiel:Example:

    c1:[type=="x1", value==1, valuetype=="boolean"]=>Issue(claim=c1);
    

    Die Ziffer 1 in diesem Beispiel ist kein gültiges Token in der Sprache, und eine solche Verwendung ist in einer übereinstimmenden Bedingung nicht zulässig.The numeral 1 in this example is not a valid token in the language, and such usage is not allowed in a matching condition. Er muss in doppelte Anführungszeichen eingeschlossen werden, um ihn zu einer Zeichenfolge zu machen.It has to be enclosed in double quotes to make it a string. Fehlermeldung: POLICY0002: die Richtlinien Daten konnten nicht analysiert werden. Zeilennummer: 1, Spaltennummer: 23, Fehler Token: 1. Zeile: ' C1: [Type = = ' x1 ', Value = = 1, ValueType = = "bool"] =>Issue (Claim = C1); ". Parserfehler: ' POLICY0029: unerwartete Eingabe.Error message: POLICY0002: Could not parse policy data. Line number: 1, Column number: 23, Error token: 1. Line: 'c1:[type=="x1", value==1, valuetype=="bool"]=>Issue(claim=c1);'.Parser error: 'POLICY0029: Unexpected input.

  5. Beispiel:Example:

    c1:[type == "x1", value == "1", valuetype == "boolean"] =>
    
         Issue(type = c1.type, value="0", valuetype == "boolean");
    

    In diesem Beispiel wurde ein doppeltes Gleichheitszeichen (= =) anstelle eines einzelnen Gleichheitszeichens (=) verwendet.This example used a double equal sign (==) instead of a single equal sign (=). Fehlermeldung: POLICY0002: die Richtlinien Daten konnten nicht analysiert werden. Zeilennummer: 1, Spaltennummer: 91, Fehler Token: = =. Zeile: ' C1: [Type = = ' x1 ', value = = ' 1 ', ValueType = = ' Boolean '] =>Issue (Type = C1. Type, Value = "0", ValueType = = "Boolean"); ". Parserfehler: ' POLICY0030: Syntax Fehler, unerwartetes ' = = ', erwartet wurde eines der folgenden Elemente: ' = 'Error message: POLICY0002: Could not parse policy data. Line number: 1, Column number: 91, Error token: ==. Line: 'c1:[type=="x1", value=="1", valuetype=="boolean"]=>Issue(type=c1.type, value="0", valuetype=="boolean");'. Parser error: 'POLICY0030: Syntax error, unexpected '==', expecting one of the following: '='

  6. Beispiel:Example:

    c1:[type=="x1", value=="boolean", valuetype=="string"] =>
    
          Issue(type=c1.type, value=c1.value, valuetype = "string");
    

    Dieses Beispiel ist syntaktisch und semantisch korrekt.This example is syntactically and semantically correct. Die Verwendung von "Boolean" als Zeichen folgen Wert ist jedoch an Verwirrung gebunden und sollte vermieden werden.However, using "boolean" as a string value is bound to cause confusion, and it should be avoided. Wie bereits erwähnt, sollten die Verwendung von sprach Terminals als Anspruchs Werte nach Möglichkeit vermieden werden.As previously mentioned, using language terminals as claims values should be avoided where possible.

Sprach TerminalsLanguage terminals

In der folgenden Tabelle sind die kompletten Terminal Zeichenfolgen und die zugehörigen sprach Terminals aufgelistet, die in der Anspruchs Transformations-Regel Sprache verwendet werden.The following table lists the complete set of terminal strings and the associated language terminals that are used in the claims transformation rules language. In diesen Definitionen werden UTF-16-Zeichen folgen ohne Beachtung der Groß-undThese definitions use case-insensitive UTF-16 strings.

StringString TerminalTerminal
"=>""=>" BeinIMPLY
";"";" SemikolonSEMICOLON
":"":" DoppelpunktCOLON
",""," KommaCOMMA
".""." GewinnDOT
"[""[" O_SQ_BRACKETO_SQ_BRACKET
"]""]" C_SQ_BRACKETC_SQ_BRACKET
"(""(" O_BRACKETO_BRACKET
")"")" C_BRACKETC_BRACKET
"==""==" EQEQ
"!=""!=" NEQNEQ
"=~""=~" REGEXP_MATCHREGEXP_MATCH
"!~""!~" REGEXP_NOT_MATCHREGEXP_NOT_MATCH
"=""=" EinräumenASSIGN
"&&""&&" ANDAND
betrifft"issue" PROBLEMISSUE
Sorte"type" TYPETYPE
Wert"value" VALUEVALUE
ValueType"valuetype" VALUE_TYPEVALUE_TYPE
erheben"claim" ErhebenCLAIM
"[_A-za-z] [_a-zA-Z0-9] *""[_A-Za-z][_A-Za-z0-9]*" IDENTIFIERIDENTIFIER
" \ " [^ \ "\n] * \ " ""\"[^\"\n]*\"" STRINGSTRING
UInt64"uint64" UINT64_TYPEUINT64_TYPE
Int64"int64" INT64_TYPEINT64_TYPE
„String“"string" STRING_TYPESTRING_TYPE
booleschen"boolean" BOOLEAN_TYPEBOOLEAN_TYPE

SprachsyntaxLanguage syntax

Die folgende Sprache für Anspruchs Transformationsregeln wird in ABNF-Form angegeben.The following claims transformation rules language is specified in ABNF form. In dieser Definition werden die in der vorherigen Tabelle angegebenen Terminals zusätzlich zu den hier definierten ABNF-Produktionen verwendet.This definition uses the terminals that are specified in the previous table in addition to the ABNF productions defined here. Die Regeln müssen in UTF-16 codiert werden, und die Zeichen folgen Vergleiche müssen bei der Groß-/Kleinschreibung nicht beachtet werden.The rules must be encoded in UTF-16, and the string comparisons must be treated as case insensitive.

Rule_set        = ;/*Empty*/
             / Rules
Rules         = Rule
             / Rule Rules
Rule          = Rule_body
Rule_body       = (Conditions IMPLY Rule_action SEMICOLON)
Conditions       = ;/*Empty*/
             / Sel_condition_list
Sel_condition_list   = Sel_condition
             / (Sel_condition_list AND Sel_condition)
Sel_condition     = Sel_condition_body
             / (IDENTIFIER COLON Sel_condition_body)
Sel_condition_body   = O_SQ_BRACKET Opt_cond_list C_SQ_BRACKET
Opt_cond_list     = /*Empty*/
             / Cond_list
Cond_list       = Cond
             / (Cond_list COMMA Cond)
Cond          = Value_cond
             / Type_cond
Type_cond       = TYPE Cond_oper Literal_expr
Value_cond       = (Val_cond COMMA Val_type_cond)
             /(Val_type_cond COMMA Val_cond)
Val_cond        = VALUE Cond_oper Literal_expr
Val_type_cond     = VALUE_TYPE Cond_oper Value_type_literal
claim_prop       = TYPE
             / VALUE
Cond_oper       = EQ
             / NEQ
             / REGEXP_MATCH
             / REGEXP_NOT_MATCH
Literal_expr      = Literal
             / Value_type_literal

Expr          = Literal
             / Value_type_expr
             / (IDENTIFIER DOT claim_prop)
Value_type_expr    = Value_type_literal
             /(IDENTIFIER DOT VALUE_TYPE)
Value_type_literal   = INT64_TYPE
             / UINT64_TYPE
             / STRING_TYPE
             / BOOLEAN_TYPE
Literal        = STRING
Rule_action      = ISSUE O_BRACKET Issue_params C_BRACKET
Issue_params      = claim_copy
             / claim_new
claim_copy       = CLAIM ASSIGN IDENTIFIER
claim_new       = claim_prop_assign_list
claim_prop_assign_list = (claim_value_assign COMMA claim_type_assign)
             /(claim_type_assign COMMA claim_value_assign)
claim_value_assign   = (claim_val_assign COMMA claim_val_type_assign)
             /(claim_val_type_assign COMMA claim_val_assign)
claim_val_assign    = VALUE ASSIGN Expr
claim_val_type_assign = VALUE_TYPE ASSIGN Value_type_expr
Claim_type_assign   = TYPE ASSIGN Expr