Type d'autorisation d'échange de jetons : Échange d'un jeton Web JSON pour un UPST

Flux

Avis de non-responsabilité : Tous les noms de produit, logos et marques et logos sont des marques de commerce de leurs propriétaires respectifs et sont utilisés ici à titre informatif seulement.

Étapes d'échange de jetons JWT vers UPST

Pour échanger un jeton JWT contre un UPST, procédez comme suit :

1. Step1 : (Facultatif) Création d'un domaine d'identité
2. Étape 2 : Créer des applications de domaine d'identité
3. Étape 3 : (Facultatif) Utiliser un utilisateur de service
4. Étape 4 : Créer une configuration d'approbation de propagation d'identité
5. Étape 5 : Génération d'une clé publique
6. Étape 6 : Générer un jeton JWT pour échanger contre UPST
7. Étape 7 : Obtenir OCI UPST

Step1 : (Facultatif) Création d'un domaine d'identité

Créez un nouveau domaine d'identité s'il n'existe pas. Voir Création d'un domaine d'identité.

Étape 2 : Créer des applications de domaine d'identité

Un client OAuth est une application approuvée enregistrée auprès d'Identity Cloud Service pour authentifier et obtenir des jetons d'accès à l'aide de flux OAuth 2.0. Vous utilisez ce client pour :

• Obtenez un jeton d'accès pour appeler les API d'administration IDCS.

• Fédérez l'identité de l'application pour échanger JWT contre UPST.

Voir Ajouter une application confidentielle. Après avoir créé l'application, enregistrez l'ID client et la clé secrète client dans un emplacement sécurisé. Vous avez besoin de deux applications de domaine d'identité suivant le principe du moindre privilège (PoLP) :

• Application dotée du rôle d'application Administrateur de domaine d'identité (IDA). Vous utilisez un jeton d'accès généré à l'aide de cette application pour effectuer des opérations sur l'approbation de propagation d'identité (étape 4 : Créer une configuration d'approbation de propagation d'identité) et l'utilisateur de service (étape 3 : (Facultatif) Utiliser un utilisateur de service).
• Une autre application de domaine d'identité sans le rôle d'application d'administrateur de domaine d'identité ou un rôle d'administrateur. Vous utilisez les données d'identification de client pour cette deuxième application de domaine d'identité pour appeler l'API d'échange de jetons. Vous devez autoriser l'utilisation de cette application avec l'échange de jetons en configurant un ID client pour l'application dans IdentityPropagationTrust.

En outre, l'application dotée d'un rôle d'application d'administrateur de domaine d'identité élevé peut également effectuer JWT vers UPST Token Exchange.

Génération d'un jeton d'accès avec le rôle d'administrateur de domaine d'identité

