Skip to content

Fix use-after-free when Firebase instances are destroyed during static destruction - #1949

Draft
AustinBenoit wants to merge 23 commits into
mainfrom
fix/static-destruction-order
Draft

AustinBenoit wants to merge 23 commits into
mainfrom
fix/static-destruction-order

Conversation

@AustinBenoit

@AustinBenoit AustinBenoit commented Oct 26, 2026 •

Copy link
Copy Markdown
Contributor

Description

Provide details of the change, and generalize the change in the PR title above.

Fixes #110.

A firebase::App or product object owned by a static (for example a static std::unique_ptr<Auth>) is destroyed during process exit. On main that 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.

  • Adds 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.
  • Moves the SDK's process-wide registries, mutexes, loggers, callback/cleanup state and non-trivial static constants in firebase_app, firebase_rest_lib and the product libraries (Analytics, AppCheck, Auth, Database, Firestore, Functions, Installations, Messaging, RemoteConfig, Storage, UMP) onto NoDestructor<T>. This also removes the namespace-scope X* g = new X() initializers, which depended on static initialization order.
  • Adds a CMake helper, firebase_cpp_reject_exit_time_destructors(<target>) (cmake/exit_time_destructors.cmake), applied to 12 library targets: firebase_app, firebase_rest_lib and every product library except Firestore. It adds Clang's -Wexit-time-destructors as a warning. It becomes -Werror=exit-time-destructors only when FIREBASE_CPP_WERROR_EXIT_TIME_DESTRUCTORS is 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.
  • Firestore is excluded from the compiler flag. firebase_firestore includes 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.
  • Adds 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 an App is destroyed before its Installations object, the object is now removed from the per-App registry. Its methods return an invalid Future instead of crashing, and GetInstance() on a new App returns 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 an App that 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

Describe how you've tested these changes. Link any manually triggered Integration tests or CPP binary SDK Packaging Github Action workflows, if applicable.

CI on this branch (d7f01ae5): all PR checks pass except check_integration_test_labels, which fails by design while the PR carries a tests-requested label.

  • Ubuntu x4 (GCC 10.5): build, archive check, and the unit suite, 116/116, including the nine static-destruction tests.
  • Windows x2: build; the Release x64 job ran the unit suite, 116/116, including the new tests.
  • macOS x2 and iOS: build, including Firestore.
  • Android x3: build.
  • 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):

  • Clang 19 build of all non-Firestore targets with -Werror=exit-time-destructors: no diagnostics. check_exit_time_destructors.py finds no __cxa_atexit / atexit reference in the 12 non-Firestore archives, and does report archives built from main.
  • New post-main() regression tests, one static_destruction_test.cc per product, for Auth, Remote Config, Installations, App Check, Functions, Storage, Database and Messaging. Each owns an App and a product object from a static and lets process exit destroy them. All eight abort on main and pass on this branch. Auth and Remote Config fail on main on a freed std::map node. The other six fail on main only through the assert on unlocking a destroyed mutex, which the pthread Mutex does not raise on Apple platforms.
  • The issue Use after free triggered on application exit #110 shape (static owner of App + Auth) under AddressSanitizer: heap-use-after-free in Auth::DeleteInternal() on main, clean on this branch.
  • InstallationsTest.DestroyAppBeforeInstallationsClearsCachedInstance crashes on main and passes here.
  • Failed initialization of Installations and RemoteConfig on desktop, through a test-only switch that forces it. The leak this fixes is visible only to a leak checker.
  • RemoveApp() for an unregistered App (app_desktop_test.cc); the test fails on main.
  • New firebase_app_no_destructor_test, including the constructor constraint; leak-free under LeakSanitizer.
  • The archive check found one thing the Clang flag cannot see: with libstdc++ before GCC 13, #include <iostream> gives the translation unit a static std::ios_base::Init with an exit-time destructor. The five SDK sources that included it without using it no longer do.

Not tested, or weaker than it looks:

  • The new tests have not run on macOS or iOS. CI does not run unit tests on macOS arm64 (on main either).
  • The CI logs do not show whether -Werror=exit-time-destructors is 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.
  • Windows-only sources are checked by neither the compiler flag nor the archive check.
  • The Android failed-initialization path compiles in CI but has never been executed.
  • Firestore: no post-main() test (its registry was already heap-allocated on main), and it is not covered by the compiler flag or the archive check.
  • Analytics and UMP have no post-main() test; they have nothing destructible on desktop.
  • firebase_app_static_destruction_test is a smoke test. It passes on main as well, because the firebase_app state it touches was already heap-allocated there.
  • The Remote Config App-first test and the Auth re-create test also pass on main. They add coverage and are not regression tests.
  • The post-main() tests depend on the test's static being destroyed after the SDK's, which follows from link order.
  • The unit suite is not AddressSanitizer-clean, on main or on this branch, because of two existing failures unrelated to this change.

Type of Change

Place an x the applicable box:

  • Bug fix. Add the issue # below if applicable.
  • New feature. A non-breaking change which adds functionality.
  • Other, such as a build process or documentation change.

Fixes #110

Related (not fixed by this change):

Unity SDK: no Unity issue is closed by this change; none has a native stack that reaches a
C++ SDK static destroyed at exit.


Notes

  • Bug fixes and feature changes require an update to the Release Notes section of release_build_files/readme.md.
  • Read the contribution guidelines CONTRIBUTING.md.
  • Changes to the public API require an internal API review. If you'd like to help us make Firebase APIs better, please propose your change in a feature request so that we can discuss it together.

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

@gemini-code-assist gemini-code-assist Bot left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

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.

Comment thread app_check/src/common/app_check.cc Resolved
Comment thread app_check/src/common/app_check.cc Resolved
Comment thread app_check/src/common/app_check.cc Resolved
Comment thread app_check/src/common/app_check.cc Resolved
Comment thread database/src/common/database.cc Resolved
Comment thread remote_config/src/remote_config.cc Resolved
Comment thread remote_config/src/remote_config.cc Resolved
Comment thread storage/src/common/storage.cc Resolved
Comment thread storage/src/common/storage.cc Resolved
Comment thread storage/src/common/storage.cc Resolved
@AustinBenoit
AustinBenoit marked this pull request as draft October 26, 2026 15:42
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.
@AustinBenoit

Copy link
Copy Markdown
Contributor Author

/gemini review

@gemini-code-assist gemini-code-assist Bot left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

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.

Comment thread app/src/no_destructor.h Resolved
Comment thread app/src/no_destructor.h Resolved
Comment thread auth/src/auth.cc Resolved
Comment thread remote_config/src/remote_config.cc Resolved
Comment thread installations/src/installations.cc Resolved
Comment thread installations/src/installations.cc Resolved
- 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.
@AustinBenoit

Copy link
Copy Markdown
Contributor Author

/gemini review

@gemini-code-assist gemini-code-assist Bot left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

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.

Comment thread auth/src/auth.cc Resolved
Comment thread installations/src/installations.cc Resolved
Comment thread installations/src/installations.cc Resolved
…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
@AustinBenoit AustinBenoit added the tests-requested: full Trigger a FULL set of integration tests (uses expanded test matrix). label Oct 30, 2026
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 =

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

⚠️ Lint warning: 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;

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

⚠️ Lint warning: 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()));

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

⚠️ Lint warning: 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>*

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

⚠️ Lint warning: Add #include <vector> for vector<>

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

tests-requested: full Trigger a FULL set of integration tests (uses expanded test matrix).

Projects

None yet

Development

Successfully merging this pull request may close these issues.

Use after free triggered on application exit

1 participant