1,065 Matching Annotations
  1. Aug 2025
    1. these differences could circulateand overwrite each other repeatedly

      In a simplistic implementation of shared mutable state atop gossip - could be so. In any CRDT they'll converge to the same value.

    2. A certificate authority or web-of-trust canhelp establish verifiable identities.

      Verifiability != credibility. Pub key is a verifiable ID. Is it credible? That's up to you to decide.

    3. Gossipsacrifices consistency for availability

      Ehh, it doesn't? It's just a mean of passing info around. You could have one "master" machine and a gossip network that receive updates to its state. You could have a distributed consensus algo atop gossip, so every peer has a consistent ever-growing tx log.

    1. Findings suggest that as long as all documentsfit within the extended context length, traditional RAG systemscan be replaced by these long-context models

      Ehh, man, [7] finding is that Self-Route efficiency is comparable to LC with way less tokens used.

  2. Jul 2025
    1. A protocol stack (or protocol suite or protocol architecture) is a collection or group of subprotocols that work together to achieve complete communication between two or more computers connected in a network
  3. May 2025
    1. to avoid, among otherproblems, the ‘dead sailors problem

      In KERI context, it's validation of a new current threshold (on rotation), such that it's possible to satisfy it.

    2. UDP

      Um, how is UDP different in overcoming mentioned vagaries?

      If both behind symmetric NATs - still impossible to communicate. And hole-punching may be required for other NATs. Since receiver's NAT likely will drop packets from IPs that receiver wasn't sending packets to.

  4. Apr 2025
    1. The use of a DAG-like structure to solve consensus has been introduced in previous works,especially in asynchronous networks. Hashgraph [ 4 ] builds an unstructured DAG, with eachblock containing two references to previous blocks, and on top of the DAG, the miners runan inefficient binary agreement protocol. This leads to expected exponential time complexity

      What kind of complexity is meant here?

      I guess voting, as witnesses of r+1 vote on each witness of r. But that's n^2, quadratic, and can be computed incrementally..

      Latency is somewhat logarithmical as f(nodes) https://hyp.is/1q-pjhaiEfC4ggdV4IIKxA/arxiv.org/pdf/1912.05895

  5. Mar 2025
    1. We can generalize the IID to an interaction context header, which may contain the IID plus any other information beneficial to gluing together the messages in an interaction.

      This information (IID) seems to be useful as a "hint" to the receiving party, so it can lookup the interaction. Storing it / having it as part of a signed content - seems redundant, given causality is part of content already.

    2. Furthermore, note that A does not need to know the B side of B's relationship with C, and B does not need to know the A side of A's relationship with C.

      Doesn't A need to auth C0 to form relationship with C1, which A knows is in relationship with B1? (mayb it's not on the record, but I thought that A and B need to tell each other their relationship with C, so each can auth C0 and C1 to befriend)

    3. letter of introduction for a new relationship

      Another flow may be for a common friend to introduce his friends to each other.

      E.g., given Alice <> Bob <> Carol

      Bob could share Alice's AID in DM to Carol, and Carol could request Alice to befriend, which will be mediated by Bob.

      So Bob recieves in DM "I, Carol, want to befriend you, Alice, via C1", and forwards it to Alice.

      This may be encrypted to Alice's A0.

      Downside is that Bob may learn something about Alice<>Carol relationship being setup. Although Bob initiated it by sharing Alice's A0, so kinda knows it already.

    4. This makes the database zero-trust because it is signed at rest

      Interesting.

      How does signing happens?

      E.g., on change to IP address of A2 it signs and ifroms C0.

      But then A2 can be behind a symmetric NAT, so it's IP is f(C0) - need C0 to tell A2 it's IP to C0.

    1. The downside of using hashes as IDs is that they requiremore space than other schemes. To avoid the storage cost ofexplicitly materialising all of the hashes, it would be possibleto design a compression scheme that recomputes hasheswhen necessary, and store only the information necessaryto perform this recomputation.
  6. Feb 2025
    1. Once the OK messagefrom a process in Pi is received, it can be considered againas a candidate to which to send a SPREAD message (movingit to Si)

      Uh, were message be lost in transmission -> no OK will be received -> pi won't ever send any more messages to it. It can be SPREAD message loss or its reverse OK message loss.

      Essentially, on each message loss there's one less link in the connection graph, until it gets fully disconnected.

      That is, if we don't remove processes from P. E.g., when learning that it learned rumors that we sent (e.g., from others).

    Tags

    Annotators

  7. Jan 2025
    1. SAIDs MUST be encoded as a CESR [CESR] Primitive. As defined above, a CESR Primitive includes a pre-pended derivation code that encodes the cryptographic suite or algorithm used to generate the digest.

      ^

  8. Dec 2024
  9. Oct 2024
    1. Anarchy is the total absence of governance, where no governmentnor laws exists. In this scenario individuals can interact peer-to-peer, butsince no coordination exists, it is impossible to scale up communication andproductivity.

      Eh, what stops them to come to consensus regarding some topic?

      Swiss folks interact peer-to-peer, passing laws.

    2. This means that thecontroller might have to take measures, like revoking ij and kl.

      Why so? They're not in the KEL anymore.

      And those who learned them will accept superseeding recovery, so maliciously issued certificates out they go.

    Annotators

  10. Sep 2024
  11. Jul 2024
  12. Jun 2024
    1. It is often the case that Atoms need to wrap the functionality of existing python libraries, or that Atoms that represent abstract syntax trees need to be compiled down to bytecode.

      This alone would not be enough to be reproducible.

      One also needs to specify execution environment.

      E.g., version of Scheme to be used.

      The Nix/Guix way.

    2. Link Node "edge label" Link Node "from vertex" Node "to vertex"

      Link could contain Edges, right?

      Overall, seems it'll be useful for Link to not care about the specific Node type (ConteptNode) for example.

      As otherwise we'd need to make Link and others polymorphic.

      Perhaps polymorphism can be defined once for an abstract Atom type, which can hold Edge or a typed Node.

      E.g., Link Atom Concept Node "edge label" Link Atom Concept Node "from vertex" Atom Numebic Node 42

      Although, I guess a Type hierarchy can be used, defining that every type inherits Atom type. Akin how in Java every class inherits Object.

      Then it's possible to make Link expect Atoms.

    1. However, if an atom is added to B that does not exist in A, then it will be in atomspace B only. If later it is added to A, then two independent copies shall exist: one in B and one in A. Its not quite clear if this is the 'right' thing to do; but defacto, this is what happens

      Re-write refs to Atom X in B to point to the newly added same Atom X in A?

    1. One of the keys might hold the truthiness of this statement. Another key might hold its probability.

      Aren't these two about the same? Where true is 1.

      And say probability = 0.6 is a more fine-grained expression of truthiness.

      This unimportant nitpick aside, can you annotate say truthiness = true with probability = 0.6?

      (probability (truthiness (owns Jack computer) true) 0.6)

    Annotators

    1. This start-over style of key rotation may well be one of the main reasons that PGP's web-of-trust failed [WOT]. Without a universally verifiable revocation mechanism, then any rotation (revocation and replacement) assertions either explicit or implicit are mutually independent of each other. This lack of universal cryptographic verifiability of a rotation fosters ambiguity at any point in time as to the actual valid mapping between the identifier and its controlling keypair(s). In other words, for a given identifier, any or all assertions made by some set of CAs may be potentially valid
    1. An Authentication Service (AS) that enables group members to authenticate the credentials presented by other group members.

      This is weird. It's meant to be a p2p design, yet it relies on a CA to approve you. It's a single point of failure. May be corrupt.

    1. The Delivery Service cannot guarantee that application messages will arrive in order within the same epoch. To address this, applications can configure the out_of_order_tolerance parameter of the SenderRatchetConfiguration. The configuration can be set as the sender_ratchet_configuration parameter of the MlsGroupCreateConfig
    2. The Delivery Service cannot guarantee that application messages from one epoch are sent before the beginning of the next epoch. To address this, applications can configure their groups to keep the necessary key material around for past epochs by setting the max_past_epochs field in the MlsGroupCreateConfig to the desired number of epochs

      This is not reliable, no certain knowledge that any further messages won't come.

    1. refinement to this approach, which reduces the amount ofinformation exchanged and the size of the tables, is to have the DBMPsexchange only the oldest of the entries in the first table (oftimestamps of last modifications received from other DBMPs).

      Resembles delta-based state CRDTs optimization technique, where only latest vals are broadcast.

    1. In [2], Berners-Lee and Connolly proposed Delta, an ap-proach in which the RDF-Graphs differences are calculatedon their serialized forms

      This resembles the way Git works, we have snapshots and deltas are calculated out of them.

      Ironically, that made Git use deltas more, not less.

  13. May 2024
    1. Given a set of n agents, at most f of which arefaulty and the rest are correct, a fault-resilient supermajority, or supermajorityfor short, is any fraction of agents greater than n+f2 . For example, if f = 0 thena simple majority is a supermajority, and if f < 13 then 23 is a supermajority
    1. a master key (MSK) that serves as the user’s identity in cross-signing and signs their other cross-signing keys

      Is a point of failure / weakest link in this chain - compomise of one key is enough to compromise Alice's identity.

      Also, requires it to be replicated across her divecise, if she wishes to add new device from any device.

    1. All API endpoints within the specification are versioned individually. This means that /v3/sync (for example) can get deprecated in favour of /v4/sync without affecting /v3/profile at all. A server supporting /v4/sync would keep serving /v3/profile as it always has

      It's cool, I guess. But then leaves one wonder, are they compatible? How to tell? There should be a kind of manifest then that maps v4 to "playing well together" granular vs.

    2. For example, if /test were to be introduced in v1.1 and deprecated in v1.2, then it can be removed in v1.3.

      That's.. not intuitive for those familiar with semver.

      Like, bump it to 2.0 instead. It's a breaking change. Everybody will get it. What's the point of the second digit if it guarantees "maybe nothing will be broken" - tell it explicity, is it or is it not.

    3. Events exchanged in the context of a room are stored in a directed acyclic graph (DAG) called an “event graph”.

      Well, better call it "event DAG" then?

      Or, "event hash-DAG" / "Merkle-DAG".

    4. signing the message in the context of the graph for integrity

      That's weird. User's not in chare of creating an event (as user-generated event is not a complete event in Matrix model, it lacks causal history).

      Relying for creation of an event on a server means you need to be online in order to use apps.

      Better: let user's device be enough, so user can create events offline, sync it later. Server is dumb - just relaying it to user's friends.

    1. In some critical interactions, however, the trade-off between convenience and security madeby reusing signing keys for multiple interaction events may not be acceptable. In this case, amore secure approach is to combine an interaction event with a rotation event by adding a pay-load data structure to the rotation event.
    2. When sufficient agreement may occur on more than one version of an event then a valida-tor may not be able to determine which version is authoritative in order to either to hold the con-troller accountable or to reconcile that event with respect to other validators

      Crazy idea: rotate key after each interaction event.

      Thus an interaction is deemed valid only if the key's been rotated. Although what's the use if keys are non-extractable in a HSM. Their security = security of the pre-rotated key. I.e., given no hardware attack vectors, decive gets stolen - both approaches are compomised.

    3. but where the witnesses are not under its control such that the a validator or originalcontroller may nonetheless trust that there may be no more that F faulty witnesses

      I.e., witnesses may be unaffiliated, providing trust.

    4. The controller is responsible to promulgate a mutually consistent set of receipts, i.e. a suffi-cient agreement of size M ≥ M C .

      Why? Witnesses can gossip with each other acks about events they learned from the controller.

      As mentioned further.

    5. Suppose instead that N = 3F + 1 , then a correctagreement is guaranteed as before but the agreement will have 2F + 1 nodes (quorum size) anddespite some F of those 2F + 1nodes becoming unresponsive, the remaining F + 1 honest andresponsive nodes will be able to propagate that correct safe agreement to the next round

      The reason behind N=3F+1, is that F nodes may behave duplicitly. So we need ((N-F) / 2) + 1 to have it safe.

    6. But there is no guarantee that the nodes in agreement (quorum) will knowthey came to agreement in a subsequent round because as many as F of the nodes in agreementin a given round may subsequently become unresponsive in the next round

      But we have f+1 for agreemend, so it will be live.

    7. An escrow cache of unverified out-of-order event provides an opportunity for malicious at-tackers to send forged event that may fill up the cache as a type of denial of service attack. Forthis reason escrow caches are typically FIFO (first-in-first-out) where older events are flushed tomake room for newer events.

      This may misfire, when there's a ton of valid events to sync, whose amount is greater than the cache limit.

      May happen when adding a new witness, requiring to sync the entire history. (do we need to provide it the entire history though? only the last not-yet-verified events are of interest for the controller to be signed by the witness)

    8. The specific details of this recovery are explained later (see Section 11.6). In gener-al, the witnessing policy is that the first seen version of an event always wins, that is, the firstverified version is witnessed (signed, stored, acknowledged and maybe disseminated) and allother versions are discarded

      Seems to harm convergence

    9. the message payload inside an IP packet includes aunique identifier provided by the identity system that is exclusive to the sender of the packet

      Including identifier in message, coupled with key-pair->identifier mapping is meant to give authenticity - that message came from the identifier.

      Problem 1: keypair will be eventually revoked, how to convey authenticity of messages before revokation and not after?

      Solution 1.1: Issue event with logical revokation time. I.e., revocation is issued on Fri, but meant to take place logically on Thu.

      Then, messages received on Fri and forward, signed by that key-pair, will be deemed not authentic.

      Solution 1.2: Use multiple signatures to prove authenticity.

      Then, even if one gets revoked - authenticity holds.

      Con: metadata overhead, need for keypair agents to be connected, higher delay - meh.

      Is there value to include identifier, given recepient still needs to resolve mapping keypair->identifier and keypair can be binded to one identifier only.

      Yes, identifier hints how to resolve it.

    10. Also more recently theTrusted Computing Group (TCG) uses the term “implicit identity” and “embedded certificateauthority” to describe the process whereby device identifiers are automatically generated by theassociated computing device [143]
  14. idp2p.github.io idp2p.github.io
    1. In contrast, a relay is an entity that passes along encrypted messages without understanding or decrypting them. It's focused on network routing only.

      Mediator is a "smart" relay, in that it knows the adressee and can relay with that in mind.

      Relay, on the other hand, does not know the destination, it works deterministicly. Iff that relay would always route messages to Bob, then Alice doesn't need to tell anything specific to the relay.

    1. Again, the discloser can retain the ‘Admit’ message as non-repudiable digital proof that the disclosee has admitted the disclosure of the ACDC

      What stops disclosee to not send the "Admit"? Thus being repudiable to "I haven't received the promised and agreed upon info".

    1. r can provide an API where transaction events or their seal references and their KEL seal references can be looked up by the SAID of the ACDC associated with the transaction event

      I guess lookup is meant to be specified, and not ad-hoc. So software can do it without human (programmer) guidance.

    2. When an Edge block does not include a SAID, d field, then the node, n field must appear as the first field in the block.

      Strange. All we need is d. Introducing n makes it not uniform. I'd expect there to be d solely, replaced at run-time with it's content.

    3. Without the entropy provided the UUID, u, field, an adversary may be able to reconstruct the block contents merely from the SAID of the block and the Schema of the block using a rainbow or dictionary attack on the set of field values allowed by the Schema

      I.e., knowing a schema makes it possible to derive content from its hash.

  15. matrix-org.github.io matrix-org.github.io
    1. but limiting the conference to 7 or 8 participants given all the duplication of the sent video required. In Element Call Beta 2, end-to-end encryption was enabled; easy, given it’s just a set of 1:1 calls.

      I imagine having to transmit stuff to every peer would not work well for low-bandwidth devices.

      Also, complete connectivity graph is a LOT of connections.

      Additionally, given one channel fails - recipient doesn't see content, while others do. (they could have broadcasted it, hey!)

      Also, won't scale for streaming.

    2. So if the network roundtrip time to your server is even 100ms, and Sliding Sync is operating infinitely quickly, you’re still going to end up showing a placeholders for a few frames

      What stops loading context around the window?

      Better off, start from windows position and sync everytihng from that priority.

      I.e., prioritize what gets replicated by how user's acting.

    3. The European Union’s Digital Markets Act (DMA) is a huge step in that direction - regulation that mandates that if the large centralised messaging providers are to operate in the EU, they must interoperate
    1. However, certain algo-rithms executed on the MEG do not scale well with thenumber of parent events, i.e., they can become very re-source intensive, especially when old parts of the MEGare referenced as parents [8]. In practice, the maximumnumber of parent events therefore has to be restrictedto a finite value d.
    1. the blocklace stores notonly valid blocks but also blocks that constitute a proof thattheir creator is Byzantine

      Only the first equivocation evidence is needed to be included, right? Subsequent equivocations can be buffered.

    2. Thus only the valid subset of theblocks will be considered as state by the replicated abstrac-tion (the CRDT).

      Note: here valid seems to refer to both well-formed and valid.

      Detection of this malformedness is possible as funciton(block). Thus a correct node will not accept such block's ops and won't make more atop.

      Additional check is required to ensure that nodes do that^.

      Nodes that do not comply are byzantine as well, and their ops can be "not observed" as well.

    3. Thus the harm a Byzantine agent may cause is limited to afinite prefix of the computation

      If it's a permission-less system, an agent may spawn more nodes to act Byzantine. So I guess the strategy of "accept equivocation in order to spread the knowledge of Byzantine agents" is suitable for permissioned systems only.