| Commit message (Collapse) | Author | Age | Files | Lines |
| |
|
|
|
|
| |
A party's key is `ssh-ed25519` or `ecdsa-sha2-nistp256`; the client signs with a private
key file or through an ssh-agent holding the key, given its public key. Code of its own
signing with ECDSA makes `s` low, which `ssh-keygen` does only half the time.
|
| |
|
|
|
|
|
|
| |
signature low-S
A key is `ssh-ed25519` or `ecdsa-sha2-nistp256`, spelled alike; an ECDSA signature is
over SHA-256, its `s` low and `r` and `s` SSH's shortest mpints, so that it is spelled
one way. The vectors and the agent test, among the harness's.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
| |
A key held in hardware is never a file: only an ssh-agent signs with it. Given a public
key as `--key` (a `.pub` file, `ssh-ed25519` or `ecdsa-sha2-nistp256`), the client asks
the agent at `SSH_AUTH_SOCK` to sign what SSHSIG signs (a sign request with the key's
blob, no flags) and writes the blob around the agent's signature as `ssh-keygen -Y sign`
does. An ECDSA signature the agent gives with a high `s` is made low, the other of its
two spellings, which the federation takes. What it makes is checked before it is used.
A private key file signs as it did.
A test starts `ssh-agent`, adds an ECDSA and an Ed25519 key to it and deletes their
files, signs through it, and has both continuum and `ssh-keygen -Y verify` check each
signature, one of an agent's high-S answers among them. Without OpenSSH it asks nothing.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
A party's keys may be held where no file has them, in a Secure Enclave or a phone, and
those are ECDSA keys on NIST P-256. Everywhere a party's key counts (a version's keys, a
key set, the key an event is signed with) such a key is taken beside an Ed25519 one,
spelled as `ssh-keygen` writes it, without a comment: `ecdsa-sha2-nistp256`, a space,
and the base64 of its SSH encoding, its point uncompressed and on the curve.
Its signature is SSHSIG as an Ed25519 one is, hashed with `sha512`, its inner signature
over SHA-256 as SSH signs with such a key. ECDSA signatures are malleable: of `s` and
the curve's order less `s`, both check. So the federation takes one spelling alone: `s`
low, at most half the order, `r` and `s` each SSH's shortest mpint, and the blob reading
back to itself as an Ed25519 one does. What anyone makes of a party's signature is then
none, as before.
The vectors are a key `ssh-keygen -t ecdsa -b 256` made, a first version naming it, and
a write and a key set `ssh-keygen -Y sign` signed with it, each taken; the signature's
high-S twin, which checks as ECDSA, and its `r` spelled longer are none. Ed25519 keys and
signatures are spelled and checked as they were.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
| |
In a swarm holding a store, the snapshot names the node's party, and the
document box shows what counts as the node reads it, read every 5 s: the
current version, the parties with their keys and nodes, the rules, the
values at places as a tree with who writes there, the proposals on the
version with where each stands, who voted what and what its version
changes, and what the node refused. `document` beside `remake…` shows the
document underneath.
Where the node votes for its party by itself, a proposal that can still
pass has a vote of each kind, cast through the node on a second click.
The page writes no values: a party signs its writes with its key.
|
| |
|
|
|
|
| |
`GET /events` names the party the node is of (`party`, `--store-party`) and whether it
votes for it by itself (`votesByItself`, `--store-vote-key`), and so casts a vote by
hand (`POST /admin/events/vote`): what a page offering votes through the node asks.
|
| |
|
|
|
|
|
|
|
| |
`continuum-party` takes its options (`node`, `token`, `key`, `record`:
`config::PARTY_OPTIONS`) on the command line and in configuration files of the node's
format: `--config`, repeatable, arguments winning, `--unset`, includes and imports. The
configuration's loader takes the options it reads as a table (`config::with_options`,
`config::merged`, `file::load_with`), the node's or the client's, and a key naming
none of them is an error in either; `node` and `token` are secrets, never logged.
|
| |
|
|
|
|
|
|
| |
`continuum-party proposals` lists the proposals on the current version at the node,
each with whether it passed or is dead and the parties voting `true` and `false`, as
`GET /events/counts` names them, and what its version changes of the current one, read
from an event proposing it, its signature checked: each field whose value differs, and
of `keys` and `nodes` each party's (`client::changes`).
|
| |
|
|
|
|
|
|
| |
`GET /events/counts` gives each proposal on the current version the parties voting
`true` and `false` (`yes`, `no`), whether it passed and whether it is dead (`passed`,
`dead`), as the node reads its votes (`State::tally`, which the fold judges by too), so
that reading where a vote stands takes no fetch of every vote. A party's client still
decides its votes by the votes it checks itself.
|
| |
|
|
|
|
| |
How rules match, a namespace each, zones and blocks a party holds by its name, shared
places given by rules of their own and kept apart from party names, what rules cost in
votes and size, and the krebs registry's rules as an example.
|
| |
|
|
|
|
| |
Reading what counts and when to read again, writing through the party's client or as
events of its own spelled and signed as the federation does, when a write counts, one
writer at a place, keeping a namespace in step, and the store API refusing writes.
|
| |
|
|
|
|
| |
Beside what every node needs watching: a version a node refused, a node without its
store, the proposals and the version, the members, the events beyond the checkpoint, and
the store's log lines at warn and error.
|
| |
|
|
|
|
| |
Upgrading the nodes of a federated swarm, each party its own, close together; what the
federation's number names, fixed by vectors; a version of another federation refused,
and moving to the next one by a version.
|
| |
|
|
|
|
| |
Compactions only, the electorate among the store's members, the snapshot holding the
store read at the base, what a node puts again after a switch, the lower of two epochs,
which epochs a node rejoins, and a swarm that never remakes.
|
| |
|
|
|
|
| |
What `GET /events/refused` shows and of which kinds, the events a refused change
carried, what the store file keeps across restarts, having a node drop events and take
them back, and when an operator does.
|
| | |
|
| |
|
|
|
|
| |
Setting up a node to vote for its party, its key and the party's one record, voting by
hand through it, its rules for following, proposing checkpoints and voting `false`
beside, what it keeps to, and what its log says.
|
| |
|
|
|
|
| |
The current version may name a checkpoint, whose heads are behind: a version naming them
again is never written. Writing a version leaves it out unless the version moves the
store on.
|
| |
|
|
|
|
| |
The next version begun from the current one, and recipes as jq filters for letting a
party in, taking one out, giving and taking back a place, zones and blocks, and keys
named anew; what a party changes by itself; and a version that only moves the store on.
|
| |
|
|
|
| |
Who a party and the adversary are, the three promises in plain words, what isn't
promised, and what that asks of a party, an operator and an application.
|
| |
|
|
|
|
|
| |
When a group forks, choosing the heads, the fork's version, its root as a node builds
it, starting the fork's nodes and beginning a record there; what a node holding the
history finds of a fork's root; and following a fork, coming back, and groups that
parted coming together.
|
| |
|
|
|
|
|
| |
A version a node refused by what it took before, finding from the parties' records who
voted twice, having a node drop one side's version and take the other's, answering by a
fork, and what keeps a node from holding its store, syncing, taking an event, or
starting.
|
| |
|
|
|
|
|
| |
What a move to a checkpoint keeps and loses, a version only moving the store on and the
heads to name, a node proposing checkpoints by its operator's rules, backing only heads
that leave out nothing held for a while (which a node voting by itself checks and a
party's client doesn't), signing again after a move, and nodes that weren't there.
|
| |
|
|
|
|
| |
The keys a version names, kept apart with the party's record, and those of its key set,
signing its writes; changing a set and signing again what should stay; changing the keys
a version names; a stolen key of either kind; and the node key, which is no party's.
|
| |
|
|
|
|
|
| |
Writing a version from the current one, its `since`s and what makes one none, proposing
it, voting through the party's client by its record and what the client refuses to
cast, voting through a node that votes for its party, a lost record, and when a proposal
passes or dies, with the counts for some numbers of parties.
|
| |
|
|
|
|
| |
Places and the rules naming their writers, a write through the party's client and what
it may hold, what counts and what stops counting, the refusals a node names, signing
again what a move refused, and what `GET /events/counts` shows.
|
| |
|
|
|
|
|
| |
What a node of a federated swarm does otherwise than any: its store options and file,
members syncing with members only, its API letting in whoever its operator lets in to do
everything, the store API refusing writes, joining by ID and from a pinned checkpoint,
and what it writes by itself.
|
| |
|
|
|
|
|
| |
`docs/guides/federation/` holds the guides to a federated swarm, the design saying what
the rules are and they how to live by them. The first: two parties start a federation, a
node each, write, read, and let a third party in by their votes. The README points to
them.
|
| |
|
|
|
|
| |
The federation spells a key without a comment, so a key set holding a line's comment is
none. `continuum-party keys` takes each key as an `authorized_keys` line, one argument
each, and writes it as the federation spells it.
|
| |
|
|
|
|
|
|
|
|
| |
A record casts nothing on the version current when it began, as a `true` sent before
may be held back somewhere. A federation's first version is current from its start, so
a record begun at a node casts nothing on it, and with every party's begun so, no
proposal on it can pass. `continuum-party init PARTY --root FILE` begins a record from
the file the store's swarm starts from, for a party that never voted in it
(`Record::before`): nothing was sent before it, and it casts on every version, the
first too. A node voting by itself takes such a record as its `--store-vote-record`.
|
| |
|
|
|
|
| |
What a federation is used for is read and written through a node's API: kartei's
entries are signed in by their parties and read from what counts there, with no stage
of their own.
|
| |
|
|
|
|
|
|
|
| |
The registry holds each kartei namespace in its party's, a place per file. What kartei's
consumers read as one for all (host and user names, the names hosts go by, addresses and
blocks in every net but `internet`) is shared, at places of its own, given by krebs's
rules: a party's by its name, and what kartei gives it beyond them by a rule each in the
first version. What kartei's consumers read is written out from what counts, but for
what names an identifier the current version doesn't give its party.
|
| |
|
|
|
|
|
|
|
|
|
| |
A rejoin makes the node's document writable again only as it ends, in the
lock of the swap, once the node checked the epoch (`Holding::follows`) and
follows it or gives it up. The store's worker reads nothing, and writes
nothing, while the document isn't writable, checked in the lock it reads
under. Whether a rejoin runs isn't enough: its state is taken up for its
last checks, while the epoch's document is still the node's, and a store
started from that document would keep the checkpoint it read there, and put
again what it took into the document the node goes back to.
|
| |
|
|
|
|
|
|
|
|
| |
A node with an empty document can't tell an epoch made up from another it
can't check: either way it takes the snapshot's checkpoint only where its
operator named or pinned it. The others move to a checkpoint and compact;
f, joining and pinning nothing, doesn't take their epoch, and g, pinning
the checkpoint, takes it and reads what they read. A made-up epoch served
by d, an honest node besides, is row 31's alone: d follows the others'
epoch wherever it reaches them.
|
| |
|
|
|
|
| |
Reaching the others, d rejoins their epoch, the lower, as any node holding
a store does, and e, reaching only d, finds their epoch there, not d's. Cut
off from them, d stays on the one it made up.
|
| |
|
|
|
|
|
| |
Of a lower one, the others try to rejoin it every so often, as in row 31,
and f, rejoining their epoch, finds them away mid-sync and gives up for
that, not for its checkpoint. Of a higher ID, they leave it alone; e,
reaching only d, still takes it, as one joining takes the newer generation.
|
| |
|
|
|
| |
Its target, attempts, whether the node rejoins now, and why the last try
failed, before the lines of the remake records.
|
| |
|
|
|
|
| |
d, serving the epoch it made up, puts again there what its store holds, as
every node holding a store does: e, judging every event, reads what d reads,
the checkpoint the others moved to among it, not the root alone.
|
| |
|
|
|
| |
It builds on tv's write, the checkpoint's head: one built on the root isn't
above the heads of the checkpoint the nodes moved to, and they refuse it.
|
| |
|
|
|
|
|
|
|
| |
While a node rejoins, its document is that of the epoch it tries, which it
follows only once it checks it (`Holding::follows`). The store's worker
reads nothing of it, and writes nothing, while the node rejoins: else the
store, starting there from the snapshot's checkpoint, would take one the
node neither builds nor has pinned, and keep it should the node give up
the rejoin.
|
| | |
|
| |
|
|
|
|
|
|
|
|
| |
d serves an epoch of the next generation it made up, of a lower ID than the
others', its snapshot holding the root as the document stood before the
checkpoint they moved to. A node joining with nothing that reaches only d
takes it, the root being what its operator named, and reads only what it
holds (15); one reaching only the others takes not their epoch, whose
checkpoint it neither builds nor has pinned (15); the others try d's, find
its root before their document's checkpoint, and stay on theirs (31).
|
| |
|
|
|
| |
`testing::serve` switches a node to an epoch whose document is a snapshot
it built itself, as a node serving a made-up epoch would.
|
| | |
|
| |
|
|
|
|
|
|
|
|
|
|
|
| |
Simulations of the store's attack rows on remakes (`docs/store.md`,
Attacks): a snapshot other than its base's isn't followed (11); one
coordinator's two decisions for an epoch, shown to different nodes, end on
the lower epoch (13); a node away while the others switch rejoins and puts
again what it wrote meanwhile (16); after a compaction whose snapshot holds
a checkpoint, a node away all along follows only once its operator pins it
(24); a compaction whose base comes before a checkpoint, switched after
nodes moved to it, leaves them there, and a node starting with nothing
reads the new document to it (28); a member deciding many compactions at
once moves every node to the lowest epoch, losing no event (30).
|
| |
|
|
|
|
|
|
| |
For simulations of a coordinator that doesn't keep to the protocol:
`testing::propose_again` proposes a remake's proposal again under a new ID,
whatever is open, and `testing::commit_as` commits a remake at the node's
heads now, whatever the votes and another decision, to a given epoch or to
the epoch of the snapshot the node builds there.
|
| |
|
|
|
|
|
|
| |
Of two epochs decided for one, a node holding a store follows the lower ID,
and a node on the other rejoins it, however many peers are on each
(`docs/store.md`, Remakes): one peer on it is enough, so that two sides of
unequal size come together. A made-up epoch keeps a node apart at worst, and
makes it take nothing it wouldn't (`Holding::follows`).
|
| |
|
|
|
|
| |
A swarm holding a store compacts: events written beyond the base, on nodes
that switch later, are put again in the new epoch, and every node holds
every event, reads the same, and refused no change.
|
| |
|
|
|
|
|
|
|
|
|
|
|
| |
builds
A node of a swarm holding a store rejoining an epoch (`docs/store.md`,
Remakes) follows it only where its snapshot has the swarm's policy and
store, and holds the node's document's checkpoint, one it builds from that
document, or one its operator pinned; with an empty document, the root of
its store too (`Holding::follows`). A made-up epoch holding another, the
root after the store moved on, say, would leave it holding events whose
history nobody puts again: it stays on its own, as when a rejoin's check
fails, and tries again later.
|
| |
|
|
|
|
|
|
|
|
| |
In a swarm holding a store, of two epochs decided for one, by a
coordinator that wrote two decisions or by remakes decided at once, a node
follows the one with the lower ID, and a node on the other rejoins it,
however many peers are on each (`docs/store.md`, Remakes): a node switches
to the lower of two committed remakes of its epoch, follows the lowest of
several newer epochs, and a ready node rejoins a lower one of its own
generation that enough peers serve.
|