GNUnet debian-0.24.3-29-g453fda2cf
 
Loading...
Searching...
No Matches
gnunet-service-core_kx.h File Reference

code for managing the key exchange (SET_KEY, PING, PONG) with other peers More...

Include dependency graph for gnunet-service-core_kx.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  InitiatorHelloPayload
 
struct  InitiatorHello
 TODO. More...
 
struct  ConfirmationAck
 The ACK. More...
 
struct  ResponderHello
 ResponderHello. More...
 
struct  ResponderHelloPayload
 
struct  InitiatorDone
 InitiatorDone. More...
 
struct  EncryptedMessage
 EncryptedMessage. More...
 
struct  Heartbeat
 KeyUpdate. More...
 

Enumerations

enum  HeartbeatFlags { GSC_HEARTBEAT_KEY_UPDATE_REQUESTED = 1 }
 Heartbeat flags. More...
 

Functions

void GSC_KX_encrypt_and_transmit (struct GSC_KeyExchangeInfo *kx, const void *payload, size_t payload_size)
 Encrypt and transmit a message with the given payload.
 
int GSC_KX_init (void)
 Initialize KX subsystem.
 
void GSC_KX_done (void)
 Shutdown KX subsystem.
 
int GSC_NEIGHBOURS_check_excess_bandwidth (const struct GSC_KeyExchangeInfo *target)
 Check if the given neighbour has excess bandwidth available.
 
unsigned int GSC_NEIGHBOURS_get_queue_length (const struct GSC_KeyExchangeInfo *target)
 Check how many messages are queued for the given neighbour.
 
void GSC_KX_handle_client_monitor_peers (struct GNUNET_MQ_Handle *mq)
 Handle GNUNET_MESSAGE_TYPE_CORE_MONITOR_PEERS request.
 

Detailed Description

code for managing the key exchange (SET_KEY, PING, PONG) with other peers

Author
Christian Grothoff

Definition in file gnunet-service-core_kx.h.

Enumeration Type Documentation

◆ HeartbeatFlags

Heartbeat flags.

Enumerator
GSC_HEARTBEAT_KEY_UPDATE_REQUESTED 

A key update is requested.

Definition at line 225 of file gnunet-service-core_kx.h.

226{
231
232};
@ GSC_HEARTBEAT_KEY_UPDATE_REQUESTED
A key update is requested.

Function Documentation

◆ GSC_KX_encrypt_and_transmit()

void GSC_KX_encrypt_and_transmit ( struct GSC_KeyExchangeInfo kx,
const void *  payload,
size_t  payload_size 
)

Encrypt and transmit a message with the given payload.

Parameters
kxkey exchange context
payloadpayload of the message
payload_sizenumber of bytes in 'payload'

Encrypt and transmit a message with the given payload.

Parameters
kxkey exchange info
payloadthe payload
payload_sizesize of the payload

Definition at line 2741 of file gnunet-service-core_kx.c.

