trustd, the daemon that decides which certificates to believe
The daemon that checks every certificate your Mac sees: its OCSP cache, the 41 MB list of what it already believes, and a trust store that updates itself.
By Chethan Kumar S N · Updated
Of all the lowercase names in Activity Monitor, trustd might be the only one that sounds like a feeling. Trust, with a d. It shows up with no icon and no explanation, sometimes more than once, sometimes under users you have never heard of like _trustd and _locationd, and if you search for it you will find two kinds of pages: forums saying do not touch it, and a surprising number of results for the phrase user trustd, typed by people who counted the rows in their own process list and wanted to know why there were several.
This page is the full answer, built the way the other process pages in this series are built: from the daemon’s own files, its own manual entry, its own logs and databases, all measured read only on one Mac running macOS 27.0.1. Nothing was quit, killed, deleted or changed while measuring, and the commands used are at the end if you want to repeat any of them.
The short version of the job: every time any process on your Mac needs to know whether a certificate is any good, whether that is a website’s TLS certificate, a mail server’s, a signed app’s, or the chain behind a configuration profile, the question lands here. trustd is the part of macOS that decides which certificates to believe.
What the process is, in one command
The process table answers the first questions, and in this daemon’s case it answers a question you did not know you had:
$ ps -Arco pid,ppid,user,etime,time,command | grep "[t]rustd"
PID PPID USER ELAPSED TIME COMMAND
60974 1 chethankumar 18-03:47:19 60:34.13 /usr/libexec/trustd --agent
61003 1 _trustd 18-03:47:07 244:44.39 /usr/libexec/trustd
Two rows, both started at the same moment 18 days ago, both parented by launchd, which is PID 1 and the only parent a system daemon ever has. The first is owned by the logged in user and carries a single flag, --agent. The second runs as _trustd, a reserved account that exists only for this daemon, and has done 244 minutes and 44 seconds of processor work over those 18 days. We will come back to that number, because it is the answer to the CPU question people actually search for.
The full picture on this Mac is wider than two rows:
| Copy | User | Why it exists |
|---|---|---|
/usr/libexec/trustd | _trustd | the one system daemon every process can ask |
/usr/libexec/trustd --agent | your user | one agent per login session, for session scoped work |
/usr/libexec/trustd --agent | _locationd | service accounts get login sessions too |
/usr/libexec/trustd --agent | _cmiodalassistants | camera and microphone helpers, same deal |
| trustd inside each iOS simulator runtime | your user | Xcode simulators ship their own macOS, roots and all |
That table is the answer to why Activity Monitor can show several trustd rows at once, and it is not a bug or an infection. It is one binary launched into several contexts, which is unusual enough that Apple’s own manual comments on it. For the same pattern at its extreme, distnoted runs one copy per background session and shows up twenty-odd times on a normal Mac.
The binary itself is 2,159,104 bytes, built for x86_64 and two arm64e variants at once, so one file runs on Intel and Apple silicon. Codesign reports it as com.apple.trustd, Platform identifier 26, signed 3 September 2026, with 23 entries in its embedded Info.plist. The reserved _trustd account has RealName trustd, group 282, and the shell /usr/bin/false, meaning nobody can log in as it. It exists to own this daemon and nothing else.
The manual entry, two sentences long
The man page at /usr/share/man/man8/trustd.8 is 534 bytes and dated 14 January 2017, and its entire description is worth reading, because it says more than most:
trustd provides services for evaluating trust in certificates for all processes on the system.
This command is not intended to be invoked directly.
The NAME line calls it a “Daemon and LaunchAgent that performs trust evaluations”, which is the manual’s way of telling you the two-in-one arrangement above is deliberate. There is a sibling page for the helper: trustdFileHelper(8), dated December 2020, 496 bytes, which says it “provides services to trustd for modifying files”. Read those two lines carefully and the architecture appears: one daemon that evaluates, one helper with the rights to write, and a set of agents for per session work. Nine years of macOS have passed since that page was written and the sentence has not needed changing.
What trust evaluation actually is
A certificate is a signed claim, and on its own it proves nothing. To say a certificate is trusted, macOS has to build a chain from it up to a root your Mac already believes, check that every signature in that chain verifies, check the dates, check that none of the certificates has been revoked, and apply any policy that applies to the occasion: one policy for TLS, another for code signing, another for S/MIME mail. Apple’s developer documentation for the Security framework describes the layer in exactly one line: “Evaluate trust based on a given policy.”
trustd is where that evaluation happens for the whole system. The apps you use do not check certificates themselves; they call the system APIs, and the system hands the question to this daemon, which has the caches, the root list and the revocation machinery already loaded. Safari, Mail, the App Store, software update, configuration profiles, and the checks behind notarized apps all end up here. The one honest nuance: Firefox carries its own certificate store and verifier, so its checks do not run through trustd. Chrome uses the Mac’s roots. Most everything else on a Mac is a system API customer.
Revocation is the part most worth understanding, because it is what makes this daemon talk to the network. A certificate can be perfectly well formed and still have been withdrawn by whoever issued it, so after verifying signatures, the daemon asks the issuer, or a cache of the issuer’s answer, whether the certificate is still good. The standard protocol for that question is OCSP, the Online Certificate Status Protocol. Apple runs responders for its own certificates, and every other certificate authority runs its own. The answers get cached, because asking again for a certificate you checked an hour ago buys nothing.
Forty five minutes of its log, counted
You can watch all of the above happen. The unified log records every evaluation, and counting a slice of it turns the vague sense of a busy daemon into numbers. In 45 minutes on a Mac doing ordinary background work, nothing special running:
| What the log shows | Count in 45 minutes |
|---|---|
| trust evaluations started | 25,752 |
| evaluations completed | 25,752 |
| log lines in total | 254,207 |
| lines mentioning ocsp | 92,566 |
| OCSP answers with no revocation information | 82,970 |
| OCSP signer chain checks | 9,440 |
| certificates found actually revoked | 0 |
| fetch failures or timeouts | 0 |
Twenty five thousand evaluations in 45 minutes is about nine and a half every second, which sounds like a lot until you see how long one takes. Here is a single evaluation from the log, verbatim, timestamps and all:
13:23:00.332 starting trust evaluation
13:23:00.333 (Security) SecKeyVerifySignature
13:23:00.333 (Security) SecKeyVerifySignature
13:23:00.334 (Security) SecKeyCopyPublicBytes
13:23:00.334 [ocsp] cert 0: OCSP status revoked=(null) ...
13:23:00.334 [ocsp] cert 1: OCSP status revoked=(null) ...
13:23:00.334 [ocsp] cert 2: OCSP status revoked=(null) ...
13:23:00.335 completed trust evaluation
Three milliseconds, start to finish: two signature verifications, a public key read, an OCSP status consult for each of three certificates in the chain, done. Multiply that by 25,752 and you have the daemon’s whole working life. The revoked=(null) entries are not failures; they are certificates whose issuers publish no revocation information for that class of certificate, which is common, and the system treats it as unknown rather than bad. In this entire window, not one certificate came back revoked and not one check timed out. That is what a healthy trust system looks like: enormous numbers, tiny costs, boring answers.
The databases it keeps
The daemon’s working state lives in /private/var/protected/trustd, and even the sizes tell the story:
| File | Size | What it holds |
|---|---|---|
| valid.sqlite3 | 41,164,800 bytes | the cache of evaluations already proven |
| pinningrules.sqlite3 | 339,968 bytes | certificate pinning rules, which override chains |
| private/ | per boot directory | the OCSP answer cache, reset by boot UUID |
| AutoAsset.plist | 360 bytes | the pointer to the current trust store asset |
The 41 MB valid.sqlite3 is the interesting one. It is a database of certificates this Mac has already decided about, so that the next evaluation can skip most of the work. Its write ahead log was last written the day before these measurements, which is the cadence you want: small, occasional, boring.
The OCSP cache is where the daemon’s own binary becomes the documentation. trustd carries its SQLite schema as string literals inside the executable, which means you can read the cache’s exact design without opening it:
CREATE TABLE ocsp(issuerNameHash BLOB NOT NULL,
issuerPubKeyHash BLOB NOT NULL, serialNum BLOB NOT NULL,
hashAlgorithm BLOB NOT NULL, responseId INTEGER NOT NULL,
certStatus INTEGER NOT NULL DEFAULT 255);
CREATE TABLE responses(responseId INTEGER PRIMARY KEY,
ocspResponse BLOB NOT NULL, responderURI BLOB,
expires DOUBLE NOT NULL, lastUsed DOUBLE NOT NULL);
Two tables: one indexes each cached answer by a hash of the issuer and the certificate’s serial number, the other stores the raw signed response and when it expires. The housekeeping queries are in there too: expired responses are deleted, and any entry whose status is not the literal value for good is thrown out rather than trusted. The binary also still carries the path /Library/Keychains/ocspcache.sqlite3, the cache’s old home from before it moved behind the protected directory. A 2 MB executable that contains its own database migrations is a good indication nobody outside Apple was ever meant to manage this by hand, and you should not.
The trust store that updates itself
Here is the part almost nobody knows. Where does the list of roots your Mac believes come from? Not from the OS install alone. It arrives as an over the air asset, the same mechanism that updates things like pronunciation dictionaries and Siri assets, downloaded by the system in the background.
The evidence is on disk. /System/Library/AssetsV2/com_apple_MobileAsset_PKITrustStore/purpose_auto/ holds timestamped trust store assets, and on this Mac there are two of them sitting side by side, one from 12 November and one from 14 November, each containing a certsTable.data of about 196 KB that the running agent was actively reading from the older of the two. The download directory is owned by _nsurlsessiond, because the system’s downloader is another one of those per user daemons. Beside them sits a 3,698 byte XML manifest dated 28 October.
So when a certificate authority is added, removed or distrusted somewhere in the world, Apple can change what every Mac believes without shipping an operating system update. The trust store is a live document. This also answers a question people ask after a certificate panic, like the occasional expired root incident: your Mac’s list of roots probably was updated to fix it, quietly, before you read the news.
Three domains of trust, and the tool that reads them
The security command, which ships with macOS, exposes the settings layer on top of all this machinery, and it sorts your Mac’s beliefs into three domains. The user domain is per person. The admin domain holds overrides pushed by an administrator or MDM. The system domain is Apple’s shipped roots.
On this Mac, a work machine, the admin domain reports five certificates: four IBM internal roots and a Cisco Umbrella root, corporate trust anchors that arrived with the machine, each with “Number of trust settings: 0”, meaning trusted as-is with no special rules. The system domain reports 157 certificates, which is the current population of Apple’s root program: DigiCert, Amazon, OISTE WISeKey, XRamp and the rest. You can export your own user domain to a file with security trust-settings-export ~/Desktop/mine.plist and read it as a property list, and the settings UI behind it is the Certificate Trust list inside Keychain Access, where a certificate can be set to Always Trust for a specific purpose.
That three layer split is worth knowing when something seems wrong. A website that fails in Safari but loads in Firefox is usually a user or admin domain override at work, or a missing root, and the fix belongs in trust settings, not in the daemon.
Six property lists and a vocabulary list
The launch configuration is unusually talkative. There are six property lists in the trusted family, and their differences explain the process table from the top of this page:
| Launch job | Runs as | What it is |
|---|---|---|
| com.apple.trustd | _trustd | the system daemon, one Mach service |
| com.apple.trustd.agent | per session | the agent copy, --agent, for Aqua, Background, LoginWindow and CryptexContainer sessions |
| com.apple.trustdFileHelper | root | the file writer, for changes trustd itself is too unprivileged to make |
| com.apple.TrustEvaluationAgent | per session | a Background only helper from the TrustEvaluationAgent framework |
| com.apple.TrustEvaluationAgent.system | system | its system side |
| com.apple.communicationtrustd | per session | a differently named sibling, not the same daemon |
The plists share one detail that is pure gold for understanding the daemon: an environment variable called DEBUGSCOPE whose value is a list of the debug scopes its own developers named, policy-node, policy-set, trust, bind, profile, trace, dbconn, OTR, serverxpc, sqlite3, and one called error_thee_well. That is the subsystem map in ten words: policies, profiles, a database connection, a server XPC interface, and OTR, the online trust responses that the OCSP cache stores.
Launchd’s own report on the system daemon adds the behaviour numbers: runs = 4 in the current boot, minimum runtime 10 seconds, exit timeout 5, immediate reason ipc (mach), meaning it was last started because something knocked on its Mach service. The Mac has been up 26 days and the daemon has been up 18, so launchd recycled it at some point and started it again, which is what EnablePressuredExit, present in every one of these plists, is for: the system may reclaim an idle trustd under memory pressure and relaunch it on demand. If it seems to disappear from Activity Monitor and come back, that is not instability, it is the design.
Why it uses CPU, in numbers
Back to the headline number: 244 minutes 44 seconds of processor time in 18 days 3 hours and 47 minutes. That works out to about 13 and a half minutes a day for the system copy, plus 3 minutes 20 seconds a day for the agent, together a bit under 1.2 per cent of one core as a lifetime average on a machine whose uptime load average hovers around 5. Right now, idle, both copies sit at or near zero per cent.
What pushes it up is volume, and volume comes from three places: network activity, because every new TLS connection can trigger evaluations; software installs and first launches, because signatures get verified; and profile or trust setting changes, because caches get invalidated when the rules change. A macOS update is the classic spike, since the daemon wakes to a changed system and a trust store asset that may have rolled forward. All of these are normal. The number to remember from this page is 3 milliseconds per evaluation: even thousands of them cost less than a second of CPU, so a trustd that is genuinely pinned for minutes is rare and worth a look at what changed in your trust settings, or at an app that is opening connections in a loop.
Memory is the non story. 9,552 KB sampled once and 9,600 KB sampled again minutes later, a 48 KB drift, for a daemon holding a 41 MB database of cached decisions. It is small because it was built to stay small.
How to look at your own
Everything on this page came from commands you can run, none of which change anything:
ps -Arco pid,ppid,user,etime,time,command | grep "[t]rustd"
man trustd
launchctl print system/com.apple.trustd
security dump-trust-settings -d
security dump-trust-settings -s
ls -lh /private/var/protected/trustd/
log show --last 30m --predicate 'process == "trustd"' --style compact
Two honest limits from this run: lsof on the system copy needs root, so its open files were read from the agent copy instead, and the SQLite databases belong to _trustd and were not opened at all, only sized and dated. Reading the tables would need the daemon’s own rights, and nothing on this page required them.
Apple never says its name
A search of the macOS User Guide’s full table of contents for this macOS version finds the daemon’s name zero times. The guide tells you to look for the padlock, to check a certificate in Safari, to trust or not trust a prompt, and the entire machinery underneath goes unmentioned. The Apple Platform Security guide has two entries containing the word trust, and both are about trust caches, a different mechanism entirely, used to vouch for code on Apple silicon. Certificate trust, this daemon’s territory, is described only at the developer layer, on the Security framework’s Trust page, with that one line: evaluate trust based on a given policy.
Which is why the name gets searched. Millions of Macs run this daemon nine years past the last time its manual was touched, doing twenty five thousand quiet jobs every 45 minutes, and the only time anyone meets it is a row in Activity Monitor on a curious evening.
Where window managers fit
trustd works on the space between your Mac and everything it connects to, and this site is about the space on your screen, so the two are not related, except that they meet in the same Activity Monitor list on the same curious evenings. This series exists because that list is full of names nobody chose for you, and knowing what they do turns the list from noise into a map.
The map on the screen side is Ribbon. Windows stay full size on one scrolling strip instead of stacking and shrinking, so the window you want is one swipe away and nothing hides behind anything. It is $15, once, for up to 3 Macs, with a full refund within 10 days, and it runs on macOS 14 Sonoma and later on Apple silicon and Intel Macs. There is a browser demo of the strip if you want to feel it before installing anything.
The short version
trustd is the daemon that decides which certificates your Mac believes. It runs as one system daemon under its own reserved user, plus one agent per login session, including sessions for service accounts and simulators, which is why Activity Monitor can show several rows. Its man page has said everything it needs to say since January 2017. It keeps a 41 MB database of decisions already made, an OCSP cache whose schema is printed inside its own binary, and a root list that arrives over the air as an asset, twice in three days on the Mac measured here.
It costs about 13 and a half minutes of processor time a day at three milliseconds per evaluation, uses 9 MB of memory, and may be recycled by launchd under memory pressure without it meaning anything. There is nothing to quit, nothing to disable and nothing to clean, and the only intervention that ever makes sense is in the trust settings themselves, through the front door that Keychain Access provides.
Questions
What is trustd on Mac?
It is the daemon that evaluates trust in certificates. Apple's own man page, all two sentences of it, says trustd provides services for evaluating trust in certificates for all processes on the system, and describes it as a daemon and LaunchAgent, which is a clue that it runs as more than one process. In practice, when Safari checks a website's certificate, when Mail talks to a mail server, when macOS checks a signed app or an installer, the question of whether to believe the certificate involved is handed to this daemon. On this Mac the system copy has been up for 18 days, runs as its own reserved user called _trustd, and sits at about 9 MB of memory.
Is trustd a virus or malware?
No. It is Apple's own code. The binary lives at /usr/libexec/trustd on the sealed system volume, is signed by Apple's system authority with a Platform identifier of 26, and runs as a reserved system account with no shell, which is the opposite of what malware does. It has shipped a man page since 2017 and has a whole family of launch jobs with names like trustdFileHelper. People search the name because several copies of it can appear in Activity Monitor at once, under different users, with a lowercase name that resembles nothing anyone installed. That is covered in its own question below.
Why is trustd using high CPU?
Because certificates are being checked, constantly. In 45 minutes on a quiet Mac, this daemon started 25,752 trust evaluations, about nine and a half every second, each finishing in a few milliseconds. Averaged over 18 days, the system copy used about 13 and a half minutes of processor time a day, under one per cent of one core, which is its normal diet. A real spike usually means one of three things: lots of network connections being opened, a cache being rebuilt after a macOS update, or certificates being rechecked after a profile or security tool touched the trust settings. If it holds a high percentage for an hour while nothing else is happening, look at what changed in your trust settings, not at the daemon.
Can I quit or disable trustd?
There is no supported way, and no reason to want one. It is not in Login Items or any System Settings pane, because it is not a background item you control. Launchd started it, and on this Mac has started it four times in one boot cycle, recycling it under memory pressure and bringing it straight back, which is by design: its job configuration carries EnablePressuredExit, so the system is allowed to reclaim it when idle and relaunch it on the next knock. It may even vanish from Activity Monitor and return with a new PID minutes later for exactly that reason. Deleting its caches is the one genuinely bad idea here: they exist so your Mac does not have to recheck every certificate it has already seen.
Why are there several trustd processes on my Mac?
Because it runs one copy per audience. There is a single system daemon, owned by the reserved _trustd user, that all processes can ask. Then there is an agent copy, launched with the same binary and a single flag, one per login session, and macOS runs login sessions for service accounts too: on the Mac measured here, besides the copy for the logged in user, there are agents running as _locationd and _cmiodalassistants. If you develop iOS apps, each simulator runtime also ships its own trustd inside its RuntimeRoot, so three or four rows can appear in Activity Monitor. They are all Apple's binary doing Apple's work, and the search phrase user trustd is this exact situation described by someone who saw it.
Ready? Buy Ribbon for $15, or read all the guides.