Table of contents
TOC
Inhaltsverzeichnis reduzieren
Inhaltsverzeichnis erweitern

Ansprüche Transformation Regeln Sprache

Bill Mathers|Zuletzt aktualisiert: 10.03.2017
|
1 Mitwirkender

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

In der Gesamtstruktur Ansprüche Transformation Feature können Sie-Brücke für die dynamische Zugriffssteuerung über Gesamtstruktur hinweg Ansprüche durch Festlegen von Ansprüchen Transformation Richtlinien für auf allen Gesamtstruktur. Die primäre Komponente aller Richtlinien werden Regeln, die in Ansprüche Transformation Regeln Sprache geschrieben sind. Dieses Thema enthält Details zu dieser Sprache und bietet einen Überblick über Ansprüche Transformationsregeln zu erstellen.

Die Windows PowerShell-Cmdlets für die Transformation Richtlinien auf über Gesamtstruktur vertraut Optionen einfache Richtlinien festlegen, die in gängigen Szenarien erforderlich sind. Diese Cmdlets die Benutzereingabe in Richtlinien und Regeln in der Ansprüche Transformation Regeln Sprache übersetzen, und dann in die vorgeschriebenen Format in Active Directory gespeichert. Weitere Informationen zu Cmdlets für Ansprüche Transformation, finden Sie unter der AD DS-Cmdlets für die dynamische Zugriffssteuerung.

Abhängig von der Konfiguration Ansprüche und die Anforderungen, die in der in der Gesamtstruktur-Vertrauensstellung in Active Directory-Gesamtstrukturen platziert möglicherweise Ihre Ansprüche Transformation Richtlinien komplexer als die Richtlinien, die von der Windows PowerShell-Cmdlets für Active Directory unterstützt werden. Um diese Richtlinien effektiv zu erstellen, ist es wichtig zu verstehen, die Sprachsyntax für Ansprüche Transformation Regeln und die Semantik. Diese Ansprüche Transformation Regeln Sprache ("die Sprache") in Active Directory ist eine Teilmenge der Sprache, mit der Active Directory-Verbunddienste für ähnliche Zwecke, und bietet eine ähnliche Syntax und Semantik. Jedoch weniger Vorgänge zulässig sind, und zusätzliche Syntax Einschränkungen befinden sich in der Active Directory-Version der Sprache.

In diesem Thema wird kurz erläutert, die Syntax und die Semantik der Ansprüche Transformation Regeln Sprache in Active Directory und Überlegungen bei der Erstellung von Richtlinien. Es enthält mehrere Sätze von Beispielregeln, um Ihnen den Einstieg erleichtern und Beispiele für fehlerhafte Syntax und die Nachrichten, die sie generieren können Fehlermeldungen zu entschlüsseln, wenn Sie die Regeln erstellen.

Tools zum Erstellen von Ansprüchen Transformation Richtlinien

Windows PowerShell-Cmdlets für Active Directory: Dies ist die bevorzugte und empfohlene Methode zum Erstellen und Ansprüche Transformation-Richtlinien festlegen. Diese Cmdlets Switches für einfache Richtlinien bereitstellen und überprüfen Sie die Regeln, die für komplexere Richtlinien festgelegt werden.

LDAP: Ansprüche Transformation Richtlinien in Active Directory über Lightweight Directory Access Protocol (LDAP) bearbeitet werden können. Dies ist jedoch nicht empfohlen, da die Richtlinien verfügen über mehrere komplexe Komponenten und Tools, die Sie verwenden, die Richtlinie nicht überprüfen können, bevor Sie schreiben in Active Directory. Dies kann später viel Zeit zur Diagnose von Problemen erfordern.

Active Directory Ansprüche Transformation Regeln Sprache

Übersicht über die Syntax

Nachfolgend finden Sie eine kurze Übersicht über die Syntax und die Semantik der Sprache:

  • Die Ansprüche Transformation Regelsatz besteht aus null oder mehr Regeln. Jede Regel besteht aus zwei aktive Teilen: Bedingungsliste auswählen und Regelaktion. Wenn die Bedingungsliste auswählen zu TRUE ausgewertet wird die entsprechende Regelaktion ausgeführt wird.

  • Wählen Sie aus der Bedingung ist NULL oder mehr wählen Bedingungen. Alle der auswählen Bedingungen muss zu TRUE ausgewertet der Bedingungsliste auswählen zu TRUE ausgewertet wird.

  • Jede Bedingung auswählen hat eine Reihe von NULL oder mehr übereinstimmenden Bedingungen. Alle der übereinstimmenden Bedingungen muss für die Bedingung auswählen, zu TRUE ausgewertet wird auf TRUE ausgewertet werden. Alle diese Aktionen werden für einen einzelnen Anspruch ausgewertet. Einen entsprechenden Anspruch, das entspricht einer Bedingung auswählen markiert sein können, indem Sie eine Bezeichner und gemäß der Regelaktion.

  • Jede Bedingung übereinstimmenden gibt die Bedingung entsprechend der Typ oder Wert oder ValueType eines Anspruchs mit verschiedenen Bedingungsoperatoren und Zeichenfolgenliterale.

    • Bei der Angabe einer Bedingung übereinstimmenden für eine Wert, Sie müssen auch angeben eine Bedingung übereinstimmenden für einen bestimmten ValueType und umgekehrt. Diese Bedingungen müssen in der Syntax nebeneinander sein.

    • ValueType übereinstimmenden Bedingungen muss bestimmte verwenden ValueType nur Literale.

  • Ein Regelaktion können einen Anspruch, der mit markiert ist, kopieren Sie eine Bezeichner oder geben Sie einen Anspruch basierend auf einen Anspruch, der eine ID gekennzeichnet ist bzw. Zeichenfolgenliterale angegeben.

Beispielregel

Dieses Beispiel zeigt eine Regel, die die Ansprüchen Typ Gesamtstrukturen zu übersetzen, vorausgesetzt, sie die gleichen Ansprüchen Werttypen verwenden und verfügen über die gleichen Interpretationen für Ansprüche Werte für diesen Typ verwendet werden kann. Die Regel verfügt über eine Bedingung und eine Problem-Anweisung, die Zeichenfolgenliterale und eine entsprechende Ansprüche Referenz verwendet.

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.  

Runtime-Vorgang

Es ist wichtig zu verstehen, die Runtime-Vorgang Ansprüche Transformationen effektiv die Regeln zu erstellen. Die Runtime-Vorgang werden drei Gruppen von Ansprüchen verwendet:

  1. Eingabe Ansprüche Satz: gesetzt Ansprüche, die für den Betrieb des Ansprüche Transformation angegeben werden.

  2. Arbeiten Ansprüche Satz: fortgeschrittene Ansprüche, die von gelesen und geschrieben während der Transformation Ansprüche.

  3. Ausgabe Ansprüche Satz: Ausgabe des Vorgangs Transformation Ansprüche.

Hier ist eine kurze Übersicht über die Common Language Runtime Ansprüche Transformationsvorgang:

  1. Eingabe Ansprüche für Ansprüche Transformation werden verwendet, um den Arbeitssatz Ansprüche zu initialisieren.

    1. Bei der Verarbeitung der jede Regel wird der Arbeitssatz Ansprüche für die Eingabe Ansprüche verwendet.

    2. Die Bedingung Auswahlliste in einer Regel wird mit allen möglichen Sätze von Ansprüche aus den Arbeitssatz für Ansprüche verglichen.

    3. Jeder Gruppe des übereinstimmenden Ansprüche dient zum Ausführen der Aktion in der Regel.

    4. Ausführen einer Regel Aktion ein Anspruch, die an die Ausgabe angefügt wird vorgibt, und die arbeiten Ansprüche. Daher wird die Ausgabe einer Regel für nachfolgende Regeln in der Regelliste als Eingabe verwendet.

  2. Die Regeln in der Regelliste werden nacheinander ab der ersten Regel verarbeitet.

  3. Wenn die gesamte Regelliste verarbeitet wird, wird die Ausgabe Ansprüche Gruppe verarbeitet, um doppelte Ansprüche entfernen und andere Sicherheit issues.The Ansprüche werden die Ausgabe einer Transformation Ansprüche.

