Security · How the service is built

Built to be trusted with someone else's DNS.

Your users give Cnamio access to something they cannot afford to break. These are the rules the service is built on, and what happens to every credential and piece of data involved.

Existing DNS is never deleted

Cnamio only adds the records your application asks for. It has no operation that removes a record that was already in the zone, and the only existing record it can change is an SPF policy, which it extends without dropping anything.

  • The zone is read first. If a requested record would collide with something that exists, nothing is written: the API answers 409 with the conflicts, and the user decides what to do at their provider.
  • A CNAME is created only at a free name. A, AAAA and MX are never added next to different existing values. TXT and CAA values are added next to existing ones, except a second DMARC policy or a second DKIM key at the same selector.
  • A domain can publish only one SPF policy, so a requested one is merged into the existing policy: every existing term stays as it is, in its place, and only the missing mechanisms are added before all. The merge is refused if the result would pass 10 DNS lookups. The user gets the merged value to paste; the automatic edit is enabled per DNS provider.
  • Disconnecting is yours to do: stop serving the domain in your app and tell the user they may remove the records. Cnamio never deletes them.

The rules for each provider are on the providers page.

Provider credentials are used once

Cnamio never asks for the password of a DNS provider account. For automatic setup the user pastes an API token or access key, and that credential:

  • is used during that single request, to read the zone and create only the requested records;
  • is never written to disk, a database or a log;
  • is discarded when the request ends.

We show users how to create a credential with the smallest scope the provider allows, such as a Cloudflare token for one zone or an AWS policy that can only create records in one hosted zone, and they can delete it right after connecting. If you pass a provider token through your own backend, do not store or log it either.

Your secret stays on your server

  • Each application has an id (app_…) and a secret (cnm_sk_…). The secret is shown once and we keep only a one-way hash of it.
  • Browsers never see the secret. They receive a session token that lasts 60 minutes and can be bound to one user, one domain and one exact list of records, so a page cannot change the target of a connection.
  • POST /token and the management API never answer cross-origin browser requests.
  • A secret can be rotated at any time; the old one keeps working for a grace period (24 hours by default) so you can deploy the new one without downtime.

One user cannot claim another user's domain

When all of your users point their domains at the same CNAME target, a CNAME that already exists proves nothing about who started the connection. Cnamio lets you require a TXT record whose value is unique to each user, built on your server and bound to the session token. domain.added is sent only when every required record is live, so only someone who controls that domain's DNS can complete the connection. The server SDKs build these records with recordsForUser.

Verified at the source

A connection is confirmed by asking every authoritative nameserver of the domain, not a public resolver that may hold a cached answer. A domain is reported as connected only when all required records are live on all of them. Checks run for up to 72 hours; after that your backend receives domain.propagation.timeout instead of silence. Once a domain is connected, monitoring keeps asking the same nameservers on a slow schedule (hourly, then every 6 hours, then daily). It only reads DNS: it never creates, changes or removes a record.

Signed webhooks

  • Every delivery carries Cnamio-Signature, an HMAC-SHA256 of "{timestamp}.{raw body}" with a signing secret only your application can read, plus Cnamio-Timestamp and Cnamio-Event-Id.
  • Reject timestamps older than 5 minutes and treat the event id as an idempotency key: a delivery that is not answered with 2xx is retried after 1, 5 and 30 minutes.
  • Webhook URLs must be public HTTPS addresses. Private and internal addresses are refused and redirects are not followed.

The verification function is in the docs and in both server SDKs.

The connect window is isolated

The window runs in an iframe served from Cnamio's origin with its own Content-Security-Policy. Its configuration, session token included, reaches it only through postMessage and never in a URL. On the page that opens it you only need to allow https://connect.cnamio.com in script-src and frame-src.

Data and privacy

  • What a connection stores: the domain, the records you asked for, the DNS provider recognized from the nameservers, the result of each propagation check, timestamps and the user identifier you choose to send.
  • Errors and logs: errors are a fixed text and never echo request contents; operational logs hold fixed status codes, never request bodies or tokens.
  • Where: our servers and database run in Brazil. The full list of providers involved is in the privacy policy.
  • This site: no cookies and no third-party scripts, served with a strict Content-Security-Policy. Page views are counted by a script of our own that stores no IP address and records nothing under Do Not Track or Global Privacy Control; the privacy policy has the details.
  • Limits: by default 60 requests per minute per address and per session, under a ceiling of 600 per application.

Cnamio is a young service and does not hold a third-party security certification today. The Privacy Policy describes our role under Brazil's LGPD and the EU GDPR, retention and your rights; the Terms of Service cover the rest.

Report a security problem

Write to contato@cnamio.com with what you found and the steps to reproduce it. Please test only with domains and applications that are yours.