Język reguł przekształcania roszczeń

Dotyczy: ✅ Windows Server 2025, ✅ Windows Server 2022, ✅ Windows Server 2019, ✅ Windows Server 2016

Funkcja przekształcania roszczeń między lasami umożliwia łączenie klauzul dla dynamicznej kontroli dostępu przez granice lasów, poprzez ustawienie zasad przekształcania roszczeń dla zaufanielasowych. Podstawowym składnikiem wszystkich zasad są reguły zapisywane w języku reguł przekształcania oświadczeń. Ten temat zawiera szczegółowe informacje o tym języku i zawiera wskazówki dotyczące tworzenia reguł przekształcania oświadczeń.

Polecenia cmdlet programu Windows PowerShell dla zasad transformacji w relacjach zaufania między lasami oferują opcje ustawiania prostych zasad, które są wymagane w typowych scenariuszach. Te cmdlety tłumaczą dane wejściowe użytkownika na zasady i reguły w języku reguł przekształcania oświadczeń, a następnie przechowują je w Active Directory w określonym formacie. Aby uzyskać więcej informacji na temat cmdletów dotyczących przekształcania oświadczeń, zobacz Cmdlety AD DS dla dynamicznej kontroli dostępu.

W zależności od konfiguracji oświadczeń i wymagań dotyczących zaufania między lasami usług Active Directory, zasady przekształcania oświadczeń mogą być bardziej złożone niż zasady obsługiwane przez polecenia cmdlet Windows PowerShell dla usług Active Directory. Aby skutecznie tworzyć takie zasady, należy zrozumieć składnię i semantykę języka reguł przekształcania roszczeń. Ten język reguł przekształcania oświadczeń ("język") w usłudze Active Directory jest podzbiorem języka, który jest używany przez usługi Active Directory Federation Services do podobnych celów i ma bardzo podobną składnię i semantykę. Istnieje jednak mniej dozwolonych operacji, a dodatkowe ograniczenia składni są umieszczane w wersji języka usługi Active Directory.

W tym temacie krótko opisano składnię i semantyka języka reguł przekształcania oświadczeń w usłudze Active Directory oraz zagadnienia, które należy wziąć pod uwagę podczas tworzenia zasad. Udostępnia kilka zestawów przykładowych reguł umożliwiających rozpoczęcie pracy oraz przykłady nieprawidłowej składni i generowanych komunikatów, które ułatwiają odszyfrowywanie komunikatów o błędach podczas tworzenia reguł.

Narzędzia do tworzenia zasad przekształcania roszczeń

Cmdlety programu Windows PowerShell dla usługi Active Directory: Jest to preferowana i zalecana metoda tworzenia i ustawiania zasad przekształcania oświadczeń. Te polecenia cmdlet udostępniają przełączniki do prostych zasad oraz zapewniają weryfikację reguł ustawionych dla bardziej złożonych zasad.

LDAP: Zasady transformacji oświadczeń można edytować w usłudze Active Directory za pomocą protokołu LDAP (Lightweight Directory Access Protocol). Nie jest to jednak zalecane, ponieważ zasady mają kilka złożonych składników, a używane narzędzia mogą nie weryfikować zasad przed zapisaniem ich w usłudze Active Directory. Może to następnie wymagać znacznego czasu na diagnozowanie problemów.

Język reguł przekształcania roszczeń usługi Active Directory

Omówienie składni

Poniżej przedstawiono krótkie omówienie składni i semantyki języka:

Zestaw reguł przekształcania oświadczeń składa się z zero lub więcej reguł. Każda reguła ma dwie aktywne części: Lista warunków i Akcja reguły. Jeśli pole Wybierz listę warunków zwróci wartość TRUE, zostanie wykonana odpowiednia akcja reguły.
Lista warunków wyboru ma zero lub więcej warunków wyboru. Wszystkie warunki wyboru muszą mieć wartość TRUE, aby lista warunków wyboru została uznana za TRUE.
Każdy warunek wyboru ma zestaw składający się z zera lub więcej warunków zgodności. Wszystkie warunki zgodności muszą mieć wartość TRUE, aby warunek wyboru również miał wartość TRUE. Wszystkie te warunki są oceniane względem pojedynczego żądania. Oświadczenie, które pasuje do Select Condition, można oznaczyć identyfikatorem i odwołać się do niego w Rule Action.
Każdy warunek dopasowania określa warunek dopasowania typu, wartości lub typu wartości roszczenia, przy użyciu różnych operatorów warunkowych i literałów tekstowych.
- Po określeniu warunku dopasowania dla wartości należy również określić warunek dopasowania dla określonego typu wartości i na odwrót. Te warunki muszą znajdować się obok siebie w składni.
- Warunki dopasowania valueType muszą używać tylko określonych literałów ValueType.
Akcja reguły może skopiować jedno oświadczenie oznaczone identyfikatorem lub wystawiać jedno oświadczenie na podstawie oświadczenia oznaczonego identyfikatorem i/lub podanymi literałami ciągu.

