GNUnet  0.11.x
Data Structures | Macros | Functions | Variables
gnunet-communicator-udp.c File Reference

Transport plugin using UDP. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_signatures.h"
#include "gnunet_constants.h"
#include "gnunet_nt_lib.h"
#include "gnunet_nat_service.h"
#include "gnunet_statistics_service.h"
#include "gnunet_transport_application_service.h"
#include "gnunet_transport_communication_service.h"
Include dependency graph for gnunet-communicator-udp.c:

Go to the source code of this file.

Data Structures

struct  UdpHandshakeSignature
 Signature we use to verify that the ephemeral key was really chosen by the specified sender. More...
 
struct  InitialKX
 "Plaintext" header at beginning of KX message. More...
 
struct  UDPConfirmation
 Encrypted continuation of UDP initial handshake, followed by message header with payload. More...
 
struct  UDPAck
 UDP key acknowledgement. More...
 
struct  UdpBroadcastSignature
 Signature we use to verify that the broadcast was really made by the peer that claims to have made it. More...
 
struct  UDPBroadcast
 Broadcast by peer in LAN announcing its presence. More...
 
struct  UDPBox
 UDP message box. More...
 
struct  UDPRekey
 UDP message box. More...
 
struct  KeyCacheEntry
 Pre-generated "kid" code (key and IV identification code) to quickly derive master key for a struct UDPBox. More...
 
struct  SharedSecret
 Shared secret we generated for a particular sender or receiver. More...
 
struct  SenderAddress
 Information we track per sender address we have recently been in contact with (we decrypt messages from the sender). More...
 
struct  ReceiverAddress
 Information we track per receiving address we have recently been in contact with (encryption to receiver). More...
 
struct  BroadcastInterface
 Interface we broadcast our presence on. More...
 
struct  SearchContext
 Context information to be used while searching for operation contexts. More...
 

Macros

#define DEFAULT_REKEY_TIME_INTERVAL   GNUNET_TIME_UNIT_DAYS
 How often do we rekey based on time (at least) More...
 
#define PROTO_QUEUE_TIMEOUT   GNUNET_TIME_UNIT_MINUTES
 How long do we wait until we must have received the initial KX? More...
 
#define BROADCAST_FREQUENCY   GNUNET_TIME_UNIT_MINUTES
 How often do we broadcast our presence on the LAN? More...
 
#define INTERFACE_SCAN_FREQUENCY   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
 How often do we scan for changes to our network interfaces? More...
 
#define ADDRESS_VALIDITY_PERIOD   GNUNET_TIME_UNIT_HOURS
 How long do we believe our addresses to remain up (before the other peer should revalidate). More...
 
#define WORKING_QUEUE_INTERVALL   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS,1)
 
#define AES_KEY_SIZE   (256 / 8)
 AES key size. More...
 
#define AES_IV_SIZE   (96 / 8)
 AES (GCM) IV size. More...
 
#define GCM_TAG_SIZE   (128 / 8)
 Size of the GCM tag. More...
 
#define GENERATE_AT_ONCE   2
 
#define KCN_THRESHOLD   92
 If we fall below this number of available KCNs, we generate additional ACKs until we reach KCN_TARGET. More...
 
#define KCN_TARGET   128
 How many KCNs do we keep around after we hit the KCN_THRESHOLD? Should be larger than KCN_THRESHOLD so we do not generate just one ACK at the time. More...
 
#define MAX_SQN_DELTA   160
 What is the maximum delta between KCN sequence numbers that we allow. More...
 
#define MAX_SECRETS   128000
 How many shared master secrets do we keep around at most per sender? Should be large enough so that we generally have a chance of sending an ACK before the sender already rotated out the master secret. More...
 
#define DEFAULT_REKEY_MAX_BYTES   (1024LLU * 1024 * 1024 * 4LLU)
 Default value for how often we do rekey based on number of bytes transmitted? (additionally randomized). More...
 
#define COMMUNICATOR_ADDRESS_PREFIX   "udp"
 Address prefix used by the communicator. More...
 
#define COMMUNICATOR_CONFIG_SECTION   "communicator-udp"
 Configuration section used by the communicator. More...
 

Functions

static void bi_destroy (struct BroadcastInterface *bi)
 An interface went away, stop broadcasting on it. More...
 
static void receiver_destroy (struct ReceiverAddress *receiver)
 Destroys a receiving state due to timeout or shutdown. More...
 
static void kce_destroy (struct KeyCacheEntry *kce)
 Free memory used by key cache entry. More...
 
static void get_kid (const struct GNUNET_HashCode *msec, uint32_t serial, struct GNUNET_ShortHashCode *kid)
 Compute kid. More...
 
static void kce_generate (struct SharedSecret *ss, uint32_t seq)
 Setup key cache entry for sequence number seq and shared secret ss. More...
 
static int secret_destroy (struct SharedSecret *ss, int withoutKce)
 Destroy ss and associated key cache entries. More...
 
static void sender_destroy (struct SenderAddress *sender)
 Functions with this signature are called whenever we need to close a sender's state due to timeout. More...
 
static void get_iv_key (const struct GNUNET_HashCode *msec, uint32_t serial, char key[(256/8)], char iv[(96/8)])
 Compute key and iv. More...
 
static void reschedule_sender_timeout (struct SenderAddress *sender)
 Increment sender timeout due to activity. More...
 
static void reschedule_receiver_timeout (struct ReceiverAddress *receiver)
 Increment receiver timeout due to activity. More...
 
static void check_timeouts (void *cls)
 Task run to check #receiver_heap and #sender_heap for timeouts. More...
 
static void calculate_cmac (struct SharedSecret *ss)
 Calculate cmac from master in ss. More...
 
static void pass_plaintext_to_core (struct SenderAddress *sender, const void *plaintext, size_t plaintext_len)
 We received plaintext_len bytes of plaintext from a sender. More...
 
static void setup_cipher (const struct GNUNET_HashCode *msec, uint32_t serial, gcry_cipher_hd_t *cipher)
 Setup cipher based on shared secret msec and serial number serial. More...
 
static int try_decrypt (const struct SharedSecret *ss, const char tag[(128/8)], uint32_t serial, const char *in_buf, size_t in_buf_size, char *out_buf)
 Try to decrypt buf using shared secret ss and key/iv derived using serial. More...
 
static struct SharedSecretsetup_shared_secret_dec (const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral)
 Setup shared secret for decryption. More...
 
static struct SharedSecretsetup_shared_secret_enc (const struct GNUNET_CRYPTO_EcdhePrivateKey *ephemeral, struct ReceiverAddress *receiver, int add_to_receiver)
 Setup shared secret for encryption. More...
 
static void setup_receiver_mq (struct ReceiverAddress *receiver)
 Setup the MQ for the receiver. More...
 
static void destroy_all_secrets (struct SharedSecret *ss, int withoutKce)
 Destroying all secrets. More...
 
static void add_acks (struct SharedSecret *ss, int acks_to_add)
 
static uint32_t reset_rekey_kces (struct ReceiverAddress *receiver, uint32_t acks_to_add)
 
static void add_acks_rekey (struct ReceiverAddress *receiver)
 
static int handle_ack (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 We received an ACK for pid. More...
 
static void try_handle_plaintext (struct SenderAddress *sender, const void *buf, size_t buf_size)
 Test if we have received a valid message in plaintext. More...
 
static void kce_generate_cb (void *cls)
 
static void kce_generate_rekey_cb (void *cls)
 
static void consider_ss_ack (struct SharedSecret *ss, int initial)
 We established a shared secret with a sender. More...
 
static void decrypt_box (const struct UDPBox *box, size_t box_len, struct KeyCacheEntry *kce)
 We received a box with matching kce. More...
 
static void decrypt_rekey (const struct UDPRekey *rekey, size_t rekey_len, struct KeyCacheEntry *kce, struct SenderAddress *sender)
 We received a rekey with matching kce. More...
 
static int find_sender_by_address (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
 Find existing struct SenderAddress by matching addresses. More...
 
static struct SenderAddresssetup_sender (const struct GNUNET_PeerIdentity *target, const struct sockaddr *address, socklen_t address_len)
 Create sender address for target. More...
 
static int verify_confirmation (const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral, const struct UDPConfirmation *uc)
 Check signature from uc against ephemeral. More...
 
static char * sockaddr_to_udpaddr_string (const struct sockaddr *address, socklen_t address_len)
 Converts address to the address string format used by this communicator in HELLOs. More...
 
static void sock_read (void *cls)
 Socket read task. More...
 
static struct sockaddr * udp_address_to_sockaddr (const char *bindto, socklen_t *sock_len)
 Convert UDP bind specification to a struct sockaddr * More...
 
static void do_pad (gcry_cipher_hd_t out_cipher, char *dgram, size_t pad_size)
 Pad dgram by pad_size using out_cipher. More...
 
static void mq_send_kx (struct GNUNET_MQ_Handle *mq, const struct GNUNET_MessageHeader *msg, void *impl_state)
 Signature of functions implementing the sending functionality of a message queue. More...
 
static void check_for_rekeying (struct ReceiverAddress *receiver, struct UDPBox *box)
 
static void send_UDPRekey (struct ReceiverAddress *receiver, struct SharedSecret *ss)
 
static void mq_send_d (struct GNUNET_MQ_Handle *mq, const struct GNUNET_MessageHeader *msg, void *impl_state)
 Signature of functions implementing the sending functionality of a message queue. More...
 
static void mq_destroy_d (struct GNUNET_MQ_Handle *mq, void *impl_state)
 Signature of functions implementing the destruction of a message queue. More...
 
static void mq_destroy_kx (struct GNUNET_MQ_Handle *mq, void *impl_state)
 Signature of functions implementing the destruction of a message queue. More...
 
static void mq_cancel (struct GNUNET_MQ_Handle *mq, void *impl_state)
 Implementation function that cancels the currently sent message. More...
 
static void mq_error (void *cls, enum GNUNET_MQ_Error error)
 Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue. More...
 
static int mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
 Function called by the transport service to initialize a message queue given address information about another peer. More...
 
static int get_receiver_delete_it (void *cls, const struct GNUNET_PeerIdentity *target, void *value)
 Iterator over all receivers to clean up. More...
 
static int get_sender_delete_it (void *cls, const struct GNUNET_PeerIdentity *target, void *value)
 Iterator over all senders to clean up. More...
 
static void do_shutdown (void *cls)
 Shutdown the UNIX communicator. More...
 
static void enc_notify_cb (void *cls, const struct GNUNET_PeerIdentity *sender, const struct GNUNET_MessageHeader *msg)
 Function called when the transport service has received a backchannel message for this communicator (!) via a different return path. More...
 
static void nat_address_cb (void *cls, void **app_ctx, int add_remove, enum GNUNET_NAT_AddressClass ac, const struct sockaddr *addr, socklen_t addrlen)
 Signature of the callback passed to GNUNET_NAT_register() for a function to call whenever our set of 'valid' addresses changes. More...
 
static void ifc_broadcast (void *cls)
 Broadcast our presence on one of our interfaces. More...
 
static int iface_proc (void *cls, const char *name, int isDefault, const struct sockaddr *addr, const struct sockaddr *broadcast_addr, const struct sockaddr *netmask, socklen_t addrlen)
 Callback function invoked for each interface found. More...
 
static void do_broadcast (void *cls)
 Scan interfaces to broadcast our presence on the LAN. More...
 
static void run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
 Setup communicator and launch network interactions. More...
 
int main (int argc, char *const *argv)
 The main function for the UNIX communicator. More...
 

Variables

static struct GNUNET_TIME_Relative rekey_interval
 The rekey interval. More...
 
static unsigned long long rekey_max_bytes
 How often we do rekey based on number of bytes transmitted. More...
 
struct SharedSecretss_finished
 Shared secret we finished the last kce working queue for. More...
 
static struct GNUNET_CONTAINER_MultiShortmapkey_cache
 Cache of pre-generated key IDs. More...
 
static struct GNUNET_SCHEDULER_Taskread_task
 ID of read task. More...
 
static struct GNUNET_SCHEDULER_Tasktimeout_task
 ID of timeout task. More...
 
static struct GNUNET_SCHEDULER_Taskbroadcast_task
 ID of master broadcast task. More...
 
static struct GNUNET_STATISTICS_Handlestats
 For logging statistics. More...
 
static struct GNUNET_TRANSPORT_CommunicatorHandlech
 Our environment. More...
 
static struct GNUNET_CONTAINER_MultiPeerMapreceivers
 Receivers (map from peer identity to struct ReceiverAddress) More...
 
static struct GNUNET_CONTAINER_MultiPeerMapsenders
 Senders (map from peer identity to struct SenderAddress) More...
 
static struct GNUNET_CONTAINER_Heapsenders_heap
 Expiration heap for senders (contains struct SenderAddress) More...
 
static struct GNUNET_CONTAINER_Heapreceivers_heap
 Expiration heap for receivers (contains struct ReceiverAddress) More...
 
static struct BroadcastInterfacebi_head
 Broadcast interface tasks. More...
 
static struct BroadcastInterfacebi_tail
 Broadcast interface tasks. More...
 
static struct GNUNET_NETWORK_Handleudp_sock
 Our socket. More...
 
static int have_v6_socket
 GNUNET_YES if udp_sock supports IPv6. More...
 
static struct GNUNET_PeerIdentity my_identity
 Our public key. More...
 
static struct GNUNET_CRYPTO_EddsaPrivateKeymy_private_key
 Our private key. More...
 
static const struct GNUNET_CONFIGURATION_Handlecfg
 Our configuration. More...
 
static struct GNUNET_TRANSPORT_ApplicationHandleah
 Our handle to report addresses for validation to TRANSPORT. More...
 
static struct GNUNET_NT_InterfaceScanneris
 Network scanner to determine network types. More...
 
static struct GNUNET_NAT_Handlenat
 Connection to NAT service. More...
 
static uint16_t my_port
 Port number to which we are actually bound. More...
 

Detailed Description

Transport plugin using UDP.

Author
Christian Grothoff

TODO:

Definition in file gnunet-communicator-udp.c.

Macro Definition Documentation

◆ DEFAULT_REKEY_TIME_INTERVAL

#define DEFAULT_REKEY_TIME_INTERVAL   GNUNET_TIME_UNIT_DAYS

How often do we rekey based on time (at least)

Definition at line 54 of file gnunet-communicator-udp.c.

Referenced by run().

◆ PROTO_QUEUE_TIMEOUT

#define PROTO_QUEUE_TIMEOUT   GNUNET_TIME_UNIT_MINUTES

How long do we wait until we must have received the initial KX?

Definition at line 59 of file gnunet-communicator-udp.c.

◆ BROADCAST_FREQUENCY

#define BROADCAST_FREQUENCY   GNUNET_TIME_UNIT_MINUTES

How often do we broadcast our presence on the LAN?

Definition at line 64 of file gnunet-communicator-udp.c.

Referenced by ifc_broadcast().

◆ INTERFACE_SCAN_FREQUENCY

#define INTERFACE_SCAN_FREQUENCY   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)

How often do we scan for changes to our network interfaces?

Definition at line 69 of file gnunet-communicator-udp.c.

Referenced by do_broadcast(), and ifc_broadcast().

◆ ADDRESS_VALIDITY_PERIOD

#define ADDRESS_VALIDITY_PERIOD   GNUNET_TIME_UNIT_HOURS

How long do we believe our addresses to remain up (before the other peer should revalidate).

Definition at line 76 of file gnunet-communicator-udp.c.

Referenced by pass_plaintext_to_core().

◆ WORKING_QUEUE_INTERVALL

#define WORKING_QUEUE_INTERVALL   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS,1)

◆ AES_KEY_SIZE

#define AES_KEY_SIZE   (256 / 8)

AES key size.

Definition at line 84 of file gnunet-communicator-udp.c.

Referenced by setup_cipher().

◆ AES_IV_SIZE

#define AES_IV_SIZE   (96 / 8)

AES (GCM) IV size.

Definition at line 89 of file gnunet-communicator-udp.c.

Referenced by get_iv_key(), and setup_cipher().

◆ GCM_TAG_SIZE

#define GCM_TAG_SIZE   (128 / 8)

Size of the GCM tag.

Definition at line 94 of file gnunet-communicator-udp.c.

◆ GENERATE_AT_ONCE

#define GENERATE_AT_ONCE   2

Definition at line 96 of file gnunet-communicator-udp.c.

Referenced by kce_generate_cb(), and kce_generate_rekey_cb().

◆ KCN_THRESHOLD

#define KCN_THRESHOLD   92

If we fall below this number of available KCNs, we generate additional ACKs until we reach KCN_TARGET.

Should be large enough that we don't generate ACKs all the time and still have enough time for the ACK to arrive before the sender runs out. So really this should ideally be based on the RTT.

Definition at line 107 of file gnunet-communicator-udp.c.

Referenced by consider_ss_ack().

◆ KCN_TARGET

#define KCN_TARGET   128

How many KCNs do we keep around after we hit the KCN_THRESHOLD? Should be larger than KCN_THRESHOLD so we do not generate just one ACK at the time.

Definition at line 115 of file gnunet-communicator-udp.c.

Referenced by kce_generate_cb().

◆ MAX_SQN_DELTA

#define MAX_SQN_DELTA   160

What is the maximum delta between KCN sequence numbers that we allow.

Used to expire 'ancient' KCNs that likely were dropped by the network. Must be larger than KCN_TARGET (otherwise we generate new KCNs all the time), but not too large (otherwise packet loss may cause sender to fall back to KX needlessly when sender runs out of ACK'ed KCNs due to losses).

Definition at line 126 of file gnunet-communicator-udp.c.

Referenced by consider_ss_ack().

◆ MAX_SECRETS

#define MAX_SECRETS   128000

How many shared master secrets do we keep around at most per sender? Should be large enough so that we generally have a chance of sending an ACK before the sender already rotated out the master secret.

Generally values around KCN_TARGET make sense. Might make sense to adapt to RTT if we had a good measurement...

Definition at line 137 of file gnunet-communicator-udp.c.

Referenced by consider_ss_ack(), and mq_send_kx().

◆ DEFAULT_REKEY_MAX_BYTES

#define DEFAULT_REKEY_MAX_BYTES   (1024LLU * 1024 * 1024 * 4LLU)

Default value for how often we do rekey based on number of bytes transmitted? (additionally randomized).

Definition at line 143 of file gnunet-communicator-udp.c.

Referenced by run().

◆ COMMUNICATOR_ADDRESS_PREFIX

#define COMMUNICATOR_ADDRESS_PREFIX   "udp"

Address prefix used by the communicator.

Definition at line 149 of file gnunet-communicator-udp.c.

Referenced by consider_ss_ack(), mq_init(), nat_address_cb(), run(), and sockaddr_to_udpaddr_string().

◆ COMMUNICATOR_CONFIG_SECTION

#define COMMUNICATOR_CONFIG_SECTION   "communicator-udp"

Configuration section used by the communicator.

Definition at line 154 of file gnunet-communicator-udp.c.

Referenced by run(), and udp_address_to_sockaddr().

Function Documentation

◆ bi_destroy()

static void bi_destroy ( struct BroadcastInterface bi)
static

An interface went away, stop broadcasting on it.

Parameters
bientity to close down

Definition at line 904 of file gnunet-communicator-udp.c.

References BroadcastInterface::ba, BroadcastInterface::broadcast_task, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log_strerror, GNUNET_NETWORK_socket_setsockopt(), GNUNET_OK, GNUNET_SCHEDULER_cancel(), BroadcastInterface::mcreq, and BroadcastInterface::sa.

Referenced by do_broadcast(), and do_shutdown().

905 {
906  if (AF_INET6 == bi->sa->sa_family)
907  {
908  /* Leave the multicast group */
910  IPPROTO_IPV6,
911  IPV6_LEAVE_GROUP,
912  &bi->mcreq,
913  sizeof(bi->mcreq)))
914  {
916  }
917  }
920  GNUNET_free (bi->sa);
921  GNUNET_free (bi->ba);
922  GNUNET_free (bi);
923 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
int GNUNET_NETWORK_socket_setsockopt(struct GNUNET_NETWORK_Handle *fd, int level, int option_name, const void *option_value, socklen_t option_len)
Set socket option.
Definition: network.c:880
static struct BroadcastInterface * bi_tail
Broadcast interface tasks.
static struct BroadcastInterface * bi_head
Broadcast interface tasks.
struct sockaddr * ba
Broadcast address to use on the interface.
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
struct sockaddr * sa
Sender's address of the interface.
static struct GNUNET_NETWORK_Handle * udp_sock
Our socket.
struct ipv6_mreq mcreq
If this is an IPv6 interface, this is the request we use to join/leave the group. ...
struct GNUNET_SCHEDULER_Task * broadcast_task
Task for this broadcast interface.
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
Here is the call graph for this function:
Here is the caller graph for this function:

◆ receiver_destroy()

static void receiver_destroy ( struct ReceiverAddress receiver)
static

Destroys a receiving state due to timeout or shutdown.

Parameters
receiverentity to close down

Definition at line 932 of file gnunet-communicator-udp.c.

References ReceiverAddress::address, ReceiverAddress::d_qh, ReceiverAddress::foreign_addr, GNUNET_assert, GNUNET_CONTAINER_heap_remove_node(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_set(), GNUNET_TRANSPORT_communicator_mq_del(), GNUNET_YES, ReceiverAddress::hn, ReceiverAddress::kx_mq, ReceiverAddress::kx_qh, ReceiverAddress::receiver_destroy_called, and ReceiverAddress::target.

Referenced by check_timeouts(), get_receiver_delete_it(), mq_destroy_d(), mq_destroy_kx(), mq_error(), mq_send_d(), and mq_send_kx().

933 {
934 
936 
938  "Disconnecting receiver for peer `%s'\n",
939  GNUNET_i2s (&receiver->target));
940  /*if (NULL != (mq = receiver->kx_mq))
941  {
942  receiver->kx_mq = NULL;
943  GNUNET_MQ_destroy (mq);
944  }*/
945  if (NULL != receiver->kx_qh)
946  {
948  receiver->kx_qh = NULL;
949  receiver->kx_mq = NULL;
950  }
951  /*if (NULL != (mq = receiver->d_mq))
952  {
953  receiver->d_mq = NULL;
954  GNUNET_MQ_destroy (mq);
955  }*/
956  if (NULL != receiver->d_qh)
957  {
959  receiver->d_qh = NULL;
960  }
963  &receiver->target,
964  receiver));
965  GNUNET_assert (receiver == GNUNET_CONTAINER_heap_remove_node (receiver->hn));
967  "# receivers active",
969  GNUNET_NO);
970  GNUNET_free (receiver->address);
971  GNUNET_free (receiver->foreign_addr);
972  GNUNET_free (receiver);
973 }
struct GNUNET_CONTAINER_HeapNode * hn
Entry in sender expiration heap.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct sockaddr * address
Address of the other peer.
int GNUNET_CONTAINER_multipeermap_remove(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Remove the given key-value pair from the map.
void GNUNET_TRANSPORT_communicator_mq_del(struct GNUNET_TRANSPORT_QueueHandle *qh)
Notify transport service that an MQ became unavailable due to a disconnect or timeout.
struct GNUNET_TRANSPORT_QueueHandle * d_qh
handle for default queue with the ch.
char * foreign_addr
Address of the receiver in the human-readable format with the COMMUNICATOR_ADDRESS_PREFIX.
static struct GNUNET_CONTAINER_MultiPeerMap * receivers
Receivers (map from peer identity to struct ReceiverAddress)
struct GNUNET_MQ_Handle * kx_mq
KX message queue we are providing for the ch.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
int receiver_destroy_called
receiver_destroy already called on receiver.
#define GNUNET_log(kind,...)
static struct GNUNET_STATISTICS_Handle * stats
For logging statistics.
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
struct GNUNET_PeerIdentity target
To whom are we talking to.
void * GNUNET_CONTAINER_heap_remove_node(struct GNUNET_CONTAINER_HeapNode *node)
Removes a node from the heap.
struct GNUNET_TRANSPORT_QueueHandle * kx_qh
handle for KX queue with the ch.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ kce_destroy()

static void kce_destroy ( struct KeyCacheEntry kce)
static

Free memory used by key cache entry.

Parameters
kcethe key cache entry

Definition at line 982 of file gnunet-communicator-udp.c.

References SenderAddress::acks_available, SharedSecret::active_kce_count, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multishortmap_remove(), GNUNET_free, GNUNET_YES, SharedSecret::kce_head, SharedSecret::kce_tail, KeyCacheEntry::kid, SharedSecret::sender, and KeyCacheEntry::ss.

Referenced by consider_ss_ack(), decrypt_box(), decrypt_rekey(), and secret_destroy().

983 {
984  struct SharedSecret *ss = kce->ss;
985 
986  ss->active_kce_count--;
987  ss->sender->acks_available--;
990  &kce->kid,
991  kce));
992  GNUNET_free (kce);
993 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct KeyCacheEntry * kce_head
Kept in a DLL, sorted by sequence number.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static struct GNUNET_CONTAINER_MultiShortmap * key_cache
Cache of pre-generated key IDs.
int GNUNET_CONTAINER_multishortmap_remove(struct GNUNET_CONTAINER_MultiShortmap *map, const struct GNUNET_ShortHashCode *key, const void *value)
Remove the given key-value pair from the map.
struct SharedSecret * ss
Corresponding shared secret.
struct SenderAddress * sender
Sender we use this shared secret with, or NULL.
struct GNUNET_ShortHashCode kid
Key and IV identification code.
struct KeyCacheEntry * kce_tail
Kept in a DLL, sorted by sequence number.
unsigned int acks_available
Number of BOX keys from ACKs we have currently available for this sender.
Shared secret we generated for a particular sender or receiver.
unsigned int active_kce_count
Number of active KCN entries.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ get_kid()

