Home / Docs / Specification / 30. Packages and dependencies
30.14 The registry client
A registry is a set of static files below a base (ADR 0122 rule 34). una ita lock, update, add and fetch read the registries of the sources the root's sources section declares, and verify every byte they use with the rules of §11 and of this section before any of it is used.
-
Where a source is read (ADR 0122 rule 40). Each source is read from its places, in order: the mirrors that Itaoca's
mirrors.unalists for it, then its own URL, the one itssourcesentry gives.mirrors.unahas one linemirrors, below it one line per source, and below each source one location in quotes per line:unamirrors acme "https://ita-mirror.example.net" "file:///srv/ita-mirror"A location is an
https://URL or afile://URL of a local directory, which holds a copy of the registry's files as its store keeps them; afile://URL is an empty host and an absolute path written as it is, with no percent-encoding, so a%,?or#in it is refused. Plainhttp://, every other scheme and a bare path are refused, and so is a source or a location listed twice, at most 64 mirrors per source and 1 MiB in all: amirrors.unathat does not read is U7008, naming its line, and no source is read from it. This release has no transport for anhttps://location: such a place cannot serve, which the diagnostic says. The first place whose root metadata and checkpoint verify (rule 3) is the one the command reads; a place that serves a copy that does not verify is skipped and named, U7010, and one that cannot serve is skipped. A place that cannot serve is one that has no transport, cannot be read, or does not serve the root metadata of the pin or the checkpoint asked for; anything else that fails is a copy that does not verify. The client tells the two apart by where the failure arose, never by the text of a message, and a message shows at most 400 characters of the part that may quote what a place served, after the reason it states, with every control character, format character (Unicode category Cf: direction marks and isolates, zero-width characters, U+FEFF, tag characters) and line or paragraph separator written as\u{…}. With no place that verifies, the source is U7010, naming each place whose copy did not verify, or U7013 when no place could serve, at the first need of the source. Everything a place serves is verified as from the source itself, by the same rules, so a file changed in a mirror makes the command fail (U7010), never take the change. Omissions. An omission by a place or a mirror, a missing document, tile, entry bundle, kept checkpoint, map tile, root version or archive, MUST only make a result unavailable, never change it. The root metadata and the latestcheckpointchoose the place; every other document below that checkpoint, verified against it by its hash, signature or proof wherever it comes from, is read from the place or, when the place omits it or cannot serve it, from the next place that serves it, in order; with none, the result that needs it is unavailable, U7013 naming the document. A missing tile, entry bundle, kept checkpoint of a size up to the point, map tile on a name's path, or archive is such an omission, never an empty or absent result: a registry keeps the checkpoint of every size it signed. A root version past the last one served is the end of the root chain, which the stored root-version floor (rule 3) keeps from going back. Withheld cosignatures. For every kept checkpoint a computation needs, the client MUST read it from every place of the source, verify each cosignature line of each copy that verifies, and merge the verified lines by witness before it computes a witness time, so a place that withholds cosignatures cannot make a time later when another place serves them. And since withheld cosignatures can only make an effect later, the client MUST compare, for each owner, its verdict with every recovery, dispute and co-signer change in effect at its earliest possible position, the first size whose first kept checkpoint with a witness time, at or after it, has a witness time at least seven days after the request's start (the threshold-th earliest of the merged cosignatures on its start checkpoint), with its verdict as the cosignatures served say: when they differ, whether the owner's chain is refused, a release of its names counts, or, for rule 8, which requests took effect and from which position, and so whether its keys changed since a lock's point, the name MUST be unavailable (U7013), an omission of cosignatures, its message naming a place's possible withholding of cosignatures; it is never refused and never resolved on either verdict. Deadline and cadence. For each pending recovery, dispute or co-signer change, a registry MUST obtain and keep the witness threshold of verified cosignatures on its deadline checkpoint D, as rule 5 defines it, and on the checkpoint just before it, so that a client can tell where the seven days end; while witnesses are down it keeps trying, and it MUST NOT log anything that relies on the request before D, the name staying unavailable meanwhile, which is the safe direction. A registry MUST publish or serve on D only cosignature lines, by any witness, dated at or after the request's target, MUST NOT let any checkpoint after the request and before D reach the target, and MUST NOT publish or serve a cosignature line dated before the target on any checkpoint from D on: every cosignature the registry publishes or serves on D is then at or after the target, so a place that strips cosignature lines from D cannot bring its witness time below the target while k remain, and with fewer than k the earliest and the served timings differ, which the client records; a D whose witness time dips below the target would need k lines dated before the target from outside the registry, such as leaked or dishonest ones. A registry MUST sign a checkpoint at every size of its log, batched appends included, each size's checkpoint kept, since a client's scans read sizes one by one. A registry MUST obtain and keep the witness threshold of cosignatures on every checkpoint whose size is a multiple of 64, the pinned cadence: when no checkpoint of the threshold exists, every place's copy merged, within 64 sizes after an entry whose logged time a result needs, or a pinned checkpoint a deadline search reads lacks it, short of the point, the result is unavailable (U7013, an omission of the cadence), and the client never takes the point's time instead; and on the start checkpoint of each pending recovery, dispute or co-signer change, the first checkpoint that includes it. The client takes a request's start as the k-th earliest of the merged verified cosignatures on its start checkpoint, so fewer than k witnesses, back-dating or withheld, cannot move it; a start checkpoint with fewer than k, every place's copy merged, is an omission (U7013), and the name is unavailable. With both, an honest registry's served and earliest timings coincide, so a name unavailable by an omission of cosignatures means that cosignatures are withheld or that the registry misbehaves. Every place's copy of each kept checkpoint having been read, the client MUST record, as typed evidence thatuna ita auditreports: a request whose two timings differ, as a missing deadline checkpoint, with the request's index and its target witness time; and a scan of 64 sizes short of the point with no checkpoint of the witness threshold where one is needed, or a pinned checkpoint without it, as a cadence gap, with its range of sizes. The deadline search. A client finds a request's deadline D of rule 5 by reading the pinned checkpoints from the request on, up to the first whose witness time reaches the target, or to the point, and then every size after the multiple of 64 below that one up to the first whose witness time reaches the target, where the deadline and pre-deadline checkpoints are kept: O(W/64 + 64) kept checkpoints for W sizes from the request to its deadline, the same search for the served effect, the earliest one, and the record of a missing deadline checkpoint. A pinned checkpoint that reaches the target bounds the search, so a later one whose witness time dips below it changes nothing. The search reads at most 2^23 = 8,388,608 sizes past the request; past them the result is unavailable (U7013, an omission of the scan cap), never a later or absent effect. ADR 0122 sets no publish rate, so the cap is chosen to cover ten times a week of a large registry at 10^5 entries a day: 10^5 × 7 × 10 = 7 × 10^6 < 2^23, so an honest registry never reaches it, and a search reads at most 2^17 pinned checkpoints and 64 more. Each names the places read and the fewest of them that served the same view of the checkpoints it rests on, and is evidence from an absence, which any place read may have caused, two places included, since two mirrors can be one party: it never asserts the registry's fault. Only an owner chain that does not settle, which its signed entries show, is the registry's misbehavior. The code of a failure comes from that failure alone: U7013 when no place served what it needed, U7010 when what was served does not verify, never from an omission an earlier failure recorded. A place that cannot serve at all, anhttps://location this release cannot read, or a file a mirror directory cannot read, a symbolic link or one it may not open, serves nothing, so what no other place serves is an omission (U7013); a file larger than its limit is refused (U7010). Inuna ita fetch, an archive that does not verify against its statement or the lock, or a provenance that does not, is U7010, and a failure to store a package in Itaoca is U7011. The withheld-eligibility delay, a named and bounded exception to the omissions rule above: cosignatures a place withholds can only make a release's logged time later, so they can delay the release's cooldown eligibility (§10 rule 4), never advance it, never select a version that is yanked or under an advisory, and delay it by at most the time the log takes to grow by 64 sizes, since without a checkpoint of the threshold within 64 sizes of the release its logged time is unavailable, never the point's. It matters when an attacker delays the eligibility of a fix release. Resolution keeps the served, later time, and the client records the delay as an observation, the release, its version and both times, the served one and the earliest the merged cosignatures allow (by each witness's timestamps never decreasing, at least the timestamps on the last kept checkpoint below it), whichuna ita auditreports. No command starts another program or opens a network connection. -
The files of a registry are those of ADR 0122 rule 34, at the paths a registry serves:
root/<n>,checkpointandcheckpoint/<size>, the log's tiles and entry bundles in the C2SPtlog-tileslayout undertile/, the name map's tiles undermap/, and archives atblobs/sha256/<hex>. A copy of a registry's store in a directory keepscheckpointas the filecheckpoint/latest, a name no size can have. Every document other than an archive is at most 16 MiB, a note at most 64 KiB. -
Opening a source. The root metadata whose digest is the pin of
sourcesis read amongroot/1toroot/64, accepted by the threshold of its own root keys, and each next versionroot/<n + 1>that exists is walked by §11 rule 8, at most 64. The checkpoint is accepted when its origin is the last root's log key name, it is signed by that key, and at least the root's witness threshold of distinct witnesses cosign it; its witness time is §11 rule 5's. The last root MUST NOT have expired at that time (U7010).- Freshness. For
lock,updateandadd, the checkpoint ischeckpoint, and its witness time MUST be less than 24 hours before the local clock; a local clock more than one hour behind it is clock skew. Both are U7010, and nothing is written. - A lock's point. For
fetchand forlock --check, the checkpoint is the lock's resolution point,checkpoint/<size>with the root hash the lock records, and no freshness is needed.lock --checkalso reads the newestcheckpointa place serves, fresh or not, extending the lock's point, only to find an owner whose chain was refused, or froze, after it (rule 5); when none can be read, a note says that a later freeze is not checked. - Floors. Itaoca keeps the floors of a registry under its identity, the hex SHA-256 of its pin (
sha256:and the hex digest of its first root metadata, which names its source), so two namessourcesgives one registry share them and one name given to two registries never mixes theirs: inregistry/<id>/checkpoint, the largest checkpoint accepted, and inregistry/<id>/root-version, the highest root version accepted, with the digest of that root metadata. The root-version file is<n> sha256:<hex>and exactly one line feed:<n>the version in decimal, at least 1 and without a leading zero, then one space,sha256:and the 64 lowercase hex digits of the digest of that version's root metadata. A file of the earlier form,<n>and one line feed, the version alone, is still read, and is compared by version only. A file in neither form is a floor that cannot be read, never an absent one. A floor is read without any lock. It is written under the kernel-held advisory lock ofregistry/<id>/floor.lock, tried for a few seconds: under the lock, the stored checkpoint is read again, the new one is written, through a fresh file and a rename, only when it is larger and consistent with the stored one by a consistency proof, and a root version, with its digest, only when it is higher: an equal version never replaces the stored floor, whatever its digest or form, so a floor of the earlier form takes a digest when a higher version is accepted. The operating system releases the lock when its holder ends, so the file's existence means nothing and it is never removed. Both floors are stored as soon as a checkpoint is accepted, whatever the command then writes,--checkand--dry-runincluded; a floor that cannot be stored, or a lock that cannot be had in time, is a note that says so, and never fails a place or a command; on a file system that takes no lock, the note says that rollback floors are not stored there, naming the path, and for any other failure to take the lock, that the lock could not be taken, with the error. A checkpoint is accepted only with a consistency proof (§11 rule 1) between it and the stored one, computed from the tiles, in either direction; a resolution never accepts one below the stored one, and for a resolution of a package with a lock, the checkpoint MUST extend the lock's resolution point, by a consistency proof from its recorded size and root hash. A root chain whose last version is below the stored root version is refused, so a place cannot hide a newer root version; and when the stored floor holds a digest, a root chain that does not hold the floor's version with that digest is refused as a fork of the root chain (ADR 0122, amendment of 2026-11-09, L3). A failure is U7010: it is evidence that the log forked, or that a place hides what the client already saw. - Historical entries verify against the current root's keys: the log's key for kept checkpoints and for recoveries and disputes, the witnesses, and the keys of Itaúna. A rotation of the root can therefore refuse entries logged before it.
- Monotonic witnesses. Across every cosignature the client holds, a witness's timestamps never decrease as the log grows (U7010).
- Freshness. For
-
Entries and chains. An entry is read from its bundle, and its leaf hash, SHA-256 of
0x00and its bytes, MUST be included in the checkpoint by an inclusion proof computed from the tiles. A name's state is its head in the name map, read from the map's tiles on the name's path from the root of the checkpoint'sita-mapextension line, each tile checked against the hash that names it, and proven against that root (§11 rule 9), then its whole chain, walked from the head by §11 rule 10, each entry verified in the log. An entry is a signed note whose text is a release statement (§11 rule 6), an owner's entry (rule 5), or a yank or an advisory (§11 rule 11), read as §15 rule 6 states; an entry of any other kind, a transfer included, refuses the name (U7010), so nothing is resolved from a part of a name's state. -
Owners' keys (ADR 0122 rules 36.3, 38 and 38.1). An owner's chain is the chain of the name-map name
owner:<owner>, which no package name can be, since a package name has no:. Its entries are signed notes of two formats. In each, every line after the format line is<field> <value>, one form per line, in the order stated, each once unless stated, and nothing after; an entry longer than a note may be (64 KiB) is refused before it is read. Anything else is refused (U7010).-
ita-owner/1, the registration, is the chain's first entry:source <source>;owner <owner>;previous none;threshold <k>; onekey <name> <base64 key>line per key, 1 to 32 of them and at leastk; then, optionally, the owner's recovery cosigners: onecosigner <name> <base64 key>line each, 1 to 32, followed bycosigners <k>,kfrom 1 to their number. A key's name is 1 to 128 bytes with no space, control character or+; no name or key is listed twice. It is signed by every key it registers.Outputita-owner/1 source itaty owner acme previous none threshold 2 key acme.laptop 47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU= key acme.phone m+aZBhHlVmmPe79aoENK0dCqbiwIpQsMwafH8+0OO9I= key acme.backup czG95RFsVbayIzFANGCv/WXvu8KbpTCJYRnkEcW1kgo= -
ita-key/1, every later event:source <source>;owner <owner>;previous <index> sha256:<hex>, the owner's previous entry; one action line; thenthreshold <k>, the owner's threshold once the event takes effect, from 1 to 32. "The current one" and "the keys after" in the table below are those of the state known when the entry is logged ("The requirement as logged", below):Action line Signed by thresholdadd <name> <base64 key>the owner's threshold of current keys, and the key added 1 to the keys after revoke <name>orrevoke <name> since <p>the owner's threshold, or the cosigners' threshold 1 to the keys after cosigners <k> <name> <base64 key> …, one or more cosigners,kat most their number; orcosigners none: a pending co-signer changethe owner's threshold the current one recover <name> <base64 key>: a pending recovery naming the new keythe log's key, and the cosigners' threshold when the owner has cosigners 1 cancel <index>: of the pending recovery or co-signer change logged at that indexany one current key of the owner the current one overrule <index>: of the cancellation of a recovery logged at that indexthe threshold of the cosigners in effect when the recovery was logged the current one dispute <name> <base64 key>: a registry dispute naming the new keythe log's key; only for an owner with no cosigners in effect 1 Outputita-key/1 source itaty owner acme previous 48211 sha256:0b7e3c110b7e3c110b7e3c110b7e3c110b7e3c110b7e3c110b7e3c110b7e3c11 revoke acme.laptop since 48190 threshold 2
This release. A client of this release replays, in an owner's chain, only registrations without
cosignerlines,add,revoke <name>andrevoke <name> since <p>on a key held or held before, together with the owner's release and yank statements (ADR 0122 Amendment 14). An owner's chain that holds any other entry, a registration with cosigners,recover,dispute,cosigners,canceloroverrule, makes the owner's names unavailable (U7013), naming the entry, unless an entry before it is one a registry must not have logged (below), which refuses them (U7010); no release of that owner counts and no yank of it stands. The rules below for those entries, the deadline, co-signer changes and competing requests, and the recovery and dispute paths of rule 38.1, are not in force for clients of this release, which judge no entry by a time; they are kept for a later release, which judges those kinds by its own rule ("What a registry logs", below). Within this release, the key floor of "What a registry logs" bounds everythresholdof the table below to 2 or more.A key's fingerprint is the hex SHA-256 of its public key. A key added, recovered or disputed is never a name or a key the owner holds or held. The client replays the owner's whole chain: an event governs the entries logged after it. A recovery, a dispute or a co-signer change waits: it takes effect at its deadline D, and governs the entries logged after D. The deadline. With the target seven days after the time the request was logged, the k-th earliest of rule 7, and a checkpoint's witness time the k-th latest of its witnesses' cosignatures, D is found from the first multiple of 64 at or after the request whose witness time reaches the target, as the first size in the 64 sizes before it, after the previous multiple of 64 and after the request, whose witness time reaches the target, or that multiple itself if none does. With no such multiple below the point, the point stands in its place when its witness time reaches the target; otherwise the request has not taken effect at the point. A checkpoint between two multiples of 64 whose witness time reaches the target before any multiple does is not the deadline, so a client and a registry find the same D whichever witnesses cosign late. Fewer than k witnesses, and a place that leaves cosignatures out, can only make the start later. A registry keeps the checkpoint of every size it signed: a kept checkpoint below the point that a place does not serve is an omission, read from the next place, and with none that serves it the result that needs it is unavailable (U7013), never a later or absent effect. When a recovery or a dispute takes effect, the new key is the owner's only key, with a threshold of one, and the change is a key change (rule 8). A recovery that a current key canceled before it took effect never takes effect, unless the cosigners in effect when it was logged overruled every cancellation of it. An overruling MUST count whenever it is logged before the recovery took effect, after its seven days included: a recovery takes effect at its deadline D, and after its last cancellation was overruled; when its seven days passed before that overruling, it governs the entries logged after the overruling. Once its cosigners overruled a cancellation of a recovery, a later cancellation of it by owner keys MUST NOT count: the cosigners' decision binds, and a thief holding one owner key cannot cancel again at each last moment. A cancellation of a dispute, of a request in effect, or of no request changes nothing, and a dispute cannot be canceled. An owner MUST NOT ask a recovery or a dispute that competes with a request of its own still waiting (below): that freezes its own chain. This release has no command that asks one.
Co-signer changes wait. A
cosignersentry, a designation, a replacement or a removal, MUST NOT take effect before its seven days have passed, as above, and MUST NOT take effect if any one current key of the owner canceled it before then; a cancellation of a co-signer change cannot be overruled. While it waits, the cosigners in effect are the old ones, for every rule that names them: recoveries, revocations, overrules and disputes, so with none in effect a dispute is available. When a recovery or a dispute takes effect, every co-signer change logged before then and still waiting MUST NOT take effect, since keys it replaces signed it; a recovery leaves in effect the cosigners that were in effect when it was logged, and a dispute leaves none.una ita lockandupdatereport a co-signer change pending at the resolution point as U7014, as a pending recovery (rule 8).Competing requests. A recovery or a dispute logged while a dispute of the chain waits competes, and so does a dispute logged while a recovery waits that was logged with cosigners in effect. A request waits from its log position until it takes effect; such a recovery waits even when canceled, since its cosigners may overrule the cancellation. A dispute logged while a recovery logged with no cosigners in effect waits does not compete: both take effect in turn, the later one last. Whether requests compete never depends on a cancellation, which a later claim of compromise can void. No competing request takes effect, and the chain MUST be taken as frozen from the log position of the later one. A frozen chain stays frozen: no later entry changes the owner's keys, its cosigners or its requests, and a dispute or a recovery logged after the freeze changes nothing; a revocation with
since <p>logged after it, signed as its kind requires by the keys in effect at the freeze, still makes its claim. A name of a frozen owner MUST be refused by resolution (U7010), and the refusal gives the freeze's position; its owner registers anew, under a new owner name. A release logged before the freeze stands, unless it is signed by a key compromised before its position; one logged from the freeze on never counts, whoever signs it, and refuses nothing. Competing requests arise only when an account was taken over, since the registry logs a recovery or a dispute only after it verifies the account; nothing in the log tells the owner's request from the attacker's, so none of them is given the keys.The requirement as logged. Each entry of an owner's chain is judged once, against the state that the replay of the chain before it reaches at its position: the owner's current keys, its threshold, its former keys, and the entry that brought each key in; its own effect is left out. Its counted signers are those of its signers among the current keys that are clean there (below). Its requirement is the owner's threshold of counted signers, for every kind, plus the added key's own signature for an
add; a registration is signed by every key it registers. Both are fixed when the entry is logged, and no later entry changes them. Itsthresholdis checked against the same state, never against one that a later claim rewrote.Claims of compromise. A revocation with
since <p>is a claim. It names a key by its name among the keys held then, which it removes, or among the keys held before and held no more, which it does not remove, itsthresholdthen the current one. ItspMUST be below its own index. A claim MUST NOT carry a signature by the key it names: an owner claims a key's past with its other keys, and retires a key of its own with a plainrevoke. A claim compromises its key fromp, taken as no earlier than the index of the entry that brought the key in, so a registration is never undone; a key compromised frompsigns nothing that counts at a position afterp.Void entries. A signer of an entry is tainted when a claim that counts compromises it from a position before the entry, or when the entry that brought it in, its registration or its addition, is void. An entry is void when its counted signers, less the tainted ones, do not meet its requirement; a void entry changes nothing, and a registration is never void. A revocation, a claim or a plain
revoke, removes its key, and its stated threshold applies, only when the key is held at its position in the replay; a revocation of a key not held there applies neither the removal nor its threshold.Which claims count. The client takes the claims from the last to the first, once: a claim counts when it is not void under the compromises of the claims after it that count, together with its own. The compromises of the claims that count are the chain's compromises; every other entry is void or not under them, and a claim that does not count is void. Nothing is iterated, and every chain has one result. A chain is contested when a claim that counts is void under the chain's compromises: every name of its owner MUST be refused (U7010) while it is, naming the claims; it is not the registry's misbehavior.
What a registry logs. A registry MUST NOT log an entry of an owner's chain unless all of these hold, and a client MUST check every entry of the chain the same way:
- it is of a kind this release replays ("This release", above) and meets the rules of its kind: a registration first and only there; a name or a key that the chain named before, in a void entry too, never again; its
thresholdright; - it meets its requirement as logged;
- for a claim: it counts on the chain that ends with it, it carries no signature by the key it names, and it changes the keys or the compromises as the chain is known: a claim on a key held removes it, and a claim on a key held before and held no more is logged only when no claim that counts on the chain before it already compromises that key from its
p, taken as no earlier than the key's introduction, or from an earlier position, so a claim that repeats a compromise already counting is not logged; - the key floor: after it, as the chain is known with it, the owner's threshold is at least 2 and its current keys number at least one more than its threshold and at most 32, for a registration and for every key event, a claim on a key held included;
- the cap of claims: the chain holds at most 64 claims with it, so a registry MUST NOT log a 65th, and the owner then registers under a new owner name.
The entries are read in log order. An entry that a registry must not have logged refuses every name of its owner (U7010), and is recorded in a typed form, naming the owner, its log index and the rule it was judged by, that
una ita auditreports as evidence against the registry; its owner registers under a new owner name, with new keys, since a key that another owner's chain named is refused (§16 rule 2). An entry of a kind this release does not replay, before any such entry, makes the names unavailable instead (U7013), and nothing after it is read. The rule of this paragraph is rule 1 ofita-key/1. A later rule applies from the log index the root metadata declares for it: whether an entry could be logged is judged by the rule in force at its position, and which claims count, which entries are void and how releases and yanks are judged follow the new rule for every chain as a whole from the first checkpoint whose size reaches that index. A client that does not know a declared rule makes the owner's names unavailable (U7013). A correction that refuses entries that let an attacker's signatures count applies to the whole log. The replay makes at most C(C + 1)/2 + 2C + 2 forward passes over a chain of C claims, O(C² · E · K) for E entries and K keys held at once, and O(E · K) for a chain with no claim; each signature of an entry by a key is verified once. The unscoped names belong to Itaúna, whose keys and threshold are the root metadata's: it has no chain, no recovery and no dispute. Attackers. The replay's contract is stated against a key-only attacker, which holds stolen keys of the owner from a log position on and has the registry log any entry that those keys' signatures allow; recoveries and disputes, which need the owner's account, are not logged in this release ("This release", above). The owner responds with its claimrevoke <stolen> since <p>,pthe position after which the key was stolen, signed by a threshold of its current keys other than the stolen one that are clean as the chain is known, and never by the stolen key; under the key floor, when it holds exactly one key more than its threshold, it first adds a new key, signed by those keys and the new one. A registry MUST notify the owner's verified contact as soon as any key event is logged against the owner's chain.The replay's contract. A signature is the attacker's when it is by a stolen key at a position after the theft, or by a key that the attacker's entries brought in. An honest release or yank is one whose signatures are all by owner keys, none the attacker's except the stolen key at or before
p, and none by a key that the owner itself claimed before that signature. An owner claim is of the honest form when itspis at or after the last position where the owner signed with the key it names. The owner is honest when, after the theft, none of its entries needs a stolen key's signature, it never signs with a key after it claimed or revoked that key, and each of its other claims is of the honest form. A client MUST replay an owner's chain so that, on every chain the registry logs:- once the owner responded, on the chain and on every chain that extends it in which every claim the owner logs after its response is of the honest form, either the owner's names are refused, or no release counts and no yank stands whose signatures are all the attacker's; an owner claim after the response that is not of the honest form, and that names a key the response or its signers' introduction relied on, can undo the response;
- no release or yank, whoever signs it, refuses the owner's names;
- against an attacker holding one key and an honest owner that responded, the owner's names resolve, a release signed by its current keys other than the stolen one counts, and every honest release or yank that counted or stood when it was logged still does;
- against an attacker holding one key of an owner whose chain the registry logged under the key floor, no entry whose signatures are all the attacker's can be logged, before or after the response; and when the owner is honest and its names resolve, it can log its response at any time while its chain holds fewer than 64 claims, after an addition of a new key when it holds exactly one key more than its threshold, and the response then counts. The key floor counts keys, not keys that can still sign (§16 rule 1): an owner that is not honest can leave a current key compromised by a claim that counts, and with it fewer keys that sign as counted than its threshold, and then no key event of its can be logged; an owner whose chain holds 64 claims logs no further claim (the cap of claims). Either owner registers under a new owner name, with new keys. An attacker holding two keys of such an owner is not covered by this item: it controls the owner's names, and the owner answers by registering a new owner name;
- two replays of one chain give the same history, the replay makes a bounded number of passes, and the result depends only on the entries in log order, and not on the order of a note's signature lines.
An owner that never acts cannot be protected against a valid key. So a refused chain fails every package of its owner:
una ita lock,updateandlock --checkMUST refuse a package whose owner's chain is refused (U7010), as above or, in a later release, frozen, naming the position,--checkby the newest checkpoint a place serves (rule 3), anduna ita auditMUST report it. Plainlock --checkneeds no fresh checkpoint, and MUST say in a note how far it looked: that a later freeze was checked at a checkpoint of a witness time it gives in UTC, or that a later freeze was not checked.--fresh:una ita lock --check --freshMUST read, from a place or a mirror, a checkpoint whose witness time is less than 24 hours before the local clock, as a resolution's (rule 3), extending the lock's resolution point by a consistency proof, and MUST fail when no place serves one (U7013, saying that--freshneeds a reachable place or mirror) and when the owner of a locked package has a refused chain there (U7010). -
-
Releases. A release of a name is a release statement of its chain, of the source and name it is read for, each version once (a second statement of a version is U7010: a release is immutable), signed by the owner's threshold of keys valid at its log position. A statement counts when its owner's chain is not refused (rule 5) and its signers that the owner's keys as logged at its position count, less those tainted under the chain's compromises (rule 5), meet the owner's threshold as logged there. Any other statement is skipped by resolution as a yanked release is, and is neither checked against nor counted by rule 26, so what is not signed as it counts cannot refuse the name; a statement that its owner's keys as logged do not sign is also recorded as evidence against the registry. A statement that met rule 26 against the releases that counted when it was logged, and fails it only against the releases that count now, is skipped and noted, never a refusal of the name. A statement that needs a capability, an operation or a trusted module that the highest release of its identity logged before it did not need breaks rule 26 of ADR 0122, and refuses the name (U7010). The key the lock names is the first signer by fingerprint, as
ed25519:<owner>:<fingerprint>,itaunafor an unscoped name. -
Logged time. An entry, a release or an owner's recovery or dispute, is logged at the k-th earliest of the distinct witnesses' earliest cosignatures on the kept checkpoints that include it, k the witness threshold (§11 rule 5). The kept checkpoints are read by size,
checkpoint/<size>from the entry's index plus one on, each signed by the log's key and a prefix of the resolution point by a consistency proof, until k witnesses are seen, at most 64 of them; past that the resolution point's cosignatures count too, which can only make the time later and a wait longer; the cooldown of §10 rule 4 is measured from it to the witness time of the resolution point, the earliest of the registries' when a program reads several. -
Resolution and the lock.
una ita lock,updateandaddresolve each registry need by §10 over the releases of rule 6, and lock each release of the build list aspackage <name> <version>,from <source>,digest,signed,logged <index>, itsneedslines from its statement, and, for a need of the root withmaylines,granted by <root> may <ceiling>; each source with a release in the lock is recorded asregistry <source>,root "<pin>",checkpoint <size> "<root hash>". Consent is §10 rule 8's, and for a release with trusted modules, by its statement'strust, as §13 states. Beside it:- Keys. A locked release whose owner's keys changed since the lock it replaces was written, another signing key, or any entry of the owner's chain logged at or after its resolution point, whatever it does, a pending recovery, dispute or co-signer change and one that took effect included, is U7014 at the need until
--accept-key <package>records it; and a release of the build list whose owner has a recovery, a dispute or a co-signer change pending at the new resolution point is U7014 too, naming it, until--accept-key <package>. Nothing is written. Consent is recorded in the lock, in the registry's section:accepted <owner> <index> …gives, per owner, the recoveries, disputes and co-signer changes pending at the resolution point whose pending state was consented to, and theneffect <owner> <index> …those in effect at the resolution point whose taking effect was; owners in order, indices ascending, each below the checkpoint's size. A consent to a pending recovery, dispute or co-signer change covers its pending state only: when it takes effect, that is the moment an account taken over lands, and it is a key change of its own, U7014 until--accept-key <package>records it as aneffect. A later lock, anduna ita lock --check, take what is recorded as consented; anything pending or in effect that the lock does not record still needs--accept-key. A recorded index counts only when it is below the size of the lock's resolution point and is, there, a recovery, a dispute or a co-signer change of the owner's chain: pending and not canceled for anacceptedindex, in effect for aneffectone; any other is U7009 at its line, reported once per owner, and consents to nothing. - Compromised releases. A release that counts as signed only with a key compromised before it was logged is never locked or fetched (U7010).
- Rule 26 against the lock. A release that replaces a locked one of its identity and needs more authority or trust than it did is U7010.
- The review of §10 rule 8 gives a registry release's
usesfrom its statement, which its archive is checked against when it is fetched (rule 9). - Floors. The floors of each registry read are stored as soon as its checkpoint is accepted (rule 3).
- Keys. A locked release whose owner's keys changed since the lock it replaces was written, another signing key, or any entry of the owner's chain logged at or after its resolution point, whatever it does, a pending recovery, dispute or co-signer change and one that took effect included, is U7014 at the need until
-
una ita fetch [path]fills Itaoca with each registry release of the lock that Itaoca does not hold with its provenance: read at the lock's resolution point (rule 3), the release statement at the lock'sloggedindex with the lock's digest and signed by the key the lock names, valid at its position; the archive atblobs/sha256/<hex>, read and hashed once (§9 rule 3); then the statement is checked against the archive (ADR 0122 rule 37): itsmanifestis the digest of the archive'sita.una, which names its package, version and edition; its needs are the archive's, each of the release's own source; itstrustis the archive's trusted modules; and what the archive's code uses, the union of theusesof its functions and handlers, checked at tier 0 from the bytes verified, is within itsauthority. The archive's code MUST check with no diagnostic but those a package read alone has by design: no lock (U7009), registry needs it cannot load (U7008 at itsita.una), and imports of their modules (U1001); any other, or a platform the checker cannot run on, refuses it, since what such code uses cannot be counted. A release that counts as signed only with a compromised key is not fetched. The package is then stored with its provenance (§9 rules 5 and 7) and loaded again as every command loads it. Any failure is U7010, and nothing of that release is stored; a source with no mirror is U7013. It printsfetched <name> <version>, or<name> <version> is in Itaocafor one held already. -
Loading. A registry release that loads verified (§9 rule 9) and that a need of the root names, by its name, its source and its major line, is mounted as a path dependency is (§12 rules 3 to 5), its files the bytes verified, named in diagnostics below
vendor/ita/<source>/<release>/oritaoca/<source>/<release>/. §12 rule 2 applies to it butaccept name, which a registry package does not need; in this release a registry release with trusted modules is not mounted either (U7008 at the need). The report gives it with itssource,nullforpath, the lock'sdigestandsigned, andtcb.registriesnames each source of a mounted release with the digest of its root metadata. -
Costs. Opening a source: O(R) root versions and O(log L) hashes and tiles for a consistency proof in a log of L entries. An entry: O(log L). A name: at most 32 map tiles of at most 12 KiB and O(256 + 8 k) hashes for its head, and O(E log L) for its E entries. An owner's keys: O(E) to replay, O(log E) to find the keys at a position. A logged time: at most 64 kept checkpoints; a recovery's effect, and its earliest position: O(W/64 + 64) kept checkpoints for the W sizes from the request to its deadline, by the deadline search of §14 rule 1 over the pinned multiples of 64 and then the sizes up to the deadline, each checkpoint read once and cached, and at most 2^23 sizes, so at most 2^17 + 64 checkpoints (§14 rule 1 gives the derivation); a checkpoint's witness time, the k-th latest of the cosignatures counted, need not grow with the size when the witnesses cosigning differ, so no binary search over it is sound. Every proof is computed from tiles fetched at most once each.