Audit log
Who did what, from where, with which key: search, export to S3/SIEM, alarms, hash chain, signed digests.
Every change made in your organization, every refused attempt to change something or to read secret material or source code, every read of secret material or source code, every SSH access by Deutsche Cloud staff to your managed machines, and every sign-in is recorded: who did it, with which credential, from where, what exactly they asked for, and how it was answered. Entries are hash-chained and the chain is signed every hour, so a changed or deleted entry is detectable — by us, and by you without us. You can send the log to your own S3 bucket, your SIEM (webhook or syslog) and your inbox (alarms).
Console: IAM → Audit log (/iam/audit-logs), and Integrity, retention, exports
(/iam/audit-logs/settings). API: /iam/api/audit-logs, /iam/api/audit-destinations. CLI:
dcloud iam audit-logs …, dcloud iam audit-destinations …. MCP: the same operations as tools.
What is recorded
| Event | Recorded |
|---|---|
| Any write that was allowed (create, change, delete, start, stop, grant …) | yes |
| A write, or a read of secret material or source code, that was refused by IAM | yes, outcome: failure |
An ordinary read (list, describe) refused over the API (a 403) |
yes, at most one entry a minute per principal and action; the next one says how many were left out (suppressed) |
| A button the console hid because you may not use it | no — nobody tried anything |
| A Deutsche Cloud operator opening SSH to one of your managed machines | yes, operator:IssueSshCertificate, with who, which machine and why |
Reads of secret material or source code (sensitive actions, e.g. a secret's value, a repository archive, database rows) |
yes, allowed or refused |
| Ordinary reads that were allowed (lists, describes) | no — volume without information |
| Machine heartbeats that were allowed (agents reporting in) | no; a refused one is recorded |
| Sign-in, sign-in failure (with the reason), sign-out | yes, auth:SignIn / auth:SignOut |
| Second factor on/off, passkey added/removed, recovery codes renewed or used | yes, auth:* |
| Password changed or reset, sessions revoked, profile changed, email verified | yes, auth:* |
| Joining the organization (invitation or first SSO sign-in), registering it | yes, auth:JoinOrganization, auth:CreateOrganization |
| CLI sign-in approved (device code), app connected or disconnected (OAuth/MCP) | yes, auth:ApproveDeviceLogin, auth:AuthorizeApp, auth:RevokeApp |
| Token exchange for a role (workload identity, Kubernetes pod identity) | yes, every attempt |
Sign-in events of a person go to every organization they are an active member of; events about one organization (joining it, connecting an app to it) go to that organization only.
Whether an action is a write is declared next to the permission (access in the service's IAM
descriptor), never guessed from its name. pnpm iam:check fails the build when a console API
service does not run the audit middleware, so a new service cannot ship unaudited.
What an entry says
The field names follow AWS CloudTrail where the meaning is the same.
| Field | Meaning |
|---|---|
createdAt (eventTime) |
when the decision was made, to the millisecond |
action (eventName) |
the IAM action (ec2:StopInstances) or event (auth:SignIn) |
outcome |
success — Succeeded: allowed, and the request was answered below 400. error — Failed: allowed, but the request failed (answered 400 or above, e.g. a 409 or a tampered ciphertext). failure — Denied: refused by IAM or by authentication (wrong password, wrong code, revoked key). Entries written before 2026-11-17 have no error: an allowed entry with a responseStatus of 400 or above reads as Failed, in the console, the filters and outcomeLabel |
outcomeLabel |
the word for outcome: Succeeded, Failed or Denied (not part of the hash) |
callerType |
session (console), access_key, oauth (a connected app, e.g. an MCP client), anonymous (a token exchange), system |
principal |
who, frozen at the time: user/alice@acme.com, iam-user/ci-deployer, role/deployer/github-run-42 |
userId, iamUserId |
the person and the IAM principal the policies were evaluated for |
accessKeyId |
the public id of the access key that signed the request (EWS1…, or the S3 key id). Never the secret |
sessionContext |
how the principal came to hold its rights: authMethod (password, password+totp, password+passkey, sso, …), mfa, assumedRole, roleSessionName, webIdentity (issuer and subject of the OIDC token a role was assumed with), oauthApp |
ipAddress, userAgent |
where from. The address is the one our ingress saw, not a header the client sent |
requestId, httpMethod, requestPath |
the request. X-Request-Id in every API response is the same id |
region |
the region of the resource, empty for regionless services |
resourceType, resourceId, resourceRn |
what it applied to. For a create, the type, id and RN are the new resource's (iam:group, not iam:*), taken from the response |
requestParams.resourceName |
the resource's name at the time of the event (users, groups, roles, policies, access keys, keys, key pairs, secrets), so a deleted resource can still be identified |
requestParams |
what was asked: a summary of the request body plus the facts the service adds (a setting's new value). See Secrets below |
responseStatus, responseElements |
the HTTP status, and the identifying fields of the answer (id, name, …Id) |
seq, prevHash, hash |
the entry's place in the hash chain (see Integrity) |
Secrets never enter the log
Request bodies are summarized, not copied. Keys are kept; numbers and booleans are kept; a string is
kept only when it is at most 64 characters, its key does not name a secret (password, secret,
token, privateKey, value, env, userData, script, content, …) and the value itself does
not look like one (a JWT, a PEM block, a known token prefix, a URL with a password, or 20+
high-entropy characters; an e-mail address is kept — who was invited or removed is the point of an
access-provisioning record). Everything else becomes "[redacted]" or "[N chars]", and a summary
is capped at 2 KB. From responses only identifying fields are kept, so a freshly created access
key's secret half never reaches the log.
Search and filter
The console page filters by action, outcome and actor with counts, searches resource, action, actor, IP, access key and request id, and opens any entry with every field above. The API takes:
dcloud iam audit-logs list --action 'iam:*,auth:SignIn' --outcome failure \
--from 2026-11-01T00:00:00Z --to 2026-11-12T00:00:00Z --limit 100
dcloud iam audit-logs list --principal user/alice@acme.com
dcloud iam audit-logs list --access-key-id EWS1ABCDEFGHJKLMNPQR
dcloud iam audit-logs list --ip 203.0.113.7 --order asc
dcloud iam audit-logs get 3f0c2b9e-8d1a-4c57-9b2e-1f6a7d8e9c0baction takes comma-separated globs; from is inclusive and to exclusive (ISO-8601);
principal, accessKeyId, ip, resourceId, requestId and callerType match exactly; search
matches parts of any of them. The answer carries total.
Export: GET /iam/api/audit-logs/export?format=csv|jsonl with the same filters streams every
matching entry, oldest first (up to 1,000,000 per download). The console's Export CSV / JSON
buttons use it with the filters on screen. CSV cells that would start a spreadsheet formula are
quoted inert.
Integrity
The hash chain
Each organization's entries form a chain. Entry n stores seq = n, prevHash (the hash of entry
n − 1; 64 zeros for the first) and
hash = hex(SHA-256( prevHash + "\n" + canonical(entry) ))where canonical(entry) is this JSON array, in this order, with null for an absent value:
[1, id, orgId, seq, createdAt, action, outcome, userId, callerType, iamUserId, principal,
accessKeyId, sessionContext, resourceType, resourceId, resourceRn, ipAddress, userAgent,
requestId, httpMethod, requestPath, region, requestParams, responseStatus, responseElements]createdAt is ISO-8601 UTC with milliseconds (2026-11-12T07:14:16.123Z). sessionContext,
requestParams and responseElements are hashed as the stored strings, which are JSON with keys
sorted at every level; in an exported record they appear parsed, so serialize them back with sorted
keys and no whitespace. Entries are appended in one transaction with the organization's chain head
locked, so seq has no gaps and entries commit in seq order.
Changing an entry breaks its hash; inserting, deleting or reordering one breaks the next entry's
prevHash or leaves a gap in seq; cutting off the newest entries leaves the chain head pointing
past the end.
Signed digests
At minute 5 of every hour (UTC) the head of each organization's chain (its seq and hash) is
signed with Ed25519, when entries were added since the last digest. An entry therefore waits at most
an hour for its signature; a quiet hour adds no digest, so the newest digest can be older than an
hour without anything being unsigned. Verify now and the settings page say which entries are not
signed yet (unsigned: count, fromSeq, toSeq, oldestAt, nextSigningAt).
Each digest also names the signature of the one before, so digests form a chain of their own. The
signed bytes are these lines joined with \n:
ews-audit-digest-v1
<orgId>
<fromSeq>
<seq>
<hash>
<signedAt, ISO-8601>
<previous signature, or ->
<keyId>The public key is shown on the settings page and returned by
GET /iam/api/audit-logs/digests (with the 200 newest digests, each with its signedPayload).
keyId is the first 16 hex characters of the SHA-256 of the key's DER (SPKI) form. Digests are also
written to every S3 export (see below) — a copy in your own bucket is what a rewrite of our
database cannot reach.
Verifying
Verify now on the settings page, dcloud iam audit-logs verify, or
GET /iam/api/audit-logs/verify recompute the chain from the oldest entry still kept, check every
digest's signature and that the entry it names has the hash it signed, and check the head:
{ "ok": true, "checkedRows": 18234, "firstSeq": 1, "lastSeq": 18234, "complete": true,
"startsAtGenesis": true, "chainBreak": null, "head": { "seq": 18234, "matches": true },
"digests": { "checked": 41, "failed": [], "latest": { "seq": 18190, "keyId": "…" } } }chainBreak names the first entry that does not hold and why (hash-mismatch,
prev-hash-mismatch, seq-gap, redaction-invalid). Entries written before the chain existed
(12 November 2026) carry no hash and are reported as legacyRows; entries redacted after they were
written (below) are counted in redactedRows.
Redacted entries
Between 12 and 18 November 2026 a kms:Encrypt request's plaintext could be kept in the entry's
request parameters (see the security advisory of 18 November 2026). Such values are removed from
entries already written without breaking the chain: the entry keeps its hash (so the next entry's
prevHash and every digest, including the copies in your bucket, still match), its request
parameters read "[redacted]" where the value was, and it carries a signed redaction record, in
exports as integrity.redaction:
{ "v": 1, "rowHash": "<the entry's hash>", "originalRequestParamsSha256": "<hex>",
"redactedRowSha256": "<hex>", "reason": "…", "redactedAt": "2026-11-…Z", "keyId": "…",
"signature": "<base64 Ed25519>" }redactedRowSha256 is the SHA-256 of the entry's canonical form (as in The hash chain) as it
reads after the redaction, so every other field of the entry stays bound. The signature is made with
the digest key over these lines joined with \n:
ews-audit-redaction-v1
<orgId>
<entry id>
<seq>
<rowHash>
<originalRequestParamsSha256>
<redactedRowSha256>
<redactedAt>
<reason>
<keyId>A verifier accepts a redacted entry when its hash equals rowHash, the SHA-256 of its canonical
form equals redactedRowSha256, and the signature holds; it does not recompute that one entry's
hash. If you kept an export from before the redaction, the SHA-256 of the entry's old
requestParams string equals originalRequestParamsSha256, and recomputing the hash from it gives
rowHash.
To verify without us, take an S3 export: recompute each record's hash from its integrity.prevHash
and its fields as above (for a record with integrity.redaction, check the redaction record
instead, see Redacted entries), check that each record's prevHash is the previous record's
hash, and check the digest files' signatures against the published key:
import { createHash, createPublicKey, verify } from 'node:crypto';
const ok = verify(null, Buffer.from(digest.signedPayload), createPublicKey(publicKeyPem),
Buffer.from(digest.signature, 'base64'));What this does not prove: anything about entries before the oldest one still kept (retention moves the start forward), and a rewrite of the whole chain and its head made before the first digest you hold. Keep an S3 export for the strongest guarantee.
Retention
Entries are kept 400 days by default (what GCP keeps admin activity for). Set 90 to 3650 days
on the settings page or with dcloud iam audit-logs update-settings --days 730
(iam:UpdateAuditLogSettings, audited with the old and new value). A daily sweep deletes older
entries — but never an entry past the newest signed digest, so nothing is deleted that no signature
vouches for. For longer archives, export to S3.
Exports and alarms (destinations)
A destination receives every new entry that matches its filter, in seq order, at least once (a
retry after a failure can repeat a batch; deduplicate on eventId). Filters: filterActions
(globs, empty = every action) and filterOutcome (success, failure or both). A new destination
starts at the present; Replay all (--resume-from start) sends every entry still stored, and
--resume-from now skips a backlog. Pause and resume keep the position. Delivery runs every
minute; a failing destination is retried with back-off (1, 2, 4 … 60 minutes) and shows its last
error. Send test delivers one synthetic iam:TestAuditDestination event at once.
| Kind | What arrives |
|---|---|
s3 |
gzip'd JSON lines, one object per batch of up to 5000 entries, at <prefix>EWSAudit/<orgId>/<yyyy>/<mm>/<dd>/events/<orgId>_audit_<fromSeq>-<toSeq>_<time>.jsonl.gz, and every hourly digest at …/digests/<orgId>_digest_<seq>.json |
webhook |
POST of { "type": "ews.audit.events", "version": "1", "destinationId", "events": [ … ] }, up to 500 entries, signed |
syslog |
RFC 5424 messages over TLS (RFC 5425 octet-counting framing), facility 13 (log audit), severity 6 (allowed) or 4 (refused), MSGID = the action, structured data [ews@32473 orgId seq eventId], the JSON record as the message |
email |
an alarm: one mail per batch of matching entries (up to 500), listing up to 25 with time, action, principal, resource and IP |
Every record has the shape { eventVersion, eventId, eventTime, orgId, seq, eventSource, eventName, outcome, userIdentity { type, principal, userId, iamUserId, accessKeyId, sessionContext }, sourceIPAddress, userAgent, requestId, httpMethod, requestPath, region, resource { type, id, rn }, requestParameters, responseStatus, responseElements, integrity { prevHash, hash } }.
S3: any S3-compatible https endpoint on port 443 — by default this platform's object storage.
Give a key that may only PutObject into the bucket (an IAM user with a policy allowing
s3:PutObject on rn:ews::<org>:s3:bucket/<bucket>/*). The secret key is stored encrypted and
never returned.
Webhook signature: X-DCLOUD-Signature: t=<unix seconds>,v1=<hex HMAC-SHA256(secret, "<t>.<raw body>")>
(also sent as X-EWS-Signature, its name before the rename).
The secret (whsec_…) is shown once, when the destination is created. Reject a t older than five
minutes.
Syslog: a public host name or address, TLS on the port given (6514 by default), verified against public CAs, or against the CA certificate (PEM) you give for a private one.
Every endpoint must resolve to public addresses only; the connection is pinned to the address that was checked and redirects are not followed.
dcloud iam audit-destinations create --kind email --name 'IAM changes' \
--filter-actions 'iam:Create*' --filter-actions 'iam:Delete*' --filter-actions 'iam:Attach*' \
--config '{"addresses":["security@acme.com"]}'
dcloud iam audit-destinations create --kind email --name 'Denied' --filter-outcome failure \
--config '{"addresses":["oncall@acme.com"]}'
dcloud iam audit-destinations create --kind s3 --name archive \
--config '{"bucket":"acme-audit","prefix":"ews/","accessKeyId":"…"}' --secret-access-key "$KEY"
dcloud iam audit-destinations create --kind webhook --name splunk --config '{"url":"https://hec.acme.com/ews"}'
dcloud iam audit-destinations create --kind syslog --name graylog --config '{"host":"logs.acme.com","port":6514}'
dcloud iam audit-destinations test <id>
dcloud iam audit-destinations update <id> --resume-from startUseful alarms: auth:SignIn with failure (password guessing), auth:DisableTwoFactor,
auth:UseRecoveryCode, iam:* (any permission change), iam:CreateAccessKey,
*:Delete*, failure on everything (a denied request is someone trying something they may not).
Permissions
| Action | Allows |
|---|---|
iam:GetAuditLogs |
read, search, export and verify the log; read digests and the retention |
iam:UpdateAuditLogSettings |
change retention (on rn:ews::<org>:iam:organization/<org>) |
iam:ListAuditDestinations |
list exports and alarms and their delivery state |
iam:CreateAuditDestination |
add one |
iam:UpdateAuditDestination |
rename, pause, resume, refilter, replay (rn:ews::<org>:iam:audit-destination/<id>) |
iam:DeleteAuditDestination |
remove one |
iam:TestAuditDestination |
send a test event |
IAMReadOnlyAccess and ReadOnlyAccess include the reads; IAMFullAccess and
AdministratorAccess include everything.
Compared with AWS CloudTrail and GCP Cloud Audit Logs
| Capability | Deutsche Cloud | CloudTrail | GCP |
|---|---|---|---|
| Writes / admin activity | always on | management events, always on | Admin Activity, always on |
| Sensitive reads | always on (secrets, source, database rows, S3 GETs) | data events, extra cost, opt in | Data Access, opt in |
| Denials | every one | as errorCode |
as status |
| Sign-ins | console, SSO, CLI device, connected apps | console sign-in events | in Workspace / Cloud Identity logs |
| Identity detail | principal, key, MFA, assumed role, web identity, app | userIdentity, sessionContext | authenticationInfo, serviceAccountDelegationInfo |
| Request / response | redacted summary, status, created id | requestParameters, responseElements | request, response (some services) |
| Tamper evidence | per-entry hash chain + hourly Ed25519 digests | hourly signed digest files (opt in) | none built in |
| Retention | 400 days default, 90–3650 | 90 days event history; trails to S3 | 400 days admin, 30 days data access |
| Search in the console | every field, whole history | 90 days, a few attributes | Logs Explorer |
| Export | S3, webhook, syslog/TLS; JSON lines, CSV | S3, CloudWatch Logs, EventBridge | sinks to GCS, BigQuery, Pub/Sub |
| Alarms | filtered destinations by email or webhook | EventBridge rules, CloudWatch alarms | log-based alerts |
Limits
- 20 destinations per organization; a webhook batch is at most 500 entries, an S3 object 5000.
verifywalks up to 200,000 entries per call by default (--max-rows, up to 2,000,000) and sayscomplete: falsewhen it stopped early.- A console or API request answers only after its entries are committed (usually one database
write later). Entries are never dropped: if the database cannot take them, they wait, in order,
and are retried until they are written. If that takes longer than 10 seconds, the request still
gets its real answer with the header
X-EWS-Audit: pending, and its entries follow. - While the audit log has been unwritable for more than 10 seconds, Deutsche Cloud refuses every change and
every sensitive read with
503andRetry-After: 10before doing it, so nothing happens that could not be recorded. - An entry the database rejects as malformed (a bug, not an outage) is written in full to Deutsche Cloud's service log instead and counted; the entries around it are written normally.
- A process stopped mid-request (a deploy) can still lose the entries of requests it had not yet answered; their clients see a broken connection, not a success.