static void get_kid ( const struct GNUNET_HashCode msec,
uint32_t  serial,
struct GNUNET_ShortHashCode kid 
)
static

Compute kid.

Parameters
msecmaster secret for HMAC calculation
serialnumber for the smac calculation
kid[out]where to write the key ID

Definition at line 1004 of file gnunet-communicator-udp.c.

References GNUNET_CRYPTO_hkdf().

Referenced by kce_generate(), mq_send_d(), and send_UDPRekey().

1007 {
1008  uint32_t sid = htonl (serial);
1009 
1010  GNUNET_CRYPTO_hkdf (kid,
1011  sizeof(*kid),
1012  GCRY_MD_SHA512,
1013  GCRY_MD_SHA256,
1014  &sid,
1015  sizeof(sid),
1016  msec,
1017  sizeof(*msec),
1018  "UDP-KID",
1019  strlen ("UDP-KID"),
1020  NULL,
1021  0);
1022 }
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_hkdf(void *result, size_t out_len, int xtr_algo, int prf_algo, const void *xts, size_t xts_len, const void *skm, size_t skm_len,...)
Derive key.
Definition: crypto_hkdf.c:320
Here is the call graph for this function:
Here is the caller graph for this function:

◆ kce_generate()

static void kce_generate ( struct SharedSecret ss,
uint32_t  seq 
)
static

Setup key cache entry for sequence number seq and shared secret ss.

Parameters
ssshared secret
seqsequence number for the key cache entry

Definition at line 1032 of file gnunet-communicator-udp.c.

References SenderAddress::acks_available, SharedSecret::active_kce_count, get_kid(), GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multishortmap_put(), GNUNET_CONTAINER_multishortmap_size(), GNUNET_new, GNUNET_NO, GNUNET_STATISTICS_set(), SharedSecret::kce_head, SharedSecret::kce_tail, KeyCacheEntry::kid, SharedSecret::master, SharedSecret::sender, KeyCacheEntry::sequence_number, and KeyCacheEntry::ss.

Referenced by consider_ss_ack(), kce_generate_cb(), and kce_generate_rekey_cb().

