Microsoft‑Graph‑Hilfsfunktionen

Projekt im Azure Active Directory Admin Center erstellen

Ein Projekt soll im Azure Active Directory Admin Center für einen Benutzer mit MS‑Office‑Konto erstellt werden.

Schritte zum Erstellen eines Projekts im Azure Active Directory Admin Center

Im Folgenden finden Sie eine Schritt‑für‑Schritt‑Anleitung zum Erstellen eines Projekts im Azure‑Active‑Directory‑Admin‑Center.

1. Gehen Sie zu Azure Active Directory und melden Sie sich mit Ihren MS‑Office‑Anmeldeinformationen an.

Azure Active Directory Link – https://aad.portal.azure.com/

2. Erstellen einer Azure‑AD‑Anwendung in Ihrem Mandanten.

Klicken Sie im linken Bereich auf die Bezeichnung Azure Active Directory. Dadurch öffnet sich das Fenster für Azure Active Directory. Auf diesem Bildschirm sollten Sie die Bezeichnung App registrations sehen. Dies ist der Ausgangspunkt für die Registrierung einer Azure‑AD‑Anwendung. Dieses Fenster ermöglicht Ihnen, eine neue Anwendung für Azure AD zu erstellen.

Klicken Sie auf die Schaltfläche New registration, um eine neue Anwendung zu erstellen.

3. Jetzt sehen Sie das Fenster für die neue Anwendungsregistrierung.

• Name Dies wird der Name Ihrer Anwendung sein.
• Supported account types Dieser Abschnitt wird den Zugriff einschränken.

Klicken Sie auf die Schaltfläche Register.

4. Sie sollten das Fenster der neu registrierten Anwendungen sehen.

• Application (client) ID Die ID Ihrer Anwendung.
• Directory (tenant) ID Die Azure‑AD‑Mandanten‑ID.

5. Berechtigungen für die Microsoft‑Graph‑API zulassen.

Klicken Sie auf die Beschriftung API permissions.

Azure hat Ihrer Anwendung bereits delegierte Berechtigungen User.Read zugewiesen. Diese Berechtigung ermöglicht das Lesen von Benutzerinformationen eines angemeldeten Benutzers. Das sind Microsoft‑Graph‑API‑Berechtigungen, die wir auch Scopes nennen.

Die vollständige Liste der Scopes für die Microsoft‑Graph‑API – https://docs.microsoft.com/en-us/graph/permissions-reference.

Klicken Sie auf die Schaltfläche + Add a permission und wählen Sie Microsoft Graph.

Klicken Sie auf Delegated permissions. Nun sehen Sie eine Liste der für die Microsoft‑Graph‑API verfügbaren Berechtigungen.

Wählen Sie die erforderlichen Berechtigungen aus und klicken Sie auf Add permissions.

Klicken Sie auf die Schaltfläche Grant admin consent.

6. Öffentliche‑Client‑Flows zulassen.

Gibt an, ob die Anwendung ein öffentlicher Client ist. Geeignet für Apps, die Token‑Grant‑Flows nutzen, die keinen Redirect‑URI verwenden.

7. Schlüssel für die Anwendung erstellen

Hilfsklassen

Die folgenden Hilfsklassen sind erforderlich, um den Code in diesem Abschnitt auszuführen. Diese Klassen dienen nur zur Vereinfachung der Demonstration.

AzureROPCTokenProvider‑Klasse

Eine Instanz von IGraphClient Klasse kümmert sich um das Erstellen von Anfragen, das Senden an die Microsoft‑Graph‑API und die Verarbeitung der Antworten. Um eine neue Instanz dieser Klasse zu erstellen, müssen Sie eine Instanz von ITokenProvider, die Anfragen an Microsoft Graph authentifizieren kann.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;

/**
 * <p>
 * Azure resource owner password credential (ROPC) token provider
 * https://docs.microsoft.com/en-us/azure/active-directory/develop/v2-oauth-ropc
 * https://docs.microsoft.com/en-us/exchange/client-developer/exchange-web-services/how-to-authenticate-an-ews-application-by-using-oauth
 * https://portal.azure.com
 * https://developer.microsoft.com/en-us/graph/graph-explorer/#
 * token parser https://jwt.io
 * </p>
 */
class AzureROPCTokenProvider implements ITokenProvider {

    private static final String GRANT_TYPE = "password";

    private final String clientId;
    private final String clientSecret;
    private final String userName;
    private final String password;
    private final String tenant;
    private final String scope;

    private OAuthToken token;

    public AzureROPCTokenProvider(String tenant, String clientId, String clientSecret,
                                  String userName, String password, String[] scopeAr) {
        this.tenant = tenant;
        this.clientId = clientId;
        this.clientSecret = clientSecret;
        this.userName = userName;
        this.password = password;
        this.scope = joinToStr(scopeAr, " ");
    }

    public synchronized OAuthToken getAccessToken(boolean ignoreExistingToken) {
        if (this.token != null && !this.token.getExpired() && !ignoreExistingToken)
            return this.token;
        token = null;

        Map<String, String> tokenArgs = geToken();

        java.util.Calendar c = java.util.Calendar.getInstance();
        c.add(java.util.Calendar.SECOND, Integer.parseInt(tokenArgs.get("expires_in")));
        token = new OAuthToken(tokenArgs.get("access_token"), TokenType.AccessToken, c.getTime());
        return token;
    }

    public final OAuthToken getAccessToken() {
        return getAccessToken(false);
    }

    public void dispose() {
    }

    private String getEncodedParameters() {
        return "client_id=" + urlEncode(clientId) + "&scope=" + urlEncode(scope) + "&username=" + urlEncode(userName)
                + "&password=" + urlEncode(password) + "&grant_type="
                + urlEncode(GRANT_TYPE);
    }

    private String getUri() {
        if (tenant == null || tenant.trim().isEmpty())
            return "https://login.microsoftonline.com/common/oauth2/v2.0/token";
        else
            return "https://login.microsoftonline.com/" + tenant + "/oauth2/v2.0/token";
    }

    private Map<String, String> geToken() {
        try {
            HttpURLConnection connection = (HttpURLConnection) new URL(getUri()).openConnection();
            connection.setRequestMethod("POST");

            byte[] requestData = getEncodedParameters().getBytes(StandardCharsets.UTF_8);

            connection.setUseCaches(false);
            connection.setDoInput(true);
            connection.setDoOutput(true);
            connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
            connection.setRequestProperty("Content-Length", "" + requestData.length);

            final OutputStream st = connection.getOutputStream();
            try {
                st.write(requestData, 0, requestData.length);
            } finally {
                st.flush();
                st.close();
            }

            connection.connect();

            if (connection.getResponseCode() >= HttpURLConnection.HTTP_BAD_REQUEST) {
                throw new IllegalAccessError("Operation failed: " + connection.getResponseCode() + "/" +
                        connection.getResponseMessage() + "\r\nDetails:\r\n{2}"
                        + readInputStream(connection.getErrorStream()));
            }

            String responseText = readInputStream(connection.getInputStream());

            Map<String, String> result = new HashMap<>();
            String[] fromJsonToKeyValue = responseText.replace("{", "").replace("}", "")
                    .replace("\"", "").replace("\r", "")
                    .replace("\n", "").split(",");
            for (String keyValue : fromJsonToKeyValue) {
                String[] pair = keyValue.split(":");
                String name = pair[0].trim().toLowerCase();
                String value = urlDecode(pair[1].trim());
                result.put(name, value);
            }

            return result;
        } catch (IOException e) {
            throw new IllegalAccessError(e.getMessage());
        }
    }

    static String urlEncode(String value) {
        try {
            return URLEncoder.encode(value, StandardCharsets.UTF_8.toString());
        } catch (UnsupportedEncodingException e) {
            throw new IllegalAccessError(e.getMessage());
        }
    }

    static String urlDecode(String value) {
        try {
            return URLDecoder.decode(value, StandardCharsets.UTF_8.toString());
        } catch (UnsupportedEncodingException e) {
            throw new IllegalAccessError(e.getMessage());
        }
    }

    static String readInputStream(InputStream is) {
        if (is == null)
            return "";

        BufferedReader reader = new BufferedReader(new InputStreamReader(is));
        StringBuilder result = new StringBuilder();
        String line;
        try {
            while ((line = reader.readLine()) != null) {
                result.append(line);
            }
        } catch (IOException e) {
            // ignore
        }
        return result.toString();
    }

    static String joinToStr(String[] arr, String sep) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < arr.length; i++) {
            if (i > 0)
                sb.append(sep);
            sb.append(arr[i]);
        }
        return sb.toString();
    }
}