Berechtigungstyp "Tokenaustausch": Kerberos-Token für UPST austauschen

Schritte zum Kerberos-Tokenaustausch

Gehen Sie wie folgt vor, um ein Kerberos-Token gegen ein UPST auszutauschen:

1. Schritt 1: Vault erstellen und Inhalt der Keytab-Datei hinzufügen
2. Schritt 2: Erforderliche IAM-Policy erstellen
3. Schritt 3: Identitätsdomainanwendung erstellen
4. Schritt 4: SPNEGO-Token für einen bestimmten Benutzer-Principal generieren
5. Schritt 5: Servicebenutzer verwenden (optional)
6. Schritt 6: Identity Propagation Trust-Konfiguration erstellen
7. Schritt 7: OCI UPST abrufen

Schritt 1: Vault erstellen und Inhalt der Keytab-Datei hinzufügen

Erstellen Sie einen Vault, und fügen Sie den Inhalt der Keytab-Datei als base64-codierte Zeichenfolge hinzu. Hinweis: IAM speichert die Keytab-Datei nicht im zugehörigen Dateisystem.

Verwenden Sie die folgenden Schritte als Leitfaden:

1. Vault erstellen. Siehe Vault erstellen.
2. Lesen Sie den Keytab-Inhalt im Format Base64.
3. Gehen Sie zum Vault, und speichern Sie ihn unverändert. Prüfen Sie beim Erstellen des Secrets Base64 als Secret-Typvorlage. Siehe Secret in einem Vault erstellen.

Schritt 2: Erforderliche IAM-Policy erstellen

Erstellen Sie eine IAM-Policy im Mandanten, damit eine Identitätsdomainressource auf Vault zugreifen kann. Dadurch kann IAM die Keytab-Konfiguration aus Vault abrufen. Verwenden Sie das folgende Beispiel als Leitfaden:

allow resource iam-domain <domain_displayName> to read secrets from vault in compartment <compartment_ocid> where all {target.secret.id = <secret_ocid_where_the_keytab_is_present>}

Schritt 3: Identitätsdomainanwendung erstellen

Erstellen Sie eine vertrauliche Identitätsdomainanwendung. Nachdem Sie die Anwendung erstellt haben, speichern Sie die Client-ID und das Client Secret an einem sicheren Ort. Siehe Vertrauliche Anwendung hinzufügen.

Schritt 4: SPNEGO-Token für einen bestimmten Benutzer-Principal generieren

Verwenden Sie das folgende Java-Codebeispiel als Leitfaden:

package com.oracle;

import com.sun.security.auth.module.Krb5LoginModule;
import org.ietf.jgss.GSSContext;
import org.ietf.jgss.GSSException;
import org.ietf.jgss.GSSManager;
import org.ietf.jgss.GSSName;
import org.ietf.jgss.Oid;

