Skip to main content
This page answers the questions a security review asks first.
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 raw User-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
With 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 — is IChannelIdentityRepository, 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 OpenIddict database is pruned by the auth server. A background job deletes token and authorization records that are no longer valid (expired or revoked) and were created more than Veriqa:OpenIddict:Server:TokenPruneThresholdSeconds ago (24 h by default), every TokenPruneIntervalSeconds (1 h), on every store provider. Valid records are never deleted. Until a record is pruned, its payload — including an avatar image for clients with avatar — stays in the database, so a lower threshold shortens how long that data is kept.

The audit trail is off until you ask for it, twice

Two independent switches, and both are needed:
  1. The satellite is opt-in — a host that never calls AddVeriqaAuditTrail has no trail at all.
  2. Veriqa:Logging:Mode ships as System, and records are written only in Audit. Disabled and System are the same thing to the sink: write nothing.
Retention, once records exist, is not a third switch: the sweep is registered automatically for either built-in sink and deletes anything older than 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. In Development 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.
Replacing a certificate is a session-invalidating operation. The configuration accepts exactly one signing and one encryption certificate, so JWKS carries a single signing key and old and new never overlap. Tokens signed with the previous key stop validating the moment you swap it. Plan key replacement as a maintenance event, not as a background rotation — the same warning appears in Preparing for production.
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.
It does not carry the IP address, the raw 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:BaseUrl what 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_ENDPOINT set, 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 the Debug 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.