Security
Model
Ada's extension contains no credentials and no backend address. Each organization connects its own backend and keeps its AI provider credentials in its own secret store; with Ada as a managed service, the publisher runs that backend and its Key Vault for the organization, in a resource group of their own. The browser never receives, stores, displays or logs an AI credential. On a backend that takes its key from Ada (one run for the organization, backend 0.62.0), an administrator types the key once: the browser sends it to the backend and keeps no copy.
| Boundary | Control |
|---|---|
| Extension → organization configuration | Non-secret document in Azure DevOps extension data. Strict schema with unknown fields rejected; URL, HTTPS and trusted-hostname checks on every load; change history. Storage cannot restrict writers (see ADMIN-CONFIGURATION.md), so every user confirms the backend hostname before first use and after every change. |
| Extension → backend | HTTPS. Metadata check without following redirects. Without a separate sign-in (AUTH_MODE=azure-devops), the user's Azure DevOps access token once per session, checked with Azure DevOps and discarded; with AUTH_MODE=entra, an Entra ID sign-in run by the backend. The session token is kept in the browser tab's sessionStorage until it expires (never localStorage or cookies), and discarded when the backend rejects it. Authorization and x-azdo-organization headers; no cookies (credentials: omit). |
| Extension → publisher's license service (Set up a backend) | HTTPS, accepted only from the extension's origin (CORS). Ada's app token, signed with the extension's key; the organization's ID and name; the user's Azure DevOps access token, used once to ask Azure DevOps (connectionData) whether the user belongs to that organization under that ID, then discarded, never stored or logged. Pull-only registry access per organization; a revoked organization is never re-enabled there; at most one new password per organization every 10 minutes, and the previous one keeps working once. |
| Extension → publisher's license service (Ideas for Ada) | HTTPS, accepted only from the extension's origin (CORS), with Ada's app token in each request; nothing else proves who asks, and the organization named with a new idea is not checked and grants nothing. People are stored only as pseudonyms (SHA-256 of the identity ID), and a request returns only approved ideas, counts, and the caller's own ideas, heart and concern: never another person's comment or organization. Limits: one line of 8 to 140 characters, 5 new ideas a person a day and 10 waiting at once, concerns of 10 to 1,000 characters. The list is one blob written only with conditional requests (its ETag), so concurrent changes are repeated, never lost; its storage account takes no shared keys, only the service's managed identity and Valor's Entra sign-in, and keeps each previous version for 30 days. Valor reviews every idea before others see it. |
| Backend authentication | Session token (HS256, SESSION_SIGNING_KEY): signature, issuer, audience (this API only), expiry and required claims. Azure DevOps token check: Azure DevOps itself confirms the user in the requested organization (connectionData); unauthenticated, anonymous and inactive identities are refused. At an Entra ID sign-in: ID token RS256 signature against the published keys, issuer, audience (the app's client ID), expiry, nonce, PKCE. |
| Backend authorization | Allowed Azure DevOps organizations (membership verified with Azure DevOps when the session starts, and the header must match the session); with an Entra ID sign-in also allowed tenants and optional allowed users, groups or app role; enabled operations. A valid token alone is not enough. CORS is not used as authentication. |
| Organization isolation | Usage counters, rate limits, concurrency, audit records and sign-in state are keyed by organization. The admin usage endpoint returns one organization at a time. |
| Backend → secrets | Reference deployment: Key Vault (RBAC) references resolved by the App Service managed identity (Key Vault Secrets User, read-only). No Key Vault SDK; no secrets in IaC, pipelines or outputs. |
| Backend → AI provider | HTTPS in production. The key is injected from validated configuration. Timeout and bounded retries. Upstream bodies are never logged or returned. |
| Extension → Azure DevOps | User identity and documented scopes (PERMISSIONS.md). No PAT. Writes only after explicit confirmation. |
| Service hook → backend | Shared secret in the x-ada-hook-secret header (compared in constant time, stored in Key Vault). Organization taken from the payload and checked against ALLOWED_ORGANIZATIONS. Completion is verified by reading the pull request again, never from the payload. Deliveries are deduplicated by event ID. |
| Backend → Azure DevOps (pull-request checks) | The App Service managed identity, with read access to the enabled repositories and Wikis and permission to comment on pull requests. It never writes Wiki pages or work items. |
| Backend → Azure DevOps (Code with Ada) | The same identity, on administrator-enabled repositories only: Read, Contribute, Create branch and Contribute to pull requests, plus View builds and Queue builds on the pipelines that validate pull requests. Only organization administrators and the teams they allow reach any of its routes, and a run starts only on repositories the requester can contribute to themselves (Git Repositories Contribute, from the repository's permissions and the requester's groups). Nothing is pushed before a person approves the plan, and only to branches under ada/code/, from the head it read; a target branch is never pushed to, and a pull request is never completed. What Ada writes runs in your pipelines before anyone reviews it, which is what validation pipelines do with any developer's branch. Its limits, enforced in code and not by the prompt: secrets files can't be read or changed; other secrets reach the model masked, and an edit is applied by exact quote only where the quote stands in the masked text too, so masked values can't be overwritten, read back or confirmed by guessing; text that looks like a secret isn't written; pipelines, agents' instructions and protected paths change only if the approved plan or the person names them, and the approval says so; .git and .ada never; commit messages can't skip pipelines. Files, documents, work items, review comments and logs are untrusted input to the model: it has no web access and no other way out than the pull request, which a person reviews and which says what changed outside the plan and which tests got weaker. |
| Backend → Azure DevOps (Repository Documentation) | The same identity, on administrator-enabled repositories only (checked again when a job is created and estimated): Read, Contribute, Create branch and Contribute to pull requests. Pushes go only to branches under ada/docs/ and ada/dev-docs/, each from the branch head it read (a moved branch is refused, never overwritten); pull requests target the default branch, so its branch policies and the administrators' required reviewers apply, or for dev documents the dev branch, where administrators may choose no reviewers: those pull requests then complete by themselves once the dev branch's policies pass. Updates after merges and scheduled dev documents have no person behind them, so their checks read every enabled repository: enable only repositories that everyone who uses Ada may read. The service hook is authenticated by PR_DOCS_HOOK_SECRET, and what it says is confirmed by reading the pull request. Code is masked for secrets before it reaches the AI model, and every code quote the documentation keeps is checked against the file. Only administrators change the settings. A job starts only for repositories the requester can read themselves (Git Repositories Read, from the repository's permissions and the requester's groups), and its checks of findings against connected services read only enabled repositories the requester can read. Runs are visible to everyone with the Code tab; only who started one or an administrator can stop, discard or retry it or download its files. |
| Extension → backend (Ada's agent) | Each message brings the person's Azure DevOps access token in the request body, as the sign-in does. The backend asks Azure DevOps whose it is and refuses one that isn't the signed-in person's; it reads with it for that request only, and neither stores nor logs it (request bodies aren't logged, and the field is redacted by name). The agent has only tools that read, or that prepare a proposal for the person; Access by tab decides which tools a person's agent gets. Handing a change to Code with Ada goes through the checks of the Code tab itself (administrators and the teams they allow, the enabled repositories, the person's own right to contribute), and starts a run whose plan the person must approve before anything is written; handing a brief to the Mockup Designer creates an empty mockup for people with the Requirements tab, and builds nothing; handing a ticket to Diagnose a Ticket, for people with the Support tab, runs one turn of its shared session as that action does, and creates nothing in Azure DevOps. The model is told that what tools return is data, never instructions, and it can change nothing whatever it is told. |
| Ada's agent: project notes and skills | Notes are read and changed only by people Azure DevOps shows the project to, asked with their own access token for each request (the answer is remembered for five minutes); a note is removed by whoever added it, or by an administrator. Notes and skills reach the model as background and guidance below Ada's own rules: the agent has no tool that changes anything, whatever a note or a skill says. A note Ada suggests is kept only when the person chooses Keep. Skills come from one repository folder that only administrators name, and are read with the asking person's access, so a repository's permissions decide who gets them. Whoever can change the files in that folder shapes Ada's work for everyone: protect its branch with a policy. Values that look like keys or passwords are masked in notes and in skills. |
| Backend → Azure DevOps (routines) | Only organization administrators set routines up and start them. Their reports are for administrators unless an administrator shows a routine to its project: then people Azure DevOps shows the project to (asked with their own token) read them on the Routine Reports page, with personal data and what looks like a secret masked. Where a routine says so, its report is posted as a comment on the pull request that started it, masked the same way, with the backend's identity: the only thing a routine writes. A routine runs with the backend's own identity and only with tools that read: it prepares no proposals and changes nothing. It can read whatever that identity can read, which may be more than a single administrator can. Where several backend instances run, one takes a due routine (a conditional write to the state store). A routine that a merged pull request starts hears of it through the pull-request service hook, which is authenticated by PR_DOCS_HOOK_SECRET (at least 32 characters for routines); what the hook says is confirmed by reading the pull request with the backend's identity, and only a completed pull request with a successful merge starts a run, once. The model is told the pull request's number and its repository's name, never its title or description: those are people's text, which the agent reads through a tool, as data. Anyone who can merge a pull request in the project can so start a run, and what they wrote reaches the model as data; the run still has only tools that read, and its report goes to administrators only. |
| Extension → backend (AI provider key) | Only where the backend takes its key from Ada (AI_KEY_SETUP_CODE_SHA256 and AI_KEY_SETUP_CODE_EXPIRES). Entering or removing a key needs a sign-in to the organization and the one-time setup code (its SHA-256 compared in constant time; it expires, works once, and ten wrong codes an hour stop further tries), or an administrator the backend recognizes. A key is tried with the provider before it is kept, sealed (AES-256-GCM, key from SETTINGS_ENCRYPTION_KEY) and never returned: Ada sees when it was set and its last four characters. The provider's address can't be changed from Ada, so a stolen session can't send questions elsewhere. Changes are logged with the pseudonymous user. |
| Backend → connected systems (Connections) | Only organization administrators set them up, and choose where their tools are offered; offered to coding tools (backend 0.59.0), a tool is called by any signed-in developer of the organization with the connection's sign-in, so tick there only what every developer may see. What it returns reaches the developer's own AI masked, and is never unmasked. HTTPS addresses only; never the backend's own machine or a cloud's metadata service, by address or by the name's resolution, checked with every request; redirects are refused; answers are limited in time and size. The backend's own identity signs in only at the ready-made kinds' hosts, for their audience: no address someone types receives its token. A stored secret is sealed (AES-256-GCM, key from SETTINGS_ENCRYPTION_KEY), never returned, and reused only for the server it was saved for. Tools that change something are never offered; the model is told about a tool what the administrator saw when ticking it, not what the server says later; what a tool returns reaches the model masked, cut and marked as data, not instructions. |
| Backend → Azure DevOps (Ask with search, Diagnose a Ticket) | The same identity reads only the projects administrators chose and never the repositories they excluded, whatever the AI model asks for; secrets files are neither indexed nor read, and values that look like secrets are masked. The answers don't depend on the asking user's own access: everyone allowed to use these features can get answers from everything administrators chose for them (an exception described in PERMISSIONS.md). |
| Mockups → browsers | Versions open only for people signed in to Ada: at /m/<token>/<file> with a preview link the open panel asked for (192-bit random token, listed on the mockup as an open preview; it stops working 10 minutes after the panel last renewed it). There are no share links: Share and Download hand over a version as a .zip of its pages, through an authenticated request. The files come with MOCKUP_CSP (a sandbox: own scripts only, nothing loaded from elsewhere, nothing sent, no pop-ups or navigation), noindex and no-referrer. While Ada's designer works, the page runs in hidden sandboxed frames in the user's browser with the same rules as a meta tag, and no dialogs. |
| MCP client → backend | With MCP_SIGN_IN=azure-devops (the default without a Microsoft sign-in): the user's own Azure DevOps access token or personal access token as the bearer token. The backend asks Azure DevOps who owns it in an allowed organization (the check the extension's sign-in uses), remembers the answer for five minutes under the token's SHA-256 hash, reads Azure DevOps with it, and neither stores nor logs it. A token from the Azure CLI carries the user's whole Azure DevOps access, a personal access token only its scopes; the backend only reads with either. With entra: an Entra access token for this API (v2, RS256 against the published keys, issuer, audience, expiry, delegated scope Ada.Mcp), then the same tenant, organization, user, group and role policy as sessions; Azure DevOps is read with an on-behalf-of token for the user. search, ask_ada, logs and trace use the organization's search index and log sources, as Ask and Diagnose a Ticket do. What a tool returns goes to the AI the client uses, outside this backend. Origins outside ALLOWED_ORIGINS are refused. Access by tab applies to each tool (the tab its feature is on), and a failed tool returns only messages written for people. |
| Access by tab and quick action | Administrators limit tabs and single quick actions to Azure DevOps teams and groups; the backend checks every signed-in request against the route's tab and quick action (a route several actions use accepts any of them), and the same rules decide the tools of Ada's agent and of coding tools. |
| Read-only Ada | One switch for the organization, kept with the access rules. The extension hides the quick actions that change Azure DevOps and refuses its own writes (Wiki pages, work items, sprints, templates); the backend's Azure DevOps client refuses every write whatever feature calls it (comments, branches, pushes, pull requests), and the requests that start Code with Ada or repository documentation runs are refused before any AI work. Ada's agent offers no proposals and no hand-over to Code with Ada while it is on. |
| Outbound log | The backend counts the host of every outgoing request (Node's undici and http diagnostics channels), per day and instance, in its state store for 30 days; no paths, no content. Administrators read the sum under Monitoring. Requests of the containers beside the backend (SearXNG's to its search engines) aren't the backend's and aren't counted. |
| Backend images | From backend 1.66.0, each release signs its three images (ada-backend, ada-searxng, ada-playwright) and an SPDX parts list (SBOM) of each, made with syft, as a cosign attestation, with Valor's key (ECDSA P-256, encrypted, held only as GitHub secrets). Signatures and parts lists stay in the private registry beside the images; no transparency log or timestamp service is contacted, so the images' names aren't published. The release checks both against deploy/ada-images.pub before it ends, and customers check them with the same key from AdaDocs (Security and trust). |
| Stored proposals | Keyed by organization. AI-client proposals are returned and decided only for their owner. A decision applies only to the revision the user reviewed (409 otherwise). |
Reference backend controls
- Fail-fast configuration: startup fails on missing values, placeholders, non-HTTPS production URLs, credentials in URLs, unresolved Key Vault references,
AUTH_MODE=nonein production, or missingALLOWED_ORGANIZATIONS. Messages name the variable, never its value. - No secrets in responses: health, readiness and metadata expose no secrets, tenant IDs, provider names or infrastructure names, and probes never call the provider.
- Logging:
- Logged: metadata only (correlation ID, operation, organization, pseudonymous user reference, latency, outcome, status category, retries, token counts).
- Never logged: request query strings (sign-in codes), mockup share tokens (
/m/[token]/…) and client addresses. - Redacted at any depth:
authorization,cookie,api-key,x-api-key,x-admin-token,AI_PROVIDER_API_KEY,ENTRA_CLIENT_SECRET,SESSION_SIGNING_KEY,ADMIN_DIAGNOSTICS_TOKEN,PR_DOCS_HOOK_SECRET,ADO_PAT,client_secret,access_token,refresh_token,id_token,code_verifierand similar. - Errors are serialized without headers.
- Usage protection: per-user, per-organization and global request limits, daily and monthly token quotas, rate and concurrency limits, input and output-token limits, enabled operations, and an emergency switch. Automatic pull-request checks and MCP calls go through the same limits.
- Model output: schema and semantic validation with one repair attempt. Output is escaped before it is written to Azure DevOps.
Reporting a vulnerability
Report vulnerabilities privately to contact@valor-co.com. Don't include credentials or content from your organization. We confirm receipt within one business day and fix within 1 to 14 days, depending on severity. Every organization licensed to use Ada may test its own Ada for security. The details are on the Security and trust page.
Review checklist (backend operators)
-
AUTH_MODE=azure-devops(orentra), withALLOWED_ORGANIZATIONSandALLOWED_ORIGINSlimited to your organizations and the Marketplace iframe origin. -
SESSION_SIGNING_KEY,ENTRA_CLIENT_SECRET(withentra, or MCP clients that sign in with Entra ID),AI_PROVIDER_API_KEY(andADMIN_DIAGNOSTICS_TOKEN) are Key Vault references, shown as resolved in the portal. - The app identity has only Key Vault Secrets User; secret administrators are separate.
- User consent to unverified applications is restricted in your Entra tenant.
- Usage limits match your budget;
AI_DISABLEDis known to on-call staff. - The data handling (DATA-HANDLING.md) matches your AI provider's terms.
- With
CODE_AGENT_ENABLED, the app identity has Contribute and Create branch only on the repositories administrators enable; target branches have branch policies with required reviewers, so nothing Ada writes is merged unreviewed; and the pipelines that validate pull requests have no more access to secrets than a developer's branch should. - With
REPO_DOCS_ENABLED, the app identity has Contribute and Create branch only on the repositories administrators enable, and the default branches have branch policies (required reviewers), so nothing Ada writes is merged unreviewed.