Przykładowa reguła

W tym przykładzie przedstawiono regułę, która może służyć do tłumaczenia typu oświadczeń między dwoma lasami, pod warunkiem, że używają one tych samych oświadczeń ValueTypes i mają te same interpretacje dla oświadczeń Wartości dla tego typu. Reguła ma jeden zgodny warunek i instrukcję problemu, która używa literałów ciągu i pasujących referencji roszczeń.

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.

Operacja środowiska uruchomieniowego

Ważne jest, aby zrozumieć działanie w czasie wykonywania przekształceń twierdzeń, aby skutecznie tworzyć reguły. Operacja środowiska uruchomieniowego używa trzech zestawów oświadczeń:

Zestaw oświadczeń wejściowych: wejściowy zestaw oświadczeń, które są przekazywane do operacji przekształcania oświadczeń.
Zestaw roboczy oświadczeń: oświadczenia pośrednie, które są odczytywane i zapisywane podczas przekształcania oświadczeń.
Zestaw oświadczeń wyjściowych: dane wyjściowe operacji przekształcania oświadczeń.

Oto krótkie omówienie operacji przekształcania roszczeń w czasie wykonywania:

Wejściowe roszczenia do przekształcenia są używane do inicjowania roboczego zestawu roszczeń.
1. Podczas przetwarzania każdej reguły zestaw oświadczeń roboczych jest używany dla oświadczeń wejściowych.
2. Lista warunków wyboru w regule jest dopasowywana do wszystkich możliwych zestawów roszczeń z aktywnego zestawu roszczeń.
3. Każdy zestaw pasujących żądań jest używany do uruchomienia akcji zgodnie z tą regułą.
4. Uruchomienie akcji reguły powoduje utworzenie jednego oświadczenia, które jest dołączane do zestawu oświadczeń wyjściowych i zestawu oświadczeń roboczych. W związku z tym dane wyjściowe z reguły są używane jako dane wejściowe dla kolejnych reguł w zestawie reguł.
Reguły w zestawie reguł są przetwarzane w kolejności sekwencyjnej, począwszy od pierwszej reguły.
Po przetworzeniu całego zestawu reguł zestaw oświadczeń wyjściowych jest przetwarzany w celu usunięcia zduplikowanych oświadczeń i innych problemów z zabezpieczeniami. Wynikowe oświadczenia są danymi wyjściowymi procesu przekształcania oświadczeń.

Istnieje możliwość pisania złożonych transformacji roszczeń na podstawie poprzedniego zachowania w czasie wykonywania.

Przykład: operacja środowiska uruchomieniowego

W tym przykładzie pokazano operację czasu wykonywania przekształcenia roszczeń, która używa dwóch reguł.


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

Semantyka reguł specjalnych

Poniżej przedstawiono specjalną składnię reguł:

Pusty zestaw reguł (Brak roszczeń wyjściowych)
Pusta lista warunków wyboru == Każde roszczenie spełnia warunki listy wyboru

Przykład: Pusta lista warunków do wyboru

Poniższa reguła pasuje do każdego oświadczenia w zestawie roboczym.
```
=> Issue (Type = "UserType", Value = "External", ValueType = "string")
```
Empty Select Matching List == Każde żądanie pasuje do listy warunków wyboru

Przykład: Puste warunki dopasowywania

Poniższa reguła pasuje do każdego oświadczenia w zestawie roboczym. Jest to podstawowa reguła "Zezwalaj na wszystko", jeśli jest używana samodzielnie.
```
C1:[] => Issule (claim = C1);
```

Zagadnienia dotyczące zabezpieczeń

Roszczenia, które dotyczą lasu

Oświadczenia przedstawione przez osoby upoważnione, przybywające do lasu, muszą być dokładnie sprawdzone, aby upewnić się, że zezwalamy lub wystawiamy tylko poprawne oświadczenia. Nieprawidłowe roszczenia mogą naruszyć bezpieczeństwo lasu, dlatego powinno się to traktować jako najwyższy priorytet podczas opracowywania polityki dotyczącej roszczeń wpływających na las.

Usługa Active Directory ma następujące funkcje, aby zapobiec błędnej konfiguracji atrybutów, które wchodzą do lasu:

Jeśli relacja zaufania lasu nie ma ustawionej polityki przekształcania oświadczeń dla tych, które wchodzą do lasu, dla celów bezpieczeństwa usługa Active Directory zignoruje wszystkie oświadczenia główne wchodzące do lasu.
Jeśli uruchomienie zestawu reguł dla roszczeń, które wchodzą do lasu, powoduje, że roszczenia nie są zdefiniowane w lesie, niezdefiniowane roszczenia są usuwane z wynikowych.