Es ist möglich, Schreiben Sie komplexe Ansprüche Transformationen auf das vorherige Verhalten von Common Language Runtime basiert.

Beispiel:-Runtime-Vorgang

Dieses Beispiel zeigt die Runtime-Vorgang eine Transformation Ansprüche, die zwei Regeln verwendet werden.


     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")}  

Spezielle Regeln Semantik

Im folgenden finden spezielle Syntax für die Regeln:

  1. Leeren Regelsatz == keine Ausgabe Ansprüche

  2. Leeren Sie die Bedingungsliste auswählen == alle Ansprüche entspricht der Liste der Bedingung auswählen

    Beispiel: Leere wählen Bedingungsliste

    Alle Ansprüche in den Arbeitssatz entspricht der folgende Regel.

    => Issue (Type = "UserType", Value = "External", ValueType = "string")  
    
  3. Leeren übereinstimmenden Liste auswählen == alle Ansprüche entspricht der Liste der Bedingung auswählen

    Beispiel: Leere übereinstimmenden Bedingungen

    Alle Ansprüche in den Arbeitssatz entspricht der folgende Regel. Dies ist die grundlegende "zulassen alle"-Regel, wenn es allein verwendet wird.

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

Überlegungen zur Sicherheit

Ansprüche, die eine Gesamtstruktur eingeben

Die Ansprüche von Sicherheitsprinzipale, die in einer Gesamtstruktur eingehende dargestellt müssen gründlich überprüft werden, um sicherzustellen, dass wir zulassen, oder geben Sie nur die richtige Ansprüche. Falsche Ansprüche die Gesamtstruktur-Sicherheit gefährden können sollte, und dies eine Rolle spielt beim Erstellen von Transformation Richtlinien für Ansprüche, die eine Gesamtstruktur eingeben.

Active Directory hat die folgenden Features fehlerhaften Konfiguration von Ansprüchen zu verhindern, die eine Gesamtstruktur eingeben:

  • Besitzt eine Gesamtstruktur-Vertrauensstellung keine Ansprüche Transformation Richtlinie für die Ansprüche, die Geben Sie einen Wald, aus Sicherheitsgründen wird Active Directory die wichtigsten Ansprüche, die die Gesamtstruktur eingeben.

  • Wenn die Regel für Ansprüche, die eine Gesamtstruktur Ergebnisse Ansprüche eingibt, die nicht in der Gesamtstruktur definiert sind, werden die undefined Ansprüche aus den Ausgabeansprüchen gelöscht.

Ansprüche, die eine Gesamtstruktur lassen

Ansprüche, die eine Gesamtstruktur lassen stellen einen geringere Sicherheitsaspekt für die Gesamtstruktur als die Ansprüche, die die Gesamtstruktur eingeben. Ansprüche sind, dürfen Sie die Gesamtstruktur als lassen – ist auch dann, wenn keine entsprechende Ansprüche Transformation Richtlinie vorhanden. Es ist auch möglich, Ansprüche aus, die nicht in der Gesamtstruktur als Teil des Transformieren von Ansprüchen, die die Gesamtstruktur lassen definiert sind. Dies ist für alle Gesamtstrukturen Vertrauensstellungen mit Ansprüchen problemlos einrichten. Ein Administrator kann erkennen, ob Ansprüche, die die Gesamtstruktur eingeben müssen umgewandelt werden, und richten Sie die entsprechende Richtlinie. Beispielsweise kann ein Administrator eine Richtlinie festgelegt, wenn einen entsprechenden Anspruch an Offenlegung von Informationen zu verhindern, dass ausblenden müssen.

Syntaxfehler in Ansprüche Transformationsregeln

Wenn eine bestimmte Ansprüche Transformation Richtlinie hat einen Satz von Regeln, der syntaktisch falsch ist oder wenn andere Syntax oder Speicher Probleme vorliegen, die Richtlinie ist ungültig. Dies ist anders als die Standard-Bedingungen, die bereits erwähnten behandelt.

