Ativar a autenticação na sua própria aplicação iOS Swift com Azure AD B2C

Artigo
01/11/2024

Este artigo mostra-lhe como adicionar a autenticação B2C (Azure AD B2C) do Azure Active Directory à sua própria aplicação móvel iOS Swift. Saiba como integrar uma aplicação iOS Swift com a Biblioteca de Autenticação da Microsoft (MSAL) para iOS.

Utilize este artigo com Configurar a autenticação numa aplicação Swift iOS de exemplo, substituindo a aplicação iOS Swift de exemplo pela sua própria aplicação iOS Swift. Depois de concluir as instruções neste artigo, a sua aplicação aceitará inícios de sessão através do Azure AD B2C.

Pré-requisitos

Reveja os pré-requisitos e as instruções de integração em Configurar a autenticação numa aplicação iOS Swift de exemplo com Azure AD B2C.

Criar um projeto de aplicação Swift para iOS

Se ainda não tiver uma aplicação Swift para iOS, configure um novo projeto ao seguir os seguintes passos:

Abra xcode e, em seguida, selecioneNovo>Projetode Ficheiro>.
Para aplicações iOS, selecioneAplicaçãoiOS> e, em seguida, selecione Seguinte.
Para Escolher opções para o seu novo projeto, forneça o seguinte:
1. Nome do produto, como MSALiOS.
2. Identificador da organização, como contoso.com.
3. Para a Interface, selecione Storyboard.
4. Para o Ciclo de vida, selecione Delegado da Aplicação UIKit.
5. Para o Idioma, selecione Swift.
Selecione Seguinte.
Selecione uma pasta na qual criar a sua aplicação e, em seguida, selecione Criar.

Passo 1: Instalar a biblioteca MSAL

Utilize CocoaPods para instalar a biblioteca MSAL. Na mesma pasta que o ficheiro .xcodeproj do seu projeto, se o ficheiro podfile não existir, crie um ficheiro vazio e dê-lhe o nome podfile. Adicione o seguinte código ao ficheiro podfile :
```
use_frameworks!

target '<your-target-here>' do
   pod 'MSAL'
end
```
Substitua <your-target-here> pelo nome do projeto (por exemplo, MSALiOS). Para obter mais informações, veja Referência da Sintaxe do Podfile.
Numa janela de terminal, aceda à pasta que contém o ficheiro podfile e, em seguida, execute a instalação do pod para instalar a biblioteca MSAL.
Depois de executar o pod install comando, é criado um <ficheiro project name.xcworkspace>. Para recarregar o projeto no Xcode, feche o Xcode e, em seguida, abra o <ficheiro project name.xcworkspace>.

Passo 2: Definir o esquema de URL da aplicação

Quando os utilizadores se autenticam, Azure AD B2C envia um código de autorização para a aplicação através do URI de redirecionamento configurado no Azure AD registo da aplicação B2C.

O formato de URI de redirecionamento predefinido MSAL é msauth.[Your_Bundle_Id]://auth. Um exemplo seria msauth.com.microsoft.identitysample.MSALiOS://auth, onde msauth.com.microsoft.identitysample.MSALiOS está o esquema de URL.

Neste passo, registe o esquema de URL com a CFBundleURLSchemes matriz. A sua aplicação escuta o esquema de URL da chamada de retorno do Azure AD B2C.

No Xcode, abra o ficheiro Info.plist como um ficheiro de código fonte. <dict> Na secção, adicione o seguinte fragmento XML:

<key>CFBundleURLTypes</key>
<array>
    <dict>
        <key>CFBundleURLSchemes</key>
        <array>
            <string>msauth.com.microsoft.identitysample.MSALiOS</string>
        </array>
    </dict>
</array>
<key>LSApplicationQueriesSchemes</key>
<array>
    <string>msauthv2</string>
    <string>msauthv3</string>
</array>

Passo 3: adicionar o código de autenticação

O código de exemplo é composto por uma UIViewController classe. A classe:

Define a estrutura de uma interface de utilizador.
Contém informações sobre a sua Azure AD fornecedor de identidade B2C. A aplicação utiliza estas informações para estabelecer uma relação de confiança com Azure AD B2C.
Contém o código de autenticação para autenticar utilizadores, adquirir tokens e validá-los.

Escolha onde UIViewController os utilizadores se autenticam. No seu , intercale UIViewControllero código com o código fornecido no GitHub.

Passo 4: Configurar a sua aplicação Swift para iOS

Depois de adicionar o código de autenticação, configure a sua aplicação iOS Swift com as suas definições de Azure AD B2C. Azure AD definições do fornecedor de identidade B2C estão configuradas na UIViewController classe escolhida na secção anterior.

Para saber como configurar a sua aplicação Swift para iOS, veja Configurar a autenticação numa aplicação Swift iOS de exemplo com Azure AD B2C.

Passo 5: Executar e testar a aplicação móvel

Crie e execute o projeto com um simulador de um dispositivo iOS ligado.
Selecione Iniciar Sessão e, em seguida, inscreva-se ou inicie sessão com o seu Azure AD conta local ou social B2C.
Depois de autenticar com êxito, verá o seu nome a apresentar na barra de navegação.

Passo 6: Personalizar os blocos modulares de código

Esta secção descreve os blocos modulares de código que permitem a autenticação para a sua aplicação iOS Swift. Lista os métodos do UIViewController e aborda como personalizar o seu código.

Passo 6.1: Instanciar uma aplicação cliente pública

As aplicações cliente públicas não são fidedignas para manter os segredos da aplicação em segurança e não têm segredos de cliente. Em viewDidLoad, instancia um MSAL com um objeto de aplicação cliente público.

O fragmento de código Swift seguinte demonstra como inicializar o MSAL com um MSALPublicClientApplicationConfig objeto de configuração.

O objeto de configuração fornece informações sobre o seu ambiente Azure AD B2C. Por exemplo, fornece o ID de cliente, o URI de redirecionamento e a autoridade para criar pedidos de autenticação para Azure AD B2C. Para obter informações sobre o objeto de configuração, veja Configurar a aplicação móvel de exemplo.

do {

    let signinPolicyAuthority = try self.getAuthority(forPolicy: self.kSignupOrSigninPolicy)
    let editProfileAuthority = try self.getAuthority(forPolicy: self.kEditProfilePolicy)
    
    let pcaConfig = MSALPublicClientApplicationConfig(clientId: kClientID, redirectUri: kRedirectUri, authority: signinPolicyAuthority)
    pcaConfig.knownAuthorities = [signinPolicyAuthority, editProfileAuthority]
    
    self.applicationContext = try MSALPublicClientApplication(configuration: pcaConfig)
    self.initWebViewParams()
    
    } catch {
        self.updateLoggingText(text: "Unable to create application \(error)")
    }

O initWebViewParams método configura a experiência de autenticação interativa .

O fragmento de código Swift seguinte inicializa o membro da webViewParameters classe com a vista Web do sistema. Para obter mais informações, consulte Personalizar browsers e WebViews para iOS/macOS.

func initWebViewParams() {
    self.webViewParameters = MSALWebviewParameters(authPresentationViewController: self)
    self.webViewParameters?.webviewType = .default
}

Passo 6.2: Iniciar um pedido de autorização interativo

Um pedido de autorização interativo é um fluxo em que é pedido aos utilizadores que se inscrevam ou iniciem sessão com a vista Web do sistema. Quando os utilizadores selecionam o botão Iniciar Sessão , o authorizationButton método é chamado.

O authorizationButton método prepara o MSALInteractiveTokenParameters objeto com dados relevantes sobre o pedido de autorização. O acquireToken método utiliza o MSALInteractiveTokenParameters para autenticar utilizadores através da vista Web do sistema.

O fragmento de código seguinte demonstra como iniciar o pedido de autorização interativo:

let parameters = MSALInteractiveTokenParameters(scopes: kScopes, webviewParameters: self.webViewParameters!)
parameters.promptType = .selectAccount
parameters.authority = authority

applicationContext.acquireToken(with: parameters) { (result, error) in

// On error code    
guard let result = result else {
    self.updateLoggingText(text: "Could not acquire token: \(error ?? "No error information" as! Error)")
    return
}

// On success code
self.accessToken = result.accessToken
self.updateLoggingText(text: "Access token is \(self.accessToken ?? "Empty")")
}

Após os utilizadores concluirem o fluxo de autorização, com êxito ou sem êxito, o resultado é devolvido ao encerramento do acquireToken método.

O acquireToken método devolve os result objetos e error . Utilize este encerramento para:

Atualize a IU da aplicação móvel com informações após a conclusão da autenticação.
Chame um serviço de API Web com um token de acesso.
Lidar com erros de autenticação (por exemplo, quando um utilizador cancela o fluxo de início de sessão).

Passo 6.3: Chamar uma API Web

Para chamar uma API Web de autorização baseada em tokens, a aplicação precisa de um token de acesso válido. A aplicação faz o seguinte:

Adquire um token de acesso com as permissões (âmbitos) necessárias para o ponto final da API Web.
Transmite o token de acesso como um token de portador no cabeçalho de autorização do pedido HTTP com este formato:

Authorization: Bearer <access-token>

Quando os utilizadores se autenticam interativamente, a aplicação obtém um token de acesso no acquireToken encerramento. Para chamadas subsequentes à API Web, utilize o método acquire token silent (acquireTokenSilent), conforme descrito nesta secção.

O acquireTokenSilent método faz as seguintes ações:

Tenta obter um token de acesso com os âmbitos pedidos da cache de tokens. Se o token estiver presente e não tiver expirado, o token será devolvido.
Se o token não estiver presente na cache de tokens ou tiver expirado, a biblioteca MSAL tenta utilizar o token de atualização para adquirir um novo token de acesso.
Se o token de atualização não existir ou tiver expirado, será devolvida uma exceção. Neste caso, deve pedir ao utilizador para iniciar sessão interativamente.

O fragmento de código seguinte demonstra como adquirir um token de acesso:

do {

// Get the authority using the sign-in or sign-up user flow
let authority = try self.getAuthority(forPolicy: self.kSignupOrSigninPolicy)

// Get the current account from the application context
guard let thisAccount = try self.getAccountByPolicy(withAccounts: applicationContext.allAccounts(), policy: kSignupOrSigninPolicy) else {
    self.updateLoggingText(text: "There is no account available!")
    return
}

// Configure the acquire token silent parameters
let parameters = MSALSilentTokenParameters(scopes: kScopes, account:thisAccount)
parameters.authority = authority
parameters.loginHint = "username"

// Acquire token silent
self.applicationContext.acquireTokenSilent(with: parameters) { (result, error) in
    if let error = error {
        
        let nsError = error as NSError
        
        // interactionRequired means we need to ask the user to sign in. This usually happens
        // when the user's Refresh Token is expired or if the user has changed their password
        // among other possible reasons.
        
        if (nsError.domain == MSALErrorDomain) {
            
            if (nsError.code == MSALError.interactionRequired.rawValue) {
                
                // Start an interactive authorization code
                // Notice we supply the account here. This ensures we acquire token for the same account
                // as we originally authenticated.
                
                ...
            }
        }
        
        self.updateLoggingText(text: "Could not acquire token: \(error)")
        return
    }
    
    guard let result = result else {
        
        self.updateLoggingText(text: "Could not acquire token: No result returned")
        return
    }
    
    // On success, set the access token to the accessToken class member. 
    // The callGraphAPI method uses the access token to call a web API  
    self.accessToken = result.accessToken
    ...
}
} catch {
self.updateLoggingText(text: "Unable to construct parameters before calling acquire token \(error)")
}

O callGraphAPI método obtém o token de acesso e chama a API Web, conforme mostrado aqui:

@objc func callGraphAPI(_ sender: UIButton) {
    guard let accessToken = self.accessToken else {
        self.updateLoggingText(text: "Operation failed because could not find an access token!")
        return
    }
    
    let sessionConfig = URLSessionConfiguration.default
    sessionConfig.timeoutIntervalForRequest = 30
    let url = URL(string: self.kGraphURI)
    var request = URLRequest(url: url!)
    request.setValue("Bearer \(accessToken)", forHTTPHeaderField: "Authorization")
    let urlSession = URLSession(configuration: sessionConfig, delegate: self, delegateQueue: OperationQueue.main)
    
    self.updateLoggingText(text: "Calling the API....")
    
    urlSession.dataTask(with: request) { data, response, error in
        guard let validData = data else {
            self.updateLoggingText(text: "Could not call API: \(error ?? "No error information" as! Error)")
            return
        }
        
        let result = try? JSONSerialization.jsonObject(with: validData, options: [])
        
        guard let validResult = result as? [String: Any] else {
            self.updateLoggingText(text: "Nothing returned from API")
            return
        }
        
        self.updateLoggingText(text: "API response: \(validResult.debugDescription)")
        }.resume()
}

Passo 6.4: Terminar sessão de utilizadores

Terminar sessão com o MSAL remove todas as informações conhecidas sobre os utilizadores da aplicação. Utilize o método de início de sessão para terminar sessão dos utilizadores e atualizar a IU. Por exemplo, pode ocultar elementos protegidos da IU, ocultar o botão de terminar sessão ou mostrar o botão de início de sessão.

O fragmento de código seguinte demonstra como terminar a sessão dos utilizadores:

@objc func signoutButton(_ sender: UIButton) {
do {
    
    
    let thisAccount = try self.getAccountByPolicy(withAccounts: applicationContext.allAccounts(), policy: kSignupOrSigninPolicy)
    
    if let accountToRemove = thisAccount {
        try applicationContext.remove(accountToRemove)
    } else {
        self.updateLoggingText(text: "There is no account to signing out!")
    }
    
    ...
    
} catch  {
    self.updateLoggingText(text: "Received error signing out: \(error)")
}
}

Passos seguintes

Aprenda a:

Partilhar via