import javax.security.auth.Subject;
import java.io.IOException;
import java.security.Principal;
import java.security.PrivilegedAction;
import java.util.Base64;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class GenerateSpnegoToken {
    static String servicePrincipal = "HTTP/iamtesp@WINDOWSKDCSERVER.COM";
    static String userPrincipal = "HTTP/<sample-job>@WINDOWSKDCSERVER.COM";
    static String userPrincipalKeyTab = "keytabs/ms/<sample-job>.keytab";
    public static void main(String[] args) throws IOException {
        System.setProperty("sun.security.krb5.debug", "true");
        System.setProperty("sun.security.spnego.debug", "true");
        System.setProperty("java.security.krb5.conf", "ms_krb5.conf");

        String spnegoToken = generateSpnegoToken();
    }
    private static String generateSpnegoToken() {
        Subject subject = getAuthenticateSubject();
        return Subject.doAs(
                subject,
                (PrivilegedAction<String>)
                        () -> {
                            String SPNEGO_OID = "1.3.6.1.5.5.2";
                            String KRB5_MECHANISM_OID = "1.2.840.113554.1.2.2";
                            String KRB5_PRINCIPAL_NAME_OID = "1.2.840.113554.1.2.2.1";

                            try {
                                // Create GSS context for the service principal and the logged-in user
                                Oid krb5Mechanism = new Oid(KRB5_MECHANISM_OID);
                                Oid krb5PrincipalNameType = new Oid(KRB5_PRINCIPAL_NAME_OID);
                                Oid spnegoOid = new Oid(SPNEGO_OID);
                                GSSManager manager = GSSManager.getInstance();
                                GSSName gssServerName =
                                        manager.createName(servicePrincipal, krb5PrincipalNameType, krb5Mechanism);
                                GSSContext gssContext =
                                        manager.createContext(
                                                gssServerName, spnegoOid, null, 240000);
                                gssContext.requestMutualAuth(true);
                                gssContext.requestCredDeleg(true);
                                gssContext.requestLifetime(10);

                                // Generate the SPNEGO token
                                byte[] token = new byte[0];
                                token = gssContext.initSecContext(token, 0, token.length);
                                return Base64.getEncoder().encodeToString(token);
                            } catch (GSSException e) {
                                throw new RuntimeException(e);
                            }
                        });
    }

    private static Subject getAuthenticateSubject() {
        final Map<String, String> options = new HashMap<>();
        options.put("keyTab", userPrincipalKeyTab);
        options.put("principal", userPrincipal);
        options.put("doNotPrompt", "true");
        options.put("isInitiator", "true");
        options.put("refreshKrb5Config", "true");
        options.put("storeKey", "true");
        options.put("useKeyTab", "true");

        // Execute the login
        Subject subject = new Subject();
        Krb5LoginModule krb5LoginModule = new Krb5LoginModule();
        krb5LoginModule.initialize(subject, null, new HashMap<String, String>(), options);
        try {
            krb5LoginModule.login();
            krb5LoginModule.commit();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        Set<Principal> principals = (Set<Principal>) subject.getPrincipals();
        Iterator<Principal> iterator = principals.iterator();
        while (iterator.hasNext()) {
            System.out.println("\nprincipal : " + ((Principal) iterator.next()));
        }

        return subject;

    }
}

Schritt 5: Servicebenutzer verwenden (optional)

Ein Servicebenutzer ist ein Identitätsdomainbenutzer, bei dem das Attribut serviceUser auf true gesetzt ist.

Um einen Servicebenutzer zu verwenden, erstellen Sie einen Benutzer ohne interaktive Anmeldeberechtigungen. Diese Servicebenutzer können Gruppen und Servicerollen erteilt werden. Ihre Anwendungen können diese Servicebenutzer verwenden, oder der angemeldete Benutzer kann sich als dieser ausgeben, um ein temporäres UPST-Token zu erhalten.

Servicebenutzer haben die folgenden Eigenschaften:

• Muss eine userName-Datei enthalten. Vor- und Nachname sind nicht erforderlich.
• Kann eine E-Mail-Adresse haben (optional).
• Kann Mitglied von Gruppen und Anwendungsrollen sein.
• API-Schlüssel können nicht vorhanden sein.
• Selfservice-Endpunkte können nicht verwendet werden.
• Kennwörter dürfen nicht vorhanden sein, und Kennwort-Policys werden nicht angewendet.

Anforderungsbeispiel: Servicebenutzer erstellen

Im Folgenden finden Sie ein Beispiel für eine Anforderung mit den Mindestattributen, die zum Erstellen eines Servicebenutzers erforderlich sind.

## POST on https://<domainURL>/admin/v1/Users
## 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"
}

Antwortbeispiel: Servicebenutzer erstellen

Im Folgenden ist ein Beispiel für eine Antwort beim Erstellen eines Servicebenutzers dargestellt.

{
    "idcsCreatedBy": {
        "type": "App",
        "display": "idcsadmin"
    },
    "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": "idcsadmin",
        "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"
    ]
}

Schritt 6: Identity Propagation Trust-Konfiguration erstellen

Mit der Identity Propagation Trust-Konfiguration wird das Vertrauen zwischen OCI Identity und den externen Cloud-Providern, die Validierung des Cloud-Providertokens und die Zuordnung der Benutzeridentität des Cloud-Providers zur Benutzeridentität der Identitätsdomains service hergestellt.

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

Anforderungsbeispiel - Identity Propagation Trust-Konfiguration erstellen

