Firebase App Check para plataformas da Apple

1. Introdução

O Firebase App Check ajuda a proteger seus recursos de back-end contra abusos, como fraude de faturamento e phishing, garantindo que as solicitações venham de apps e dispositivos legítimos. Ele funciona com os serviços do Firebase e com seus próprios serviços de back-end para manter os recursos seguros.

Saiba mais sobre o Firebase App Check na documentação do Firebase.

O App Check usa serviços específicos da plataforma para verificar a integridade de um app e/ou dispositivo. Esses serviços são chamados de provedores de atestado. Um desses provedores é o serviço App Attest da Apple, que o App Check pode usar para verificar a autenticidade de apps e dispositivos da Apple.

O que você vai criar

Neste codelab, você vai adicionar e aplicar o App Check a um aplicativo de amostra para que o Realtime Database do projeto esteja protegido contra o acesso de apps e dispositivos ilegítimos.

O que você aprenderá

• Como adicionar o Firebase App Check a um app existente.
• Como instalar diferentes provedores de atestado do Firebase App Check.
• Como configurar o App Attest para seu app.
• Como configurar o provedor de atestado de depuração para testar seu app em simuladores durante o desenvolvimento de apps.

O que é necessário

• Xcode 13.3.1 ou versões mais recentes
• Uma conta de desenvolvedor da Apple que permita a criação de novos identificadores de apps
• Um dispositivo iOS/iPadOS compatível com o App Attest (saiba mais sobre a disponibilidade da API App Attest)

Observação:você ainda pode concluir este codelab sem uma conta de desenvolvedor da Apple e um dispositivo qualificado. Nesse caso, você só poderá executar o app em um simulador com um provedor de depuração do Firebase App Check.

2. Acessar o projeto inicial

O repositório de guias de início rápido do Firebase para iOS contém aplicativos de exemplo para demonstrar diferentes produtos do Firebase. Você usará o app de início rápido do Firebase Database para SwiftUI como base para este codelab.

Clone o repositório do Guia de início rápido do Firebase para iOS na linha de comando:

git clone https://github.com/firebase/quickstart-ios.git
cd quickstart-ios

Abra o projeto do app Guia de início rápido da SwiftUI do Realtime Database no Xcode:

cd database/DatabaseExampleSwiftUI/DatabaseExample
xed .

3. Adicionar o App Check ao seu app

1. Aguarde o Swift Package Manager resolver as dependências do projeto.
2. Abra a guia General do destino do app DatabaseExample (iOS). Depois, na seção Frameworks, bibliotecas e conteúdo incorporado, clique no botão +.
3. Selecione para adicionar FirebaseAppCheck.

4. Criar e instalar a fábrica do provedor do App Check

1. No grupo de arquivos Shared, adicione um novo grupo chamado AppCheck.
2. Dentro desse grupo, crie uma classe de fábrica em um arquivo separado, por exemplo, MyAppCheckProviderFactory.swift, certificando-se de adicioná-la ao destino DatabaseExample (iOS):

   import Firebase
   
   class MyAppCheckProviderFactory: NSObject, AppCheckProviderFactory {
     func createProvider(with app: FirebaseApp) -> AppCheckProvider? {
       #if targetEnvironment(simulator)
         // App Attest is not available on simulators.
         // Use a debug provider.
         return AppCheckDebugProvider(app: app)
       #else
         // Use App Attest provider on real devices.
         return AppAttestProvider(app: app)
       #endif
     }
   }
   

3. Em seguida, no DatabaseExampleApp.swift, importe FirebaseAppCheck e defina uma instância da classe MyAppCheckProviderFactory como a fábrica do provedor do App Check.

   import SwiftUI
   import FirebaseCore
   import FirebaseAppCheck
   
   @main
   struct DatabaseExampleApp: App {
     init() {
       // Set an instance of MyAppCheckProviderFactory as an App Check
       // provider factory before configuring Firebase.
       AppCheck.setAppCheckProviderFactory(MyAppCheckProviderFactory())
       FirebaseApp.configure()
     }
     ...
   }
   

5. Criar e configurar um projeto do Firebase

Para usar o App Check no seu projeto do iOS, siga estas etapas no Console do Firebase:

• Configurar um projeto do Firebase
• Adicionar o app iOS ao projeto do Firebase.
• Configure o Firebase Authentication.
• Inicialize a instância do Realtime Database que você vai proteger.
• Configure o App Check.