1033 {
1034  struct KeyCacheEntry *kce;
1035 
1036  GNUNET_assert (0 < seq);
1037  kce = GNUNET_new (struct KeyCacheEntry);
1038  kce->ss = ss;
1039  kce->sequence_number = seq;
1040  get_kid (&ss->master, seq, &kce->kid);
1042  ss->active_kce_count++;
1043  ss->sender->acks_available++;
1045  key_cache,
1046  &kce->kid,
1047  kce,
1050  "# KIDs active",
1052  GNUNET_NO);
1053 }
struct KeyCacheEntry * kce_head
Kept in a DLL, sorted by sequence number.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
unsigned int GNUNET_CONTAINER_multishortmap_size(const struct GNUNET_CONTAINER_MultiShortmap *map)
Get the number of key-value pairs in the map.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static struct GNUNET_CONTAINER_MultiShortmap * key_cache
Cache of pre-generated key IDs.
struct SharedSecret * ss
Corresponding shared secret.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct SenderAddress * sender
Sender we use this shared secret with, or NULL.
uint32_t sequence_number
Sequence number used to derive this entry from master key.
struct GNUNET_ShortHashCode kid
Key and IV identification code.
Pre-generated "kid" code (key and IV identification code) to quickly derive master key for a struct U...
struct GNUNET_HashCode master
Master shared secret.
struct KeyCacheEntry * kce_tail
Kept in a DLL, sorted by sequence number.
unsigned int acks_available
Number of BOX keys from ACKs we have currently available for this sender.
int GNUNET_CONTAINER_multishortmap_put(struct GNUNET_CONTAINER_MultiShortmap *map, const struct GNUNET_ShortHashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
static void get_kid(const struct GNUNET_HashCode *msec, uint32_t serial, struct GNUNET_ShortHashCode *kid)
Compute kid.
unsigned int active_kce_count
Number of active KCN entries.
Allow multiple values with the same key.
static struct GNUNET_STATISTICS_Handle * stats
For logging statistics.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ secret_destroy()

static int secret_destroy ( struct SharedSecret ss,
int  withoutKce 
)
static

Destroy ss and associated key cache entries.

Parameters
ssshared secret to destroy
withoutKceIf GNUNET_YES shared secrets with kce will not be destroyed.

Definition at line 1063 of file gnunet-communicator-udp.c.

References ReceiverAddress::acks_available, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multishortmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_set(), GNUNET_STATISTICS_update(), GNUNET_YES, kce_destroy(), SharedSecret::kce_head, SharedSecret::master, SenderAddress::num_secrets, ReceiverAddress::num_secrets, SharedSecret::receiver, UdpHandshakeSignature::receiver, SharedSecret::sender, UdpHandshakeSignature::sender, SharedSecret::sequence_allowed, SharedSecret::sequence_used, SenderAddress::ss_head, ReceiverAddress::ss_head, SenderAddress::ss_tail, and ReceiverAddress::ss_tail.

Referenced by destroy_all_secrets().

1064 {
1065  struct SenderAddress *sender;
1066  struct ReceiverAddress *receiver;
1067  struct KeyCacheEntry *kce;
1068 
1069  if (withoutKce && (ss->sequence_allowed > 0))
1070  return GNUNET_NO;
1071 
1073  "secret %s destroy %u %u\n",
1074  GNUNET_h2s (&ss->master),
1075  withoutKce,
1076  ss->sequence_allowed);
1077  if (NULL != (sender = ss->sender))
1078  {
1079  GNUNET_CONTAINER_DLL_remove (sender->ss_head, sender->ss_tail, ss);
1080  sender->num_secrets--;
1081  }
1082  if (NULL != (receiver = ss->receiver))
1083  {
1084  GNUNET_CONTAINER_DLL_remove (receiver->ss_head, receiver->ss_tail, ss);
1085  receiver->num_secrets--;
1086  // Uncomment this for alternativ 1 of backchannel functionality
1087  receiver->acks_available -= (ss->sequence_allowed - ss->sequence_used);
1089  "%u receiver->acks_available 3\n",
1090  receiver->acks_available);
1091  // Until here for alternativ 1
1092  }
1093  while (NULL != (kce = ss->kce_head))
1094  kce_destroy (kce);
1095  GNUNET_STATISTICS_update (stats, "# Secrets active", -1, GNUNET_NO);
1097  "# KIDs active",
1099  GNUNET_NO);
1100  GNUNET_free (ss);
1101  return GNUNET_YES;
1102 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct SharedSecret * ss_tail
Shared secrets we used with target, last used is tail.
struct KeyCacheEntry * kce_head
Kept in a DLL, sorted by sequence number.
unsigned int GNUNET_CONTAINER_multishortmap_size(const struct GNUNET_CONTAINER_MultiShortmap *map)
Get the number of key-value pairs in the map.
static struct GNUNET_CONTAINER_MultiShortmap * key_cache
Cache of pre-generated key IDs.
uint32_t sequence_allowed
Up to which sequence number did the other peer allow us to use this key, or up to which number did we...
unsigned int num_secrets
Length of the DLL at ss_head.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
static void kce_destroy(struct KeyCacheEntry *kce)
Free memory used by key cache entry.
struct SenderAddress * sender
Sender we use this shared secret with, or NULL.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
struct SharedSecret * ss_head
Shared secrets we used with target, first used is head.
Pre-generated "kid" code (key and IV identification code) to quickly derive master key for a struct U...
uint32_t sequence_used
Up to which sequence number did we use this master already? (for encrypting only) ...
struct GNUNET_HashCode master
Master shared secret.
struct SharedSecret * ss_tail
Shared secrets we received with target, last used is tail.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
Information we track per receiving address we have recently been in contact with (encryption to recei...
unsigned int num_secrets
Length of the DLL at ss_head.
void receiver(void *cls, const void *buf, size_t available, const struct sockaddr *addr, socklen_t addrlen, int errCode)
Callback to read from the SOCKS5 proxy.
Definition: socks.c:329
unsigned int acks_available
Number of BOX keys from ACKs we have currently available for this receiver.
struct ReceiverAddress * receiver
Receiver we use this shared secret with, or NULL.
Information we track per sender address we have recently been in contact with (we decrypt messages fr...
#define GNUNET_log(kind,...)
static struct GNUNET_STATISTICS_Handle * stats
For logging statistics.
#define GNUNET_free(ptr)
Wrapper around free.
struct SharedSecret * ss_head
Shared secrets we received from target, first used is head.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ sender_destroy()

static void sender_destroy ( struct SenderAddress sender)
static

Functions with this signature are called whenever we need to close a sender's state due to timeout.

Parameters
senderentity to close down

Definition at line 1112 of file gnunet-communicator-udp.c.

References SenderAddress::address, GNUNET_assert, GNUNET_CONTAINER_heap_remove_node(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_free, GNUNET_NO, GNUNET_STATISTICS_set(), GNUNET_YES, SenderAddress::hn, SenderAddress::sender_destroy_called, and SenderAddress::target.

Referenced by check_timeouts(), and get_sender_delete_it().

1113 {
1115  GNUNET_assert (
1116  GNUNET_YES ==
1118  GNUNET_assert (sender == GNUNET_CONTAINER_heap_remove_node (sender->hn));
1120  "# senders active",
1122  GNUNET_NO);
1123  GNUNET_free (sender->address);
1124  GNUNET_free (sender);
1125 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
int sender_destroy_called
sender_destroy already called on sender.
int GNUNET_CONTAINER_multipeermap_remove(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Remove the given key-value pair from the map.
struct GNUNET_PeerIdentity target
To whom are we talking to.
struct sockaddr * address
Address of the other peer.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
static struct GNUNET_CONTAINER_MultiPeerMap * senders
Senders (map from peer identity to struct SenderAddress)
struct GNUNET_CONTAINER_HeapNode * hn
Entry in sender expiration heap.
static struct GNUNET_STATISTICS_Handle * stats
For logging statistics.
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
void * GNUNET_CONTAINER_heap_remove_node(struct GNUNET_CONTAINER_HeapNode *node)
Removes a node from the heap.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ get_iv_key()

static void get_iv_key ( const struct GNUNET_HashCode msec,
uint32_t  serial,
char  key[(256/8)],
char  iv[(96/8)] 
)
static

Compute key and iv.

Parameters
msecmaster secret for calculation
serialnumber for the smac calculation
key[out]where to write the decryption key
iv[out]where to write the IV

Definition at line 1137 of file gnunet-communicator-udp.c.

References AES_IV_SIZE, GNUNET_CRYPTO_hkdf(), key, and res.

Referenced by setup_cipher().

1141 {
1142  uint32_t sid = htonl (serial);
1143  char res[AES_KEY_SIZE + AES_IV_SIZE];
1144 
1145  GNUNET_CRYPTO_hkdf (res,
1146  sizeof(res),
1147  GCRY_MD_SHA512,
1148  GCRY_MD_SHA256,
1149  &sid,
1150  sizeof(sid),
1151  msec,
1152  sizeof(*msec),
1153  "UDP-IV-KEY",
1154  strlen ("UDP-IV-KEY"),
1155  NULL,
1156  0);
1157  memcpy (key, res, AES_KEY_SIZE);
1158  memcpy (iv, &res[AES_KEY_SIZE], AES_IV_SIZE);
1159 }
#define AES_IV_SIZE
AES (GCM) IV size.
static int res
struct GNUNET_HashCode key
The key used in the DHT.
#define AES_KEY_SIZE
AES key size.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_hkdf(void *result, size_t out_len, int xtr_algo, int prf_algo, const void *xts, size_t xts_len, const void *skm, size_t skm_len,...)
Derive key.
Definition: crypto_hkdf.c:320
Here is the call graph for this function:
Here is the caller graph for this function:

◆ reschedule_sender_timeout()

static void reschedule_sender_timeout ( struct SenderAddress sender)
static

Increment sender timeout due to activity.

Parameters
senderaddress for which the timeout should be rescheduled

Definition at line 1168 of file gnunet-communicator-udp.c.

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_CONTAINER_heap_update_cost(), GNUNET_TIME_relative_to_absolute(), SenderAddress::hn, and SenderAddress::timeout.

Referenced by setup_sender().

1169 {
1170  sender->timeout =
1173 }
void GNUNET_CONTAINER_heap_update_cost(struct GNUNET_CONTAINER_HeapNode *node, GNUNET_CONTAINER_HeapCostType new_cost)
Updates the cost of any node in the tree.
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:181
struct GNUNET_TIME_Absolute timeout
Timeout for this sender.
uint64_t abs_value_us
The actual value.
#define GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT
After how long do we consider a connection to a peer dead if we don&#39;t receive messages from the peer...
struct GNUNET_CONTAINER_HeapNode * hn
Entry in sender expiration heap.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ reschedule_receiver_timeout()

static void reschedule_receiver_timeout ( struct ReceiverAddress receiver)
static

Increment receiver timeout due to activity.

Parameters
receiveraddress for which the timeout should be rescheduled

Definition at line 1182 of file gnunet-communicator-udp.c.

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_CONTAINER_heap_update_cost(), GNUNET_TIME_relative_to_absolute(), ReceiverAddress::hn, and ReceiverAddress::timeout.

Referenced by mq_send_d(), and mq_send_kx().

1183 {
1184  receiver->timeout =
1187  receiver->timeout.abs_value_us);
1188 }
void GNUNET_CONTAINER_heap_update_cost(struct GNUNET_CONTAINER_HeapNode *node, GNUNET_CONTAINER_HeapCostType new_cost)
Updates the cost of any node in the tree.
struct GNUNET_CONTAINER_HeapNode * hn
Entry in sender expiration heap.
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:181
uint64_t abs_value_us
The actual value.
#define GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT
After how long do we consider a connection to a peer dead if we don&#39;t receive messages from the peer...
struct GNUNET_TIME_Absolute timeout
Timeout for this receiver address.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ check_timeouts()

static void check_timeouts ( void *  cls)
static

Task run to check #receiver_heap and #sender_heap for timeouts.

Parameters
clsunused, NULL

Definition at line 1197 of file gnunet-communicator-udp.c.

References GNUNET_CONTAINER_heap_peek(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_relative_min(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, UdpHandshakeSignature::receiver, receiver_destroy(), GNUNET_TIME_Relative::rel_value_us, UdpHandshakeSignature::sender, sender_destroy(), SenderAddress::sender_destroy_called, SenderAddress::timeout, and ReceiverAddress::timeout.

Referenced by mq_init(), and setup_sender().

1198 {
1199  struct GNUNET_TIME_Relative st;
1200  struct GNUNET_TIME_Relative rt;
1201  struct GNUNET_TIME_Relative delay;
1202  struct ReceiverAddress *receiver;
1203  struct SenderAddress *sender;
1204 
1205  (void) cls;
1206  timeout_task = NULL;
1208  while (NULL != (receiver = GNUNET_CONTAINER_heap_peek (receivers_heap)))
1209  {
1210  /* if (GNUNET_YES != receiver->receiver_destroy_called) */
1211  /* { */
1213  if (0 != rt.rel_value_us)
1214  break;
1216  "Receiver timed out\n");
1217  receiver_destroy (receiver);
1218  // }
1219  }
1221  while (NULL != (sender = GNUNET_CONTAINER_heap_peek (senders_heap)))
1222  {
1223  if (GNUNET_YES != sender->sender_destroy_called)
1224  {
1226  if (0 != st.rel_value_us)
1227  break;
1228  sender_destroy (sender);
1229  }
1230  }
1232  if (delay.rel_value_us < GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
1234 }
uint64_t rel_value_us
The actual value.
int sender_destroy_called
sender_destroy already called on sender.
struct GNUNET_TIME_Absolute timeout
Timeout for this sender.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1269
void * GNUNET_CONTAINER_heap_peek(const struct GNUNET_CONTAINER_Heap *heap)
Get element stored at the root of heap.
static void check_timeouts(void *cls)
Task run to check #receiver_heap and #sender_heap for timeouts.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
Information we track per receiving address we have recently been in contact with (encryption to recei...
struct GNUNET_TIME_Relative GNUNET_TIME_relative_min(struct GNUNET_TIME_Relative t1, struct GNUNET_TIME_Relative t2)
Return the minimum of two relative time values.
Definition: time.c:200
static struct GNUNET_CONTAINER_Heap * senders_heap
Expiration heap for senders (contains struct SenderAddress)
static struct GNUNET_TIME_Relative delay
When should dkg communication start?
void receiver(void *cls, const void *buf, size_t available, const struct sockaddr *addr, socklen_t addrlen, int errCode)
Callback to read from the SOCKS5 proxy.
Definition: socks.c:329
static struct GNUNET_CONTAINER_Heap * receivers_heap
Expiration heap for receivers (contains struct ReceiverAddress)
Information we track per sender address we have recently been in contact with (we decrypt messages fr...
static void receiver_destroy(struct ReceiverAddress *receiver)
Destroys a receiving state due to timeout or shutdown.
#define GNUNET_log(kind,...)
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:232
static struct GNUNET_SCHEDULER_Task * st
The shutdown task.
struct GNUNET_TIME_Absolute timeout
Timeout for this receiver address.
static void sender_destroy(struct SenderAddress *sender)
Functions with this signature are called whenever we need to close a sender&#39;s state due to timeout...
Time for relative time used by GNUnet, in microseconds.
static struct GNUNET_SCHEDULER_Task * timeout_task
ID of timeout task.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ calculate_cmac()

static void calculate_cmac ( struct SharedSecret ss)
static

Calculate cmac from master in ss.

Parameters
ss[in,out]data structure to complete

Definition at line 1243 of file gnunet-communicator-udp.c.

References SharedSecret::cmac, GNUNET_CRYPTO_hkdf(), and SharedSecret::master.

Referenced by decrypt_rekey(), setup_shared_secret_enc(), and sock_read().

1244 {
1245  GNUNET_CRYPTO_hkdf (&ss->cmac,
1246  sizeof(ss->cmac),
1247  GCRY_MD_SHA512,
1248  GCRY_MD_SHA256,
1249  "CMAC",
1250  strlen ("CMAC"),
1251  &ss->master,
1252  sizeof(ss->master),
1253  "UDP-CMAC",
1254  strlen ("UDP-CMAC"),
1255  NULL,
1256  0);
1257 }
struct GNUNET_HashCode cmac
CMAC is used to identify master in ACKs.
struct GNUNET_HashCode master
Master shared secret.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_hkdf(void *result, size_t out_len, int xtr_algo, int prf_algo, const void *xts, size_t xts_len, const void *skm, size_t skm_len,...)
Derive key.
Definition: crypto_hkdf.c:320
Here is the call graph for this function:
Here is the caller graph for this function:

◆ pass_plaintext_to_core()

static void pass_plaintext_to_core ( struct SenderAddress sender,
const void *  plaintext,
size_t  plaintext_len 
)
static

We received plaintext_len bytes of plaintext from a sender.

Pass it on to CORE.

Parameters
queuethe queue that received the plaintext
plaintextthe plaintext that was received
plaintext_lennumber of bytes of plaintext received

Definition at line 1269 of file gnunet-communicator-udp.c.

References ADDRESS_VALIDITY_PERIOD, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_TRANSPORT_communicator_receive(), GNUNET_MessageHeader::size, and SenderAddress::target.

Referenced by try_handle_plaintext().

1272 {
1273  const struct GNUNET_MessageHeader *hdr = plaintext;
1274  const char *pos = plaintext;
1275 
1276  while (ntohs (hdr->size) < plaintext_len)
1277  {
1279  "# bytes given to core",
1280  ntohs (hdr->size),
1281  GNUNET_NO);
1283  "Giving %u bytes to TNG\n", ntohs (hdr->size));
1286  &sender->target,
1287  hdr,
1289  NULL /* no flow control possible */
1290  ,
1291  NULL));
1292  /* move on to next message, if any */
1293  plaintext_len -= ntohs (hdr->size);
1294  if (plaintext_len < sizeof(*hdr))
1295  break;
1296  pos += ntohs (hdr->size);
1297  hdr = (const struct GNUNET_MessageHeader *) pos;
1298  // TODO for now..., we do not actually sen >1msg or have a way of telling
1299  // if we are done
1300  break;
1301  }
1303  "# bytes padding discarded",
1304  plaintext_len,
1305  GNUNET_NO);
1306 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
struct GNUNET_PeerIdentity target
To whom are we talking to.
int GNUNET_TRANSPORT_communicator_receive(struct GNUNET_TRANSPORT_CommunicatorHandle *handle, const struct GNUNET_PeerIdentity *sender, const struct GNUNET_MessageHeader *msg, struct GNUNET_TIME_Relative expected_addr_validity, GNUNET_TRANSPORT_MessageCompletedCallback cb, void *cb_cls)
Notify transport service that the communicator has received a message.
#define ADDRESS_VALIDITY_PERIOD
How long do we believe our addresses to remain up (before the other peer should revalidate).
#define GNUNET_log(kind,...)
static struct GNUNET_STATISTICS_Handle * stats
For logging statistics.
Header for all communications.
static struct GNUNET_TRANSPORT_CommunicatorHandle * ch
Our environment.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ setup_cipher()

static void setup_cipher ( const struct GNUNET_HashCode msec,
uint32_t  serial,
gcry_cipher_hd_t *  cipher 
)
static

Setup cipher based on shared secret msec and serial number serial.

Parameters
msecmaster shared secret
serialserial number of cipher to set up
cipher[out]cipher to initialize

Definition at line 1318 of file gnunet-communicator-udp.c.

References AES_IV_SIZE, AES_KEY_SIZE, get_iv_key(), GNUNET_assert, and key.

Referenced by mq_send_d(), mq_send_kx(), send_UDPRekey(), and try_decrypt().

1321 {
1322  char key[AES_KEY_SIZE];
1323  char iv[AES_IV_SIZE];
1324  int rc;
1325 
1326  GNUNET_assert (0 ==
1327  gcry_cipher_open (cipher,
1328  GCRY_CIPHER_AES256 /* low level: go for speed */,
1329  GCRY_CIPHER_MODE_GCM,
1330  0 /* flags */));
1331  get_iv_key (msec, serial, key, iv);
1332  rc = gcry_cipher_setkey (*cipher, key, sizeof(key));
1333  GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY));
1334  rc = gcry_cipher_setiv (*cipher, iv, sizeof(iv));
1335  GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY));
1336 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define AES_IV_SIZE
AES (GCM) IV size.
struct GNUNET_HashCode key
The key used in the DHT.
#define AES_KEY_SIZE
AES key size.
static void get_iv_key(const struct GNUNET_HashCode *msec, uint32_t serial, char key[(256/8)], char iv[(96/8)])
Compute key and iv.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ try_decrypt()

static int try_decrypt ( const struct SharedSecret ss,
const char  tag[(128/8)],
uint32_t  serial,
const char *  in_buf,
size_t  in_buf_size,
char *  out_buf 
)
static

Try to decrypt buf using shared secret ss and key/iv derived using serial.

Parameters
ssshared secret
tagGCM authentication tag
serialserial number to use
in_bufinput buffer to decrypt
in_buf_sizenumber of bytes in in_buf and available in out_buf
out_bufwhere to write the result
Returns
GNUNET_OK on success

Definition at line 1352 of file gnunet-communicator-udp.c.

References GNUNET_assert, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_SYSERR, SharedSecret::master, and setup_cipher().

Referenced by decrypt_box(), decrypt_rekey(), and sock_read().

1358 {
1359  gcry_cipher_hd_t cipher;
1360 
1361  setup_cipher (&ss->master, serial, &cipher);
1362  GNUNET_assert (
1363  0 ==
1364  gcry_cipher_decrypt (cipher, out_buf, in_buf_size, in_buf, in_buf_size));
1365  if (0 != gcry_cipher_checktag (cipher, tag, GCM_TAG_SIZE))
1366  {
1367  gcry_cipher_close (cipher);
1369  "# AEAD authentication failures",
1370  1,
1371  GNUNET_NO);
1372  return GNUNET_SYSERR;
1373  }
1374  gcry_cipher_close (cipher);
1375  return GNUNET_OK;
1376 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GCM_TAG_SIZE
Size of the GCM tag.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
static void setup_cipher(const struct GNUNET_HashCode *msec, uint32_t serial, gcry_cipher_hd_t *cipher)
Setup cipher based on shared secret msec and serial number serial.
struct GNUNET_HashCode master
Master shared secret.
static struct GNUNET_STATISTICS_Handle * stats
For logging statistics.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ setup_shared_secret_dec()

static struct SharedSecret* setup_shared_secret_dec ( const struct GNUNET_CRYPTO_EcdhePublicKey ephemeral)
static

Setup shared secret for decryption.

Parameters
ephemeralephemeral key we received from the other peer
Returns
new shared secret

Definition at line 1386 of file gnunet-communicator-udp.c.

References GNUNET_CRYPTO_eddsa_ecdh(), GNUNET_new, and SharedSecret::master.

Referenced by sock_read().

1387 {
1388  struct SharedSecret *ss;
1389 
1390  ss = GNUNET_new (struct SharedSecret);
1391  GNUNET_CRYPTO_eddsa_ecdh (my_private_key, ephemeral, &ss->master);
1392  return ss;
1393 }
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_HashCode master
Master shared secret.
static struct GNUNET_CRYPTO_EddsaPrivateKey * my_private_key
Our private key.
Shared secret we generated for a particular sender or receiver.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_ecdh(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, const struct GNUNET_CRYPTO_EcdhePublicKey *pub, struct GNUNET_HashCode *key_material)
Derive key material from a ECDH public key and a private EdDSA key.
Definition: crypto_ecc.c:718
Here is the call graph for this function:
Here is the caller graph for this function:

◆ setup_shared_secret_enc()

static struct SharedSecret* setup_shared_secret_enc ( const struct GNUNET_CRYPTO_EcdhePrivateKey ephemeral,
struct ReceiverAddress receiver,
int  add_to_receiver 
)
static

Setup shared secret for encryption.

Parameters
ephemeralephemeral key we are sending to the other peer
receiver[in,out]queue to initialize encryption key for
Returns
new shared secret

Definition at line 1404 of file gnunet-communicator-udp.c.

References calculate_cmac(), GNUNET_CONTAINER_DLL_insert, GNUNET_CRYPTO_ecdh_eddsa(), GNUNET_new, GNUNET_NO, GNUNET_STATISTICS_update(), SharedSecret::master, ReceiverAddress::num_secrets, GNUNET_PeerIdentity::public_key, SharedSecret::receiver, UdpHandshakeSignature::receiver, setup_receiver_mq(), ReceiverAddress::ss_head, ReceiverAddress::ss_tail, and ReceiverAddress::target.

Referenced by mq_send_kx(), and send_UDPRekey().

1406 {
1407  struct SharedSecret *ss;
1408 
1409  ss = GNUNET_new (struct SharedSecret);
1410  GNUNET_CRYPTO_ecdh_eddsa (ephemeral,
1411  &receiver->target.public_key,
1412  &ss->master);
1413  calculate_cmac (ss);
1414  ss->receiver = receiver;
1415  GNUNET_CONTAINER_DLL_insert (receiver->ss_head, receiver->ss_tail, ss);
1416  receiver->num_secrets++;
1417  GNUNET_STATISTICS_update (stats, "# Secrets active", 1, GNUNET_NO);
1418  return ss;
1419 }
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
unsigned int num_secrets
Length of the DLL at ss_head.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecdh_eddsa(const struct GNUNET_CRYPTO_EcdhePrivateKey *priv, const struct GNUNET_CRYPTO_EddsaPublicKey *pub, struct GNUNET_HashCode *key_material)
Derive key material from a EdDSA public key and a private ECDH key.
Definition: crypto_ecc.c:758
struct GNUNET_HashCode master
Master shared secret.
struct SharedSecret * ss_tail
Shared secrets we received with target, last used is tail.
Shared secret we generated for a particular sender or receiver.
void receiver(void *cls, const void *buf, size_t available, const struct sockaddr *addr, socklen_t addrlen, int errCode)
Callback to read from the SOCKS5 proxy.
Definition: socks.c:329
struct ReceiverAddress * receiver
Receiver we use this shared secret with, or NULL.
static struct GNUNET_STATISTICS_Handle * stats
For logging statistics.
static void calculate_cmac(struct SharedSecret *ss)
Calculate cmac from master in ss.
struct GNUNET_PeerIdentity target
To whom are we talking to.
struct GNUNET_CRYPTO_EddsaPublicKey public_key
struct SharedSecret * ss_head
Shared secrets we received from target, first used is head.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ setup_receiver_mq()

static void setup_receiver_mq ( struct ReceiverAddress receiver)
static

Setup the MQ for the receiver.

If a queue exists, the existing one is destroyed. Then the MTU is recalculated and a fresh queue is initialized.

Parameters
receiverreceiver to setup MQ for

Definition at line 3068 of file gnunet-communicator-udp.c.

References ReceiverAddress::address, ReceiverAddress::d_mq, ReceiverAddress::d_mtu, ReceiverAddress::d_qh, ReceiverAddress::foreign_addr, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MQ_queue_for_callbacks(), GNUNET_TRANSPORT_communicator_mq_add(), GNUNET_TRANSPORT_CS_OUTBOUND, GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED, ReceiverAddress::kx_mq, ReceiverAddress::kx_mtu, ReceiverAddress::kx_qh, mq_cancel(), mq_destroy_d(), mq_destroy_kx(), mq_error(), mq_send_d(), mq_send_kx(), ReceiverAddress::nt, and ReceiverAddress::target.

Referenced by mq_init(), and setup_shared_secret_enc().

3069 {
3070  size_t base_mtu;
3071 
3072  /*if (NULL != receiver->kx_qh)
3073  {
3074  GNUNET_TRANSPORT_communicator_mq_del (receiver->kx_qh);
3075  receiver->kx_qh = NULL;
3076  }
3077  if (NULL != receiver->d_qh)
3078  {
3079  GNUNET_TRANSPORT_communicator_mq_del (receiver->d_qh);
3080  receiver->d_qh = NULL;
3081  }*/
3082  // GNUNET_assert (NULL == receiver->mq);
3083  switch (receiver->address->sa_family)
3084  {
3085  case AF_INET:
3086  base_mtu = 1480 /* Ethernet MTU, 1500 - Ethernet header - VLAN tag */
3087  - sizeof(struct GNUNET_TUN_IPv4Header) /* 20 */
3088  - sizeof(struct GNUNET_TUN_UdpHeader) /* 8 */;
3089  break;
3090 
3091  case AF_INET6:
3092  base_mtu = 1280 /* Minimum MTU required by IPv6 */
3093  - sizeof(struct GNUNET_TUN_IPv6Header) /* 40 */
3094  - sizeof(struct GNUNET_TUN_UdpHeader) /* 8 */;
3095  break;
3096 
3097  default:
3098  GNUNET_assert (0);
3099  break;
3100  }
3101  /* MTU based on full KX messages */
3102  receiver->kx_mtu = base_mtu - sizeof(struct InitialKX) /* 48 */
3103  - sizeof(struct UDPConfirmation); /* 104 */
3104  /* MTU based on BOXed messages */
3105  receiver->d_mtu = base_mtu - sizeof(struct UDPBox);
3106 
3108  "Setting up MQs and QHs\n");
3109  /* => Effective MTU for CORE will range from 1080 (IPv6 + KX) to
3110  1404 (IPv4 + Box) bytes, depending on circumstances... */
3111  if (NULL == receiver->kx_mq)
3113  &mq_destroy_kx,
3114  &mq_cancel,
3115  receiver,
3116  NULL,
3117  &mq_error,
3118  receiver);
3119  if (NULL == receiver->d_mq)
3121  &mq_destroy_d,
3122  &mq_cancel,
3123  receiver,
3124  NULL,
3125  &mq_error,
3126  receiver);
3127 
3128  receiver->kx_qh =
3130  &receiver->target,
3131  receiver->foreign_addr,
3132  receiver->kx_mtu,
3134  0, /* Priority */
3135  receiver->nt,
3137  receiver->kx_mq);
3138  receiver->d_qh =
3140  &receiver->target,
3141  receiver->foreign_addr,
3142  receiver->d_mtu,
3143  0, /* Initialize with 0 acks */
3144  1, /* Priority */
3145  receiver->nt,
3147  receiver->d_mq);
3148 
3149 }
static void mq_send_d(struct GNUNET_MQ_Handle *mq, const struct GNUNET_MessageHeader *msg, void *impl_state)
Signature of functions implementing the sending functionality of a message queue. ...
static void mq_destroy_d(struct GNUNET_MQ_Handle *mq, void *impl_state)
Signature of functions implementing the destruction of a message queue.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct sockaddr * address
Address of the other peer.
UDP packet header.
Standard IPv4 header.
Encrypted continuation of UDP initial handshake, followed by message header with payload.
"Plaintext" header at beginning of KX message.
struct GNUNET_TRANSPORT_QueueHandle * d_qh
handle for default queue with the ch.
char * foreign_addr
Address of the receiver in the human-readable format with the COMMUNICATOR_ADDRESS_PREFIX.
struct GNUNET_MQ_Handle * GNUNET_MQ_queue_for_callbacks(GNUNET_MQ_SendImpl send, GNUNET_MQ_DestroyImpl destroy, GNUNET_MQ_CancelImpl cancel, void *impl_state, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *cls)
Create a message queue for the specified handlers.
Definition: mq.c:565
enum GNUNET_NetworkType nt
Which network type does this queue use?
struct GNUNET_MQ_Handle * kx_mq
KX message queue we are providing for the ch.
size_t kx_mtu
MTU we allowed transport for this receiver&#39;s KX queue.
UDP message box.
static void mq_destroy_kx(struct GNUNET_MQ_Handle *mq, void *impl_state)
Signature of functions implementing the destruction of a message queue.
static void mq_cancel(struct GNUNET_MQ_Handle *mq, void *impl_state)
Implementation function that cancels the currently sent message.
size_t d_mtu
MTU we allowed transport for this receiver&#39;s default queue.
struct GNUNET_TRANSPORT_QueueHandle * GNUNET_TRANSPORT_communicator_mq_add(struct GNUNET_TRANSPORT_CommunicatorHandle *ch, const struct GNUNET_PeerIdentity *peer, const char *address, uint32_t mtu, uint64_t q_len, uint32_t priority, enum GNUNET_NetworkType nt, enum GNUNET_TRANSPORT_ConnectionStatus cs, struct GNUNET_MQ_Handle *mq)
Notify transport service that a MQ became available due to an "inbound" connection or because the com...
Standard IPv6 header.
#define GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED
Queue length.
this is an outbound connection (transport initiated)
#define GNUNET_log(kind,...)
static void mq_error(void *cls, enum GNUNET_MQ_Error error)
Generic error handler, called with the appropriate error code and the same closure specified at the c...
static struct GNUNET_TRANSPORT_CommunicatorHandle * ch
Our environment.
struct GNUNET_PeerIdentity target
To whom are we talking to.
static void mq_send_kx(struct GNUNET_MQ_Handle *mq, const struct GNUNET_MessageHeader *msg, void *impl_state)
Signature of functions implementing the sending functionality of a message queue. ...
struct GNUNET_TRANSPORT_QueueHandle * kx_qh
handle for KX queue with the ch.
struct GNUNET_MQ_Handle * d_mq
Default message queue we are providing for the ch.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ destroy_all_secrets()

static void destroy_all_secrets ( struct SharedSecret ss,
int  withoutKce 
)
static

Destroying all secrets.

Depending on parameter we keep those secrets having a kce.

Parameters
ssThe secret we will not destroy.
withoutKceIf GNUNET_YES shared secrets with kce will not be destroyed.

Definition at line 1439 of file gnunet-communicator-udp.c.

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_NO, SharedSecret::next, SharedSecret::receiver, UdpHandshakeSignature::receiver, secret_destroy(), SharedSecret::sender, UdpHandshakeSignature::sender, SenderAddress::ss_head, and ReceiverAddress::ss_head.

Referenced by add_acks(), consider_ss_ack(), and mq_send_kx().