## POST on https://<domainURL>/admin/v1/IdentityPropagationTrusts
## Payload:
{
 "active": true,
 "allowImpersonation": false,
 "issuer": "idcs_psr_itp",
 "name": "<identity_propagation_trust_name>",
 "oauthClients": [
 "<oauthclient-id>"
 ],
 "keytab": {
 "secretOcid": "<secret_ocid>"
 },
 "subjectMappingAttribute": "userName",
 "subjectType": "User",
 "type": "SPNEGO",
 "schemas": [
 "urn:ietf:params:scim:schemas:oracle:idcs:IdentityPropagationTrust"
 ]
}

Antwortbeispiel - Trust-Konfiguration für Identitätspropagierung erstellen

  "response": {
    "name": "<identity_propagation_trust_name>",
    "type": "<token_type>",
    "issuer": "idcs_psr_itp",
    "accountId": "<example_account_id>",
    "subjectClaimName": "cognito:username",
    "subjectMappingAttribute": "username",
    "subjectType": "User",
    "clientClaimName": "appId",
    "clientClaimValues": ["<client_claim_value>"],
    "active": true,
    "publicKeyEndpoint": "https://example.identityprovider.com/publickey/<publickey_value>",
    "publicCertificate": "<public_certificate_value>",
    "oauthClients": ["<oauthclient-id>"],

    "allowImpersonation": true,
    "impersonationServiceUsers": [
      {
        "rule": "groups co \"network-admin\"",
        "userId": "<user_id>"
      },
      {
        "rule": "groups co \"tenancy-admin\"",
        "userId": "<user_id>"
      }
    ],
    "keytab": {
      "secretOcid": "<secret_ocid>",
      "secretVersion": "<secret_version>"
    },
    "clockSkewSeconds": 60,
    "id": "<identity_propagation_trust_id>",
    "meta": {
      "created": "2023-11-09T23:26:53.224Z",
      "lastModified": "2023-11-09T23:26:53.224Z",
      "resourceType": "IdentityPropagationTrust",
      "location": "http://example.hostname.com:8990/admin/v1/IdentityPropagationTrusts/<identity_propagation_trust_id>"
    },
    "schemas": [
      "urn:ietf:params:scim:schemas:oracle:idcs:IdentityPropagationTrust"
    ],
    "idcsCreatedBy": {
      "value": "<app_id>",
      "display": "admin",
      "type":"App",
      "$ref": "http://example.hostname.com:8990/admin/v1/Apps/<app_id>"
    },
    "idcsLastModifiedBy": {
      "value": "<app_id>",
      "display": "admin",
      "type":"App",
      "$ref": "http://example.hostname.com:8990/admin/v1/Apps/<app_id>"
    }
  }

Schritt 7: OCI UPST abrufen

Beispiel für UPST-Tokenanforderung: OCI-signaturbasiert

Im Folgenden ist ein Beispiel für eine OCI-signaturbasierte cURL-Anforderung aufgeführt.

## OCI Signature Based Request
curl  -X POST -sS https://<domainURL>/oauth2/v1/token -i 
-H 'date: Wed, 06 Dec 2023 01:17:33 GMT' 
-H 'x-content-sha256: <key>' 
-H 'content-type: application/x-www-form-urlencoded;charset=utf-8' 
-H 'content-length: 197' 
-H 'Authorization: Signature version="1",keyId="<key_id>",algorithm="rsa-sha256",headers="(request-target) date host x-content-sha256 content-type content-length",signature="a+aH0b...TLtPA=="'  --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=spnego' \
--data-urlencode 'issuer=<Issuer stored in the Identity Trust Propagation. For example, examplead@kdcserver.com>' -k
{
   "token": "<token_id>"
}

UPST-Tokenanforderung - Beispiel: App-basiert auf Identitätsdomain

Im Folgenden wird eine anwendungsbasierte cURL-Beispielanforderung für OCI-Identitätsdomains dargestellt.

## 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=spnego' \
--data-urlencode 'issuer=<Issuer stored in the Identity Trust Propagation. For example, examplead@kdcserver.com>' -k
{
   "token": "<token_id>"
}