diff --git a/veilid-core/proto/veilid.capnp b/veilid-core/proto/veilid.capnp index 3525da9f..1ce4c11a 100644 --- a/veilid-core/proto/veilid.capnp +++ b/veilid-core/proto/veilid.capnp @@ -3,14 +3,14 @@ # IDs And Hashes ############################## -struct Curve25519PublicKey { +struct Key256 @0xdde44e3286f6a90d { u0 @0 :UInt64; u1 @1 :UInt64; u2 @2 :UInt64; u3 @3 :UInt64; } -struct Ed25519Signature { +struct Signature512 @0x806749043a129c12 { u0 @0 :UInt64; u1 @1 :UInt64; u2 @2 :UInt64; @@ -21,79 +21,72 @@ struct Ed25519Signature { u7 @7 :UInt64; } -struct XChaCha20Poly1305Nonce { +struct Nonce24 @0xb6260db25d8d7dfc { u0 @0 :UInt64; u1 @1 :UInt64; u2 @2 :UInt64; } -struct BLAKE3Hash { - u0 @0 :UInt64; - u1 @1 :UInt64; - u2 @2 :UInt64; - u3 @3 :UInt64; -} - -using NodeID = Curve25519PublicKey; -using RoutePublicKey = Curve25519PublicKey; -using ValueID = Curve25519PublicKey; -using Nonce = XChaCha20Poly1305Nonce; -using Signature = Ed25519Signature; -using BlockID = BLAKE3Hash; +using NodeID = Key256; +using RoutePublicKey = Key256; +using ValueID = Key256; +using Nonce = Nonce24; +using Signature = Signature512; +using BlockID = Key256; using TunnelID = UInt64; # Node Dial Info ################################################################ -struct AddressIPV4 { +struct AddressIPV4 @0xdb8769881266a6a0 { addr @0 :UInt32; # Address in big endian format } -struct AddressIPV6 { +struct AddressIPV6 @0xb35d6e6011dc5c20 { addr0 @0 :UInt32; # \ addr1 @1 :UInt32; # \ Address in big addr2 @2 :UInt32; # / endian format addr3 @3 :UInt32; # / } -struct Address { +struct Address @0x812706e9e57d108b { union { ipv4 @0 :AddressIPV4; ipv6 @1 :AddressIPV6; } } -struct SocketAddress { +struct SocketAddress @0x82df4272f4dd3a62 { address @0 :Address; port @1 :UInt16; } -enum ProtocolKind { +enum ProtocolKind @0xde0bf5787c067d5a { udp @0; ws @1; wss @2; tcp @3; } -struct DialInfoUDP { +struct DialInfoUDP @0xbb38a8b8b7024a7c { socketAddress @0 :SocketAddress; } -struct DialInfoTCP { +struct DialInfoTCP @0x9e0a9371b9a9f7fc { socketAddress @0 :SocketAddress; } -struct DialInfoWS { +struct DialInfoWS @0xd7795f7a92ab15b0 { socketAddress @0 :SocketAddress; request @1 :Text; } -struct DialInfoWSS { +struct DialInfoWSS @0xe639faa41b7d7b04 { socketAddress @0 :SocketAddress; request @1 :Text; } -struct DialInfo { +struct DialInfo @0xe1cd1c39fc2defdf { union { udp @0 :DialInfoUDP; tcp @1 :DialInfoTCP; @@ -105,12 +98,12 @@ struct DialInfo { # Signals ############################## -struct SignalInfoHolePunch { +struct SignalInfoHolePunch @0xeeb9ab6861890c9a { receipt @0 :Data; # receipt to return with hole punch peerInfo @1 :PeerInfo; # peer info of the signal sender for hole punch attempt } -struct SignalInfoReverseConnect { +struct SignalInfoReverseConnect @0xd9ebd3bd0d46e013 { receipt @0 :Data; # receipt to return with reverse connect peerInfo @1 :PeerInfo; # peer info of the signal sender for reverse connect attempt } @@ -118,7 +111,7 @@ struct SignalInfoReverseConnect { # Private Routes ############################## -struct RouteHopData { +struct RouteHopData @0x8ce231f9d1b7adf2 { nonce @0 :Nonce; # nonce for encrypted blob blob @1 :Data; # encrypted blob with ENC(nonce,DH(PK,SK)) # if this is a safety route RouteHopData, there is a single byte tag appended to the end of the encrypted blob @@ -128,7 +121,7 @@ struct RouteHopData { # if this is a private route RouteHopData, only can decode to RouteHop, no tag is appended } -struct RouteHop { +struct RouteHop @0xf8f672d75cce0c3b { node :union { nodeId @0 :NodeID; # node id only for established routes peerInfo @1 :PeerInfo; # full peer info for this hop to establish the route @@ -137,13 +130,13 @@ struct RouteHop { # if this is a safety route routehop, this field is not optional and must exist } -struct PrivateRoute { +struct PrivateRoute @0x8a83fccb0851e776 { publicKey @0 :RoutePublicKey; # private route public key (unique per private route) hopCount @1 :UInt8; # Count of hops left in the private route (for timeout calculation purposes only) firstHop @2 :RouteHop; # Optional: first hop in the private route, if empty, this is the last hop and payload should be decrypted and processed. } -struct SafetyRoute { +struct SafetyRoute @0xf554734d07cb5d59 { publicKey @0 :RoutePublicKey; # safety route public key (unique per safety route) hopCount @1 :UInt8; # Count of hops left in the safety route (for timeout calculation purposes only) hops :union { @@ -157,7 +150,7 @@ struct SafetyRoute { using ValueSeqNum = UInt32; # sequence numbers for values -struct ValueKey { +struct ValueKey @0xe64b0992c21a0736 { publicKey @0 :ValueID; # the location of the value subkey @1 :Text; # the name of the subkey (or empty if the whole key) } @@ -167,7 +160,7 @@ struct ValueKey { # seq @1 :ValueSeqNum; # the sequence number of the value subkey # } -struct ValueData { +struct ValueData @0xb4b7416f169f2a3d { data @0 :Data; # value or subvalue contents seq @1 :ValueSeqNum; # sequence number of value } @@ -175,14 +168,14 @@ struct ValueData { # Operations ############################## -enum NetworkClass { +enum NetworkClass @0x8cebfc2a6230717f { invalid @0; # X = Invalid network class, network is not yet set up inboundCapable @1; # I = Inbound capable without relay, may require signal outboundOnly @2; # O = Outbound only, inbound relay required except with reverse connect signal webApp @3; # W = PWA, outbound relay is required in most cases } -enum DialInfoClass { +enum DialInfoClass @0x880005edfdd38b1e { direct @0; # D = Directly reachable with public IP and no firewall, with statically configured port mapped @1; # M = Directly reachable with via portmap behind any NAT or firewalled with dynamically negotiated port fullConeNAT @2; # F = Directly reachable device without portmap behind full-cone NAT @@ -191,12 +184,12 @@ enum DialInfoClass { portRestrictedNAT @5; # P = Device without portmap behind address-and-port restricted NAT } -struct DialInfoDetail { +struct DialInfoDetail @0x96423aa1d67b74d8 { dialInfo @0 :DialInfo; class @1 :DialInfoClass; } -struct PublicInternetNodeStatus { +struct PublicInternetNodeStatus @0x9c9d7f1f12eb088f { willRoute @0 :Bool; willTunnel @1 :Bool; willSignal @2 :Bool; @@ -204,35 +197,35 @@ struct PublicInternetNodeStatus { willValidateDialInfo @4 :Bool; } -struct LocalNetworkNodeStatus { +struct LocalNetworkNodeStatus @0x957f5bfed2d0b5a5 { willRelay @0 :Bool; willValidateDialInfo @1 :Bool; } -struct NodeStatus { +struct NodeStatus @0xd36b9e7a3bf3330d { union { publicInternet @0 :PublicInternetNodeStatus; localNetwork @1 :LocalNetworkNodeStatus; } } -struct ProtocolTypeSet { +struct ProtocolTypeSet @0x82f12f55a1b73326 { udp @0 :Bool; tcp @1 :Bool; ws @2 :Bool; wss @3 :Bool; } -struct AddressTypeSet { +struct AddressTypeSet @0x9f52d5430d349e6b { ipv4 @0 :Bool; ipv6 @1 :Bool; } -struct SenderInfo { +struct SenderInfo @0x8a4464fab4b1d101 { socketAddress @0 :SocketAddress; # socket address that for the sending peer } -struct NodeInfo { +struct NodeInfo @0xe125d847e3f9f419 { networkClass @0 :NetworkClass; # network class of this node outboundProtocols @1 :ProtocolTypeSet; # protocols that can go outbound addressTypes @2 :AddressTypeSet; # address types supported @@ -241,13 +234,13 @@ struct NodeInfo { dialInfoDetailList @5 :List(DialInfoDetail); # inbound dial info details for this node } -struct SignedDirectNodeInfo { +struct SignedDirectNodeInfo @0xe0e7ea3e893a3dd7 { nodeInfo @0 :NodeInfo; # node info timestamp @1 :UInt64; # when signed node info was generated signature @2 :Signature; # signature } -struct SignedRelayedNodeInfo { +struct SignedRelayedNodeInfo @0xb39e8428ccd87cbb { nodeInfo @0 :NodeInfo; # node info relayId @1 :NodeID; # node id for relay relayInfo @2 :SignedDirectNodeInfo; # signed node info for relay @@ -255,202 +248,202 @@ struct SignedRelayedNodeInfo { signature @4 :Signature; # signature } -struct SignedNodeInfo { +struct SignedNodeInfo @0xd2478ce5f593406a { union { direct @0 :SignedDirectNodeInfo; # node info for nodes reachable without a relay relayed @1 :SignedRelayedNodeInfo; # node info for nodes requiring a relay } } -struct PeerInfo { +struct PeerInfo @0xfe2d722d5d3c4bcb { nodeId @0 :NodeID; # node id for 'closer peer' signedNodeInfo @1 :SignedNodeInfo; # signed node info for 'closer peer' } -struct RoutedOperation { +struct RoutedOperation @0xcbcb8535b839e9dd { version @0 :UInt8; # crypto version in use for the data signatures @1 :List(Signature); # signatures from nodes that have handled the private route nonce @2 :Nonce; # nonce Xmsg data @3 :Data; # operation encrypted with ENC(Xmsg,DH(PKapr,SKbsr)) } -struct OperationStatusQ { +struct OperationStatusQ @0x865d80cea70d884a { nodeStatus @0 :NodeStatus; # Optional: node status update about the statusq sender } -struct OperationStatusA { +struct OperationStatusA @0xb306f407fa812a55 { nodeStatus @0 :NodeStatus; # Optional: returned node status senderInfo @1 :SenderInfo; # Optional: info about StatusQ sender from the perspective of the replier } -struct OperationValidateDialInfo { +struct OperationValidateDialInfo @0xbc716ad7d5d060c8 { dialInfo @0 :DialInfo; # dial info to use for the receipt receipt @1 :Data; # receipt to return to dial info to prove it is reachable redirect @2 :Bool; # request a different node do the validate } -struct OperationReturnReceipt { +struct OperationReturnReceipt @0xeb0fb5b5a9160eeb { receipt @0 :Data; # receipt being returned to its origin } -struct OperationFindNodeQ { +struct OperationFindNodeQ @0xfdef788fe9623bcd { nodeId @0 :NodeID; # node id to locate } -struct OperationFindNodeA { +struct OperationFindNodeA @0xa84cf2fb40c77089 { peers @0 :List(PeerInfo); # returned 'closer peer' information } -struct OperationRoute { +struct OperationRoute @0x96741859ce6ac7dd { safetyRoute @0 :SafetyRoute; # Where this should go operation @1 :RoutedOperation; # The operation to be routed } -struct OperationNodeInfoUpdate { +struct OperationNodeInfoUpdate @0xc9647b32a48b66ce { signedNodeInfo @0 :SignedNodeInfo; # Our signed node info } -struct OperationAppCallQ { +struct OperationAppCallQ @0xade67b9f09784507 { message @0 :Data; # Opaque request to application } -struct OperationAppCallA { +struct OperationAppCallA @0xf7c797ac85f214b8 { message @0 :Data; # Opaque response from application } -struct OperationAppMessage { +struct OperationAppMessage @0x9baf542d81b411f5 { message @0 :Data; # Opaque message to application } -struct OperationGetValueQ { +struct OperationGetValueQ @0xf88a5b6da5eda5d0 { key @0 :ValueKey; # key for value to get } -struct OperationGetValueA { +struct OperationGetValueA @0xd896bb46f2e0249f { union { data @0 :ValueData; # the value if successful peers @1 :List(PeerInfo); # returned 'closer peer' information if not successful } } -struct OperationSetValueQ { +struct OperationSetValueQ @0xbac06191ff8bdbc5 { key @0 :ValueKey; # key for value to update value @1 :ValueData; # value or subvalue contents (older or equal seq number gets dropped) } -struct OperationSetValueA { +struct OperationSetValueA @0x9378d0732dc95be2 { union { data @0 :ValueData; # the new value if successful, may be a different value than what was set if the seq number was lower or equal peers @1 :List(PeerInfo); # returned 'closer peer' information if not successful } } -struct OperationWatchValueQ { +struct OperationWatchValueQ @0xf9a5a6c547b9b228 { key @0 :ValueKey; # key for value to watch } -struct OperationWatchValueA { +struct OperationWatchValueA @0xa726cab7064ba893 { expiration @0 :UInt64; # timestamp when this watch will expire in usec since epoch (0 if watch failed) peers @1 :List(PeerInfo); # returned list of other nodes to ask that could propagate watches } -struct OperationValueChanged { +struct OperationValueChanged @0xd1c59ebdd8cc1bf6 { key @0 :ValueKey; # key for value that changed value @1 :ValueData; # value or subvalue contents with sequence number } -struct OperationSupplyBlockQ { +struct OperationSupplyBlockQ @0xadbf4c542d749971 { blockId @0 :BlockID; # hash of the block we can supply } -struct OperationSupplyBlockA { +struct OperationSupplyBlockA @0xf003822e83b5c0d7 { union { expiration @0 :UInt64; # when the block supplier entry will need to be refreshed peers @1 :List(PeerInfo); # returned 'closer peer' information if not successful } } -struct OperationFindBlockQ { +struct OperationFindBlockQ @0xaf4353ff004c7156 { blockId @0 :BlockID; # hash of the block to locate } -struct OperationFindBlockA { +struct OperationFindBlockA @0xc51455bc4915465d { data @0 :Data; # Optional: the actual block data if we have that block ourselves # null if we don't have a block to return suppliers @1 :List(PeerInfo); # returned list of suppliers if we have them peers @2 :List(PeerInfo); # returned 'closer peer' information } -struct OperationSignal { +struct OperationSignal @0xd4f94f2a5d207e49 { union { holePunch @0 :SignalInfoHolePunch; reverseConnect @1 :SignalInfoReverseConnect; } } -enum TunnelEndpointMode { +enum TunnelEndpointMode @0xef06f4c29beb7458 { raw @0; # raw tunnel turn @1; # turn tunnel } -enum TunnelError { +enum TunnelError @0xb82c6bfb1ec38c7c { badId @0; # Tunnel ID was rejected noEndpoint @1; # Endpoint was unreachable rejectedMode @2; # Endpoint couldn't provide mode noCapacity @3; # Endpoint is full } -struct TunnelEndpoint { +struct TunnelEndpoint @0xc2602aa983cc337d { mode @0 :TunnelEndpointMode; # what kind of endpoint this is description @1 :Text; # endpoint description (TODO) } -struct FullTunnel { +struct FullTunnel @0x9821c3dc75373f63 { id @0 :TunnelID; # tunnel id to use everywhere timeout @1 :UInt64; # duration from last data when this expires if no data is sent or received local @2 :TunnelEndpoint; # local endpoint remote @3 :TunnelEndpoint; # remote endpoint } -struct PartialTunnel { +struct PartialTunnel @0x827a7ebc02be2fc8 { id @0 :TunnelID; # tunnel id to use everywhere timeout @1 :UInt64; # timestamp when this expires if not completed local @2 :TunnelEndpoint; # local endpoint } -struct OperationStartTunnelQ { +struct OperationStartTunnelQ @0xa9c49afce44187af { id @0 :TunnelID; # tunnel id to use everywhere localMode @1 :TunnelEndpointMode; # what kind of local endpoint mode is being requested depth @2 :UInt8; # the number of nodes in the tunnel } -struct OperationStartTunnelA { +struct OperationStartTunnelA @0x818162e4cc61bf1e { union { partial @0 :PartialTunnel; # the first half of the tunnel error @1 :TunnelError; # if we didn't start the tunnel, why not } } -struct OperationCompleteTunnelQ { +struct OperationCompleteTunnelQ @0xe978594588eb950b { id @0 :TunnelID; # tunnel id to use everywhere localMode @1 :TunnelEndpointMode; # what kind of local endpoint mode is being requested depth @2 :UInt8; # the number of nodes in the tunnel endpoint @3 :TunnelEndpoint; # the remote endpoint to complete } -struct OperationCompleteTunnelA { +struct OperationCompleteTunnelA @0x84090791bb765f2a { union { tunnel @0 :FullTunnel; # the tunnel description error @1 :TunnelError; # if we didn't complete the tunnel, why not } } -struct OperationCancelTunnelQ { +struct OperationCancelTunnelQ @0xae2811ae0a003738 { id @0 :TunnelID; # the tunnel id to cancel } -struct OperationCancelTunnelA { +struct OperationCancelTunnelA @0xbba23c992eff97bc { union { tunnel @0 :TunnelID; # the tunnel id that was cancelled error @1 :TunnelError; # if we couldn't cancel, why not @@ -458,7 +451,7 @@ struct OperationCancelTunnelA { } # Things that want an answer -struct Question { +struct Question @0xd8510bc33492ef70 { respondTo :union { sender @0 :Void; # sender privateRoute @1 :PrivateRoute; # embedded private route to be used for reply @@ -484,7 +477,7 @@ struct Question { } # Things that don't want an answer -struct Statement { +struct Statement @0x990e20828f404ae1 { detail :union { # Direct operations validateDialInfo @0 :OperationValidateDialInfo; @@ -500,7 +493,7 @@ struct Statement { } # Things that are answers -struct Answer { +struct Answer @0xacacb8b6988c1058 { detail :union { # Direct operations statusA @0 :OperationStatusA; @@ -521,7 +514,7 @@ struct Answer { } } -struct Operation { +struct Operation @0xbf2811c435403c3b { opId @0 :UInt64; # Random RPC ID. Must be random to foil reply forgery attacks. senderNodeInfo @1 :SignedNodeInfo; # (optional) SignedNodeInfo for the sender to be cached by the receiver. kind :union { diff --git a/veilid-core/src/rpc_processor/coders/block_id.rs b/veilid-core/src/rpc_processor/coders/block_id.rs deleted file mode 100644 index c42481b6..00000000 --- a/veilid-core/src/rpc_processor/coders/block_id.rs +++ /dev/null @@ -1,38 +0,0 @@ -use crate::crypto::*; -use crate::*; -use core::convert::TryInto; -use rpc_processor::*; - -pub fn decode_block_id(public_key: &veilid_capnp::b_l_a_k_e3_hash::Reader) -> DHTKey { - let u0 = public_key.get_u0().to_be_bytes(); - let u1 = public_key.get_u1().to_be_bytes(); - let u2 = public_key.get_u2().to_be_bytes(); - let u3 = public_key.get_u3().to_be_bytes(); - - let mut x: [u8; 32] = Default::default(); - x[0..8].copy_from_slice(&u0); - x[8..16].copy_from_slice(&u1); - x[16..24].copy_from_slice(&u2); - x[24..32].copy_from_slice(&u3); - - DHTKey::new(x) -} - -pub fn encode_block_id( - key: &DHTKey, - builder: &mut veilid_capnp::b_l_a_k_e3_hash::Builder, -) -> Result<(), RPCError> { - builder.set_u0(u64::from_be_bytes( - key.bytes[0..8].try_into().map_err(RPCError::internal)?, - )); - builder.set_u1(u64::from_be_bytes( - key.bytes[8..16].try_into().map_err(RPCError::internal)?, - )); - builder.set_u2(u64::from_be_bytes( - key.bytes[16..24].try_into().map_err(RPCError::internal)?, - )); - builder.set_u3(u64::from_be_bytes( - key.bytes[24..32].try_into().map_err(RPCError::internal)?, - )); - Ok(()) -} diff --git a/veilid-core/src/rpc_processor/coders/public_key.rs b/veilid-core/src/rpc_processor/coders/dht_key.rs similarity index 87% rename from veilid-core/src/rpc_processor/coders/public_key.rs rename to veilid-core/src/rpc_processor/coders/dht_key.rs index 1bec140b..dd7a8909 100644 --- a/veilid-core/src/rpc_processor/coders/public_key.rs +++ b/veilid-core/src/rpc_processor/coders/dht_key.rs @@ -3,7 +3,7 @@ use crate::*; use core::convert::TryInto; use rpc_processor::*; -pub fn decode_public_key(public_key: &veilid_capnp::curve25519_public_key::Reader) -> DHTKey { +pub fn decode_dht_key(public_key: &veilid_capnp::key256::Reader) -> DHTKey { let u0 = public_key.get_u0().to_be_bytes(); let u1 = public_key.get_u1().to_be_bytes(); let u2 = public_key.get_u2().to_be_bytes(); @@ -18,9 +18,9 @@ pub fn decode_public_key(public_key: &veilid_capnp::curve25519_public_key::Reade DHTKey::new(x) } -pub fn encode_public_key( +pub fn encode_dht_key( key: &DHTKey, - builder: &mut veilid_capnp::curve25519_public_key::Builder, + builder: &mut veilid_capnp::key256::Builder, ) -> Result<(), RPCError> { builder.set_u0(u64::from_be_bytes( key.bytes[0..8] diff --git a/veilid-core/src/rpc_processor/coders/signature.rs b/veilid-core/src/rpc_processor/coders/dht_signature.rs similarity index 90% rename from veilid-core/src/rpc_processor/coders/signature.rs rename to veilid-core/src/rpc_processor/coders/dht_signature.rs index 956fb74a..9e008faa 100644 --- a/veilid-core/src/rpc_processor/coders/signature.rs +++ b/veilid-core/src/rpc_processor/coders/dht_signature.rs @@ -1,10 +1,7 @@ use crate::*; use rpc_processor::*; -pub fn encode_signature( - sig: &DHTSignature, - builder: &mut veilid_capnp::ed25519_signature::Builder, -) { +pub fn encode_signature(sig: &DHTSignature, builder: &mut veilid_capnp::signature512::Builder) { let sig = &sig.bytes; builder.set_u0(u64::from_be_bytes( @@ -33,7 +30,7 @@ pub fn encode_signature( )); } -pub fn decode_signature(reader: &veilid_capnp::ed25519_signature::Reader) -> DHTSignature { +pub fn decode_signature(reader: &veilid_capnp::signature512::Reader) -> DHTSignature { let u0 = reader.get_u0().to_be_bytes(); let u1 = reader.get_u1().to_be_bytes(); let u2 = reader.get_u2().to_be_bytes(); diff --git a/veilid-core/src/rpc_processor/coders/mod.rs b/veilid-core/src/rpc_processor/coders/mod.rs index ccc6dc17..b5c3c709 100644 --- a/veilid-core/src/rpc_processor/coders/mod.rs +++ b/veilid-core/src/rpc_processor/coders/mod.rs @@ -1,6 +1,7 @@ mod address; mod address_type_set; -mod block_id; +mod dht_key; +mod dht_signature; mod dial_info; mod dial_info_class; mod dial_info_detail; @@ -12,10 +13,8 @@ mod operations; mod peer_info; mod private_safety_route; mod protocol_type_set; -mod public_key; mod sender_info; mod signal_info; -mod signature; mod signed_direct_node_info; mod signed_node_info; mod signed_relayed_node_info; @@ -26,7 +25,8 @@ mod value_key; pub use address::*; pub use address_type_set::*; -pub use block_id::*; +pub use dht_key::*; +pub use dht_signature::*; pub use dial_info::*; pub use dial_info_class::*; pub use dial_info_detail::*; @@ -38,10 +38,8 @@ pub use operations::*; pub use peer_info::*; pub use private_safety_route::*; pub use protocol_type_set::*; -pub use public_key::*; pub use sender_info::*; pub use signal_info::*; -pub use signature::*; pub use signed_direct_node_info::*; pub use signed_node_info::*; pub use signed_relayed_node_info::*; diff --git a/veilid-core/src/rpc_processor/coders/nonce.rs b/veilid-core/src/rpc_processor/coders/nonce.rs index a73bd56a..5eb39dce 100644 --- a/veilid-core/src/rpc_processor/coders/nonce.rs +++ b/veilid-core/src/rpc_processor/coders/nonce.rs @@ -1,10 +1,7 @@ use crate::*; use rpc_processor::*; -pub fn encode_nonce( - nonce: &Nonce, - builder: &mut veilid_capnp::x_cha_cha20_poly1305_nonce::Builder, -) { +pub fn encode_nonce(nonce: &Nonce, builder: &mut veilid_capnp::nonce24::Builder) { builder.set_u0(u64::from_be_bytes( nonce[0..8].try_into().expect("slice with incorrect length"), )); @@ -20,7 +17,7 @@ pub fn encode_nonce( )); } -pub fn decode_nonce(reader: &veilid_capnp::x_cha_cha20_poly1305_nonce::Reader) -> Nonce { +pub fn decode_nonce(reader: &veilid_capnp::nonce24::Reader) -> Nonce { let u0 = reader.get_u0().to_be_bytes(); let u1 = reader.get_u1().to_be_bytes(); let u2 = reader.get_u2().to_be_bytes(); diff --git a/veilid-core/src/rpc_processor/coders/operations/operation_find_block.rs b/veilid-core/src/rpc_processor/coders/operations/operation_find_block.rs index 71fcba11..5503ad31 100644 --- a/veilid-core/src/rpc_processor/coders/operations/operation_find_block.rs +++ b/veilid-core/src/rpc_processor/coders/operations/operation_find_block.rs @@ -11,7 +11,7 @@ impl RPCOperationFindBlockQ { reader: &veilid_capnp::operation_find_block_q::Reader, ) -> Result { let bi_reader = reader.get_block_id().map_err(RPCError::protocol)?; - let block_id = decode_block_id(&bi_reader); + let block_id = decode_dht_key(&bi_reader); Ok(RPCOperationFindBlockQ { block_id }) } @@ -20,7 +20,7 @@ impl RPCOperationFindBlockQ { builder: &mut veilid_capnp::operation_find_block_q::Builder, ) -> Result<(), RPCError> { let mut bi_builder = builder.reborrow().init_block_id(); - encode_block_id(&self.block_id, &mut bi_builder)?; + encode_dht_key(&self.block_id, &mut bi_builder)?; Ok(()) } diff --git a/veilid-core/src/rpc_processor/coders/operations/operation_find_node.rs b/veilid-core/src/rpc_processor/coders/operations/operation_find_node.rs index bfd0ded9..95ca3ea5 100644 --- a/veilid-core/src/rpc_processor/coders/operations/operation_find_node.rs +++ b/veilid-core/src/rpc_processor/coders/operations/operation_find_node.rs @@ -11,7 +11,7 @@ impl RPCOperationFindNodeQ { reader: &veilid_capnp::operation_find_node_q::Reader, ) -> Result { let ni_reader = reader.get_node_id().map_err(RPCError::protocol)?; - let node_id = decode_public_key(&ni_reader); + let node_id = decode_dht_key(&ni_reader); Ok(RPCOperationFindNodeQ { node_id }) } pub fn encode( @@ -19,7 +19,7 @@ impl RPCOperationFindNodeQ { builder: &mut veilid_capnp::operation_find_node_q::Builder, ) -> Result<(), RPCError> { let mut ni_builder = builder.reborrow().init_node_id(); - encode_public_key(&self.node_id, &mut ni_builder)?; + encode_dht_key(&self.node_id, &mut ni_builder)?; Ok(()) } } diff --git a/veilid-core/src/rpc_processor/coders/operations/operation_supply_block.rs b/veilid-core/src/rpc_processor/coders/operations/operation_supply_block.rs index b094eaaf..67b7ab00 100644 --- a/veilid-core/src/rpc_processor/coders/operations/operation_supply_block.rs +++ b/veilid-core/src/rpc_processor/coders/operations/operation_supply_block.rs @@ -11,7 +11,7 @@ impl RPCOperationSupplyBlockQ { reader: &veilid_capnp::operation_supply_block_q::Reader, ) -> Result { let bi_reader = reader.get_block_id().map_err(RPCError::protocol)?; - let block_id = decode_block_id(&bi_reader); + let block_id = decode_dht_key(&bi_reader); Ok(RPCOperationSupplyBlockQ { block_id }) } @@ -20,7 +20,7 @@ impl RPCOperationSupplyBlockQ { builder: &mut veilid_capnp::operation_supply_block_q::Builder, ) -> Result<(), RPCError> { let mut bi_builder = builder.reborrow().init_block_id(); - encode_block_id(&self.block_id, &mut bi_builder)?; + encode_dht_key(&self.block_id, &mut bi_builder)?; Ok(()) } diff --git a/veilid-core/src/rpc_processor/coders/peer_info.rs b/veilid-core/src/rpc_processor/coders/peer_info.rs index 428980f4..5c7e67ab 100644 --- a/veilid-core/src/rpc_processor/coders/peer_info.rs +++ b/veilid-core/src/rpc_processor/coders/peer_info.rs @@ -7,7 +7,7 @@ pub fn encode_peer_info( ) -> Result<(), RPCError> { // let mut nid_builder = builder.reborrow().init_node_id(); - encode_public_key(&peer_info.node_id.key, &mut nid_builder)?; + encode_dht_key(&peer_info.node_id.key, &mut nid_builder)?; let mut sni_builder = builder.reborrow().init_signed_node_info(); encode_signed_node_info(&peer_info.signed_node_info, &mut sni_builder)?; @@ -23,7 +23,7 @@ pub fn decode_peer_info(reader: &veilid_capnp::peer_info::Reader) -> Result { let mut ni_builder = node_builder.init_node_id(); - encode_public_key(&ni.key, &mut ni_builder)?; + encode_dht_key(&ni.key, &mut ni_builder)?; } RouteNode::PeerInfo(pi) => { let mut pi_builder = node_builder.init_peer_info(); @@ -72,7 +72,7 @@ pub fn decode_route_hop(reader: &veilid_capnp::route_hop::Reader) -> Result { let ni_reader = ni.map_err(RPCError::protocol)?; - RouteNode::NodeId(NodeId::new(decode_public_key(&ni_reader))) + RouteNode::NodeId(NodeId::new(decode_dht_key(&ni_reader))) } veilid_capnp::route_hop::node::Which::PeerInfo(pi) => { let pi_reader = pi.map_err(RPCError::protocol)?; @@ -101,7 +101,7 @@ pub fn encode_private_route( private_route: &PrivateRoute, builder: &mut veilid_capnp::private_route::Builder, ) -> Result<(), RPCError> { - encode_public_key( + encode_dht_key( &private_route.public_key, &mut builder.reborrow().init_public_key(), )?; @@ -117,9 +117,9 @@ pub fn encode_private_route( pub fn decode_private_route( reader: &veilid_capnp::private_route::Reader, ) -> Result { - let public_key = decode_public_key(&reader.get_public_key().map_err( - RPCError::map_protocol("invalid public key in private route"), - )?); + let public_key = decode_dht_key(&reader.get_public_key().map_err(RPCError::map_protocol( + "invalid public key in private route", + ))?); let hop_count = reader.get_hop_count(); let first_hop = if reader.has_first_hop() { let rh_reader = reader @@ -143,7 +143,7 @@ pub fn encode_safety_route( safety_route: &SafetyRoute, builder: &mut veilid_capnp::safety_route::Builder, ) -> Result<(), RPCError> { - encode_public_key( + encode_dht_key( &safety_route.public_key, &mut builder.reborrow().init_public_key(), )?; @@ -166,7 +166,7 @@ pub fn encode_safety_route( pub fn decode_safety_route( reader: &veilid_capnp::safety_route::Reader, ) -> Result { - let public_key = decode_public_key( + let public_key = decode_dht_key( &reader .get_public_key() .map_err(RPCError::map_protocol("invalid public key in safety route"))?, diff --git a/veilid-core/src/rpc_processor/coders/signed_relayed_node_info.rs b/veilid-core/src/rpc_processor/coders/signed_relayed_node_info.rs index 530f8254..646f6597 100644 --- a/veilid-core/src/rpc_processor/coders/signed_relayed_node_info.rs +++ b/veilid-core/src/rpc_processor/coders/signed_relayed_node_info.rs @@ -10,7 +10,7 @@ pub fn encode_signed_relayed_node_info( encode_node_info(&signed_relayed_node_info.node_info, &mut ni_builder)?; let mut rid_builder = builder.reborrow().init_relay_id(); - encode_public_key(&signed_relayed_node_info.relay_id.key, &mut rid_builder)?; + encode_dht_key(&signed_relayed_node_info.relay_id.key, &mut rid_builder)?; let mut ri_builder = builder.reborrow().init_relay_info(); encode_signed_direct_node_info(&signed_relayed_node_info.relay_info, &mut ri_builder)?; @@ -39,7 +39,7 @@ pub fn decode_signed_relayed_node_info( .reborrow() .get_relay_id() .map_err(RPCError::protocol)?; - let relay_id = decode_public_key(&rid_reader); + let relay_id = decode_dht_key(&rid_reader); let ri_reader = reader .reborrow() diff --git a/veilid-core/src/rpc_processor/coders/value_key.rs b/veilid-core/src/rpc_processor/coders/value_key.rs index 035ab998..7561b3c6 100644 --- a/veilid-core/src/rpc_processor/coders/value_key.rs +++ b/veilid-core/src/rpc_processor/coders/value_key.rs @@ -6,7 +6,7 @@ pub fn encode_value_key( builder: &mut veilid_capnp::value_key::Builder, ) -> Result<(), RPCError> { let mut pk_builder = builder.reborrow().init_public_key(); - encode_public_key(&value_key.key, &mut pk_builder)?; + encode_dht_key(&value_key.key, &mut pk_builder)?; if let Some(subkey) = &value_key.subkey { builder.set_subkey(subkey); } @@ -15,7 +15,7 @@ pub fn encode_value_key( pub fn decode_value_key(reader: &veilid_capnp::value_key::Reader) -> Result { let pk_reader = reader.get_public_key().map_err(RPCError::protocol)?; - let key = decode_public_key(&pk_reader); + let key = decode_dht_key(&pk_reader); let subkey = if !reader.has_subkey() { None } else { diff --git a/veilid-core/src/veilid_api/mod.rs b/veilid-core/src/veilid_api/mod.rs index 69348803..9f4994c5 100644 --- a/veilid-core/src/veilid_api/mod.rs +++ b/veilid-core/src/veilid_api/mod.rs @@ -2099,8 +2099,8 @@ impl SignedRelayedNodeInfo { // Add relay id to signature let mut rid_msg = ::capnp::message::Builder::new_default(); - let mut rid_builder = rid_msg.init_root::(); - encode_public_key(&relay_id.key, &mut rid_builder).map_err(VeilidAPIError::internal)?; + let mut rid_builder = rid_msg.init_root::(); + encode_dht_key(&relay_id.key, &mut rid_builder).map_err(VeilidAPIError::internal)?; sig_bytes.append(&mut builder_to_vec(rid_msg).map_err(VeilidAPIError::internal)?); // Add relay info to signature diff --git a/veilid-server/proto/veilid-client.capnp b/veilid-server/proto/veilid-client.capnp index 320ffea4..e12b587a 100644 --- a/veilid-server/proto/veilid-client.capnp +++ b/veilid-server/proto/veilid-client.capnp @@ -1,15 +1,15 @@ @0xd29582d26b2fb073; -struct ApiResult { +struct ApiResult @0x8111724bdb812929 { union { ok @0 :Text; err @1 :Text; } } -interface Registration {} +interface Registration @0xdd45f30a7c22e391 {} -interface VeilidServer { +interface VeilidServer @0xcb2c699f14537f94 { register @0 (veilidClient :VeilidClient) -> (registration :Registration, state :Text); debug @1 (command :Text) -> (result :ApiResult); attach @2 () -> (result :ApiResult); @@ -20,6 +20,6 @@ interface VeilidServer { appCallReply @7 (id :UInt64, message :Data) -> (result :ApiResult); } -interface VeilidClient { +interface VeilidClient @0xbfcea60fb2ba4736 { update @0 (veilidUpdate :Text); } \ No newline at end of file