Sprawdzanie aplikacji Firebase na platformy Apple

1. Wstęp

Firebase App Check pomaga chronić zasoby zaplecza przed nadużyciami, takimi jak oszustwa w rozliczeniach i wyłudzanie informacji, dzięki upewnieniu się, że żądania pochodzą z legalnych aplikacji i urządzeń. Współpracuje zarówno z usługami Firebase, jak i Twoimi własnymi usługami zaplecza, aby zapewnić bezpieczeństwo Twoich zasobów.

Więcej informacji o Sprawdzaniu aplikacji Firebase znajdziesz w dokumentacji Firebase.

Kontrola aplikacji korzysta z usług specyficznych dla platformy, aby zweryfikować integralność aplikacji i/lub urządzenia. Usługi te nazywane są dostawcami atestacji . Jednym z takich dostawców jest usługa App Attest firmy Apple, za pomocą której App Check może weryfikować autentyczność aplikacji i urządzeń Apple.

Co zbudujesz

W tym laboratorium programowania dodasz i wymusisz sprawdzanie aplikacji w istniejącej przykładowej aplikacji, aby baza danych czasu rzeczywistego projektu była chroniona przed dostępem do nielegalnych aplikacji i urządzeń.

Czego się nauczysz

  • Jak dodać Sprawdzanie aplikacji Firebase do istniejącej aplikacji.
  • Jak zainstalować różnych dostawców atestacji Firebase App Check.
  • Jak skonfigurować Atest aplikacji dla swojej aplikacji.
  • Jak skonfigurować dostawcę zaświadczania debugowania do testowania aplikacji na symulatorach podczas tworzenia aplikacji.

Co będziesz potrzebował

  • Xcode 13.3.1 lub nowszy
  • Konto Apple Developer, które umożliwia tworzenie nowych identyfikatorów aplikacji
  • Urządzenie z systemem iOS/iPadOS, które obsługuje App Attest (dowiedz się więcej o dostępności interfejsu App Attest API )

2. Pobierz projekt startowy

Repozytorium Firebase Quickstarts dla iOS zawiera przykładowe aplikacje do prezentacji różnych produktów Firebase. Jako podstawy do tego ćwiczenia z programowania użyjesz aplikacji Firebase Database Quickstart dla SwiftUI.

Sklonuj repozytorium Szybki start Firebase dla systemu iOS z wiersza poleceń:

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

Otwórz projekt aplikacji Realtime Database SwiftUI Quickstart w Xcode:

cd database/DatabaseExampleSwiftUI/DatabaseExample
xed .

3. Dodaj sprawdzanie aplikacji do swojej aplikacji

  1. Poczekaj, aż Menedżer pakietów Swift rozwiąże zależności projektu.
  2. Otwórz kartę Ogólne celu aplikacji DatabaseExample (iOS) . Następnie w sekcji Frameworks, Libraries i Embedded Content kliknij przycisk + .
  3. Wybierz, aby dodać FirebaseAppCheck .

4. Utwórz i zainstaluj fabrykę dostawcy App Check

  1. W grupie Shared pliki dodaj nową grupę o nazwie AppCheck .
  2. Wewnątrz tej grupy utwórz klasę fabryki w osobnym pliku, np. MyAppCheckProviderFactory.swift , pamiętając o dodaniu jej do obiektu docelowego 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. Następnie w DatabaseExampleApp.swift zaimportuj FirebaseAppCheck i ustaw wystąpienie klasy MyAppCheckProviderFactory jako fabrykę dostawcy 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. Utwórz i skonfiguruj projekt Firebase

Aby użyć Sprawdzania aplikacji w projekcie iOS, musisz wykonać następujące czynności w konsoli Firebase:

  • Skonfiguruj projekt Firebase.
  • Dodaj swoją aplikację na iOS do projektu Firebase.
  • Skonfiguruj Uwierzytelnianie Firebase.
  • Zainicjuj instancję Bazy danych czasu rzeczywistego, którą chcesz chronić.
  • Skonfiguruj sprawdzanie aplikacji.

Utwórz projekt