2744{
2745 struct GNUNET_MQ_Envelope *env;
2746 struct EncryptedMessage *encrypted_msg;
2747 unsigned char enc_key[AEAD_KEY_BYTES];
2748 unsigned char enc_nonce[AEAD_NONCE_BYTES];
2749 unsigned char seq_enc_k[crypto_stream_chacha20_ietf_KEYBYTES];
2750 uint64_t sqn;
2751 uint64_t epoch;
2752 int8_t ret;
2753
2754 encrypted_msg = NULL;
2755
2756 check_rekey (kx);
2757 sqn = kx->current_sqn;
2758 epoch = kx->current_epoch;
2759 /* We are the sender and as we are going to send,
2760 * we are using the initiator key material */
2762 sqn,
2763 enc_key,
2764 enc_nonce);
2765 kx->current_sqn++;
2766 derive_sn (&kx->current_ats,
2767 seq_enc_k,
2768 sizeof seq_enc_k);
2769 env = GNUNET_MQ_msg_extra (encrypted_msg,
2770 payload_size,
2772 // only encrypt the payload for now
2773 // TODO encrypt other fields as well
2774 ret = crypto_aead_xchacha20poly1305_ietf_encrypt_detached (
2775 (unsigned char*) &encrypted_msg[1], // c - resulting ciphertext
2776 (unsigned char*) &encrypted_msg->tag, // mac - resulting mac/tag
2777 NULL, // maclen
2778 (unsigned char*) payload, // m - plain message
2779 payload_size, // mlen
2780 NULL, // ad - additional data TODO also cover the unencrypted part (epoch)
2781 0, // adlen
2782 NULL, // nsec - unused
2783 enc_nonce, // npub nonce
2784 enc_key // k - key
2785 );
2786 if (0 != ret)
2787 {
2789 "Something went wrong encrypting message\n");
2790 GNUNET_assert (0);
2791 }
2792 {
2793 /* compute the sequence number */
2794 unsigned char *seq_enc_nonce;
2795 uint64_t seq_nbo;
2796 uint32_t seq_enc_ctr;
2797
2798 seq_nbo = GNUNET_htonll (sqn);
2799 seq_enc_ctr = *((uint32_t*) encrypted_msg->tag);
2800 seq_enc_nonce = &encrypted_msg->tag[sizeof (uint32_t)];
2801 crypto_stream_chacha20_ietf_xor_ic (
2802 (unsigned char*) &encrypted_msg->sequence_number,
2803 (unsigned char*) &seq_nbo,
2804 sizeof seq_nbo,
2805 seq_enc_nonce,
2806 ntohl (seq_enc_ctr),
2807 seq_enc_k);
2808#if DEBUG_KX
2809 GNUNET_print_bytes (seq_enc_k,
2810 sizeof seq_enc_k,
2811 8,
2812 GNUNET_NO);
2813 GNUNET_print_bytes ((char*) &seq_enc_ctr,
2814 16,
2815 8,
2816 GNUNET_NO);
2817#endif
2819 "Sending encrypted message with E(SQN=%" PRIu64 ")=%" PRIu64
2820 "\n",
2821 sqn,
2822 encrypted_msg->sequence_number);
2823 }
2824 encrypted_msg->epoch = GNUNET_htonll (epoch);
2825
2826 // TODO actually copy payload
2827 GNUNET_MQ_send (kx->mq, env);
2828}
struct GNUNET_MQ_Envelope * env
Definition 005.c:1
static int ret
Final status code.
Definition gnunet-arm.c:93
#define AEAD_NONCE_BYTES
libsodium has very long symbol names
static void check_rekey(struct GSC_KeyExchangeInfo *kx)
static void derive_per_message_secrets(const struct GNUNET_ShortHashCode *ts, uint64_t seq, unsigned char key[crypto_aead_xchacha20poly1305_ietf_KEYBYTES], unsigned char nonce[crypto_aead_xchacha20poly1305_ietf_NPUBBYTES])
key = HKDF-Expand [I,R][A,H]TS, "key", 32) nonce = HKDF-Expand ([I,R][A,H]TS, "iv",...
#define AEAD_KEY_BYTES
libsodium has very long symbol names
static void derive_sn(const struct GNUNET_ShortHashCode *secret, unsigned char *sn, size_t sn_len)
static unsigned long long payload
How much data are we currently storing in the database?
#define GNUNET_log(kind,...)
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
@ GNUNET_NO
void GNUNET_print_bytes(const void *buf, size_t buf_len, int fold, int in_be)
Print a byte string in hexadecimal ascii notation.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition mq.c:305
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
#define GNUNET_MESSAGE_TYPE_CORE_ENCRYPTED_MESSAGE_CAKE
Encrypted message.
uint64_t current_sqn
Our current sequence number.
struct GNUNET_MQ_Handle * mq
Message queue for sending messages to peer.
uint64_t current_epoch
Our currently used epoch for sending.
struct GNUNET_ShortHashCode current_ats
*ATS - our current application traffic secret by epoch

References AEAD_KEY_BYTES, AEAD_NONCE_BYTES, check_rekey(), GSC_KeyExchangeInfo::current_ats, GSC_KeyExchangeInfo::current_epoch, GSC_KeyExchangeInfo::current_sqn, derive_per_message_secrets(), derive_sn(), env, EncryptedMessage::epoch, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_htonll(), GNUNET_log, GNUNET_MESSAGE_TYPE_CORE_ENCRYPTED_MESSAGE_CAKE, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_print_bytes(), GSC_KeyExchangeInfo::mq, payload, ret, EncryptedMessage::sequence_number, and EncryptedMessage::tag.

Referenced by handle_heartbeat(), handle_initiator_done(), send_heartbeat(), and try_transmission().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GSC_KX_init()

int GSC_KX_init ( void  )

Initialize KX subsystem.

Returns
GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 2865 of file gnunet-service-core_kx.c.

2866{
2868 GNUNET_MQ_hd_var_size (initiator_hello,
2870 struct InitiatorHello,
2871 NULL),
2872 GNUNET_MQ_hd_var_size (initiator_done,
2874 struct InitiatorDone,
2875 NULL),
2876 GNUNET_MQ_hd_var_size (responder_hello,
2878 struct ResponderHello,
2879 NULL),
2880 GNUNET_MQ_hd_var_size (encrypted_message, // TODO rename?
2882 struct EncryptedMessage,
2883 NULL),
2885 };
2886
2890 NULL); // TODO potentially wait
2891 // until we have a peer_id?
2892 // pay attention to whether
2893 // we have one anyways
2894 if (NULL == pils)
2895 {
2896 GSC_KX_done ();
2897 return GNUNET_SYSERR;
2898 }
2899
2901 transport =
2904 handlers,
2905 NULL, // cls - this connection-independant
2906 // cls seems not to be needed.
2907 // the connection-specific cls
2908 // will be set as a return value
2909 // of
2910 // handle_transport_notify_connect
2913 if (NULL == transport)
2914 {
2915 GSC_KX_done ();
2916 return GNUNET_SYSERR;
2917 }
2919 "Connected to TRANSPORT\n");
2920 return GNUNET_OK;
2921}
struct GNUNET_MQ_MessageHandlers handlers[]
Definition 003.c:1
const struct GNUNET_CONFIGURATION_Handle * GSC_cfg
Our configuration.
struct GNUNET_PeerIdentity GSC_my_identity
Our identity.
static void * handle_transport_notify_connect(void *cls, const struct GNUNET_PeerIdentity *peer_id, struct GNUNET_MQ_Handle *mq)
Function called by transport to notify us that a peer connected to us (on the network level).
static void peer_id_change_cb(void *cls, const struct GNUNET_HELLO_Parser *parser, const struct GNUNET_HashCode *hash)
Callback for PILS to be called once the peer id changes.
static void handle_transport_notify_disconnect(void *cls, const struct GNUNET_PeerIdentity *peer, void *handler_cls)
Function called by transport telling us that a peer disconnected.
static struct GNUNET_NotificationContext * nc
Notification context for broadcasting to monitors.
void GSC_KX_done()
Shutdown KX subsystem.
static enum GNUNET_GenericReturnValue init_phase
Indicates whether we are still in the initialisation phase (waiting for our peer id).
static struct GNUNET_TRANSPORT_CoreHandle * transport
Transport service.
static struct GNUNET_PILS_Handle * pils
Pils service.
struct GNUNET_PILS_Handle * GNUNET_PILS_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_PILS_PidChangeCallback pid_change_cb, void *cls)
Connect to the PILS service.
Definition pils_api.c:367
struct GNUNET_TRANSPORT_CoreHandle * GNUNET_TRANSPORT_core_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_PeerIdentity *self, const struct GNUNET_MQ_MessageHandler *handlers, void *cls, GNUNET_TRANSPORT_NotifyConnect nc, GNUNET_TRANSPORT_NotifyDisconnect nd)
Connect to the transport service.
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_SYSERR
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
struct GNUNET_NotificationContext * GNUNET_notification_context_create(unsigned int queue_length)
Create a new notification context.
Definition nc.c:122
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_MESSAGE_TYPE_CORE_INITIATOR_DONE
Third and final message of the handshake, second of the initiator.
#define GNUNET_MESSAGE_TYPE_CORE_RESPONDER_HELLO
Reply to the first message from the initiator - first message sent by the responder.
#define GNUNET_MESSAGE_TYPE_CORE_INITIATOR_HELLO
for more detail on the following messages see https://lsd.gnunet.org/lsd0012/draft-schanzen-cake....
Message handler for a specific message type.

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_CORE_ENCRYPTED_MESSAGE_CAKE, GNUNET_MESSAGE_TYPE_CORE_INITIATOR_DONE, GNUNET_MESSAGE_TYPE_CORE_INITIATOR_HELLO, GNUNET_MESSAGE_TYPE_CORE_RESPONDER_HELLO, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_notification_context_create(), GNUNET_OK, GNUNET_PILS_connect(), GNUNET_SYSERR, GNUNET_TRANSPORT_core_connect(), GNUNET_YES, GSC_cfg, GSC_KX_done(), GSC_my_identity, handle_transport_notify_connect(), handle_transport_notify_disconnect(), handlers, init_phase, nc, peer_id_change_cb(), pils, and transport.

