Firebase App Check para plataformas 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 pode ser usado pelo App Check para verificar a autenticidade de dispositivos e apps da Apple.

O que você vai criar

Neste codelab, você vai adicionar e aplicar o App Check em um aplicativo de exemplo existente para que o Realtime Database do projeto não seja acessado por 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.

O que é necessário

• Xcode 13.3.1 ou versões mais recentes
• Uma conta de desenvolvedor da Apple que permite criar 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:ainda é possível 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 início rápido do Firebase para iOS contém apps de amostra 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 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 de início rápido do SwiftUI do Realtime Database no Xcode:

cd database/DatabaseExampleSwiftUI/DatabaseExample
xed .

3. Adicionar o App Check ao seu app

1. Aguarde o Gerenciador de pacotes do Swift resolver as dependências do projeto.
2. Abra a guia Geral do destino de app DatabaseExample (iOS). Em seguida, na seção Estruturas, 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, e não se esqueça 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, em 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:

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

Criar um projeto

Primeiro, você precisa criar um projeto do Firebase.

1. No Console do Firebase, selecione Adicionar projeto.
2. Dê o nome App Check Codelab ao projeto
3. Clique em Continuar.
4. Desative o Google Analytics neste projeto e clique em Criar projeto.

Criar uma instância do Realtime Database

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. Deixe o local padrão (us-central1) do banco de dados inalterado e clique em Next.
3. Verifique se o Modo bloqueado está selecionado e clique no botão Ativar para ativar as regras de segurança do seu banco de dados.
4. Acesse a guia Regras do navegador do Realtime Database e substitua as regras padrão pelo seguinte:

   {
       "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 conexão com o Firebase

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

1. No Xcode, selecione o projeto DatabaseExample no navegador do projeto.
2. Selecione o destino DatabaseExample (iOS) e abra a guia Signing & Capabilities.
3. Você verá a mensagem de erro "Signing for DatabaseExample (iOS) requer a Development team".
4. Atualize o identificador do pacote para 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 a equipe de desenvolvimento.
6. Você vai saber que tudo deu certo quando o Xcode mostrar "Perfil de provisionamento: perfil gerenciado do Xcode" e um pequeno ícone de informações ao lado do marcador. Clique neste ícone para exibir mais detalhes sobre o perfil de provisionamento.

Importante:não fornecer um identificador de pacote exclusivo vai impedir que seu projeto seja 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, confira a documentação sobre como adicionar o Firebase ao 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 do iOS+ para adicionar um novo app iOS ao seu projeto do Firebase.
2. Insira o ID do pacote do seu app (use o que você definiu na seção anterior, como com.acme.samples.firebase.quickstart.DatabaseExample. Lembre-se de que esse 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 o app.
5. Clique em Fazer o download do GoogleService-Info.plist para fazer o download do arquivo.
6. No Xcode, você vai ver que o projeto já contém um arquivo chamado GoogleService-Info.plist. Exclua esse arquivo primeiro. Na próxima etapa, ele será substituído pelo do seu projeto do Firebase.
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 dele é 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. Essa é muita configuração até agora, mas aguente firme! Se você nunca usou o Firebase, já conheceu as partes essenciais de um fluxo de trabalho que em breve vai conhecer.

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

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

1. Ainda no Console do Firebase, abra a seção Autenticação.
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 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.

Experimente o app

Volte para o Xcode e execute o aplicativo no simulador de iOS. 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 e marque com estrela/remove a estrela de 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 expandir 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 (você pode encontrar essa informação na seção Assinatura do portal Apple Developer):
5. Clique em Salvar.

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

Agora está tudo pronto para 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

Chegou a hora de testar o SDK do Firebase App Check e implementar códigos 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 app venham de instâncias legítimas.

1. Adicione o recurso App Attest para o destino do app no projeto Xcode:
2. Abra a guia Signing & Capabilities nas configurações de destino do app
3. clique no botão "+"
4. Na caixa de diálogo, encontre e selecione o capability App Attest .
5. Um arquivo DatabaseExample (iOS).entitlements aparecerá na pasta raiz do seu projeto Xcode após 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, ao executar o app no Xcode, o App Attest é executado no sandbox ou no modo de desenvolvimento. Portanto, conclua as etapas acima para alternar o modo App Attest. Caso contrário, o Firebase App Attest não realizará a confirmação 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ê vai aplicar o App Check, que vai bloquear 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

Com o provedor de depuração do Firebase App Check, é possível testar aplicativos com a aplicação do Firebase App Check em ambientes não confiáveis, incluindo o iOS Simulator, durante o processo de desenvolvimento. Em seguida, você precisa configurar o provedor de depuração em conjunto.

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 fábrica

Você fez a maior parte disso ao criar a fábrica do provedor do App Check. Nesta etapa, você adicionará a geração de registros do secret local de depuração gerado pelo provedor de depuração. Assim, você poderá registrar essa instância do app no console do Firebase para fins de depuração.

Atualize o 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 nos dá mais flexibilidade para configurar o App Check dependendo do ambiente. Por exemplo, é possível usar outros provedores de atestado, como o DeviceCheck, ou um provedor de atestado personalizado em versões de 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 o AppCheckDebugProviderFactory

Para casos mais simples, é possível instalar o AppCheckDebugProviderFactory de maneira 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ê vai economizar algumas linhas de código ao criar sua própria fábrica do provedor do App Check.

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

Acessar a chave secreta de depuração no simulador do iOS

1. Se você optar por instalar o AppCheckDebugProviderFactory (opção 2 acima), ative a geração de registros de depuração para seu 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. Você pode usar o filtro do console para encontrá-lo 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, uma nova chave secreta de depuração será gerada. Registre o novo secret de depuração.

Registrar o secret de depuração

1. Volte ao console do Firevbase e acesse a seção App Check.
2. Na guia Apps, clique no seu app para expandir 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 Save

Após essas etapas, você poderá usar o app no Simulator 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.

Confira mais detalhes sobre esse fluxo na documentação. Consulte Usar o App Check com o provedor de depuração no iOS.

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

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

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

Cuidado:em um aplicativo ativo com usuários atuais, não ative a aplicação, a menos que você tenha certeza de que os usuários migraram para a nova versão do app que pode ser aprovada no atestado do App Check. Todos os usuários reais que usam o app antigo sem a integração do App Check vão perder o acesso ao Realtime Database, mesmo se usarem o serviço em dispositivos legítimos.

Para facilitar a transição dos usuários, você geralmente precisa lançar o app integrado ao App Check com antecedência e não aplicar o projeto do Firebase 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.

Após 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. Desative o registro do App Check comentando o código de registro do App Check no método init do ponto de entrada do app em DatabaseExampleApp.
2. Para redefinir o simulador, selecione Dispositivo > Apagar todo o conteúdo e configurações. Isso vai excluir permanentemente o simulador e invalidar 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 no arquivo 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 do 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 atual
• 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 o app em um simulador
• Acompanhe 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

Saiba como usar a Configuração remota para lançar gradualmente o App Check para seus usuários no codelab Lançar 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 permite que você tenha mais flexibilidade, se necessário. Confira mais detalhes nos links abaixo:

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