Active Directory ist nicht in diesem Fall die Absicht zu ermitteln und wird in ein Abgesicherter Modus, wo keine Ansprüche Ausgabe erzeugt auf die Vertrauensstellung + Richtung durchlaufen. Administrator eingreifen ist erforderlich, um dieses Problem zu beheben. Dies kann passieren, wenn LDAP verwendet wird, um die Ansprüche Transformation Richtlinie zu bearbeiten. Windows PowerShell-Cmdlets für Active Directory verfügen Überprüfung zu verhindern, dass eine Richtlinie hinsichtlich Syntax schreiben.

Weitere Aspekte der Sprache

  1. Es gibt mehrere Schlüssel Wörter oder Zeichen, die in dieser Sprache (als Terminals bezeichnet) sind. Diese werden angezeigt, der Sprache Terminals Tabelle weiter unten in diesem Thema. Die Fehlermeldungen verwenden Sie die Tags für diese Terminals zur Klärung.

  2. Terminals können manchmal als Zeichenfolgenliterale verwendet werden. Diese Verwendung kann jedoch einen Konflikt mit der Sprachdefinition oder haben unerwünschten. Diese Art der Verwendung wird nicht empfohlen.

  3. Die Regelaktion kann keine typkonvertierungen führen Sie auf Werte in Anspruch und ein Regelsatz, das diese Regel-Aktion enthält ist ungültig. In diesem Fall einen Laufzeitfehler und keine Ausgabe Ansprüche hergestellt werden.

  4. Wenn eine Regelaktion auf einen Bezeichner, die nicht in der Liste der Bedingung auswählen Teil der Regel verwendet wurde verweist, ist es eine ungültige Verwendung. Dies würde dazu führen, dass einen Fehler.

    Beispiel: Falsche ID-Verweis
    Die folgende Regel veranschaulicht eine falsche Kennung, die in der Regelaktion verwendet.

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

Beispiel für die Transformationsregeln

  • Alle Ansprüche eines bestimmten Typs zulassen

    Genaue Typ

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

    Mithilfe von Regex

    C1: [type =~ "XYZ*"] => Issue (claim = C1);  
    
  • Verhindern, dass einen bestimmte Anspruchstyp können
    Genaue Typ

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

    Mithilfe von Regex

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

Beispiele für Fehlermeldungen Regeln

Die Transformationsregeln Ansprüche werden durch einen benutzerdefinierten Parser Syntaxfehler suchen analysiert. Dieser Parser wird von zugehörigen Windows PowerShell-Cmdlets ausgeführt, bevor Regeln in Active Directory gespeichert. Fehler bei der Analyse der Regeln einschließlich Syntaxfehler enthält, werden auf der Konsole gedruckt. Domänencontroller der Organisation auch den Parser vor der Verwendung der Regeln für die Umwandlung von Ansprüchen ausführen und sie Fehler melden Sie sich im Ereignisprotokoll (Ereignisprotokoll Zahlen hinzufügen).