Referenced by run().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GSC_KX_done()

void GSC_KX_done ( void  )

Shutdown KX subsystem.

Definition at line 2928 of file gnunet-service-core_kx.c.

2929{
2930 struct PilsRequest *pr;
2931 while (NULL != (pr = pils_requests_head))
2932 {
2935 pr);
2936 if (NULL != pr->op)
2937 GNUNET_PILS_cancel (pr->op);
2938 GNUNET_free (pr);
2939 }
2940 if (NULL != pils)
2941 {
2943 pils = NULL;
2944 }
2945 if (NULL != transport)
2946 {
2948 transport = NULL;
2949 }
2950 if (NULL != rekey_task)
2951 {
2953 rekey_task = NULL;
2954 }
2955 if (NULL != nc)
2956 {
2958 nc = NULL;
2959 }
2960}
static struct PilsRequest * pils_requests_head
PILS Operation DLL.
static struct PilsRequest * pils_requests_tail
PILS Operation DLL.
static struct GNUNET_SCHEDULER_Task * rekey_task
Task scheduled for periodic re-generation (and thus rekeying) of our ephemeral key.
void GNUNET_PILS_disconnect(struct GNUNET_PILS_Handle *handle)
Disconnect from the PILS service.
Definition pils_api.c:390
void GNUNET_PILS_cancel(struct GNUNET_PILS_Operation *op)
Cancel request.
Definition pils_api.c:495
void GNUNET_TRANSPORT_core_disconnect(struct GNUNET_TRANSPORT_CoreHandle *handle)
Disconnect from the transport service.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_notification_context_destroy(struct GNUNET_NotificationContext *nc)
Destroy the context, force disconnect for all subscribers.
Definition nc.c:138
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition scheduler.c:980
struct GNUNET_PILS_Operation * op
The pils operation.

References GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_notification_context_destroy(), GNUNET_PILS_cancel(), GNUNET_PILS_disconnect(), GNUNET_SCHEDULER_cancel(), GNUNET_TRANSPORT_core_disconnect(), nc, PilsRequest::op, pils, pils_requests_head, pils_requests_tail, rekey_task, and transport.

Referenced by GSC_KX_init(), and shutdown_task().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GSC_NEIGHBOURS_check_excess_bandwidth()

int GSC_NEIGHBOURS_check_excess_bandwidth ( const struct GSC_KeyExchangeInfo target)

Check if the given neighbour has excess bandwidth available.

Parameters
targetneighbour to check
Returns
GNUNET_YES if excess bandwidth is available, GNUNET_NO if not

Definition at line 2977 of file gnunet-service-core_kx.c.

2978{
2979 return kxinfo->has_excess_bandwidth;
2980}

References GSC_KeyExchangeInfo::has_excess_bandwidth.

Referenced by try_transmission().

Here is the caller graph for this function:

◆ GSC_NEIGHBOURS_get_queue_length()

unsigned int GSC_NEIGHBOURS_get_queue_length ( const struct GSC_KeyExchangeInfo kxinfo)

Check how many messages are queued for the given neighbour.

Parameters
targetneighbour to check
Returns
number of items in the message queue
Parameters
kxinfodata about neighbour to check
Returns
number of items in the message queue

Definition at line 2970 of file gnunet-service-core_kx.c.

2971{
2972 return GNUNET_MQ_get_length (kxinfo->mq);
2973}
unsigned int GNUNET_MQ_get_length(struct GNUNET_MQ_Handle *mq)
Obtain the current length of the message queue.
Definition mq.c:293

References GNUNET_MQ_get_length(), and GSC_KeyExchangeInfo::mq.

Referenced by try_transmission().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GSC_KX_handle_client_monitor_peers()

void GSC_KX_handle_client_monitor_peers ( struct GNUNET_MQ_Handle mq)

Handle GNUNET_MESSAGE_TYPE_CORE_MONITOR_PEERS request.

For this request type, the client does not have to have transmitted an INIT request. All current peers are returned, regardless of which message types they accept.

Parameters
mqmessage queue to add for monitoring

Definition at line 2992 of file gnunet-service-core_kx.c.

2993{
2994 struct GNUNET_MQ_Envelope *env;
2995 struct MonitorNotifyMessage *done_msg;
2996 struct GSC_KeyExchangeInfo *kx;
2997
2999 for (kx = kx_head; NULL != kx; kx = kx->next)
3000 {
3001 struct GNUNET_MQ_Envelope *env_notify;
3002 struct MonitorNotifyMessage *msg;
3003
3005 msg->state = htonl ((uint32_t) kx->status);
3006 msg->peer = kx->peer;
3007 msg->timeout = GNUNET_TIME_absolute_hton (kx->timeout);
3008 GNUNET_MQ_send (mq, env_notify);
3009 }
3011 done_msg->state = htonl ((uint32_t) GNUNET_CORE_KX_ITERATION_FINISHED);
3014}
struct GNUNET_MessageHeader * msg
Definition 005.c:2
static struct GSC_KeyExchangeInfo * kx_head
DLL head.
@ GNUNET_CORE_KX_ITERATION_FINISHED
This is not a state in a peer's state machine, but a special value used with the GNUNET_CORE_MonitorC...
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
void GNUNET_notification_context_add(struct GNUNET_NotificationContext *nc, struct GNUNET_MQ_Handle *mq)
Add a subscriber to the notification context.
Definition nc.c:161
#define GNUNET_MESSAGE_TYPE_CORE_MONITOR_NOTIFY
Reply for monitor by CORE service.
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition time.c:640
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
static struct GNUNET_MQ_Handle * mq
Our connection to the resolver service, created on-demand, but then persists until error or shutdown.
Information about the status of a key exchange with another peer.
struct GSC_KeyExchangeInfo * next
DLL.
struct GNUNET_PeerIdentity peer
Identity of the peer.
struct GNUNET_TIME_Absolute timeout
When should the session time out (if there are no Acks to HEARTBEATs)?
enum GNUNET_CORE_KxState status
What is our connection state?
Message sent by the service to monitor clients to notify them about a peer changing status.
Definition core.h:313
uint32_t state
New peer state, an enum GNUNET_CORE_KxState in NBO.
Definition core.h:322
struct GNUNET_TIME_AbsoluteNBO timeout
How long will we stay in this state (if nothing else happens)?
Definition core.h:332

References env, GNUNET_CORE_KX_ITERATION_FINISHED, GNUNET_MESSAGE_TYPE_CORE_MONITOR_NOTIFY, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_notification_context_add(), GNUNET_TIME_absolute_hton(), GNUNET_TIME_UNIT_FOREVER_ABS, kx_head, mq, msg, nc, GSC_KeyExchangeInfo::next, GSC_KeyExchangeInfo::peer, MonitorNotifyMessage::state, GSC_KeyExchangeInfo::status, MonitorNotifyMessage::timeout, and GSC_KeyExchangeInfo::timeout.

Referenced by handle_client_monitor_peers().

Here is the call graph for this function:
Here is the caller graph for this function: