Kontrola aplikacji Firebase dla platform Apple

1. Wstęp

Firebase App Check pomaga chronić zasoby backendu przed nadużyciami, takimi jak oszustwa związane z rachunkami i wyłudzanie informacji, upewniając 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 backendu, aby zapewnić bezpieczeństwo Twoich zasobów.

Więcej informacji na temat sprawdzania aplikacji Firebase znajdziesz w dokumentacji Firebase.

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

Co zbudujesz

Podczas tych zajęć z programowania dodasz i wymusisz sprawdzanie aplikacji w istniejącej przykładowej aplikacji, aby baza danych czasu rzeczywistego projektu była chroniona przed dostępem nielegalnych aplikacji i urządzeń.

Czego się dowiesz

  • Jak dodać Sprawdzanie aplikacji Firebase do istniejącej aplikacji.
  • Jak zainstalować różnych dostawców atestów Firebase App Check.
  • Jak skonfigurować App Attest dla swojej aplikacji.
  • Jak skonfigurować dostawcę zaświadczenia debugowania, aby testował aplikację w symulatorach podczas tworzenia aplikacji.

Co będziesz potrzebował

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

2. Pobierz projekt startowy

Repozytorium Firebase Quickstarts dla iOS zawiera przykładowe aplikacje demonstrujące różne produkty Firebase. Jako podstawę tego ćwiczenia z kodowania będziesz używać aplikacji Firebase Database Quickstart dla SwiftUI.

Sklonuj repozytorium Firebase Quickstarts dla 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 docelowej aplikacji DatabaseExample (iOS) . Następnie w sekcji Struktury, biblioteki i zawartość osadzona kliknij przycisk + .
  3. Wybierz, aby dodać FirebaseAppCheck .

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

  1. W grupie plików Shared dodaj nową grupę o nazwie AppCheck .
  2. Wewnątrz tej grupy utwórz klasę fabryczną 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 instancję klasy MyAppCheckProviderFactory jako fabrykę dostawców 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 skorzystać z Sprawdzania aplikacji w projekcie na iOS, wykonaj następujące kroki 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 opcję 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ę ( us-central1 ) bazy danych 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 karty Reguły przeglądarki Realtime Database i zastąp reguły domyślne 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 udostępniania. Wykonaj poniższe kroki, aby dodać przykładową aplikację do swojego konta programisty:

  1. W Xcode wybierz projekt DatabaseExample w nawigatorze projektu.
  2. Wybierz element docelowy DatabaseExample (iOS) i otwórz kartę Podpisywanie i możliwości .
  3. Powinien zostać wyświetlony 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 swojej witryny, na przykład com.acme.samples.firebase.quickstart.DatabaseExample (proszę nie używać 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 „Profil udostępniania: profil zarządzany Xcode” i małą ikonę informacyjną obok tej etykiety. Kliknięcie tej ikony wyświetli więcej szczegółów na temat profilu udostępniania.

Połącz swoją aplikację na iOS

Aby uzyskać szczegółowe wyjaśnienia dotyczące łączenia aplikacji, zapoznaj się z dokumentacją dotyczącą dodawania Firebase do projektu na iOS . Aby rozpocząć, wykonaj następujące główne kroki 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ę na iOS do projektu Firebase.
  2. Wprowadź identyfikator pakietu swojej aplikacji (użyj tego, który zdefiniowałeś w poprzedniej sekcji, np. com.acme.samples.firebase.quickstart.DatabaseExample — pamiętaj, że musi to być unikalny identyfikator)
  3. Kliknij opcję Zarejestruj aplikację .
  4. Firebase generuje plik GoogleService-Info.plist zawierający wszystkie niezbędne metadane Firebase dla Twojej aplikacji.
  5. Kliknij opcję 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 dla 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 nazwę GoogleService-Info.plist
  8. Kliknij pozostałe etapy procesu rejestracji. Ponieważ przykładowy projekt jest już poprawnie skonfigurowany, nie musisz wprowadzać żadnych zmian w kodzie.

Skonfiguruj uwierzytelnianie Firebase

Uff! Jak na razie sporo konfiguracji, ale trzymajcie się mocno! Jeśli dopiero zaczynasz korzystać z Firebase, znasz już istotne części przepływu pracy, z którymi wkrótce się zapoznasz.

Teraz skonfigurujesz uwierzytelnianie Firebase dla tej aplikacji.

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

  1. Wciąż w konsoli Firebase otwórz sekcję Uwierzytelnianie w konsoli.
  2. Kliknij Rozpocznij , aby skonfigurować uwierzytelnianie Firebase dla swojego projektu.
  3. Wybierz zakładkę Metoda logowania .
  4. Wybierz opcję E-mail/hasło w sekcji Dostawcy natywni .
  5. Włącz opcję E-mail/hasło i kliknij Zapisz .

Dodaj użytkownika testowego

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

Zabierz aplikację na przejażdżkę

Wróć do Xcode i uruchom aplikację w symulatorze iOS. Zaloguj się, podając adres e-mail i hasło nowo utworzonego użytkownika testowego. Po zalogowaniu utwórz post, opublikuj komentarz do istniejącego posta i oznaczaj posty gwiazdką/usuń gwiazdkę.

6. Skonfiguruj dostawcę zaświadczenia aplikacji App Attest

W tym kroku skonfigurujesz Sprawdzanie aplikacji tak, aby korzystało z dostawcy App Attest w konsoli Firebase.

  1. W konsoli Firebase przejdź do sekcji Sprawdzanie aplikacji w konsoli.
  2. Kliknij Rozpocznij .
  3. Na karcie Aplikacje kliknij aplikację, aby rozwinąć jej szczegóły.
  4. Kliknij opcję App Attest , aby skonfigurować aplikację App Attest, a następnie wprowadź identyfikator zespołu swojego konta programisty Apple (znajdziesz go w sekcji Członkostwo w 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ą i włączono Sprawdzanie aplikacji.

Teraz możesz skonfigurować naszą specjalną usługę atestacji! Więcej informacji na temat tego przepływu pracy można znaleźć w artykule Włączanie sprawdzania aplikacji przy użyciu narzędzia App Attest w systemie iOS .

7. Skonfiguruj App Attest dla swojej aplikacji

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

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

  1. Dodaj funkcję App Attest dla docelowej 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ę 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 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. W późniejszym kroku wymusisz sprawdzanie aplikacji, które zablokuje wysyłanie żądań z nielegalnych aplikacji i urządzeń.

Aby dowiedzieć się więcej na temat tego przepływu pracy, zobacz Włączanie sprawdzania aplikacji za pomocą testu aplikacji w systemie iOS .

8. Skonfiguruj dostawcę atestu debugowania dla symulatora iOS

Dostawca Firebase App Check Debug umożliwia testowanie aplikacji z egzekwowaniem Firebase App Check w niezaufanych środowiskach, w tym w symulatorze iOS, podczas procesu programowania. 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 tych czynności została wykonana podczas tworzenia fabryki dostawców sprawdzania aplikacji. W tym kroku dodasz rejestrowanie lokalnego sekretu debugowania wygenerowanego przez dostawcę debugowania, dzięki czemu będziesz mógł zarejestrować tę instancję aplikacji w konsoli Firebase na potrzeby debugowania.

Zaktualizuj plik MyAppCheckProviderFactory.swift następującym 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
  }
}

Takie podejście zapewnia nam większą elastyczność w konfigurowaniu Sprawdzania aplikacji w zależności od środowiska. Na przykład możesz skorzystać z usług innych dostawców atestów, takich jak DeviceCheck , lub niestandardowego dostawcy atestów w wersjach systemów operacyjnych, w których nie jest dostępny App Attest . 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 linijek kodu podczas tworzenia własnej fabryki dostawców App Check.

Zarejestruj swój sekret debugowania w konsoli Firebase

Pobierz sekret debugowania z symulatora systemu iOS

  1. Jeśli zdecydowałeś 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ę w symulatorze
  3. Znajdź sekret debugowania w konsoli Xcode. Możesz użyć filtra konsoli, aby znaleźć go szybciej: d4c65af93e369c55.png

Uwaga: Klucz 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 sekret debugowania. Pamiętaj, aby zarejestrować nowy klucz tajny debugowania.

Zarejestruj sekret debugowania

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

Po wykonaniu tych kroków możesz używać aplikacji w symulatorze nawet przy wymuszonej kontroli aplikacji.

Uwaga: Dostawca debugowania został specjalnie zaprojektowany, aby zapobiegać wyciekom sekretów debugowania. Przy obecnym podejściu nie trzeba przechowywać sekretu debugowania w kodzie źródłowym.

Więcej szczegółów na temat tego przepływu można znaleźć w dokumentacji — zobacz Korzystanie z sprawdzania aplikacji u dostawcy debugowania w systemie iOS .

9. Włącz wymuszanie sprawdzania aplikacji dla bazy danych Firebase Realtime Database

Na razie nasza aplikacja deklaruje AppCheckProviderFactory , która zwraca AppAttestProvider dla prawdziwych urządzeń. Po uruchomieniu na urządzeniu fizycznym aplikacja przeprowadzi atest i wyśle ​​wyniki do zaplecza Firebase. Jednak backend Firebase nadal akceptuje żądania z dowolnego urządzenia, symulatora iOS, skryptu itp. Ten tryb jest przydatny, jeśli nadal masz użytkowników ze starą wersją aplikacji bez sprawdzania aplikacji i nie chcesz wymuszać dostępu jeszcze sprawdza.

Teraz musisz włączyć wymuszanie sprawdzania aplikacji, aby mieć pewność, że dostęp do aplikacji Firebase będzie możliwy tylko z legalnych urządzeń. Stare wersje aplikacji bez integracji App Check przestaną działać po włączeniu wymuszania dla projektu Firebase.

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

64e6a81fa979b635.png

  1. Przeczytaj informacje w oknie dialogowym potwierdzenia, a następnie kliknij opcję Wymuszaj .

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ć, jak wymuszanie sprawdzania aplikacji działa, wykonaj następujące kroki:

  1. Wyłącz rejestrację App Check, komentując kod rejestracyjny App Check w metodzie init punktu wejścia aplikacji w DatabaseExampleApp .
  2. Zresetuj symulator, wybierając opcję Urządzenie > Usuń 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 do kodu rejestracyjnego App Check w DatabaseExampleApp .
  2. Uruchom ponownie aplikację.
  3. Zwróć uwagę na nowy token sprawdzania aplikacji w konsoli Xcode.
  4. Zarejestruj token debugowania w ustawieniach sprawdzania aplikacji w konsoli Firebase.
  5. Uruchom aplikację ponownie.
  6. Nie powinieneś już widzieć komunikatu o błędzie i powinieneś móc dodawać nowe posty i komentarze w aplikacji.

10. Gratulacje!

9785d32f18b995d2.gif

Teraz wiesz, jak:

  • Dodaj kontrolę aplikacji do istniejącego projektu
  • Skonfiguruj dostawcę zaświadczenia App Attest dla wersji produkcyjnej aplikacji
  • Skonfiguruj dostawcę zaświadczenia debugowania, aby przetestować aplikację na symulatorze
  • Obserwuj wdrażanie wersji aplikacji, aby wiedzieć, kiedy wymusić sprawdzanie aplikacji w projekcie Firebase
  • Włącz wymuszanie sprawdzania aplikacji

Następne kroki

Dowiedz się, jak korzystać ze zdalnej konfiguracji, aby stopniowo udostępniać Sprawdzanie aplikacji użytkownikom, podczas zajęć z programowania Stopniowe wdrażanie sprawdzania aplikacji Firebase przy użyciu zdalnej konfiguracji Firebase

Oto inne zasoby, które mogą okazać się pomocne

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