In diesem Abschnitt werden einige Beispiele für Regeln, die Fehler mit falscher Syntax und die entsprechende Syntax geschrieben werden, die vom Parser generiert werden.

  1. Beispiel:

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

    In diesem Beispiel wird ein falsch verwendeten Semikolon anstelle von einem Doppelpunkt.
    Folgende Fehlermeldung angezeigt:
    POLICY0002: Die Daten konnte nicht analysiert werden.
    Zeilennummer: 1, Spalte-Anzahl: 2, Fehler Token:;. Zeile: "c1; [] = > Issue(claim=c1); ".
    Parserfehler: "POLICY0030: Syntaxfehler, unerwartete";", um einen der folgenden erwartet:": "."

  2. Beispiel:

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

    In diesem Beispiel ist das ID-Tag in der Kopie Ausstellung Anweisung nicht definiert.
    Fehlermeldung:
    POLICY0011: Keine Zustände in der Regel Anspruch entsprechen die Bedingungstag in der CopyIssuanceStatement angegeben: "c2".

  3. Beispiel:

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

    "Bool" ist ein Terminal in der Sprache, und es ist kein gültiger ValueType. Gültige Terminals sind in der Fehlermeldung aufgeführt.
    Folgende Fehlermeldung angezeigt:
    POLICY0002: Die Daten konnte nicht analysiert werden.
    Zeilennummer: Nummer 1: 39, Fehler Token: "Bool". Zeile: "c1: [Typ =="X1"Wert"1", Valuetype == =="Bool"] = > Issue(claim=c1);".
    Parserfehler: "POLICY0030: Syntaxfehler, unerwartete"STRING", erwartet einen der folgenden:"INT64_TYPE""UINT64_TYPE"'STRING_TYPE', 'BOOLEAN_TYPE'"BEZEICHNER"

  4. Beispiel:

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

    Die Zahl 1 in diesem Beispiel ist kein gültiges Token in der Sprache, und diese Verwendung ist nicht zulässig, in einer Bedingung. Er muss in Anführungszeichen, sorgen für eine Zeichenfolge eingeschlossen werden.
    Folgende Fehlermeldung angezeigt:
    POLICY0002: Die Daten konnte nicht analysiert werden.
    Zeilennummer: 1, Spalte-Anzahl: 23, Fehler Token: 1. Zeile: "c1: [Typ =="X1", Wert == 1, Valuetype =="Bool"] = > Issue(claim=c1);". **Parserfehler: "POLICY0029: unerwartete Eingaben.

  5. Beispiel:

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

    In diesem Beispiel wird ein double Gleichheitszeichen (==) anstelle von ein Gleichheitszeichen (=) verwendet.
    Folgende Fehlermeldung angezeigt:
    POLICY0002: Die Daten konnte nicht analysiert werden.
    Zeilennummer: 1, Spalte-Anzahl: 91, Fehler Token: ==. Zeile: "c1: [Typ =="X1"Wert"1", ==
    ValueType == "Boolean"] = > Problem (type=c1.type, Value = "0", Valuetype == "Boolean"); ".
    Parserfehler: "POLICY0030: Syntaxfehler, unerwartete"==", erwartet einen der folgenden:"="

  6. Beispiel:

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

    In diesem Beispiel wird die Syntax und semantisch richtig ist. Verwenden jedoch "Boolean" ein Zeichenfolgenwert fest, Verwechslungen gebunden ist, und es sollte vermieden werden. Wie bereits erwähnt, mit Sprache Terminals Ansprüche-Werte nach Möglichkeit vermieden werden sollte.

Sprache Terminals

Die folgende Tabelle enthält den vollständigen Satz von Terminal Zeichenfolgen und die zugehörigen Sprachpakete Terminals, die in der Sprache für Ansprüche Transformation Regeln verwendet werden. Diese Definitionen verwenden Groß- und Kleinschreibung UTF-16 Zeichenfolgen.

ZeichenfolgeTerminaldienste
"=>"IMPLIZIEREN
";"DURCH SEMIKOLONS
":"DOPPELPUNKT
","KOMMA
"."PUNKT
"["O_SQ_BRACKET
"]"C_SQ_BRACKET
"("O_BRACKET
")"C_BRACKET
"=="EQ
"!="NEQ
"=~"REGEXP_MATCH
"!~"REGEXP_NOT_MATCH
"="WEISEN SIE
"&&"UND
"Problem"DAS PROBLEM
"Type"TYP
"Value"WERT
"Valuetype"WERTTYP
"Ansprüche"ANSPRÜCHE
"[_A-Za-z][_A-Za-z0-9]*"BEZEICHNER
"\"[^\"\n]*\""ZEICHENFOLGE
"uint64"UINT64_TYPE
"int64"INT64_TYPE
"String"STRING_TYPE
"boolean"BOOLEAN_TYPE

Sprachsyntax

Die folgenden Ansprüche Transformation Regeln Sprache wird in Form von ABNF angegeben. Diese Definition verwendet die Terminals, die in der obigen Tabelle neben die hier definierte ABNF-Produktionen angegeben werden. Die Regeln müssen in UTF-16 codiert sein und Zeichenfolgenvergleiche müssen als Groß-/ Kleinschreibung behandelt werden.

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  
© 2017 Microsoft