Najpierw musisz utworzyć projekt Firebase.

  1. W konsoli Firebase wybierz Dodaj projekt .
  2. Nazwij swój projekt App Check Codelab
  3. Kliknij Kontynuuj.
  4. Wyłącz Google Analytics dla tego projektu, a następnie kliknij Utwórz projekt.

Utwórz instancję bazy danych czasu rzeczywistego

Teraz przejdź do sekcji Baza danych czasu rzeczywistego w konsoli Firebase.

  1. Kliknij przycisk Utwórz bazę danych , aby rozpocząć proces tworzenia bazy danych.
  2. Pozostaw domyślną lokalizację bazy danych ( us-central1 ) bez zmian i kliknij Dalej .
  3. Upewnij się, że wybrany jest tryb zablokowany i kliknij przycisk Włącz , aby włączyć reguły bezpieczeństwa dla swojej bazy danych.
  4. Przejdź do zakładki Reguły w przeglądarce Bazy danych czasu rzeczywistego i zastąp domyślne reguły następującymi:
    {
        "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. Kliknij przycisk Publikuj , aby aktywować zaktualizowane reguły bezpieczeństwa.

Przygotuj aplikację na iOS do połączenia z Firebase

Aby móc uruchomić przykładową aplikację na urządzeniu fizycznym, musisz dodać projekt do swojego zespołu programistów, aby Xcode mógł zarządzać wymaganym profilem aprowizacji. Wykonaj te czynności, aby dodać przykładową aplikację do swojego konta programisty:

  1. W Xcode wybierz projekt DatabaseExample w nawigatorze projektów.
  2. Wybierz cel DatabaseExample (iOS) i otwórz kartę Podpisywanie i możliwości .
  3. Powinien pojawić się komunikat o błędzie „Podpisywanie dla DatabaseExample (iOS) wymaga zespołu programistów” .
  4. Zaktualizuj identyfikator pakietu do unikalnego identyfikatora. Najłatwiej to osiągnąć, używając odwrotnej nazwy domeny witryny, na przykład com.acme.samples.firebase.quickstart.DatabaseExample (nie używaj tego identyfikatora; zamiast tego wybierz własny, unikalny identyfikator).
  5. Wybierz swój zespół programistów.
  6. Będziesz wiedział, że wszystko poszło dobrze, gdy Xcode wyświetli „Provisioning Profile: Xcode Managed Profile” i małą ikonę informacyjną obok tej etykiety. Kliknięcie tej ikony spowoduje wyświetlenie więcej szczegółów na temat profilu aprowizacji.

Połącz swoją aplikację na iOS

Szczegółowe informacje na temat łączenia aplikacji znajdziesz w dokumentacji dotyczącej dodawania Firebase do projektu iOS . Aby rozpocząć, wykonaj następujące główne czynności w konsoli Firebase:

  1. Na ekranie Przegląd projektu nowego projektu kliknij przycisk + Dodaj aplikację , a następnie kliknij ikonę iOS+ , aby dodać nową aplikację iOS do projektu Firebase.
  2. Wprowadź identyfikator pakietu swojej aplikacji (użyj tego, który zdefiniowałeś w poprzedniej sekcji, na przykład com.acme.samples.firebase.quickstart.DatabaseExample — pamiętaj, że musi to być unikalny identyfikator)
  3. Kliknij Zarejestruj aplikację .
  4. Firebase generuje plik GoogleService-Info.plist zawierający wszystkie niezbędne metadane Firebase dla Twojej aplikacji.
  5. Kliknij Pobierz GoogleService-Info.plist , aby pobrać plik.
  6. W Xcode zobaczysz, że projekt zawiera już plik o nazwie GoogleService-Info.plist . Najpierw usuń ten plik — w następnym kroku zastąpisz go plikiem z własnego projektu Firebase.
  7. Skopiuj plik GoogleService-Info.plist pobrany w poprzednim kroku do folderu głównego projektu Xcode i dodaj go do obiektu docelowego DatabaseExample (iOS) , upewniając się, że ma on nazwę GoogleService-Info.plist
  8. Kliknij pozostałe kroki procesu rejestracji. Ponieważ przykładowy projekt jest już poprawnie skonfigurowany, nie musisz wprowadzać żadnych zmian w kodzie.

Skonfiguruj uwierzytelnianie Firebase

Uff! Jak na razie to całkiem sporo, ale trzymaj się mocno! Jeśli jesteś nowicjuszem w Firebase, znasz już podstawowe elementy przepływu pracy, z którymi wkrótce się zapoznasz.

Teraz skonfigurujesz Uwierzytelnianie Firebase dla tej aplikacji.

Włącz dostawcę uwierzytelniania e-mail/logowania za pomocą hasła

  1. Nadal w konsoli Firebase otwórz sekcję Uwierzytelnianie konsoli.
  2. Kliknij Rozpocznij , aby skonfigurować Uwierzytelnianie Firebase w swoim projekcie.
  3. Wybierz kartę Metoda logowania .
  4. Wybierz E-mail/hasło w sekcji Dostawcy natywni.
  5. Włącz e-mail/hasło i kliknij Zapisz .

Dodaj użytkownika testowego

  1. Otwórz kartę Użytkownicy w sekcji Uwierzytelnianie .
  2. Kliknij Dodaj użytkownika .
  3. Podaj adres e-mail i hasło użytkownika testowego, a następnie kliknij Dodaj użytkownika .

Zabierz aplikację na przejażdżkę

Wróć do Xcode i uruchom aplikację w symulatorze iOS. Zaloguj się za pomocą adresu e-mail i hasła dla właśnie utworzonego użytkownika testowego. Po zalogowaniu utwórz posta, opublikuj komentarz do istniejącego posta i oznacz posty gwiazdką lub odznacz je.

6. Skonfiguruj dostawcę atestacji aplikacji

W tym kroku skonfigurujesz sprawdzanie aplikacji do korzystania z dostawcy atestów aplikacji w konsoli Firebase.

  1. W konsoli Firebase przejdź do sekcji Kontrola aplikacji konsoli.
  2. Kliknij Rozpocznij .
  3. Na karcie Aplikacje kliknij swoją aplikację, aby rozwinąć jej szczegóły.
  4. Kliknij App Attest , aby skonfigurować App Attest, a następnie wprowadź identyfikator zespołu swojego konta Apple Developer Account (znajdziesz go w sekcji Membership na portalu Apple Developer): 1645f7a369b678c2.png
  5. Kliknij Zapisz .

Dzięki temu masz działający projekt Firebase, który jest połączony z naszą nową aplikacją, a Kontrola aplikacji jest włączona.

Możesz teraz skonfigurować naszą konkretną usługę atestacji! Aby uzyskać więcej informacji o tym przepływie pracy, zobacz Włączanie sprawdzania aplikacji za pomocą zaświadczenia aplikacji w systemie iOS .

7. Skonfiguruj Atest aplikacji dla swojej aplikacji

Teraz nadszedł czas, aby zdobyć pakiet Firebase App Check SDK i zaimplementować kod klienta.

Najpierw musisz skonfigurować projekt Xcode, aby zestaw SDK mógł korzystać z interfejsu API App Attest firmy Apple, aby upewnić się, że żądania wysyłane z Twojej aplikacji pochodzą z legalnych wystąpień Twojej aplikacji.

  1. Dodaj funkcję App Attest dla celu aplikacji w projekcie Xcode:
  2. otwórz kartę Podpisywanie i możliwości w ustawieniach docelowych aplikacji
  3. kliknij przycisk „ +
  4. w oknie dialogowym znajdź i wybierz opcję Atest aplikacji ae84cd988a5fab31.png
  5. Plik DatabaseExample (iOS).entitlements pojawi się w folderze głównym projektu Xcode po wykonaniu poprzedniego kroku.
  6. W pliku DatabaseExample (iOS).entitlements zmień wartość klucza App Attest Environment na production.

Po wykonaniu tych kroków i uruchomieniu aplikacji na fizycznym urządzeniu z systemem iOS (iPhone/iPad), aplikacja nadal będzie mogła uzyskać dostęp do Bazy danych czasu rzeczywistego. Na późniejszym etapie wymusisz sprawdzanie aplikacji, które zablokuje żądania wysyłane z nielegalnych aplikacji i urządzeń.

Aby dowiedzieć się więcej o tym przepływie pracy, zobacz Włączanie sprawdzania aplikacji za pomocą zaświadczenia aplikacji w systemie iOS .

8. Skonfiguruj dostawcę atestacji debugowania dla symulatora iOS

Dostawca debugowania Firebase App Check umożliwia testowanie aplikacji z wymuszeniem Firebase App Check w niezaufanych środowiskach, w tym w symulatorze iOS, podczas procesu tworzenia. Następnie musisz wspólnie skonfigurować dostawcę debugowania.

Zainstaluj dostawcę debugowania Firebase w swojej aplikacji

Opcja 1: Warunkowo utwórz instancję dostawcy debugowania w swojej fabryce

Większość z nich została wykonana podczas tworzenia fabryki dostawców sprawdzania aplikacji. W tym kroku dodasz rejestrowanie lokalnego klucza tajnego debugowania wygenerowanego przez dostawcę debugowania, dzięki czemu możesz zarejestrować to wystąpienie aplikacji w konsoli Firebase na potrzeby debugowania.

Zaktualizuj MyAppCheckProviderFactory.swift za pomocą następującego kodu:

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

Takie podejście daje nam większą elastyczność w konfigurowaniu App Check w zależności od środowiska. Na przykład możesz korzystać z innych dostawców atestacji, takich jak DeviceCheck lub niestandardowego dostawcy atestacji w wersjach systemu operacyjnego, w których App Atest nie jest dostępny. Zobacz przykład poniżej:

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

Opcja 2: Zainstaluj AppCheckDebugProviderFactory

W prostszych przypadkach możesz tymczasowo lub warunkowo zainstalować AppCheckDebugProviderFactory przed skonfigurowaniem instancji aplikacji Firebase:

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

  AppCheck.setAppCheckProviderFactory(providerFactory)

  FirebaseApp.configure()
}

