Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Dati attendibili inviati a Verified Access dai fornitori di servizi fiduciari
I dati attendibili sono dati inviati Accesso verificato da AWS da un provider fiduciario. I dati sulla fiducia vengono anche chiamati «affermazioni degli utenti» o «contesto di fiducia». I dati generalmente includono informazioni su un utente o su un dispositivo. Esempi di dati attendibili includono l'e-mail degli utenti, l'appartenenza ai gruppi, la versione del sistema operativo del dispositivo, lo stato di sicurezza del dispositivo e così via. Le informazioni inviate variano a seconda del fornitore di fiducia, quindi è necessario fare riferimento alla documentazione del fornitore di fiducia per un elenco completo e aggiornato dei dati sulla fiducia.
Tuttavia, utilizzando le funzionalità di registrazione dell'accesso verificato, puoi anche vedere quali dati attendibili vengono inviati dal tuo provider fiduciario. Ciò può essere utile quando si definiscono politiche che consentono o negano l'accesso alle applicazioni. Per informazioni sull'inclusione del contesto di fiducia nei log, consulta. [Abilita o disabilita il contesto di fiducia di accesso verificato](include-trust-context.md)
Questa sezione contiene esempi di dati sulla fiducia ed esempi per aiutarti a iniziare a scrivere le politiche. Le informazioni qui fornite sono solo a scopo illustrativo e non come riferimento ufficiale.
**Topics**
+ [Contesto predefinito](trust-data-default-context.md)
+ [AWS IAM Identity Center contesto](trust-data-iam.md)
+ [Contesto di terze parti](trust-data-third-party-trust.md)
+ [L'utente dichiara di aver superato](user-claims-passing.md)
# Contesto predefinito per i dati attendibili di Verified Access
Accesso verificato da AWS include alcuni elementi sulla richiesta corrente per impostazione predefinita in tutte le valutazioni Cedar indipendentemente dai provider di fiducia configurati. Se lo desideri, puoi scrivere una politica che valuti i dati.
Di seguito sono riportati alcuni esempi dei dati inclusi nella valutazione.
**Topics**
+ [Richiesta HTTP](#default-context-http-request)
+ [Flusso TCP](#default-context-tcp-flow)
## Richiesta HTTP
Quando viene valutata una politica, Verified Access include i dati sulla richiesta HTTP corrente nel contesto Cedar sotto la `context.http_request` chiave.
```
{
"title": "HTTP Request data included by Verified Access",
"type": "object",
"properties": {
"http_method": {
"type": "string",
"description": "The HTTP method",
"example": "GET"
},
"hostname": {
"type": "string",
"description": "The host subcomponent of the authority component of the URI",
"example": "example.com"
},
"path": {
"type": "string",
"description": "The path component of the URI",
"example": "app/images"
},
"query": {
"type": "string",
"description": "The query component of the URI",
"example": "value1=1&value2=2"
},
"x_forwarded_for": {
"type": "string",
"description": "The value of the X-Forwarded-For request header",
"example": "17.7.7.1"
},
"port": {
"type": "integer",
"description": "The endpoint port",
"example": 443
},
"user_agent": {
"type": "string",
"description": "The value of the User-Agent request header",
"example": "Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:47.0) Gecko/20100101 Firefox/47.0"
},
"client_ip": {
"type": "string",
"description": "The IP address connecting to the endpoint",
"example": "15.248.6.6"
}
}
}
```
**Esempio di policy**
Di seguito è riportato un esempio di politica Cedar che utilizza i dati della richiesta HTTP.
```
forbid(principal, action, resource) when {
context.http_request.http_method == "POST"
&& !(context.identity.roles.contains("Administrator"))
};
```
## Flusso TCP
Quando viene valutata una policy, Verified Access include i dati sul flusso TCP corrente nel contesto Cedar sotto la chiave. `context.tcp_flow`
```
{
"title": "TCP flow data included by Verified Access",
"type": "object",
"properties": {
"destination_ip": {
"type": "string",
"description": "The IP address of the target",
"example": "192.100.1.3"
},
"destination_port": {
"type": "string",
"description": "The target port",
"example": 22
},
"client_ip": {
"type": "string",
"description": "The IP address connecting to the endpoint",
"example": "172.154.16.9"
}
}
}
```
# AWS IAM Identity Center contesto per i dati attendibili di Verified Access
Quando viene valutata una policy, se la definisci AWS IAM Identity Center come trust provider, Accesso verificato da AWS include i dati sulla fiducia nel contesto Cedar nella chiave specificata come «Policy Reference Name» nella configurazione del trust provider. Se lo desideri, puoi scrivere una politica che valuti i dati sulla fiducia.
**Nota**
La chiave di contesto per il provider fiduciario deriva dal nome di riferimento della politica configurato al momento della creazione del provider fiduciario. Ad esempio, se configurate il nome di riferimento della policy come «idp123", la chiave di contesto sarà «context.idp123". Verificate di utilizzare la chiave contestuale corretta quando create la policy.
Lo [schema JSON](https://json-schema.org/) seguente mostra quali dati sono inclusi nella valutazione.
```
{
"title": "AWS IAM Identity Center context specification",
"type": "object",
"properties": {
"user": {
"type": "object",
"properties": {
"user_id": {
"type": "string",
"description": "a unique user id generated by AWS IdC"
},
"user_name": {
"type": "string",
"description": "username provided in the directory"
},
"email": {
"type": "object",
"properties": {
"address": {
"type": "email",
"description": "email address associated with the user"
},
"verified": {
"type": "boolean",
"description": "whether the email address has been verified by AWS IdC"
}
}
}
}
},
"groups": {
"type": "object",
"description": "A list of groups the user is a member of",
"patternProperties": {
"^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$": {
"type": "object",
"description": "The Group ID of the group",
"properties": {
"group_name": {
"type": "string",
"description": "The customer-provided name of the group"
}
}
}
}
}
}
}
```
Di seguito è riportato un esempio di policy che valuta in base ai dati di attendibilità forniti da. AWS IAM Identity Center
```
permit(principal, action, resource) when {
context.idc.user.email.verified == true
// User is in the "sales" group with specific ID
&& context.idc.groups has "c242c5b0-6081-1845-6fa8-6e0d9513c107"
};
```
**Nota**
Poiché i nomi dei gruppi possono essere modificati, IAM Identity Center fa riferimento ai gruppi utilizzando il loro ID di gruppo. Questo aiuta a evitare di violare una dichiarazione politica quando si cambia il nome di un gruppo.
# Contesto di fornitori di fiducia di terze parti per i dati attendibili ad accesso verificato
Questa sezione descrive i dati sulla fiducia forniti Accesso verificato da AWS da fornitori di fiducia di terze parti.
**Nota**
La chiave di contesto per il provider fiduciario deriva dal nome di riferimento della politica che si configura al momento della creazione del provider fiduciario. Ad esempio, se configurate il nome di riferimento della policy come «idp123", la chiave di contesto sarà «context.idp123". Assicurati di utilizzare la chiave contestuale corretta quando crei la policy.
**Topics**
+ [Estensione del browser](#trust-data-browser)
+ [Jamf](#trust-data-iam-jamf)
+ [CrowdStrike](#trust-data-iam-cs)
+ [JumpCloud](#trust-data-jc)
## Estensione del browser
Se prevedi di incorporare il contesto di attendibilità del dispositivo nelle tue politiche di accesso, avrai bisogno dell'estensione del browser AWS Verified Access o dell'estensione del browser di un altro partner. Verified Access attualmente supporta i browser Google Chrome e Mozilla Firefox.
Attualmente supportiamo tre provider affidabili per dispositivi: Jamf (che supporta i dispositivi macOS) CrowdStrike , (che supporta i dispositivi Windows 11 e Windows 10) JumpCloud e (che supporta sia Windows che macOS).
+ Se utilizzi **Jamf** Trust Data nelle tue norme, gli utenti devono scaricare e installare l'estensione del Accesso verificato da AWS browser dal [Chrome web store](https://chromewebstore.google.com/category/extensions) o dal sito [aggiuntivo per Firefox sui](https://addons.mozilla.org/en-US/firefox/) propri dispositivi.
+ Se utilizzi dati **CrowdStrike**attendibili nelle tue politiche, per prima cosa gli utenti devono installare l'[host di messaggistica Accesso verificato da AWS nativo](https://d3p8dc6667u8pq.cloudfront.net/WPF/latest/AWS_Verified_Access_Native_Messaging_Host.msi) (link per il download diretto). Questo componente è necessario per ottenere i dati di attendibilità dall' CrowdStrike agente in esecuzione sui dispositivi degli utenti. Quindi, dopo aver installato questo componente, gli utenti devono installare l'estensione Accesso verificato da AWS del browser dal [Chrome Web Store](https://chromewebstore.google.com/category/extensions) o dal [sito aggiuntivo di Firefox sui](https://addons.mozilla.org/en-US/firefox/) propri dispositivi.
+ Se lo utilizzi **JumpCloud**, i tuoi utenti devono avere l'estensione JumpCloud del browser del [Chrome web store](https://chromewebstore.google.com/category/extensions) o del [sito aggiuntivo per Firefox installata sui](https://addons.mozilla.org/en-US/firefox/) loro dispositivi.
## Jamf
Jamf è un fornitore di servizi fiduciari di terze parti. Quando viene valutata una politica, se definisci Jamf come fornitore di fiducia, Verified Access include i dati sulla fiducia nel contesto Cedar nella chiave specificata come «Nome di riferimento della politica» nella configurazione del provider fiduciario. Se lo desideri, puoi scrivere una politica che valuti i dati sulla fiducia. Lo [schema JSON](https://json-schema.org/) seguente mostra quali dati sono inclusi nella valutazione.
Per ulteriori informazioni sull'utilizzo di Jamf con Verified Access, consulta [Integrating AWS Verified Access with Jamf Device Identity](https://docs.jamf.com/technical-papers/jamf-security/aws-verified-access/index.html) sul sito Web Jamf.
```
{
"title": "Jamf device data specification",
"type": "object",
"properties": {
"iss": {
"type": "string",
"description": "\"Issuer\" - the Jamf customer ID"
},
"iat": {
"type": "integer",
"description": "\"Issued at Time\" - a unixtime (seconds since epoch) value of when the device information data was generated"
},
"exp": {
"type": "integer",
"description": "\"Expiration\" - a unixtime (seconds since epoch) value for when this device information is no longer valid"
},
"sub": {
"type": "string",
"description": "\"Subject\" - either the hardware UID or a value generated based on device location"
},
"groups": {
"type": "array",
"description": "Group IDs from UEM connector sync",
"items": {
"type": "string"
}
},
"risk": {
"type": "string",
"enum": [
"HIGH",
"MEDIUM",
"LOW",
"SECURE",
"NOT_APPLICABLE"
],
"description": "a Jamf-reported level of risk associated with the device."
},
"osv": {
"type": "string",
"description": "The version of the OS that is currently running, in Apple version number format (https://support.apple.com/en-us/HT201260)"
}
}
}
```
Di seguito è riportato un esempio di policy che valuta i dati di fiducia forniti da Jamf.
```
permit(principal, action, resource) when {
context.jamf.risk == "LOW"
};
```
Cedar fornisce una `.contains()` funzione utile per aiutare con enumerazioni come il punteggio di rischio di Jamf.
```
permit(principal, action, resource) when {
["LOW", "SECURE"].contains(context.jamf.risk)
};
```
## CrowdStrike
CrowdStrike è un fornitore di fiducia di terze parti. Quando viene valutata una politica, se la definisci CrowdStrike come fornitore di fiducia, Verified Access include i dati sulla fiducia nel contesto Cedar nella chiave specificata come «Nome di riferimento della politica» nella configurazione del provider fiduciario. Se lo desideri, puoi scrivere una politica che valuti i dati sulla fiducia. Lo [schema JSON](https://json-schema.org/) seguente mostra quali dati sono inclusi nella valutazione.
Per ulteriori informazioni sull'utilizzo CrowdStrike con Verified Access, consulta [Proteggere le applicazioni private con CrowdStrike e Accesso verificato da AWS](https://github.com/CrowdStrike/aws-verified-access/) sul GitHub sito Web.
```
{
"title": "CrowdStrike device data specification",
"type": "object",
"properties": {
"assessment": {
"type": "object",
"description": "Data about CrowdStrike's assessment of the device",
"properties": {
"overall": {
"type": "integer",
"description": "A single metric, between 1-100, that accounts as a weighted average of the OS and and Sensor Config scores"
},
"os": {
"type": "integer",
"description": "A single metric, between 1-100, that accounts for the OS-specific settings monitored on the host"
},
"sensor_config": {
"type": "integer",
"description": "A single metric, between 1-100, that accounts for the different sensor policies monitored on the host"
},
"version": {
"type": "string",
"description": "The version of the scoring algorithm being used"
}
}
},
"cid": {
"type": "string",
"description": "Customer ID (CID) unique to the customer's environment"
},
"exp": {
"type": "integer",
"description": "unixtime, The expiration time of the token"
},
"iat": {
"type": "integer",
"description": "unixtime, The issued time of the token"
},
"jwk_url": {
"type": "string",
"description": "URL that details the JWT signing"
},
"platform": {
"type": "string",
"enum": ["Windows 10", "Windows 11", "macOS"],
"description": "Operating system of the endpoint"
},
"serial_number": {
"type": "string",
"description": "The serial number of the device derived by unique system information"
},
"sub": {
"type": "string",
"description": "Unique CrowdStrike Agent ID (AID) of machine"
},
"typ": {
"type": "string",
"enum": ["crowdstrike-zta+jwt"],
"description": "Generic name for this JWT media. Client MUST reject any other type"
}
}
}
```
Di seguito è riportato un esempio di policy che valuta i dati di attendibilità forniti da. CrowdStrike
```
permit(principal, action, resource) when {
context.crowdstrike.assessment.overall > 50
};
```
## JumpCloud
JumpCloud è un fornitore di servizi fiduciari di terze parti. Quando viene valutata una politica, se la definisci JumpCloud come fornitore di fiducia, Verified Access include i dati sulla fiducia nel contesto Cedar nella chiave specificata come «Nome di riferimento della politica» nella configurazione del provider fiduciario. Se lo desideri, puoi scrivere una politica che valuti i dati sulla fiducia. Lo [schema JSON](https://json-schema.org/) seguente mostra quali dati sono inclusi nella valutazione.
Per ulteriori informazioni sull'utilizzo JumpCloud con AWS Verified Access, consulta [Integrazione JumpCloud e accesso AWS verificato sul JumpCloud sito](https://jumpcloud.com/support/integrate-with-aws-verified-access) Web.
```
{
"title": "JumpCloud device data specification",
"type": "object",
"properties": {
"device": {
"type": "object",
"description": "Properties of the device",
"properties": {
"is_managed": {
"type": "boolean",
"description": "Boolean to indicate if the device is under management"
}
}
},
"exp": {
"type": "integer",
"description": "Expiration. Unixtime of the token's expiration."
},
"durt_id": {
"type": "string",
"description": "Device User Refresh Token ID. Unique ID that represents the device + user."
},
"iat": {
"type": "integer",
"description": "Issued At. Unixtime of the token's issuance."
},
"iss": {
"type": "string",
"description": "Issuer. This will be 'go.jumpcloud.com'"
},
"org_id": {
"type": "string",
"description": "The JumpCloud Organization ID"
},
"sub": {
"type": "string",
"description": "Subject. The managed JumpCloud user ID on the device."
},
"system": {
"type": "string",
"description": "The JumpCloud system ID"
}
}
}
```
Di seguito è riportato un esempio di policy che valuta in base al contesto di fiducia fornito da. JumpCloud
```
permit(principal, action, resource) when {
context.jumpcloud.org_id == 'Unique_organization_identifier'
};
```
# L'utente dichiara il superamento e la verifica della firma in Verified Access
Dopo che un' Accesso verificato da AWS istanza ha autenticato correttamente un utente, invia le dichiarazioni utente ricevute dall'IdP all'endpoint Verified Access. Le dichiarazioni degli utenti sono firmate in modo che le applicazioni possano verificare le firme e verificare anche che le attestazioni siano state inviate da Verified Access. Durante questo processo, viene aggiunta la seguente intestazione HTTP:
`x-amzn-ava-user-context`
Questa intestazione contiene le affermazioni degli utenti in formato token web JSON (JWT). Il formato JWT include un'intestazione, un carico utile e una firma con codifica URL base64. Verified Access utilizza ES384 (algoritmo di firma ECDSA che utilizza l'algoritmo hash SHA-384) per generare la firma JWT.
Le applicazioni possono utilizzare queste dichiarazioni per la personalizzazione o altre esperienze specifiche dell'utente. Gli sviluppatori di applicazioni devono informarsi sul livello di unicità e verifica di ogni affermazione fornita dal fornitore di identità prima dell'uso. In generale, l'`sub`affermazione è il modo migliore per identificare un determinato utente.
**Topics**
+ [Dichiarazioni degli utenti JWT per OIDC](#oidc-sample)
+ [Dichiarazioni degli utenti di JWT per IAM Identity Center](#IdC-sample)
+ [Chiavi pubbliche](#public-keys)
+ [Recupero e decodifica di JWT](#sample-code)
## Esempio: dichiarazioni utente firmate JWT for OIDC
Gli esempi seguenti mostrano come appariranno l'intestazione e il payload per le dichiarazioni degli utenti OIDC nel formato JWT.
Intestazione di esempio:
```
{
"alg": "ES384",
"kid": "12345678-1234-1234-1234-123456789012",
"signer": "arn:aws:ec2:us-east-1:123456789012:verified-access-instance/vai-abc123xzy321a2b3c",
"iss": "OIDC Issuer URL",
"exp": "expiration" (120 secs)
}
```
Esempio di payload:
```
{
"sub": "xyzsubject",
"email": "xxx@amazon.com",
"email_verified": true,
"groups": [
"Engineering",
"finance"
],
"additional_user_context": {
"aud": "xxx",
"exp": 1000000000,
"groups": [
"group-id-1",
"group-id-2"
],
"iat": 1000000000,
"iss": "https://oidc-tp.com/",
"sub": "xyzsubject",
"ver": "1.0"
}
}
```
## Esempio: dichiarazioni utente firmate JWT for IAM Identity Center
Gli esempi seguenti mostrano come appariranno l'intestazione e il payload per le dichiarazioni degli utenti di IAM Identity Center nel formato JWT.
**Nota**
Per IAM Identity Center, nelle dichiarazioni verranno incluse solo le informazioni sull'utente.
Intestazione di esempio:
```
{
"alg": "ES384",
"kid": "12345678-1234-1234-1234-123456789012",
"signer": "arn:aws:ec2:us-east-1:123456789012:verified-access-instance/vai-abc123xzy321a2b3c",
"iss": "arn:aws:ec2:us-east-1:123456789012:verified-access-trust-provider/vatp-abc123xzy321a2b3c",
"exp": "expiration" (120 secs)
}
```
Esempio di payload:
```
{
"user": {
"user_id": "f478d4c8-a001-7064-6ea6-12423523",
"user_name": "test-123",
"email": {
"address": "test@amazon.com",
"verified": false
}
}
}
```
## Chiavi pubbliche
Poiché le istanze di accesso verificato non crittografano le dichiarazioni degli utenti, ti consigliamo di configurare gli endpoint di accesso verificato per utilizzare HTTPS. Se configuri il tuo endpoint di accesso verificato per utilizzare HTTP, assicurati di limitare il traffico verso l'endpoint utilizzando i gruppi di sicurezza.
Per garantire la sicurezza, è necessario verificare la firma prima di eseguire qualsiasi autorizzazione in base alle affermazioni e verificare che il `signer` campo nell'intestazione JWT contenga l'ARN dell'istanza Verified Access previsto.
Per ottenere la chiave pubblica, ottenere la chiave ID dall'intestazione JWT e utilizzarla per cercare la chiave pubblica dall'endpoint.
L'endpoint per ciascuno è il seguente: Regione AWS
`https://public-keys.prod.verified-access..amazonaws.com/`
## Esempio: recupero e decodifica di JWT
Il seguente esempio di codice mostra come ottenere l'ID della chiave, la chiave pubblica e il payload in Python 3.9.
```
import jwt
import requests
import base64
import json
# Step 1: Validate the signer
expected_verified_access_instance_arn = 'arn:aws:ec2:region-code:account-id:verified-access-instance/verified-access-instance-id'
encoded_jwt = headers.dict['x-amzn-ava-user-context']
jwt_headers = encoded_jwt.split('.')[0]
decoded_jwt_headers = base64.b64decode(jwt_headers)
decoded_jwt_headers = decoded_jwt_headers.decode("utf-8")
decoded_json = json.loads(decoded_jwt_headers)
received_verified_access_instance_arn = decoded_json['signer']
assert expected_verified_access_instance_arn == received_verified_access_instance_arn, "Invalid Signer"
# Step 2: Get the key id from JWT headers (the kid field)
kid = decoded_json['kid']
# Step 3: Get the public key from regional endpoint
url = 'https://public-keys.prod.verified-access.' + region + '.amazonaws.com/' + kid
req = requests.get(url)
pub_key = req.text
# Step 4: Get the payload
payload = jwt.decode(encoded_jwt, pub_key, algorithms=['ES384'])
```