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 faturamento e phishing, garantindo que as solicitações venham de aplicativos e dispositivos legítimos. Ele funciona com os serviços do Firebase e seus próprios serviços de back-end para manter seus recursos seguros.

Você pode saber 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 dos 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ê vai 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 aplicativos de amostra para demonstrar diferentes produtos Firebase. Você usará o aplicativo Firebase Database Quickstart para SwiftUI como base para este codelab.

Clone o repositório do 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á-lo 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 do 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 do 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 do Firebase.

  1. No console do Firebase , selecione Adicionar projeto .
  2. Dê um nome ao 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 do Realtime Database

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

Prepare seu aplicativo iOS para ser conectado ao Firebase

Para poder executar o aplicativo de exemplo 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 Assinatura e recursos .
  3. Você deve ver uma mensagem de erro dizendo "Assinar para DatabaseExample (iOS) requer uma equipe de desenvolvimento" .
  4. Atualize o identificador do 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 ao lado desse 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 do 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 este 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 do 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 seja chamado GoogleService-Info.plist
  8. Clique nas etapas restantes do fluxo de registro. Como o projeto de exemplo já está configurado corretamente, você não precisa fazer nenhuma alteração 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 as quais logo se familiarizará.

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

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 Primeiros passos para configurar o Firebase Authentication para seu projeto.
  3. Selecione a guia Método de login .
  4. Selecione Email/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 seu 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. 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, publique um comentário em uma postagem existente e marque/desmarque postagens.

6. Configure um provedor de atestado de atestado de aplicativo

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 App Attest e, em seguida, insira o ID da equipe de sua conta de desenvolvedor da Apple (você pode encontrá-lo na seção Membership no portal de desenvolvedor da Apple): 1645f7a369b678c2.png
  5. Clique em Salvar .

Com isso, você tem um projeto do Firebase em funcionamento que está 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 saber mais sobre esse fluxo de trabalho, consulte Habilitar verificação de aplicativo com atestado de aplicativo 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 do seu aplicativo venham de instâncias legítimas do 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 seu 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 depois de 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á 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 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 no seu aplicativo

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

Você fez a maior parte disso quando criou a fábrica do provedor App Check. Nesta etapa, você adicionará o registro do segredo de depuração local gerado pelo provedor de depuração para poder registrar essa 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 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 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 verificação de aplicativos.

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

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

  1. Se você optar por instalar AppCheckDebugProviderFactory (opção 2 acima), precisará 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 do 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 segredo 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 ser executado 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 iOS Simulator, de um script etc. Esse modo é útil quando você ainda tem usuários com uma versão antiga do seu aplicativo sem 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 app sem integração do App Check deixarão de funcionar assim que você ativar a aplicação do projeto do Firebase.

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

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 seu 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. Descomente o código de registro do App Check em DatabaseExampleApp .
  2. Reinicie o aplicativo.
  3. Anote o 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
  • Configurar um provedor de atestado de atestado de aplicativo 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

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

Estes são outros recursos que podem ser úteis