Firebase App Check para plataformas Apple

1. Introdução

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

Você pode aprender 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 aplicativo 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 aplicativos e dispositivos da Apple.

O que você vai construir

Neste codelab, você adicionará e aplicará o App Check em um aplicativo de amostra existente para que o Realtime Database do projeto seja protegido contra acesso por aplicativos e dispositivos ilegítimos.

O que você aprenderá

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

O que você precisará

  • Xcode 13.3.1 ou posterior
  • Uma conta de desenvolvedor da Apple que permite criar novos identificadores de aplicativos
  • Um dispositivo iOS/iPadOS compatível com App Attest (saiba mais sobre a disponibilidade da API App Attest )

2. Obtenha o projeto inicial

O repositório Firebase Quickstarts para iOS contém exemplos de aplicativos para demonstrar diferentes produtos Firebase. Você usará o app Firebase Database Quickstart para SwiftUI como base para este codelab.

Clone o repositório Firebase Quickstarts para iOS na linha de comando:

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

Abra o projeto do aplicativo Realtime Database SwiftUI Quickstart no Xcode:

cd database/DatabaseExampleSwiftUI/DatabaseExample
xed .

3. Adicione o App Check ao seu aplicativo

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

4. Crie e instale a fábrica do provedor App Check

  1. No grupo de arquivos Shared , adicione um novo grupo chamado AppCheck .
  2. Dentro deste 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, em DatabaseExampleApp.swift , certifique-se de importar FirebaseAppCheck e defina uma instância da classe MyAppCheckProviderFactory como a fábrica do provedor 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. Crie e configure um projeto Firebase

Para usar o App Check em seu projeto iOS, você precisa seguir estas etapas no console do Firebase:

  • Configure um projeto do Firebase.
  • Adicione seu aplicativo iOS ao projeto Firebase.
  • Configure a Autenticação do Firebase.
  • Inicialize a instância do Realtime Database que você vai proteger.
  • Configurar verificação de aplicativo.

Criar um projeto

Primeiro, você precisa criar um projeto Firebase.

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

Criar uma instância de banco de dados em tempo real

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

  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 ) para o banco de dados inalterado e clique em Next .
  3. Certifique-se de que o Modo bloqueado esteja selecionado e clique no botão Habilitar para habilitar as Regras de segurança para seu banco de dados.
  4. Navegue até 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.

Prepare seu aplicativo iOS para ser conectado ao Firebase

Para poder executar o aplicativo de amostra em um dispositivo físico, você precisa adicionar o projeto à sua equipe de desenvolvimento para que o Xcode possa gerenciar o perfil de provisionamento necessário para você. Siga estas etapas para adicionar o aplicativo de amostra à 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ê deve ver uma mensagem de erro dizendo "A assinatura do DatabaseExample (iOS) requer uma equipe de desenvolvimento" .
  4. Atualize o identificador de pacote para um identificador exclusivo. A maneira mais fácil de conseguir isso é usando o nome de domínio reverso do seu site, por exemplo, com.acme.samples.firebase.quickstart.DatabaseExample (não use esse ID; escolha seu próprio ID exclusivo).
  5. Selecione sua equipe de desenvolvimento.
  6. Você saberá que tudo correu bem quando o Xcode exibir "Provisioning Profile: Xcode Managed Profile" e um pequeno ícone de informações próximo a este rótulo. Clicar neste ícone exibirá mais detalhes sobre o perfil de provisionamento.

Conecte seu aplicativo iOS

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

  1. Na tela Visão geral do projeto do seu novo projeto, clique no botão + Adicionar aplicativo e, em seguida, clique no ícone iOS+ para adicionar um novo aplicativo iOS ao seu projeto Firebase.
  2. Insira o ID do pacote do seu aplicativo (use aquele que você definiu na seção anterior, como com.acme.samples.firebase.quickstart.DatabaseExample - lembre-se de que deve ser um identificador exclusivo)
  3. Clique em Registrar aplicativo .
  4. O Firebase gera um arquivo GoogleService-Info.plist contendo todos os metadados do Firebase necessários para seu aplicativo.
  5. Clique em Baixar GoogleService-Info.plist para baixar o arquivo.
  6. No Xcode, você verá que o projeto já contém um arquivo chamado GoogleService-Info.plist . Exclua este arquivo primeiro - você o substituirá pelo de seu próprio projeto do Firebase na próxima etapa.
  7. Copie o arquivo GoogleService-Info.plist que você baixou na etapa anterior para a pasta raiz do seu projeto Xcode e adicione-o ao destino DatabaseExample (iOS) , certificando-se de que se chama GoogleService-Info.plist
  8. Clique nas etapas restantes do fluxo de registro. Como o projeto de amostra já está configurado corretamente, não é necessário fazer alterações no código.

Configurar autenticação do Firebase

Ufa! Isso é um pouco de configuração até agora, mas segure firme! Se você é novo no Firebase, já viu partes essenciais de um fluxo de trabalho com o qual logo estará familiarizado.

Agora, você configurará o Firebase Authentication para este aplicativo.

Habilitar 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 entrada .
  4. Selecione E-mail/Senha na seção Provedores nativos .
  5. Habilite 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 .

Leve o aplicativo para dar uma volta

Volte para o Xcode e execute o aplicativo no iOS Simulator. Entre com o e-mail e a senha do usuário de teste que você acabou de criar. Uma vez conectado, crie uma postagem, poste um comentário em uma postagem existente e marque/desmarque postagens.

6. Configure um provedor de atestado de App Attest

Nesta etapa, você configurará o App Check para usar o provedor App Attest no Firebase console.

  1. No console do Firebase, navegue até a seção App Check do console.
  2. Clique em Começar .
  3. Na guia Aplicativos , clique no seu aplicativo para expandir seus detalhes.
  4. Clique em App Attest para configurar o App Attest e, em seguida, insira o Team ID da sua conta de desenvolvedor Apple (você pode encontrá-lo na seção Membership no portal Apple Developer): 1645f7a369b678c2.png
  5. Clique em Salvar .

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

Agora você está pronto para configurar nosso serviço de atestado específico! Para obter mais informações sobre esse fluxo de trabalho, consulte Ativar verificação de aplicativo com App Attest no iOS .

7. Configure o App Attest para seu aplicativo

Agora é hora de colocar as mãos no Firebase App Check SDK e implementar algum código de cliente.

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

  1. Adicione o recurso App Attest para seu destino de aplicativo no projeto Xcode:
  2. abra a guia Assinatura e recursos nas configurações de destino do aplicativo
  3. clique no botão " + "
  4. na caixa de diálogo, localize e selecione o recurso App Attest ae84cd988a5fab31.png
  5. Um arquivo DatabaseExample (iOS).entitlements aparecerá na pasta raiz do seu projeto Xcode após executar a etapa anterior.
  6. No arquivo DatabaseExample (iOS).entitlements , altere o valor da chave App Attest Environment para production.

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

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

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

O provedor Firebase App Check Debug possibilita testar aplicativos com 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 juntos.

Instale o provedor de depuração do Firebase em seu aplicativo

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

Você fez a maior parte disso quando criou a fábrica de provedores do App Check. Nesta etapa, você adicionará o log do segredo de depuração local gerado pelo provedor de depuração, para poder registrar esta instância do aplicativo 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 nos dá mais flexibilidade para configurar o App Check dependendo do ambiente. Por exemplo, você pode usar outros provedores de atestado como DeviceCheck ou um provedor de atestado personalizado em versões do sistema operacional 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, você pode instalar temporariamente ou condicionalmente o AppCheckDebugProviderFactory antes de configurar a instância do aplicativo Firebase:

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

  AppCheck.setAppCheckProviderFactory(providerFactory)

  FirebaseApp.configure()
}

Isso economizará algumas linhas de código na criação de sua própria fábrica de provedores de App Check.

Registre seu segredo de depuração no console do Firebase

Obtenha o segredo de depuração do seu simulador iOS

  1. Se você escolheu instalar AppCheckDebugProviderFactory (opção 2 acima), você precisa habilitar o registro de depuração para seu aplicativo adicionando -FIRDebugEnabled aos argumentos de inicialização do aplicativo: f1c6b477a373e144.png
  2. Execute seu aplicativo em um Simulador
  3. Encontre o segredo de depuração no console do Xcode. Você pode usar o filtro do console para encontrá-lo mais rapidamente: d4c65af93e369c55.png

Observação: o segredo de depuração é gerado para seu simulador na primeira inicialização do aplicativo e é armazenado nos padrões do usuário. Se você remover o aplicativo, redefinir o simulador ou usar outro simulador, um novo segredo de depuração será gerado. Certifique-se de registrar o novo segredo de depuração.

Registre o segredo de depuração

  1. De volta ao console Firevbase, vá para a seção App Check .
  2. Na guia Aplicativos , clique no seu aplicativo para expandir seus detalhes.
  3. No menu flutuante, selecione Gerenciar tokens de depuração : d77c8ff768a00b4b.png
  4. Adicione o segredo que você copiou do console do Xcode e clique em Salvar f845c97b86f694d0.png

Após essas etapas, você pode usar o aplicativo no Simulador mesmo com o App Check aplicado.

Observação: o provedor de depuração foi projetado especificamente para ajudar a evitar vazamentos de segredos de depuração. Com a abordagem atual, você não precisa armazenar o segredo de depuração em seu código-fonte.

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

9. Ative a aplicação do App Check para o Firebase Realtime Database

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

Agora, você precisa ativar a aplicação do App Check para garantir que o aplicativo Firebase possa ser acessado apenas de dispositivos legítimos. As versões antigas do aplicativo sem integração com o App Check deixarão de funcionar assim que você habilitar a aplicação para o projeto Firebase.

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

64e6a81fa979b635.png

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

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

Tente acessar o Realtime Database com um aplicativo ilegítimo

Para ver 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 aplicativo em DatabaseExampleApp .
  2. Redefina o simulador selecionando Dispositivo > Apagar todo o conteúdo e configurações . Isso limpará o Simulador (e invalidará o token do dispositivo).
  3. Execute o aplicativo novamente no Simulador.
  4. Agora você deve 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 o comentário do código de registro do App Check em DatabaseExampleApp .
  2. Reinicie o aplicativo.
  3. Tome nota do novo token App Check no console do Xcode.
  4. Registre o token de depuração nas configurações do App Check do seu aplicativo no Firebase console.
  5. Execute novamente o aplicativo.
  6. Você não verá mais uma mensagem de erro e poderá adicionar novas postagens e comentários no aplicativo.

10. Parabéns!

9785d32f18b995d2.gif

Agora você sabe como:

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

Próximos passos

Saiba como usar o Remote Config para distribuir gradualmente o App Check para seus usuários no codelab Implantar gradualmente o Firebase App Check usando o Firebase Remote Config

Estes são outros recursos que você pode achar ú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 a seguir para obter mais detalhes: