basic crypto working (single client, fixed keys)

basic functionality is working.
encryption is done in Echo::send and decryption in worker::handleEchoData (virtual for client & server)
for the time keys are fixed and hardcoded.

key should be derived from passphrase (keystreching) and nonce is random generated on challenge request
and then increased (if 8byte char or 24 byte char is used is still to be decided)

Utility's rand function should use real rand (/dev/random) has to be adjusted for classes (mainly Auth)

nonce should be sent on challenge request (isConnectionRequest variable in echo)
change crypto algorithm to use 8byte nonce

use crypto_stream_salsa20_ref_xor so we need only 8bytes nonce (uint64_t)
use this to send nonce once when client authenticates and then increment with seq number

change all function calls to use uint64_t instead of char* for nonce
use fixed 0 as test nonce for now.
remove uneccessary include for nacl in client.h

include -lnacl in Makefile for now (this should be done in 'osflags')
send random nonce on connection request

random nonce is sent in connection request.(Appended to end of payload)
afterwards nonce should be increased by seqid. seqid and nonce must be
kept track of since icmp packets could arrive out of order

server.cpp major refactoring (mostly identation fixes)
crypto functions replaced with proper macros for interoperabillity
nonce and key moved to Client Data for multiclient usage
error in previous commit

a ' was accidently inserted and comited.
increase nonce with each message

nonce must be only used once.
We already send a random nonce on beginning of authentication.
on every packet received increase nonce to ensure it is used only once.

salsa20 cipher has a 8byte nonce which is enough when each nonce ist not chosen randomly,
so every time we receive or sent a packet we increase nonce.

TODO: to keep track of lost packets or out of order packets we keep a reference between
nonce and seq. therefore change echo sequence is enforced.
create encryption key from password

password is created from given passphrase now.

TODO: a simple keystrech algorithm is used. check for better options.
example: scrypt .. but we do not want to add a lot of dependencies.
evaluate keystrength possibilities. code should be easily changeable.
Auth::Auth() needs to be changed when better option is found
use nacl for hashing

remove sha1.cpp & sha1.h in favor of nacl library hash function.
add htonll for future endianess compatibility
slight refactor or server, echo and client (80 char limit)
fix endianess

endianess fixed. sha is transmitted & stored in unsigned char now.
endianess for nonce is fixed with htoll
compensate for packet loss in nonce counting

when a packet is lost the nonce counting would be out of order.
to compensate for this we store the last received seq.
when a packet is received we subtract stored seq from act seq and use
this value as nonce increment. (when no packet is lost this is 1)

also: use random as ICMP header ID and increment ICMP header SEQ on every echo.
(linux behaviour)
handle multiuser & multiuser nat

echo ID is used as client identifier. Since seq and ID is not encrypted
echo ID is chosen random on beginning and never changed. This is Linux behavior
which uses PID as ID and increases SEQ on every echo (as we do)

with this it should be possible to have multiple clients even behind nat