Dzięki temu zaoszczędzisz kilka wierszy kodu podczas tworzenia własnej fabryki dostawców sprawdzania aplikacji.

Zarejestruj klucz tajny debugowania w konsoli Firebase

Uzyskaj sekret debugowania ze swojego symulatora iOS

  1. Jeśli zdecydujesz się zainstalować AppCheckDebugProviderFactory (opcja 2 powyżej), musisz włączyć rejestrowanie debugowania dla swojej aplikacji, dodając -FIRDebugEnabled do argumentów uruchamiania aplikacji: f1c6b477a373e144.png
  2. Uruchom swoją aplikację na symulatorze
  3. Znajdź klucz tajny debugowania w konsoli Xcode. Możesz użyć filtra konsoli, aby szybciej go znaleźć: d4c65af93e369c55.png

Uwaga: klucz tajny debugowania jest generowany dla symulatora przy pierwszym uruchomieniu aplikacji i jest przechowywany w ustawieniach domyślnych użytkownika. Jeśli usuniesz aplikację, zresetujesz symulator lub użyjesz innego symulatora, zostanie wygenerowany nowy klucz tajny debugowania. Pamiętaj, aby zarejestrować nowy klucz tajny debugowania.

Zarejestruj sekret debugowania

  1. Wróć do konsoli Firevbase, przejdź do sekcji Sprawdzanie aplikacji .
  2. Na karcie Aplikacje kliknij swoją aplikację, aby rozwinąć jej szczegóły.
  3. W rozszerzonym menu wybierz Zarządzaj tokenami debugowania : d77c8ff768a00b4b.png
  4. Dodaj klucz tajny skopiowany z konsoli Xcode, a następnie kliknij Zapisz f845c97b86f694d0.png

