Threat model
Assets
Security event integrity, secrets and personal data, policy/configuration integrity, SQLite durability, Azure identity, destination routing and assessment evidence.
Threats and current controls
- Malicious JSON, log/newline injection and oversized records: strict JSON object
parsing, depth 32, 1 MiB ingress limit, structured serialization and JSONL
records written from parsed envelopes. Enum fields (
eventResult,eventSeverity,actor.type,security.decision) accept a declared member name (any case) or a declared ordinal only; undefined ordinals, numeric strings and comma-joined names are schema-invalid, never fingerprinted or queued. Pipeline document node kinds follow the same rule. - Poison records at delivery: a queued payload the Azure output can never upload
(invalid JSON, a repeated top-level property, invalid escapes) dead-letters alone
as
payload-invalid-json; it never fails or blocks the rest of the batch. - Secret leakage: secret field-name removal (exact names and fragments), value detectors over strings, numbers and key names, fail-closed HMAC, and quarantine on any redaction error, all before persistence; payload-free operational logs; no token persistence.
- Replay and duplicate delivery: unique stable fingerprint and event ID, leased
delivery transitions and acknowledgement records. Generated privacy alerts,
EC2 host events and AWS records use deterministic ids so retries and re-reads
deduplicate. Acknowledged rows are kept for the retention window
(
BOWER_QUEUE_RETENTION_HOURS, default 7 days) to preserve deduplication. Deduplication is checked before backpressure, so a resend to a full queue is acknowledged as a duplicate rather than retried. Malformed queue input is an error, never a silent duplicate. - Queue/disk exhaustion: the byte cap counts undelivered rows only, a recurring
retention job purges acknowledged rows, capacity returns HTTP 503 for producer
back-off, and ingest is rate limited (HTTP 429). Poison events dead-letter
individually or after
BOWER_MAX_DELIVERY_ATTEMPTS. Filesystem quota and disk-free health enforcement remain required. - Hiding activity behind suppression: suppression is opt-in per policy, refused for
neverSamplepolicies, counted durably in the enqueue transaction and reported by a policy-approved summary event per window with the key values; a policy set that suppresses must accept the summary or it does not load, and a refused summary keeps the window open rather than dropping counts. Poorly chosen key fields can still merge distinct actors, so review keys like any policy change. Theaggregateaction stores no individual event at all, only these counts, so it carries the same key review and is equally refused forneverSamplepolicies. - Silent loss of a source: optional source expectations degrade
/healthand the heartbeat when an application stops delivering accepted events. - Archive tampering or loss after retention: archive segments carry file digests and
continue the queue ledger chain;
bower archive verify --anchorrecomputes every link and proves it reaches a management-witnessed head. Retention purges only events covered by a verified archive of the same queue (segments present and intact, contiguous from at or below the oldest stored event, chain equal to the queue ledger) and otherwise purges nothing. Archive writers hold an exclusive lock and never replace a committed segment. Write-once storage for the archive directory remains an operator control. - Policy tampering: loaded policy is validated and hashed. Signed bundles and file permission checks remain required.
- Parser exploitation: no arbitrary code execution. YAML documents are size-limited.
XML parsers are not present. Signed pack parsers may carry a transform program
(new trust boundary: signed pack content operating on raw, pre-redaction records
inside the collector). Controls: only signed packs from trusted keys load; a fixed
allow-list of 20 pure functions, no loops, recursion, I/O, environment, randomness or
clock (evaluation time is an explicit input); static limits and a 1,000,000-step
per-record budget with string, array, record and output size limits; Bower's own
linear-time regex engine (Pike VM, no backtracking); static sensitivity flow checks;
reserved targets (
security*,bower*, credential-like names). Failures quarantine the record before redaction and persist nothing; errors carry only a statement number, column and code, never statement text or values. Transform output reaches persistence only through the allowlisted semantic mapping and the privacy engine. Management preview validates but never runs transforms. - Pack test output leaking raw values:
bower pack builderror text,bower pack testoutput and its JSON/JUnit CI reports (new output: report files and CI artifacts) carry sample names, decisions andexpectFieldsdiffs only. Field assertions are checked against the redacted event; an expected string that equals a pre-redaction value missing from the redacted event, or that contains amustNotContainentry, fails the sample without being printed, so a pack cannot be signed with, or report, a raw sensitive expectation. Unknown sample members fail, so a mistyped assertion cannot pass silently. CI signs with an ephemeral key and never publishes the packs. - Credential theft and overprivilege: one explicit Azure credential source
(
BOWER_AZURE_CREDENTIAL: managed identity by default, workload identity, environment or Azure CLI) instead ofDefaultAzureCredentialprobing. The management heartbeat refuses non-HTTPS remote endpoints. Credentials and access tokens are never logged or stored by Bower. - Destination redirection: endpoint/DCR values are explicit and endpoint requires HTTPS. Signed configuration and Azure resource validation remain required.
- Syslog listeners (new network trust boundary,
BOWER_SYSLOG_CONFIG): bind loopback by default and refuse a non-loopback address unless the protocol is TLS (optionally with client certificates) orallowInsecureNonLoopbackis set; a per-listener sender allow-list; strict UTF-8 RFC 5424/3164 parsing with stable failure codes; 64 KiB frames, connection caps, a per-frame idle timeout against slow loris, bounded submissions and a bounded UDP buffer. Accepting a sender never accepts its events: only a route to an active signed pack parser that selects the record, then redaction and policy, can queue one. Counters only; no frame content is logged or exposed. See syslog source. - File tail (new local trust boundary,
BOWER_FILE_CONFIG): only operator-named files, no wildcards, directories or default route; paths must lie strictly below an allowed root, with no linked directories and no linked file unlessallowSymlinkpermits one link whose target passes the same checks, re-checked after each read (path.1too); on Linux the open isO_NOFOLLOW | O_NONBLOCKand the handle must match the path's device and inode. Bounded lines (at most 30 KiB), polls and json-lines depth; oversized lines are skipped without buffering. A line becomes an event only through its route's signed pack parser, then redaction and policy; anyone who can write the file can inject lines, and any local user can through the system logger (logger -t 'sshd[1]'). Counters only. Rotation gaps are counted on a best-effort basis: lines written to a rotatedpath.1after Bower left it are counted only while Bower can still observe thatpath.1, and lines are lost uncounted if it is rotated again (topath.2) first. A writer appending topath.1can delay the switch to the new file only by a bounded number of polls (the drain cap). See file tail source. - Live tap (
GET /v1/tap,bower tap; new trust boundary: an operator-facing stream of accepted event content). See tap and top.- Pre-redaction exposure: there is no raw or
parsedtap point. Frames are built only from final selection outcomes, after the privacy engine. Accepted events carry the exact redacted payload handed to the queue. Rejected, quarantined, conflicting and transform-failed records are metadata only: stage, action, event type, application, environment, policy id and bounded reason codes. Tests inject known secrets (password field, AWS key, card number, JWT, API token) into accepted, rejected and invalid events and assert that none appears in the stream or the logs, in both runtimes. - Unauthorised reading: tap needs the shared ingest token or a producer listed in
BOWER_TAP_PRODUCERS. Per-producer tokens are refused (403), so a producer cannot read other producers' events. Without ingest authentication, only a loopback listener may tap.BOWER_TAP_ENABLED=falseremoves the endpoint. - Bulk export: caps on concurrent sessions, frames per second, frames per session, session duration and event size. There is no file output and nothing is persisted. Filter values are restricted to a safe character set.
- Accountability: every session (opened, refused, closed) is logged with the producer id, filters, caps, duration and counts, never the token or content.
- Ingest impact: publishing never blocks. Each session has a 64-frame buffer; frames
over the rate allowance or the buffer are dropped and counted (
framesRateLimited,framesDropped). Delivery is not involved. Streams end on host shutdown so drain never waits. - Residual risk: anyone holding the shared token sees post-redaction content, the
same content Sentinel receives. Protect the token as an operator credential and
prefer per-producer tokens for producers. Status
activitylists application and environment names (metadata) behind the same token.
- Pre-redaction exposure: there is no raw or
- Windows Event Log (new local trust boundary,
BOWER_WINDOWS_EVENTLOG_CONFIG, C# collector on Windows only; non-Windows hosts refuse the setting): the collector reads local channels as a least-privilege account in Event Log Readers. The query is generated from validated event ID and provider allow-lists (no free text, no collect-all form), so the event log service returns only allow-listed event content. Separate fixed boundary probes read only the oldest and newest record IDs, never XML, messages or event properties, to detect resets reliably. Event XML is bounded (64 KiB, no DTD or resolver) and flattened into a bounded record; publisher-rendered message strings are opt-in and, like every field, reach the envelope only through a signed pack mapping and redaction. Bookmarks live in the queue database and move only after durable enqueue or a definitive drop (including not-selected, rejected, invalid and oversized records); event ids from channel, computer, record id and creation time deduplicate re-reads. Counters and failure codes only. See Windows Event Log source. - Event injection: the collector requires a shared bearer token
(
BOWER_INGEST_TOKEN, compared in constant time) whenever it listens beyond loopback and refuses to start without one. Kubernetes manifests add a NetworkPolicy limiting ingress to labelled producer pods./healthexposes status only; queue and job metadata need the token. - Destination overload and throttling: the Logs Ingestion output adapts request
concurrency (bounded 1 to
MaximumConcurrency) and stops starting batches after aRetry-After. Back-pressure waits for a request slot over the already-leased batch; queue byte caps and producer 503s still apply. Thedeliverystatus block is counters, limits and a deadline only, behind the token. No new trust boundary. - Management command channel (heartbeat v2): commands travel outbound only, in the
heartbeat response, and come from a closed set. That set is
fetch-bundle,run-canary,reloadandrotate-credential(token-enrolled collectors only). No command carries code, paths or arguments.- Signing: each command is signed with a dedicated P-256 key and bound to one
collector id, a 128-bit nonce and an expiry of at most 1 hour. The signed
kindkeeps a command signature from verifying as any other Bower document. - Collector checks: the collector verifies against its own trusted keys, so a TLS inspection proxy or a network attacker that alters the response cannot forge or replay a command.
- At most once: a durable ledger written before execution makes each command run at most once across restarts.
- Refusals: unknown, expired, replayed and forged commands are refused, reported and audited.
- Blast radius of a compromised management plane or signing key: it can only issue the enumerated commands. That means fetching the currently assigned (already two-person approved) privacy profile, queuing synthetic canaries (bounded by lifetime, 8 per heartbeat and 16 outstanding), and restarting the collector at most once every 10 minutes. It cannot read events, change policy or privacy content, approve anything or run code.
- Signing: each command is signed with a dedicated P-256 key and bound to one
collector id, a 128-bit nonce and an expiry of at most 1 hour. The signed
- Token enrolment (new trust boundary: an anonymous endpoint, and a credential the
collector holds on disk). See collector enrolment.
- Token theft or guessing: tokens carry 256 random bits, are single use, expire (24
hours by default, 7 days at most), are bound to an environment and optionally a
collector id, and are stored only as SHA-256 hashes. They are shown once, never
logged and never returned again. A stolen unused token enrols at most one collector,
which still waits in
Pendingfor a reasoned approver decision, so it buys no access to events, policy or commands. Every refusal is audited with its reason. - Anonymous endpoint abuse:
POST /api/collectors/enrolis the only anonymous write. It has a 16 KiB body limit, 10 requests per minute per address, one generic refusal message (the reason is only in the audit) and a constant-time hash comparison. - Take-over: a token cannot enrol over a collector id bound to an Entra principal, and
cannot re-enrol a suspended or revoked collector. An enrolled principal
(
enrolled:<collectorId>, never a GUID) has onlyBower.Collectorand can act only for its own collector id. - Credential theft: the credential is the collector's own P-256 key; management holds
only the public key, so a management database leak yields nothing that can
authenticate. The private key sits in an owner-only file next to the queue; anyone
who can read it can already read the queue. Each request carries a 5-minute signed
assertion whose exact canonical bytes, signed
kind, lifetime and clock skew are checked, so an assertion cannot be reused as any other Bower signature or kept for long. TLS-inspection proxies see assertions as they see Entra tokens. - Revocation and rotation: every request re-reads the credential, so revocation takes effect on the next heartbeat. Credentials expire after 30 days; collectors rotate when 10 days remain, and the old key is retired on the first use of the new one.
- Token theft or guessing: tokens carry 256 random bits, are single use, expire (24
hours by default, 7 days at most), are bound to an environment and optionally a
collector id, and are stored only as SHA-256 hashes. They are shown once, never
logged and never returned again. A stolen unused token enrols at most one collector,
which still waits in
- Relays (new trust boundary, relay mode): a relay collector
accepts already redacted, decided events from downstream collectors over mutual TLS and
carries their management traffic in a tunnel.
- Downstream identity: the relay listener requires a client certificate whose SHA-256
pin is in the relay's downstreams file, inside its validity period and with
clientAuthusage when restricted. A downstream can only submit batches and envelopes naming the collector id its pin maps to (403orcollector-mismatchotherwise), so a compromised downstream cannot inject events as another collector. - Data on the relay: payloads are stored byte for byte without re-redaction. The relay does not parse raw source data; it deserializes the post-redaction envelope to validate its identity, accepting policy decision and content fingerprint before enqueueing. The relay therefore holds only post-redaction data. Its queue, ledger, retention and capacity limits are those of any collector; batches are bounded (500 events, 8 MiB, 8 concurrent).
- Relay identity cannot be forged downstream: the management tunnel only reaches the relay's own configured management endpoint (no target from the client, so no open proxy), and TLS to management runs inside it. The relay sees ciphertext only, so it cannot read or alter heartbeats, enrolment tokens, assertions or commands, and holds no downstream key. Commands stay signed by management and bound to the downstream's id.
- Durability across the hop: the relay answers only after its queue commit, and the downstream marks an event delivered only on that answer, so a relay crash or lost response leads to a resend that deduplicates, never a loss or a second queue row.
- Downstream identity: the relay listener requires a client certificate whose SHA-256
pin is in the relay's downstreams file, inside its validity period and with
- Native installers (new trust boundaries: the package or MSI an administrator runs as
root or SYSTEM, and the offline bundle that carries a pre-seeded token to the host).
See installers.
- Tampered package: packages are built in CI from the
publishartefacts and signed (rpm/deb GPG, Authenticode) only when the signing secrets are configured; until then they are unsigned, the bundle says so (UNSIGNED.txt), and the Windows installer warns or, with-RequireSignature, refuses. The bundle installers checkSHA256SUMSbefore installing; verify the archive itself out of band. - Over-privileged service: Linux runs as the
bowersystem account (no shell, no capabilities,ProtectSystem=strict, writes only to/var/lib/bowerand/var/spool/bower). Windows runs as the virtual accountNT SERVICE\Bower;%ProgramData%\Bowerdoes not inherit the ProgramData ACL, only SYSTEM and Administrators control it, and the service can write only its state, enrolment and spool folders. CI asserts both, including that no other principal has access. - Pre-seeded token exposure: the token is never a package or MSI property (MSI logs
properties) or a command-line argument. The installer moves it into an owner-only
location and deletes the seed copy; the collector deletes its copy as soon as
management has consumed or refused it (
BOWER_MANAGEMENT_ENROLMENT_TOKEN_REMOVE_AFTER_USE). The token stays single use and expiring, so a copied bundle enrols at most one collector, which still waits inPending. - Secrets left after uninstall: removal (not upgrade) deletes the management
credential, any unused token and the operator secrets folder (
/etc/bower/secretsandbower.envon Linux,%ProgramData%\Bower\secretson Windows). CI proves it on Ubuntu, Rocky Linux 9 and Windows. The queue is kept until purge because it may hold events the destination has not acknowledged. - Configuration tampering: settings files, trusted keys and packs are writable only by root or Administrators. A trusted pack or command key planted by someone with that access is outside Bower's control, as is any change such a user can make.
- Tampered package: packages are built in CI from the
- Management proxies: the management channel honours the standard proxy variables or an explicit proxy. A CA bundle adds roots for TLS-inspection proxies. Verification and host name checks are never disabled. Proxy URLs carrying credentials are refused, and the password comes from a file that is never logged, hashed or reported. An inspecting proxy can read heartbeat metadata and the bearer token in transit, so trust it as you would the management host. It cannot forge commands.
- Management API abuse: Entra-only endpoints (except token enrolment and the enrolled-collector credential, above), per-principal rate limiting, HSTS on HTTPS, restricted CORS headers and methods, and fixed error messages that never echo framework exception detail or server paths.
- Onboarding canary (
/setup, optional): the management API can hold a canary ingest token (a file read per run, at most 4 KiB, never returned, logged or stored) and a read-only verifier identity. OnlyBower.Administratorstarts a run, one at a time, each audited. The token should be a dedicated producer ID scoped to the canary identity. Workspace, DCR and table identifiers are validated against strict patterns before any Azure call (no..path segments). Results are metadata only; errors map to fixed messages and only exception type names are logged. Proof is shown only for a destination-query-verified run. See console onboarding. - Console home view (
/api/home, any interactive role): computed on the server from management state; it changes nothing and links to the pages that do. Collectors now report redaction counts by detector type on the heartbeat (at most 64 type ids and counts; an honest collector never sends values, paths or event ids). Type ids are untrusted metadata: management checks only their characters and length, so a compromised collector could encode data in one. Management stores the ids as sent in its own database (to compute increases) but/api/homereturns only allowlisted group names and labels; any id it does not recognise shows as "Other sensitive details". A compromised collector can also inflate or hide its own counts; the home view shows them as counts, not proof. Sentinel delivery is shown as proven only for a destination-query-verified setup run. See console home. - Local management exposure: HTTP listener defaults to loopback and has body limit. Named pipe and Unix socket transports remain required.
- Supply chain: central pinned packages, restore vulnerability audit, warnings as errors. SBOM, CodeQL, container scanning, signing and provenance remain required.
Residual risks
Name-based redaction cannot prove arbitrary free-text values contain no secret.
Structured number detectors (TFN, Medicare, card, IBAN and similar) skip matches wholly
inside a canonical UUID or 32-hex-digit token, so random event ids are not redacted and
quarantined as event-id-redacted. This is an accepted limit: a producer that
deliberately writes an identifier in UUID shape is not caught, whether an eight-digit
TFN as the first group (10040680-0000-0000-0000-000000000000), a labelled value such
as TFN: <uuid>, a UUID-shaped passport (passport A1234567-0000-0000-0000-000000000000)
or a card number laid across the first groups. Redaction protects against accidental
disclosure, not a producer intent on leaking data; secret and custom detectors still
scan these tokens, and an operator can add a custom detector for UUID-shaped values (see
UUIDs and dashless GUIDs).
The custom-log sample reader re-checks for symbolic links after opening, but a
swap and swap-back between checks remains possible; keep sample roots writable
only by trusted operators. Custom-log previews enforce a server-owned masking
floor and show no values for an operator-authored regex. The pattern still decides,
for each line, whether the line matches (any non-matching line fails the whole
preview) and whether its captures pass type validation (rejected counts and which
source lines produce rows). That line-level match oracle lets an authorised operator
infer undetected text in a server sample one request at a time. For JSON and
key/value samples, naming a key in the configuration also shows whether that key
exists. Keep sample roots to logs operators may already read. SQL Server incrementing cursors hold back rows newer
than CommitSettleDelay; transactions open longer than that can still be skipped.
Applications must use typed contracts and avoid unrestricted attributes. Local DB
encryption is deployment responsibility. Current collector does not verify
configuration ownership/mode. Current Azure path is not tenant-tested here.
Command expiry relies on the collector clock (5 minutes of skew tolerated), so keep
collectors time-synchronised. A collector whose command ledger cannot be read refuses
every command until an operator removes or repairs the file. A reload restarts the
process: delivery resumes from the durable queue, but the restart briefly interrupts
ingest. It is refused, before restarting, when any start-up file the running
configuration names would not load; it cannot validate changed environment variables,
which only a supervisor restart applies.
A signed transform can still select the wrong substring of a free-text field into an allowlisted target (for example a password typed as a username); the privacy engine redacts the mapped envelope, but review transform programs like policy changes.
Relay compromise: an attacker who controls a relay can read, delay, drop or replay the
post-redaction events it holds (as with any collector's queue), can inject events into
Sentinel that claim a downstream's collector id (the relay is trusted to deliver, and
Sentinel rows carry no downstream signature), and can deny downstreams their management
tunnel. It cannot read raw source data, change what the downstream's ledger recorded, read
or forge management traffic, or authenticate to management as a downstream. Comparing the
downstream's ledger payload hashes with the relay's ledger (bower queue verify on each)
detects altered or injected events after the fact. A compromised downstream can submit
only its own collector id's events. Pins are revoked by removing them and restarting the
relay; there is no online revocation. Relay client certificate keys are protected by file
permissions only.
Enrolment tokens are bearer secrets until used: deliver them over a channel you trust and prefer short lifetimes and a collector id scope. An assertion captured in transit (for example by a trusted TLS-inspection proxy) can be replayed for up to 5 minutes; it is bound to one collector and grants only that collector's heartbeat role. The credential file is protected by file permissions only (owner-only on Unix, the directory ACL on Windows); there is no hardware-backed key storage yet. A collector offline past its credential's 30 days needs a new token and a new approval.
UDP syslog senders can be spoofed (the allow-list checks only the source address) and
UDP is best effort. Syslog hostname and app-name are sender-claimed: without a
per-route allowedSenders, any allowed sender can reach any route. Syslog TLS
material is reloaded when its files change; client certificates are checked against
an optional revocation list signed by their issuing CA's key, and open sessions are
re-validated after a change, but a sender loses frames it writes into a refused
session. A file that cannot be loaded keeps the last good material, so a failed
rotation leaves the old certificate (and an old list until its nextUpdate) in force. Plain syslog has no
application acknowledgement, so frames in flight when the collector stops are lost
unless the sender retransmits.
Windows event log writers are only as trustworthy as the channel's write access: any
program allowed to write to a channel such as Application can forge an allow-listed
event ID under a provider name it registers, so prefer restricted channels, list
providers and match on provider in the pack. Events overwritten before they are
read are lost and counted (gaps); a log cleared and refilled past the bookmark while
the collector is stopped is not detected as a reset.
The installers delete files with shred -u (Linux, where available) or a plain delete
(Windows). Neither guarantees the token bytes are gone from journaling, copy-on-write or
SSD storage; the token's single use and short expiry are the control that matters. A
token that management never sees (the host never reaches it) stays on disk in the
owner-only enrolment folder until it is used, the package is removed or an operator
deletes it. Any local user can create folders in %ProgramData%: Install-BowerCollector.ps1
refuses a %ProgramData%\Bower not owned by SYSTEM or Administrators, but a plain
msiexec install re-permissions an existing folder without changing its owner, so check
the owner first when you install the MSI directly on a shared host.
Treat pseudonymised identifiers as potentially personal information.
Guided privacy editing
Guided privacy editing validates both the original and generated YAML with the collector's strict loader. It preserves advanced configuration outside the form, requires operator authorization and uses the existing two-person version review and audited assignment flow. Its preview accepts only a server-owned synthetic event and applies built-in protection after the candidate profile, so form choices cannot expose an unprotected preview. No user-supplied sample paths are read. See privacy editing.
Guided source setup
The management API stores validated configuration plans and credential locations, not credential values or event bodies. Planning never reads a referenced secret file, resolves a Key Vault secret, or opens a user-supplied network address. Checks use existing authenticated heartbeat metadata. Preview samples are synthetic and redacted server-side; failed redaction prevents submission. A healthy check-in is not Sentinel evidence, and an old source event cannot complete a new request.
File source plans never read the named file. They name one Linux file inside one
allowed directory, with no wildcards or traversal and not the whole disk. Kernel,
device, systemd credential (/run/credentials, also as /var/run/credentials)
and Bower's own configuration, secret, state, spool and log directories are
refused for both the allowed directory and the file, so a parent directory named
in the plan cannot reach into them. These checks compare path text: the server
cannot see host links, so an allowed directory that is a link into a refused
directory (the collector allows a linked allowed directory) is the host
administrator's responsibility. Each plan routes the file to one shipped signed pack
parser, so a request cannot widen collection to arbitrary files or unparsed
lines. Duplicate pending requests are refused inside the store transaction. File
requests share their parser's application identity, so the server-side check
never reports one as working on that evidence alone.
An operator requests a plan and a different approver decides it; the API enforces this independently of UI controls and audits both decisions and self-review refusals. Approved plans can be signed by an opt-in server-side P-256 key. The signature binds files, environment settings, sender snippets, verification and target identity. Downloads do not push changes or replace collector pack trust. Protect that signing key like the existing management command key and verify against a separately trusted public key. See guided source setup.
AWS fault-validation evidence
The AWS lab report records the tested redaction, durable-output and failure-recovery paths with their limits. Its central-state scan and local spool counts do not establish Sentinel arrival or coverage of every source/detector. Failed latency and recovery deadlines remain visible alongside successful eventual-delivery checks.