1440 {
1441  struct SenderAddress *sender;
1442  struct ReceiverAddress *receiver;
1443  struct SharedSecret *ss_to_destroy;
1444  struct SharedSecret *ss_start;
1445  struct SharedSecret *pos;
1446  int at_least_one_destroyed = GNUNET_NO;
1447 
1449  "Starting destroy all withoutKce: %u.\n",
1450  withoutKce);
1451 
1452  if (NULL != (sender = ss->sender))
1453  {
1454  ss_start = sender->ss_head;
1455  }
1456  else if (NULL != (receiver = ss->receiver))
1457  {
1458  ss_start = receiver->ss_head;
1459  }
1460  else
1461  {
1463  "Shared secret has no sender or receiver!\n");
1464  return;
1465  }
1466 
1467  pos = ss_start;
1468  while (NULL != pos)
1469  {
1470  ss_to_destroy = pos;
1471  pos = pos->next;
1472 
1473  if (ss != ss_to_destroy)
1474  at_least_one_destroyed = secret_destroy (ss_to_destroy, withoutKce);
1475  }
1476 
1477  if ((ss != ss_start) && ! at_least_one_destroyed)
1478  {
1480  "Really destroying all.\n");
1481  destroy_all_secrets (ss_start, GNUNET_NO);
1482  }
1483 
1485  "Finished destroy all.\n");
1486 }
struct SenderAddress * sender
Sender we use this shared secret with, or NULL.
struct SharedSecret * ss_head
Shared secrets we used with target, first used is head.
struct SharedSecret * next
Kept in a DLL.
Information we track per receiving address we have recently been in contact with (encryption to recei...
Shared secret we generated for a particular sender or receiver.
void receiver(void *cls, const void *buf, size_t available, const struct sockaddr *addr, socklen_t addrlen, int errCode)
Callback to read from the SOCKS5 proxy.
Definition: socks.c:329
struct ReceiverAddress * receiver
Receiver we use this shared secret with, or NULL.
static int secret_destroy(struct SharedSecret *ss, int withoutKce)
Destroy ss and associated key cache entries.
Information we track per sender address we have recently been in contact with (we decrypt messages fr...
#define GNUNET_log(kind,...)
static void destroy_all_secrets(struct SharedSecret *ss, int withoutKce)
Destroying all secrets.
struct SharedSecret * ss_head
Shared secrets we received from target, first used is head.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ add_acks()

static void add_acks ( struct SharedSecret ss,
int  acks_to_add 
)
static

Definition at line 1490 of file gnunet-communicator-udp.c.

References ReceiverAddress::d_qh, destroy_all_secrets(), GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_TRANSPORT_communicator_mq_update(), GNUNET_YES, ReceiverAddress::number_rekeying_kce, SharedSecret::receiver, ReceiverAddress::ss_head, and ReceiverAddress::ss_tail.

Referenced by add_acks_rekey(), and handle_ack().

1491 {
1492 
1493  struct ReceiverAddress *receiver = ss->receiver;
1494 
1495  GNUNET_assert (NULL != ss);
1496  GNUNET_assert (NULL != receiver);
1497  GNUNET_assert (NULL != receiver->d_qh);
1498 
1500  "Tell transport we have %u more acks!\n",
1501  acks_to_add);
1503  "%u kce for rekeying.\n",
1504  receiver->number_rekeying_kce);
1506  receiver->d_qh,
1507  acks_to_add,
1508  1);
1509  // Until here for alternativ 1
1510 
1511  /* move ss to head to avoid discarding it anytime soon! */
1512 
1513  GNUNET_CONTAINER_DLL_remove (receiver->ss_head, receiver->ss_tail, ss);
1514  GNUNET_CONTAINER_DLL_insert (receiver->ss_head, receiver->ss_tail, ss);
1516 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_TRANSPORT_QueueHandle * d_qh
handle for default queue with the ch.
struct SharedSecret * ss_tail
Shared secrets we received with target, last used is tail.
Information we track per receiving address we have recently been in contact with (encryption to recei...
void receiver(void *cls, const void *buf, size_t available, const struct sockaddr *addr, socklen_t addrlen, int errCode)
Callback to read from the SOCKS5 proxy.
Definition: socks.c:329
struct ReceiverAddress * receiver
Receiver we use this shared secret with, or NULL.
#define GNUNET_log(kind,...)
int number_rekeying_kce
Number of kce we retain for sending the rekeying shared secret.
static struct GNUNET_TRANSPORT_CommunicatorHandle * ch
Our environment.
static void destroy_all_secrets(struct SharedSecret *ss, int withoutKce)
Destroying all secrets.
void GNUNET_TRANSPORT_communicator_mq_update(struct GNUNET_TRANSPORT_CommunicatorHandle *ch, const struct GNUNET_TRANSPORT_QueueHandle *u_qh, uint64_t q_len, uint32_t priority)
Notify transport service that an MQ was updated.
struct SharedSecret * ss_head
Shared secrets we received from target, first used is head.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ reset_rekey_kces()

static uint32_t reset_rekey_kces ( struct ReceiverAddress receiver,
uint32_t  acks_to_add 
)
static

Definition at line 1520 of file gnunet-communicator-udp.c.

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, and ReceiverAddress::number_rekeying_kce.

Referenced by add_acks_rekey(), and handle_ack().

1522 {
1523  int needed_for_rekeying;
1524 
1526  "%u kce for rekeying and %u acks_to_add\n",
1527  receiver->number_rekeying_kce,
1528  acks_to_add);
1529 
1530  needed_for_rekeying = (3 - receiver->number_rekeying_kce);
1531  if (acks_to_add <= needed_for_rekeying)
1532  {
1533  receiver->number_rekeying_kce += acks_to_add;
1534  acks_to_add = 0;
1535  }
1536  else
1537  {
1538  acks_to_add -= (3 - receiver->number_rekeying_kce);
1539  receiver->number_rekeying_kce = 3;
1540  }
1541 
1543  "%u kce for rekeying and %u acks_to_add\n",
1544  receiver->number_rekeying_kce,
1545  acks_to_add);
1546  return acks_to_add;
1547 }
#define GNUNET_log(kind,...)
int number_rekeying_kce
Number of kce we retain for sending the rekeying shared secret.
Here is the caller graph for this function:

◆ add_acks_rekey()

static void add_acks_rekey ( struct ReceiverAddress receiver)
static

Definition at line 1551 of file gnunet-communicator-udp.c.

References ReceiverAddress::acks_available, add_acks(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), ReceiverAddress::number_rekeying_kce, reset_rekey_kces(), SharedSecret::sequence_allowed, and ReceiverAddress::ss_rekey.

Referenced by handle_ack(), and mq_send_d().

1552 {
1553  uint32_t acks_to_add = receiver->ss_rekey->sequence_allowed;
1554 
1555  if (receiver->number_rekeying_kce < 3)
1556  acks_to_add = reset_rekey_kces (receiver, acks_to_add);
1557  receiver->acks_available = receiver->ss_rekey->sequence_allowed;
1559  "%u receiver->acks_available 4\n",
1560  receiver->acks_available);
1561  /* add_acks (receiver->ss_rekey, acks_to_add - 3); */
1562  if (0 != acks_to_add)
1563  {
1564  add_acks (receiver->ss_rekey, acks_to_add);
1565  }
1566  receiver->ss_rekey = NULL;
1568  "# rekeying successful\n");
1570  "# rekeying successful",
1571  1,
1572  GNUNET_NO);
1573 }
static void add_acks(struct SharedSecret *ss, int acks_to_add)
uint32_t sequence_allowed
Up to which sequence number did the other peer allow us to use this key, or up to which number did we...
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
static uint32_t reset_rekey_kces(struct ReceiverAddress *receiver, uint32_t acks_to_add)
struct SharedSecret * ss_rekey
Shared secret we use with target for rekeying.
unsigned int acks_available
Number of BOX keys from ACKs we have currently available for this receiver.
#define GNUNET_log(kind,...)
static struct GNUNET_STATISTICS_Handle * stats
For logging statistics.
int number_rekeying_kce
Number of kce we retain for sending the rekeying shared secret.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_ack()

static int handle_ack ( void *  cls,
const struct GNUNET_PeerIdentity pid,
void *  value 
)
static

We received an ACK for pid.

Check if it is for the receiver in value and if so, handle it and return GNUNET_NO. Otherwise, return GNUNET_YES.

Parameters
clsa const struct UDPAck
pidpeer the ACK is from
valuea struct ReceiverAddress
Returns
GNUNET_YES to continue to iterate

Definition at line 1587 of file gnunet-communicator-udp.c.

References UDPAck::acks_available, ReceiverAddress::acks_available, add_acks(), add_acks_rekey(), UDPAck::cmac, SharedSecret::cmac, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_NO, GNUNET_YES, SharedSecret::master, SharedSecret::next, ReceiverAddress::number_rekeying_kce, ReceiverAddress::rekeying, reset_rekey_kces(), SharedSecret::sequence_allowed, UDPAck::sequence_max, ReceiverAddress::ss_head, ReceiverAddress::ss_rekey, and value.

Referenced by enc_notify_cb(), and try_handle_plaintext().

1588 {
1589  const struct UDPAck *ack = cls;
1590  struct ReceiverAddress *receiver = value;
1591  uint32_t acks_to_add;
1592  uint32_t allowed;
1593  // int needed_for_rekeying;
1594 
1596  "in handle ack with cmac %s\n",
1597  GNUNET_h2s (&ack->cmac));
1598 
1599  if (NULL != receiver->ss_rekey)
1601  "We have rekey secret with cmac %s \n",
1602  GNUNET_h2s (&receiver->ss_rekey->cmac));
1603 
1604  if ((NULL != receiver->ss_rekey) && (0 == memcmp (&ack->cmac,
1605  &receiver->ss_rekey->cmac,
1606  sizeof(struct
1607  GNUNET_HashCode))) )
1608  {
1609  allowed = ntohl (ack->sequence_max);
1610 
1611  if (allowed > receiver->ss_rekey->sequence_allowed)
1612  {
1614  "%u > %u (%u %u) for rekey secrect %s\n", allowed,
1615  receiver->ss_rekey->sequence_allowed,
1616  receiver->acks_available,
1617  ack->acks_available,
1618  GNUNET_h2s (&receiver->ss_rekey->master));
1619 
1620  receiver->ss_rekey->sequence_allowed = allowed;
1621 
1622  if (GNUNET_NO == receiver->rekeying)
1623  add_acks_rekey (receiver);
1624 
1625  return GNUNET_NO;
1626  }
1627  }
1628 
1629  (void) pid;
1630  for (struct SharedSecret *ss = receiver->ss_head; NULL != ss; ss = ss->next)
1631  {
1632  if (0 == memcmp (&ack->cmac, &ss->cmac, sizeof(struct GNUNET_HashCode)))
1633  {
1634 
1636  "Found matching mac\n");
1637 
1638  allowed = ntohl (ack->sequence_max);
1639 
1640  if (allowed > ss->sequence_allowed)
1641  {
1643  "%u > %u (%u %u) for secrect %s\n", allowed,
1644  ss->sequence_allowed,
1645  receiver->acks_available,
1646  ack->acks_available,
1647  GNUNET_h2s (&ss->master));
1648  // Uncomment this for alternativ 1 of backchannel functionality
1649  acks_to_add = (allowed - ss->sequence_allowed);
1650  if ((GNUNET_NO == receiver->rekeying) &&
1651  (receiver->number_rekeying_kce < 3) )
1652  acks_to_add = reset_rekey_kces (receiver, acks_to_add);
1653  /* if ((GNUNET_NO == receiver->rekeying) && */
1654  /* (receiver->number_rekeying_kce < */
1655  /* 3) ) */
1656  /* { */
1657  /* needed_for_rekeying = (3 - receiver->number_rekeying_kce); */
1658  /* if (acks_to_add <= needed_for_rekeying) */
1659  /* { */
1660  /* receiver->number_rekeying_kce += acks_to_add; */
1661  /* acks_to_add = 0; */
1662  /* } */
1663  /* else */
1664  /* { */
1665  /* acks_to_add -= (3 - receiver->number_rekeying_kce); */
1666  /* receiver->number_rekeying_kce = 3; */
1667  /* } */
1668  /* } */
1669  /* GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, */
1670  /* "%u kce for rekeying\n", */
1671  /* receiver->number_rekeying_kce); */
1672 
1673  if ((0 != acks_to_add) && (GNUNET_NO == receiver->rekeying))
1674  {
1675  receiver->acks_available += (allowed - ss->sequence_allowed);
1676  ss->sequence_allowed = allowed;
1678  "%u receiver->acks_available 5\n",
1679  receiver->acks_available);
1680  add_acks (ss, acks_to_add);
1681  }
1682  }
1683  return GNUNET_NO;
1684  }
1685  }
1686  return GNUNET_YES;
1687 }
static void add_acks(struct SharedSecret *ss, int acks_to_add)
struct GNUNET_HashCode cmac
CMAC is used to identify master in ACKs.
uint32_t sequence_allowed
Up to which sequence number did the other peer allow us to use this key, or up to which number did we...
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
static uint32_t reset_rekey_kces(struct ReceiverAddress *receiver, uint32_t acks_to_add)
struct SharedSecret * ss_rekey
Shared secret we use with target for rekeying.
static char * value
Value of the record to add/remove.
struct GNUNET_HashCode master
Master shared secret.
static void add_acks_rekey(struct ReceiverAddress *receiver)
A 512-bit hashcode.
struct SharedSecret * next
Kept in a DLL.
Information we track per receiving address we have recently been in contact with (encryption to recei...
struct GNUNET_HashCode cmac
CMAC of the base key being acknowledged.
Shared secret we generated for a particular sender or receiver.
void receiver(void *cls, const void *buf, size_t available, const struct sockaddr *addr, socklen_t addrlen, int errCode)
Callback to read from the SOCKS5 proxy.
Definition: socks.c:329
unsigned int acks_available
Number of BOX keys from ACKs we have currently available for this receiver.
uint32_t sequence_max
Sequence acknowledgement limit.
#define GNUNET_log(kind,...)
UDP key acknowledgement.
int number_rekeying_kce
Number of kce we retain for sending the rekeying shared secret.
uint32_t acks_available
Sequence acknowledgement limit.
int rekeying
Flag indicating sender is initiated rekeying for this receiver.
struct SharedSecret * ss_head
Shared secrets we received from target, first used is head.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ try_handle_plaintext()

static void try_handle_plaintext ( struct SenderAddress sender,
const void *  buf,
size_t  buf_size 
)
static

Test if we have received a valid message in plaintext.

If so, handle it.

Parameters
senderpeer to process inbound plaintext for
bufbuffer we received
buf_sizenumber of bytes in buf

Definition at line 1699 of file gnunet-communicator-udp.c.

References GNUNET_CONTAINER_multipeermap_get_multiple(), GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK, GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_PAD, handle_ack(), pass_plaintext_to_core(), GNUNET_MessageHeader::size, SenderAddress::target, type, and GNUNET_MessageHeader::type.

Referenced by decrypt_box(), and sock_read().

1702 {
1703  const struct GNUNET_MessageHeader *hdr =
1704  (const struct GNUNET_MessageHeader *) buf;
1705  const struct UDPAck *ack = (const struct UDPAck *) buf;
1706  uint16_t type;
1707 
1708  if (sizeof(*hdr) > buf_size)
1709  return; /* not even a header */
1710  if (ntohs (hdr->size) > buf_size)
1711  return; /* not even a header */
1712  type = ntohs (hdr->type);
1713  switch (type)
1714  {
1716  /* lookup master secret by 'cmac', then update sequence_max */
1718  &sender->target,
1719  &handle_ack,
1720  (void *) ack);
1721  /* There could be more messages after the ACK, handle those as well */
1722  buf += ntohs (hdr->size);
1723  buf_size -= ntohs (hdr->size);
1724  pass_plaintext_to_core (sender, buf, buf_size);
1725  break;
1726 
1728  /* skip padding */
1729  break;
1730 
1731  default:
1732  pass_plaintext_to_core (sender, buf, buf_size);
1733  }
1734 }
#define GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_PAD
UDP communicator padding.
#define GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK
UDP KX acknowledgement.
static int handle_ack(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
We received an ACK for pid.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
struct GNUNET_PeerIdentity target
To whom are we talking to.
static struct GNUNET_CONTAINER_MultiPeerMap * receivers
Receivers (map from peer identity to struct ReceiverAddress)
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
static void pass_plaintext_to_core(struct SenderAddress *sender, const void *plaintext, size_t plaintext_len)
We received plaintext_len bytes of plaintext from a sender.
static char buf[2048]
UDP key acknowledgement.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
Header for all communications.
int GNUNET_CONTAINER_multipeermap_get_multiple(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map that match a particular key.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ kce_generate_cb()

static void kce_generate_cb ( void *  cls)
static

Definition at line 1738 of file gnunet-communicator-udp.c.

References SenderAddress::acks_available, GENERATE_AT_ONCE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_YES, kce_generate(), SenderAddress::kce_task, SenderAddress::kce_task_finished, KCN_TARGET, SharedSecret::master, SenderAddress::rekeying, SharedSecret::sender, SharedSecret::sequence_allowed, SenderAddress::ss_rekey, and WORKING_QUEUE_INTERVALL.

Referenced by consider_ss_ack(), and kce_generate_rekey_cb().

1739 {
1740  struct SharedSecret *ss = cls;
1741 
1742  ss->sender->kce_task = NULL;
1743 
1744  if (((GNUNET_NO == ss->sender->rekeying) && (ss->sender->acks_available <
1745  KCN_TARGET) ) ||
1746  ((ss->sender->ss_rekey == ss) && (GNUNET_YES == ss->sender->rekeying) &&
1747  (ss->sender->acks_available < 128)))
1748  {
1749 
1751  "Precomputing keys for master %s\n",
1752  GNUNET_h2s (&(ss->master)));
1753 
1754  for (int i = 0; i < GENERATE_AT_ONCE; i++)
1755  kce_generate (ss, ++ss->sequence_allowed);
1756 
1760  ss);
1761  }
1762  else
1763  {
1765  "We have enough keys.\n");
1766  ss_finished = ss;
1768  }
1769 
1770 
1771 }
#define KCN_TARGET
How many KCNs do we keep around after we hit the KCN_THRESHOLD? Should be larger than KCN_THRESHOLD s...
int rekeying
Flag indicating sender is initiated rekeying for this receiver.
uint32_t sequence_allowed
Up to which sequence number did the other peer allow us to use this key, or up to which number did we...
#define WORKING_QUEUE_INTERVALL
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
struct SenderAddress * sender
Sender we use this shared secret with, or NULL.
struct GNUNET_SCHEDULER_Task * kce_task
ID of kce working queue task.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1269
struct GNUNET_HashCode master
Master shared secret.
unsigned int acks_available
Number of BOX keys from ACKs we have currently available for this sender.
#define GENERATE_AT_ONCE
static void kce_generate_cb(void *cls)
Shared secret we generated for a particular sender or receiver.
int kce_task_finished
Is the kce_task finished?
struct SharedSecret * ss_finished
Shared secret we finished the last kce working queue for.
#define GNUNET_log(kind,...)
static void kce_generate(struct SharedSecret *ss, uint32_t seq)
Setup key cache entry for sequence number seq and shared secret ss.
struct SharedSecret * ss_rekey
Shared secret we use with target for rekeying.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ kce_generate_rekey_cb()

static void kce_generate_rekey_cb ( void *  cls)
static

Definition at line 1775 of file gnunet-communicator-udp.c.

References GENERATE_AT_ONCE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_SCHEDULER_add_delayed(), kce_generate(), kce_generate_cb(), SenderAddress::kce_task, SenderAddress::kce_task_rekey, SharedSecret::master, SharedSecret::sender, SharedSecret::sequence_allowed, and WORKING_QUEUE_INTERVALL.

Referenced by consider_ss_ack().

1776 {
1777  struct SharedSecret *ss = cls;
1778 
1779  ss->sender->kce_task_rekey = NULL;
1780 
1781  if (NULL == ss->sender->kce_task)
1782  {
1783 
1785  "Precomputing keys for rekey master %s\n",
1786  GNUNET_h2s (&(ss->master)));
1787 
1788  for (int i = 0; i < GENERATE_AT_ONCE; i++)
1789  kce_generate (ss, ++ss->sequence_allowed);
1790 
1794  ss);
1795  ss->sender->kce_task_rekey = NULL;
1796  }
1797  else
1798  {
1802  ss);
1803  }
1804 }
uint32_t sequence_allowed
Up to which sequence number did the other peer allow us to use this key, or up to which number did we...
#define WORKING_QUEUE_INTERVALL
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
struct SenderAddress * sender
Sender we use this shared secret with, or NULL.
struct GNUNET_SCHEDULER_Task * kce_task
ID of kce working queue task.
struct GNUNET_SCHEDULER_Task * kce_task_rekey
ID of kce rekey working queue task.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1269
struct GNUNET_HashCode master
Master shared secret.
static void kce_generate_rekey_cb(void *cls)
#define GENERATE_AT_ONCE
static void kce_generate_cb(void *cls)
Shared secret we generated for a particular sender or receiver.
#define GNUNET_log(kind,...)
static void kce_generate(struct SharedSecret *ss, uint32_t seq)
Setup key cache entry for sequence number seq and shared secret ss.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ consider_ss_ack()

static void consider_ss_ack ( struct SharedSecret ss,
int  initial 
)
static

We established a shared secret with a sender.

We should try to send the sender an struct UDPAck at the next opportunity to allow the sender to use ss longer (assuming we did not yet already recently).

Parameters
ssshared secret to generate ACKs for
initialThe SharedSecret came with initial KX.

Definition at line 1817 of file gnunet-communicator-udp.c.

References UDPAck::acks_available, SenderAddress::acks_available, UDPAck::cmac, SharedSecret::cmac, COMMUNICATOR_ADDRESS_PREFIX, destroy_all_secrets(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_i2s_full(), GNUNET_log, GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_TRANSPORT_communicator_notify(), GNUNET_YES, UDPAck::header, kce_destroy(), kce_generate(), kce_generate_cb(), kce_generate_rekey_cb(), SharedSecret::kce_head, SharedSecret::kce_tail, SenderAddress::kce_task, SenderAddress::kce_task_finished, SenderAddress::kce_task_rekey, KCN_THRESHOLD, SharedSecret::master, MAX_SECRETS, MAX_SQN_DELTA, SenderAddress::num_secrets, SenderAddress::rekeying, SharedSecret::sender, SharedSecret::sequence_allowed, UDPAck::sequence_max, KeyCacheEntry::sequence_number, GNUNET_MessageHeader::size, ss_finished, SenderAddress::target, GNUNET_MessageHeader::type, and WORKING_QUEUE_INTERVALL.

Referenced by decrypt_box(), decrypt_rekey(), and sock_read().

1818 {
1819  struct GNUNET_SCHEDULER_Task *kce_task_rekey;
1820  struct GNUNET_SCHEDULER_Task *kce_task;
1821  int kce_task_finished;
1822 
1823  kce_task_rekey = ss->sender->kce_task_rekey;
1824  kce_task_finished = ss->sender->kce_task_finished;
1825  kce_task = ss->sender->kce_task;
1826 
1827  GNUNET_assert (NULL != ss->sender);
1829  "Considering SS UDPAck %s\n",
1830  GNUNET_i2s_full (&ss->sender->target));
1831 
1833  "We have %u acks available.\n",
1834  ss->sender->acks_available);
1835  /* drop ancient KeyCacheEntries */
1836  while ((NULL != ss->kce_head) &&
1837  (MAX_SQN_DELTA <
1839  kce_destroy (ss->kce_tail);
1840 
1841 
1842  if (GNUNET_NO == initial)
1843  kce_generate (ss, ++ss->sequence_allowed);
1844 
1845  /*if (0 == ss->sender->acks_available)
1846  {
1847  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1848  "Generating keys\n");
1849  while (ss->active_kce_count < KCN_TARGET)
1850  kce_generate (ss, ++ss->sequence_allowed);
1851  }*/
1852 
1853  if (((NULL != kce_task) && kce_task_finished) || (GNUNET_NO == initial))
1854  {
1855  struct UDPAck ack;
1856  struct SharedSecret *ss_tell;
1857 
1858  if (GNUNET_NO != initial)
1859  ss_tell = ss_finished;
1860  else
1861  ss_tell = ss;
1862 
1863  ack.header.type = htons (GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK);
1864  ack.header.size = htons (sizeof(ack));
1865  ack.sequence_max = htonl (ss_tell->sequence_allowed);
1866  ack.acks_available = ss->sender->acks_available;
1867  ack.cmac = ss_tell->cmac;
1869  "Notifying transport of UDPAck %s with initial %u and master %s\n",
1870  GNUNET_i2s_full (&ss_tell->sender->target),
1871  initial,
1872  GNUNET_h2s (&(ss_tell->master)));
1874  &ss_tell->sender->target,
1876  &ack.header);
1877  if (GNUNET_NO != initial)
1878  {
1880  kce_task = NULL;
1881  kce_task_finished = GNUNET_NO;
1882  }
1883  }
1884  else if ((NULL == kce_task) && ((KCN_THRESHOLD >
1885  ss->sender->acks_available) ||
1886  (GNUNET_YES == ss->sender->rekeying) ||
1887  (ss->sender->num_secrets > MAX_SECRETS) ))
1888  {
1889 
1890  // kce_generate (ss, ++ss->sequence_allowed);
1891  // kce_generate (ss, ++ss->sequence_allowed);
1892  // TODO This task must be per sender!
1895  ss);
1896  kce_task_finished = GNUNET_NO;
1897 
1898  }
1899  else if ((NULL == kce_task_rekey) && (GNUNET_YES ==
1900  ss->sender->rekeying) )
1901  {
1904  ss);
1905  }
1906 }
struct KeyCacheEntry * kce_head
Kept in a DLL, sorted by sequence number.
#define GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK
UDP KX acknowledgement.
int rekeying
Flag indicating sender is initiated rekeying for this receiver.
struct GNUNET_HashCode cmac
CMAC is used to identify master in ACKs.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
uint32_t sequence_allowed
Up to which sequence number did the other peer allow us to use this key, or up to which number did we...
#define WORKING_QUEUE_INTERVALL
const char * GNUNET_i2s_full(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
static void kce_destroy(struct KeyCacheEntry *kce)
Free memory used by key cache entry.
struct SenderAddress * sender
Sender we use this shared secret with, or NULL.
uint32_t sequence_number
Sequence number used to derive this entry from master key.
struct GNUNET_SCHEDULER_Task * kce_task
ID of kce working queue task.
struct GNUNET_SCHEDULER_Task * kce_task_rekey
ID of kce rekey working queue task.
struct GNUNET_PeerIdentity target
To whom are we talking to.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1269
struct GNUNET_HashCode master
Master shared secret.
struct KeyCacheEntry * kce_tail
Kept in a DLL, sorted by sequence number.
#define MAX_SECRETS
How many shared master secrets do we keep around at most per sender? Should be large enough so that w...
static void kce_generate_rekey_cb(void *cls)
#define COMMUNICATOR_ADDRESS_PREFIX
Address prefix used by the communicator.
unsigned int acks_available
Number of BOX keys from ACKs we have currently available for this sender.
static void kce_generate_cb(void *cls)
Shared secret we generated for a particular sender or receiver.
unsigned int num_secrets
Length of the DLL at ss_head.
#define KCN_THRESHOLD
If we fall below this number of available KCNs, we generate additional ACKs until we reach KCN_TARGET...
int kce_task_finished
Is the kce_task finished?
struct SharedSecret * ss_finished
Shared secret we finished the last kce working queue for.
void GNUNET_TRANSPORT_communicator_notify(struct GNUNET_TRANSPORT_CommunicatorHandle *ch, const struct GNUNET_PeerIdentity *pid, const char *comm, const struct GNUNET_MessageHeader *header)
The communicator asks the transport service to route a message via a different path to another commun...
#define GNUNET_log(kind,...)
UDP key acknowledgement.
Entry in list of pending tasks.
Definition: scheduler.c:134
#define MAX_SQN_DELTA
What is the maximum delta between KCN sequence numbers that we allow.
static struct GNUNET_TRANSPORT_CommunicatorHandle * ch
Our environment.
static void kce_generate(struct SharedSecret *ss, uint32_t seq)
Setup key cache entry for sequence number seq and shared secret ss.
static void destroy_all_secrets(struct SharedSecret *ss, int withoutKce)
Destroying all secrets.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ decrypt_box()

static void decrypt_box ( const struct UDPBox box,
size_t  box_len,
struct KeyCacheEntry kce 
)
static

We received a box with matching kce.

Decrypt and process it.

Parameters
boxthe data we received
box_lennumber of bytes in box
kcekey index to decrypt box

Definition at line 1917 of file gnunet-communicator-udp.c.

References consider_ss_ack(), UDPBox::gcm_tag, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_sh2s(), GNUNET_STATISTICS_update(), GNUNET_YES, kce_destroy(), SenderAddress::rekeying, SharedSecret::sender, KeyCacheEntry::sequence_number, KeyCacheEntry::ss, SenderAddress::ss_rekey, try_decrypt(), and try_handle_plaintext().

Referenced by sock_read().

1920 {
1921  struct SharedSecret *ss = kce->ss;
1922  char out_buf[box_len - sizeof(*box)];
1923 
1924  GNUNET_assert (NULL != ss->sender);
1925  if (GNUNET_OK != try_decrypt (ss,
1926  box->gcm_tag,
1927  kce->sequence_number,
1928  (const char *) &box[1],
1929  sizeof(out_buf),
1930  out_buf))
1931  {
1933  "# Decryption failures with valid KCE",
1934  1,
1935  GNUNET_NO);
1936  kce_destroy (kce);
1937  return;
1938  }
1939  kce_destroy (kce);
1941  "# bytes decrypted with BOX",
1942  sizeof(out_buf),
1943  GNUNET_NO);
1945  "# messages decrypted with BOX",
1946  1,
1947  GNUNET_NO);
1949  "decrypted UDPBox with kid %s\n",
1950  GNUNET_sh2s (&box->kid));
1951  try_handle_plaintext (ss->sender, out_buf, sizeof(out_buf));
1952  if ((GNUNET_NO == box->rekeying) && (GNUNET_YES == ss->sender->rekeying))
1953  {
1954  ss->sender->rekeying = GNUNET_NO;
1955  ss->sender->ss_rekey = NULL;
1956  // destroy_all_secrets (ss, GNUNET_NO);
1958  "Receiver stopped rekeying.\n");
1959  }
1960  else if (GNUNET_NO == box->rekeying)
1961  consider_ss_ack (ss, GNUNET_NO);
1962  else
1963  {
1964  ss->sender->rekeying = GNUNET_YES;
1966  "Got Box: Receiver doing rekeying.\n");
1967  }
1968 }
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
static void consider_ss_ack(struct SharedSecret *ss, int initial)
We established a shared secret with a sender.
int rekeying
Flag indicating sender is initiated rekeying for this receiver.
char gcm_tag[(128/8)]
128-bit authentication tag for the following encrypted message, from GCM.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct SharedSecret * ss
Corresponding shared secret.
static void kce_destroy(struct KeyCacheEntry *kce)
Free memory used by key cache entry.
struct SenderAddress * sender
Sender we use this shared secret with, or NULL.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
uint32_t sequence_number
Sequence number used to derive this entry from master key.
static void try_handle_plaintext(struct SenderAddress *sender, const void *buf, size_t buf_size)
Test if we have received a valid message in plaintext.
Shared secret we generated for a particular sender or receiver.
#define GNUNET_log(kind,...)
static struct GNUNET_STATISTICS_Handle * stats
For logging statistics.
struct SharedSecret * ss_rekey
Shared secret we use with target for rekeying.
static int try_decrypt(const struct SharedSecret *ss, const char tag[(128/8)], uint32_t serial, const char *in_buf, size_t in_buf_size, char *out_buf)
Try to decrypt buf using shared secret ss and key/iv derived using serial.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ decrypt_rekey()

static void decrypt_rekey ( const struct UDPRekey rekey,
size_t  rekey_len,
struct KeyCacheEntry kce,
struct SenderAddress sender 
)
static

We received a rekey with matching kce.

Decrypt and process it.

Parameters
rekeythe data we received
rekey_lennumber of bytes in rekey
kcekey index to decrypt rekey

Definition at line 1979 of file gnunet-communicator-udp.c.

References SenderAddress::acks_available, calculate_cmac(), SharedSecret::cmac, consider_ss_ack(), UDPRekey::gcm_tag, GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_sh2s(), GNUNET_STATISTICS_update(), GNUNET_YES, kce_destroy(), SharedSecret::master, SenderAddress::num_secrets, SharedSecret::sender, UdpHandshakeSignature::sender, SharedSecret::sequence_allowed, KeyCacheEntry::sequence_number, KeyCacheEntry::ss, SenderAddress::ss_head, SenderAddress::ss_rekey, SenderAddress::ss_tail, and try_decrypt().

Referenced by sock_read().

1983 {
1984  struct SharedSecret *ss = kce->ss;
1985  struct SharedSecret *ss_rekey;
1986  char out_buf[rekey_len - sizeof(*rekey)];
1987  struct GNUNET_HashCode *master;
1988 
1989 
1991  "decrypt_rekey.\n");
1992 
1993  GNUNET_assert (NULL != ss->sender);
1994  if (GNUNET_OK != try_decrypt (ss,
1995  rekey->gcm_tag,
1996  kce->sequence_number,
1997  (const char *) &rekey[1],
1998  sizeof(out_buf),
1999  out_buf))
2000  {
2002  "# Decryption failures with valid KCE",
2003  1,
2004  GNUNET_NO);
2006  "Decryption with kid %s failed\n",
2007  GNUNET_sh2s (&rekey->kid));
2008  kce_destroy (kce);
2009  return;
2010  }
2011  kce_destroy (kce);
2013  "# bytes decrypted with Rekey",
2014  sizeof(out_buf),
2015  GNUNET_NO);
2017  "decrypted UDPRekey with kid %s\n",
2018  GNUNET_sh2s (&rekey->kid));
2019  /*cmac = (struct GNUNET_HashCode *) out_buf;
2020  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2021  "Received secret with cmac %s \n",
2022  GNUNET_h2s (&cmac));*/
2023  // ss_rekey = (struct SharedSecret *) out_buf;
2024  master = (struct GNUNET_HashCode *) out_buf;
2025  ss_rekey = GNUNET_new (struct SharedSecret);
2026  ss_rekey->master = *master;
2027  calculate_cmac (ss_rekey);
2028  ss_rekey->sender = sender;
2029  // ss_rekey->sequence_used = 0;
2030  // ss_rekey->sequence_allowed = 0;
2031  /* ss_rekey->active_kce_count = 0; */
2032  /* ss_rekey->prev = NULL; */
2033  /* ss_rekey->next = NULL; */
2034  /* GNUNET_assert (ss_rekey->prev == NULL && sender->ss_head != ss_rekey); */
2035  /* GNUNET_assert (ss_rekey->next == NULL && sender->ss_tail != ss_rekey); */
2036  GNUNET_CONTAINER_DLL_insert (sender->ss_head, sender->ss_tail, ss_rekey);
2037  sender->ss_rekey = ss_rekey;
2038  sender->num_secrets++;
2040  "Received secret with cmac %s\n",
2041  GNUNET_h2s (&(ss_rekey->cmac)));
2043  "Received secret with master %s.\n",
2044  GNUNET_h2s (&(ss_rekey->master)));
2046  "We have %u sequence_allowed.\n",
2047  ss_rekey->sequence_allowed);
2049  "We have a sender %p\n",
2050  ss_rekey->sender);
2052  "We have %u acks available.\n",
2053  ss_rekey->sender->acks_available);
2054  consider_ss_ack (ss_rekey, GNUNET_YES);
2055 
2056 }
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
struct SharedSecret * ss_tail
Shared secrets we used with target, last used is tail.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
static void consider_ss_ack(struct SharedSecret *ss, int initial)
We established a shared secret with a sender.
struct GNUNET_HashCode cmac
CMAC is used to identify master in ACKs.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
uint32_t sequence_allowed
Up to which sequence number did the other peer allow us to use this key, or up to which number did we...
struct SharedSecret * ss
Corresponding shared secret.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
static void kce_destroy(struct KeyCacheEntry *kce)
Free memory used by key cache entry.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct SenderAddress * sender
Sender we use this shared secret with, or NULL.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
uint32_t sequence_number
Sequence number used to derive this entry from master key.
struct SharedSecret * ss_head
Shared secrets we used with target, first used is head.
struct GNUNET_HashCode master
Master shared secret.
unsigned int acks_available
Number of BOX keys from ACKs we have currently available for this sender.
A 512-bit hashcode.
Shared secret we generated for a particular sender or receiver.
unsigned int num_secrets
Length of the DLL at ss_head.
#define GNUNET_log(kind,...)
static struct GNUNET_STATISTICS_Handle * stats
For logging statistics.
char gcm_tag[(128/8)]
128-bit authentication tag for the following encrypted message, from GCM.
static void calculate_cmac(struct SharedSecret *ss)
Calculate cmac from master in ss.
struct SharedSecret * ss_rekey
Shared secret we use with target for rekeying.
static int try_decrypt(const struct SharedSecret *ss, const char tag[(128/8)], uint32_t serial, const char *in_buf, size_t in_buf_size, char *out_buf)
Try to decrypt buf using shared secret ss and key/iv derived using serial.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ find_sender_by_address()

static int find_sender_by_address ( void *  cls,
const struct GNUNET_PeerIdentity key,
void *  value 
)
static

Find existing struct SenderAddress by matching addresses.

Parameters
clsa struct SearchContext
keyignored, must match already
valuea struct SenderAddress
Returns
GNUNET_YES if not found (continue to search), GNUNET_NO if found

Definition at line 2090 of file gnunet-communicator-udp.c.

References SenderAddress::address, SearchContext::address, SenderAddress::address_len, SearchContext::address_len, GNUNET_NO, GNUNET_YES, sc, SearchContext::sender, UdpHandshakeSignature::sender, and value.

Referenced by setup_sender().

2093 {
2094  struct SearchContext *sc = cls;
2095  struct SenderAddress *sender = value;
2096 
2097  if ((sender->address_len == sc->address_len) &&
2098  (0 == memcmp (sender->address, sc->address, sender->address_len)))
2099  {
2100  sc->sender = sender;
2101  return GNUNET_NO; /* stop iterating! */
2102  }
2103  return GNUNET_YES;
2104 }
socklen_t address_len
Number of bytes in address.
socklen_t address_len
Length of the address.
static char * value
Value of the record to add/remove.
struct sockaddr * address
Address of the other peer.
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
Context information to be used while searching for operation contexts.
Definition: testbed_api.c:225
Information we track per sender address we have recently been in contact with (we decrypt messages fr...
struct SenderAddress * sender
Return value to set if we found a match.
const struct sockaddr * address
Address we are looking for.
Here is the caller graph for this function:

◆ setup_sender()

static struct SenderAddress* setup_sender ( const struct GNUNET_PeerIdentity target,
const struct sockaddr *  address,
socklen_t  address_len 
)
static

Create sender address for target.

Note that we might already have one, so a fresh one is only allocated if one does not yet exist for address.

Parameters
targetpeer to generate address for
addresstarget address
address_lennumber of bytes in address
Returns
data structure to keep track of key material for decrypting data from target

Definition at line 2119 of file gnunet-communicator-udp.c.

References GNUNET_TIME_Absolute::abs_value_us, address, SenderAddress::address, SearchContext::address, SenderAddress::address_len, SearchContext::address_len, check_timeouts(), find_sender_by_address(), GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_CONTAINER_heap_insert(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multipeermap_get_multiple(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_memdup, GNUNET_new, GNUNET_NO, GNUNET_NT_scanner_get_type(), GNUNET_SCHEDULER_add_now(), GNUNET_STATISTICS_set(), GNUNET_TIME_relative_to_absolute(), SenderAddress::hn, SenderAddress::nt, reschedule_sender_timeout(), SearchContext::sender, UdpHandshakeSignature::sender, SenderAddress::target, and SenderAddress::timeout.

Referenced by sock_read().

2122 {
2123  struct SenderAddress *sender;
2124  struct SearchContext sc = { .address = address,
2125  .address_len = address_len,
2126  .sender = NULL };
2127 
2129  target,
2131  &sc);
2132  if (NULL != sc.sender)
2133  {
2135  return sc.sender;
2136  }
2137  sender = GNUNET_new (struct SenderAddress);
2138  sender->target = *target;
2140  sender->address_len = address_len;
2142  senders,
2143  &sender->target,
2144  sender,
2147  "# senders active",
2149  GNUNET_NO);
2150  sender->timeout =
2153  sender,
2154  sender->timeout.abs_value_us);
2156  if (NULL == timeout_task)
2158  return sender;
2159 }
enum GNUNET_NetworkType GNUNET_NT_scanner_get_type(struct GNUNET_NT_InterfaceScanner *is, const struct sockaddr *addr, socklen_t addrlen)
Returns where the address is located: loopback, LAN or WAN.
Definition: nt.c:314
struct GNUNET_CONTAINER_HeapNode * GNUNET_CONTAINER_heap_insert(struct GNUNET_CONTAINER_Heap *heap, void *element, GNUNET_CONTAINER_HeapCostType cost)
Inserts a new element into the heap.
socklen_t address_len
Number of bytes in address.
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:181
socklen_t address_len
Length of the address.
static struct GNUNET_NT_InterfaceScanner * is
Network scanner to determine network types.
#define GNUNET_memdup(buf, size)
Allocate and initialize a block of memory.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_TIME_Absolute timeout
Timeout for this sender.
uint64_t abs_value_us
The actual value.
static void reschedule_sender_timeout(struct SenderAddress *sender)
Increment sender timeout due to activity.
struct GNUNET_PeerIdentity target
To whom are we talking to.
static struct GNUNET_CONTAINER_MultiPeerMap * receivers
Receivers (map from peer identity to struct ReceiverAddress)
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1296
static void check_timeouts(void *cls)
Task run to check #receiver_heap and #sender_heap for timeouts.
struct sockaddr * address
Address of the other peer.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
static struct GNUNET_CONTAINER_Heap * senders_heap
Expiration heap for senders (contains struct SenderAddress)
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
static struct GNUNET_CONTAINER_MultiPeerMap * senders
Senders (map from peer identity to struct SenderAddress)
Allow multiple values with the same key.
#define GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT
After how long do we consider a connection to a peer dead if we don&#39;t receive messages from the peer...
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
struct GNUNET_CONTAINER_HeapNode * hn
Entry in sender expiration heap.
Context information to be used while searching for operation contexts.
Definition: testbed_api.c:225
Information we track per sender address we have recently been in contact with (we decrypt messages fr...
static struct GNUNET_STATISTICS_Handle * stats
For logging statistics.
static int find_sender_by_address(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Find existing struct SenderAddress by matching addresses.
struct SenderAddress * sender
Return value to set if we found a match.
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
static char * address
GNS address for this phone.
int GNUNET_CONTAINER_multipeermap_get_multiple(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map that match a particular key.
static struct GNUNET_SCHEDULER_Task * timeout_task
ID of timeout task.
enum GNUNET_NetworkType nt
Which network type does this queue use?
Here is the call graph for this function:
Here is the caller graph for this function:

◆ verify_confirmation()

static int verify_confirmation ( const struct GNUNET_CRYPTO_EcdhePublicKey ephemeral,
const struct UDPConfirmation uc 
)
static

Check signature from uc against ephemeral.

Parameters
ephermalkey that is signed
ucsignature of claimant
Returns
GNUNET_OK if signature is valid

Definition at line 2170 of file gnunet-communicator-udp.c.

References UdpHandshakeSignature::ephemeral, GNUNET_CRYPTO_eddsa_verify, GNUNET_SIGNATURE_COMMUNICATOR_UDP_HANDSHAKE, UDPConfirmation::monotonic_time, UdpHandshakeSignature::monotonic_time, my_identity, GNUNET_PeerIdentity::public_key, GNUNET_CRYPTO_EccSignaturePurpose::purpose, UdpHandshakeSignature::purpose, UdpHandshakeSignature::receiver, UDPConfirmation::sender, UdpHandshakeSignature::sender, UDPConfirmation::sender_sig, and GNUNET_CRYPTO_EccSignaturePurpose::size.

Referenced by sock_read().

2172 {
2173  struct UdpHandshakeSignature uhs;
2174 
2176  uhs.purpose.size = htonl (sizeof(uhs));
2177  uhs.sender = uc->sender;
2178  uhs.receiver = my_identity;
2179  uhs.ephemeral = *ephemeral;
2180  uhs.monotonic_time = uc->monotonic_time;
2183  &uhs,
2184  &uc->sender_sig,
2185  &uc->sender.public_key);
2186 }
uint32_t purpose
What does this signature vouch for? This must contain a GNUNET_SIGNATURE_PURPOSE_XXX constant (from g...
static struct GNUNET_PeerIdentity my_identity
Our public key.
#define GNUNET_SIGNATURE_COMMUNICATOR_UDP_HANDSHAKE
Signature used by UDP communicator handshake.
#define GNUNET_CRYPTO_eddsa_verify(purp, ps, sig, pub)
Verify EdDSA signature.
struct GNUNET_CRYPTO_EddsaSignature sender_sig
Sender&#39;s signature of type GNUNET_SIGNATURE_COMMUNICATOR_UDP_HANDSHAKE.
struct GNUNET_CRYPTO_EccSignaturePurpose purpose
Purpose must be GNUNET_SIGNATURE_COMMUNICATOR_UDP_HANDSHAKE.
struct GNUNET_TIME_AbsoluteNBO monotonic_time
Monotonic time of sender, to possibly help detect replay attacks (if receiver persists times by sende...
struct GNUNET_PeerIdentity sender
Sender&#39;s identity.
Signature we use to verify that the ephemeral key was really chosen by the specified sender...
struct GNUNET_CRYPTO_EcdhePublicKey ephemeral
Ephemeral key used by the sender.
struct GNUNET_CRYPTO_EddsaPublicKey public_key
Here is the caller graph for this function:

◆ sockaddr_to_udpaddr_string()

static char* sockaddr_to_udpaddr_string ( const struct sockaddr *  address,
socklen_t  address_len 
)
static

Converts address to the address string format used by this communicator in HELLOs.

Parameters
addressthe address to convert, must be AF_INET or AF_INET6.
address_lennumber of bytes in address
Returns
string representation of address

Definition at line 2198 of file gnunet-communicator-udp.c.

References COMMUNICATOR_ADDRESS_PREFIX, GNUNET_a2s(), GNUNET_asprintf(), GNUNET_assert, and ret.

Referenced by mq_init(), and sock_read().

2200 {
2201  char *ret;
2202 
2203  switch (address->sa_family)
2204  {
2205  case AF_INET:
2206  GNUNET_asprintf (&ret,
2207  "%s-%s",
2209  GNUNET_a2s (address, address_len));
2210  break;
2211 
2212  case AF_INET6:
2213  GNUNET_asprintf (&ret,
2214  "%s-%s",
2216  GNUNET_a2s (address, address_len));
2217  break;
2218 
2219  default:
2220  GNUNET_assert (0);
2221  }
2222  return ret;
2223 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
#define COMMUNICATOR_ADDRESS_PREFIX
Address prefix used by the communicator.
const char * GNUNET_a2s(const struct sockaddr *addr, socklen_t addrlen)
Convert a "struct sockaddr*" (IPv4 or IPv6 address) to a string (for printing debug messages)...
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
static char * address
GNS address for this phone.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ sock_read()

static void sock_read ( void *  cls)
static

Socket read task.

Parameters
clsNULL

Definition at line 2232 of file gnunet-communicator-udp.c.

References buf, calculate_cmac(), consider_ss_ack(), decrypt_box(), decrypt_rekey(), do_decrypt(), InitialKX::ephemeral, InitialKX::gcm_tag, GNUNET_break_op, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_multishortmap_get(), GNUNET_CRYPTO_eddsa_verify, GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_log_strerror, GNUNET_NETWORK_socket_recvfrom(), GNUNET_NO, GNUNET_NT_scanner_get_type(), GNUNET_OK, GNUNET_SCHEDULER_add_read_net(), GNUNET_sh2s(), GNUNET_SIGNATURE_COMMUNICATOR_UDP_BROADCAST, GNUNET_STATISTICS_update(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TRANSPORT_application_validate(), GNUNET_YES, UdpBroadcastSignature::h_address, UDPBox::kid, UDPRekey::kid, nt, SenderAddress::num_secrets, GNUNET_PeerIdentity::public_key, GNUNET_CRYPTO_EccSignaturePurpose::purpose, UdpBroadcastSignature::purpose, InitialKX::rekeying, UDPBox::rekeying, SenderAddress::rekeying, UDPConfirmation::sender, UdpBroadcastSignature::sender, UDPRekey::sender, SharedSecret::sender, UdpHandshakeSignature::sender, setup_sender(), setup_shared_secret_dec(), GNUNET_CRYPTO_EccSignaturePurpose::size, sockaddr_to_udpaddr_string(), KeyCacheEntry::ss, SenderAddress::ss_head, SenderAddress::ss_rekey, SenderAddress::ss_tail, try_decrypt(), try_handle_plaintext(), uc, and verify_confirmation().

Referenced by run().

2233 {
2234  struct sockaddr_storage sa;
2235  socklen_t salen = sizeof(sa);
2236  char buf[UINT16_MAX];
2237  ssize_t rcvd;
2238 
2239  (void) cls;
2241  udp_sock,
2242  &sock_read,
2243  NULL);
2245  buf,
2246  sizeof(buf),
2247  (struct sockaddr *) &sa,
2248  &salen);
2249  if (-1 == rcvd)
2250  {
2252  return;
2253  }
2255  "Read %lu bytes\n", rcvd);
2256 
2257  if (rcvd > sizeof(struct UDPRekey))
2258  {
2259  const struct UDPRekey *rekey;
2260  const struct UDPBox *box;
2261  struct KeyCacheEntry *kce;
2262  struct SenderAddress *sender;
2263  int do_decrypt = GNUNET_NO;
2264 
2265  rekey = (const struct UDPRekey *) buf;
2266  box = (const struct UDPBox *) buf;
2268 
2269  if ((GNUNET_YES == box->rekeying) || (GNUNET_NO == box->rekeying))
2271  "UDPRekey has rekeying %u\n",
2272  box->rekeying);
2273  else
2274  do_decrypt = GNUNET_YES;
2275 
2276  if ((GNUNET_YES == do_decrypt) && (NULL != kce) && (GNUNET_YES ==
2277  kce->ss->sender->
2278  rekeying))
2279  {
2281  "UDPRekey with kid %s\n",
2282  GNUNET_sh2s (&rekey->kid));
2283  sender = setup_sender (&rekey->sender, (const struct sockaddr *) &sa,
2284  salen);
2285 
2286  if (NULL != sender->ss_rekey)
2287  return;
2288 
2289  decrypt_rekey (rekey, (size_t) rcvd, kce, sender);
2290  return;
2291  }
2292  }
2293 
2294  /* first, see if it is a UDPBox */
2295  if (rcvd > sizeof(struct UDPBox))
2296  {
2297  const struct UDPBox *box;
2298  struct KeyCacheEntry *kce;
2299 
2300  box = (const struct UDPBox *) buf;
2302  if (NULL != kce)
2303  {
2304  decrypt_box (box, (size_t) rcvd, kce);
2305  return;
2306  }
2307  }
2308 
2309  /* next, check if it is a broadcast */
2310  if (sizeof(struct UDPBroadcast) == rcvd)
2311  {
2312  const struct UDPBroadcast *ub;
2313  struct UdpBroadcastSignature uhs;
2314 
2315  ub = (const struct UDPBroadcast *) buf;
2316  uhs.purpose.purpose = htonl (GNUNET_SIGNATURE_COMMUNICATOR_UDP_BROADCAST);
2317  uhs.purpose.size = htonl (sizeof(uhs));
2318  uhs.sender = ub->sender;
2319  GNUNET_CRYPTO_hash (&sa, salen, &uhs.h_address);
2320  if (GNUNET_OK ==
2322  &uhs,
2323  &ub->sender_sig,
2324  &ub->sender.public_key))
2325  {
2326  char *addr_s;
2327  enum GNUNET_NetworkType nt;
2328 
2329  addr_s =
2330  sockaddr_to_udpaddr_string ((const struct sockaddr *) &sa, salen);
2331  GNUNET_STATISTICS_update (stats, "# broadcasts received", 1, GNUNET_NO);
2332  /* use our own mechanism to determine network type */
2333  nt =
2334  GNUNET_NT_scanner_get_type (is, (const struct sockaddr *) &sa, salen);
2335  GNUNET_TRANSPORT_application_validate (ah, &ub->sender, nt, addr_s);
2336  GNUNET_free (addr_s);
2337  return;
2338  }
2339  /* continue with KX, mostly for statistics... */
2340  }
2341 
2342 
2343  /* finally, test if it is a KX */
2344  if (rcvd < sizeof(struct UDPConfirmation) + sizeof(struct InitialKX))
2345  {
2347  "# messages dropped (no kid, too small for KX)",
2348  1,
2349  GNUNET_NO);
2350  return;
2351  }
2353  "Got KX\n");
2354  {
2355  const struct InitialKX *kx;
2356  struct SharedSecret *ss;
2357  char pbuf[rcvd - sizeof(struct InitialKX)];
2358  const struct UDPConfirmation *uc;
2359  struct SenderAddress *sender;
2360 
2361  kx = (const struct InitialKX *) buf;
2362  ss = setup_shared_secret_dec (&kx->ephemeral);
2364  "Before DEC\n");
2365 
2366  if (GNUNET_OK != try_decrypt (ss,
2367  kx->gcm_tag,
2368  0,
2369  &buf[sizeof(*kx)],
2370  sizeof(pbuf),
2371  pbuf))
2372  {
2374  "Unable to decrypt tag, dropping...\n");
2375  GNUNET_free (ss);
2377  stats,
2378  "# messages dropped (no kid, AEAD decryption failed)",
2379  1,
2380  GNUNET_NO);
2381  return;
2382  }
2384  "Before VERIFY\n");
2385 
2386  uc = (const struct UDPConfirmation *) pbuf;
2387  if (GNUNET_OK != verify_confirmation (&kx->ephemeral, uc))
2388  {
2389  GNUNET_break_op (0);
2390  GNUNET_free (ss);
2392  "# messages dropped (sender signature invalid)",
2393  1,
2394  GNUNET_NO);
2395  return;
2396  }
2398  "Before SETUP_SENDER\n");
2399 
2400  calculate_cmac (ss);
2401  sender = setup_sender (&uc->sender, (const struct sockaddr *) &sa, salen);
2402  ss->sender = sender;
2403  GNUNET_CONTAINER_DLL_insert (sender->ss_head, sender->ss_tail, ss);
2404  sender->num_secrets++;
2405  GNUNET_STATISTICS_update (stats, "# Secrets active", 1, GNUNET_NO);
2407  "# messages decrypted without BOX",
2408  1,
2409  GNUNET_NO);
2410  try_handle_plaintext (sender, &uc[1], sizeof(pbuf) - sizeof(*uc));
2411  if ((GNUNET_NO == kx->rekeying) && (GNUNET_YES == ss->sender->rekeying))
2412  {
2413  ss->sender->rekeying = GNUNET_NO;
2414  sender->ss_rekey = NULL;
2415  // destroy_all_secrets (ss, GNUNET_NO);
2417  "Receiver stopped rekeying.\n");
2418  }
2419  else if (GNUNET_NO == kx->rekeying)
2421  else
2422  {
2423  ss->sender->rekeying = GNUNET_YES;
2425  "Got KX: Receiver doing rekeying.\n");
2426  }
2427  /*if (sender->num_secrets > MAX_SECRETS)
2428  secret_destroy (sender->ss_tail);*/
2429  }
2430 }
enum GNUNET_NetworkType GNUNET_NT_scanner_get_type(struct GNUNET_NT_InterfaceScanner *is, const struct sockaddr *addr, socklen_t addrlen)
Returns where the address is located: loopback, LAN or WAN.
Definition: nt.c:314
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
struct SharedSecret * ss_tail
Shared secrets we used with target, last used is tail.
static struct GNUNET_TRANSPORT_ApplicationHandle * ah
Our handle to report addresses for validation to TRANSPORT.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
Broadcast by peer in LAN announcing its presence.
static struct SenderAddress * setup_sender(const struct GNUNET_PeerIdentity *target, const struct sockaddr *address, socklen_t address_len)
Create sender address for target.
static void consider_ss_ack(struct SharedSecret *ss, int initial)
We established a shared secret with a sender.
char gcm_tag[(128/8)]
HMAC for the following encrypted message, using GCM.
int rekeying
Flag indicating sender is initiated rekeying for this receiver.
static struct SharedSecret * setup_shared_secret_dec(const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral)
Setup shared secret for decryption.
void GNUNET_TRANSPORT_application_validate(struct GNUNET_TRANSPORT_ApplicationHandle *ch, const struct GNUNET_PeerIdentity *peer, enum GNUNET_NetworkType nt, const char *addr)
An application (or a communicator) has received a HELLO (or other address data of another peer) and w...
struct GNUNET_CRYPTO_EcdhePublicKey ephemeral
Ephemeral key for KX.
static struct GNUNET_CONTAINER_MultiShortmap * key_cache
Cache of pre-generated key IDs.
static struct GNUNET_FS_UnindexContext * uc
static struct GNUNET_NT_InterfaceScanner * is
Network scanner to determine network types.
struct SharedSecret * ss
Corresponding shared secret.
struct SenderAddress * sender
Sender we use this shared secret with, or NULL.
Encrypted continuation of UDP initial handshake, followed by message header with payload.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
#define GNUNET_CRYPTO_eddsa_verify(purp, ps, sig, pub)
Verify EdDSA signature.
int rekeying
A flag indicating, if the sender is doing rekeying.
static char * sockaddr_to_udpaddr_string(const struct sockaddr *address, socklen_t address_len)
Converts address to the address string format used by this communicator in HELLOs.
GNUNET_NetworkType
Types of networks (with separate quotas) we support.
Definition: gnunet_nt_lib.h:35
"Plaintext" header at beginning of KX message.
struct GNUNET_ShortHashCode kid
Key and IV identification code.
struct SharedSecret * ss_head
Shared secrets we used with target, first used is head.
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
static int do_decrypt(struct GSC_KeyExchangeInfo *kx, const struct GNUNET_CRYPTO_SymmetricInitializationVector *iv, const void *in, void *out, size_t size)
Decrypt size bytes from in and write the result to out.
Pre-generated "kid" code (key and IV identification code) to quickly derive master key for a struct U...
static int verify_confirmation(const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral, const struct UDPConfirmation *uc)
Check signature from uc against ephemeral.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
#define GNUNET_SIGNATURE_COMMUNICATOR_UDP_BROADCAST
Signature used by UDP broadcasts.
static char buf[2048]
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
UDP message box.
UDP message box.
static void sock_read(void *cls)
Socket read task.
static struct GNUNET_NAT_AUTO_Test * nt
Handle to a NAT test operation.
static void try_handle_plaintext(struct SenderAddress *sender, const void *buf, size_t buf_size)
Test if we have received a valid message in plaintext.
Shared secret we generated for a particular sender or receiver.
unsigned int num_secrets
Length of the DLL at ss_head.
static struct GNUNET_NETWORK_Handle * udp_sock
Our socket.
static void decrypt_box(const struct UDPBox *box, size_t box_len, struct KeyCacheEntry *kce)
We received a box with matching kce.
struct GNUNET_PeerIdentity sender
Sender&#39;s identity.
struct GNUNET_PeerIdentity sender
Sender&#39;s identity.
int rekeying
A flag indicating, if the sender is doing rekeying.
void * GNUNET_CONTAINER_multishortmap_get(const struct GNUNET_CONTAINER_MultiShortmap *map, const struct GNUNET_ShortHashCode *key)
Given a key find a value in the map matching the key.
Information we track per sender address we have recently been in contact with (we decrypt messages fr...
Signature we use to verify that the broadcast was really made by the peer that claims to have made it...
#define GNUNET_log(kind,...)
struct GNUNET_ShortHashCode kid
Key and IV identification code.
static struct GNUNET_STATISTICS_Handle * stats
For logging statistics.
static struct GNUNET_SCHEDULER_Task * read_task
ID of read task.
static void calculate_cmac(struct SharedSecret *ss)
Calculate cmac from master in ss.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_read_net(struct GNUNET_TIME_Relative delay, struct GNUNET_NETWORK_Handle *rfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1517
static void decrypt_rekey(const struct UDPRekey *rekey, size_t rekey_len, struct KeyCacheEntry *kce, struct SenderAddress *sender)
We received a rekey with matching kce.
ssize_t GNUNET_NETWORK_socket_recvfrom(const struct GNUNET_NETWORK_Handle *desc, void *buffer, size_t length, struct sockaddr *src_addr, socklen_t *addrlen)
Read data from a socket (always non-blocking).
Definition: network.c:754
#define GNUNET_free(ptr)
Wrapper around free.
struct SharedSecret * ss_rekey
Shared secret we use with target for rekeying.
static int try_decrypt(const struct SharedSecret *ss, const char tag[(128/8)], uint32_t serial, const char *in_buf, size_t in_buf_size, char *out_buf)
Try to decrypt buf using shared secret ss and key/iv derived using serial.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ udp_address_to_sockaddr()

static struct sockaddr* udp_address_to_sockaddr ( const char *  bindto,
socklen_t *  sock_len 
)
static

Convert UDP bind specification to a struct sockaddr *

Parameters
bindtobind specification to convert
[out]sock_lenset to the length of the address
Returns
converted bindto specification

Definition at line 2441 of file gnunet-communicator-udp.c.

References COMMUNICATOR_CONFIG_SECTION, dummy, GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_malloc, GNUNET_memdup, GNUNET_NETWORK_test_pf(), GNUNET_NO, GNUNET_strdup, GNUNET_YES, port, and start.

Referenced by mq_init(), and run().

2442 {
2443  struct sockaddr *in;
2444  unsigned int port;
2445  char dummy[2];
2446  char *colon;
2447  char *cp;
2448 
2449  if (1 == sscanf (bindto, "%u%1s", &port, dummy))
2450  {
2451  /* interpreting value as just a PORT number */
2452  if (port > UINT16_MAX)
2453  {
2455  "BINDTO specification `%s' invalid: value too large for port\n",
2456  bindto);
2457  return NULL;
2458  }
2459  if ((GNUNET_NO == GNUNET_NETWORK_test_pf (PF_INET6)) ||
2460  (GNUNET_YES ==
2463  "DISABLE_V6")))
2464  {
2465  struct sockaddr_in *i4;
2466 
2467  i4 = GNUNET_malloc (sizeof(struct sockaddr_in));
2468  i4->sin_family = AF_INET;
2469  i4->sin_port = htons ((uint16_t) port);
2470  *sock_len = sizeof(struct sockaddr_in);
2471  in = (struct sockaddr *) i4;
2472  }
2473  else
2474  {
2475  struct sockaddr_in6 *i6;
2476 
2477  i6 = GNUNET_malloc (sizeof(struct sockaddr_in6));
2478  i6->sin6_family = AF_INET6;
2479  i6->sin6_port = htons ((uint16_t) port);
2480  *sock_len = sizeof(struct sockaddr_in6);
2481  in = (struct sockaddr *) i6;
2482  }
2483  return in;
2484  }
2485  cp = GNUNET_strdup (bindto);
2486  colon = strrchr (cp, ':');
2487  if (NULL != colon)
2488  {
2489  /* interpret value after colon as port */
2490  *colon = '\0';
2491  colon++;
2492  if (1 == sscanf (colon, "%u%1s", &port, dummy))
2493  {
2494  /* interpreting value as just a PORT number */
2495  if (port > UINT16_MAX)
2496  {
2498  "BINDTO specification `%s' invalid: value too large for port\n",
2499  bindto);
2500  GNUNET_free (cp);
2501  return NULL;
2502  }
2503  }
2504  else
2505  {
2506  GNUNET_log (
2508  "BINDTO specification `%s' invalid: last ':' not followed by number\n",
2509  bindto);
2510  GNUNET_free (cp);
2511  return NULL;
2512  }
2513  }
2514  else
2515  {
2516  /* interpret missing port as 0, aka pick any free one */
2517  port = 0;
2518  }
2519  {
2520  /* try IPv4 */
2521  struct sockaddr_in v4;
2522  if (1 == inet_pton (AF_INET, cp, &v4.sin_addr))
2523  {
2524  v4.sin_family = AF_INET;
2525  v4.sin_port = htons ((uint16_t) port);
2526 #if HAVE_SOCKADDR_IN_SIN_LEN
2527  v4.sin_len = sizeof(struct sockaddr_in);
2528 #endif
2529  in = GNUNET_memdup (&v4, sizeof(struct sockaddr_in));
2530  *sock_len = sizeof(struct sockaddr_in);
2531  GNUNET_free (cp);
2532  return in;
2533  }
2534  }
2535  {
2536  /* try IPv6 */
2537  struct sockaddr_in6 v6;
2538  const char *start;
2539 
2540  start = cp;
2541  if (('[' == *cp) && (']' == cp[strlen (cp) - 1]))
2542  {
2543  start++; /* skip over '[' */
2544  cp[strlen (cp) - 1] = '\0'; /* eat ']' */
2545  }
2546  if (1 == inet_pton (AF_INET6, start, &v6.sin6_addr))
2547  {
2548  v6.sin6_family = AF_INET6;
2549  v6.sin6_port = htons ((uint16_t) port);
2550 #if HAVE_SOCKADDR_IN_SIN_LEN
2551  v6.sin6_len = sizeof(sizeof(struct sockaddr_in6));
2552 #endif
2553  in = GNUNET_memdup (&v6, sizeof(v6));
2554  *sock_len = sizeof(v6);
2555  GNUNET_free (cp);
2556  return in;
2557  }
2558  }
2559  /* #5528 FIXME (feature!): maybe also try getnameinfo()? */
2560  GNUNET_free (cp);
2561  return NULL;
2562 }
#define COMMUNICATOR_CONFIG_SECTION
Configuration section used by the communicator.
static int start
Set if we are to start default services (including ARM).
Definition: gnunet-arm.c:39
#define GNUNET_memdup(buf, size)
Allocate and initialize a block of memory.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
static struct in_addr dummy
Target "dummy" address of the packet we pretend to respond to.
static uint16_t port
Port number.
Definition: gnunet-bcd.c:83
#define GNUNET_log(kind,...)
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_yesno(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
Get a configuration value that should be in a set of "YES" or "NO".
static const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
#define GNUNET_malloc(size)
Wrapper around malloc.
int GNUNET_NETWORK_test_pf(int pf)
Test if the given protocol family is supported by this system.
Definition: network.c:85
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ do_pad()

static void do_pad ( gcry_cipher_hd_t  out_cipher,
char *  dgram,
size_t  pad_size 
)
static

Pad dgram by pad_size using out_cipher.

Parameters
out_ciphercipher to use
dgramdatagram to pad
pad_sizenumber of bytes of padding to append

Definition at line 2573 of file gnunet-communicator-udp.c.

References GNUNET_assert, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_block(), GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_PAD, and GNUNET_MessageHeader::size.

Referenced by mq_send_d(), mq_send_kx(), and send_UDPRekey().

2574 {
2575  char pad[pad_size];
2576 
2578  if (sizeof(pad) > sizeof(struct GNUNET_MessageHeader))
2579  {
2580  struct GNUNET_MessageHeader hdr =
2581  { .size = htons (sizeof(pad)),
2582  .type = htons (GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_PAD) };
2583 
2584  memcpy (pad, &hdr, sizeof(hdr));
2585  }
2586  GNUNET_assert (
2587  0 ==
2588  gcry_cipher_encrypt (out_cipher, dgram, sizeof(pad), pad, sizeof(pad)));
2589 }
#define GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_PAD
UDP communicator padding.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
void GNUNET_CRYPTO_random_block(enum GNUNET_CRYPTO_Quality mode, void *buffer, size_t length)
Fill block with a random values.
Header for all communications.
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
Here is the call graph for this function:
Here is the caller graph for this function:

◆ mq_send_kx()

static void mq_send_kx ( struct GNUNET_MQ_Handle mq,
const struct GNUNET_MessageHeader msg,
void *  impl_state 
)
static

Signature of functions implementing the sending functionality of a message queue.

Parameters
mqthe message queue
msgthe message to send
impl_stateour struct ReceiverAddress

Definition at line 2601 of file gnunet-communicator-udp.c.

References ReceiverAddress::address, ReceiverAddress::address_len, destroy_all_secrets(), do_pad(), InitialKX::ephemeral, UdpHandshakeSignature::ephemeral, InitialKX::gcm_tag, GNUNET_a2s(), GNUNET_assert, GNUNET_break, GNUNET_CRYPTO_ecdhe_key_create(), GNUNET_CRYPTO_ecdhe_key_get_public(), GNUNET_CRYPTO_eddsa_sign, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_log_strerror, GNUNET_MQ_impl_send_continue(), GNUNET_NETWORK_socket_sendto(), GNUNET_NO, GNUNET_SIGNATURE_COMMUNICATOR_UDP_HANDSHAKE, GNUNET_TIME_absolute_get_monotonic(), GNUNET_TIME_absolute_hton(), GNUNET_YES, ReceiverAddress::kx_mq, ReceiverAddress::kx_mtu, SharedSecret::master, MAX_SECRETS, UDPConfirmation::monotonic_time, UdpHandshakeSignature::monotonic_time, my_identity, ReceiverAddress::num_secrets, GNUNET_CRYPTO_EccSignaturePurpose::purpose, UdpHandshakeSignature::purpose, UdpHandshakeSignature::receiver, receiver_destroy(), ReceiverAddress::receiver_destroy_called, InitialKX::rekeying, ReceiverAddress::rekeying, reschedule_receiver_timeout(), UDPConfirmation::sender, UdpHandshakeSignature::sender, UDPConfirmation::sender_sig, setup_cipher(), setup_shared_secret_enc(), GNUNET_CRYPTO_EccSignaturePurpose::size, GNUNET_MessageHeader::size, ReceiverAddress::target, and uc.

Referenced by setup_receiver_mq().

2604 {
2605  struct ReceiverAddress *receiver = impl_state;
2606  uint16_t msize = ntohs (msg->size);
2607  struct UdpHandshakeSignature uhs;
2608  struct UDPConfirmation uc;
2609  struct InitialKX kx;
2610  struct GNUNET_CRYPTO_EcdhePrivateKey epriv;
2611  char dgram[receiver->kx_mtu + sizeof(uc) + sizeof(kx)];
2612  size_t dpos;
2613  gcry_cipher_hd_t out_cipher;
2614  struct SharedSecret *ss;
2615 
2616  GNUNET_assert (mq == receiver->kx_mq);
2617  if (msize > receiver->kx_mtu)
2618  {
2619  GNUNET_break (0);
2620  if (GNUNET_YES != receiver->receiver_destroy_called)
2621  receiver_destroy (receiver);
2622  return;
2623  }
2624  reschedule_receiver_timeout (receiver);
2625 
2626  /* setup key material */
2628 
2629  ss = setup_shared_secret_enc (&epriv, receiver, GNUNET_YES);
2630 
2631  if (receiver->num_secrets > MAX_SECRETS)
2632  {
2634  }
2635 
2636  setup_cipher (&ss->master, 0, &out_cipher);
2637  /* compute 'uc' */
2638  uc.sender = my_identity;
2639  uc.monotonic_time =
2641  uhs.purpose.purpose = htonl (GNUNET_SIGNATURE_COMMUNICATOR_UDP_HANDSHAKE);
2642  uhs.purpose.size = htonl (sizeof(uhs));
2643  uhs.sender = my_identity;
2644  uhs.receiver = receiver->target;
2645  GNUNET_CRYPTO_ecdhe_key_get_public (&epriv, &uhs.ephemeral);
2646  uhs.monotonic_time = uc.monotonic_time;
2648  &uhs,
2649  &uc.sender_sig);
2650  /* Leave space for kx */
2651  dpos = sizeof(kx);
2652  /* Append encrypted uc to dgram */
2653  GNUNET_assert (0 == gcry_cipher_encrypt (out_cipher,
2654  &dgram[dpos],
2655  sizeof(uc),
2656  &uc,
2657  sizeof(uc)));
2658  dpos += sizeof(uc);
2659  /* Append encrypted payload to dgram */
2660  GNUNET_assert (
2661  0 == gcry_cipher_encrypt (out_cipher, &dgram[dpos], msize, msg, msize));
2662  dpos += msize;
2663  do_pad (out_cipher, &dgram[dpos], sizeof(dgram) - dpos);
2664  /* Datagram starts with kx */
2665  kx.ephemeral = uhs.ephemeral;
2666  GNUNET_assert (
2667  0 == gcry_cipher_gettag (out_cipher, kx.gcm_tag, sizeof(kx.gcm_tag)));
2668  gcry_cipher_close (out_cipher);
2669  if (GNUNET_NO == receiver->rekeying)
2670  kx.rekeying = GNUNET_NO;
2671  else
2672  kx.rekeying = GNUNET_YES;
2673  memcpy (dgram, &kx, sizeof(kx));
2675  dgram,
2676  sizeof(dgram),
2677  receiver->address,
2678  receiver->address_len))
2681  "Sending KX to %s\n", GNUNET_a2s (receiver->address,
2682  receiver->address_len));
2684 }
#define GNUNET_CRYPTO_eddsa_sign(priv, ps, sig)
EdDSA sign a given block.
static struct GNUNET_PeerIdentity my_identity
Our public key.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct sockaddr * address
Address of the other peer.
static struct GNUNET_FS_UnindexContext * uc
unsigned int num_secrets
Length of the DLL at ss_head.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
Encrypted continuation of UDP initial handshake, followed by message header with payload.
#define GNUNET_SIGNATURE_COMMUNICATOR_UDP_HANDSHAKE
Signature used by UDP communicator handshake.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
"Plaintext" header at beginning of KX message.
static void setup_cipher(const struct GNUNET_HashCode *msec, uint32_t serial, gcry_cipher_hd_t *cipher)
Setup cipher based on shared secret msec and serial number serial.
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
void GNUNET_CRYPTO_ecdhe_key_create(struct GNUNET_CRYPTO_EcdhePrivateKey *pk)
Create a new private key.
Definition: crypto_ecc.c:435
struct GNUNET_HashCode master
Master shared secret.
struct GNUNET_MQ_Handle * kx_mq
KX message queue we are providing for the ch.
#define MAX_SECRETS
How many shared master secrets do we keep around at most per sender? Should be large enough so that w...
size_t kx_mtu
MTU we allowed transport for this receiver&#39;s KX queue.
ssize_t GNUNET_NETWORK_socket_sendto(const struct GNUNET_NETWORK_Handle *desc, const void *message, size_t length, const struct sockaddr *dest_addr, socklen_t dest_len)
Send data to a particular destination (always non-blocking).
Definition: network.c:846
const char * GNUNET_a2s(const struct sockaddr *addr, socklen_t addrlen)
Convert a "struct sockaddr*" (IPv4 or IPv6 address) to a string (for printing debug messages)...
static struct GNUNET_CRYPTO_EddsaPrivateKey * my_private_key
Our private key.
int receiver_destroy_called
receiver_destroy already called on receiver.
Information we track per receiving address we have recently been in contact with (encryption to recei...
Private ECC key encoded for transmission.
Shared secret we generated for a particular sender or receiver.
void GNUNET_CRYPTO_ecdhe_key_get_public(const struct GNUNET_CRYPTO_EcdhePrivateKey *priv, struct GNUNET_CRYPTO_EcdhePublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:213
static struct SharedSecret * setup_shared_secret_enc(const struct GNUNET_CRYPTO_EcdhePrivateKey *ephemeral, struct ReceiverAddress *receiver, int add_to_receiver)
Setup shared secret for encryption.
static struct GNUNET_NETWORK_Handle * udp_sock
Our socket.
void receiver(void *cls, const void *buf, size_t available, const struct sockaddr *addr, socklen_t addrlen, int errCode)
Callback to read from the SOCKS5 proxy.
Definition: socks.c:329
static void do_pad(gcry_cipher_hd_t out_cipher, char *dgram, size_t pad_size)
Pad dgram by pad_size using out_cipher.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get_monotonic(const struct GNUNET_CONFIGURATION_Handle *cfg)
Obtain the current time and make sure it is monotonically increasing.
Definition: time.c:590
static void reschedule_receiver_timeout(struct ReceiverAddress *receiver)
Increment receiver timeout due to activity.
socklen_t address_len
Length of the address.
static void receiver_destroy(struct ReceiverAddress *receiver)
Destroys a receiving state due to timeout or shutdown.
#define GNUNET_log(kind,...)
Signature we use to verify that the ephemeral key was really chosen by the specified sender...
struct GNUNET_PeerIdentity target
To whom are we talking to.
static void destroy_all_secrets(struct SharedSecret *ss, int withoutKce)
Destroying all secrets.
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:464
void GNUNET_MQ_impl_send_continue(struct GNUNET_MQ_Handle *mq)
Call the send implementation for the next queued message, if any.
Definition: mq.c:499
static const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
int rekeying
Flag indicating sender is initiated rekeying for this receiver.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ check_for_rekeying()

static void check_for_rekeying ( struct ReceiverAddress receiver,
struct UDPBox box 
)
static

Definition at line 2688 of file gnunet-communicator-udp.c.

References GNUNET_TIME_Absolute::abs_value_us, ReceiverAddress::acks_available, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_sh2s(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_relative_to_absolute(), GNUNET_YES, UDPBox::kid, ReceiverAddress::rekey_acks_available, rekey_interval, rekey_max_bytes, ReceiverAddress::rekey_send_bytes, ReceiverAddress::rekey_timeout, UDPBox::rekeying, ReceiverAddress::rekeying, GNUNET_TIME_Relative::rel_value_us, and ReceiverAddress::ss_rekey.

Referenced by mq_send_d().

2689 {
2690 
2691  struct GNUNET_TIME_Relative rt;
2692 
2694  "Timeout is %llu\n.",
2695  (unsigned long long) receiver->rekey_timeout.abs_value_us);
2696 
2697  if (0 == receiver->rekey_timeout.abs_value_us)
2698  {
2700  rekey_interval);
2701  }
2702  else
2703  {
2706  "Relative time is %llu and timeout is %llu\n.",
2707  (unsigned long long) rt.rel_value_us,
2708  (unsigned long long) receiver->rekey_timeout.abs_value_us);
2709 
2710  if ((0 == rt.rel_value_us) || (receiver->rekey_send_bytes >
2711  rekey_max_bytes) )
2712  {
2714  "Bytes send %llu greater than %llu max bytes\n.",
2715  (unsigned long long) receiver->rekey_send_bytes,
2716  rekey_max_bytes);
2718  "Relative time is %llu and timeout is %llu\n.",
2719  (unsigned long long) rt.rel_value_us,
2720  (unsigned long long) receiver->rekey_timeout.abs_value_us);
2721 
2722  receiver->rekey_timeout.abs_value_us = 0;
2723  receiver->rekey_send_bytes = 0;
2724  receiver->ss_rekey = NULL;
2725  // destroy_all_secrets (ss, GNUNET_NO);
2726  receiver->rekeying = GNUNET_YES;
2727  receiver->rekey_acks_available = receiver->acks_available;
2728  box->rekeying = GNUNET_YES;
2730  "Sender started rekeying.\n");
2731  if (GNUNET_YES == box->rekeying)
2733  "Sending rekeying with kid %s\n",
2734  GNUNET_sh2s (&box->kid));
2735  }
2736  }
2737 }
struct GNUNET_TIME_Absolute rekey_timeout
Timeout for this receiver address.
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:181
static unsigned long long rekey_max_bytes
How often we do rekey based on number of bytes transmitted.
uint64_t abs_value_us
The actual value.
struct SharedSecret * ss_rekey
Shared secret we use with target for rekeying.
struct GNUNET_ShortHashCode kid
Key and IV identification code.
static struct GNUNET_TIME_Relative rekey_interval
The rekey interval.
uint64_t rekey_send_bytes
Send bytes for this receiver address.
unsigned int rekey_acks_available
Acks available when we started rekeying.
unsigned int acks_available
Number of BOX keys from ACKs we have currently available for this receiver.
int rekeying
A flag indicating, if the sender is doing rekeying.
#define GNUNET_log(kind,...)
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:232
int rekeying
Flag indicating sender is initiated rekeying for this receiver.
Time for relative time used by GNUnet, in microseconds.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ send_UDPRekey()

static void send_UDPRekey ( struct ReceiverAddress receiver,
struct SharedSecret ss 
)
static

Definition at line 2741 of file gnunet-communicator-udp.c.

References do_pad(), UDPRekey::gcm_tag, get_kid(), GNUNET_a2s(), GNUNET_assert, GNUNET_CRYPTO_ecdhe_key_create(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_log, GNUNET_log_strerror, GNUNET_NETWORK_socket_sendto(), GNUNET_NO, GNUNET_sh2s(), UDPRekey::kid, SharedSecret::master, my_identity, SharedSecret::prev, UDPRekey::sender, SharedSecret::sequence_allowed, SharedSecret::sequence_used, setup_cipher(), and setup_shared_secret_enc().

Referenced by mq_send_d().

2742 {
2743  uint8_t is_ss_rekey_sequence_allowed_zero = GNUNET_NO;
2744  uint8_t is_acks_available_below = GNUNET_NO;
2745  uint8_t send_rekey = GNUNET_NO;
2746  uint16_t not_below;
2747  struct GNUNET_CRYPTO_EcdhePrivateKey epriv;
2748  struct UDPRekey *rekey;
2749  size_t dpos;
2750 
2751  char rekey_dgram[sizeof(struct UDPRekey) + receiver->d_mtu];
2752 
2753  if (NULL != receiver->ss_rekey)
2754  {
2755  not_below = (receiver->rekey_acks_available
2756  - (receiver->rekey_acks_available % 3)) / 3;
2757  is_ss_rekey_sequence_allowed_zero = (0 ==
2758  receiver->ss_rekey->sequence_allowed);
2759  is_acks_available_below = (receiver->acks_available >= not_below);
2760  send_rekey = (0 == (receiver->acks_available - not_below) % not_below) &&
2761  is_acks_available_below && is_ss_rekey_sequence_allowed_zero;
2763  "send_rekey: %u, %u, %u\n",
2764  send_rekey,
2765  receiver->rekey_acks_available,
2766  receiver->acks_available);
2767  }
2768  else if (NULL == receiver->ss_rekey)
2769  {
2770  /* setup key material */
2772  receiver->ss_rekey = setup_shared_secret_enc (&epriv, receiver,
2773  GNUNET_NO);
2774  receiver->ss_rekey->sequence_allowed = 0;
2776  "Setup secret with cmac %s\n",
2777  GNUNET_h2s (&(receiver->ss_rekey->cmac)));
2779  "Setup secret with master %s.\n",
2780  GNUNET_h2s (&(receiver->ss_rekey->master)));
2781  }
2782 
2783  if (send_rekey)
2784  {
2785  GNUNET_assert (0 != receiver->number_rekeying_kce);
2786  gcry_cipher_hd_t rekey_out_cipher;
2787 
2788  while (NULL != ss && ss->sequence_used >= ss->sequence_allowed)
2789  {
2790  ss = ss->prev;
2791  }
2792 
2793  if (NULL != ss)
2794  {
2795  rekey = (struct UDPRekey *) rekey_dgram;
2796  rekey->sender = my_identity;
2797  ss->sequence_used++;
2798  get_kid (&ss->master, ss->sequence_used, &rekey->kid);
2799  receiver->number_rekeying_kce--;
2800  setup_cipher (&ss->master, ss->sequence_used, &rekey_out_cipher);
2801  /* Append encrypted payload to dgram */
2802  dpos = sizeof(struct UDPRekey);
2803 
2804  GNUNET_assert (
2805  0 == gcry_cipher_encrypt (rekey_out_cipher, &rekey_dgram[dpos],
2806  sizeof(receiver->ss_rekey->master),
2807  &(receiver->ss_rekey->master),
2808  sizeof(receiver->ss_rekey->master)));
2809  dpos += sizeof(receiver->ss_rekey->master);
2810  /* GNUNET_assert ( */
2811  /* 0 == gcry_cipher_encrypt (rekey_out_cipher, &rekey_dgram[dpos], */
2812  /* /\*sizeof(receiver->ss_rekey->cmac), */
2813  /* &(receiver->ss_rekey->cmac), */
2814  /* sizeof(receiver->ss_rekey->cmac))); */
2815  /* dpos += sizeof(receiver->ss_rekey->cmac);*\/ */
2816  /* sizeof(receiver->ss_rekey), */
2817  /* receiver->ss_rekey, */
2818  /* sizeof(receiver->ss_rekey))); */
2819  /* dpos += sizeof(receiver->ss_rekey); */
2820  do_pad (rekey_out_cipher, &rekey_dgram[dpos], sizeof(rekey_dgram)
2821  - dpos);
2822  GNUNET_assert (0 == gcry_cipher_gettag (rekey_out_cipher,
2823  rekey->gcm_tag,
2824  sizeof(rekey->gcm_tag)));
2825  gcry_cipher_close (rekey_out_cipher);
2826 
2828  "Sending rekey with kid %s and master %s\n",
2829  GNUNET_sh2s (&rekey->kid),
2830  GNUNET_h2s (&(receiver->ss_rekey->master)));
2832  "Sending rekey with cmac %s\n",
2833  GNUNET_h2s (&(receiver->ss_rekey->cmac)));
2835  "%u rekey kces left.\n",
2836  receiver->number_rekeying_kce);
2837 
2839  rekey_dgram,
2840  sizeof(rekey_dgram),
2841  receiver->address,
2842  receiver->address_len))
2844 
2845  receiver->acks_available--;
2847  "%u receiver->acks_available 1\n",
2848  receiver->acks_available);
2850  "Sending UDPRekey to %s\n", GNUNET_a2s (receiver->address,
2851  receiver->
2852  address_len));
2853  }
2854  }
2855 }
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
static struct GNUNET_PeerIdentity my_identity
Our public key.
struct GNUNET_HashCode cmac
CMAC is used to identify master in ACKs.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
uint32_t sequence_allowed
Up to which sequence number did the other peer allow us to use this key, or up to which number did we...
struct sockaddr * address
Address of the other peer.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
static void setup_cipher(const struct GNUNET_HashCode *msec, uint32_t serial, gcry_cipher_hd_t *cipher)
Setup cipher based on shared secret msec and serial number serial.
struct SharedSecret * ss_rekey
Shared secret we use with target for rekeying.
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
void GNUNET_CRYPTO_ecdhe_key_create(struct GNUNET_CRYPTO_EcdhePrivateKey *pk)
Create a new private key.
Definition: crypto_ecc.c:435
uint32_t sequence_used
Up to which sequence number did we use this master already? (for encrypting only) ...
struct GNUNET_HashCode master
Master shared secret.
ssize_t GNUNET_NETWORK_socket_sendto(const struct GNUNET_NETWORK_Handle *desc, const void *message, size_t length, const struct sockaddr *dest_addr, socklen_t dest_len)
Send data to a particular destination (always non-blocking).
Definition: network.c:846
unsigned int rekey_acks_available
Acks available when we started rekeying.
UDP message box.
const char * GNUNET_a2s(const struct sockaddr *addr, socklen_t addrlen)
Convert a "struct sockaddr*" (IPv4 or IPv6 address) to a string (for printing debug messages)...
Private ECC key encoded for transmission.
static struct SharedSecret * setup_shared_secret_enc(const struct GNUNET_CRYPTO_EcdhePrivateKey *ephemeral, struct ReceiverAddress *receiver, int add_to_receiver)
Setup shared secret for encryption.
static void get_kid(const struct GNUNET_HashCode *msec, uint32_t serial, struct GNUNET_ShortHashCode *kid)
Compute kid.
static struct GNUNET_NETWORK_Handle * udp_sock
Our socket.
static void do_pad(gcry_cipher_hd_t out_cipher, char *dgram, size_t pad_size)
Pad dgram by pad_size using out_cipher.
struct SharedSecret * prev
Kept in a DLL.
struct GNUNET_PeerIdentity sender
Sender&#39;s identity.
unsigned int acks_available
Number of BOX keys from ACKs we have currently available for this receiver.
socklen_t address_len
Length of the address.
#define GNUNET_log(kind,...)
struct GNUNET_ShortHashCode kid
Key and IV identification code.
char gcm_tag[(128/8)]
128-bit authentication tag for the following encrypted message, from GCM.
int number_rekeying_kce
Number of kce we retain for sending the rekeying shared secret.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ mq_send_d()

