Bahasa Aturan Transformasi Klaim

Artikel
02/13/2024
Berlaku untuk:

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

Fitur transformasi klaim lintas hutan memungkinkan Anda menjembatani klaim untuk Kontrol Akses Dinamis di seluruh batas hutan dengan menetapkan kebijakan transformasi klaim pada kepercayaan lintas hutan. Komponen utama dari semua kebijakan adalah aturan yang ditulis dalam bahasa aturan transformasi klaim. Topik ini menyediakan detail tentang bahasa ini dan memberikan panduan tentang penulisan aturan transformasi klaim.

Cmdlet Windows PowerShell untuk kebijakan transformasi pada kepercayaan lintas hutan memiliki opsi untuk menetapkan kebijakan sederhana yang diperlukan dalam skenario umum. Cmdlet ini menerjemahkan input pengguna ke dalam kebijakan dan aturan dalam bahasa aturan transformasi klaim, lalu menyimpannya di Direktori Aktif dalam format yang ditentukan. Untuk informasi selengkapnya tentang cmdlet untuk transformasi klaim, lihat Cmdlet AD DS untuk Kontrol Akses Dinamis.

Bergantung pada konfigurasi klaim dan persyaratan yang ditempatkan pada kepercayaan lintas forest di forest Direktori Aktif Anda, kebijakan transformasi klaim Anda mungkin harus lebih kompleks daripada kebijakan yang didukung oleh cmdlet Windows PowerShell untuk Direktori Aktif. Untuk menulis kebijakan tersebut secara efektif, penting untuk memahami sintaks bahasa dan semantik aturan transformasi klaim. Ini mengklaim bahasa aturan transformasi ("bahasa") di Direktori Aktif adalah subset bahasa yang digunakan oleh Layanan Federasi Direktori Aktif untuk tujuan serupa, dan memiliki sintaks dan semantik yang sangat mirip. Namun, ada lebih sedikit operasi yang diizinkan, dan pembatasan sintaks tambahan ditempatkan dalam versi Direktori Aktif bahasa.

Topik ini secara singkat menjelaskan sintaks dan semantik bahasa aturan transformasi klaim di Direktori Aktif dan pertimbangan yang akan dibuat saat menulis kebijakan. Ini menyediakan beberapa set aturan contoh untuk membantu Anda memulai, dan contoh sintaks yang salah dan pesan yang dihasilkannya, untuk membantu Anda menguraikan pesan kesalahan saat Anda menulis aturan.

Alat untuk menulis kebijakan transformasi klaim

Cmdlet Windows PowerShell untuk Direktori Aktif: Ini adalah cara yang disukai dan direkomendasikan untuk menulis dan mengatur kebijakan transformasi klaim. Cmdlet ini menyediakan sakelar untuk kebijakan sederhana dan memverifikasi aturan yang ditetapkan untuk kebijakan yang lebih kompleks.

LDAP: Kebijakan transformasi klaim dapat diedit di Direktori Aktif melalui Lightweight Directory Access Protocol (LDAP). Namun, ini tidak disarankan karena kebijakan memiliki beberapa komponen yang kompleks, dan alat yang Anda gunakan mungkin tidak memvalidasi kebijakan sebelum menulisnya ke Direktori Aktif. Ini kemudian mungkin memerlukan banyak waktu untuk mendiagnosis masalah.

Bahasa aturan transformasi klaim Direktori Aktif

Gambaran umum sintaksis

Berikut adalah gambaran singkat sintaksis dan semantik bahasa:

Seperangkat aturan transformasi klaim terdiri dari nol atau lebih aturan. Setiap aturan memiliki dua bagian aktif: Pilih Daftar Kondisi dan Tindakan Aturan. Jika Daftar Pilih Kondisi dievaluasi ke TRUE, tindakan aturan terkait dijalankan.
Pilih Daftar Kondisi memiliki nol atau lebih Pilih Kondisi. Semua Pilih Kondisi harus dievaluasi ke TRUE untuk Daftar Pilih Kondisi untuk dievaluasi ke TRUE.
Setiap Kondisi Pilih memiliki satu set kondisi pencocokan nol atau lebih. Semua Kondisi pencocokan harus dievaluasi ke TRUE agar Kondisi Pilih dievaluasi ke TRUE. Semua kondisi ini dievaluasi terhadap satu klaim. Klaim yang cocok dengan Kondisi Pilih dapat ditandai oleh Pengidentifikasi dan dirujuk dalam Tindakan Aturan.
Setiap Kondisi Pencocokan menentukan kondisi yang cocok dengan Jenis atau Nilai atau ValueType klaim dengan menggunakan Operator Kondisi dan Literal String yang berbeda.
- Saat Anda menentukan Kondisi Pencocokan untuk Nilai, Anda juga harus menentukan Kondisi Pencocokan untuk ValueType tertentu dan sebaliknya. Kondisi ini harus berdampingan satu sama lain dalam sintaks.
- Kondisi pencocokan ValueType harus menggunakan literal ValueType tertentu saja.
Tindakan Aturan dapat menyalin satu klaim yang ditandai dengan Pengidentifikasi atau mengeluarkan satu klaim berdasarkan klaim yang ditandai dengan Pengidentifikasi dan/atau String Literal yang diberikan.

Contoh aturan

Contoh ini menunjukkan aturan yang dapat digunakan untuk menerjemahkan Jenis klaim di antara dua forest, asalkan mereka menggunakan ValueTypes klaim yang sama dan memiliki interpretasi yang sama untuk Nilai klaim untuk jenis ini. Aturan ini memiliki satu kondisi yang cocok dan pernyataan Masalah yang menggunakan Literal String dan referensi klaim yang cocok.

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.

Operasi runtime

Penting untuk memahami operasi runtime transformasi klaim untuk menulis aturan secara efektif. Operasi runtime menggunakan tiga set klaim:

Set klaim input: Kumpulan input klaim yang diberikan ke operasi transformasi klaim.
Kumpulan klaim kerja: Klaim menengah yang dibaca dari dan ditulis ke selama transformasi klaim.
Kumpulan klaim output: Output operasi transformasi klaim.

Berikut adalah gambaran umum singkat tentang operasi transformasi klaim runtime:

Klaim input untuk transformasi klaim digunakan untuk menginisialisasi kumpulan klaim yang berfungsi.
1. Saat memproses setiap aturan, kumpulan klaim kerja digunakan untuk klaim input.
2. Daftar Kondisi Pilihan dalam aturan dicocokkan dengan semua kumpulan klaim yang mungkin dari kumpulan klaim kerja.
3. Setiap set klaim yang cocok digunakan untuk menjalankan tindakan dalam aturan tersebut.
4. Menjalankan tindakan aturan menghasilkan satu klaim, yang ditambahkan ke kumpulan klaim output dan kumpulan klaim kerja. Dengan demikian, output dari aturan digunakan sebagai input untuk aturan berikutnya dalam seperangkat aturan.
Aturan dalam seperangkat aturan diproses secara berurutan dimulai dengan aturan pertama.
Ketika seluruh seperangkat aturan diproses, kumpulan klaim output diproses untuk menghapus klaim duplikat dan untuk masalah keamanan lainnya. Klaim yang dihasilkan adalah output dari proses transformasi klaim.

Dimungkinkan untuk menulis transformasi klaim kompleks berdasarkan perilaku runtime sebelumnya.

Contoh: Operasi runtime

Contoh ini menunjukkan operasi runtime transformasi klaim yang menggunakan dua aturan.


     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 aturan khusus

Berikut ini adalah sintaks khusus untuk aturan:

Seperangkat Aturan Kosong == Tidak Ada Klaim Output
Kosong Pilih Daftar Kondisi == Setiap Klaim cocok dengan Daftar Pilih Kondisi

Contoh: Kosongkan Pilih Daftar Kondisi

Aturan berikut cocok dengan setiap klaim dalam set kerja.
```
=> Issue (Type = "UserType", Value = "External", ValueType = "string")
```
Kosong Pilih Daftar yang Cocok == Setiap klaim cocok dengan Daftar Pilih Kondisi

Contoh: Kondisi Pencocokan Kosong

Aturan berikut cocok dengan setiap klaim dalam set kerja. Ini adalah aturan dasar "Izinkan-semua" jika digunakan sendiri.
```
C1:[] => Issule (claim = C1);
```

Pertimbangan keamanan

Klaim yang memasuki forest

Klaim yang disampaikan oleh prinsipal yang masuk ke forest perlu diperiksa secara menyeluruh untuk memastikan bahwa kami mengizinkan atau mengeluarkan klaim yang benar saja. Klaim yang tidak tepat dapat membahayakan keamanan hutan, dan ini harus menjadi pertimbangan utama saat menulis kebijakan transformasi untuk klaim yang memasuki forest.

Direktori Aktif memiliki fitur berikut untuk mencegah kesalahan konfigurasi klaim yang memasuki forest:

Jika kepercayaan hutan tidak memiliki kebijakan transformasi klaim yang ditetapkan untuk klaim yang memasuki forest, untuk tujuan keamanan, Direktori Aktif menghilangkan semua klaim utama yang memasuki forest.
Jika menjalankan aturan yang ditetapkan pada klaim yang memasukkan forest menghasilkan klaim yang tidak ditentukan di forest, klaim yang tidak ditentukan akan dihilangkan dari klaim output.

Klaim yang meninggalkan hutan

Klaim yang meninggalkan hutan menghadirkan kekhawatiran keamanan yang lebih rendah untuk hutan daripada klaim yang masuk ke hutan. Klaim diizinkan untuk meninggalkan forest apa adanya bahkan ketika tidak ada kebijakan transformasi klaim yang sesuai. Dimungkinkan juga untuk mengeluarkan klaim yang tidak didefinisikan di forest sebagai bagian dari mengubah klaim yang meninggalkan hutan. Ini untuk dengan mudah menyiapkan kepercayaan lintas hutan dengan klaim. Administrator dapat menentukan apakah klaim yang memasukkan forest perlu diubah, dan menyiapkan kebijakan yang sesuai. Misalnya, administrator dapat menetapkan kebijakan jika ada kebutuhan untuk menyembunyikan klaim untuk mencegah pengungkapan informasi.

Kesalahan sintaks dalam aturan transformasi klaim

Jika kebijakan transformasi klaim tertentu memiliki seperangkat aturan yang salah secara sintetis atau jika ada masalah sintaks atau penyimpanan lainnya, kebijakan tersebut dianggap tidak valid. Ini diperlakukan secara berbeda dari kondisi default yang disebutkan sebelumnya.

Direktori Aktif tidak dapat menentukan niat dalam hal ini dan masuk ke mode fail-safe, di mana tidak ada klaim output yang dihasilkan pada kepercayaan +arah traversal tersebut. Intervensi administrator diperlukan untuk memperbaiki masalah. Ini bisa terjadi jika LDAP digunakan untuk mengedit kebijakan transformasi klaim. Cmdlet Windows PowerShell untuk Direktori Aktif memiliki validasi untuk mencegah penulisan kebijakan dengan masalah sintaksis.

Pertimbangan bahasa lain

Ada beberapa kata kunci atau karakter yang khusus dalam bahasa ini (disebut sebagai terminal). Ini disajikan dalam tabel Terminal bahasa nanti dalam topik ini. Pesan kesalahan menggunakan tag untuk terminal ini untuk disambiguasi.
Terminal terkadang dapat digunakan sebagai literal string. Namun, penggunaan tersebut dapat bertentang dengan definisi bahasa atau memiliki konsekuensi yang tidak diinginkan. Penggunaan semacam ini tidak disarankan.
Tindakan aturan tidak dapat melakukan konversi jenis apa pun pada Nilai klaim, dan seperangkat aturan yang berisi tindakan aturan seperti itu dianggap tidak valid. Ini akan menyebabkan kesalahan runtime, dan tidak ada klaim output yang dihasilkan.
Jika tindakan aturan mengacu pada Pengidentifikasi yang tidak digunakan dalam bagian Pilih Daftar Kondisi dari aturan, itu adalah penggunaan yang tidak valid. Ini akan menyebabkan kesalahan sintaks.

Contoh: Referensi Pengidentifikasi yang salah Aturan berikut mengilustrasikan Pengidentifikasi yang salah yang digunakan dalam tindakan aturan.
```
C1:[] => Issue (claim = C2);
```

Contoh aturan transformasi

Izinkan semua klaim dari jenis tertentu

Jenis yang tepat

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

Menggunakan Regex

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

Melarang jenis klaim tertentu Jenis tepat

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

Menggunakan Regex

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

Contoh kesalahan pengurai aturan

Aturan transformasi klaim diurai oleh pengurai kustom untuk memeriksa kesalahan sintaks. Pengurai ini dijalankan oleh cmdlet Windows PowerShell terkait sebelum menyimpan aturan di Direktori Aktif. Setiap kesalahan dalam mengurai aturan, termasuk kesalahan sintaksis, dicetak di konsol. Pengendali domain juga menjalankan pengurai sebelum menggunakan aturan untuk mengubah klaim, dan mereka mencatat kesalahan di log peristiwa (menambahkan nomor log peristiwa).

Bagian ini mengilustrasikan beberapa contoh aturan yang ditulis dengan sintaks yang salah dan kesalahan sintaks yang sesuai yang dihasilkan oleh pengurai.

Contoh:
```
c1;[]=>Issue(claim=c1);
```
Contoh ini memiliki titik koma yang salah digunakan sebagai pengganti titik dua. Pesan kesalahan:POLICY0002: Tidak dapat mengurai data kebijakan.Nomor baris: 1, Nomor kolom: 2, Token kesalahan: ;. Baris: 'c1; []=>Issue(claim=c1);'.Kesalahan pengurai: 'POLICY0030: Sintaks error, unexpected ';', mengharapkan salah satu hal berikut: ':' .'
Contoh:
```
c1:[]=>Issue(claim=c2);
```
Dalam contoh ini, tag Pengidentifikasi dalam pernyataan penerbitan salinan tidak ditentukan. Pesan kesalahan: POLICY0011: Tidak ada kondisi dalam aturan klaim yang cocok dengan tag kondisi yang ditentukan dalam CopyIssuanceStatement: 'c2'.
Contoh:
```
c1:[type=="x1", value=="1", valuetype=="bool"]=>Issue(claim=c1)
```
"bool" bukan Terminal dalam bahasa, dan itu bukan ValueType yang valid. Terminal yang valid tercantum dalam pesan kesalahan berikut. Pesan kesalahan:POLICY0002: Tidak dapat mengurai data kebijakan. Nomor baris: 1, Nomor kolom: 39, Token kesalahan: "bool". Baris: 'c1:[type=="x1", value=="1",valuetype=="bool"]=>Issue(claim=c1);'. Kesalahan pengurai: 'POLICY0030: Kesalahan sintaks, 'STRING' yang tidak terduga, mengharapkan salah satu hal berikut: 'INT64_TYPE' 'UINT64_TYPE' 'STRING_TYPE' 'BOOLEAN_TYPE' 'IDENTIFIER'
Contoh:
```
c1:[type=="x1", value==1, valuetype=="boolean"]=>Issue(claim=c1);
```
Angka 1 dalam contoh ini bukan token yang valid dalam bahasa, dan penggunaan tersebut tidak diizinkan dalam kondisi yang cocok. Ini harus diapit dalam tanda kutip ganda untuk menjadikannya string. Pesan kesalahan:POLICY0002: Tidak dapat mengurai data kebijakan.Nomor baris: 1, Nomor kolom: 23, Token kesalahan: 1. Baris: 'c1:[type=="x1", value==1, valuetype=="bool"]=>Issue(claim=c1);'.Kesalahan pengurai: 'POLICY0029: Input tak terduga.
Contoh:
```
c1:[type == "x1", value == "1", valuetype == "boolean"] =>

     Issue(type = c1.type, value="0", valuetype == "boolean");
```
Contoh ini menggunakan tanda sama dengan ganda (==) alih-alih tanda sama dengan tunggal (=). Pesan kesalahan:POLICY0002: Tidak dapat mengurai data kebijakan.Nomor baris: 1, Nomor kolom: 91, Token kesalahan: ==. Baris: 'c1:[type=="x1", value=="1",valuetype=="boolean"]=>Issue(type=c1.type, value="0", valuetype=="boolean");'.Kesalahan pengurai: 'POLICY0030: Kesalahan sintaksis, '==' yang tidak terduga, mengharapkan salah satu hal berikut: '='
Contoh:
```
c1:[type=="x1", value=="boolean", valuetype=="string"] =>

      Issue(type=c1.type, value=c1.value, valuetype = "string");
```
Contoh ini secara sintetis dan semantik benar. Namun, menggunakan "boolean" sebagai nilai string terikat untuk menyebabkan kebingungan, dan harus dihindari. Seperti yang disebutkan sebelumnya, menggunakan terminal bahasa sebagai nilai klaim harus dihindari jika memungkinkan.

Terminal bahasa

Tabel berikut mencantumkan kumpulan lengkap string terminal dan terminal bahasa terkait yang digunakan dalam bahasa aturan transformasi klaim. Definisi ini menggunakan string UTF-16 yang tidak peka huruf besar/kecil.

String	Terminal
"=>"	BERARTI
";"	TITIK KOMA
":"	TITIK DUA
","	KOMA
"."	DOT
"["	O_SQ_BRACKET
"]"	C_SQ_BRACKET
"("	O_BRACKET
")"	C_BRACKET
"=="	EQ
"!="	NEQ
"=~"	REGEXP_MATCH
"!~"	REGEXP_NOT_MATCH
"="	MENETAPKAN
"&&"	AND
"masalah"	MASALAH
"type"	TYPE
"nilai"	VALUE
"valuetype"	VALUE_TYPE
"klaim"	KLAIM
"[_A-Za-z][_A-Za-z0-9]*"	PENGENAL
"\"[^\"\n]*\""	STRING
"uint64"	UINT64_TYPE
"int64"	INT64_TYPE
"string"	STRING_TYPE
"boolean"	BOOLEAN_TYPE

Sintaks bahasa

Bahasa aturan transformasi klaim berikut ditentukan dalam formulir ABNF. Definisi ini menggunakan terminal yang ditentukan dalam tabel sebelumnya selain produksi ABNF yang ditentukan di sini. Aturan harus dikodekan dalam UTF-16, dan perbandingan string harus diperlakukan sebagai tidak peka huruf besar/kecil.

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

Bagikan melalui