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-1f6a7d8e9c0b

action 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 start

Useful 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.
  • verify walks up to 200,000 entries per call by default (--max-rows, up to 2,000,000) and says complete: false when 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 503 and Retry-After: 10 before 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.
Did this page help you?