Sprawdzanie aplikacji Firebase na platformach Apple

1. Wprowadzenie

Sprawdzanie aplikacji Firebase pomaga chronić zasoby backendu przed nadużyciami, takimi jak oszukańcze płatności czy wyłudzanie informacji, poprzez upewnianie się, że żądania pochodzą z prawidłowych aplikacji i urządzeń. Współpracuje z usługami Firebase i usługami backendu, aby chronić Twoje zasoby.

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

App Check korzysta z usług specyficznych dla platformy, aby weryfikować integralność aplikacji lub urządzenia. Usługi te są nazywane dostawcami atestów. Jednym z takich dostawców jest usługa App Attest firmy Apple, której Sprawdzanie aplikacji może używać do weryfikowania autentyczności aplikacji i urządzeń Apple.

Co utworzysz

W tym samouczku dodasz i wymusisz weryfikację aplikacji w istniejącej aplikacji przykładowej, aby chronić Bazę danych czasu rzeczywistego projektu przed dostępem z nieprawidłowych aplikacji i urządzeń.

Czego się nauczysz

  • Jak dodać Sprawdzanie aplikacji Firebase do istniejącej aplikacji.
  • Jak zainstalować różnych dostawców atestów Sprawdzania aplikacji Firebase.
  • Jak skonfigurować App Attest w aplikacji.
  • Jak skonfigurować dostawcę atestu debugowania, aby testować aplikację na symulatorach podczas jej tworzenia.

Czego potrzebujesz

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

2. Pobieranie projektu startowego

Repozytorium Firebase Quickstarts for iOS zawiera przykładowe aplikacje, które prezentują różne usługi Firebase. W tym samouczku wykorzystasz aplikację Firebase Database Quickstart dla SwiftUI jako podstawę.

Sklonuj repozytorium Firebase Quickstarts for 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. Dodawanie do aplikacji weryfikacji aplikacji

  1. Poczekaj, aż menedżer pakietów Swift rozwiąże zależności projektu.
  2. Otwórz kartę Ogólne w przypadku DatabaseExample (iOS) aplikacji docelowej. Następnie w sekcji Frameworki, biblioteki i treści osadzone kliknij przycisk +.
  3. Wybierz, aby dodać FirebaseAppCheck.

4. Tworzenie i instalowanie fabryki dostawcy App Check

  1. W grupie plików Shared dodaj nową grupę o nazwie AppCheck.
  2. W tej grupie utwórz klasę fabryczną w osobnym pliku, np. MyAppCheckProviderFactory.swift , i dodaj ją do elementu 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 instancję 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. Tworzenie i konfigurowanie projektu Firebase

Aby używać weryfikacji aplikacji w projekcie na iOS, wykonaj te czynności w konsoli Firebase:

  • Skonfiguruj projekt Firebase.
  • Dodaj 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. Zaloguj się w konsoli Firebase, korzystając ze swojego konta Google.
  2. Kliknij przycisk, aby utworzyć nowy projekt, a następnie wpisz jego nazwę (np. App Check Codelab).
  3. Kliknij Dalej.
  4. Po wyświetleniu monitu przeczytaj i zaakceptuj warunki usługi Firebase, a potem kliknij Dalej.
  5. (Opcjonalnie) Włącz w konsoli Firebase pomoc AI (nazywaną „Gemini w Firebase”).
  6. W tym samouczku nie potrzebujesz Google Analytics, więc wyłącz opcję Google Analytics.
  7. Kliknij Utwórz projekt, poczekaj, aż projekt zostanie udostępniony, a następnie kliknij Dalej.

Tworzenie instancji bazy danych czasu rzeczywistego

