From 5101ef756a18baf5d7e794d15577fa73ef2a18fa Mon Sep 17 00:00:00 2001 From: Andrew Date: Sat, 20 Jul 2013 10:39:05 -0400 Subject: [PATCH] Fixed comments in other files as per request of jvrv --- core/net_crypto.c | 248 +++++++++++++++++++++++----------------------- core/net_crypto.h | 108 ++++++++++---------- core/network.c | 56 +++++------ core/network.h | 215 +++++++++++++++++++++++----------------- 4 files changed, 332 insertions(+), 295 deletions(-) diff --git a/core/net_crypto.c b/core/net_crypto.c index 62df614e..c819c8c4 100644 --- a/core/net_crypto.c +++ b/core/net_crypto.c @@ -28,23 +28,23 @@ #include "net_crypto.h" -//Our public and secret keys. +/* Our public and secret keys. */ uint8_t self_public_key[crypto_box_PUBLICKEYBYTES]; uint8_t self_secret_key[crypto_box_SECRETKEYBYTES]; typedef struct { - uint8_t public_key[crypto_box_PUBLICKEYBYTES];//the real public key of the peer. - uint8_t recv_nonce[crypto_box_NONCEBYTES];//nonce of received packets - uint8_t sent_nonce[crypto_box_NONCEBYTES];//nonce of sent packets. - uint8_t sessionpublic_key[crypto_box_PUBLICKEYBYTES];//our public key for this session. - uint8_t sessionsecret_key[crypto_box_SECRETKEYBYTES];//our private key for this session. - uint8_t peersessionpublic_key[crypto_box_PUBLICKEYBYTES];//The public key of the peer. - uint8_t status;//0 if no connection, 1 we have sent a handshake, 2 if connexion is not confirmed yet - //(we have received a handshake but no empty data packet), 3 if the connection is established. - //4 if the connection is timed out. - uint16_t number; //Lossless_UDP connection number corresponding to this connection. + uint8_t public_key[crypto_box_PUBLICKEYBYTES]; /* the real public key of the peer. */ + uint8_t recv_nonce[crypto_box_NONCEBYTES]; /* nonce of received packets */ + uint8_t sent_nonce[crypto_box_NONCEBYTES]; /* nonce of sent packets. */ + uint8_t sessionpublic_key[crypto_box_PUBLICKEYBYTES]; /* our public key for this session. */ + uint8_t sessionsecret_key[crypto_box_SECRETKEYBYTES];our private key for this session. + uint8_t peersessionpublic_key[crypto_box_PUBLICKEYBYTES]; /* The public key of the peer. */ + uint8_t status;/* 0 if no connection, 1 we have sent a handshake, 2 if connexion is not confirmed yet + (we have received a handshake but no empty data packet), 3 if the connection is established. + 4 if the connection is timed out. */ + uint16_t number; /* Lossless_UDP connection number corresponding to this connection. */ }Crypto_Connection; @@ -54,18 +54,18 @@ static Crypto_Connection crypto_connections[MAX_CRYPTO_CONNECTIONS]; #define MAX_FRIEND_REQUESTS 32 -//keeps track of the connection numbers for friends request so we can check later if they were sent +/* keeps track of the connection numbers for friends request so we can check later if they were sent */ static int outbound_friendrequests[MAX_FRIEND_REQUESTS]; #define MAX_INCOMING 64 -//keeps track of the connection numbers for friends request so we can check later if they were sent +/* keeps track of the connection numbers for friends request so we can check later if they were sent */ static int incoming_connections[MAX_INCOMING]; -//encrypts plain of length length to encrypted of length + 16 using the -//public key(32 bytes) of the receiver and the secret key of the sender and a 24 byte nonce -//return -1 if there was a problem. -//return length of encrypted data if everything was fine. +/* encrypts plain of length length to encrypted of length + 16 using the + public key(32 bytes) of the receiver and the secret key of the sender and a 24 byte nonce + return -1 if there was a problem. + return length of encrypted data if everything was fine. */ int encrypt_data(uint8_t * public_key, uint8_t * secret_key, uint8_t * nonce, uint8_t * plain, uint32_t length, uint8_t * encrypted) { @@ -78,24 +78,24 @@ int encrypt_data(uint8_t * public_key, uint8_t * secret_key, uint8_t * nonce, uint8_t temp_encrypted[MAX_DATA_SIZE + crypto_box_ZEROBYTES]; uint8_t zeroes[crypto_box_BOXZEROBYTES] = {0}; - memcpy(temp_plain + crypto_box_ZEROBYTES, plain, length);//pad the message with 32 0 bytes. + memcpy(temp_plain + crypto_box_ZEROBYTES, plain, length); /* pad the message with 32 0 bytes. */ crypto_box(temp_encrypted, temp_plain, length + crypto_box_ZEROBYTES, nonce, public_key, secret_key); - //if encryption is successful the first crypto_box_BOXZEROBYTES of the message will be zero + /* if encryption is successful the first crypto_box_BOXZEROBYTES of the message will be zero */ if(memcmp(temp_encrypted, zeroes, crypto_box_BOXZEROBYTES) != 0) { return -1; } - //unpad the encrypted message + /* unpad the encrypted message */ memcpy(encrypted, temp_encrypted + crypto_box_BOXZEROBYTES, length - crypto_box_BOXZEROBYTES + crypto_box_ZEROBYTES); return length - crypto_box_BOXZEROBYTES + crypto_box_ZEROBYTES; } -//decrypts encrypted of length length to plain of length length - 16 using the -//public key(32 bytes) of the sender, the secret key of the receiver and a 24 byte nonce -//return -1 if there was a problem(decryption failed) -//return length of plain data if everything was fine. +/* decrypts encrypted of length length to plain of length length - 16 using the + public key(32 bytes) of the sender, the secret key of the receiver and a 24 byte nonce + return -1 if there was a problem(decryption failed) + return length of plain data if everything was fine. */ int decrypt_data(uint8_t * public_key, uint8_t * secret_key, uint8_t * nonce, uint8_t * encrypted, uint32_t length, uint8_t * plain) { @@ -107,30 +107,30 @@ int decrypt_data(uint8_t * public_key, uint8_t * secret_key, uint8_t * nonce, uint8_t temp_encrypted[MAX_DATA_SIZE + crypto_box_ZEROBYTES] = {0}; uint8_t zeroes[crypto_box_ZEROBYTES] = {0}; - memcpy(temp_encrypted + crypto_box_BOXZEROBYTES, encrypted, length);//pad the message with 16 0 bytes. + memcpy(temp_encrypted + crypto_box_BOXZEROBYTES, encrypted, length); /* pad the message with 16 0 bytes. */ if(crypto_box_open(temp_plain, temp_encrypted, length + crypto_box_BOXZEROBYTES, nonce, public_key, secret_key) == -1) { return -1; } - //if decryption is successful the first crypto_box_ZEROBYTES of the message will be zero + /* if decryption is successful the first crypto_box_ZEROBYTES of the message will be zero */ if(memcmp(temp_plain, zeroes, crypto_box_ZEROBYTES) != 0) { return -1; } - //unpad the plain message + /* unpad the plain message */ memcpy(plain, temp_plain + crypto_box_ZEROBYTES, length - crypto_box_ZEROBYTES + crypto_box_BOXZEROBYTES); return length - crypto_box_ZEROBYTES + crypto_box_BOXZEROBYTES; } -//increment the given nonce by 1 +/* increment the given nonce by 1 */ void increment_nonce(uint8_t * nonce) { uint32_t i; - for(i = 0; i < crypto_box_NONCEBYTES; i++) + for(i = 0; i < crypto_box_NONCEBYTES; ++i) { - nonce[i]++; + ++nonce[i]; if(nonce[i] != 0) { break; @@ -138,20 +138,20 @@ void increment_nonce(uint8_t * nonce) } } -//fill the given nonce with random bytes. -//TODO: make this more optimized +/* fill the given nonce with random bytes. + TODO: make this more optimized */ void random_nonce(uint8_t * nonce) { uint32_t i; - for(i = 0; i < crypto_box_NONCEBYTES; i++) + for(i = 0; i < crypto_box_NONCEBYTES; ++i) { nonce[i] = random_int() % 256; } } -//return 0 if there is no received data in the buffer -//return -1 if the packet was discarded. -//return length of received data if successful +/* return 0 if there is no received data in the buffer + return -1 if the packet was discarded. + return length of received data if successful */ int read_cryptpacket(int crypt_connection_id, uint8_t * data) { if(crypt_connection_id < 0 || crypt_connection_id >= MAX_CRYPTO_CONNECTIONS) @@ -184,8 +184,8 @@ int read_cryptpacket(int crypt_connection_id, uint8_t * data) } -//return 0 if data could not be put in packet queue -//return 1 if data was put into the queue +/* return 0 if data could not be put in packet queue + return 1 if data was put into the queue */ int write_cryptpacket(int crypt_connection_id, uint8_t * data, uint32_t length) { if(crypt_connection_id < 0 || crypt_connection_id >= MAX_CRYPTO_CONNECTIONS) @@ -217,10 +217,10 @@ int write_cryptpacket(int crypt_connection_id, uint8_t * data, uint32_t length) return 1; } -//send a friend request to peer with public_key and ip_port. -//Data represents the data we send with the friends request. -//returns -1 on failure -//returns a positive friend request id that can be used later to see if it was sent correctly on success. +/* send a friend request to peer with public_key and ip_port. + Data represents the data we send with the friends request. + returns -1 on failure + returns a positive friend request id that can be used later to see if it was sent correctly on success. */ int send_friendrequest(uint8_t * public_key, IP_Port ip_port, uint8_t * data, uint32_t length) { if(length > MAX_DATA_SIZE - 1 - crypto_box_PUBLICKEYBYTES - crypto_box_NONCEBYTES) @@ -228,7 +228,7 @@ int send_friendrequest(uint8_t * public_key, IP_Port ip_port, uint8_t * data, ui return -1; } uint32_t i; - for(i = 0; i < MAX_FRIEND_REQUESTS; i++) + for(i = 0; i < MAX_FRIEND_REQUESTS; ++i) { if(outbound_friendrequests[i] == -1) { @@ -264,10 +264,10 @@ int send_friendrequest(uint8_t * public_key, IP_Port ip_port, uint8_t * data, ui return -1; } -//return -1 if failure -//return 0 if connection is still trying to send the request. -//return 1 if sent correctly -//return 2 if connection timed out +/* return -1 if failure + return 0 if connection is still trying to send the request. + return 1 if sent correctly + return 2 if connection timed out */ int check_friendrequest(int friend_request) { if(friend_request < 0 || friend_request > MAX_FRIEND_REQUESTS) @@ -299,9 +299,9 @@ int check_friendrequest(int friend_request) return 0; } -//Send a crypto handshake packet containing an encrypted secret nonce and session public key -//to peer with connection_id and public_key -//the packet is encrypted with a random nonce which is sent in plain text with the packet +/* Send a crypto handshake packet containing an encrypted secret nonce and session public key + to peer with connection_id and public_key + the packet is encrypted with a random nonce which is sent in plain text with the packet */ int send_cryptohandshake(int connection_id, uint8_t * public_key, uint8_t * secret_nonce, uint8_t * session_key) { uint8_t temp_data[MAX_DATA_SIZE]; @@ -324,9 +324,9 @@ int send_cryptohandshake(int connection_id, uint8_t * public_key, uint8_t * secr return write_packet(connection_id, temp_data, len + 1 + crypto_box_PUBLICKEYBYTES + crypto_box_NONCEBYTES); } -//Extract secret nonce, session public key and public_key from a packet(data) with length length -//return 1 if successful -//return 0 if failure +/* Extract secret nonce, session public key and public_key from a packet(data) with length length + return 1 if successful + return 0 if failure */ int handle_cryptohandshake(uint8_t * public_key, uint8_t * secret_nonce, uint8_t * session_key, uint8_t * data, uint16_t length) { @@ -359,13 +359,13 @@ int handle_cryptohandshake(uint8_t * public_key, uint8_t * secret_nonce, } -//puts the public key of the friend if public_key, the data from the request -//in data if a friend request was sent to us and returns the length of the data. -//return -1 if no valid friend requests. +/* puts the public key of the friend if public_key, the data from the request + in data if a friend request was sent to us and returns the length of the data. + return -1 if no valid friend requests. */ int handle_friendrequest(uint8_t * public_key, uint8_t * data) { uint32_t i; - for(i = 0; i < MAX_INCOMING; i++) + for(i = 0; i < MAX_INCOMING; ++i) { if(incoming_connections[i] != -1) { @@ -384,12 +384,12 @@ int handle_friendrequest(uint8_t * public_key, uint8_t * data) if(len1 != -1) { kill_connection(incoming_connections[i]); - //kill_connection_in(incoming_connections[i], 1); //conection is useless now, kill it in 1 seconds + /* kill_connection_in(incoming_connections[i], 1); //conection is useless now, kill it in 1 seconds */ incoming_connections[i] = -1; return len1; } } - kill_connection(incoming_connections[i]); //conection is useless now, kill it. + kill_connection(incoming_connections[i]); /* conection is useless now, kill it. */ incoming_connections[i] = -1; } } @@ -397,13 +397,13 @@ int handle_friendrequest(uint8_t * public_key, uint8_t * data) return -1; } -//get crypto connection id from public key of peer -//return -1 if there are no connections like we are looking for -//return id if it found it +/* get crypto connection id from public key of peer + return -1 if there are no connections like we are looking for + return id if it found it */ int getcryptconnection_id(uint8_t * public_key) { uint32_t i; - for(i = 0; i < MAX_CRYPTO_CONNECTIONS; i++) + for(i = 0; i < MAX_CRYPTO_CONNECTIONS; ++i) { if(crypto_connections[i].status > 0) { @@ -417,9 +417,9 @@ int getcryptconnection_id(uint8_t * public_key) } -//Start a secure connection with other peer who has public_key and ip_port -//returns -1 if failure -//returns crypt_connection_id of the initialized connection if everything went well. +/* Start a secure connection with other peer who has public_key and ip_port + returns -1 if failure + returns crypt_connection_id of the initialized connection if everything went well. */ int crypto_connect(uint8_t * public_key, IP_Port ip_port) { uint32_t i; @@ -432,7 +432,7 @@ int crypto_connect(uint8_t * public_key, IP_Port ip_port) return -1; } } - for(i = 0; i < MAX_CRYPTO_CONNECTIONS; i++) + for(i = 0; i < MAX_CRYPTO_CONNECTIONS; ++i) { if(crypto_connections[i].status == 0) { @@ -453,23 +453,23 @@ int crypto_connect(uint8_t * public_key, IP_Port ip_port) increment_nonce(crypto_connections[i].recv_nonce); return i; } - return -1;//this should never happen. + return -1; /* this should never happen. */ } } return -1; } -//handle an incoming connection -//return -1 if no crypto inbound connection -//return incoming connection id (Lossless_UDP one) if there is an incoming crypto connection -//Put the public key of the peer in public_key, the secret_nonce from the handshake into secret_nonce -//and the session public key for the connection in session_key -//to accept it see: accept_crypto_inbound(...) -//to refuse it just call kill_connection(...) on the connection id +/* handle an incoming connection + return -1 if no crypto inbound connection + return incoming connection id (Lossless_UDP one) if there is an incoming crypto connection + Put the public key of the peer in public_key, the secret_nonce from the handshake into secret_nonce + and the session public key for the connection in session_key + to accept it see: accept_crypto_inbound(...) + to refuse it just call kill_connection(...) on the connection id */ int crypto_inbound(uint8_t * public_key, uint8_t * secret_nonce, uint8_t * session_key) { uint32_t i; - for(i = 0; i < MAX_INCOMING; i++) + for(i = 0; i < MAX_INCOMING; ++i) { if(incoming_connections[i] != -1) { @@ -486,7 +486,7 @@ int crypto_inbound(uint8_t * public_key, uint8_t * secret_nonce, uint8_t * sessi if(handle_cryptohandshake(public_key, secret_nonce, session_key, temp_data, len)) { int connection_id = incoming_connections[i]; - incoming_connections[i] = -1;//remove this connection from the incoming connection list. + incoming_connections[i] = -1; /* remove this connection from the incoming connection list. */ return connection_id; } } @@ -495,9 +495,9 @@ int crypto_inbound(uint8_t * public_key, uint8_t * secret_nonce, uint8_t * sessi return -1; } -//kill a crypto connection -//return 0 if killed successfully -//return 1 if there was a problem. +/* kill a crypto connection + return 0 if killed successfully + return 1 if there was a problem. */ int crypto_kill(int crypt_connection_id) { if(crypt_connection_id < 0 || crypt_connection_id >= MAX_CRYPTO_CONNECTIONS) @@ -515,9 +515,9 @@ int crypto_kill(int crypt_connection_id) } -//accept an incoming connection using the parameters provided by crypto_inbound -//return -1 if not successful -//returns the crypt_connection_id if successful +/* accept an incoming connection using the parameters provided by crypto_inbound + return -1 if not successful + returns the crypt_connection_id if successful */ int accept_crypto_inbound(int connection_id, uint8_t * public_key, uint8_t * secret_nonce, uint8_t * session_key) { uint32_t i; @@ -530,7 +530,7 @@ int accept_crypto_inbound(int connection_id, uint8_t * public_key, uint8_t * sec { return -1; }*/ - for(i = 0; i < MAX_CRYPTO_CONNECTIONS; i++) + for(i = 0; i < MAX_CRYPTO_CONNECTIONS; ++i) { if(crypto_connections[i].status == 0) { @@ -549,20 +549,20 @@ int accept_crypto_inbound(int connection_id, uint8_t * public_key, uint8_t * sec { increment_nonce(crypto_connections[i].recv_nonce); uint32_t zero = 0; - crypto_connections[i].status = 3;//connection status needs to be 3 for write_cryptpacket() to work + crypto_connections[i].status = 3; /* connection status needs to be 3 for write_cryptpacket() to work */ write_cryptpacket(i, ((uint8_t *)&zero), sizeof(zero)); - crypto_connections[i].status = 2;//set it to its proper value right after. + crypto_connections[i].status = 2; /* set it to its proper value right after. */ return i; } - return -1;//this should never happen. + return -1; /* this should never happen. */ } } return -1; } -//return 0 if no connection, 1 we have sent a handshake, 2 if connexion is not confirmed yet -//(we have received a handshake but no empty data packet), 3 if the connection is established. -//4 if the connection is timed out and waiting to be killed +/* return 0 if no connection, 1 we have sent a handshake, 2 if connexion is not confirmed yet + (we have received a handshake but no empty data packet), 3 if the connection is established. + 4 if the connection is timed out and waiting to be killed */ int is_cryptoconnected(int crypt_connection_id) { if(crypt_connection_id >= 0 && crypt_connection_id < MAX_CRYPTO_CONNECTIONS) @@ -573,37 +573,37 @@ int is_cryptoconnected(int crypt_connection_id) } -//Generate our public and private keys -//Only call this function the first time the program starts. +/* Generate our public and private keys + Only call this function the first time the program starts. */ void new_keys() { crypto_box_keypair(self_public_key,self_secret_key); } -//save the public and private keys to the keys array -//Length must be crypto_box_PUBLICKEYBYTES + crypto_box_SECRETKEYBYTES +/* save the public and private keys to the keys array + Length must be crypto_box_PUBLICKEYBYTES + crypto_box_SECRETKEYBYTES */ void save_keys(uint8_t * keys) { memcpy(keys, self_public_key, crypto_box_PUBLICKEYBYTES); memcpy(keys + crypto_box_PUBLICKEYBYTES, self_secret_key, crypto_box_SECRETKEYBYTES); } -//load the public and private keys from the keys array -//Length must be crypto_box_PUBLICKEYBYTES + crypto_box_SECRETKEYBYTES +/* load the public and private keys from the keys array + Length must be crypto_box_PUBLICKEYBYTES + crypto_box_SECRETKEYBYTES */ void load_keys(uint8_t * keys) { memcpy(self_public_key, keys, crypto_box_PUBLICKEYBYTES); memcpy(self_secret_key, keys + crypto_box_PUBLICKEYBYTES, crypto_box_SECRETKEYBYTES); } -//TODO: optimize this -//adds an incoming connection to the incoming_connection list. -//returns 0 if successful -//returns 1 if failure +/* TODO: optimize this + adds an incoming connection to the incoming_connection list. + returns 0 if successful + returns 1 if failure */ int new_incoming(int id) { uint32_t i; - for(i = 0; i < MAX_INCOMING; i++) + for(i = 0; i < MAX_INCOMING; ++i) { if(incoming_connections[i] == -1) { @@ -614,8 +614,8 @@ int new_incoming(int id) return 1; } -//TODO: optimize this -//handle all new incoming connections. +/* TODO: optimize this + handle all new incoming connections. */ static void handle_incomings() { int income; @@ -629,11 +629,11 @@ static void handle_incomings() } } -//handle received packets for not yet established crypto connections. +/* handle received packets for not yet established crypto connections. */ static void receive_crypto() { uint32_t i; - for(i = 0; i < MAX_CRYPTO_CONNECTIONS; i++) + for(i = 0; i < MAX_CRYPTO_CONNECTIONS; ++i) { if(crypto_connections[i].status == 1) { @@ -643,12 +643,12 @@ static void receive_crypto() uint8_t session_key[crypto_box_PUBLICKEYBYTES]; uint16_t len; if(id_packet(crypto_connections[i].number) == 1) - //if the packet is a friend request drop it (because we are already friends) + /* if the packet is a friend request drop it (because we are already friends) */ { len = read_packet(crypto_connections[i].number, temp_data); } - if(id_packet(crypto_connections[i].number) == 2)//handle handshake packet. + if(id_packet(crypto_connections[i].number) == 2) /* handle handshake packet. */ { len = read_packet(crypto_connections[i].number, temp_data); if(handle_cryptohandshake(public_key, secret_nonce, session_key, temp_data, len)) @@ -659,16 +659,16 @@ static void receive_crypto() memcpy(crypto_connections[i].peersessionpublic_key, session_key, crypto_box_PUBLICKEYBYTES); increment_nonce(crypto_connections[i].sent_nonce); uint32_t zero = 0; - crypto_connections[i].status = 3;//connection status needs to be 3 for write_cryptpacket() to work + crypto_connections[i].status = 3; /* connection status needs to be 3 for write_cryptpacket() to work */ write_cryptpacket(i, ((uint8_t *)&zero), sizeof(zero)); - crypto_connections[i].status = 2;//set it to its proper value right after. + crypto_connections[i].status = 2; /* set it to its proper value right after. */ } } } else if(id_packet(crypto_connections[i].number) != -1) { - //This should not happen - //kill the connection if it does + /* This should not happen + kill the connection if it does */ crypto_kill(crypto_connections[i].number); } @@ -689,35 +689,35 @@ static void receive_crypto() increment_nonce(crypto_connections[i].recv_nonce); crypto_connections[i].status = 3; - //connection is accepted so we disable the auto kill by setting it to about 1 month from now. + /* connection is accepted so we disable the auto kill by setting it to about 1 month from now. */ kill_connection_in(crypto_connections[i].number, 3000000); } else { - //This should not happen - //kill the connection if it does + /* This should not happen + kill the connection if it does */ crypto_kill(crypto_connections[i].number); } } else if(id_packet(crypto_connections[i].number) != -1) { - //This should not happen - //kill the connection if it does + /* This should not happen + kill the connection if it does */ crypto_kill(crypto_connections[i].number); } } } } -//run this to (re)initialize net_crypto -//sets all the global connection variables to their default values. +/* run this to (re)initialize net_crypto + sets all the global connection variables to their default values. */ void initNetCrypto() { memset(crypto_connections, 0 ,sizeof(crypto_connections)); memset(outbound_friendrequests, -1 ,sizeof(outbound_friendrequests)); memset(incoming_connections, -1 ,sizeof(incoming_connections)); uint32_t i; - for(i = 0; i < MAX_CRYPTO_CONNECTIONS; i++) + for(i = 0; i < MAX_CRYPTO_CONNECTIONS; ++i) { crypto_connections[i].number = ~0; } @@ -726,7 +726,7 @@ void initNetCrypto() static void killTimedout() { uint32_t i; - for(i = 0; i < MAX_CRYPTO_CONNECTIONS; i++) + for(i = 0; i < MAX_CRYPTO_CONNECTIONS; ++i) { if(crypto_connections[i].status != 0 && is_connected(crypto_connections[i].number) == 4) { @@ -740,12 +740,12 @@ static void killTimedout() } } -//main loop +/* main loop */ void doNetCrypto() { - //TODO:check if friend requests were sent correctly - //handle new incoming connections - //handle friend requests + /* TODO:check if friend requests were sent correctly + handle new incoming connections + handle friend requests */ handle_incomings(); receive_crypto(); killTimedout(); diff --git a/core/net_crypto.h b/core/net_crypto.h index df2cb9ca..0bf21f60 100644 --- a/core/net_crypto.h +++ b/core/net_crypto.h @@ -26,111 +26,111 @@ #include "Lossless_UDP.h" -//Our public key. +/* Our public key. */ extern uint8_t self_public_key[crypto_box_PUBLICKEYBYTES]; extern uint8_t self_secret_key[crypto_box_SECRETKEYBYTES]; #define ENCRYPTION_PADDING (crypto_box_ZEROBYTES - crypto_box_BOXZEROBYTES) -//encrypts plain of length length to encrypted of length + 16 using the -//public key(32 bytes) of the receiver and the secret key of the sender and a 24 byte nonce -//return -1 if there was a problem. -//return length of encrypted data if everything was fine. +/* encrypts plain of length length to encrypted of length + 16 using the + public key(32 bytes) of the receiver and the secret key of the sender and a 24 byte nonce + return -1 if there was a problem. + return length of encrypted data if everything was fine. */ int encrypt_data(uint8_t * public_key, uint8_t * secret_key, uint8_t * nonce, uint8_t * plain, uint32_t length, uint8_t * encrypted); -//decrypts encrypted of length length to plain of length length - 16 using the -//public key(32 bytes) of the sender, the secret key of the receiver and a 24 byte nonce -//return -1 if there was a problem(decryption failed) -//return length of plain data if everything was fine. +/* decrypts encrypted of length length to plain of length length - 16 using the + public key(32 bytes) of the sender, the secret key of the receiver and a 24 byte nonce + return -1 if there was a problem(decryption failed) + return length of plain data if everything was fine. */ int decrypt_data(uint8_t * public_key, uint8_t * secret_key, uint8_t * nonce, uint8_t * encrypted, uint32_t length, uint8_t * plain); -//fill the given nonce with random bytes. +/* fill the given nonce with random bytes. */ void random_nonce(uint8_t * nonce); -//return 0 if there is no received data in the buffer -//return -1 if the packet was discarded. -//return length of received data if successful +/* return 0 if there is no received data in the buffer + return -1 if the packet was discarded. + return length of received data if successful */ int read_cryptpacket(int crypt_connection_id, uint8_t * data); -//return 0 if data could not be put in packet queue -//return 1 if data was put into the queue +/* return 0 if data could not be put in packet queue + return 1 if data was put into the queue */ int write_cryptpacket(int crypt_connection_id, uint8_t * data, uint32_t length); -//send a friend request to peer with public_key and ip_port. -//Data represents the data we send with the friends request. -//returns -1 on failure -//returns a positive friend request id that can be used later to see if it was sent correctly on success. +/* send a friend request to peer with public_key and ip_port. + Data represents the data we send with the friends request. + returns -1 on failure + returns a positive friend request id that can be used later to see if it was sent correctly on success. */ int send_friendrequest(uint8_t * public_key, IP_Port ip_port, uint8_t * data, uint32_t length); -//return -1 if failure -//return 0 if connection is still trying to send the request. -//return 1 if sent correctly -//return 2 if connection timed out +/* return -1 if failure + return 0 if connection is still trying to send the request. + return 1 if sent correctly + return 2 if connection timed out */ int check_friendrequest(int friend_request); -//puts the public key of the friend if public_key, the data from the request -//in data if a friend request was sent to us and returns the length of the data. -//return -1 if no valid friend requests. +/* puts the public key of the friend if public_key, the data from the request + in data if a friend request was sent to us and returns the length of the data. + return -1 if no valid friend requests. */ int handle_friendrequest(uint8_t * public_key, uint8_t * data); -//Start a secure connection with other peer who has public_key and ip_port -//returns -1 if failure -//returns crypt_connection_id of the initialized connection if everything went well. +/* Start a secure connection with other peer who has public_key and ip_port + returns -1 if failure + returns crypt_connection_id of the initialized connection if everything went well. */ int crypto_connect(uint8_t * public_key, IP_Port ip_port); -//kill a crypto connection -//return 0 if killed successfully -//return 1 if there was a problem. +/* kill a crypto connection + return 0 if killed successfully + return 1 if there was a problem. */ int crypto_kill(int crypt_connection_id); -//handle an incoming connection -//return -1 if no crypto inbound connection -//return incoming connection id (Lossless_UDP one) if there is an incoming crypto connection -//Put the public key of the peer in public_key, the secret_nonce from the handshake into secret_nonce -//and the session public key for the connection in session_key -//to accept it see: accept_crypto_inbound(...) -//to refuse it just call kill_connection(...) on the connection id +/* handle an incoming connection + return -1 if no crypto inbound connection + return incoming connection id (Lossless_UDP one) if there is an incoming crypto connection + Put the public key of the peer in public_key, the secret_nonce from the handshake into secret_nonce + and the session public key for the connection in session_key + to accept it see: accept_crypto_inbound(...) + to refuse it just call kill_connection(...) on the connection id */ int crypto_inbound(uint8_t * public_key, uint8_t * secret_nonce, uint8_t * session_key); -//accept an incoming connection using the parameters provided by crypto_inbound -//return -1 if not successful -//returns the crypt_connection_id if successful +/* accept an incoming connection using the parameters provided by crypto_inbound + return -1 if not successful + returns the crypt_connection_id if successful */ int accept_crypto_inbound(int connection_id, uint8_t * public_key, uint8_t * secret_nonce, uint8_t * session_key); -//return 0 if no connection, 1 we have sent a handshake, 2 if connexion is not confirmed yet -//(we have received a handshake but no empty data packet), 3 if the connection is established. -//4 if the connection is timed out and waiting to be killed +/* return 0 if no connection, 1 we have sent a handshake, 2 if connexion is not confirmed yet + (we have received a handshake but no empty data packet), 3 if the connection is established. + 4 if the connection is timed out and waiting to be killed */ int is_cryptoconnected(int crypt_connection_id); -//Generate our public and private keys -//Only call this function the first time the program starts. +/* Generate our public and private keys + Only call this function the first time the program starts. */ void new_keys(); -//save the public and private keys to the keys array -//Length must be crypto_box_PUBLICKEYBYTES + crypto_box_SECRETKEYBYTES +/* save the public and private keys to the keys array + Length must be crypto_box_PUBLICKEYBYTES + crypto_box_SECRETKEYBYTES */ void save_keys(uint8_t * keys); -//load the public and private keys from the keys array -//Length must be crypto_box_PUBLICKEYBYTES + crypto_box_SECRETKEYBYTES +/* load the public and private keys from the keys array + Length must be crypto_box_PUBLICKEYBYTES + crypto_box_SECRETKEYBYTES */ void load_keys(uint8_t * keys); -//run this to (re)initialize net_crypto -//sets all the global connection variables to their default values. +/* run this to (re)initialize net_crypto + sets all the global connection variables to their default values. */ void initNetCrypto(); -//main loop +/* main loop */ void doNetCrypto(); diff --git a/core/network.c b/core/network.c index c08b3512..dbe4574c 100644 --- a/core/network.c +++ b/core/network.c @@ -25,12 +25,12 @@ #include "network.h" -//returns current UNIX time in microseconds (us). +/* returns current UNIX time in microseconds (us). */ uint64_t current_time() { uint64_t time; #ifdef WIN32 - //This probably works fine + /* This probably works fine */ FILETIME ft; GetSystemTimeAsFileTime(&ft); time = ft.dwHighDateTime; @@ -48,8 +48,8 @@ uint64_t current_time() } -//return a random number -//NOTE: this function should probably not be used where cryptographic randomness is absolutely necessary +/* return a random number + NOTE: this function should probably not be used where cryptographic randomness is absolutely necessary */ uint32_t random_int() { #ifndef VANILLA_NACL @@ -60,11 +60,11 @@ uint32_t random_int() #endif } -//our UDP socket, a global variable. +/* our UDP socket, a global variable. */ static int sock; -//Basic network functions: -//Function to send packet(data) of length length to ip_port +/* Basic network functions: + Function to send packet(data) of length length to ip_port */ int sendpacket(IP_Port ip_port, uint8_t * data, uint32_t length) { ADDR addr = {AF_INET, ip_port.port, ip_port.ip}; @@ -72,10 +72,10 @@ int sendpacket(IP_Port ip_port, uint8_t * data, uint32_t length) } -//Function to receive data, ip and port of sender is put into ip_port -//the packet data into data -//the packet length into length. -//dump all empty packets. +/* Function to receive data, ip and port of sender is put into ip_port + the packet data into data + the packet length into length. + dump all empty packets. */ int receivepacket(IP_Port * ip_port, uint8_t * data, uint32_t * length) { ADDR addr; @@ -87,8 +87,8 @@ int receivepacket(IP_Port * ip_port, uint8_t * data, uint32_t * length) (*(int32_t *)length) = recvfrom(sock,(char *) data, MAX_UDP_PACKET_SIZE, 0, (struct sockaddr *)&addr, &addrlen); if(*(int32_t *)length <= 0) { - //nothing received - //or empty packet + /* nothing received + or empty packet */ return -1; } ip_port->ip = addr.ip; @@ -97,12 +97,12 @@ int receivepacket(IP_Port * ip_port, uint8_t * data, uint32_t * length) } -//initialize networking -//bind to ip and port -//ip must be in network order EX: 127.0.0.1 = (7F000001) -//port is in host byte order (this means don't worry about it) -//returns 0 if no problems -//TODO: add something to check if there are errors +/* initialize networking + bind to ip and port + ip must be in network order EX: 127.0.0.1 = (7F000001) + port is in host byte order (this means don't worry about it) + returns 0 if no problems + TODO: add something to check if there are errors */ int init_networking(IP ip ,uint16_t port) { #ifdef WIN32 @@ -117,11 +117,11 @@ int init_networking(IP ip ,uint16_t port) #endif srand((uint32_t)current_time()); - //initialize our socket + /* initialize our socket */ sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); - //Functions to increase the size of the send and receive UDP buffers - //NOTE: uncomment if necessary + /* Functions to increase the size of the send and receive UDP buffers + NOTE: uncomment if necessary */ /* int n = 1024 * 1024 * 2; if(setsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char*)&n, sizeof(n)) == -1) @@ -134,28 +134,28 @@ int init_networking(IP ip ,uint16_t port) return -1; }*/ - //Set socket nonblocking + /* Set socket nonblocking */ #ifdef WIN32 - //I think this works for windows + /* I think this works for windows */ u_long mode = 1; - //ioctl(sock, FIONBIO, &mode); + /* ioctl(sock, FIONBIO, &mode); */ ioctlsocket(sock, FIONBIO, &mode); #else fcntl(sock, F_SETFL, O_NONBLOCK, 1); #endif - //Bind our socket to port PORT and address 0.0.0.0 + /* Bind our socket to port PORT and address 0.0.0.0 */ ADDR addr = {AF_INET, htons(port), ip}; bind(sock, (struct sockaddr*)&addr, sizeof(addr)); return 0; } -//function to cleanup networking stuff +/* function to cleanup networking stuff */ void shutdown_networking() { #ifdef WIN32 WSACleanup(); #endif return; -} \ No newline at end of file +} diff --git a/core/network.h b/core/network.h index 33f11239..8f88940c 100644 --- a/core/network.h +++ b/core/network.h @@ -1,6 +1,6 @@ /* network.h * -* Datatypes, functions and includes for the core networking. +* Functions for the core networking. * Copyright (C) 2013 Tox project All Rights Reserved. @@ -21,104 +21,141 @@ along with Tox. If not, see . */ - -#ifndef NETWORK_H -#define NETWORK_H - -#include -#include -#include -#include -#include +#include "network.h" - -#ifdef WIN32 //Put win32 includes here - -#include -#include - -#undef VANILLA_NACL//make sure on windows we use libsodium - -#else //Linux includes - -#include -#include -#include -#include -#include - - -#endif - -#ifndef VANILLA_NACL -//we use libsodium by default -#include -#else - -//TODO: Including stuff like this is bad. This needs fixing. -//We keep support for the original NaCl for now. -#include "../nacl/build/Linux/include/amd64/crypto_box.h" - -#endif - - -#define MAX_UDP_PACKET_SIZE 65507 - -typedef union +/* returns current UNIX time in microseconds (us). */ +uint64_t current_time() { - uint8_t c[4]; - uint16_t s[2]; - uint32_t i; -}IP; - -typedef struct -{ - IP ip; - uint16_t port; - //not used for anything right now - uint16_t padding; -}IP_Port; - -typedef struct -{ - int16_t family; - uint16_t port; - IP ip; - uint8_t zeroes[8]; - #ifdef ENABLE_IPV6 - uint8_t zeroes2[12]; + uint64_t time; + #ifdef WIN32 + /* This probably works fine */ + FILETIME ft; + GetSystemTimeAsFileTime(&ft); + time = ft.dwHighDateTime; + time <<=32; + time |= ft.dwLowDateTime; + time -= 116444736000000000UL; + return time/10; + #else + struct timeval a; + gettimeofday(&a, NULL); + time = 1000000UL*a.tv_sec + a.tv_usec; + return time; #endif -}ADDR; + + +} +/* return a random number + NOTE: this function should probably not be used where cryptographic randomness is absolutely necessary */ +uint32_t random_int() +{ + #ifndef VANILLA_NACL + /* NOTE: this function comes from libsodium */ + return randombytes_random(); + #else + return random(); + #endif +} -//returns current time in milleseconds since the epoch. -uint64_t current_time(); +/* our UDP socket, a global variable. */ +static int sock; -//return a random number -//NOTE: this function should probably not be used where cryptographic randomness is absolutely necessary -uint32_t random_int(); +/* Basic network functions: + Function to send packet(data) of length length to ip_port */ +int sendpacket(IP_Port ip_port, uint8_t * data, uint32_t length) +{ + ADDR addr = {AF_INET, ip_port.port, ip_port.ip}; + return sendto(sock,(char *) data, length, 0, (struct sockaddr *)&addr, sizeof(addr)); + +} -//Basic network functions: +/* Function to receive data, ip and port of sender is put into ip_port + the packet data into data + the packet length into length. + dump all empty packets. */ +int receivepacket(IP_Port * ip_port, uint8_t * data, uint32_t * length) +{ + ADDR addr; + #ifdef WIN32 + int addrlen = sizeof(addr); + #else + uint32_t addrlen = sizeof(addr); + #endif + (*(int32_t *)length) = recvfrom(sock,(char *) data, MAX_UDP_PACKET_SIZE, 0, (struct sockaddr *)&addr, &addrlen); + if(*(int32_t *)length <= 0) + { + /* nothing received + or empty packet */ + return -1; + } + ip_port->ip = addr.ip; + ip_port->port = addr.port; + return 0; + +} -//Function to send packet(data) of length length to ip_port -int sendpacket(IP_Port ip_port, uint8_t * data, uint32_t length); +/* initialize networking + bind to ip and port + ip must be in network order EX: 127.0.0.1 = (7F000001) + port is in host byte order (this means don't worry about it) + returns 0 if no problems + TODO: add something to check if there are errors */ +int init_networking(IP ip ,uint16_t port) +{ + #ifdef WIN32 + WSADATA wsaData; + if(WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR) + { + return -1; + } + + #else + srandom((uint32_t)current_time()); + #endif + srand((uint32_t)current_time()); + + /* initialize our socket */ + sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); + + /* Functions to increase the size of the send and receive UDP buffers + NOTE: uncomment if necessary + + int n = 1024 * 1024 * 2; + if(setsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char*)&n, sizeof(n)) == -1) + { + return -1; + } -//Function to receive data, ip and port of sender is put into ip_port -//the packet data into data -//the packet length into length. -int receivepacket(IP_Port * ip_port, uint8_t * data, uint32_t * length); + if(setsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char*)&n, sizeof(n)) == -1) + { + return -1; + }*/ + + /*Set socket nonblocking */ + #ifdef WIN32 + /* I think this works for windows */ + u_long mode = 1; + /* ioctl(sock, FIONBIO, &mode); */ + ioctlsocket(sock, FIONBIO, &mode); + #else + fcntl(sock, F_SETFL, O_NONBLOCK, 1); + #endif + + /* Bind our socket to port PORT and address 0.0.0.0 */ + ADDR addr = {AF_INET, htons(port), ip}; + bind(sock, (struct sockaddr*)&addr, sizeof(addr)); + return 0; -//initialize networking -//bind to ip and port -//ip must be in network order EX: 127.0.0.1 = (7F000001) -//port is in host byte order (this means don't worry about it) -//returns 0 if no problems -//TODO: add something to check if there are errors -int init_networking(IP ip ,uint16_t port); +} - -//function to cleanup networking stuff(doesn't do much right now) -void shutdown_networking(); -#endif +/* function to cleanup networking stuff */ +void shutdown_networking() +{ + #ifdef WIN32 + WSACleanup(); + #endif + return; +}