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

Importante

A partir de 1º de maio de 2025, o Azure AD B2C não estará mais disponível para compra para novos clientes. Saiba mais em nossas perguntas frequentes.

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

Use este artigo com Configurar a autenticação em um aplicativo iOS Swift de exemplo, substituindo o aplicativo iOS Swift de exemplo por seu próprio aplicativo iOS Swift. Depois de concluir as instruções neste artigo, seu aplicativo aceitará entradas 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 do iOS Swift

Se você ainda não tiver um aplicativo swift do iOS, configure um novo projeto executando as seguintes etapas:

Abra o Xcode e selecione Arquivo>Novo>Projeto.
Para aplicativos iOS, selecioneo aplicativo> e selecione Avançar.
Para escolher opções para 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. Em Ciclo de vida, selecione Delegado do Aplicativo UIKit.
5. Para o Idioma, selecione Swift.
Selecione Próximo.
Selecione uma pasta na qual criar seu aplicativo e selecione Criar.

Etapa 1: Instalar a biblioteca MSAL

Use CocoaPods para instalar a biblioteca MSAL. Na mesma pasta que o arquivo .xcodeproj do projeto, se o arquivo podfile não existir, crie um arquivo vazio e nomeie-o como 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 obter mais informações, consulte Referência de sintaxe podfile.
Em uma janela de terminal, vá para a pasta que contém o arquivo podfile e execute a instalação do pod para instalar a biblioteca MSAL.
Depois de executar o pod install comando, um <arquivo name.xcworkspace> do projeto será criado. Para recarregar o projeto no Xcode, feche o Xcode e abra o arquivo <nome do seu projeto>.xcworkspace.

Etapa 2: Definir o esquema de URL do aplicativo

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

O formato de URI de redirecionamento padrão da 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.

Nesta etapa, registre seu esquema de URL usando a CFBundleURLSchemes matriz. 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 seguinte trecho de código 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>

Etapa 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 do usuário.
Contém informações sobre seu provedor de identidade do Azure AD B2C. O aplicativo usa essas informações 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 local UIViewController em que os usuários se autentiquem. Na sua UIViewController, mescle o código com o código fornecido no GitHub.

Etapa 4: Configurar seu aplicativo iOS Swift

Depois de adicionar o código 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 UIViewController classe escolhida na seção anterior.

Para saber como configurar seu aplicativo iOS Swift, consulte 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

Crie e execute o projeto com um simulador de um dispositivo iOS conectado.
Selecione Entrar e inscreva-se ou entre com sua conta local ou social do Azure AD B2C.
Depois de autenticar com êxito, você verá seu nome de exibição na barra de navegação.

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

Esta seção descreve os blocos de construção de código que habilitam a autenticação para seu aplicativo iOS Swift. Ele lista os métodos do UIViewController e discute como personalizar seu código.

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

Aplicativos cliente públicos não são confiáveis para manter com segurança os segredos do aplicativo e eles não têm segredos do cliente. No viewDidLoad, instancie uma MSAL usando um objeto de aplicativo cliente público.

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

O objeto de configuração fornece informações sobre seu 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 initWebViewParams método configura a experiência de autenticação interativa .

O trecho de código Swift a seguir inicializa o membro da classe webViewParameters com o visualizador da web do sistema. Para obter mais informações, consulte Personalizar navegadores e WebViews 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 se inscrever ou entrar usando o modo de exibição da Web do sistema. Quando os usuários selecionam o botão Entrar, o authorizationButton método é chamado.

O authorizationButton método prepara o MSALInteractiveTokenParameters objeto com dados relevantes sobre a solicitação de autorização. O método acquireToken usa o MSALInteractiveTokenParameters para autenticar usuários via a visão geral do sistema na Web.

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 concluirem o fluxo de autorização, com êxito ou sem êxito, o resultado será retornado para o fechamento do acquireToken método.

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

Atualize a interface do usuário do aplicativo 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.
Manipular 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 de um token de acesso válido. O aplicativo faz o seguinte:

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 acquireTokenSilent método faz 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, uma exceção será retornada. Nesse caso, você deve solicitar que o usuário entre interativamente.

O snippet de código a seguir 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 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: Desconscreve 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. Por exemplo, você pode ocultar elementos de interface do usuário protegidos, ocultar o botão de saída ou mostrar o botão de entrada.

O snippet de código a seguir demonstra como desconscrever 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:

Comentários

Esta página foi útil?

Last updated on 2025-05-02