Criar um projeto

Primeiro, você precisa criar um projeto do Firebase.

1. No Console do Firebase, selecione Adicionar projeto.
2. Nomeie seu projeto como App Check Codelab
3. Clique em Continuar.
4. Desative o Google Analytics neste projeto e clique em Criar projeto.

Criar uma instância do Realtime Database

Agora navegue até a seção Realtime Database do Console do Firebase.

1. Clique no botão Criar banco de dados para iniciar o fluxo de trabalho de criação do banco de dados.
2. Mantenha o local padrão (us-central1) do banco de dados e clique em Próxima.
3. Verifique se o Modo bloqueado está selecionado e clique no botão Ativar para ativar as regras de segurança do banco de dados.
4. Acesse a guia Regras do navegador do Realtime Database e substitua as regras padrão pelas seguintes:

   {
       "rules": {
           // User profiles are only readable/writable by the user who owns it
           "users": {
               "$UID": {
                   ".read": "auth.uid == $UID",
                   ".write": "auth.uid == $UID"
               }
           },
           // Posts can be read by anyone but only written by logged-in users.
           "posts": {
               ".read": true,
               ".write": "auth.uid != null",
               "$POSTID": {
                   // UID must match logged in user and is fixed once set
                   "uid": {
                       ".validate": "(data.exists() && data.val() == newData.val()) || newData.val() == auth.uid"
                   },
                   // User can only update own stars
                   "stars": {
                       "$UID": {
                           ".validate": "auth.uid == $UID"
                       }
                   }
               }
           },
           // User posts can be read by anyone but only written by the user that owns it,
           // and with a matching UID
           "user-posts": {
               ".read": true,
               "$UID": {
                   "$POSTID": {
                       ".write": "auth.uid == $UID",
                       ".validate": "data.exists() || newData.child('uid').val() == auth.uid"
                   }
               }
           },
           // Comments can be read by anyone but only written by a logged in user
           "post-comments": {
               ".read": true,
               ".write": "auth.uid != null",
               "$POSTID": {
                   "$COMMENTID": {
                       // UID must match logged in user and is fixed once set
                       "uid": {
                           ".validate": "(data.exists() && data.val() == newData.val()) || newData.val() == auth.uid"
                       }
                   }
               }
           }
       }
   }
   

5. Clique no botão Publicar para ativar as regras de segurança atualizadas.

Preparar seu app iOS para ser conectado ao Firebase

Para executar o app de exemplo em um dispositivo físico, adicione o projeto à sua equipe de desenvolvimento para que o Xcode possa gerenciar o perfil de provisionamento necessário. Siga estas etapas para adicionar o app de exemplo à sua conta de desenvolvedor:

1. No Xcode, selecione o projeto DatabaseExample no navegador de projetos.
2. Selecione o destino DatabaseExample (iOS) e abra a guia Signing & Capabilities.
3. Você verá a mensagem de erro "Assinando o DatabaseExample (iOS) requer uma equipe de desenvolvimento".
4. Atualize o identificador do pacote com um identificador exclusivo. A maneira mais fácil de fazer isso é usando o nome de domínio inverso do seu site, por exemplo, com.acme.samples.firebase.quickstart.DatabaseExample. Não use esse ID, escolha um ID exclusivo.
5. Selecione sua equipe de desenvolvimento.
6. Você saberá que tudo correu bem quando o Xcode exibir "Perfil de provisionamento: perfil gerenciado do Xcode" e um pequeno ícone de informação ao lado desse marcador. Clique nesse ícone para ver mais detalhes sobre o perfil de provisionamento.

Importante:se você não fornecer um identificador de pacote exclusivo, seu projeto não será registrado no portal para desenvolvedores da Apple. Somente apps registrados podem ser executados em um dispositivo físico.

Conectar seu app iOS

Para uma explicação detalhada sobre como conectar seu app, consulte a documentação sobre como adicionar o Firebase ao seu projeto do iOS. Para começar, siga estas etapas principais no Console do Firebase:

1. Na tela Visão geral do projeto do novo projeto, clique no botão + Adicionar app e no ícone iOS+ para adicionar um novo app iOS ao projeto do Firebase.
2. Insira o ID do pacote do seu app. Use o ID definido na seção anterior, como com.acme.samples.firebase.quickstart.DatabaseExample. Lembre-se de que ele precisa ser um identificador exclusivo
3. Clique em Registrar app.
4. O Firebase gera um arquivo GoogleService-Info.plist que contém todos os metadados necessários do Firebase para seu app.
5. Clique em Fazer o download do GoogleService-Info.plist para fazer o download do arquivo.
6. No Xcode, você verá que o projeto já contém um arquivo chamado GoogleService-Info.plist. Exclua esse arquivo primeiro. Você o substituirá pelo do seu projeto do Firebase na próxima etapa.
7. Copie o arquivo GoogleService-Info.plist que você salvou na etapa anterior na pasta raiz do seu projeto Xcode e adicione-o ao destino DatabaseExample (iOS), certificando-se de que o nome seja GoogleService-Info.plist
8. Clique nas etapas restantes do fluxo de registro. Como o projeto de exemplo já está configurado corretamente, não é necessário fazer alterações no código.

Configure o Firebase Authentication

Ufa. A configuração já foi bem parecida, mas espere um pouco. Se você é iniciante no Firebase, viu partes essenciais de um fluxo de trabalho com as quais logo conhecerá.

Agora você vai configurar o Firebase Authentication para esse app.

Ativar provedor de login de e-mail/senha de autenticação

1. Ainda no Console do Firebase, abra a seção Autenticação do console.
2. Clique em Começar para configurar o Firebase Authentication para seu projeto.
3. Selecione a guia Método de login.
4. Selecione E-mail/senha na seção Provedores nativos.
5. Ative a opção E-mail/senha e clique em Salvar.

Adicionar um usuário de teste

1. Abra a guia Usuários da seção Autenticação.
2. Clique em Adicionar usuário.
3. Especifique um e-mail e uma senha para o usuário de teste e clique em Adicionar usuário.

Teste o app

Volte para o Xcode e execute o aplicativo no iOS Simulator. Faça login com o e-mail e a senha do usuário de teste que você acabou de criar. Depois de fazer login, crie uma postagem, poste um comentário em uma postagem existente e marque com estrela/remova as estrelas das postagens.

6. Configurar um provedor de atestado do App Attest

Nesta etapa, você vai configurar o App Check para usar o provedor App Attest no Console do Firebase.

1. No Console do Firebase, navegue até a seção App Check.
2. Clique em Começar.
3. Na guia Apps, clique no seu app para abrir os detalhes.
4. Clique em App Attest para configurar o App Attest e insira o ID da equipe da sua conta de desenvolvedor da Apple (disponível na seção Membership do portal Apple Developer):
5. Clique em Salvar.

Com isso, você tem um projeto do Firebase em funcionamento conectado ao nosso novo app, e o App Check está ativado.

Agora você já pode configurar nosso serviço de atestado específico. Para saber mais sobre esse fluxo de trabalho, consulte Ativar o App Check com o App Attest no iOS.

7. Configurar o App Attest para seu aplicativo

Agora é hora de começar a usar o SDK do Firebase App Check e implementar o código do cliente.

Primeiro, você precisa configurar o projeto Xcode para que o SDK possa usar a API App Attest da Apple e garantir que as solicitações enviadas do seu aplicativo venham de instâncias legítimas do aplicativo.

1. Adicione o recurso App Attest ao destino do app no projeto do Xcode:
2. Abra a guia Signing & Capabilities nas configurações do app.
3. Clique no botão "+"
4. Na caixa de diálogo, encontre e selecione o recurso App Attest
5. Um arquivo DatabaseExample (iOS).entitlements vai aparecer na pasta raiz do projeto Xcode depois de concluir a etapa anterior.
6. No arquivo DatabaseExample (iOS).entitlements, mude o valor da chave App Attest Environment para production..

Importante:no momento, o Firebase App Check só oferece suporte ao provedor App Attest quando ele está no modo de produção. Por padrão, quando você executa seu app no Xcode, o App Attest é executado no modo de sandbox ou no modo de desenvolvimento. Portanto, certifique-se de concluir as etapas acima para alternar o modo App Attest. Caso contrário, o Firebase App Check não fará o atestado do dispositivo.

Depois de concluir essas etapas e iniciar o app em um dispositivo iOS físico (iPhone/iPad), o app ainda poderá acessar o Realtime Database. Em uma etapa posterior, você aplicará o App Check, que vai bloquear as solicitações enviadas de apps e dispositivos ilegítimos.

Para saber mais sobre esse fluxo de trabalho, consulte Ativar o App Check com o App Attest no iOS.

8. Configurar um provedor de atestado de depuração para o simulador de iOS

O provedor Firebase App Check Debug possibilita testar aplicativos com a aplicação do Firebase App Check em ambientes não confiáveis, incluindo o simulador de iOS, durante o processo de desenvolvimento. Em seguida, configure o provedor de depuração juntos.

Aviso: o provedor de depuração permite o acesso aos recursos do Firebase em dispositivos não verificados. Nunca use o provedor de depuração nos builds de produção do seu app. Além disso, tenha cuidado para não vazar seu token de depuração.

Instalar o provedor de depuração do Firebase no seu app

Opção 1: criar condicionalmente uma instância do provedor de depuração na sua fábrica

Você fez a maior parte disso quando criou a fábrica do provedor do App Check. Nesta etapa, você adicionará a geração de registros do secret de depuração local gerado pelo provedor de depuração. Assim, será possível registrar essa instância do app no Console do Firebase para fins de depuração.

Atualize MyAppCheckProviderFactory.swift com o seguinte código:

import Firebase

class MyAppCheckProviderFactory: NSObject, AppCheckProviderFactory {
  func createProvider(with app: FirebaseApp) -> AppCheckProvider? {
#if targetEnvironment(simulator)
    // App Attest is not available on simulators.
    // Use a debug provider.
    let provider = AppCheckDebugProvider(app: app)

    // Print only locally generated token to avoid a valid token leak on CI.
    print("Firebase App Check debug token: \(provider?.localDebugToken() ?? "" )")

    return provider
#else
    // Use App Attest provider on real devices.
    return AppAttestProvider(app: app)
#endif
  }
}

Essa abordagem oferece mais flexibilidade para configurar o App Check dependendo do ambiente. Por exemplo, você pode usar outros provedores de atestado, como o DeviceCheck, ou um provedor de atestado personalizado em versões do SO em que o App Attest não está disponível. Veja um exemplo abaixo.

import Firebase

class MyAppCheckProviderFactory: NSObject, AppCheckProviderFactory {
  func createProvider(with app: FirebaseApp) -> AppCheckProvider? {
      #if targetEnvironment(simulator)
      // App Attest is not available on simulators.
      // Use a debug provider.
      let provider = AppCheckDebugProvider(app: app)

      // Print only locally generated token to avoid a valid token leak on CI.
      print("Firebase App Check debug token: \(provider?.localDebugToken() ?? "" )")

      return provider
      #else
      if #available(iOS 14.0, *) {
        // Use App Attest provider on real devices.
        return AppAttestProvider(app: app)
      } else {
        return DeviceCheckProvider(app: app)
      }
      #endif
  }
}

Opção 2: instalar AppCheckDebugProviderFactory

Para casos mais simples, é possível instalar o AppCheckDebugProviderFactory de forma temporária ou condicional antes de configurar a instância do aplicativo do Firebase:

init() {
#if targetEnvironment(simulator)
  let providerFactory = AppCheckDebugProviderFactory()
#else
  let providerFactory = MyAppCheckProviderFactory()
#endif

  AppCheck.setAppCheckProviderFactory(providerFactory)

  FirebaseApp.configure()
}

Com isso, você poupará algumas linhas de código para criar sua própria fábrica de provedor do App Check.

Registrar o secret de depuração no Console do Firebase

Gerar o secret de depuração do simulador de iOS

1. Se você optar por instalar AppCheckDebugProviderFactory (opção 2 acima), será necessário ativar a geração de registros de depuração para o app adicionando -FIRDebugEnabled aos argumentos de inicialização:
2. Executar o app em um simulador
3. Encontre o secret de depuração no console do Xcode. Use o filtro do console para encontrá-las mais rapidamente:

Observação:a chave secreta de depuração é gerada para o simulador na primeira inicialização do app e armazenada nos padrões do usuário. Se você remover o app, redefinir o simulador ou usar outro simulador, um novo secret de depuração será gerado. Registre o novo secret de depuração.

Registrar o secret de depuração

1. De volta ao console do Firevbase, acesse a seção App Check.
2. Na guia Apps, clique no seu app para abrir os detalhes.
3. No menu flutuante, selecione Gerenciar tokens de depuração:
4. Adicione o secret que você copiou do console do Xcode e clique em Salvar

Após essas etapas, você poderá usar o app no simulador mesmo com o App Check aplicado.

Observação:o provedor de depuração foi projetado especificamente para evitar vazamentos de secrets de depuração. Com a abordagem atual, não é necessário armazenar a chave secreta de depuração no código-fonte.

Mais detalhes sobre esse fluxo podem ser encontrados na documentação. Consulte Usar App Check com o provedor de depuração no iOS.

9. Ativar a aplicação do App Check no Firebase Realtime Database

Por enquanto, o app declara uma AppCheckProviderFactory que retorna uma AppAttestProvider para dispositivos reais. Quando executado em um dispositivo físico, o app realiza o atestado e envia os resultados para o back-end do Firebase. No entanto, o back-end do Firebase ainda aceita solicitações de qualquer dispositivo, do iOS Simulator, de um script etc. Esse modo é útil quando você ainda tem usuários com uma versão antiga do seu app sem o App Check e ainda não quer aplicar verificações de acesso.

Agora você precisa ativar a aplicação do App Check para garantir que o app Firebase possa ser acessado apenas de dispositivos legítimos. As versões antigas do app sem integração com o App Check deixarão de funcionar depois que você ativar a aplicação obrigatória no projeto do Firebase.

Atenção:em um aplicativo ativo com usuários atuais, não ative a aplicação obrigatória, a menos que você tenha certeza de que os usuários migraram para a nova versão do app que pode transmitir o atestado do App Check. Todos os usuários reais que usam seu app antigo sem o App Check integrado vão perder o acesso ao Realtime Database, mesmo em dispositivos legítimos.

Para facilitar a transição dos usuários, geralmente é necessário lançar o app integrado ao App Check com antecedência e manter o projeto do Firebase não aplicado por um tempo. As métricas de solicitação do App Check disponíveis no Console do Firebase podem ajudar você a decidir quando é o momento certo para ativar a aplicação.

1. No Console do Firebase, na seção App Check, clique em Realtime Database para expandir os detalhes.
2. Clique em Aplicar.

3. Leia as informações na caixa de diálogo de confirmação e clique em Aplicar.

Depois de concluir essas etapas, apenas apps legítimos poderão acessar o banco de dados. Todos os outros apps serão bloqueados.

Tentar acessar o Realtime Database com um app ilegítimo

Para conferir a aplicação do App Check em ação, siga estas etapas:

1. Para desativar o registro do App Check, comente o código de registro no método init do ponto de entrada do seu app em DatabaseExampleApp.
2. Para redefinir o simulador, selecione Dispositivo > Apagar Conteúdo e Ajustes. Essa ação exclui permanentemente os dados do simulador e invalida o token do dispositivo.
3. Execute o app novamente no simulador.
4. Agora você verá a seguinte mensagem de erro:

   [FirebaseDatabase][I-RDB034005] Firebase Database connection was forcefully killed by the server.  Will not attempt reconnect. Reason: Invalid appcheck token.
   

Para reativar o App Check, faça o seguinte:

1. Remova a marca de comentário do código de registro do App Check em DatabaseExampleApp.
2. Reinicie o app.
3. Anote o novo token do App Check no console do Xcode.
4. Registre o token de depuração nas configurações do App Check no seu app no Console do Firebase.
5. Execute o app novamente.
6. Você não verá mais uma mensagem de erro e poderá adicionar novas postagens e comentários no app.

10. Parabéns!

Agora você sabe como:

• Adicionar o App Check a um projeto existente
• Configurar um provedor de atestado do App Attest para a versão de produção do seu app
• Configurar um provedor de atestado de depuração para testar seu app em um simulador
• Observe o lançamento da versão do app para saber quando aplicar o App Check ao seu projeto do Firebase
• Ativar a aplicação obrigatória do App Check

Próximas etapas

Aprenda a usar a Configuração remota para lançar gradualmente o App Check aos seus usuários no codelab Implantar gradualmente o Firebase App Check usando a Configuração remota do Firebase

Estes são outros recursos que podem ser úteis

A configuração descrita neste codelab funcionará na maioria dos casos, mas o App Check oferece mais flexibilidade, se necessário. Confira os links abaixo para mais detalhes:

• Repositório de guias de início rápido do Firebase para iOS
• Ativar o App Check com o App Attest no iOS
• Firebase App Check na documentação do Firebase
• Como estabelecer a integridade do seu app
• Registrar um ID de app
• Ativar recursos do app