Utilisez l'application avec le rôle d'application Administrateur de domaine d'identité défini pour générer un jeton d'accès. Voir Génération de jetons d'accès. Utilisez le jeton d'accès généré pour effectuer des opérations CRUD (Créer, Remplacer, Mettre à jour, Supprimer) sur IdentityPropagationTrusts (Étape 4 : Créer une configuration de confiance de propagation d'identité) et l'utilisateur de service (Étape 3 : (Facultatif) Utiliser un utilisateur de service).

Étape 3 : (Facultatif) Utiliser un utilisateur de service

Un utilisateur de service est un utilisateur de domaine d'identité sans privilèges de connexion interactive. Ils ont des privilèges minimes.

Les utilisateurs du service peuvent être accordés aux groupes et aux applications. Les applications peuvent utiliser des utilisateurs de service ou l'utilisateur connecté peut emprunter l'identité de ceux-ci pour obtenir un jeton UPST temporaire.

Les utilisateurs du service ont les caractéristiques suivantes :

• Vous devez avoir un userName. Le prénom et le nom de famille ne sont pas obligatoires.
• Peut avoir une adresse de courriel (facultatif).
• Peut être membre de groupes et de rôles d'application.
• Impossible d'avoir des clés d'API.
• Impossible d'utiliser des points d'extrémité en libre-service.
• Impossible d'avoir des mots de passe et les politiques de mot de passe ne s'appliquent pas.

Exemple de demande : Créer un utilisateur de service

Voici un exemple de demande avec les attributs minimum requis pour créer un utilisateur de service avec l'attribut serviceUser réglé à true.

## POST on https://<domainURL>/admin/v1/Users
 
## Header:
"Authorization: Bearer <IDA_Access_Token>" \
"Content-Type: application/json"
 
## Payload:
{
    "schemas": [
        "urn:ietf:params:scim:schemas:core:2.0:User"
    ],
    "urn:ietf:params:scim:schemas:oracle:idcs:extension:user:User": {
        "serviceUser": true
    },
    "userName": "myServiceUserName"
}

Exemple de réponse : Créer un utilisateur de service

Voici un exemple de réponse lors de la création d'un utilisateur de service.

{
    "idcsCreatedBy": {
        "type": "App",
        "display": "admin"
    },
    "id": "<user_id>",
    "urn:ietf:params:scim:schemas:oracle:idcs:extension:user:User": {
        "isFederatedUser": false,
        "isGroupMembershipSyncedToUsersGroups": true,
        "serviceUser": true
    },
    "meta": {
        "created": "2023-12-07T06:52:55.380Z",
        "lastModified": "2023-12-07T06:52:55.380Z",
        "version": "<version>",
        "resourceType": "User",
        "location": "https://<domainURL>/admin/v1/Users/<user_id>"
    },
    "active": true,
    "idcsLastModifiedBy": {
        "display": "admin",
        "type": "App"
    },
    "urn:ietf:params:scim:schemas:oracle:idcs:extension:userState:User": {
        "locked": {
            "on": false
        }
    },
    "ocid": "ocid1.user.region1...<ocid>",
    "userName": "myServiceUserName",
    "schemas": [
        "urn:ietf:params:scim:schemas:core:2.0:User",
        "urn:ietf:params:scim:schemas:oracle:idcs:extension:userState:User",
        "urn:ietf:params:scim:schemas:oracle:idcs:extension:capabilities:User",
        "urn:ietf:params:scim:schemas:oracle:idcs:extension:user:User"
    ]
}

Étape 4 : Créer une configuration d'approbation de propagation d'identité

La configuration de l'approbation de propagation d'identité permet d'établir l'approbation entre l'identité OCI et les fournisseurs en nuage externes, la validation du jeton du fournisseur en nuage et le mappage de l'identité de l'utilisateur du fournisseur en nuage avec les domaines d'identité service de l'identité de l'utilisateur.

"oauthClients": [
 "oauthclient-id"
 ],

Exemple de demande : Créer une configuration d'approbation de propagation d'identité

## POST on https://<secureDomainURL>/admin/v1/IdentityPropagationTrusts
## Header:
"Authorization: Bearer <IDA_Access_Token>" \
"Content-Type: application/json"
 
## Payload:
{
  "active": true,
  "allowImpersonation": true,
  "issuer": "<<UNIQUE_ISSUER_VALUE>>",
  "name": "Token Trust JWT to UPST",
  "oauthClients": [
  "<oauthclient-id>"
  ],
  "publicCertificate": "<public_certificate_value>",
  "publicKeyEndpoint": "https://example.identityprovider.com/publickey/<publickey_value>",
  "clientClaimName": "client_claim_name",
  "clientClaimValues": [
  "<<client_claim_value>>"
  ],
  "impersonationServiceUsers": [
    {
      "rule": "sub eq *",
      "value": "<<user_id>>"
    }
  ],
  "subjectType": "User",
  "type": "JWT",
  "schemas": [
  "urn:ietf:params:scim:schemas:oracle:idcs:IdentityPropagationTrust"
  ]
}

Exemple de réponse

{
  "active": true,
  "allowImpersonation": true,
  "issuer": "<<UNIQUE_ISSUER_VALUE>>",
  "name": "Token Trust JWT to UPST",
  "oauthClients": [
  "<oauthclient-id>"
  ],
  "publicCertificate": "<public_certificate_value>",
  "publicKeyEndpoint": "https://example.identityprovider.com/publickey/<publickey_value>",
  "clientClaimName": "client_claim_name",
  "clientClaimValues": [
  "<<client_claim_value>>"
  ],
  "subjectType": "User",
  "type": "JWT",
  "schemas": [
  "urn:ietf:params:scim:schemas:oracle:idcs:IdentityPropagationTrust"
  ]
}

Exemple de demande : Pour allowImpersonation, réglez la valeur à false Identity Propagation Trust Configuration

{
    "active": true,
    "allowImpersonation": false,
    "issuer": "<<issuer_value>>",
    "name": "Token Trust JWT to UPST",
    "oauthClients": [
        "25d123....."
    ],
    "publicKeyEndpoint": "https://<<secureDomainURL>>/admin/v1/SigningCert/jwk",
    "clientClaimName": "client_name",
    "clientClaimValues": ["<<client_name_value>>"],
    "subjectClaimName": "sub",
    "subjectMappingAttribute": "userName",
    "subjectType": "User",
    "type": "JWT",
    "schemas": [
        "urn:ietf:params:scim:schemas:oracle:idcs:IdentityPropagationTrust"
    ]
}

Exemple de demande : Extraction d'une configuration d'approbation de propagation d'identité

## GET on https://<secureDomainURL>/admin/v1/IdentityPropagationTrusts/{{id}}
## Header:
"Authorization: Bearer <IDA_Access_Token>"

Si allowImpersonation est réglé à "true" et que impersonationServiceUsers est défini dans la fiducie de propagation d'identité, utilisez l'exemple de demande suivant.

## GET on https://<secureDomainURL>/admin/v1/IdentityPropagationTrusts/{{id}}?attributes=impersonationServiceUsers
## Header:
"Authorization: Bearer <IDA_Access_Token>"

Exemple de réponse

{
  "active": true,
  "allowImpersonation": true,
  "issuer": "<<UNIQUE_ISSUER_VALUE>>",
  "name": "Token Trust JWT to UPST",
  "oauthClients": [
  "<oauthclient-id>"
  ],
  "publicCertificate": "<public_certificate_value>",
  "publicKeyEndpoint": "https://example.identityprovider.com/publickey/<publickey_value>",
  "clientClaimName": "client_claim_name",
  "clientClaimValues": [
  "<<client_claim_value>>"
  ],
  "subjectClaimName": "sub",
  "subjectMappingAttribute": "userName",
  "subjectType": "User",
  "type": "JWT",
  "impersonationServiceUsers": [
  {
       "ocid": "ocid1.user.oc1..this.is.user.ocid",
       "rule": "sub eq *",
       "value": "<<user_id>>",
       "$ref": "https://<<secureDomainURL>>/admin/v1/Users/<<user_id>>"
  }
  "schemas": [
  "urn:ietf:params:scim:schemas:oracle:idcs:IdentityPropagationTrust"
  ]
}

Étape 5 : Génération d'une clé publique

Utilisez les commandes suivantes dans un terminal (Linux/macOS) ou Git Bash sous Windows :

# Generate a 2048-bit RSA private key
openssl genrsa -out private_key.pem 2048
 
# Extract the public key in PEM format
openssl rsa -in private_key.pem -pubout -out public_key.pem

Après les avoir exécutées :

• private_key.pem est la clé privée utilisée pour signer le jeton JWT.

• public_key.pem est la clé publique utilisée par OCI pour vérifier la signature JWT.

Étape 6 : Générer un jeton JWT pour échanger contre UPST

Générez un jeton JWT avec le flux de travail des données d'identification par mot de passe du responsable de la ressource, le flux de travail des données d'identification du client et le flux de travail d'assertion d'utilisateur d'OCI, ou avec toute IdPs externe telle que Microsoft Entra ID, Google Firebase Authentication, AWS Cognito, Okta, etc. Le jeton JWT généré :

• Contient les réclamations relatives à l'utilisateur ou à la charge de travail.

• Est signé par la clé privée du fournisseur d'identités afin qu'OCI puisse vérifier son authenticité à l'aide de la clé publique.

• Est échangé au point d'extrémité du jeton de sécurité d'OCI contre une UPST.

Étape 7 : Obtenir OCI UPST

JWT est échangé au niveau du point d'extrémité d'échange de jetons OCI. Le point d'extrémité du jeton décode et vérifie la signature JWT à l'aide de la clé publique de la configuration d'approbation, valide l'émetteur et les revendications correspondantes, comme défini dans l'approbation de propagation d'identité, et génère UPST.

La réception UPST générée est utilisée pour accéder aux ressources à l'aide de la trousse SDK/de l'API OCI.

Exemple de demande de jeton UPST : Basé sur une application de domaine d'identité

Voici un exemple de demande cURL basée sur une application de domaine d'identité OCI.

## IAM Domain App Based Request. Note that client credentials can be sent as part of basic authn header or in the payload. 
curl --location ' https://<domainURL>/oauth2/v1/token' \
--header 'Content-Type: application/x-www-form-urlencoded' \
--header 'Authorization: Basic <auth_code>' \
--data-urlencode 'grant_type=urn:ietf:params:oauth:grant-type:token-exchange' \
--data-urlencode 'requested_token_type=urn:oci:token-type:oci-upst' \
--data-urlencode 'public_key=<public_key>' \
--data-urlencode 'subject_token=<subject_token>' \
--data-urlencode 'subject_token_type=jwt' -k
{
   "token": "<token_id>"
}