Oświadczenia, które opuszczają las

Roszczenia, które opuszczają las, stanowią mniejsze zagrożenie dla bezpieczeństwa lasu niż roszczenia, które wchodzą do lasu. Roszczenia mogą opuszczać las as-is nawet wtedy, gdy nie ma odpowiedniej polityki przekształcania roszczeń. Istnieje również możliwość wystawiania oświadczeń, które nie są zdefiniowane w lesie w ramach przekształcania oświadczeń, które opuszczają las. Jest to łatwe konfigurowanie relacji zaufania między lasami przy użyciu oświadczeń. Administrator może określić, czy roszczenia, które wchodzą do lasu, muszą zostać przekształcone, i skonfigurować odpowiednią politykę. Na przykład administrator może ustawić zasady, jeśli istnieje potrzeba ukrycia oświadczenia, aby zapobiec ujawnieniu informacji.

Błędy składniowe w regułach przekształcania oświadczeń

Jeśli dana polityka przekształcania żądań ma zestaw reguł, który jest składniowo niepoprawny, lub występują inne problemy ze składnią albo przechowywaniem, polityka jest uznawana za nieprawidłową. Jest to traktowane inaczej niż w przypadku warunków domyślnych wymienionych wcześniej.

Usługa Active Directory nie może określić intencji w tym przypadku i włącza tryb awaryjny, w którym żadne roszczenia wyjściowe nie są generowane w kontekście tego zaufania oraz kierunku przechodzenia. Aby rozwiązać ten problem, wymagana jest interwencja administratora. Może się tak zdarzyć, jeśli protokół LDAP jest używany do edytowania zasad przekształcania oświadczeń. Polecenia cmdlet programu Windows PowerShell dla usługi Active Directory mają walidację, aby zapobiec zapisywaniu zasad z problemami ze składnią.

Inne zagadnienia dotyczące języka

Istnieje kilka słów kluczowych lub znaków, które są specjalne w tym języku (nazywane terminalami). Zostaną one przedstawione w tabeli zatytułowanej Terminale języka, która znajduje się w dalszej części tego tematu. Komunikaty o błędach używają tagów dla tych terminali do uściślania.
Czasami terminale mogą być używane jako literały ciągu. Jednak takie użycie może powodować konflikt z definicją języka lub mieć niezamierzone konsekwencje. Tego rodzaju użycie nie jest zalecane.
Akcja reguły nie może wykonać żadnych konwersji typów na wartości roszczeń, a zestaw reguł zawierający taką akcję jest uważany za nieprawidłowy. Spowoduje to błąd środowiska uruchomieniowego i nie są generowane żadne oświadczenia wyjściowe.
Jeśli akcja reguły odwołuje się do identyfikatora, który nie został użyty w części Wybierz listę warunków reguły, jest to nieprawidłowe użycie. Spowoduje to błąd składniowy.

Przykład: nieprawidłowe odwołanie do identyfikatora Poniższa reguła ilustruje nieprawidłowy identyfikator używany w akcji reguły.
```
C1:[] => Issue (claim = C2);
```

Przykładowe reguły przekształcania

Zezwalaj na wszystkie oświadczenia określonego typu

Dokładny typ
```
C1:[type=="XYZ"] => Issue (claim = C1);
```
Korzystanie z wyrażeń regularnych
```
C1: [type =~ "XYZ*"] => Issue (claim = C1);
```
Nie zezwalaj na określony typ roszczenia Dokładny typ
```
C1:[type != "XYZ"] => Issue (claim=C1);
```
Korzystanie z wyrażeń regularnych
```
C1:[Type !~ "XYZ?"] => Issue (claim=C1);
```

Przykłady błędów analizatora reguł

Reguły przekształcania roszczeń są analizowane przez niestandardowy parser w celu sprawdzenia błędów składniowych. Ten analizator jest uruchamiany przez powiązane polecenia cmdlet programu Windows PowerShell przed zapisaniem reguł w usłudze Active Directory. Wszelkie błędy podczas analizowania reguł, w tym błędów składniowych, są drukowane w konsoli programu . Kontrolery domeny uruchamiają również analizator przed użyciem reguł przekształcania oświadczeń i rejestrują błędy w dzienniku zdarzeń (dodaj numery dzienników zdarzeń).

W tej sekcji przedstawiono kilka przykładów reguł napisanych przy użyciu nieprawidłowej składni i odpowiednich błędów składni generowanych przez analizator.

