Habilitar a autenticação em seu próprio aplicativo iOS Swift usando o Azure AD B2C

Artigo
01/11/2024

Este artigo mostra como adicionar a autenticação do Azure Active Directory B2C (Azure AD B2C) ao seu próprio aplicativo móvel do iOS Swift. Saiba como integrar um aplicativo iOS Swift com a Biblioteca de Autenticação da Microsoft (MSAL) para iOS.

Use este texto com o artigo Configurar a autenticação em um aplicativo iOS Swift de exemplo, substituindo o aplicativo iOS Swift de exemplo pelo seu próprio aplicativo iOS Swift. Depois de concluir as instruções neste artigo, o aplicativo aceitará as credenciais por meio do Azure AD B2C.

Pré-requisitos

Examine os pré-requisitos e as instruções de integração em Configurar a autenticação em um aplicativo iOS Swift de exemplo usando o Azure AD B2C.

Criar um projeto de aplicativo iOS Swift

Se você ainda não tiver um aplicativo iOS Swift, configure um novo projeto seguindo as etapas a seguir:

Abra o Xcode e selecione Arquivo>Novo>Projeto.
Para aplicativos iOS, selecione iOS>Aplicativo e, em seguida, Avançar.
Para Escolher as opções do novo projeto, forneça as seguintes informações:
1. Nome do produto, como MSALiOS.
2. Identificador de organização, como contoso.com.
3. Em interface, selecione Storyboard.
4. Em Ciclo de vida, selecione Delegado do Aplicativo UIKit.
5. Em Linguagem, selecione Swift.
Selecione Avançar.
Selecione uma pasta na qual criar o aplicativo e, em seguida, selecione Criar.

Etapa 1: Instalar a biblioteca MSAL

Use o CocoaPods para instalar a biblioteca MSAL. Na mesma pasta do arquivo .xcodeproj do projeto, se o arquivo podfile não existir, crie um arquivo vazio com o nome podfile. Adicione o seguinte código ao arquivo podfile:
```
use_frameworks!

target '<your-target-here>' do
   pod 'MSAL'
end
```
Substitua <your-target-here> pelo nome do projeto (por exemplo, MSALiOS). Para mais informações, consulte Referência de sintaxe do Podfile.
Em uma janela do terminal, vá até a pasta que contém o arquivo podfile e execute instalar pod para instalar a biblioteca MSAL.
Após a execução do comando pod install, um arquivo .xcworkspace< com >o nome do seu projeto é criado. Para recarregar o projeto no Xcode, feche o Xcode e abra o arquivo .xcworkspace< com >o nome do projeto.

Etapa 2: Definir o esquema da URL do aplicativo

Quando os usuários são autenticados, o Azure AD B2C envia um código de autorização para o aplicativo usando o URI de redirecionamento configurado no registro do aplicativo Azure AD B2C.

O formato do URI de redirecionamento padrão da MSAL é msauth.[Your_Bundle_Id]://auth. Um exemplo seria msauth.com.microsoft.identitysample.MSALiOS://auth, em que msauth.com.microsoft.identitysample.MSALiOS é o esquema da URL.

Nesta etapa, registre o esquema da URL usando a matriz CFBundleURLSchemes. Seu aplicativo vai escutar o esquema de URL para o retorno de chamada do Azure AD B2C.

No Xcode, abra o arquivo Info.plist como um arquivo de código-fonte. Na seção <dict>, adicione o snippet XML a seguir:

<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>

Etapa 3: Adicionar o código de autenticação

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

Define a estrutura da interface do usuário.
Contém informações sobre seu provedor de identidade do Azure AD B2C. O aplicativo usa esta informação para estabelecer uma relação de confiança com o Azure AD B2C.
Contém o código de autenticação para autenticar usuários, adquirir tokens e validá-los.

Escolha um UIViewController em que os usuários serão autenticados. No UIViewController, mescle o código com o código fornecido no GitHub.

Etapa 4: Configurar o aplicativo iOS Swift

Depois de adicionar os componentes de autenticação, configure seu aplicativo iOS Swift com as configurações do Azure AD B2C. As configurações do provedor de identidade do Azure AD B2C são configuradas na classe UIViewController que foi escolhida na seção anterior.

Para saber como configurar o aplicativo iOS Swift, confira Configurar a autenticação em um aplicativo iOS Swift de exemplo usando o Azure AD B2C.

Etapa 5: Executar e testar o aplicativo móvel

Compile e execute o projeto com um simulador de um dispositivo iOS conectado.
Selecione Conectar e inscreva-se ou entre com sua conta do Azure AD B2C local ou social.
Depois de ter realizado a autenticação, seu nome será exibido na barra de navegação.

Etapa 6: Personalizar os blocos de construção de código

Esta seção descreve os blocos de construção de código que habilitam a autenticação no aplicativo iOS Swift. Ela lista os métodos do UIViewController e discute as maneiras de personalizar o código.

Etapa 6.1: Criar uma instância de um aplicativo cliente público

Os aplicativos cliente públicos não são confiáveis para manter com segurança os segredos do aplicativo e não contêm segredos do cliente. Em viewDidLoad, crie uma instância da MSAL usando um objeto de aplicativo de cliente público.

O snippet de código Swift a seguir demonstra como iniciar a MSAL com um objeto de configuração MSALPublicClientApplicationConfig.

O objeto de configuração fornece informações sobre o ambiente do Azure AD B2C. Por exemplo, ele fornece a ID do cliente, o URI de redirecionamento e a autoridade para criar solicitações de autenticação para o Azure AD B2C. Para obter informações sobre o objeto de configuração, consulte Configurar o aplicativo 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 método initWebViewParams configura a experiência de autenticação interativa.

O seguinte snippet de código Swift inicializa o membro da classe webViewParameters com o modo de exibição Web do sistema. Para obter mais informações, confira Personalizar navegadores e modos de exibição Web para iOS/macOS.

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

Etapa 6.2: Iniciar uma solicitação de autorização interativa

Uma solicitação de autorização interativa é um fluxo em que os usuários são solicitados a inscrever-se ou entrar usando o modo de exibição Web do sistema. O método authorizationButton é chamado quando os usuários selecionam o botão Entrar.

O método authorizationButton prepara o objeto MSALInteractiveTokenParameters com os dados relevantes da solicitação de autorização. O método acquireToken usa MSALInteractiveTokenParameters para autenticar os usuários por meio do modo de exibição Web do sistema.

O snippet de código a seguir demonstra como iniciar a solicitação de autorização interativa:

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")")
}

Depois que os usuários concluem o fluxo de autorização, com ou sem êxito, o resultado será retornado para o fechamento do método acquireToken.

O método acquireToken retorna os objetos result e error. Use este fechamento para:

Atualizar a interface do usuário do aplicativo móvel com informações após a conclusão da autenticação.
Chamar um serviço de API Web com um token de acesso.
Tratar erros de autenticação (por exemplo, quando um usuário cancela o fluxo de entrada).

Etapa 6.3: Chamar uma API Web

Para chamar uma API Web de autorização baseada em token, o aplicativo precisa ter um token de acesso válido. O aplicativo faz as seguintes ações:

Adquire um token de acesso com as permissões necessárias (escopos) para o ponto de extremidade da API Web.
Passa o token de acesso como um token de portador no cabeçalho de autorização da solicitação HTTP usando este formato:

Authorization: Bearer <access-token>

Quando os usuários fazem autenticação interativamente, o aplicativo obtém um token de acesso no fechamento acquireToken. Para as chamadas à API Web subsequentes, use o método silencioso de aquisição de tokens (acquireTokenSilent), conforme descrito nesta seção.

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

Ele tenta buscar um token de acesso com os escopos solicitados do cache de token. Se o token estiver presente e não tiver expirado, o token será retornado.
Se o token não estiver presente no cache de token ou tiver expirado, a biblioteca MSAL tentará usar 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á retornada uma exceção. Nesse caso, é recomendável solicitar que o usuário entre de forma interativa.

O seguinte trecho de código 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 método callGraphAPI recupera 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()
}

Etapa 6.4: Desconectar usuários

Desconectar-se usando o MSAL remove do aplicativo toda a informação conhecida sobre os usuários. Use o método de saída para desconectar usuários e atualizar a interface do usuário. Por exemplo, você pode ocultar elementos de interface do usuário protegidos, esconder o botão de saída ou mostrar o botão de entrada.

O seguinte snippet de código demonstra como desconectar usuários:

@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)")
}
}

Próximas etapas

Saiba como:

Compartilhar via