aboutsummaryrefslogtreecommitdiffstats
path: root/src/federation/party.rs
Commit message (Collapse)AuthorAgeFilesLines
* federation: votes on the events proposing a checkpoint above its headstv32 hours1-2/+8
| | | | | | | | | | | | | | | Anyone could propose a checkpoint's version again, by an event beside its heads. A node voting by itself, and a party's client, built a vote on every event proposing what it voted on, so every vote was beside the heads, and no version event written on them was taken: the checkpoint could never move the store. And the voters' rule refused it once that event was held for a while, as the heads left it out. They vote on the events proposing it that are above the heads it names (`State::proposing`), which `GET /events/counts` lists as `proposals`; where there are none, `none` says so, the node casts nothing and the client says why. The voters' rule leaves proposals and votes aside, as they lapse with the move. Row 70 is tested (`federation_attack_70`).
* events: why no party's client backs a proposaltv38 hours1-0/+3
| | | | | | | | | | | | `GET /events/counts` gives each proposal on the current version `none`: why a party's client backs it not (`client::backable`), where it is no version as this node reads it, none changing the current one, or one naming the heads of the current one's checkpoint; else `null`. So a node shows that a proposal is none, and why, before it passes: one that passes all the same is never written, or, no version here, the node stops at its version event. The dashboard shows it with the proposal, and `continuum-party proposals` says it by the federation the client knows. Row 48's test checks what a node shows of the proposal.
* continuum-party: proposes only what a party may backtv45 hours1-8/+5
| | | | | | | | | One check (`client::backable`) decides what a party's client proposes and what it votes `true` on: a version, changing the current one as a version must, whose checkpoint, where it names one, names none of the heads of the current version's checkpoint, as a version naming those again is never written. A proposal nobody may back is refused before it is signed, saying why.
* continuum-party keys, nodes: shown given no change, --set, --forcetv45 hours1-46/+110
| | | | | | | | | | `keys` and `nodes` alone (`--list`) show the party's key set or node list as it counts at the node, one a line, without a key. `--set` writes it whole, none twice, in place of the arguments that did; `--add` and `--remove` change it as it counts. A set or list left empty, whichever way (`--set` with none, `--remove` of the last), is written with `--force` only: none of the party's writes count without keys, nor its nodes as members without a list.
* continuum-party: votes and proposals checked for the key a version namestv46 hours1-11/+16
| | | | | | A vote or a proposal is signed with a key the current version names for the party, as a key set and a node list are: the client checks it before it signs, and records nothing where the key isn't one.
* continuum-party keys, nodes: --add and --remove, and the key they needtv46 hours1-18/+198
| | | | | | | | | | | | | `keys` and `nodes` write the party's key set or node list whole, or, with `--add` and `--remove`, the set or list as it counts at the node with those added or taken off, each of which must change it; the client says what it writes. Node IDs are checked as the federation spells them. A set or list is signed with a key the current version names for the party: the client checks that first, and where it isn't one, or the party is none of the version, says that only a version naming the party's keys or list anew changes them, which a party proposes and the parties pass.
* continuum-party propose: the proposal's hash, and --yestv46 hours1-6/+18
| | | | | `propose` says the proposal's hash, the version's, which `vote` takes; with `--yes`, it votes `true` on it too, by the record, as `vote` does.
* continuum-party propose: only a version changing the current onetv46 hours1-1/+8
| | | | | | The client proposes a version only where it changes the current one as a version must (its number, the hash it names, each `since`), and says why it doesn't otherwise: no other can pass.
* continuum-party next: the version after the current one, to changetv46 hours1-0/+44
| | | | | | | `next` prints the current version numbered on, naming its hash as the version it changes, and without the checkpoint it names, whose heads are behind: what a party changes and proposes. The guides begin a version with it.
* continuum-party: why waiting for the ssh-agent may blockecdsatv46 hours1-0/+4
| | | | | The client signs one event at a time and does nothing else meanwhile, and an agent may wait for its user as long as that takes.
* continuum-party: a key the ssh-agent holds, given itselftv46 hours1-18/+105
| | | | | | | | | `--key` gives a public key itself, an `authorized_keys` line, as well as a file of them: of a file of several, the first signs, with a warning naming it, and another is given itself to sign with it. An agent that doesn't hold the key given signs nothing, and the client stops before it records or puts what it would have signed, saying which key it asked for.
* continuum-party: signing through an ssh-agentslopulus3 days1-14/+41
| | | | | | | | | | | | | | 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.
* keys: a party's key may be ecdsa-sha2-nistp256, its signature low-S onlyslopulus3 days1-1/+2
| | | | | | | | | | | | | | | | | | | | 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.
* continuum-party: options from configuration files, as the node'stv3 days1-44/+70
| | | | | | | | | `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: where each proposal stands, and what it changestv3 days1-0/+58
| | | | | | | | `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`).
* continuum-party keys: a key set from authorized_keys lines, comments left outtv3 days1-3/+11
| | | | | | 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.
* client: a record begun from the store's root casts on its first versiontv3 days1-5/+25
| | | | | | | | | | 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`.
* federation: votes build on the events proposing what they vote ontv3 days1-3/+5
| | | | | | | | | | A node voting by itself, and a party's client, signed a vote on the heads the node held: where those held what is beside a checkpoint's heads (a party's writes made while the swarm was parted, say), the vote wasn't above them, and a version event written on it was refused, so the checkpoint never moved, though it passed. Both now vote on the events proposing what they vote on, and a node proposes a checkpoint on the heads it names: so their votes are above those heads wherever the proposal is.
* continuum-party: a federation's root, a fork's made through a node, and checkedtv3 days1-6/+110
| | | | | | | | `root FILE`: the root of the federation whose first version the file holds, as the file its founders start its swarm from (`--store-root`). `fork FILE HEAD...`: the root of the fork at those heads by the version the file holds, with the events it keeps, as a node holding the federation builds it (`POST /admin/events/fork`). `check FILE`: what a node finds of the fork whose root the file holds (`POST /events/fork`).
* continuum-party: a vote through the node that votes for the partytv3 days1-2/+31
| | | | | | | A party that has a node vote by itself votes by hand only through that node: `continuum-party vote PROPOSAL yes|no --through` asks the node to cast it (`POST /admin/events/vote`), by the record the node keeps, without a key or record of the client's own.
* continuum-party: a party's client of a federationtv3 days1-0/+459
A second binary, behind the `federation` feature: a party's client, which signs its party's events with one of its keys (`--key`, an OpenSSH private key file), puts them through a node's API (`--node`, its user and password in the URL, or `--token`), and keeps its party's record (`--record`), by which it votes, written before a vote is sent (`federation::party`, run by `continuum::party`): * `init PARTY` begins a record of `PARTY` on the version current now; * `write PATH VALUE`, `keys KEY...`, `nodes NODE...` and `propose FILE` sign events on the node's heads, recorded, and put; * `vote PROPOSAL yes|no` votes on the proposal of that hash on the current version, by the record: with a `true`, the votes on its party's earlier proposal, from the node, checked, kept as the nays that freed it; * `again` signs again, of the latest event it signed at each place, its key set and its node list, what the node refuses as not above its checkpoint's heads, or as built on one it refuses; * `twice RECORD...` names, from the records of parties' clients, a party that voted twice. The feature brings reqwest along, the client's HTTP.