mirror of
https://github.com/servalproject/serval-dna.git
synced 2024-12-19 05:07:56 +00:00
cbb1939241
Change overlay_frame payload to use an overlay_buffer structure for consistency and ease of payload construction. Added some sanity checking to peer score calculation. Getting closer to being able to TX acks to selfannouncements. Other little things to accomplish these.
269 lines
11 KiB
C
269 lines
11 KiB
C
#include "mphlr.h"
|
|
|
|
|
|
int packetOkOverlay(int interface,unsigned char *packet,int len,unsigned char *transaction_id,
|
|
struct sockaddr *recvaddr,int recvaddrlen,int parseP)
|
|
{
|
|
/*
|
|
Overlay packets are ensembles contain one or more frames each of which
|
|
should be handled separately.
|
|
|
|
There are two main types of enclosed frame.
|
|
|
|
1. Announcement frames which contain information that helps to maintain the
|
|
operation of the mesh.
|
|
|
|
and
|
|
|
|
2. Data frames that contain messages directed to nodes on the mesh.
|
|
|
|
In both instances we allow the contained addresses to be shortened to save bandwidth,
|
|
especially for low-bandwidth links.
|
|
|
|
All frames have the following fields:
|
|
|
|
Frame type (8-24bits)
|
|
TTL (8bits)
|
|
Remaining frame size (RFS) (see overlay_payload.c or overlay_buffer.c for explanation of format)
|
|
Next hop (variable length due to address abbreviation)
|
|
Destination (variable length due to address abbreviation)*
|
|
Source (variable length due to address abbreviation)*
|
|
Payload (length = RFS- len(frame type) - len(next hop)*
|
|
|
|
This structure is intended to allow relaying nodes to quickly ignore frames that are
|
|
not addressed to them as either the next hop or final destination.
|
|
|
|
The RFS field uses additional bytes to encode the length of longer frames.
|
|
This provides us with a slight space saving for the common case of short frames.
|
|
|
|
* Indicates fields that may be encrypted. The source and destination addresses can
|
|
be encrypted for paranoid traffic so that only the hops along the route know who is
|
|
talking to whom. This is not totally secure, but does prevent collateral eaves dropping
|
|
of frames by 4th parties. Paranoid communities could elect to only use nodes they trust
|
|
to carry the frame. And finally, the frame payload itself can be enciphered with the
|
|
final destination's public key, so that it is not possible even for the relaying 3rd
|
|
parties to observe the content.
|
|
|
|
Naturally some information will leak simply based on the size, periodicity and other
|
|
characteristics of the traffic, and some 3rd parties may be malevolent, so noone should
|
|
assume that this provides complete security.
|
|
|
|
Paranoid mode introduces a bandwidth cost of one signature, and a potentially substantial
|
|
energy cost of requiring every node along the delivery path to decrypt and reencrypt the
|
|
frame.
|
|
|
|
It would also be possible to design a super-paranoid mode where source routing is used with
|
|
concentric shells of encryption so that each hop can only work out the next hop to send it
|
|
to. However, that would result in rather large frames, and require an on-demand routing
|
|
approach which may well betray more information than the super-paranoid mode would hide.
|
|
|
|
Note also that it is possible to dispatch frames on a local link which are addressed to
|
|
broadcast, but are enciphered. In that situation only the intended recipient can
|
|
decode the frame, but at the cost of having all nodes on the local link having to decrypt
|
|
frame. Of course the nodes may elect to not decrypt such anonymous frames.
|
|
|
|
Such frames could even be flooded throughout part of the mesh by having the TTL>1, and
|
|
optionally with an anonymous source address to provide some plausible deniability for both
|
|
sending and reception if combined with a randomly selected TTL to give the impression of
|
|
the source having received the frame from elsewhere.
|
|
|
|
|
|
*/
|
|
|
|
int ofs;
|
|
overlay_frame f;
|
|
|
|
/* Skip magic bytes and version */
|
|
for(ofs=4;ofs<len;)
|
|
{
|
|
/* Clear out the data structure ready for next frame */
|
|
f.nexthop_address_status=OA_UNINITIALISED;
|
|
f.destination_address_status=OA_UNINITIALISED;
|
|
f.source_address_status=OA_UNINITIALISED;
|
|
|
|
/* Get normal form of packet type and modifiers */
|
|
f.type=packet[ofs]&OF_TYPE_BITS;
|
|
f.modifiers=packet[ofs]&OF_MODIFIER_BITS;
|
|
|
|
switch(packet[ofs]&OF_TYPE_BITS)
|
|
{
|
|
case OF_TYPE_EXTENDED20:
|
|
/* Eat the next two bytes and then skip over this reserved frame type */
|
|
f.type=OF_TYPE_FLAG_E20|(packet[ofs]&OF_MODIFIER_BITS)|(packet[ofs+2]<<12)|(packet[ofs+1]<<4);
|
|
f.modifiers=0;
|
|
ofs+=3;
|
|
break;
|
|
case OF_TYPE_EXTENDED12:
|
|
/* Eat the next byte and then skip over this reserved frame type */
|
|
f.type=OF_TYPE_FLAG_E12|(packet[ofs]&OF_MODIFIER_BITS)|(packet[ofs+1]<<4);
|
|
f.modifiers=0;
|
|
ofs+=2;
|
|
break;
|
|
case OF_TYPE_RESERVED_07:
|
|
case OF_TYPE_RESERVED_08:
|
|
case OF_TYPE_RESERVED_09:
|
|
case OF_TYPE_RESERVED_0a:
|
|
case OF_TYPE_RESERVED_0b:
|
|
case OF_TYPE_RESERVED_0c:
|
|
case OF_TYPE_RESERVED_0d:
|
|
case OF_TYPE_SELFANNOUNCE:
|
|
case OF_TYPE_SELFANNOUNCE_ACK:
|
|
case OF_TYPE_DATA:
|
|
case OF_TYPE_DATA_VOICE:
|
|
case OF_TYPE_RHIZOME_ADVERT:
|
|
case OF_TYPE_PLEASEEXPLAIN:
|
|
/* No extra bytes to deal with here */
|
|
ofs++;
|
|
break;
|
|
}
|
|
/* Get time to live */
|
|
f.ttl=packet[ofs++];
|
|
|
|
/* Decode length of remainder of frame */
|
|
f.rfs=rfs_decode(packet,&ofs);
|
|
|
|
if (!f.rfs) {
|
|
/* Zero length -- assume we fell off the end of the packet */
|
|
break;
|
|
}
|
|
|
|
/* Now extract the next hop address */
|
|
int alen=0;
|
|
int offset=ofs;
|
|
f.nexthop_address_status=overlay_abbreviate_expand_address(interface,packet,&offset,f.nexthop,&alen);
|
|
|
|
/* Now just make the rest of the frame available via the received frame structure, as the
|
|
frame may not be for us, so there is no point wasting time and energy if we don't have
|
|
to.
|
|
*/
|
|
f.bytes=&packet[offset];
|
|
f.bytecount=f.rfs-(offset-ofs);
|
|
|
|
/* Finally process the frame */
|
|
overlay_frame_process(interface,&f);
|
|
|
|
/* Skip the rest of the bytes in this frame so that we can examine the next one in this
|
|
ensemble */
|
|
if (debug&4) fprintf(stderr,"ofs=%d, f.rfs=%d, len=%d\n",ofs,f.rfs,len);
|
|
ofs+=f.rfs;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int overlay_frame_resolve_addresses(int interface,overlay_frame *f)
|
|
{
|
|
/* Get destination and source addresses and set pointers to payload appropriately */
|
|
int alen=0;
|
|
int offset=0;
|
|
|
|
overlay_abbreviate_set_most_recent_address(f->nexthop);
|
|
f->destination_address_status=overlay_abbreviate_expand_address(interface,f->bytes,&offset,f->destination,&alen);
|
|
alen=0;
|
|
f->source_address_status=overlay_abbreviate_expand_address(interface,f->bytes,&offset,f->source,&alen);
|
|
|
|
/* Copy payload into overlay_buffer structure */
|
|
if (f->bytecount-offset<0) return WHY("Abbreviated ddresses run past end of packet");
|
|
if (!f->payload) f->payload=ob_new(f->bytecount-offset); else f->payload->length=0;
|
|
if (!f->payload) return WHY("calloc(overlay_buffer) failed.");
|
|
if (ob_append_bytes(f->payload,&f->bytes[offset],f->bytecount-offset))
|
|
return WHY("ob_append_bytes() failed.");
|
|
|
|
return 0;
|
|
}
|
|
|
|
int overlay_add_selfannouncement(int interface,overlay_buffer *b)
|
|
{
|
|
/* Pull the first record from the HLR database and turn it into a
|
|
self-announcment. These are shorter than regular Subscriber Observation
|
|
Notices (SON) because they are just single-hop announcments of presence.
|
|
|
|
Do we really need to push the whole SID (32 bytes), or will just, say,
|
|
8 do so that we use a prefix of the SID which is still very hard to forge?
|
|
|
|
A hearer of a self-announcement who has not previously seen the sender might
|
|
like to get some authentication to prevent naughty people from spoofing routes.
|
|
|
|
We can do this by having ourselves, the sender, keep track of the last few frames
|
|
we have sent, so that we can be asked to sign them. Actually, we won't sign them,
|
|
as that is too slow/energy intensive, but we could use a D-H exchange with the neighbour,
|
|
performed once to get a shared secret that can be used to feed a stream cipher to
|
|
produce some sort of verification.
|
|
|
|
XXX - But this functionality really needs to move up a level to whole frame composition.
|
|
*/
|
|
|
|
unsigned char c;
|
|
unsigned char *sid=overlay_get_my_sid();
|
|
|
|
/* Header byte */
|
|
c=OF_TYPE_SELFANNOUNCE;
|
|
if (ob_append_bytes(b,&c,1))
|
|
return WHY("ob_append_bytes() could not add self-announcement header");
|
|
|
|
int send_prefix=(overlay_interfaces[interface].ticks_since_sent_full_address<4);
|
|
|
|
/* A TTL for this frame.
|
|
XXX - BATMAN uses various TTLs, but I think that it may just be better to have all TTL=1,
|
|
and have the onward nodes selectively choose which nodes to on-announce. If we prioritise
|
|
newly arrived nodes somewhat (or at least reserve some slots for them), then we can still
|
|
get the good news travels fast property of BATMAN, but without having to flood in the formal
|
|
sense. */
|
|
c=1;
|
|
if (ob_append_bytes(b,&c,1))
|
|
return WHY("ob_append_bytes() could not add TTL to self-announcement");
|
|
|
|
/* Add space for Remaining Frame Size field. This will always be a single byte
|
|
for self-announcments as they are always <256 bytes. */
|
|
c=1+1+(send_prefix?(1+7):SID_SIZE)+4+4;
|
|
if (ob_append_bytes(b,&c,1))
|
|
return WHY("ob_append_bytes() could not add RFS for self-announcement frame");
|
|
|
|
/* Add next-hop address. Always link-local broadcast for self-announcements */
|
|
c=OA_CODE_BROADCAST;
|
|
if (ob_append_bytes(b,&c,1))
|
|
return WHY("ob_append_bytes() could not add self-announcement header");
|
|
|
|
/* Add final destination. Always broadcast for self-announcments.
|
|
As we have just referenced the broadcast address, we can encode it in a single byte */
|
|
c=OA_CODE_PREVIOUS;
|
|
if (ob_append_bytes(b,&c,1))
|
|
return WHY("ob_append_bytes() could not add self-announcement header");
|
|
|
|
/* Add our SID to the announcement as sender
|
|
We can likely get away with abbreviating our own address much of the time, since these
|
|
frames will be sent on a regular basis. However, we can only abbreviate using a prefix,
|
|
not any of the fancier methods. Indeed, if we tried to use the standard abbreviation
|
|
functions they would notice that we are attaching an address which is ourself, and send
|
|
a uselessly short address. So instead we will use a simple scheme where we will send our
|
|
address in full an arbitrary 1 in 4 times.
|
|
*/
|
|
if (overlay_interfaces[interface].ticks_since_sent_full_address>3)
|
|
{ if (ob_append_bytes(b,sid,SID_SIZE)) return WHY("Could not append SID to self-announcement");
|
|
overlay_interfaces[interface].ticks_since_sent_full_address=0;
|
|
}
|
|
else
|
|
{
|
|
c=OA_CODE_PREFIX7;
|
|
if (ob_append_bytes(b,&c,1)) return WHY("ob_append_bytes() could not add address format code.");
|
|
if (ob_append_bytes(b,sid,7)) return WHY("Could not append SID prefix to self-announcement");
|
|
overlay_interfaces[interface].ticks_since_sent_full_address++;
|
|
}
|
|
|
|
/* Sequence number range. Based on one tick per milli-second. */
|
|
overlay_update_sequence_number();
|
|
if (ob_append_int(b,overlay_interfaces[interface].last_tick_ms))
|
|
return WHY("ob_append_int() could not add low sequence number to self-announcement");
|
|
if (ob_append_int(b,overlay_sequence_number))
|
|
return WHY("ob_append_int() could not add high sequence number to self-announcement");
|
|
overlay_interfaces[interface].last_tick_ms=overlay_sequence_number;
|
|
|
|
/* A byte that indicates which interface we are sending over */
|
|
if (ob_append_byte(b,interface))
|
|
return WHY("ob_append_int() could not add interface number to self-announcement");
|
|
|
|
return 0;
|
|
}
|
|
|
|
|