You are viewing a plain text version of this content. The canonical link for it is here.
Posted to issues@trafficserver.apache.org by "c-taylor (via GitHub)" <gi...@apache.org> on 2026/06/02 15:56:48 UTC
[I] SSLCertContext::operator= writes ctx without holding this->ctx_mutex (data race with concurrent getCtx/setCtx) [trafficserver]
c-taylor opened a new issue, #13225:
URL: https://github.com/apache/trafficserver/issues/13225
Worked Copilot suggestion from https://github.com/apache/trafficserver/pull/13098
----
**Component:** `iocore/net` — TLS cert lookup
**Files:**
- `src/iocore/net/SSLCertLookup.cc`
- `src/iocore/net/P_SSLCertLookup.h`
## Summary
`SSLCertContext::operator=` (`src/iocore/net/SSLCertLookup.cc:245-256`) mutates `this->ctx` and the four sibling fields (`opt`, `userconfig`, `keyblock`, `ctx_type`) without acquiring `this->ctx_mutex`. The class's documented contract — established by `getCtx()` / `setCtx()` (`src/iocore/net/SSLCertLookup.cc:259-271`) and by the comment in `P_SSLCertLookup.h:122` ("Threadsafe Functions to get and set shared SSL_CTX pointer") — is that `ctx` is protected by `ctx_mutex`. `operator=` violates that invariant: a thread copy-assigning to `*cc` races against any concurrent `cc->getCtx()` / `cc->setCtx()` reader or writer, because the assigner takes a lock only on `other.ctx_mutex`, never on `this->ctx_mutex`.
The same gap is present (less severely) for `opt`, `userconfig`, `keyblock`, `ctx_type`: those fields are read directly throughout the codebase without any lock, and `operator=` writes them with no synchronization at all.
## Why this matters
Published `SSLCertContext` instances are mutated post-publication today. The cert-secret reload path calls `setCtx()` on entries returned by `lookup->find(...)`:
- `src/iocore/net/SSLUtils.cc:1704`
- `src/iocore/net/SSLUtils.cc:1729`
There is currently no in-tree call site that invokes `operator=` on a published `SSLCertContext` (insertion goes through `SSLContextStorage::store()` → `ctx_store.push_back(cc)` at `src/iocore/net/SSLCertLookup.cc:437-441`, which uses the copy *constructor*, not `operator=`, even on vector reallocation). So the bug is latent. But the class invariant is wrong as stated: a future change that assigns to a published entry — e.g., a partial-reload variant that swaps a slot in-place rather than rebuilding the whole `SSLCertLookup` — would silently introduce a data race that current readers via `getCtx()` would not be protected against.
## Reproduction sketch (conceptual — not currently triggerable in tree)
```cpp
SSLCertContext *cc = lookup->find(name); // published entry
// Thread A:
auto p = cc->getCtx(); // lock_guard(ctx_mutex), reads ctx
// Thread B:
*cc = SSLCertContext(new_ctx, ...); // takes other.ctx_mutex,
// then writes cc->ctx with NO lock on cc->ctx_mutex
```
Thread A and Thread B race on `cc->ctx` (a `std::shared_ptr`). Tearing during the assignment can leave `cc->ctx` observably half-updated to A; Thread A may also load a refcount/control-block pair that disagree, leading to use-after-free or double-decrement on the underlying `SSL_CTX`.
## Possible Fix
Lock both `other.ctx_mutex` and `this->ctx_mutex` in `operator=`, using `std::lock` to acquire them in a deadlock-free order, and move *all* field assignments inside the locked section so the assignment is atomic from any reader's perspective. The self-assignment guard (`&other != this`) must remain to avoid double-locking the same mutex.
Apply this patch to `src/iocore/net/SSLCertLookup.cc:245-256`:
```cpp
SSLCertContext &
SSLCertContext::operator=(SSLCertContext const &other)
{
if (&other != this) {
std::unique_lock<std::mutex> other_lock(other.ctx_mutex, std::defer_lock);
std::unique_lock<std::mutex> this_lock(this->ctx_mutex, std::defer_lock);
std::lock(other_lock, this_lock);
this->opt = other.opt;
this->userconfig = other.userconfig;
this->keyblock = other.keyblock;
this->ctx_type = other.ctx_type;
this->ctx = other.ctx;
}
return *this;
}
```
Note: the copy constructor at `src/iocore/net/SSLCertLookup.cc:234-242` is *not* affected — `this` is not yet observable during construction, so locking `this->ctx_mutex` is unnecessary. Locking `other.ctx_mutex` is sufficient and is already done.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: issues-unsubscribe@trafficserver.apache.org.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
Re: [I] SSLCertContext::operator= writes ctx without holding this->ctx_mutex (data race with concurrent getCtx/setCtx) [trafficserver]
Posted by "AceMeistr (via GitHub)" <gi...@apache.org>.
AceMeistr commented on issue #13225:
URL: https://github.com/apache/trafficserver/issues/13225#issuecomment-4605557677
I have applied the fix with:
```cpp
SSLCertContext &
SSLCertContext::operator=(SSLCertContext const &other)
{
if (&other != this) {
std::scoped_lock lock(this->ctx_mutex, other.ctx_mutex);
this->opt = other.opt;
this->userconfig = other.userconfig;
this->keyblock = other.keyblock;
this->ctx_type = other.ctx_type;
this->ctx = other.ctx;
}
return *this;
}
```
Replaced the manual lock definition and sequence with std::scoped_lock to lock both the target and source object mutexes at once simultaneously
Resolves data races if another thread tried to read or modify the target object concurrently.
also pushed lock guard to beginning to avoid source mutation during read to avoid data race by threads
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: issues-unsubscribe@trafficserver.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
Re: [I] SSLCertContext::operator= writes ctx without holding this->ctx_mutex (data race with concurrent getCtx/setCtx) [trafficserver]
Posted by "bryancall (via GitHub)" <gi...@apache.org>.
bryancall closed issue #13225: SSLCertContext::operator= writes ctx without holding this->ctx_mutex (data race with concurrent getCtx/setCtx)
URL: https://github.com/apache/trafficserver/issues/13225
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: issues-unsubscribe@trafficserver.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org