Teraz otwórz sekcję Baza danych czasu rzeczywistego w konsoli Firebase.

  1. Aby rozpocząć przepływ pracy tworzenia bazy danych, kliknij przycisk Utwórz bazę danych.
  2. Pozostaw domyślną lokalizację (us-central1) bazy danych bez zmian i kliknij Dalej.
  3. Upewnij się, że wybrano Tryb zablokowany, a następnie kliknij przycisk Włącz, aby włączyć reguły zabezpieczeń dla bazy danych.
  4. Otwórz kartę Reguły w przeglądarce Realtime Database i zastąp reguły domyślne tymi:
    {
    "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. Aby aktywować zaktualizowane reguły zabezpieczeń, kliknij przycisk Opublikuj.

Przygotowywanie aplikacji 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 aprowizacyjnym. Aby dodać przykładową aplikację do konta dewelopera:

  1. W Xcode wybierz projekt DatabaseExample w nawigatorze projektu.
  2. Wybierz DatabaseExample (iOS) i otwórz kartę Podpisywanie i możliwości.
  3. Powinien pojawić się komunikat o błędzie „Podpisywanie aplikacji DatabaseExample (iOS) wymaga zespołu programistów”.
  4. Zaktualizuj identyfikator pakietu, aby był unikalny. Najłatwiej to zrobić, używając odwróconej nazwy domeny witryny, np. com.acme.samples.firebase.quickstart.DatabaseExample (nie używaj tego identyfikatora, wybierz własny, niepowtarzalny identyfikator).
  5. Wybierz zespół deweloperski.
  6. Jeśli wszystko przebiegnie prawidłowo, Xcode wyświetli komunikat „Provisioning Profile: Xcode Managed Profile” (Profil administracyjny: profil zarządzany przez Xcode) oraz małą ikonę informacji obok tej etykiety. Kliknięcie tej ikony spowoduje wyświetlenie większej liczby szczegółów dotyczących profilu administracyjnego.

Łączenie aplikacji na iOS

Szczegółowe wyjaśnienie, jak połączyć aplikację, znajdziesz w dokumentacji na temat dodawania Firebase do projektu na iOS. Aby rozpocząć, wykonaj te główne czynności w konsoli Firebase:

  1. Na ekranie Przegląd projektu nowego projektu kliknij przycisk + Dodaj aplikację, a potem kliknij ikonę iOS+, aby dodać nową aplikację na iOS do projektu Firebase.
  2. Wpisz identyfikator pakietu aplikacji (użyj identyfikatora zdefiniowanego w poprzedniej sekcji, np. com.acme.samples.firebase.quickstart.DatabaseExample – pamiętaj, że musi to być unikalny identyfikator).
  3. Kliknij Zarejestruj aplikację.
  4. Firebase generuje GoogleService-Info.plist zawierający wszystkie niezbędne metadane Firebase dotyczące Twojej aplikacji.
  5. Aby pobrać plik, kliknij Pobierz GoogleService-Info.plist.
  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 elementu docelowego DatabaseExample (iOS). Upewnij się, że plik ma nazwę GoogleService-Info.plist.
  8. Wykonaj pozostałe czynności w procesie rejestracji. Przykładowy projekt jest już prawidłowo skonfigurowany, więc nie musisz wprowadzać żadnych zmian w kodzie.

Konfigurowanie Uwierzytelniania Firebase

Uff... To już sporo ustawień, ale jeszcze trochę. Jeśli dopiero zaczynasz korzystać z Firebase, zapoznałeś(-aś) się już z najważniejszymi elementami procesu, które wkrótce staną się dla Ciebie znajome.

Teraz skonfigurujesz Uwierzytelnianie Firebase dla tej aplikacji.

Włącz dostawcę uwierzytelniania przy użyciu adresu e-mail i hasła

  1. W konsoli Firebase otwórz sekcję Uwierzytelnianie.
  2. Aby skonfigurować uwierzytelnianie Firebase w projekcie, kliknij Rozpocznij.
  3. Wybierz kartę Metoda logowania.
  4. W sekcji Dostawcy natywni wybierz Adres e-mail/hasło.
  5. Włącz Email/Password (Adres e-mail/hasło) i kliknij Save (Zapisz).

Dodawanie użytkownika testowego

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

Wypróbuj aplikację

Wróć do Xcode i uruchom aplikację w symulatorze iOS. Zaloguj się, podając adres e-mail i hasło utworzonego przed chwilą użytkownika testowego. Po zalogowaniu możesz tworzyć posty, dodawać komentarze do istniejących postów oraz oznaczać posty gwiazdką i usuwać to oznaczenie.

6. Konfigurowanie dostawcy atestów App Attest

W tym kroku skonfigurujesz weryfikację aplikacji tak, aby korzystała z dostawcy App Attest w konsoli Firebase.

  1. W konsoli Firebase otwórz sekcję Weryfikacja aplikacji.
  2. Kliknij Rozpocznij.
  3. Na karcie Aplikacje kliknij aplikację, aby rozwinąć jej szczegóły.
  4. Kliknij App Attest, aby skonfigurować App Attest, a następnie wpisz identyfikator zespołu z konta dewelopera Apple (znajdziesz go w sekcji Członkostwo w portalu dla deweloperów Apple): 1645f7a369b678c2.png
  5. Kliknij Zapisz.

W ten sposób uzyskasz działający projekt Firebase połączony z nową aplikacją, w którym włączona jest weryfikacja aplikacji.

Możesz teraz skonfigurować naszą usługę atestowania. Więcej informacji o tym procesie znajdziesz w artykule Włączanie Sprawdzania aplikacji za pomocą App Attest w iOS.

7. Konfigurowanie App Attest w aplikacji

Teraz możesz już zacząć korzystać z pakietu SDK Sprawdzania aplikacji Firebase i wdrażać kod klienta.

Najpierw musisz skonfigurować projekt Xcode, aby pakiet SDK mógł używać interfejsu App Attest API od Apple do sprawdzania, czy żądania wysyłane z aplikacji pochodzą z jej prawidłowych instancji.

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

Po wykonaniu tych czynności i uruchomieniu aplikacji na fizycznym urządzeniu z iOS (iPhone/iPad) aplikacja nadal będzie mieć dostęp do bazy danych czasu rzeczywistego. W dalszej części tego modułu wymusisz Sprawdzanie aplikacji, co zablokuje żądania wysyłane z nielegalnych aplikacji i urządzeń.

Więcej informacji o tym procesie znajdziesz w artykule Włączanie Sprawdzania aplikacji za pomocą App Attest w iOS.

8. Konfigurowanie dostawcy atestów debugowania na potrzeby symulatora iOS

Dostawca Firebase App Check Debug umożliwia testowanie aplikacji z wymuszonym Sprawdzaniem aplikacji Firebase w niezaufanych środowiskach, w tym w symulatorze iOS, podczas procesu programowania. Następnie musisz skonfigurować dostawcę debugowania.

Zainstaluj w aplikacji dostawcę debugowania Firebase

Opcja 1. Warunkowe tworzenie instancji dostawcy debugowania w fabryce

Większość tych czynności została wykonana podczas tworzenia fabryki dostawcy weryfikacji aplikacji. W tym kroku dodasz rejestrowanie lokalnego tajnego klucza debugowania wygenerowanego przez dostawcę debugowania, aby zarejestrować tę instancję aplikacji w konsoli Firebase na potrzeby debugowania.

Zaktualizuj plik MyAppCheckProviderFactory.swift tym kodem:

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

Dzięki temu mamy większą elastyczność w konfigurowaniu weryfikacji aplikacji w zależności od środowiska. Możesz na przykład używać innych dostawców atestów, takich jak DeviceCheck, lub niestandardowego dostawcy atestów w wersjach systemu operacyjnego, w których App Attest nie jest dostępny. Przykład:

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. Instalowanie 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()
}

Pozwoli to zaoszczędzić kilka wierszy kodu podczas tworzenia własnej fabryki dostawców weryfikacji aplikacji.

Rejestrowanie tajnego klucza debugowania w konsoli Firebase

Pobieranie tajnego klucza debugowania z symulatora iOS

  1. Jeśli zdecydujesz się na instalację AppCheckDebugProviderFactory (opcja 2 powyżej), musisz włączyć rejestrowanie debugowania w aplikacji, dodając -FIRDebugEnabled do argumentów uruchamiania aplikacji: f1c6b477a373e144.png
  2. Uruchamianie aplikacji w symulatorze
  3. Znajdź tajny klucz debugowania w konsoli Xcode. Aby szybciej znaleźć tę informację, możesz użyć filtra konsoli: d4c65af93e369c55.png

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

Zarejestruj tajny klucz debugowania

  1. Wróć do konsoli Firebase i otwórz sekcję Weryfikacja aplikacji.
  2. Na karcie Aplikacje kliknij aplikację, aby rozwinąć jej szczegóły.
  3. W menu rozszerzonym wybierz Zarządzaj tokenami debugowania: d77c8ff768a00b4b.png
  4. Dodaj tajny klucz skopiowany z konsoli Xcode, a potem kliknij Zapisz f845c97b86f694d0.png.

Po wykonaniu tych czynności możesz używać aplikacji w symulatorze nawet wtedy, gdy weryfikacja aplikacji jest wymuszona.

Uwaga: dostawca debugowania został zaprojektowany specjalnie po to, aby zapobiegać wyciekom tajnego klucza debugowania. W przypadku obecnego podejścia nie musisz przechowywać tajnego klucza debugowania w kodzie źródłowym.

Więcej informacji o tym procesie znajdziesz w dokumentacji – zobacz Korzystanie ze Sprawdzania aplikacji z dostawcą debugowania w iOS.

9. Włącz egzekwowanie Sprawdzania aplikacji w przypadku Bazy danych czasu rzeczywistego Firebase

Obecnie nasza aplikacja deklaruje AppCheckProviderFactory, która zwraca AppAttestProvider w przypadku prawdziwych urządzeń. Podczas działania na urządzeniu fizycznym aplikacja przeprowadzi atest i wyśle wyniki do backendu Firebase. Jednak backend Firebase nadal akceptuje żądania z dowolnego urządzenia, symulatora iOS, skryptu itp. Ten tryb jest przydatny, gdy masz jeszcze użytkowników ze starą wersją aplikacji bez App Check i nie chcesz jeszcze wymuszać sprawdzania dostępu.

Teraz musisz włączyć wymuszanie Sprawdzania aplikacji, aby mieć pewność, że do aplikacji Firebase można uzyskać dostęp tylko z uprawnionych urządzeń. Starsze wersje aplikacji bez integracji ze Sprawdzaniem aplikacji przestaną działać po włączeniu egzekwowania w projekcie Firebase.

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

64e6a81fa979b635.png

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

Po wykonaniu tych czynności tylko uprawnione aplikacje będą mieć dostęp do bazy danych. Wszystkie inne aplikacje zostaną zablokowane.

Próba uzyskania dostępu do bazy danych w czasie rzeczywistym za pomocą nielegalnej aplikacji

Aby zobaczyć, jak działa egzekwowanie App Check, wykonaj te czynności:

  1. Wyłącz rejestrację w Sprawdzaniu aplikacji, komentując kod rejestracji w Sprawdzaniu aplikacji w metodzie init punktu wejścia aplikacji w DatabaseExampleApp.
  2. Zresetuj symulator, wybierając Urządzenie > Wymaż całą zawartość i ustawienia. Spowoduje to wyczyszczenie symulatora (i unieważnienie tokena urządzenia).
  3. Ponownie uruchom aplikację w symulatorze.
  4. Powinien wyświetlić się ten 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ć weryfikację aplikacji:

  1. Odkomentuj kod rejestracji App Check w pliku DatabaseExampleApp.
  2. Uruchom ponownie aplikację.
  3. Zanotuj nowy token App Check w konsoli Xcode.
  4. Zarejestruj token debugowania w ustawieniach weryfikacji aplikacji w konsoli Firebase.
  5. Uruchom ponownie aplikację.
  6. Komunikat o błędzie nie powinien się już wyświetlać, a w aplikacji powinna być możliwość dodawania nowych postów i komentarzy.

10. Gratulacje!

9785d32f18b995d2.gif

Wiesz już, jak:

  • Dodawanie weryfikacji aplikacji do istniejącego projektu
  • Konfigurowanie dostawcy atestów App Attest dla wersji produkcyjnej aplikacji
  • Konfigurowanie dostawcy atestu debugowania w celu testowania aplikacji w symulatorze
  • Obserwuj wdrażanie wersji aplikacji, aby wiedzieć, kiedy włączyć weryfikację aplikacji w projekcie Firebase.
  • Włączanie wymuszania Sprawdzania aplikacji

Następne kroki

Dowiedz się, jak stopniowo wdrażać weryfikację aplikacji Firebase wśród użytkowników za pomocą Zdalnej konfiguracji Firebase. W tym celu zapoznaj się z samouczkiem dotyczącym stopniowego wdrażania weryfikacji aplikacji Firebase za pomocą Zdalnej konfiguracji Firebase.

Inne przydatne materiały

Konfiguracja opisana w tych ćwiczeniach z programowania sprawdzi się w większości przypadków, ale usługa App Check zapewnia większą elastyczność, jeśli jest to potrzebne. Więcej informacji znajdziesz w tych artykułach: