Repository navigation
Fix use-after-free when Firebase instances are destroyed during static destruction - #1949
AustinBenoit wants to merge 23 commits into
Conversation
Each product keeps a process-wide map of App -> instance plus a mutex, and both are touched from the instance's destructor via DeleteInternal(). When a user holds an instance in a static (e.g. a static std::unique_ptr<Auth>) that is destroyed after the SDK's own globals, the destructor accesses an already-destroyed map or mutex. Auth and Remote Config stored the map as a static std::map, which produced a heap-use-after-free in ~Auth()/~RemoteConfig(). Database, Storage, Functions, Installations and App Check already heap-allocated the map but still used a static Mutex, which is destroyed at exit before the lock in DeleteInternal(). Bring every product in line with the layout App and Firestore already use: the map is lazily allocated and freed when the last instance goes away, and the mutex is allocated once and never freed. Fixes #110
There was a problem hiding this comment.
Code Review
This pull request addresses a potential crash at process exit by ensuring that global mutexes and maps for various Firebase SDK components (Auth, RemoteConfig, Database, Storage, Functions, Installations, and AppCheck) are handled safely. The changes involve dynamically allocating these objects to prevent destruction order issues during C++ runtime shutdown. The reviewer correctly identified that the current implementation of global mutex initialization is susceptible to the Static Initialization Order Fiasco (SIOF) and suggested using a function-local static pointer ('construct on first use' idiom) to mitigate this risk.
Replace the namespace-scope `Mutex* g_x = new Mutex();` globals with accessor functions that own a function-local static. Dynamic initialization of a namespace-scope pointer is subject to static initialization order, so a static initializer in another translation unit that called GetInstance() would have found a null mutex. A function-local static is initialized on first use, thread-safely, regardless of translation unit order, and the pointer it holds is still never freed. Auth and Remote Config now also keep their map behind the same kind of accessor instead of lazily allocating and freeing a raw pointer, which removes the null checks and manual lifetime management from the GetInstance/Find/DeleteInternal paths. Callers only ever see references.
Introduce firebase::NoDestructor<T>, a small wrapper (modelled on absl::NoDestructor) that constructs a T in place and never runs its destructor. Use it for the registry mutexes of every product and the registry maps of Auth and Remote Config in place of `static T* const t = new T;`. The objects are now stored inline in the function-local static rather than on the heap, there is no `new` or raw pointer anywhere in the registry code, and leak checkers have nothing to report since nothing is allocated. The semantics are otherwise unchanged: constructed on first use, thread-safely, regardless of translation unit order, and never destroyed. Includes a unit test for NoDestructor.
|
/gemini review |
There was a problem hiding this comment.
Code Review
This pull request introduces a NoDestructor utility class to wrap function-local statics, such as global maps and mutexes, ensuring they are constructed on first use and never destroyed. This change prevents crashes at process exit when Firebase SDK instances (such as Auth, RemoteConfig, Database, Storage, Functions, Installations, or AppCheck) are owned by static objects and destroyed after the SDK's globals. The review feedback highlights several critical issues regarding redundant recursive locking or potential deadlocks in Auth, RemoteConfig, and Installations where locked functions call other functions that attempt to acquire the same mutex. Additionally, minor improvements are suggested for NoDestructor to use decayed array pointers instead of pointer-to-array types for cleaner and more portable casts.
- In NoDestructor, cast the decayed array pointer `storage_` rather than `&storage_` in placement new and `get()`. - In Auth, RemoteConfig, and Installations, factor out `Find*Locked(App*)` helpers (and inline the internal cleanup in `~Installations()`) so callers that already hold the registry mutex do not recursively re-lock it.
|
/gemini review |
There was a problem hiding this comment.
Code Review
This pull request introduces the NoDestructor template class to wrap function-local statics, preventing process-exit crashes when Firebase SDK instances (such as Auth, RemoteConfig, Database, Storage, Functions, Installations, and AppCheck) are owned by static objects and destroyed after the SDK's globals. The feedback suggests optimizing the Auth map deletion by performing a direct key lookup instead of iterating through the map, and refactoring the Installations cleanup logic into a helper function to eliminate code duplication.
…odules - Harden NoDestructor<T> with SFINAE forwarding-ctor guard, brace-init overloads, and std::launder access - Migrate firebase_app, app/rest, and all product libraries (Analytics, AppCheck, Auth, Database, Firestore, Functions, Installations, Messaging, RemoteConfig, Storage, UMP) across Desktop, Android, and iOS onto function-local NoDestructor accessors - Fix Installations out-of-order App deletion map retention, ABA safety, failed-init cleanup in Installations/RemoteConfig, and O(log N) Auth map removal - Enable -Werror=exit-time-destructors on Clang/AppleClang across all 12 static library targets - Add firebase_app_static_destruction_test, expanded NoDestructor unit tests, and Installations out-of-order teardown regression test
Conflicts: - app/rest/util.cc: keep main's curl global ref-counting in CreateCurlPtr()/DestroyCurlPtr() and this branch's UtilCurlMutex() accessor. - release_build_files/readme.md: keep both sets of release notes. Also restore three unrelated clang-format hunks (app/src/app_desktop.cc, app/src/util.h, database/tests/desktop/view/view_processor_test.cc) to main's text so the file format check passes.
Require std::is_constructible<T, Args&&...> so NoDestructor<T> is not
implicitly convertible from argument lists T rejects. GCC 10 otherwise
reports NoDestructor<std::vector<int>>({10, 20, 30}) as ambiguous with the
deleted copy constructor.
Document that NoDestructor is for function-local statics only, and why that
cannot be enforced with a static_assert.
…-free Make the map and vector test objects function-local statics so their heap allocations stay reachable under LeakSanitizer.
Add firebase_cpp_reject_exit_time_destructors() in cmake/exit_time_destructors.cmake. It adds -Wexit-time-destructors on Clang, and -Werror=exit-time-destructors only when FIREBASE_CPP_WERROR_EXIT_TIME_DESTRUCTORS is ON, so a declaration in a third-party header cannot break source builds of the SDK. Stop applying the flag to firebase_firestore: firebase-ios-sdk headers it includes declare function-local statics with destructors, which failed every Clang build of Firestore.
Set FIREBASE_CPP_WERROR_EXIT_TIME_DESTRUCTORS in the desktop, Android and iOS workflows; the CMake option defaults to that environment variable. Add scripts/gha/check_exit_time_destructors.py, which fails when an SDK static library references __cxa_atexit or atexit, and run it on the Linux desktop jobs, where GCC has no equivalent diagnostic.
RemoveApp() no longer releases a callback reference when the App was never added. Cover that with a test that fails without the change.
AddCallback logs, and logging locks a Mutex, so the claim that it avoids constructing a Mutex during static initialization was wrong.
Avoids the "Future with handle 1 still exists" warning at exit. Describe the test as the smoke test it is.
Replaces a namespace-scope "new std::mutex()" initializer, which depends on static initialization order, with the pattern used elsewhere.
std::string allocates for short strings with the legacy libstdc++ ABI, which the Linux build uses by default.
…null InstallationsInternal and RemoteConfigInternal took a reference on the shared JNI class cache before calling the Java getInstance(). When that returned null (or threw) and FIREBASE_ASSERT() did not abort because the application installed its own log callback, Initialized() stayed false and the owning object's DeleteInternal() skipped Cleanup(), so the reference was never released. Release it in the constructor on that path. Installations also clears a pending Java exception first, as Remote Config already did. Not compiled or run: no Android toolchain on the machine this was written on.
Each test binary keeps an App and a product instance in a namespace-scope object and lets exit() destroy them after main() has returned, which is the situation in issue #110. A regression makes the binary crash or abort on exit. Covered: Auth, Remote Config, Installations, App Check, Functions, Storage, Database and Messaging (listener removal). All but App Check also destroy a second App before its product instance; App Check is left out of that order because an App deletes its own AppCheck. On Linux with clang 19 every one of these aborts on origin/main and exits 0 with this change. Auth and Remote Config fail there on a freed std::map node; the others fail on the Mutex::Release() assertion for a destroyed mutex, which Apple platforms do not enforce. Functions had no unit tests, so this adds functions/tests.
…paths Installations and Remote Config can only fail to initialize on Android, so the desktop implementations get SetInitializationFailsForTesting() to let unit tests reach the failed-init branch of GetInstance() and DeleteInternal(). New tests: - Installations and Remote Config: GetInstance() returns null when initialization fails and does not cache the failed instance. That the failed instance is deleted is only visible to a leak checker. - Remote Config: destroying the App first clears the cached instance (counterpart of the Installations test). - Auth: deleting an Auth removes only its own map entry and the App gets a working Auth again.
With libstdc++ before GCC 13, <iostream> defines a static std::ios_base::Init in every translation unit that includes it, which registers an exit-time destructor and fails scripts/gha/check_exit_time_destructors.py. Nothing in the file uses it.
With libstdc++ older than GCC 13, including <iostream> gives the translation unit a static std::ios_base::Init object, whose destructor is registered to run at exit. None of these four files uses the standard streams; util_desktop.cc and metadata_desktop.cc keep <sstream> for the string streams they do use.
| if (!cleaned_up_) { | ||
| while (callbacks_.begin() != callbacks_.end()) { | ||
| std::pair<void *, CleanupCallback> object_and_callback = | ||
| std::pair<void*, CleanupCallback> object_and_callback = |
There was a problem hiding this comment.
Add #include <utility> for pair<>
| @@ -47,9 +48,10 @@ static_assert(sizeof(FutureBase) == sizeof(Future<int>), | |||
| typedef void DataDeleteFn(void* data_to_delete); | |||
| typedef std::pair<FutureHandleId, FutureBackingData*> BackingPair; | |||
There was a problem hiding this comment.
Add #include <utility> for pair<>
|
|
||
| const std::pair<Variant, Variant>& QueryParamsComparator::MaxNode() { | ||
| static const NoDestructor<std::pair<Variant, Variant>> max_node( | ||
| std::make_pair(QueryParamsComparator::kMaxKey, MaxVariant())); |
There was a problem hiding this comment.
Add #include <utility> for make_pair
| namespace internal { | ||
| extern ::firebase::Mutex g_cached_ump_embedded_files_mutex; | ||
| ::firebase::Mutex& CachedUmpEmbeddedFilesMutex(); | ||
| extern std::vector<::firebase::internal::EmbeddedFile>* |
There was a problem hiding this comment.
Add #include <vector> for vector<>
Description
Fixes #110.
A
firebase::Appor product object owned by a static (for example a staticstd::unique_ptr<Auth>) is destroyed during process exit. Onmainthat can happen after the C++ runtime has already destroyed the SDK's own static maps and mutexes, so the destructor uses freed memory or a destroyed mutex.firebase::NoDestructor<T>(app/src/no_destructor.h, new in this PR): a wrapper for function-local statics that are constructed thread-safely on first use and never destroyed.firebase_app,firebase_rest_liband the product libraries (Analytics,AppCheck,Auth,Database,Firestore,Functions,Installations,Messaging,RemoteConfig,Storage,UMP) ontoNoDestructor<T>. This also removes the namespace-scopeX* g = new X()initializers, which depended on static initialization order.firebase_cpp_reject_exit_time_destructors(<target>)(cmake/exit_time_destructors.cmake), applied to 12 library targets:firebase_app,firebase_rest_liband every product library except Firestore. It adds Clang's-Wexit-time-destructorsas a warning. It becomes-Werror=exit-time-destructorsonly whenFIREBASE_CPP_WERROR_EXIT_TIME_DESTRUCTORSis on, which the desktop, Android and iOS workflows turn on through an environment variable. Source builds outside CI are not broken by a static in a dependency's header.firebase_firestoreincludes firebase-ios-sdk headers (Firestore/core/src/api/stages.h,Firestore/core/src/model/field_index.h) that declare statics with destructors, so the flag cannot be enabled there until those are changed upstream. Firestore's own registries in this repo are migrated, but nothing enforces that for Firestore.scripts/gha/check_exit_time_destructors.py, run on the Linux desktop jobs. GCC and MSVC have no equivalent warning, so on Linux the script checks the 12 non-Firestore archives for references to__cxa_atexit/atexit.Behavior changes that are not part of the mechanical migration:
Installations: when anAppis destroyed before itsInstallationsobject, the object is now removed from the per-App registry. Its methods return an invalidFutureinstead of crashing, andGetInstance()on a newAppreturns a new instance.Installations,RemoteConfig: an instance whose initialization failed is deleted without touching state it never registered. On Android, a null Java instance now releases the class reference taken in the constructor.Auth:Auth::DeleteInternal()erases its registry entry by key.app_common::RemoveApp()no longer releases a callback reference for anAppthat was never registered.Known trade-off: SDK statics are now intentionally never destroyed, so leak checkers that do not treat still-reachable memory as live will keep reporting them (see #1446 below).
Testing
CI on this branch (
d7f01ae5): all PR checks pass exceptcheck_integration_test_labels, which fails by design while the PR carries atests-requestedlabel.file_format_check, lint, docs, and the Linux local integration tests.Integration tests: one full manually triggered run on
d7f01ae5(Desktop, Android, iOS; all products), https://github.com/firebase/firebase-cpp-sdk/actions/runs/43934762162. All 24 jobs are green after one re-run: one Firestore emulator test,QueryNetworkTest.TestWatchSurvivesNetworkDisconnect, timed out once on Ubuntu/openssl and passed when that job was re-run.Local runs (Linux x86_64, clang 19 and g++ 15; Firestore compiled but not linked or run):
-Werror=exit-time-destructors: no diagnostics.check_exit_time_destructors.pyfinds no__cxa_atexit/atexitreference in the 12 non-Firestore archives, and does report archives built frommain.main()regression tests, onestatic_destruction_test.ccper product, for Auth, Remote Config, Installations, App Check, Functions, Storage, Database and Messaging. Each owns anAppand a product object from a static and lets process exit destroy them. All eight abort onmainand pass on this branch. Auth and Remote Config fail onmainon a freedstd::mapnode. The other six fail onmainonly through the assert on unlocking a destroyed mutex, which the pthreadMutexdoes not raise on Apple platforms.App+Auth) under AddressSanitizer:heap-use-after-freeinAuth::DeleteInternal()onmain, clean on this branch.InstallationsTest.DestroyAppBeforeInstallationsClearsCachedInstancecrashes onmainand passes here.InstallationsandRemoteConfigon desktop, through a test-only switch that forces it. The leak this fixes is visible only to a leak checker.RemoveApp()for an unregisteredApp(app_desktop_test.cc); the test fails onmain.firebase_app_no_destructor_test, including the constructor constraint; leak-free under LeakSanitizer.#include <iostream>gives the translation unit a staticstd::ios_base::Initwith an exit-time destructor. The five SDK sources that included it without using it no longer do.Not tested, or weaker than it looks:
maineither).-Werror=exit-time-destructorsis actually in effect in the macOS, iOS and Android builds. The environment variable is set there; the CMake option itself was verified only locally on Linux.main()test (its registry was already heap-allocated onmain), and it is not covered by the compiler flag or the archive check.main()test; they have nothing destructible on desktop.firebase_app_static_destruction_testis a smoke test. It passes onmainas well, because thefirebase_appstate it touches was already heap-allocated there.main. They add coverage and are not regression tests.main()tests depend on the test's static being destroyed after the SDK's, which follows from link order.mainor on this branch, because of two existing failures unrelated to this change.Type of Change
Place an
xthe applicable box:Fixes #110
Related (not fixed by this change):
checkers that do not treat still-reachable memory as live will keep reporting them.
path first-use-initialized; the root cause there was never confirmed.
Mutexdestructors being incorrectly run at exit (cl/364325997) #345.Unity SDK: no Unity issue is closed by this change; none has a native stack that reaches a
C++ SDK static destroyed at exit.
[Bug] Crash on Quit when using Analytics, Crashlytics, and Remote Config firebase-unity-sdk#570, libc.so Crash after updating to firebase unity sdk 8.6.1/8.6.2 quickstart-unity#1193
Crashes on application exit ios (Messaging and Analytics sdks) quickstart-unity#271, Crash in firebase::messaging::ProcessMessages quickstart-unity#294
CppInstanceManager<T>, listenermutexes, Crashlytics locks) still have exit-time destructors and should move to
firebase::NoDestructor<T>in a separate firebase-unity-sdk PR.Notes
Release Notessection ofrelease_build_files/readme.md.