static void mq_send_d ( struct GNUNET_MQ_Handle mq,
const struct GNUNET_MessageHeader msg,
void *  impl_state 
)
static

Signature of functions implementing the sending functionality of a message queue.

Parameters
mqthe message queue
msgthe message to send
impl_stateour struct ReceiverAddress

Definition at line 2867 of file gnunet-communicator-udp.c.

References ReceiverAddress::acks_available, add_acks_rekey(), check_for_rekeying(), ReceiverAddress::d_mq, ReceiverAddress::d_mtu, do_pad(), UDPBox::gcm_tag, get_kid(), GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_log, GNUNET_log_strerror, GNUNET_MQ_impl_send_continue(), GNUNET_NETWORK_socket_sendto(), GNUNET_NO, GNUNET_YES, UDPBox::kid, SharedSecret::prev, receiver_destroy(), ReceiverAddress::receiver_destroy_called, UDPBox::rekeying, reschedule_receiver_timeout(), send_UDPRekey(), setup_cipher(), GNUNET_MessageHeader::size, and ReceiverAddress::ss_tail.

Referenced by setup_receiver_mq().

2870 {
2871  struct ReceiverAddress *receiver = impl_state;
2872  uint16_t msize = ntohs (msg->size);
2873 
2874  GNUNET_assert (mq == receiver->d_mq);
2875  if ((msize > receiver->d_mtu) ||
2876  (0 == receiver->acks_available))
2877  {
2879  "msize: %u, mtu: %lu, acks: %u\n",
2880  msize,
2881  receiver->d_mtu,
2882  receiver->acks_available);
2883 
2884  GNUNET_break (0);
2885  if (GNUNET_YES != receiver->receiver_destroy_called)
2886  receiver_destroy (receiver);
2887  return;
2888  }
2889  reschedule_receiver_timeout (receiver);
2890 
2891  /* begin "BOX" encryption method, scan for ACKs from tail! */
2892  for (struct SharedSecret *ss = receiver->ss_tail; NULL != ss; ss = ss->prev)
2893  {
2894  if (0 < ss->sequence_used)
2896  "Trying to send UDPBox with shared secrect %s sequence_used %u and ss->sequence_allowed %u\n",
2897  GNUNET_h2s (&ss->master),
2898  ss->sequence_used,
2899  ss->sequence_allowed);
2900  // Uncomment this for alternativ 1 of backchannel functionality
2901  if (ss->sequence_used >= ss->sequence_allowed)
2902  // Until here for alternativ 1
2903  // Uncomment this for alternativ 2 of backchannel functionality
2904  // if (0 == ss->sequence_allowed)
2905  // Until here for alternativ 2
2906  {
2907  continue;
2908  }
2909  char dgram[sizeof(struct UDPBox) + receiver->d_mtu];
2910  struct UDPBox *box;
2911  gcry_cipher_hd_t out_cipher;
2912  size_t dpos;
2913 
2914  box = (struct UDPBox *) dgram;
2915  ss->sequence_used++;
2916  get_kid (&ss->master, ss->sequence_used, &box->kid);
2917  setup_cipher (&ss->master, ss->sequence_used, &out_cipher);
2918  /* Append encrypted payload to dgram */
2919  dpos = sizeof(struct UDPBox);
2920  GNUNET_assert (
2921  0 == gcry_cipher_encrypt (out_cipher, &dgram[dpos], msize, msg, msize));
2922  dpos += msize;
2923  do_pad (out_cipher, &dgram[dpos], sizeof(dgram) - dpos);
2924  GNUNET_assert (0 == gcry_cipher_gettag (out_cipher,
2925  box->gcm_tag,
2926  sizeof(box->gcm_tag)));
2927  gcry_cipher_close (out_cipher);
2928 
2929  receiver->rekey_send_bytes += sizeof(struct UDPBox) + receiver->d_mtu;
2930 
2931  if (GNUNET_NO == receiver->rekeying)
2932  box->rekeying = GNUNET_NO;
2933  else
2934  box->rekeying = GNUNET_YES;
2935 
2937  dgram,
2938  sizeof(dgram),
2939  receiver->address,
2940  receiver->address_len))
2943  "Sending UDPBox %u acks left\n",
2944  receiver->acks_available);
2946  receiver->acks_available--;
2948  "%u receiver->acks_available 2\n",
2949  receiver->acks_available);
2950  check_for_rekeying (receiver, box);
2951  if (0 == receiver->acks_available - receiver->number_rekeying_kce)
2952  {
2953  /* We have no more ACKs */
2955  "No more acks\n");
2956  if (GNUNET_YES == receiver->rekeying)
2957  {
2958  receiver->rekeying = GNUNET_NO;
2960  "Sender stopped rekeying\n");
2961 
2962  if ((NULL != receiver->ss_rekey) && (0 <
2963  receiver->ss_rekey->
2964  sequence_allowed) )
2965  add_acks_rekey (receiver);
2966  }
2967  }
2968  else if ((GNUNET_YES == receiver->rekeying) )
2969  {
2970  send_UDPRekey (receiver, ss);
2971  }
2972 
2973  return;
2974  }
2975 }
char gcm_tag[(128/8)]
128-bit authentication tag for the following encrypted message, from GCM.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static void send_UDPRekey(struct ReceiverAddress *receiver, struct SharedSecret *ss)
struct sockaddr * address
Address of the other peer.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static void setup_cipher(const struct GNUNET_HashCode *msec, uint32_t serial, gcry_cipher_hd_t *cipher)
Setup cipher based on shared secret msec and serial number serial.
struct SharedSecret * ss_rekey
Shared secret we use with target for rekeying.
struct GNUNET_ShortHashCode kid
Key and IV identification code.
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
uint64_t rekey_send_bytes
Send bytes for this receiver address.
static void add_acks_rekey(struct ReceiverAddress *receiver)
struct SharedSecret * ss_tail
Shared secrets we received with target, last used is tail.
ssize_t GNUNET_NETWORK_socket_sendto(const struct GNUNET_NETWORK_Handle *desc, const void *message, size_t length, const struct sockaddr *dest_addr, socklen_t dest_len)
Send data to a particular destination (always non-blocking).
Definition: network.c:846
UDP message box.
int receiver_destroy_called
receiver_destroy already called on receiver.
Information we track per receiving address we have recently been in contact with (encryption to recei...
size_t d_mtu
MTU we allowed transport for this receiver&#39;s default queue.
Shared secret we generated for a particular sender or receiver.
static void get_kid(const struct GNUNET_HashCode *msec, uint32_t serial, struct GNUNET_ShortHashCode *kid)
Compute kid.
static struct GNUNET_NETWORK_Handle * udp_sock
Our socket.
void receiver(void *cls, const void *buf, size_t available, const struct sockaddr *addr, socklen_t addrlen, int errCode)
Callback to read from the SOCKS5 proxy.
Definition: socks.c:329
static void do_pad(gcry_cipher_hd_t out_cipher, char *dgram, size_t pad_size)
Pad dgram by pad_size using out_cipher.
struct SharedSecret * prev
Kept in a DLL.
unsigned int acks_available
Number of BOX keys from ACKs we have currently available for this receiver.
static void reschedule_receiver_timeout(struct ReceiverAddress *receiver)
Increment receiver timeout due to activity.
int rekeying
A flag indicating, if the sender is doing rekeying.
socklen_t address_len
Length of the address.
static void receiver_destroy(struct ReceiverAddress *receiver)
Destroys a receiving state due to timeout or shutdown.
#define GNUNET_log(kind,...)
static void check_for_rekeying(struct ReceiverAddress *receiver, struct UDPBox *box)
int number_rekeying_kce
Number of kce we retain for sending the rekeying shared secret.
void GNUNET_MQ_impl_send_continue(struct GNUNET_MQ_Handle *mq)
Call the send implementation for the next queued message, if any.
Definition: mq.c:499
int rekeying
Flag indicating sender is initiated rekeying for this receiver.
struct GNUNET_MQ_Handle * d_mq
Default message queue we are providing for the ch.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ mq_destroy_d()

static void mq_destroy_d ( struct GNUNET_MQ_Handle mq,
void *  impl_state 
)
static

Signature of functions implementing the destruction of a message queue.

Implementations must not free mq, but should take care of impl_state.

Parameters
mqthe message queue to destroy
impl_stateour struct ReceiverAddress

Definition at line 2987 of file gnunet-communicator-udp.c.

References ReceiverAddress::d_mq, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_YES, receiver_destroy(), and ReceiverAddress::receiver_destroy_called.

Referenced by setup_receiver_mq().

2988 {
2989  struct ReceiverAddress *receiver = impl_state;
2991  "Default MQ destroyed\n");
2992  if (mq == receiver->d_mq)
2993  {
2994  receiver->d_mq = NULL;
2995  if (GNUNET_YES != receiver->receiver_destroy_called)
2996  receiver_destroy (receiver);
2997  }
2998 }
int receiver_destroy_called
receiver_destroy already called on receiver.
Information we track per receiving address we have recently been in contact with (encryption to recei...
void receiver(void *cls, const void *buf, size_t available, const struct sockaddr *addr, socklen_t addrlen, int errCode)
Callback to read from the SOCKS5 proxy.
Definition: socks.c:329
static void receiver_destroy(struct ReceiverAddress *receiver)
Destroys a receiving state due to timeout or shutdown.
#define GNUNET_log(kind,...)
struct GNUNET_MQ_Handle * d_mq
Default message queue we are providing for the ch.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ mq_destroy_kx()

static void mq_destroy_kx ( struct GNUNET_MQ_Handle mq,
void *  impl_state 
)
static

Signature of functions implementing the destruction of a message queue.

Implementations must not free mq, but should take care of impl_state.

Parameters
mqthe message queue to destroy
impl_stateour struct ReceiverAddress

Definition at line 3010 of file gnunet-communicator-udp.c.

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_YES, ReceiverAddress::kx_mq, receiver_destroy(), and ReceiverAddress::receiver_destroy_called.

Referenced by setup_receiver_mq().

3011 {
3012  struct ReceiverAddress *receiver = impl_state;
3014  "KX MQ destroyed\n");
3015  if (mq == receiver->kx_mq)
3016  {
3017  receiver->kx_mq = NULL;
3018  if (GNUNET_YES != receiver->receiver_destroy_called)
3019  receiver_destroy (receiver);
3020  }
3021 }
struct GNUNET_MQ_Handle * kx_mq
KX message queue we are providing for the ch.
int receiver_destroy_called
receiver_destroy already called on receiver.
Information we track per receiving address we have recently been in contact with (encryption to recei...
void receiver(void *cls, const void *buf, size_t available, const struct sockaddr *addr, socklen_t addrlen, int errCode)
Callback to read from the SOCKS5 proxy.
Definition: socks.c:329
static void receiver_destroy(struct ReceiverAddress *receiver)
Destroys a receiving state due to timeout or shutdown.
#define GNUNET_log(kind,...)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ mq_cancel()

static void mq_cancel ( struct GNUNET_MQ_Handle mq,
void *  impl_state 
)
static

Implementation function that cancels the currently sent message.

Parameters
mqmessage queue
impl_stateour struct RecvierAddress

Definition at line 3031 of file gnunet-communicator-udp.c.

References GNUNET_assert.

Referenced by setup_receiver_mq().

3032 {
3033  /* Cancellation is impossible with UDP; bail */
3034  GNUNET_assert (0);
3035 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Here is the caller graph for this function:

◆ mq_error()

static void mq_error ( void *  cls,
enum GNUNET_MQ_Error  error 
)
static

Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue.

Not every message queue implementation supports an error handler.

Parameters
clsour struct ReceiverAddress
errorerror code

Definition at line 3048 of file gnunet-communicator-udp.c.

References GNUNET_ERROR_TYPE_ERROR, GNUNET_i2s(), GNUNET_log, receiver_destroy(), and ReceiverAddress::target.

Referenced by setup_receiver_mq().

3049 {
3050  struct ReceiverAddress *receiver = cls;
3051 
3053  "MQ error in queue to %s: %d\n",
3054  GNUNET_i2s (&receiver->target),
3055  (int) error);
3056  receiver_destroy (receiver);
3057 }
Information we track per receiving address we have recently been in contact with (encryption to recei...
void receiver(void *cls, const void *buf, size_t available, const struct sockaddr *addr, socklen_t addrlen, int errCode)
Callback to read from the SOCKS5 proxy.
Definition: socks.c:329
static void receiver_destroy(struct ReceiverAddress *receiver)
Destroys a receiving state due to timeout or shutdown.
#define GNUNET_log(kind,...)
struct GNUNET_PeerIdentity target
To whom are we talking to.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
Here is the call graph for this function:
Here is the caller graph for this function:

◆ mq_init()

static int mq_init ( void *  cls,
const struct GNUNET_PeerIdentity peer,
const char *  address 
)
static

Function called by the transport service to initialize a message queue given address information about another peer.

If and when the communication channel is established, the communicator must call GNUNET_TRANSPORT_communicator_mq_add() to notify the service that the channel is now up. It is the responsibility of the communicator to manage sane retries and timeouts for any peer/address combination provided by the transport service. Timeouts and retries do not need to be signalled to the transport service.

Parameters
clsclosure
peeridentity of the other peer
addresswhere to send the message, human-readable communicator-specific format, 0-terminated, UTF-8
Returns
GNUNET_OK on success, GNUNET_SYSERR if the provided address is invalid

Definition at line 3171 of file gnunet-communicator-udp.c.

References GNUNET_TIME_Absolute::abs_value_us, ReceiverAddress::address, ReceiverAddress::address_len, check_timeouts(), COMMUNICATOR_ADDRESS_PREFIX, ReceiverAddress::foreign_addr, GNUNET_break_op, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_CONTAINER_heap_insert(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multipeermap_put(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s_full(), GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_NT_scanner_get_type(), GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_STATISTICS_set(), GNUNET_SYSERR, GNUNET_TIME_relative_to_absolute(), ReceiverAddress::hn, ReceiverAddress::nt, peer, UdpHandshakeSignature::receiver, setup_receiver_mq(), sockaddr_to_udpaddr_string(), ReceiverAddress::target, ReceiverAddress::timeout, and udp_address_to_sockaddr().

Referenced by run().

3172 {
3173  struct ReceiverAddress *receiver;
3174  const char *path;
3175  struct sockaddr *in;
3176  socklen_t in_len;
3177 
3178  if (0 != strncmp (address,
3180  strlen (COMMUNICATOR_ADDRESS_PREFIX "-")))
3181  {
3182  GNUNET_break_op (0);
3183  return GNUNET_SYSERR;
3184  }
3185  path = &address[strlen (COMMUNICATOR_ADDRESS_PREFIX "-")];
3186  in = udp_address_to_sockaddr (path, &in_len);
3187 
3188  receiver = GNUNET_new (struct ReceiverAddress);
3189  receiver->address = in;
3190  receiver->address_len = in_len;
3191  receiver->target = *peer;
3192  receiver->nt = GNUNET_NT_scanner_get_type (is, in, in_len);
3194  receivers,
3195  &receiver->target,
3196  receiver,
3199  "Added %s to receivers\n",
3200  GNUNET_i2s_full (&receiver->target));
3201  receiver->timeout =
3204  receiver,
3205  receiver->timeout.abs_value_us);
3207  "# receivers active",
3209  GNUNET_NO);
3210  receiver->foreign_addr =
3211  sockaddr_to_udpaddr_string (receiver->address, receiver->address_len);
3212  setup_receiver_mq (receiver);
3213  if (NULL == timeout_task)
3215  return GNUNET_OK;
3216 }
enum GNUNET_NetworkType GNUNET_NT_scanner_get_type(struct GNUNET_NT_InterfaceScanner *is, const struct sockaddr *addr, socklen_t addrlen)
Returns where the address is located: loopback, LAN or WAN.
Definition: nt.c:314
struct GNUNET_CONTAINER_HeapNode * GNUNET_CONTAINER_heap_insert(struct GNUNET_CONTAINER_Heap *heap, void *element, GNUNET_CONTAINER_HeapCostType cost)
Inserts a new element into the heap.
struct GNUNET_CONTAINER_HeapNode * hn
Entry in sender exp