Example:
```
c1;[]=>Issue(claim=c1);
```
W tym przykładzie nieprawidłowo użyto średnika zamiast dwukropka. Komunikat o błędzie:POLICY0002: Nie można zanalizować danych polityki.Numer wiersza: 1, Numer kolumny: 2, Token błędu: ;. Wiersz: „c1; []=>Issue(claim=c1);”.Błąd parsera: „POLICY0030: Błąd składniowy, nieoczekiwany ';', oczekiwano jednego z następujących: ':'.”
Example:
```
c1:[]=>Issue(claim=c2);
```
W tym przykładzie tag Identyfikator w instrukcji wystawiania kopii jest niezdefiniowany. Komunikat o błędzie: POLICY0011: Brak warunków w regule oświadczeń pasuje do tagu warunku określonego w zmiennej CopyIssuanceStatement: "c2".
Example:
```
c1:[type=="x1", value=="1", valuetype=="bool"]=>Issue(claim=c1)
```
"bool" nie jest terminalem języka i nie jest prawidłowym typem wartości. Prawidłowe terminale są wyświetlane w następującym komunikacie o błędzie. Komunikat o błędzie:POLICY0002: Nie można przeanalizować danych zasad. Numer wiersza: 1, Numer kolumny: 39, Token błędu: "bool". Linia: 'c1:[type=="x1", value=="1", valuetype=="bool"]=>Issue(claim=c1);'. Błąd analizatora: "POLICY0030: Błąd składniowy, nieoczekiwany ciąg, oczekiwany jeden z następujących: "INT64_TYPE" "UINT64_TYPE" "STRING_TYPE" "BOOLEAN_TYPE" "IDENTYFIKATOR"
Example:
```
c1:[type=="x1", value==1, valuetype=="boolean"]=>Issue(claim=c1);
```
Liczba 1 w tym przykładzie nie jest prawidłowym tokenem w języku, a takie użycie nie jest dozwolone w warunku dopasowania. Musi być ujęty w podwójne cudzysłowy, aby stał się ciągiem znaków. Komunikat o błędzie:POLICY0002: Nie można przeanalizować danych polityki.Numer wiersza: 1, Numer kolumny: 23, Błędny token: 1. Wiersz: 'c1:[type=="x1", value==1, valuetype=="bool"]=>Issue(claim=c1);'.Błąd parsowania: 'POLICY0029: Nieoczekiwane dane wejściowe.
Example:
```
c1:[type == "x1", value == "1", valuetype == "boolean"] =>

     Issue(type = c1.type, value="0", valuetype == "boolean");
```
W tym przykładzie użyto podwójnego znaku równości (==) zamiast pojedynczego znaku równości (=). Komunikat o błędzie:POLICY0002: Nie można przeanalizować danych zasad.Numer wiersza: 1, Numer kolumny: 91, Token błędu: ==. Wiersz: 'c1:[type=="x1", value=="1",valuetype=="boolean"]=>Issue(type=c1.type, value="0", valuetype=="boolean");'.Błąd analizatora: 'POLICY0030: Błąd składniowy, nieoczekiwany '==', oczekiwano jednego z następujących: '='
Example:
```
c1:[type=="x1", value=="boolean", valuetype=="string"] =>

      Issue(type=c1.type, value=c1.value, valuetype = "string");
```
Ten przykład jest składniowo i semantycznie poprawny. Jednak używanie "boolean" jako wartości typu string z pewnością powoduje nieporozumienia i należy jej unikać. Jak wspomniano wcześniej, należy unikać używania terminali językowych jako wartości oświadczeń, jeśli to możliwe.

Terminale językowe

W poniższej tabeli wymieniono kompletny zestaw ciągów terminalowych i skojarzonych terminali językowych, które są używane w języku reguł przekształcania oświadczeń. Te definicje używają ciągów UTF-16 bez uwzględniania wielkości liter.

String	Terminal
=>	IMPLY
";"	SEMICOLON
":"	COLON
","	COMMA
"."	DOT
"["	O_SQ_BRACKET
"]"	C_SQ_BRACKET
"("	O_BRACKET
")"	C_BRACKET
"=="	EQ
"!="	NEQ
"=~"	REGEXP_MATCH
"!~"	REGEXP_NOT_MATCH
"="	ASSIGN
"&&"	AND
"issue"	ISSUE
"type"	TYPE
"value"	VALUE
"valuetype"	VALUE_TYPE
"claim"	CLAIM
"[_A-Za-z][_A-Za-z0-9]*"	IDENTIFIER
"\"[^\"\n]*\""	STRING
"uint64"	UINT64_TYPE
"int64"	INT64_TYPE
"string"	STRING_TYPE
"boolean"	BOOLEAN_TYPE

Składnia języka

W formacie ABNF określono następujący język reguł przekształcania twierdzeń. Ta definicja używa terminali określonych w poprzedniej tabeli oprócz produkcji ABNF zdefiniowanych tutaj. Reguły muszą być zakodowane w formacie UTF-16, a porównania ciągów muszą być traktowane jako bez uwzględniania wielkości liter.

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

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-08-08