Po wykonaniu tych czynności możesz korzystać z aplikacji w symulatorze, nawet z wymuszonym sprawdzaniem aplikacji.

Uwaga: dostawca debugowania został specjalnie zaprojektowany, aby zapobiegać wyciekom tajnych danych debugowania. Przy obecnym podejściu nie musisz przechowywać klucza tajnego debugowania w kodzie źródłowym.

Więcej szczegółów na temat tego przepływu można znaleźć w dokumentacji — zobacz Używanie sprawdzania aplikacji z dostawcą debugowania w systemie iOS .

9. Włącz wymuszanie sprawdzania aplikacji dla bazy danych czasu rzeczywistego Firebase

Na razie nasza aplikacja deklaruje AppCheckProviderFactory , która zwraca AppAttestProvider dla rzeczywistych urządzeń. Gdy działa na urządzeniu fizycznym, Twoja aplikacja przeprowadzi atest i wyśle ​​wyniki do backendu Firebase. Backend Firebase nadal jednak akceptuje żądania z dowolnego urządzenia, symulatora iOS, skryptu itp. Ten tryb jest przydatny, gdy nadal masz użytkowników ze starą wersją aplikacji bez sprawdzania aplikacji, a nie chcesz wymuszać dostępu czeki jeszcze.

Teraz musisz włączyć wymuszanie sprawdzania aplikacji, aby zapewnić dostęp do aplikacji Firebase tylko z legalnych urządzeń. Stare wersje aplikacji bez integracji App Check przestaną działać, gdy włączysz wymuszanie w projekcie Firebase.

  1. W konsoli Firebase w sekcji Sprawdzanie aplikacji kliknij Baza danych czasu rzeczywistego , aby rozwinąć jej szczegóły.
  2. Kliknij Wymuś .

64e6a81fa979b635.png

  1. Przeczytaj informacje w oknie dialogowym potwierdzenia, a następnie kliknij Wymuś .

Po wykonaniu tych kroków tylko legalne aplikacje będą mogły uzyskać dostęp do bazy danych. Wszystkie inne aplikacje zostaną zablokowane.

Spróbuj uzyskać dostęp do Bazy danych czasu rzeczywistego za pomocą nielegalnej aplikacji

Aby zobaczyć wymuszanie sprawdzania aplikacji w akcji, wykonaj następujące kroki:

  1. Wyłącz rejestrację Sprawdzania aplikacji przez wykomentowanie kodu rejestracyjnego Sprawdzania aplikacji w metodzie init punktu wejścia aplikacji w DatabaseExampleApp .
  2. Zresetuj symulator, wybierając opcję Urządzenie > Wymaż całą zawartość i ustawienia . Spowoduje to wyczyszczenie Symulatora (i unieważnienie tokena urządzenia).
  3. Uruchom aplikację ponownie w symulatorze.
  4. Powinieneś teraz zobaczyć następujący komunikat o błędzie:
    [FirebaseDatabase][I-RDB034005] Firebase Database connection was forcefully killed by the server.  Will not attempt reconnect. Reason: Invalid appcheck token.
    

Aby ponownie włączyć Sprawdzanie aplikacji, wykonaj następujące czynności:

  1. Usuń komentarz z kodu rejestracyjnego sprawdzania aplikacji w DatabaseExampleApp .
  2. Uruchom ponownie aplikację.
  3. Zwróć uwagę na nowy token App Check w konsoli Xcode.
  4. Zarejestruj token debugowania w ustawieniach sprawdzania aplikacji swojej aplikacji w konsoli Firebase.
  5. Uruchom ponownie aplikację.
  6. Nie powinieneś już widzieć komunikatu o błędzie i powinieneś być w stanie dodawać nowe posty i komentarze w aplikacji.

10. Gratulacje!

9785d32f18b995d2.gif

Teraz wiesz, jak:

  • Dodaj sprawdzanie aplikacji do istniejącego projektu
  • Skonfiguruj dostawcę atestacji aplikacji dla wersji produkcyjnej swojej aplikacji
  • Skonfiguruj dostawcę zaświadczeń debugowania, aby przetestować swoją aplikację na symulatorze
  • Obserwuj wdrażanie wersji aplikacji, aby wiedzieć, kiedy należy wymusić sprawdzanie aplikacji w projekcie Firebase
  • Włącz wymuszanie sprawdzania aplikacji

Następne kroki

Dowiedz się, jak używać Zdalnej konfiguracji do stopniowego wdrażania Kontroli aplikacji wśród użytkowników w sekcji Stopniowe wdrażanie Kontroli aplikacji Firebase za pomocą ćwiczeń z kodowania Zdalnej konfiguracji Firebase

Oto inne zasoby, które mogą Ci się przydać

Konfiguracja opisana w tym laboratorium będzie działać w większości przypadków, ale Kontrola aplikacji zapewnia większą elastyczność w razie potrzeby — sprawdź poniższe łącza, aby uzyskać więcej informacji: