Add ability to set the App Check Debug Factory token (#1288)

* Add a way to set the App Check debug token

* Formatting

* Update build.gradle

* Update debug_provider_ios.h

* Change variable name

Author: a-maurice

app_check/integration_test/build.gradle

@@ -83,6 +83,9 @@ android {
   lintOptions {
     abortOnError false
   }
+  packagingOptions {
+    pickFirst 'META-INF/**/coroutines.pro'
+  }
 }
 
 apply from: "$gradle.firebase_cpp_sdk_dir/Android/firebase_dependencies.gradle"

app_check/src/android/app_check_android.cc

@@ -297,7 +297,7 @@ AppCheckInternal::AppCheckInternal(App* app) : app_(app) {
         util::Terminate(env);
       } else {
         // Each provider is optional as a user may or may not use it.
-        CacheDebugProviderMethodIds(env, activity);
+        CacheDebugProviderMethodIds(env, activity, embedded_files);
         CachePlayIntegrityProviderMethodIds(env, activity);
         g_initialized_count++;
       }

app_check/src/android/debug_provider_android.cc

@@ -14,7 +14,11 @@
 
 #include "app_check/src/android/debug_provider_android.h"
 
+#include <string>
+#include <vector>
+
 #include "app/src/app_common.h"
+#include "app/src/embedded_file.h"
 #include "app/src/util_android.h"
 #include "app_check/src/android/common_android.h"
 #include "firebase/app_check/debug_provider.h"
@@ -43,24 +47,45 @@ METHOD_LOOKUP_DEFINITION(
     "com/google/firebase/appcheck/debug/DebugAppCheckProviderFactory",
     DEBUG_PROVIDER_FACTORY_METHODS)
 
+// clang-format off
+#define JNI_APP_CHECK_DEBUG_HELPER_METHODS(X)                    \
+  X(SetDebugToken, "SetDebugToken",                             \
+    "(Lcom/google/firebase/FirebaseApp;Ljava/lang/String;)V",    \
+    util::kMethodTypeStatic)
+// clang-format on
+
+METHOD_LOOKUP_DECLARATION(jni_debug_helper, JNI_APP_CHECK_DEBUG_HELPER_METHODS)
+METHOD_LOOKUP_DEFINITION(
+    jni_debug_helper,
+    "com/google/firebase/appcheck/internal/cpp/JniAppCheckDebugHelper",
+    JNI_APP_CHECK_DEBUG_HELPER_METHODS)
+
 static bool g_methods_cached = false;
 
 const char kMethodsNotCachedError[] =
     "DebugAppCheckProviderFactory methods were not cached.";
 
-bool CacheDebugProviderMethodIds(JNIEnv* env, jobject activity) {
-  // Cache the DebugProvider classes.
-  g_methods_cached = debug_provider_factory::CacheMethodIds(env, activity);
+bool CacheDebugProviderMethodIds(
+    JNIEnv* env, jobject activity,
+    const std::vector<firebase::internal::EmbeddedFile>& embedded_files) {
+  // Cache the DebugProvider and JniAppCheckDebugHelper classes.
+  g_methods_cached =
+      debug_provider_factory::CacheMethodIds(env, activity) &&
+      jni_debug_helper::CacheClassFromFiles(env, activity, &embedded_files) &&
+      jni_debug_helper::CacheMethodIds(env, activity);
   return g_methods_cached;
 }
 
 void ReleaseDebugProviderClasses(JNIEnv* env) {
   debug_provider_factory::ReleaseClass(env);
+  jni_debug_helper::ReleaseClass(env);
   g_methods_cached = false;
 }
 
 DebugAppCheckProviderFactoryInternal::DebugAppCheckProviderFactoryInternal()
-    : created_providers_(), android_provider_factory_(nullptr) {}
+    : created_providers_(),
+      android_provider_factory_(nullptr),
+      debug_token_() {}
 
 DebugAppCheckProviderFactoryInternal::~DebugAppCheckProviderFactoryInternal() {
   for (auto it = created_providers_.begin(); it != created_providers_.end();
@@ -98,6 +123,19 @@ AppCheckProvider* DebugAppCheckProviderFactoryInternal::CreateProvider(
     env->DeleteLocalRef(j_provider_factory_local);
   }
   jobject platform_app = app->GetPlatformApp();
+
+  // Before making the Provider, which is when Android reads the Debug token,
+  // if we have a token to override it with, use it.
+  if (!debug_token_.empty()) {
+    jstring java_token = env->NewStringUTF(debug_token_.c_str());
+    env->CallStaticVoidMethod(
+        jni_debug_helper::GetClass(),
+        jni_debug_helper::GetMethodId(jni_debug_helper::kSetDebugToken),
+        platform_app, java_token);
+    FIREBASE_ASSERT(!util::CheckAndClearJniExceptions(env));
+    env->DeleteLocalRef(java_token);
+  }
+
   jobject j_android_provider_local = env->CallObjectMethod(
       android_provider_factory_,
       debug_provider_factory::GetMethodId(debug_provider_factory::kCreate),
@@ -114,6 +152,12 @@ AppCheckProvider* DebugAppCheckProviderFactoryInternal::CreateProvider(
   return cpp_provider;
 }
 
+void DebugAppCheckProviderFactoryInternal::SetDebugToken(
+    const std::string& token) {
+  // The App may not exist yet, so we save the debug token to use later.
+  debug_token_ = token;
+}
+
 }  // namespace internal
 }  // namespace app_check
 }  // namespace firebase

app_check/src/android/debug_provider_android.h

@@ -16,15 +16,20 @@
 #define FIREBASE_APP_CHECK_SRC_ANDROID_DEBUG_PROVIDER_ANDROID_H_
 
 #include <map>
+#include <string>
+#include <vector>
 
+#include "app/src/embedded_file.h"
 #include "firebase/app_check.h"
 
 namespace firebase {
 namespace app_check {
 namespace internal {
 
 // Cache the method ids so we don't have to look up JNI functions by name.
-bool CacheDebugProviderMethodIds(JNIEnv* env, jobject activity);
+bool CacheDebugProviderMethodIds(
+    JNIEnv* env, jobject activity,
+    const std::vector<firebase::internal::EmbeddedFile>& embedded_files);
 
 // Release provider classes cached by CacheDebugProviderMethodIds().
 void ReleaseDebugProviderClasses(JNIEnv* env);
@@ -37,10 +42,14 @@ class DebugAppCheckProviderFactoryInternal : public AppCheckProviderFactory {
 
   AppCheckProvider* CreateProvider(App* app) override;
 
+  void SetDebugToken(const std::string& token);
+
  private:
   jobject android_provider_factory_;
 
   std::map<App*, AppCheckProvider*> created_providers_;
+
+  std::string debug_token_;
 };
 
 }  // namespace internal

app_check/src/android/play_integrity_provider_android.cc

@@ -120,14 +120,9 @@ AppCheckProvider* PlayIntegrityProviderFactoryInternal::CreateProvider(
 
 }  // namespace internal
 
-static PlayIntegrityProviderFactory* g_play_integrity_provider_factory =
-    nullptr;
-
 PlayIntegrityProviderFactory* PlayIntegrityProviderFactory::GetInstance() {
-  if (!g_play_integrity_provider_factory) {
-    g_play_integrity_provider_factory = new PlayIntegrityProviderFactory();
-  }
-  return g_play_integrity_provider_factory;
+  static PlayIntegrityProviderFactory g_play_integrity_provider_factory;
+  return &g_play_integrity_provider_factory;
 }
 
 PlayIntegrityProviderFactory::PlayIntegrityProviderFactory()

app_check/src/common/debug_provider_common.cc

@@ -12,6 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include <string>
+
 #include "firebase/app_check/debug_provider.h"
 
 // Include the header that matches the platform being used.
@@ -27,14 +29,9 @@
 namespace firebase {
 namespace app_check {
 
-static DebugAppCheckProviderFactory* g_debug_app_check_provider_factory =
-    nullptr;
-
 DebugAppCheckProviderFactory* DebugAppCheckProviderFactory::GetInstance() {
-  if (!g_debug_app_check_provider_factory) {
-    g_debug_app_check_provider_factory = new DebugAppCheckProviderFactory();
-  }
-  return g_debug_app_check_provider_factory;
+  static DebugAppCheckProviderFactory g_debug_app_check_provider_factory;
+  return &g_debug_app_check_provider_factory;
 }
 
 DebugAppCheckProviderFactory::DebugAppCheckProviderFactory()
@@ -54,5 +51,11 @@ AppCheckProvider* DebugAppCheckProviderFactory::CreateProvider(App* app) {
   return nullptr;
 }
 
+void DebugAppCheckProviderFactory::SetDebugToken(const std::string& token) {
+  if (internal_) {
+    return internal_->SetDebugToken(token);
+  }
+}
+
 }  // namespace app_check
 }  // namespace firebase

app_check/src/desktop/debug_provider_desktop.cc

@@ -34,7 +34,7 @@ namespace internal {
 
 class DebugAppCheckProvider : public AppCheckProvider {
  public:
-  explicit DebugAppCheckProvider(App* app);
+  DebugAppCheckProvider(App* app, const std::string& token);
   ~DebugAppCheckProvider() override;
 
   void GetToken(std::function<void(AppCheckToken, int, const std::string&)>
@@ -44,10 +44,12 @@ class DebugAppCheckProvider : public AppCheckProvider {
   App* app_;
 
   scheduler::Scheduler scheduler_;
+
+  std::string debug_token_;
 };
 
-DebugAppCheckProvider::DebugAppCheckProvider(App* app)
-    : app_(app), scheduler_() {
+DebugAppCheckProvider::DebugAppCheckProvider(App* app, const std::string& token)
+    : app_(app), scheduler_(), debug_token_(token) {
   firebase::rest::util::Initialize();
   firebase::rest::InitTransportCurl();
 }
@@ -90,19 +92,22 @@ void DebugAppCheckProvider::GetToken(
     std::function<void(AppCheckToken, int, const std::string&)>
         completion_callback) {
   // Identify the user's debug token
-  // TODO(amaurice): For now uses an environment variable, but should use other
-  // options.
-  const char* debug_token = std::getenv("APP_CHECK_DEBUG_TOKEN");
+  const char* debug_token_cstr;
+  if (!debug_token_.empty()) {
+    debug_token_cstr = debug_token_.c_str();
+  } else {
+    debug_token_cstr = std::getenv("APP_CHECK_DEBUG_TOKEN");
+  }
 
-  if (!debug_token) {
+  if (!debug_token_cstr) {
     completion_callback({}, kAppCheckErrorInvalidConfiguration,
                         "Missing debug token");
     return;
   }
 
   // Exchange debug token with the backend to get a proper attestation token.
   auto request = MakeShared<DebugTokenRequest>(app_);
-  request->SetDebugToken(debug_token);
+  request->SetDebugToken(debug_token_cstr);
 
   // Use an async call, since we don't want to block on the server response.
   auto async_call =
@@ -111,7 +116,7 @@ void DebugAppCheckProvider::GetToken(
 }
 
 DebugAppCheckProviderFactoryInternal::DebugAppCheckProviderFactoryInternal()
-    : provider_map_() {}
+    : provider_map_(), debug_token_() {}
 
 DebugAppCheckProviderFactoryInternal::~DebugAppCheckProviderFactoryInternal() {
   // Clear the map
@@ -129,11 +134,16 @@ AppCheckProvider* DebugAppCheckProviderFactoryInternal::CreateProvider(
     return it->second;
   }
   // Create a new provider and cache it
-  AppCheckProvider* provider = new DebugAppCheckProvider(app);
+  AppCheckProvider* provider = new DebugAppCheckProvider(app, debug_token_);
   provider_map_[app] = provider;
   return provider;
 }
 
+void DebugAppCheckProviderFactoryInternal::SetDebugToken(
+    const std::string& token) {
+  debug_token_ = token;
+}
+
 }  // namespace internal
 }  // namespace app_check
 }  // namespace firebase

app_check/src/desktop/debug_provider_desktop.h

@@ -16,6 +16,7 @@
 #define FIREBASE_APP_CHECK_SRC_DESKTOP_DEBUG_PROVIDER_DESKTOP_H_
 
 #include <map>
+#include <string>
 
 #include "firebase/app_check.h"
 
@@ -31,8 +32,12 @@ class DebugAppCheckProviderFactoryInternal : public AppCheckProviderFactory {
 
   AppCheckProvider* CreateProvider(App* app) override;
 
+  void SetDebugToken(const std::string& token);
+
  private:
   std::map<App*, AppCheckProvider*> provider_map_;
+
+  std::string debug_token_;
 };
 
 }  // namespace internal

app_check/src/include/firebase/app_check/app_attest_provider.h

@@ -28,19 +28,21 @@ class AppAttestProviderFactoryInternal;
 /// AppAttestProviders. This is the default implementation.
 class AppAttestProviderFactory : public AppCheckProviderFactory {
  public:
+  AppAttestProviderFactory(const AppAttestProviderFactory&) = delete;
+  AppAttestProviderFactory& operator=(const AppAttestProviderFactory&) = delete;
+
   /// Gets an instance of this class for installation into a
   /// firebase::app_check::AppCheck instance.
   static AppAttestProviderFactory* GetInstance();
 
-  virtual ~AppAttestProviderFactory();
-
   /// Gets the AppCheckProvider associated with the given
   /// {@link App} instance, or creates one if none
   /// already exists.
   firebase::app_check::AppCheckProvider* CreateProvider(App* app) override;
 
  private:
   AppAttestProviderFactory();
+  ~AppAttestProviderFactory() override;
 
   internal::AppAttestProviderFactoryInternal* internal_;
 };

app_check/src/include/firebase/app_check/debug_provider.h

@@ -15,6 +15,8 @@
 #ifndef FIREBASE_APP_CHECK_SRC_INCLUDE_FIREBASE_APP_CHECK_DEBUG_PROVIDER_H_
 #define FIREBASE_APP_CHECK_SRC_INCLUDE_FIREBASE_APP_CHECK_DEBUG_PROVIDER_H_
 
+#include <string>
+
 #include "firebase/app_check.h"
 
 namespace firebase {
@@ -34,7 +36,9 @@ class DebugAppCheckProviderFactoryInternal;
 /// NOTE: Do not use the debug provider in applications used by real users.
 class DebugAppCheckProviderFactory : public AppCheckProviderFactory {
  public:
-  ~DebugAppCheckProviderFactory() override;
+  DebugAppCheckProviderFactory(const DebugAppCheckProviderFactory&) = delete;
+  DebugAppCheckProviderFactory& operator=(const DebugAppCheckProviderFactory&) =
+      delete;
 
   /// Gets an instance of this class for installation into a
   /// firebase::app_check::AppCheck instance.
@@ -45,8 +49,14 @@ class DebugAppCheckProviderFactory : public AppCheckProviderFactory {
   /// already exists.
   firebase::app_check::AppCheckProvider* CreateProvider(App* app) override;
 
+  /// Sets the Debug Token to use when communicating with the backend.
+  /// This should match a debug token set in the Firebase console for your
+  /// App.
+  void SetDebugToken(const std::string& token);
+
  private:
   DebugAppCheckProviderFactory();
+  ~DebugAppCheckProviderFactory() override;
 
   internal::DebugAppCheckProviderFactoryInternal* internal_;
 };