This is a factual description of the software, not legal advice and not a compliance
certification. Which of these facts matter under your regulator, and what you have to do about
them, is a decision for you and your counsel.
Who holds what
Veriqa is delivered as code you run. In the self-hosted model that is the whole answer to “where does the data go”:- You are the controller. The database, the key material and the logs are on your infrastructure, under your connection strings. Nothing is provisioned for you.
- Veriqa (the vendor) is neither controller nor processor of your users’ data. No user data reaches the Veriqa vendor: the product does not phone home, ships no telemetry and has no vendor endpoint of any kind. Apart from your own data stores, the code connects only to what you configure: messaging app APIs, SMTP and IMAP servers, account providers, HTTP channel adapters, the RabbitMQ bus and an OTLP collector (see What leaves your perimeter).
- The messaging app providers are your counterparties, not the Veriqa vendor’s. Telegram, the WhatsApp Cloud API and every other channel you enable see the messages you send through your own bot credentials. Your relationship with each of them is direct.
Personal data inventory
Everything the shipped product touches, and nothing beyond it.
Avatar. The Telegram adapter downloads the avatar when the tokens are issued, and only for a
client that requests the
avatar scope: without that scope, Veriqa does not ask Telegram for the
photo. The file is at most AvatarDataUri.MaxImageBytes (64 KiB): the image is kept in the payload
of every token that carries the picture claim, and the limit bounds the size of those records. A
larger photo is not delivered. Token issuance waits at most 5 seconds for the avatar. The core drops
a malformed or oversized value from any adapter. In each of these cases, the sign-in goes on without
an avatar.
Not in the list: message bodies from the channel (a channel adapter reads what it
needs to identify the sender and confirm, and keeps nothing else) and any
long-lived profile of the user beyond the collected claims above. The product ships no user
directory — see
Channel identities.
Collection defaults
This is how the product ships. Collection starts without any action from you, and stopping it takes one. The exceptions are off until you turn them on: the rawUser-Agent of the initiator, hop mode
itself, and the fingerprint, country and raw User-Agent of the scanning phone. Hop mode has an
exception of its own, described under the table.
Hop mode itself ships off.
Veriqa:HopMode:Enabled turns it on for the node,
Veriqa:Channels:{Channel}:HopEnabled for one channel, and the same members of a client entry or a
tenant record for one application or tenant. See Veriqa:HopMode.
A channel that starts by a code alone (CodeStart.LinkCarriesTransaction = false) is the exception:
its QR code carries a hop link even with hop mode off, under the conditions given in
Start by a code. The HopMode rows apply wherever a hop link is opened,
so with such a channel enabled, the IP and the parsed User-Agent of the scanning phone are
collected by default.
Two qualifications that matter more than the flags:
Geolocation is on by default but inert by default. The lookup needs the satellite package
Veriqa.Core.AuthServer.MaxMind and a local .mmdb database, and the base packages carry
neither. Without them the provider reports itself unavailable and the geo fields stay empty — so a
stock installation collects no location, even though the flag says true. Adding the database is
what starts the collection. The standalone image already carries the package: there, collection
starts once you mount the database and point Veriqa:InitiatorContext:GeoIp:DatabasePath at it.
The IP must also be trusted: while forwarded headers are accepted from
any source (no KnownProxies / KnownIPNetworks configured), the lookup is skipped.
The IP is collected but never shown and never logged. It goes into the snapshot inside the
transaction and stops there. The confirmation message does not carry it (what the message does carry
is listed under What leaves your perimeter), and the diagnostic log for
an untrusted forwarding configuration records a result code rather than the address.
Turning off the initiator context is one section:
appsettings.json
Enabled: false no snapshot is built, and the confirmation message simply carries no context
line. You can also keep the context and narrow it — drop region from DisplayFields, or set
CollectIpAddress: false (which also removes geolocation, since the lookup has no input). Details
and the per-application narrowing are in Initiator context.
The context of the scanning phone has a switch of its own: Veriqa:HopMode:CollectScannerContext: false
stops its collection while hop mode stays on.
Where it is stored
Channel identities: nothing is stored by default
The port that would persist a channel identity — channel user id, phone, email, display name, as an upsert with neither TTL nor deletion — isIChannelIdentityRepository, and Veriqa ships no
implementation of it and registers none. Sign-in works without one: the resolved identity travels
with the transaction and is gone with it. Keeping that data indefinitely is an act you perform
deliberately, by registering an implementation of your own; see
Storage.
Retention
In short: the transaction store empties itself within about fifteen minutes of a
sign-in, and the audit trail is the only Veriqa store that keeps anything for days. Everything with
an indefinite lifetime is something you added — a channel identity repository, the collected claims
store, or tokens with a lifetime you chose.
The audit trail is off until you ask for it, twice
Two independent switches, and both are needed:- The satellite is opt-in — a host that never calls
AddVeriqaAuditTrailhas no trail at all. Veriqa:Logging:Modeships asSystem, and records are written only inAudit.DisabledandSystemare the same thing to the sink: write nothing.
RetentionDays. ConfigureRetention only
tunes how often the sweep runs and how large its batches are — it does not turn retention on, and
skipping the call does not leave records unbounded. A retention of zero or less is refused at
startup rather than read as “keep nothing”.
The one case where nothing sweeps: a custom sink you registered with UseSink<TSink>(). Records
then live in your store, the built-in sweep is not registered, and the host says so at startup.
Bounding that store is up to you.
appsettings.json
What an audit record actually contains
A closed set of attributes, fixed in the schema — one column per attribute, no free-form payload: the timestamp, the actor, the action code, the target (the transaction id), the outcome and its reason code, plus the transaction type, channel type, correlation id, tenant,client_id, UI locale
and time zone, the channel’s own safe details and its declared inbound verification level.
The actor is masked. For an action the user performed in a channel it is
{channel}:{masked id} — at most the last two characters of the channel user id stay readable. The
unmasked value never leaves the transaction store.
No IP, no User-Agent, no geolocation, no display name, no email reaches an audit record. The
initiator context lives in the transaction and dies with it.
The single exception you can switch on is the parameters of the confirmed operation — the declared
action kind and its slot values. Those are your application’s domain data and may be anything, so
they are off by default and copied into the record only when you ask
(Preparing for production).
Encryption
There is no application-level encryption of stored personal data beyond that one protected field,
and no key management of its own. If your threat model requires personal data encrypted at rest,
that requirement is met at the storage layer you operate — encrypted volumes, TDE, an encrypted
connection to the database — not by a setting in Veriqa.
Secrets —
client_secret, bot tokens, SMTP credentials — belong in environment variables or a
secret store, never in config files in the repository. Passwords are never written to a log: where
one has to be compared, the comparison is over a SHA-256 hash.
Keys
Three kinds of key material, three different homes. Token signing and encryption certificates. InDevelopment the product uses OpenIddict’s
development certificates. Outside Development it loads X.509 certificates you supply, by path or
base64 (Veriqa:OpenIddict:Server:SigningCertificate* / EncryptionCertificate*), and refuses to
start without them.
The DataProtection key ring. The same keys protect the relying-party expectations, the sign-in
cookie, hop links and the other values listed in Where it is stored, so anyone
who holds the ring can decrypt the expectations and forge those values. Protect it like the signing
certificate. In the Veriqa host Redis takes priority (Veriqa:DataProtection:RedisConnectionString),
then a directory (Veriqa:DataProtection:KeysDirectory). With neither set, ASP.NET Core keeps the
keys in its default location for the account the host runs under — in the container image,
/home/app/.aspnet/DataProtection-Keys inside the container — and they are lost when the container is
recreated, for example on an image update. After that, cookies, hop links and the protected
expectations of live transactions can no longer be read. The keys are stored unencrypted unless you
set Veriqa:DataProtection:Certificate* to encrypt them with a certificate; either way, limit access
to the Redis instance or the directory that holds them. When Veriqa runs inside your own ASP.NET Core
application, it uses your application’s key ring and does not read the Veriqa:DataProtection:*
keys; encrypting the keys at rest (ProtectKeysWith*) is then part of your application’s setup.
Data Protection rotates its own keys, and
values written under an earlier key stay readable while that key is still in the ring, so a ring on
durable storage makes rotation a non-event.
Channel and application secrets — bot tokens, client_secret, SMTP credentials. Rotating them
is a channel-side and client-side operation. A new Telegram or MAX bot token takes effect only
after Veriqa restarts: these channels build their bot client from the token once and keep it for
the lifetime of the process, and the WeChat channel does the same with AppId and AppSecret.
Until then the channel calls the API with the old credentials: after you revoke a leaked token, the
channel stops working until you restart Veriqa. The Viber channel reads its token on every call, and
the Email channel reads its SMTP credentials for every email, so a new Viber token and new SMTP
credentials take effect after a configuration reload, with no restart.
What leaves your perimeter
Only what you configure. Per confirmation, the outbound message of a channel carries:- the name of the application that started the sign-in;
- the browser, OS and region of the initiator, where those are known and displayed;
- a link or buttons to confirm; a sign-in message in a chat also names the time of the request, and an email names the time its link or code expires;
- for an operation confirmation, the text of the question with the slot values your application passed, such as an amount or a recipient. The outcome receipt carries them only if you add those slots to its wording: the shipped receipt texts have none.
User-Agent, the user’s own profile data, or the email
and phone number your application expects from the user. Slot values leave your perimeter in the
message text, so fill them only with what you are ready to share with the messaging app provider.
Where it goes depends on the channel: api.telegram.org for Telegram, platform-api2.max.ru for
MAX, graph.facebook.com for the WhatsApp Cloud API and Messenger, api.twilio.com for WhatsApp
through Twilio, graph.instagram.com for Instagram, api.weixin.qq.com for WeChat,
chatapi.viber.com for Viber, and your own SMTP server for Email. In the
other direction, each channel returns the sender’s profile — the fields in the inventory table
above. The messaging app sees the message content and the recipient because that is what delivering a
message means; the Email channel sees whatever your SMTP relay sees.
The external event bus. If you wire the RabbitMQ publisher, transaction events leave the process
carrying the safe attribution only, including the masked channel identity. The parameters of a
confirmed operation are explicitly excluded from serialization and never reach the bus, whatever the
audit configuration says.
Other outbound connections. Each one exists only if you configure it:
- Email over IMAP — the service reads the mailbox on your mail server and, with OAuth sign-in, also calls the token endpoint you name.
- Sign-in with a provider account — the adapter exchanges the code and asks the provider (Google, Apple and others) for the user’s details. The provider sees who is signing in.
- HTTP channel adapter — Veriqa sends to
Http:BaseUrlwhat it would send to a channel: the text of the question, the button captions and the request context. Your adapter handles the data from there. - OTLP collector — with
OTEL_EXPORTER_OTLP_ENDPOINTset, metrics, traces and logs go there, including the text of log entries with their masked identifiers.
Logs
Application logs are not an audit trail and are not designed to be evidence. What matters for this page is what they must never contain, and what the code does about it: above theDebug level,
identifiers are written as a 16-character hex fingerprint (the first 8 bytes of an unsalted
SHA-256) rather than as themselves, so an operator can still stitch the steps of one sign-in
together. The fingerprint is a pseudonym, not anonymization: for a short identifier, such as a
numeric user id or a phone number, anyone who reads the log can recover the value by brute force.
A few Information and Warning entries carry a partial mask instead: an email address keeps its
first character and its domain (u***@example.com), a sub keeps its last two characters.
Treat logs at Information and above as personal data. At Debug and below, identifiers may be
written as they are. Tokens, secrets and the initiator’s IP are not logged at all.
That is the shipped behavior of Veriqa’s own log statements. Your host, your reverse proxy and your
platform’s request logging are outside it — an access log in front of the auth server records client
IPs by default, and bounding that is part of the same deployment step that configures
ForwardedHeaders:KnownProxies.
A hop link carries its token in the path, and ASP.NET Core adds the request path to log entries through
the RequestPath scope and writes it in Request starting entries. The shipped host settings therefore
set the Microsoft.AspNetCore.Hosting.Diagnostics category to None, in the global rule and in the rules
for the EventLog and EventSource providers, which removes both; TraceId still ties together the entries
of one request. Only the Development environment keeps the category at Information.
Hop link tokens return to every log output if you raise this level or add a rule for one provider that
enables the category, such as Logging:Console:LogLevel:Default.
In embedded mode, set the same levels in your host. TraceId remains only if the host has tracing on.
Without tracing, the entries of one request have no shared identifier, and the correlation id of sign-in
audit records stays empty.
What is left for you to decide
Nothing on this list has a right answer the product can pick for you.- Whether to keep the initiator context at all, and whether to add a GeoIP database.
- Whether to keep the context of the phone that scans a hop QR code (
Veriqa:HopMode:Collect*): its IP, browser, OS and device type are collected by default, like the initiator’s. - Whether to enable the audit trail, at what retention, and whether records should carry the parameters of confirmed operations.
- Whether to persist channel identities — and, if so, how they get deleted.
- Whether to turn on the collected claims store, and with what retention.
- How long expired and revoked token records stay in the OpenIddict database before pruning.
- Where the DataProtection key ring lives.
- Encryption at rest, backups and their retention, at the storage layer.
- How a deletion request from a user is executed across your stores. Veriqa deletes its transaction
rows on its own schedule and its audit rows on retention; the collected claims store you reach by
sub(endpoint or host call); anything you added is yours to reach.
Next steps
Preparing for production
The checklist to run before going live.
Storage
Which store holds what, and how to wire each one.
Known limitations
What the product does not do.