2013-07-04 20:56:19 +00:00
|
|
|
/*
|
|
|
|
* ZeroTier One - Global Peer to Peer Ethernet
|
2014-02-16 20:40:22 +00:00
|
|
|
* Copyright (C) 2011-2014 ZeroTier Networks LLC
|
2013-07-04 20:56:19 +00:00
|
|
|
*
|
|
|
|
* This program is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*
|
|
|
|
* --
|
|
|
|
*
|
|
|
|
* ZeroTier may be used and distributed under the terms of the GPLv3, which
|
|
|
|
* are available at: http://www.gnu.org/licenses/gpl-3.0.html
|
|
|
|
*
|
|
|
|
* If you would like to embed ZeroTier into a commercial application or
|
|
|
|
* redistribute it in a modified binary form, please contact ZeroTier Networks
|
|
|
|
* LLC. Start here: http://www.zerotier.com/
|
|
|
|
*/
|
|
|
|
|
2013-12-07 00:49:20 +00:00
|
|
|
#ifndef ZT_N_PACKET_HPP
|
|
|
|
#define ZT_N_PACKET_HPP
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <stdio.h>
|
2013-09-17 19:53:59 +00:00
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
#include <string>
|
|
|
|
#include <iostream>
|
|
|
|
|
2014-10-29 00:25:34 +00:00
|
|
|
#include "Constants.hpp"
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
#include "Address.hpp"
|
2013-09-16 17:02:10 +00:00
|
|
|
#include "Poly1305.hpp"
|
2013-07-04 20:56:19 +00:00
|
|
|
#include "Salsa20.hpp"
|
|
|
|
#include "Utils.hpp"
|
|
|
|
#include "Buffer.hpp"
|
|
|
|
|
|
|
|
#include "../ext/lz4/lz4.h"
|
|
|
|
|
|
|
|
/**
|
2013-09-20 17:36:14 +00:00
|
|
|
* Protocol version -- incremented only for MAJOR changes
|
2013-07-11 02:58:43 +00:00
|
|
|
*
|
|
|
|
* 1 - 0.2.0 ... 0.2.5
|
2013-09-20 17:36:14 +00:00
|
|
|
* 2 - 0.3.0 ... 0.4.5
|
2013-07-11 02:58:43 +00:00
|
|
|
* * Added signature and originating peer to multicast frame
|
|
|
|
* * Double size of multicast frame bloom filter
|
2013-10-05 14:19:12 +00:00
|
|
|
* 3 - 0.5.0 ... 0.6.0
|
2013-09-20 17:36:14 +00:00
|
|
|
* * Yet another multicast redesign
|
|
|
|
* * New crypto completely changes key agreement cipher
|
2015-01-05 19:47:22 +00:00
|
|
|
* 4 - 0.6.0 ... CURRENT
|
2013-10-05 14:19:12 +00:00
|
|
|
* * New identity format based on hashcash design
|
2013-10-16 21:47:26 +00:00
|
|
|
*
|
|
|
|
* This isn't going to change again for a long time unless your
|
|
|
|
* author wakes up again at 4am with another great idea. :P
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
2013-10-05 14:19:12 +00:00
|
|
|
#define ZT_PROTO_VERSION 4
|
2013-07-04 20:56:19 +00:00
|
|
|
|
2014-09-30 23:28:25 +00:00
|
|
|
/**
|
|
|
|
* Minimum supported protocol version
|
|
|
|
*/
|
|
|
|
#define ZT_PROTO_VERSION_MIN 4
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
/**
|
|
|
|
* Maximum hop count allowed by packet structure (3 bits, 0-7)
|
|
|
|
*
|
|
|
|
* This is not necessarily the maximum hop counter after which
|
|
|
|
* relaying is no longer performed.
|
|
|
|
*/
|
|
|
|
#define ZT_PROTO_MAX_HOPS 7
|
|
|
|
|
2014-10-02 17:54:34 +00:00
|
|
|
/**
|
|
|
|
* Cipher suite: Curve25519/Poly1305/Salsa20/12 without payload encryption
|
|
|
|
*
|
|
|
|
* This specifies Poly1305 MAC using a 32-bit key derived from the first
|
|
|
|
* 32 bytes of a Salsa20/12 keystream as in the Salsa20/12 cipher suite,
|
|
|
|
* but the payload is not encrypted. This is currently only used to send
|
|
|
|
* HELLO since that's the public key specification packet and must be
|
|
|
|
* sent in the clear. Key agreement is performed using Curve25519 elliptic
|
|
|
|
* curve Diffie-Hellman.
|
|
|
|
*/
|
2014-10-02 18:13:53 +00:00
|
|
|
#define ZT_PROTO_CIPHER_SUITE__C25519_POLY1305_NONE 0
|
2014-10-02 17:54:34 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Cipher suite: Curve25519/Poly1305/Salsa20/12
|
|
|
|
*
|
|
|
|
* This specifies Poly1305 using the first 32 bytes of a Salsa20/12 key
|
|
|
|
* stream as its one-time-use key followed by payload encryption with
|
|
|
|
* the remaining Salsa20/12 key stream. Key agreement is performed using
|
|
|
|
* Curve25519 elliptic curve Diffie-Hellman.
|
|
|
|
*/
|
2014-10-02 18:13:53 +00:00
|
|
|
#define ZT_PROTO_CIPHER_SUITE__C25519_POLY1305_SALSA2012 1
|
2014-10-02 17:54:34 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Cipher suite: Curve25519/AES256-GCM
|
|
|
|
*
|
|
|
|
* This specifies AES256 in GCM mode using GCM's built-in authentication
|
|
|
|
* with Curve25519 elliptic curve Diffie-Hellman.
|
|
|
|
*
|
|
|
|
* (Not implemented yet in client but reserved for future use.)
|
|
|
|
*/
|
2014-10-02 18:13:53 +00:00
|
|
|
#define ZT_PROTO_CIPHER_SUITE__C25519_AES256_GCM 2
|
2014-10-02 17:54:34 +00:00
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
/**
|
|
|
|
* Header flag indicating that a packet is fragmented
|
|
|
|
*
|
|
|
|
* If this flag is set, the receiver knows to expect more than one fragment.
|
|
|
|
* See Packet::Fragment for details.
|
|
|
|
*/
|
|
|
|
#define ZT_PROTO_FLAG_FRAGMENTED 0x40
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Verb flag indicating payload is compressed with LZ4
|
|
|
|
*/
|
|
|
|
#define ZT_PROTO_VERB_FLAG_COMPRESSED 0x80
|
|
|
|
|
2013-10-18 21:39:48 +00:00
|
|
|
/**
|
|
|
|
* Rounds used for Salsa20 encryption in ZT
|
|
|
|
*/
|
|
|
|
#define ZT_PROTO_SALSA20_ROUNDS 12
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
// Indices of fields in normal packet header -- do not change as this
|
|
|
|
// might require both code rework and will break compatibility.
|
|
|
|
#define ZT_PACKET_IDX_IV 0
|
|
|
|
#define ZT_PACKET_IDX_DEST 8
|
|
|
|
#define ZT_PACKET_IDX_SOURCE 13
|
|
|
|
#define ZT_PACKET_IDX_FLAGS 18
|
2013-09-16 17:02:10 +00:00
|
|
|
#define ZT_PACKET_IDX_MAC 19
|
2013-07-04 20:56:19 +00:00
|
|
|
#define ZT_PACKET_IDX_VERB 27
|
|
|
|
#define ZT_PACKET_IDX_PAYLOAD 28
|
|
|
|
|
|
|
|
/**
|
2013-09-26 21:45:19 +00:00
|
|
|
* Packet buffer size (can be changed)
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
2013-09-26 21:45:19 +00:00
|
|
|
#define ZT_PROTO_MAX_PACKET_LENGTH (ZT_MAX_PACKET_FRAGMENTS * ZT_UDP_DEFAULT_PAYLOAD_MTU)
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Minimum viable packet length (also length of header)
|
|
|
|
*/
|
|
|
|
#define ZT_PROTO_MIN_PACKET_LENGTH ZT_PACKET_IDX_PAYLOAD
|
|
|
|
|
|
|
|
// Indexes of fields in fragment header -- also can't be changed without
|
|
|
|
// breaking compatibility.
|
|
|
|
#define ZT_PACKET_FRAGMENT_IDX_PACKET_ID 0
|
|
|
|
#define ZT_PACKET_FRAGMENT_IDX_DEST 8
|
|
|
|
#define ZT_PACKET_FRAGMENT_IDX_FRAGMENT_INDICATOR 13
|
|
|
|
#define ZT_PACKET_FRAGMENT_IDX_FRAGMENT_NO 14
|
|
|
|
#define ZT_PACKET_FRAGMENT_IDX_HOPS 15
|
|
|
|
#define ZT_PACKET_FRAGMENT_IDX_PAYLOAD 16
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Value found at ZT_PACKET_FRAGMENT_IDX_FRAGMENT_INDICATOR in fragments
|
|
|
|
*/
|
|
|
|
#define ZT_PACKET_FRAGMENT_INDICATOR ZT_ADDRESS_RESERVED_PREFIX
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Minimum viable fragment length
|
|
|
|
*/
|
|
|
|
#define ZT_PROTO_MIN_FRAGMENT_LENGTH ZT_PACKET_FRAGMENT_IDX_PAYLOAD
|
|
|
|
|
2014-04-10 23:30:15 +00:00
|
|
|
/**
|
|
|
|
* Length of LAN beacon packets
|
|
|
|
*/
|
|
|
|
#define ZT_PROTO_BEACON_LENGTH 13
|
|
|
|
|
2014-10-02 17:54:34 +00:00
|
|
|
/**
|
|
|
|
* Index of address in a LAN beacon
|
|
|
|
*/
|
|
|
|
#define ZT_PROTO_BEACON_IDX_ADDRESS 8
|
2013-07-04 20:56:19 +00:00
|
|
|
|
2013-08-03 16:53:46 +00:00
|
|
|
// Field incides for parsing verbs -------------------------------------------
|
2013-08-02 21:17:34 +00:00
|
|
|
|
2014-09-26 21:18:25 +00:00
|
|
|
// Some verbs have variable-length fields. Those aren't fully defined here
|
|
|
|
// yet-- instead they are parsed using relative indexes in IncomingPacket.
|
|
|
|
// See their respective handler functions.
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
#define ZT_PROTO_VERB_HELLO_IDX_PROTOCOL_VERSION (ZT_PACKET_IDX_PAYLOAD)
|
|
|
|
#define ZT_PROTO_VERB_HELLO_IDX_MAJOR_VERSION (ZT_PROTO_VERB_HELLO_IDX_PROTOCOL_VERSION + 1)
|
|
|
|
#define ZT_PROTO_VERB_HELLO_IDX_MINOR_VERSION (ZT_PROTO_VERB_HELLO_IDX_MAJOR_VERSION + 1)
|
|
|
|
#define ZT_PROTO_VERB_HELLO_IDX_REVISION (ZT_PROTO_VERB_HELLO_IDX_MINOR_VERSION + 1)
|
|
|
|
#define ZT_PROTO_VERB_HELLO_IDX_TIMESTAMP (ZT_PROTO_VERB_HELLO_IDX_REVISION + 2)
|
|
|
|
#define ZT_PROTO_VERB_HELLO_IDX_IDENTITY (ZT_PROTO_VERB_HELLO_IDX_TIMESTAMP + 8)
|
2013-08-02 21:17:34 +00:00
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
#define ZT_PROTO_VERB_ERROR_IDX_IN_RE_VERB (ZT_PACKET_IDX_PAYLOAD)
|
|
|
|
#define ZT_PROTO_VERB_ERROR_IDX_IN_RE_PACKET_ID (ZT_PROTO_VERB_ERROR_IDX_IN_RE_VERB + 1)
|
|
|
|
#define ZT_PROTO_VERB_ERROR_IDX_ERROR_CODE (ZT_PROTO_VERB_ERROR_IDX_IN_RE_PACKET_ID + 8)
|
|
|
|
#define ZT_PROTO_VERB_ERROR_IDX_PAYLOAD (ZT_PROTO_VERB_ERROR_IDX_ERROR_CODE + 1)
|
2013-08-02 21:17:34 +00:00
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
#define ZT_PROTO_VERB_OK_IDX_IN_RE_VERB (ZT_PACKET_IDX_PAYLOAD)
|
|
|
|
#define ZT_PROTO_VERB_OK_IDX_IN_RE_PACKET_ID (ZT_PROTO_VERB_OK_IDX_IN_RE_VERB + 1)
|
|
|
|
#define ZT_PROTO_VERB_OK_IDX_PAYLOAD (ZT_PROTO_VERB_OK_IDX_IN_RE_PACKET_ID + 8)
|
2013-08-02 21:17:34 +00:00
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
#define ZT_PROTO_VERB_WHOIS_IDX_ZTADDRESS (ZT_PACKET_IDX_PAYLOAD)
|
2013-08-02 21:17:34 +00:00
|
|
|
|
2013-10-17 10:41:52 +00:00
|
|
|
#define ZT_PROTO_VERB_RENDEZVOUS_IDX_FLAGS (ZT_PACKET_IDX_PAYLOAD)
|
|
|
|
#define ZT_PROTO_VERB_RENDEZVOUS_IDX_ZTADDRESS (ZT_PROTO_VERB_RENDEZVOUS_IDX_FLAGS + 1)
|
2013-07-04 20:56:19 +00:00
|
|
|
#define ZT_PROTO_VERB_RENDEZVOUS_IDX_PORT (ZT_PROTO_VERB_RENDEZVOUS_IDX_ZTADDRESS + 5)
|
|
|
|
#define ZT_PROTO_VERB_RENDEZVOUS_IDX_ADDRLEN (ZT_PROTO_VERB_RENDEZVOUS_IDX_PORT + 2)
|
|
|
|
#define ZT_PROTO_VERB_RENDEZVOUS_IDX_ADDRESS (ZT_PROTO_VERB_RENDEZVOUS_IDX_ADDRLEN + 1)
|
2013-08-02 21:17:34 +00:00
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
#define ZT_PROTO_VERB_FRAME_IDX_NETWORK_ID (ZT_PACKET_IDX_PAYLOAD)
|
|
|
|
#define ZT_PROTO_VERB_FRAME_IDX_ETHERTYPE (ZT_PROTO_VERB_FRAME_IDX_NETWORK_ID + 8)
|
|
|
|
#define ZT_PROTO_VERB_FRAME_IDX_PAYLOAD (ZT_PROTO_VERB_FRAME_IDX_ETHERTYPE + 2)
|
2013-08-02 21:17:34 +00:00
|
|
|
|
2014-06-11 04:41:34 +00:00
|
|
|
#define ZT_PROTO_VERB_EXT_FRAME_IDX_NETWORK_ID (ZT_PACKET_IDX_PAYLOAD)
|
|
|
|
#define ZT_PROTO_VERB_EXT_FRAME_LEN_NETWORK_ID 8
|
2014-06-12 18:40:30 +00:00
|
|
|
#define ZT_PROTO_VERB_EXT_FRAME_IDX_FLAGS (ZT_PROTO_VERB_EXT_FRAME_IDX_NETWORK_ID + ZT_PROTO_VERB_EXT_FRAME_LEN_NETWORK_ID)
|
|
|
|
#define ZT_PROTO_VERB_EXT_FRAME_LEN_FLAGS 1
|
2014-09-30 23:28:25 +00:00
|
|
|
#define ZT_PROTO_VERB_EXT_FRAME_IDX_COM (ZT_PROTO_VERB_EXT_FRAME_IDX_FLAGS + ZT_PROTO_VERB_EXT_FRAME_LEN_FLAGS)
|
2014-06-12 18:40:30 +00:00
|
|
|
#define ZT_PROTO_VERB_EXT_FRAME_IDX_TO (ZT_PROTO_VERB_EXT_FRAME_IDX_FLAGS + ZT_PROTO_VERB_EXT_FRAME_LEN_FLAGS)
|
2014-06-11 04:41:34 +00:00
|
|
|
#define ZT_PROTO_VERB_EXT_FRAME_LEN_TO 6
|
|
|
|
#define ZT_PROTO_VERB_EXT_FRAME_IDX_FROM (ZT_PROTO_VERB_EXT_FRAME_IDX_TO + ZT_PROTO_VERB_EXT_FRAME_LEN_TO)
|
|
|
|
#define ZT_PROTO_VERB_EXT_FRAME_LEN_FROM 6
|
|
|
|
#define ZT_PROTO_VERB_EXT_FRAME_IDX_ETHERTYPE (ZT_PROTO_VERB_EXT_FRAME_IDX_FROM + ZT_PROTO_VERB_EXT_FRAME_LEN_FROM)
|
|
|
|
#define ZT_PROTO_VERB_EXT_FRAME_LEN_ETHERTYPE 2
|
2014-06-21 16:25:10 +00:00
|
|
|
#define ZT_PROTO_VERB_EXT_FRAME_IDX_PAYLOAD (ZT_PROTO_VERB_EXT_FRAME_IDX_ETHERTYPE + ZT_PROTO_VERB_EXT_FRAME_LEN_ETHERTYPE)
|
2014-06-11 04:41:34 +00:00
|
|
|
|
2014-09-26 21:18:25 +00:00
|
|
|
// P5_MULTICAST_FRAME is deprecated
|
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_PROPAGATION_DEPTH (ZT_PACKET_IDX_PAYLOAD)
|
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_PROPAGATION_DEPTH 2
|
2014-10-06 20:16:16 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_PROPAGATION_FIFO (ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_PROPAGATION_DEPTH + ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_PROPAGATION_DEPTH)
|
2014-09-26 21:18:25 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_PROPAGATION_FIFO 320
|
2014-10-06 20:16:16 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_PROPAGATION_BLOOM (ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_PROPAGATION_FIFO + ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_PROPAGATION_FIFO)
|
2014-09-26 21:18:25 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_PROPAGATION_BLOOM 1024
|
2014-10-06 20:16:16 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_FLAGS (ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_PROPAGATION_BLOOM + ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_PROPAGATION_BLOOM)
|
2014-09-26 21:18:25 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_FLAGS 1
|
2014-10-06 20:16:16 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX__START_OF_SIGNED_PORTION (ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_FLAGS)
|
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_NETWORK_ID (ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_FLAGS + ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_FLAGS)
|
2014-09-26 21:18:25 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_NETWORK_ID 8
|
2014-10-06 20:16:16 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_PROPAGATION_BLOOM_NONCE (ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_NETWORK_ID + ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_NETWORK_ID)
|
2014-09-26 21:18:25 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_PROPAGATION_BLOOM_NONCE 2
|
2014-10-06 20:16:16 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_PROPAGATION_PREFIX_BITS (ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_PROPAGATION_BLOOM_NONCE + ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_PROPAGATION_BLOOM_NONCE)
|
2014-09-26 21:18:25 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_PROPAGATION_PREFIX_BITS 1
|
2014-10-06 20:16:16 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_PROPAGATION_PREFIX (ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_PROPAGATION_PREFIX_BITS + ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_PROPAGATION_PREFIX_BITS)
|
2014-09-26 21:18:25 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_PROPAGATION_PREFIX 1
|
2014-10-06 20:16:16 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_ORIGIN (ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_PROPAGATION_PREFIX + ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_PROPAGATION_PREFIX)
|
2014-09-26 21:18:25 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_ORIGIN 5
|
2014-10-06 20:16:16 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_ORIGIN_MCID (ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_ORIGIN + ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_ORIGIN)
|
2014-09-26 21:18:25 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_ORIGIN_MCID 3
|
2014-10-06 20:16:16 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_GUID (ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_ORIGIN)
|
2014-09-26 21:18:25 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_GUID 8
|
2014-10-06 20:16:16 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_SOURCE_MAC (ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_ORIGIN_MCID + ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_ORIGIN_MCID)
|
2014-09-26 21:18:25 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_SOURCE_MAC 6
|
2014-10-06 20:16:16 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_DEST_MAC (ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_SOURCE_MAC + ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_SOURCE_MAC)
|
2014-09-26 21:18:25 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_DEST_MAC 6
|
2014-10-06 20:16:16 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_DEST_ADI (ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_DEST_MAC + ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_DEST_MAC)
|
2014-09-26 21:18:25 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_DEST_ADI 4
|
2014-10-06 20:16:16 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_ETHERTYPE (ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_DEST_ADI + ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_DEST_ADI)
|
2014-09-26 21:18:25 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_ETHERTYPE 2
|
2014-10-06 20:16:16 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_FRAME_LEN (ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_ETHERTYPE + ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_ETHERTYPE)
|
2014-09-26 21:18:25 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_FRAME_LEN 2
|
2014-10-06 20:16:16 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_FRAME (ZT_PROTO_VERB_P5_MULTICAST_FRAME_IDX_FRAME_LEN + ZT_PROTO_VERB_P5_MULTICAST_FRAME_LEN_FRAME_LEN)
|
2014-09-30 23:28:25 +00:00
|
|
|
#define ZT_PROTO_VERB_P5_MULTICAST_FRAME_FLAGS_HAS_MEMBERSHIP_CERTIFICATE 0x01
|
2013-10-25 18:51:55 +00:00
|
|
|
|
2013-08-02 21:17:34 +00:00
|
|
|
#define ZT_PROTO_VERB_NETWORK_CONFIG_REQUEST_IDX_NETWORK_ID (ZT_PACKET_IDX_PAYLOAD)
|
|
|
|
#define ZT_PROTO_VERB_NETWORK_CONFIG_REQUEST_IDX_DICT_LEN (ZT_PROTO_VERB_NETWORK_CONFIG_REQUEST_IDX_NETWORK_ID + 8)
|
|
|
|
#define ZT_PROTO_VERB_NETWORK_CONFIG_REQUEST_IDX_DICT (ZT_PROTO_VERB_NETWORK_CONFIG_REQUEST_IDX_DICT_LEN + 2)
|
|
|
|
|
2014-09-26 21:18:25 +00:00
|
|
|
#define ZT_PROTO_VERB_MULTICAST_GATHER_IDX_NETWORK_ID (ZT_PACKET_IDX_PAYLOAD)
|
|
|
|
#define ZT_PROTO_VERB_MULTICAST_GATHER_IDX_FLAGS (ZT_PROTO_VERB_MULTICAST_GATHER_IDX_NETWORK_ID + 8)
|
|
|
|
#define ZT_PROTO_VERB_MULTICAST_GATHER_IDX_MAC (ZT_PROTO_VERB_MULTICAST_GATHER_IDX_FLAGS + 1)
|
|
|
|
#define ZT_PROTO_VERB_MULTICAST_GATHER_IDX_ADI (ZT_PROTO_VERB_MULTICAST_GATHER_IDX_MAC + 6)
|
|
|
|
#define ZT_PROTO_VERB_MULTICAST_GATHER_IDX_GATHER_LIMIT (ZT_PROTO_VERB_MULTICAST_GATHER_IDX_ADI + 4)
|
|
|
|
|
2014-10-09 19:42:25 +00:00
|
|
|
// Note: COM, GATHER_LIMIT, and SOURCE_MAC are optional, and so are specified without size
|
|
|
|
#define ZT_PROTO_VERB_MULTICAST_FRAME_IDX_NETWORK_ID (ZT_PACKET_IDX_PAYLOAD)
|
2014-09-26 21:18:25 +00:00
|
|
|
#define ZT_PROTO_VERB_MULTICAST_FRAME_IDX_FLAGS (ZT_PROTO_VERB_MULTICAST_FRAME_IDX_NETWORK_ID + 8)
|
2014-10-09 19:42:25 +00:00
|
|
|
#define ZT_PROTO_VERB_MULTICAST_FRAME_IDX_COM (ZT_PROTO_VERB_MULTICAST_FRAME_IDX_FLAGS + 1)
|
2014-09-26 21:18:25 +00:00
|
|
|
#define ZT_PROTO_VERB_MULTICAST_FRAME_IDX_GATHER_LIMIT (ZT_PROTO_VERB_MULTICAST_FRAME_IDX_FLAGS + 1)
|
2014-10-09 19:42:25 +00:00
|
|
|
#define ZT_PROTO_VERB_MULTICAST_FRAME_IDX_SOURCE_MAC (ZT_PROTO_VERB_MULTICAST_FRAME_IDX_FLAGS + 1)
|
|
|
|
#define ZT_PROTO_VERB_MULTICAST_FRAME_IDX_DEST_MAC (ZT_PROTO_VERB_MULTICAST_FRAME_IDX_FLAGS + 1)
|
|
|
|
#define ZT_PROTO_VERB_MULTICAST_FRAME_IDX_DEST_ADI (ZT_PROTO_VERB_MULTICAST_FRAME_IDX_DEST_MAC + 6)
|
|
|
|
#define ZT_PROTO_VERB_MULTICAST_FRAME_IDX_ETHERTYPE (ZT_PROTO_VERB_MULTICAST_FRAME_IDX_DEST_ADI + 4)
|
2014-09-30 23:28:25 +00:00
|
|
|
#define ZT_PROTO_VERB_MULTICAST_FRAME_IDX_FRAME (ZT_PROTO_VERB_MULTICAST_FRAME_IDX_ETHERTYPE + 2)
|
2014-09-26 21:18:25 +00:00
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
#define ZT_PROTO_VERB_HELLO__OK__IDX_TIMESTAMP (ZT_PROTO_VERB_OK_IDX_PAYLOAD)
|
2013-09-20 17:36:14 +00:00
|
|
|
#define ZT_PROTO_VERB_HELLO__OK__IDX_PROTOCOL_VERSION (ZT_PROTO_VERB_HELLO__OK__IDX_TIMESTAMP + 8)
|
|
|
|
#define ZT_PROTO_VERB_HELLO__OK__IDX_MAJOR_VERSION (ZT_PROTO_VERB_HELLO__OK__IDX_PROTOCOL_VERSION + 1)
|
|
|
|
#define ZT_PROTO_VERB_HELLO__OK__IDX_MINOR_VERSION (ZT_PROTO_VERB_HELLO__OK__IDX_MAJOR_VERSION + 1)
|
|
|
|
#define ZT_PROTO_VERB_HELLO__OK__IDX_REVISION (ZT_PROTO_VERB_HELLO__OK__IDX_MINOR_VERSION + 1)
|
2013-08-03 16:53:46 +00:00
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
#define ZT_PROTO_VERB_WHOIS__OK__IDX_IDENTITY (ZT_PROTO_VERB_OK_IDX_PAYLOAD)
|
2013-08-03 16:53:46 +00:00
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
#define ZT_PROTO_VERB_WHOIS__ERROR__IDX_ZTADDRESS (ZT_PROTO_VERB_ERROR_IDX_PAYLOAD)
|
|
|
|
|
2013-08-03 16:53:46 +00:00
|
|
|
#define ZT_PROTO_VERB_NETWORK_CONFIG_REQUEST__OK__IDX_NETWORK_ID (ZT_PROTO_VERB_OK_IDX_PAYLOAD)
|
|
|
|
#define ZT_PROTO_VERB_NETWORK_CONFIG_REQUEST__OK__IDX_DICT_LEN (ZT_PROTO_VERB_NETWORK_CONFIG_REQUEST__OK__IDX_NETWORK_ID + 8)
|
|
|
|
#define ZT_PROTO_VERB_NETWORK_CONFIG_REQUEST__OK__IDX_DICT (ZT_PROTO_VERB_NETWORK_CONFIG_REQUEST__OK__IDX_DICT_LEN + 2)
|
|
|
|
|
2014-10-02 20:50:37 +00:00
|
|
|
#define ZT_PROTO_VERB_MULTICAST_GATHER__OK__IDX_NETWORK_ID (ZT_PROTO_VERB_OK_IDX_PAYLOAD)
|
|
|
|
#define ZT_PROTO_VERB_MULTICAST_GATHER__OK__IDX_MAC (ZT_PROTO_VERB_MULTICAST_GATHER__OK__IDX_NETWORK_ID + 8)
|
|
|
|
#define ZT_PROTO_VERB_MULTICAST_GATHER__OK__IDX_ADI (ZT_PROTO_VERB_MULTICAST_GATHER__OK__IDX_MAC + 6)
|
|
|
|
#define ZT_PROTO_VERB_MULTICAST_GATHER__OK__IDX_GATHER_RESULTS (ZT_PROTO_VERB_MULTICAST_GATHER__OK__IDX_ADI + 4)
|
|
|
|
|
|
|
|
#define ZT_PROTO_VERB_MULTICAST_FRAME__OK__IDX_NETWORK_ID (ZT_PROTO_VERB_OK_IDX_PAYLOAD)
|
|
|
|
#define ZT_PROTO_VERB_MULTICAST_FRAME__OK__IDX_MAC (ZT_PROTO_VERB_MULTICAST_FRAME__OK__IDX_NETWORK_ID + 8)
|
|
|
|
#define ZT_PROTO_VERB_MULTICAST_FRAME__OK__IDX_ADI (ZT_PROTO_VERB_MULTICAST_FRAME__OK__IDX_MAC + 6)
|
|
|
|
#define ZT_PROTO_VERB_MULTICAST_FRAME__OK__IDX_FLAGS (ZT_PROTO_VERB_MULTICAST_FRAME__OK__IDX_ADI + 4)
|
2014-10-29 23:24:19 +00:00
|
|
|
#define ZT_PROTO_VERB_MULTICAST_FRAME__OK__IDX_COM_AND_GATHER_RESULTS (ZT_PROTO_VERB_MULTICAST_FRAME__OK__IDX_FLAGS + 1)
|
2014-10-02 20:50:37 +00:00
|
|
|
|
2013-08-03 16:53:46 +00:00
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
namespace ZeroTier {
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ZeroTier packet
|
|
|
|
*
|
|
|
|
* Packet format:
|
|
|
|
* <[8] random initialization vector (doubles as 64-bit packet ID)>
|
|
|
|
* <[5] destination ZT address>
|
|
|
|
* <[5] source ZT address>
|
2014-10-02 17:54:34 +00:00
|
|
|
* <[1] flags/cipher (top 5 bits) and ZT hop count (last 3 bits)>
|
2013-09-16 17:02:10 +00:00
|
|
|
* <[8] 8-bit MAC (currently first 8 bytes of poly1305 tag)>
|
2013-07-04 20:56:19 +00:00
|
|
|
* [... -- begin encryption envelope -- ...]
|
2014-10-02 17:54:34 +00:00
|
|
|
* <[1] encrypted flags (top 3 bits) and verb (last 5 bits)>
|
2013-07-04 20:56:19 +00:00
|
|
|
* [... verb-specific payload ...]
|
|
|
|
*
|
|
|
|
* Packets smaller than 28 bytes are invalid and silently discarded.
|
|
|
|
*
|
2014-10-02 18:08:59 +00:00
|
|
|
* The flags/cipher/hops bit field is: FFCCCHHH where C is a 3-bit cipher
|
2014-10-02 17:54:34 +00:00
|
|
|
* selection allowing up to 8 cipher suites, F is flags (reserved, currently
|
|
|
|
* all zero), and H is hop count.
|
|
|
|
*
|
|
|
|
* The three-bit hop count is the only part of a packet that is mutable in
|
|
|
|
* transit without invalidating the MAC. All other bits in the packet are
|
|
|
|
* immutable. This is because intermediate nodes can increment the hop
|
|
|
|
* count up to 7 (protocol max).
|
2013-07-04 20:56:19 +00:00
|
|
|
*
|
|
|
|
* http://tonyarcieri.com/all-the-crypto-code-youve-ever-written-is-probably-broken
|
|
|
|
*
|
|
|
|
* For unencrypted packets, MAC is computed on plaintext. Only HELLO is ever
|
|
|
|
* sent in the clear, as it's the "here is my public key" message.
|
2014-04-10 23:30:15 +00:00
|
|
|
*
|
|
|
|
* Beacon format and beacon packets:
|
|
|
|
* <[8] 8 random bytes>
|
|
|
|
* <[5] sender ZT address>
|
|
|
|
*
|
|
|
|
* A beacon is a 13-byte packet containing only the address of the sender.
|
|
|
|
* Receiving peers may or may not respond to beacons with a HELLO or other
|
|
|
|
* message to initiate direct communication.
|
|
|
|
*
|
|
|
|
* Beacons may be used for direct LAN announcement or NAT traversal.
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
|
|
|
class Packet : public Buffer<ZT_PROTO_MAX_PACKET_LENGTH>
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
* A packet fragment
|
|
|
|
*
|
|
|
|
* Fragments are sent if a packet is larger than UDP MTU. The first fragment
|
|
|
|
* is sent with its normal header with the fragmented flag set. Remaining
|
|
|
|
* fragments are sent this way.
|
|
|
|
*
|
|
|
|
* The fragmented bit indicates that there is at least one fragment. Fragments
|
|
|
|
* themselves contain the total, so the receiver must "learn" this from the
|
|
|
|
* first fragment it receives.
|
|
|
|
*
|
|
|
|
* Fragments are sent with the following format:
|
|
|
|
* <[8] packet ID of packet whose fragment this belongs to>
|
|
|
|
* <[5] destination ZT address>
|
|
|
|
* <[1] 0xff, a reserved address, signals that this isn't a normal packet>
|
|
|
|
* <[1] total fragments (most significant 4 bits), fragment no (LS 4 bits)>
|
2014-10-02 17:54:34 +00:00
|
|
|
* <[1] ZT hop count (top 5 bits unused and must be zero)>
|
2013-07-04 20:56:19 +00:00
|
|
|
* <[...] fragment data>
|
|
|
|
*
|
|
|
|
* The protocol supports a maximum of 16 fragments. If a fragment is received
|
|
|
|
* before its main packet header, it should be cached for a brief period of
|
|
|
|
* time to see if its parent arrives. Loss of any fragment constitutes packet
|
|
|
|
* loss; there is no retransmission mechanism. The receiver must wait for full
|
|
|
|
* receipt to authenticate and decrypt; there is no per-fragment MAC. (But if
|
|
|
|
* fragments are corrupt, the MAC will fail for the whole assembled packet.)
|
|
|
|
*/
|
|
|
|
class Fragment : public Buffer<ZT_PROTO_MAX_PACKET_LENGTH>
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
Fragment() :
|
|
|
|
Buffer<ZT_PROTO_MAX_PACKET_LENGTH>()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
template<unsigned int C2>
|
|
|
|
Fragment(const Buffer<C2> &b)
|
|
|
|
throw(std::out_of_range) :
|
|
|
|
Buffer<ZT_PROTO_MAX_PACKET_LENGTH>(b)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Initialize from a packet
|
|
|
|
*
|
|
|
|
* @param p Original assembled packet
|
|
|
|
* @param fragStart Start of fragment (raw index in packet data)
|
|
|
|
* @param fragLen Length of fragment in bytes
|
|
|
|
* @param fragNo Which fragment (>= 1, since 0 is Packet with end chopped off)
|
|
|
|
* @param fragTotal Total number of fragments (including 0)
|
|
|
|
* @throws std::out_of_range Packet size would exceed buffer
|
|
|
|
*/
|
|
|
|
Fragment(const Packet &p,unsigned int fragStart,unsigned int fragLen,unsigned int fragNo,unsigned int fragTotal)
|
|
|
|
throw(std::out_of_range)
|
|
|
|
{
|
|
|
|
init(p,fragStart,fragLen,fragNo,fragTotal);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Initialize from a packet
|
|
|
|
*
|
|
|
|
* @param p Original assembled packet
|
|
|
|
* @param fragStart Start of fragment (raw index in packet data)
|
|
|
|
* @param fragLen Length of fragment in bytes
|
|
|
|
* @param fragNo Which fragment (>= 1, since 0 is Packet with end chopped off)
|
|
|
|
* @param fragTotal Total number of fragments (including 0)
|
|
|
|
* @throws std::out_of_range Packet size would exceed buffer
|
|
|
|
*/
|
|
|
|
inline void init(const Packet &p,unsigned int fragStart,unsigned int fragLen,unsigned int fragNo,unsigned int fragTotal)
|
|
|
|
throw(std::out_of_range)
|
|
|
|
{
|
|
|
|
if ((fragStart + fragLen) > p.size())
|
|
|
|
throw std::out_of_range("Packet::Fragment: tried to construct fragment of packet past its length");
|
|
|
|
setSize(fragLen + ZT_PROTO_MIN_FRAGMENT_LENGTH);
|
|
|
|
|
|
|
|
// NOTE: this copies both the IV/packet ID and the destination address.
|
2014-10-29 00:25:34 +00:00
|
|
|
memcpy(field(ZT_PACKET_FRAGMENT_IDX_PACKET_ID,13),p.field(ZT_PACKET_IDX_IV,13),13);
|
2013-07-04 20:56:19 +00:00
|
|
|
|
2013-07-09 18:06:55 +00:00
|
|
|
(*this)[ZT_PACKET_FRAGMENT_IDX_FRAGMENT_INDICATOR] = ZT_PACKET_FRAGMENT_INDICATOR;
|
|
|
|
(*this)[ZT_PACKET_FRAGMENT_IDX_FRAGMENT_NO] = (char)(((fragTotal & 0xf) << 4) | (fragNo & 0xf));
|
|
|
|
(*this)[ZT_PACKET_FRAGMENT_IDX_HOPS] = 0;
|
2013-07-04 20:56:19 +00:00
|
|
|
|
2014-10-29 00:25:34 +00:00
|
|
|
memcpy(field(ZT_PACKET_FRAGMENT_IDX_PAYLOAD,fragLen),p.field(fragStart,fragLen),fragLen);
|
2013-07-04 20:56:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get this fragment's destination
|
|
|
|
*
|
|
|
|
* @return Destination ZT address
|
|
|
|
*/
|
2013-07-29 17:56:20 +00:00
|
|
|
inline Address destination() const { return Address(field(ZT_PACKET_FRAGMENT_IDX_DEST,ZT_ADDRESS_LENGTH),ZT_ADDRESS_LENGTH); }
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @return True if fragment is of a valid length
|
|
|
|
*/
|
2013-07-09 18:06:55 +00:00
|
|
|
inline bool lengthValid() const { return (size() >= ZT_PACKET_FRAGMENT_IDX_PAYLOAD); }
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @return ID of packet this is a fragment of
|
|
|
|
*/
|
|
|
|
inline uint64_t packetId() const { return at<uint64_t>(ZT_PACKET_FRAGMENT_IDX_PACKET_ID); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return Total number of fragments in packet
|
|
|
|
*/
|
2013-07-09 18:06:55 +00:00
|
|
|
inline unsigned int totalFragments() const { return (((unsigned int)((*this)[ZT_PACKET_FRAGMENT_IDX_FRAGMENT_NO]) >> 4) & 0xf); }
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @return Fragment number of this fragment
|
|
|
|
*/
|
2013-07-09 18:06:55 +00:00
|
|
|
inline unsigned int fragmentNumber() const { return ((unsigned int)((*this)[ZT_PACKET_FRAGMENT_IDX_FRAGMENT_NO]) & 0xf); }
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @return Fragment ZT hop count
|
|
|
|
*/
|
2013-07-09 18:06:55 +00:00
|
|
|
inline unsigned int hops() const { return (unsigned int)((*this)[ZT_PACKET_FRAGMENT_IDX_HOPS]); }
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Increment this packet's hop count
|
|
|
|
*/
|
|
|
|
inline void incrementHops()
|
|
|
|
{
|
2013-07-09 18:06:55 +00:00
|
|
|
(*this)[ZT_PACKET_FRAGMENT_IDX_HOPS] = (((*this)[ZT_PACKET_FRAGMENT_IDX_HOPS]) + 1) & ZT_PROTO_MAX_HOPS;
|
2013-07-04 20:56:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2013-07-09 18:06:55 +00:00
|
|
|
* @return Length of payload in bytes
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
2013-07-09 18:06:55 +00:00
|
|
|
inline unsigned int payloadLength() const { return ((size() > ZT_PACKET_FRAGMENT_IDX_PAYLOAD) ? (size() - ZT_PACKET_FRAGMENT_IDX_PAYLOAD) : 0); }
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
/**
|
2013-07-09 18:06:55 +00:00
|
|
|
* @return Raw packet payload
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
2013-07-09 18:06:55 +00:00
|
|
|
inline const unsigned char *payload() const
|
|
|
|
{
|
|
|
|
return field(ZT_PACKET_FRAGMENT_IDX_PAYLOAD,size() - ZT_PACKET_FRAGMENT_IDX_PAYLOAD);
|
|
|
|
}
|
2013-07-04 20:56:19 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ZeroTier protocol verbs
|
|
|
|
*/
|
|
|
|
enum Verb /* Max value: 32 (5 bits) */
|
|
|
|
{
|
|
|
|
/* No operation, payload ignored, no reply */
|
|
|
|
VERB_NOP = 0,
|
|
|
|
|
|
|
|
/* Announcement of a node's existence:
|
2013-07-06 17:34:35 +00:00
|
|
|
* <[1] protocol version>
|
2013-07-04 20:56:19 +00:00
|
|
|
* <[1] software major version>
|
|
|
|
* <[1] software minor version>
|
|
|
|
* <[2] software revision>
|
2013-07-06 17:34:35 +00:00
|
|
|
* <[8] timestamp (ms since epoch)>
|
|
|
|
* <[...] binary serialized identity (see Identity)>
|
2013-07-04 20:56:19 +00:00
|
|
|
*
|
|
|
|
* OK payload:
|
2013-07-06 17:34:35 +00:00
|
|
|
* <[8] timestamp (echoed from original HELLO)>
|
2013-09-13 18:41:20 +00:00
|
|
|
* <[1] protocol version (of responder)>
|
|
|
|
* <[1] software major version (of responder)>
|
|
|
|
* <[1] software minor version (of responder)>
|
|
|
|
* <[2] software revision (of responder)>
|
2013-07-04 20:56:19 +00:00
|
|
|
*
|
|
|
|
* ERROR has no payload.
|
|
|
|
*/
|
|
|
|
VERB_HELLO = 1,
|
|
|
|
|
|
|
|
/* Error response:
|
2013-07-06 17:34:35 +00:00
|
|
|
* <[1] in-re verb>
|
|
|
|
* <[8] in-re packet ID>
|
|
|
|
* <[1] error code>
|
|
|
|
* <[...] error-dependent payload>
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
|
|
|
VERB_ERROR = 2,
|
|
|
|
|
|
|
|
/* Success response:
|
2013-07-06 17:34:35 +00:00
|
|
|
* <[1] in-re verb>
|
|
|
|
* <[8] in-re packet ID>
|
|
|
|
* <[...] request-specific payload>
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
|
|
|
VERB_OK = 3,
|
|
|
|
|
|
|
|
/* Query an identity by address:
|
2013-07-06 17:34:35 +00:00
|
|
|
* <[5] address to look up>
|
2013-07-04 20:56:19 +00:00
|
|
|
*
|
|
|
|
* OK response payload:
|
2013-07-06 17:34:35 +00:00
|
|
|
* <[...] binary serialized identity>
|
2013-07-04 20:56:19 +00:00
|
|
|
*
|
2013-10-17 10:41:52 +00:00
|
|
|
* ERROR response payload:
|
|
|
|
* <[5] address>
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
|
|
|
VERB_WHOIS = 4,
|
|
|
|
|
|
|
|
/* Meet another node at a given protocol address:
|
2013-10-17 10:41:52 +00:00
|
|
|
* <[1] flags (unused, currently 0)>
|
2013-07-04 20:56:19 +00:00
|
|
|
* <[5] ZeroTier address of peer that might be found at this address>
|
|
|
|
* <[2] 16-bit protocol address port>
|
|
|
|
* <[1] protocol address length (4 for IPv4, 16 for IPv6)>
|
|
|
|
* <[...] protocol address (network byte order)>
|
|
|
|
*
|
|
|
|
* This is sent by a relaying node to initiate NAT traversal between two
|
|
|
|
* peers that are communicating by way of indirect relay. The relay will
|
|
|
|
* send this to both peers at the same time on a periodic basis, telling
|
|
|
|
* each where it might find the other on the network.
|
|
|
|
*
|
2013-12-31 19:03:45 +00:00
|
|
|
* Upon receipt a peer sends HELLO to establish a direct link.
|
2013-07-04 20:56:19 +00:00
|
|
|
*
|
|
|
|
* Nodes should implement rate control, limiting the rate at which they
|
|
|
|
* respond to these packets to prevent their use in DDOS attacks. Nodes
|
|
|
|
* may also ignore these messages if a peer is not known or is not being
|
|
|
|
* actively communicated with.
|
|
|
|
*
|
|
|
|
* No OK or ERROR is generated.
|
|
|
|
*/
|
|
|
|
VERB_RENDEZVOUS = 5,
|
|
|
|
|
2014-09-30 15:38:03 +00:00
|
|
|
/* ZT-to-ZT unicast ethernet frame (shortened EXT_FRAME):
|
2013-07-04 20:56:19 +00:00
|
|
|
* <[8] 64-bit network ID>
|
2013-07-06 17:34:35 +00:00
|
|
|
* <[2] 16-bit ethertype>
|
|
|
|
* <[...] ethernet payload>
|
2013-07-04 20:56:19 +00:00
|
|
|
*
|
|
|
|
* MAC addresses are derived from the packet's source and destination
|
2014-09-30 15:38:03 +00:00
|
|
|
* ZeroTier addresses. This is a shortened EXT_FRAME that elides full
|
|
|
|
* Ethernet framing and other optional flags and features when they
|
|
|
|
* are not necessary.
|
2013-07-04 20:56:19 +00:00
|
|
|
*
|
2013-09-27 20:03:13 +00:00
|
|
|
* ERROR may be generated if a membership certificate is needed for a
|
|
|
|
* closed network. Payload will be network ID.
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
|
|
|
VERB_FRAME = 6,
|
|
|
|
|
2014-09-30 23:28:25 +00:00
|
|
|
/* Full Ethernet frame with MAC addressing and optional fields:
|
2014-06-10 22:25:15 +00:00
|
|
|
* <[8] 64-bit network ID>
|
2014-09-30 15:38:03 +00:00
|
|
|
* <[1] flags>
|
|
|
|
* [<[...] certificate of network membership>]
|
2014-06-10 22:25:15 +00:00
|
|
|
* <[6] destination MAC or all zero for destination node>
|
|
|
|
* <[6] source MAC or all zero for node of origin>
|
|
|
|
* <[2] 16-bit ethertype>
|
|
|
|
* <[...] ethernet payload>
|
|
|
|
*
|
2014-09-30 15:38:03 +00:00
|
|
|
* Flags:
|
|
|
|
* 0x01 - Certificate of network membership is attached
|
|
|
|
*
|
|
|
|
* An extended frame carries full MAC addressing, making them a
|
|
|
|
* superset of VERB_FRAME. They're used for bridging or when we
|
|
|
|
* want to attach a certificate since FRAME does not support that.
|
2014-06-10 22:25:15 +00:00
|
|
|
*
|
2014-09-30 23:28:25 +00:00
|
|
|
* Multicast frames may not be sent as EXT_FRAME.
|
|
|
|
*
|
2014-06-10 22:25:15 +00:00
|
|
|
* ERROR may be generated if a membership certificate is needed for a
|
|
|
|
* closed network. Payload will be network ID.
|
|
|
|
*/
|
|
|
|
VERB_EXT_FRAME = 7,
|
2013-07-11 02:58:43 +00:00
|
|
|
|
2014-09-19 01:28:14 +00:00
|
|
|
/* A multicast frame [old multicast protocol, deprecated]:
|
2013-09-30 15:05:35 +00:00
|
|
|
* <[2] 16-bit propagation depth or 0xffff for "do not forward">
|
2013-09-26 21:45:19 +00:00
|
|
|
* <[320] propagation FIFO>
|
|
|
|
* <[1024] propagation bloom filter>
|
|
|
|
* [... begin signed portion ...]
|
2013-09-27 20:03:13 +00:00
|
|
|
* <[1] 8-bit flags, currently unused and must be 0>
|
2013-07-11 02:58:43 +00:00
|
|
|
* <[8] 64-bit network ID>
|
2013-09-26 21:45:19 +00:00
|
|
|
* <[2] 16-bit random propagation bloom filter nonce>
|
|
|
|
* <[1] number of significant bits in propagation restrict prefix>
|
2013-09-30 15:05:35 +00:00
|
|
|
* <[1] propagation restriction prefix (sig bits right to left)>
|
2013-09-26 21:45:19 +00:00
|
|
|
* <[5] ZeroTier address of node of origin>
|
|
|
|
* <[3] 24-bit multicast ID, together with origin forms GUID>
|
2013-07-11 02:58:43 +00:00
|
|
|
* <[6] source MAC address>
|
2013-09-20 17:36:14 +00:00
|
|
|
* <[6] destination multicast group MAC address>
|
2013-09-26 21:45:19 +00:00
|
|
|
* <[4] destination multicast group ADI field>
|
2013-09-20 17:36:14 +00:00
|
|
|
* <[2] 16-bit frame ethertype>
|
2013-07-11 02:58:43 +00:00
|
|
|
* <[2] 16-bit length of payload>
|
2013-09-20 17:36:14 +00:00
|
|
|
* <[...] ethernet frame payload>
|
|
|
|
* [... end of signed portion ...]
|
2013-07-11 02:58:43 +00:00
|
|
|
* <[2] 16-bit length of signature>
|
2013-09-20 17:36:14 +00:00
|
|
|
* <[...] signature (currently Ed25519/SHA-512, 96 bytes in length)>
|
2013-10-25 18:51:55 +00:00
|
|
|
* [<[...] network membership certificate (optional)>]
|
|
|
|
*
|
|
|
|
* Flags:
|
|
|
|
* 0x01 - Multicast frame includes network membership certificate
|
|
|
|
* for original sender for this network.
|
2013-07-11 02:58:43 +00:00
|
|
|
*
|
2013-09-26 21:45:19 +00:00
|
|
|
* When a multicast frame is received:
|
2013-07-11 02:58:43 +00:00
|
|
|
*
|
2013-09-26 21:45:19 +00:00
|
|
|
* (1) Check the signature of the signed portion of packet, discard on fail
|
|
|
|
* (2) Check for duplicate multicast, STOP if duplicate
|
|
|
|
* (3) Check rate limits, STOP if over limit
|
|
|
|
* (4) Inject into tap if member of network and packet passes other checks
|
|
|
|
* (5) Increment propagation depth, STOP if over limit
|
|
|
|
* (6) Pop topmost element off FIFO -- this is next hop
|
|
|
|
* (7) Push suggested next hops onto FIFO until full -- set corresponding
|
|
|
|
* bits in bloom filter
|
|
|
|
* (8) Send to next hop, or to a supernode if none
|
2013-07-11 02:58:43 +00:00
|
|
|
*
|
2013-09-26 21:45:19 +00:00
|
|
|
* When choosing next hops, exclude addresses corresponding to bits already
|
|
|
|
* set in the bloom filter and addresses outside the propagation restrict
|
|
|
|
* prefix.
|
2013-09-20 17:36:14 +00:00
|
|
|
*
|
2014-06-10 22:25:15 +00:00
|
|
|
* Active bridges on a network are always added as next hops for all
|
|
|
|
* multicast and broadcast traffic, as if they "like" all groups.
|
|
|
|
*
|
2013-09-26 21:45:19 +00:00
|
|
|
* Algorithm for setting bits in bloom filter:
|
2013-09-20 17:36:14 +00:00
|
|
|
*
|
2013-09-26 21:45:19 +00:00
|
|
|
* (1) Place the address in the least significant 40 bits of a 64-bit int.
|
|
|
|
* (2) Add the bloom filter nonce to this value.
|
|
|
|
* (3) XOR the least significant 13 bits of this value with the next most
|
|
|
|
* significant 13 bits and so on, 4 times.
|
|
|
|
* (4) This value ANDed with 0x1fff is the bit to set in the bloom filter.
|
|
|
|
* (5) Set this bit via: byte[bit >> 3] |= (0x80 >> (bit & 7))
|
2013-09-20 17:36:14 +00:00
|
|
|
*
|
2013-09-26 21:45:19 +00:00
|
|
|
* To check bits in bloom filter perform the same computation but mask the
|
|
|
|
* bit instead of ORing it.
|
|
|
|
*
|
|
|
|
* Propagation occurs within a restrict prefix. The restrict prefix is
|
|
|
|
* applied to the least significant 16 bits of an address. The original
|
|
|
|
* sender of the multicast sets the restrict prefix and sends 2^N copies
|
2013-09-27 20:03:13 +00:00
|
|
|
* of the multicast frame, one for each address prefix.
|
2013-09-26 21:45:19 +00:00
|
|
|
*
|
2013-09-27 20:03:13 +00:00
|
|
|
* ERROR may be generated if a membership certificate is needed for a
|
|
|
|
* closed network. Payload will be network ID.
|
2013-09-26 21:45:19 +00:00
|
|
|
*/
|
2014-09-19 01:28:14 +00:00
|
|
|
VERB_P5_MULTICAST_FRAME = 8,
|
2013-09-26 21:45:19 +00:00
|
|
|
|
|
|
|
/* Announce interest in multicast group(s):
|
|
|
|
* <[8] 64-bit network ID>
|
|
|
|
* <[6] multicast Ethernet address>
|
|
|
|
* <[4] multicast additional distinguishing information (ADI)>
|
|
|
|
* [... additional tuples of network/address/adi ...]
|
|
|
|
*
|
|
|
|
* LIKEs are sent to peers with whom you have a direct peer to peer
|
|
|
|
* connection, and always including supernodes.
|
|
|
|
*
|
|
|
|
* OK/ERROR are not generated.
|
2013-07-11 02:58:43 +00:00
|
|
|
*/
|
2013-09-26 21:45:19 +00:00
|
|
|
VERB_MULTICAST_LIKE = 9,
|
2013-07-27 20:20:08 +00:00
|
|
|
|
2013-10-27 11:26:50 +00:00
|
|
|
/* Network member certificate replication/push:
|
2013-10-07 20:13:52 +00:00
|
|
|
* <[...] serialized certificate of membership>
|
2013-10-17 10:41:52 +00:00
|
|
|
* [ ... additional certificates may follow ...]
|
2013-07-27 20:20:08 +00:00
|
|
|
*
|
2013-10-16 21:47:26 +00:00
|
|
|
* Certificate contains network ID, peer it was issued for, etc.
|
|
|
|
*
|
|
|
|
* OK/ERROR are not generated.
|
2013-07-27 20:20:08 +00:00
|
|
|
*/
|
2013-07-29 20:18:29 +00:00
|
|
|
VERB_NETWORK_MEMBERSHIP_CERTIFICATE = 10,
|
2013-07-29 17:56:20 +00:00
|
|
|
|
|
|
|
/* Network configuration request:
|
|
|
|
* <[8] 64-bit network ID>
|
2013-07-31 13:27:55 +00:00
|
|
|
* <[2] 16-bit length of request meta-data dictionary>
|
|
|
|
* <[...] string-serialized request meta-data>
|
2013-07-29 17:56:20 +00:00
|
|
|
*
|
|
|
|
* This message requests network configuration from a node capable of
|
|
|
|
* providing it. Such nodes run the netconf service, which must be
|
|
|
|
* installed into the ZeroTier home directory.
|
|
|
|
*
|
|
|
|
* OK response payload:
|
|
|
|
* <[8] 64-bit network ID>
|
2013-07-31 13:27:55 +00:00
|
|
|
* <[2] 16-bit length of network configuration dictionary>
|
2013-07-29 17:56:20 +00:00
|
|
|
* <[...] network configuration dictionary>
|
|
|
|
*
|
|
|
|
* OK returns a Dictionary (string serialized) containing the network's
|
|
|
|
* configuration and IP address assignment information for the querying
|
2013-07-31 13:27:55 +00:00
|
|
|
* node. It also contains a membership certificate that the querying
|
|
|
|
* node can push to other peers to demonstrate its right to speak on
|
|
|
|
* a given network.
|
2013-07-29 17:56:20 +00:00
|
|
|
*
|
2013-10-17 10:41:52 +00:00
|
|
|
* ERROR response payload:
|
|
|
|
* <[8] 64-bit network ID>
|
2013-10-27 11:26:50 +00:00
|
|
|
*
|
|
|
|
* Support is optional. Nodes should return UNSUPPORTED_OPERATION if
|
|
|
|
* not supported or enabled.
|
2013-07-29 17:56:20 +00:00
|
|
|
*/
|
|
|
|
VERB_NETWORK_CONFIG_REQUEST = 11,
|
|
|
|
|
2015-01-05 19:47:22 +00:00
|
|
|
/* DEPRECATED -- was never actually used */
|
2014-09-19 01:28:14 +00:00
|
|
|
VERB_NETWORK_CONFIG_REFRESH = 12,
|
|
|
|
|
|
|
|
/* Request endpoints for multicast distribution:
|
|
|
|
* <[8] 64-bit network ID>
|
2014-10-10 00:58:31 +00:00
|
|
|
* <[1] flags>
|
2014-09-19 01:28:14 +00:00
|
|
|
* <[6] MAC address of multicast group being queried>
|
|
|
|
* <[4] 32-bit ADI for multicast group being queried>
|
2014-10-10 00:58:31 +00:00
|
|
|
* <[4] 32-bit requested max number of multicast peers>
|
|
|
|
* [<[...] network certificate of membership>]
|
|
|
|
*
|
|
|
|
* Flags:
|
|
|
|
* 0x01 - Network certificate of membership is attached
|
2014-09-19 01:28:14 +00:00
|
|
|
*
|
|
|
|
* This message asks a peer for additional known endpoints that have
|
|
|
|
* LIKEd a given multicast group. It's sent when the sender wishes
|
|
|
|
* to send multicast but does not have the desired number of recipient
|
2014-09-22 20:18:24 +00:00
|
|
|
* peers.
|
2014-09-19 01:28:14 +00:00
|
|
|
*
|
|
|
|
* OK response payload:
|
|
|
|
* <[8] 64-bit network ID>
|
|
|
|
* <[6] MAC address of multicast group being queried>
|
|
|
|
* <[4] 32-bit ADI for multicast group being queried>
|
2014-09-30 23:28:25 +00:00
|
|
|
* [begin gather results -- these same fields can be in OK(MULTICAST_FRAME)]
|
2014-09-22 20:18:24 +00:00
|
|
|
* <[4] 32-bit total number of known members in this multicast group>
|
2014-09-19 01:28:14 +00:00
|
|
|
* <[2] 16-bit number of members enumerated in this packet>
|
|
|
|
* <[...] series of 5-byte ZeroTier addresses of enumerated members>
|
|
|
|
*
|
2014-09-25 22:57:43 +00:00
|
|
|
* If no endpoints are known, OK and ERROR are both optional. It's okay
|
|
|
|
* to return nothing in that case since gathering is "lazy."
|
|
|
|
*
|
2014-09-19 01:28:14 +00:00
|
|
|
* ERROR response payload:
|
|
|
|
* <[8] 64-bit network ID>
|
|
|
|
* <[6] MAC address of multicast group being queried>
|
|
|
|
* <[4] 32-bit ADI for multicast group being queried>
|
|
|
|
*
|
|
|
|
* ERRORs are optional and are only generated if permission is denied,
|
|
|
|
* certificate of membership is out of date, etc.
|
|
|
|
*/
|
2014-09-22 20:18:24 +00:00
|
|
|
VERB_MULTICAST_GATHER = 13,
|
2014-09-19 01:28:14 +00:00
|
|
|
|
|
|
|
/* Multicast frame:
|
2014-09-24 20:45:58 +00:00
|
|
|
* <[8] 64-bit network ID>
|
2014-09-26 21:18:25 +00:00
|
|
|
* <[1] flags>
|
2014-10-09 19:42:25 +00:00
|
|
|
* [<[...] network certificate of membership>]
|
|
|
|
* [<[4] 32-bit implicit gather limit>]
|
|
|
|
* [<[6] source MAC>]
|
|
|
|
* <[6] destination MAC (multicast address)>
|
|
|
|
* <[4] 32-bit multicast ADI (multicast address extension)>
|
2014-09-19 01:28:14 +00:00
|
|
|
* <[2] 16-bit ethertype>
|
|
|
|
* <[...] ethernet payload>
|
|
|
|
*
|
2014-09-26 21:18:25 +00:00
|
|
|
* Flags:
|
|
|
|
* 0x01 - Network certificate of membership is attached
|
2014-10-09 19:42:25 +00:00
|
|
|
* 0x02 - Implicit gather limit field is present
|
|
|
|
* 0x04 - Source MAC is specified -- otherwise it's computed from sender
|
2014-09-26 21:18:25 +00:00
|
|
|
*
|
2014-10-09 19:42:25 +00:00
|
|
|
* OK and ERROR responses are optional. OK may be generated if there are
|
|
|
|
* implicit gather results or if the recipient wants to send its own
|
|
|
|
* updated certificate of network membership to the sender. ERROR may be
|
|
|
|
* generated if a certificate is needed or if multicasts to this group
|
|
|
|
* are no longer wanted (multicast unsubscribe).
|
2014-09-30 23:28:25 +00:00
|
|
|
*
|
2014-09-25 22:57:43 +00:00
|
|
|
* OK response payload:
|
2014-09-30 23:28:25 +00:00
|
|
|
* <[8] 64-bit network ID>
|
|
|
|
* <[6] MAC address of multicast group>
|
|
|
|
* <[4] 32-bit ADI for multicast group>
|
|
|
|
* <[1] flags>
|
2014-10-09 19:42:25 +00:00
|
|
|
* [<[...] network certficate of membership>]
|
2014-09-30 23:28:25 +00:00
|
|
|
* [<[...] implicit gather results if flag 0x01 is set>]
|
|
|
|
*
|
2014-10-09 19:42:25 +00:00
|
|
|
* OK flags (same bits as request flags):
|
|
|
|
* 0x01 - OK includes certificate of network membership
|
|
|
|
* 0x02 - OK includes implicit gather results
|
2014-09-19 01:28:14 +00:00
|
|
|
*
|
|
|
|
* ERROR response payload:
|
2014-09-30 23:28:25 +00:00
|
|
|
* <[8] 64-bit network ID>
|
2014-09-19 01:28:14 +00:00
|
|
|
* <[6] multicast group MAC>
|
|
|
|
* <[4] 32-bit multicast group ADI>
|
|
|
|
*/
|
2015-01-05 19:47:22 +00:00
|
|
|
VERB_MULTICAST_FRAME = 14,
|
|
|
|
|
|
|
|
/* Message or query to a service:
|
|
|
|
* <[8] 64-bit service identifier>
|
|
|
|
* <[1] flags>
|
|
|
|
* [<[...] payload to service>]
|
|
|
|
*
|
|
|
|
* Flags are currently unused and must be zero.
|
|
|
|
*
|
|
|
|
* Services allow out-of-band extensions to be added to the
|
|
|
|
* ZeroTier peer-to-peer network without having to mix them
|
|
|
|
* with the Ethernet virtualization layer. Right now this
|
|
|
|
* includes the network configuration (netconf) service, and
|
|
|
|
* in the future could include things like DHTs, caching,
|
|
|
|
* mesh net functionality, extensions to cryptographic or
|
|
|
|
* authentication services, remote administration, remote
|
|
|
|
* debugging, etc.
|
|
|
|
*
|
|
|
|
* Service identifiers less than or equal to 0xffff (65535)
|
|
|
|
* are reserved for use by ZeroTier Networks, with ID 0 being
|
|
|
|
* the netconf service that provisions and configures virtual
|
|
|
|
* networks. These IDs should not be used by third party
|
|
|
|
* developers. IDs above 65535 can be used, and should be
|
|
|
|
* assigned using something like a cryptographic random number
|
|
|
|
* generator to minimize the potential for collisions.
|
|
|
|
*
|
|
|
|
* OK responses to this message contain the same fields as
|
|
|
|
* above, and their meaning is service-dependent.
|
|
|
|
*
|
|
|
|
* ERROR_UNSUPPORTED_OPERATION may optionally be returned if
|
|
|
|
* the queried service ID is not available on this node.
|
|
|
|
* Payload consists of the 64-bit service ID queried.
|
|
|
|
*/
|
|
|
|
VERB_SERVICE_MESSAGE = 15
|
2013-07-04 20:56:19 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Error codes for VERB_ERROR
|
|
|
|
*/
|
|
|
|
enum ErrorCode
|
|
|
|
{
|
|
|
|
/* No error, not actually used in transit */
|
|
|
|
ERROR_NONE = 0,
|
|
|
|
|
|
|
|
/* Invalid request */
|
|
|
|
ERROR_INVALID_REQUEST = 1,
|
|
|
|
|
|
|
|
/* Bad/unsupported protocol version */
|
|
|
|
ERROR_BAD_PROTOCOL_VERSION = 2,
|
|
|
|
|
|
|
|
/* Unknown object queried (e.g. with WHOIS) */
|
2013-08-13 01:25:36 +00:00
|
|
|
ERROR_OBJ_NOT_FOUND = 3,
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
/* HELLO pushed an identity whose address is already claimed */
|
|
|
|
ERROR_IDENTITY_COLLISION = 4,
|
|
|
|
|
|
|
|
/* Verb or use case not supported/enabled by this node */
|
2013-10-05 14:19:12 +00:00
|
|
|
ERROR_UNSUPPORTED_OPERATION = 5,
|
2013-07-27 20:20:08 +00:00
|
|
|
|
|
|
|
/* Message to private network rejected -- no unexpired certificate on file */
|
2013-10-16 21:47:26 +00:00
|
|
|
ERROR_NEED_MEMBERSHIP_CERTIFICATE = 6,
|
|
|
|
|
|
|
|
/* Tried to join network, but you're not a member */
|
2014-09-19 01:28:14 +00:00
|
|
|
ERROR_NETWORK_ACCESS_DENIED_ = 7, /* extra _ to avoid Windows name conflict */
|
|
|
|
|
|
|
|
/* Multicasts to this group are not wanted */
|
|
|
|
ERROR_UNWANTED_MULTICAST = 8
|
2013-07-04 20:56:19 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param v Verb
|
|
|
|
* @return String representation (e.g. HELLO, OK)
|
|
|
|
*/
|
|
|
|
static const char *verbString(Verb v)
|
|
|
|
throw();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param e Error code
|
|
|
|
* @return String error name
|
|
|
|
*/
|
|
|
|
static const char *errorString(ErrorCode e)
|
|
|
|
throw();
|
|
|
|
|
|
|
|
template<unsigned int C2>
|
|
|
|
Packet(const Buffer<C2> &b)
|
|
|
|
throw(std::out_of_range) :
|
|
|
|
Buffer<ZT_PROTO_MAX_PACKET_LENGTH>(b)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Construct a new empty packet with a unique random packet ID
|
|
|
|
*
|
|
|
|
* Flags and hops will be zero. Other fields and data region are undefined.
|
|
|
|
* Use the header access methods (setDestination() and friends) to fill out
|
|
|
|
* the header. Payload should be appended; initial size is header size.
|
|
|
|
*/
|
|
|
|
Packet() :
|
|
|
|
Buffer<ZT_PROTO_MAX_PACKET_LENGTH>(ZT_PROTO_MIN_PACKET_LENGTH)
|
|
|
|
{
|
2013-07-09 18:06:55 +00:00
|
|
|
Utils::getSecureRandom(field(ZT_PACKET_IDX_IV,8),8);
|
|
|
|
(*this)[ZT_PACKET_IDX_FLAGS] = 0; // zero flags and hops
|
2013-07-04 20:56:19 +00:00
|
|
|
}
|
|
|
|
|
2014-09-22 20:18:24 +00:00
|
|
|
/**
|
|
|
|
* Make a copy of a packet with a new initialization vector and destination address
|
|
|
|
*
|
|
|
|
* This can be used to take one draft prototype packet and quickly make copies to
|
|
|
|
* encrypt for different destinations.
|
|
|
|
*
|
|
|
|
* @param prototype Prototype packet
|
|
|
|
* @param dest Destination ZeroTier address for new packet
|
|
|
|
*/
|
|
|
|
Packet(const Packet &prototype,const Address &dest) :
|
|
|
|
Buffer<ZT_PROTO_MAX_PACKET_LENGTH>(prototype)
|
|
|
|
{
|
|
|
|
Utils::getSecureRandom(field(ZT_PACKET_IDX_IV,8),8);
|
|
|
|
setDestination(dest);
|
|
|
|
}
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
/**
|
|
|
|
* Construct a new empty packet with a unique random packet ID
|
|
|
|
*
|
|
|
|
* @param dest Destination ZT address
|
|
|
|
* @param source Source ZT address
|
|
|
|
* @param v Verb
|
|
|
|
*/
|
|
|
|
Packet(const Address &dest,const Address &source,const Verb v) :
|
|
|
|
Buffer<ZT_PROTO_MAX_PACKET_LENGTH>(ZT_PROTO_MIN_PACKET_LENGTH)
|
|
|
|
{
|
2013-07-09 18:06:55 +00:00
|
|
|
Utils::getSecureRandom(field(ZT_PACKET_IDX_IV,8),8);
|
2013-07-04 20:56:19 +00:00
|
|
|
setDestination(dest);
|
|
|
|
setSource(source);
|
2013-07-09 18:06:55 +00:00
|
|
|
(*this)[ZT_PACKET_IDX_FLAGS] = 0; // zero flags and hops
|
2013-07-04 20:56:19 +00:00
|
|
|
setVerb(v);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Reset this packet structure for reuse in place
|
|
|
|
*
|
|
|
|
* @param dest Destination ZT address
|
|
|
|
* @param source Source ZT address
|
|
|
|
* @param v Verb
|
|
|
|
*/
|
|
|
|
inline void reset(const Address &dest,const Address &source,const Verb v)
|
|
|
|
{
|
|
|
|
setSize(ZT_PROTO_MIN_PACKET_LENGTH);
|
2013-07-09 18:06:55 +00:00
|
|
|
Utils::getSecureRandom(field(ZT_PACKET_IDX_IV,8),8);
|
2013-07-04 20:56:19 +00:00
|
|
|
setDestination(dest);
|
|
|
|
setSource(source);
|
2013-07-09 18:06:55 +00:00
|
|
|
(*this)[ZT_PACKET_IDX_FLAGS] = 0; // zero flags and hops
|
2013-07-04 20:56:19 +00:00
|
|
|
setVerb(v);
|
|
|
|
}
|
|
|
|
|
2013-07-11 20:19:06 +00:00
|
|
|
/**
|
|
|
|
* Generate a new IV / packet ID in place
|
|
|
|
*
|
|
|
|
* This can be used to re-use a packet buffer multiple times to send
|
|
|
|
* technically different but otherwise identical copies of the same
|
|
|
|
* packet.
|
|
|
|
*/
|
|
|
|
inline void newInitializationVector()
|
|
|
|
{
|
|
|
|
Utils::getSecureRandom(field(ZT_PACKET_IDX_IV,8),8);
|
|
|
|
}
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
/**
|
|
|
|
* Set this packet's destination
|
|
|
|
*
|
|
|
|
* @param dest ZeroTier address of destination
|
|
|
|
*/
|
|
|
|
inline void setDestination(const Address &dest)
|
|
|
|
{
|
2013-07-09 18:06:55 +00:00
|
|
|
unsigned char *d = field(ZT_PACKET_IDX_DEST,ZT_ADDRESS_LENGTH);
|
2013-07-04 20:56:19 +00:00
|
|
|
for(unsigned int i=0;i<ZT_ADDRESS_LENGTH;++i)
|
2013-07-09 18:06:55 +00:00
|
|
|
d[i] = dest[i];
|
2013-07-04 20:56:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set this packet's source
|
|
|
|
*
|
|
|
|
* @param source ZeroTier address of source
|
|
|
|
*/
|
|
|
|
inline void setSource(const Address &source)
|
|
|
|
{
|
2013-07-09 18:06:55 +00:00
|
|
|
unsigned char *s = field(ZT_PACKET_IDX_SOURCE,ZT_ADDRESS_LENGTH);
|
2013-07-04 20:56:19 +00:00
|
|
|
for(unsigned int i=0;i<ZT_ADDRESS_LENGTH;++i)
|
2013-07-09 18:06:55 +00:00
|
|
|
s[i] = source[i];
|
2013-07-04 20:56:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get this packet's destination
|
|
|
|
*
|
|
|
|
* @return Destination ZT address
|
|
|
|
*/
|
2013-07-29 17:56:20 +00:00
|
|
|
inline Address destination() const { return Address(field(ZT_PACKET_IDX_DEST,ZT_ADDRESS_LENGTH),ZT_ADDRESS_LENGTH); }
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Get this packet's source
|
|
|
|
*
|
|
|
|
* @return Source ZT address
|
|
|
|
*/
|
2013-07-29 17:56:20 +00:00
|
|
|
inline Address source() const { return Address(field(ZT_PACKET_IDX_SOURCE,ZT_ADDRESS_LENGTH),ZT_ADDRESS_LENGTH); }
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @return True if packet is of valid length
|
|
|
|
*/
|
2013-07-09 18:06:55 +00:00
|
|
|
inline bool lengthValid() const { return (size() >= ZT_PROTO_MIN_PACKET_LENGTH); }
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @return True if packet is fragmented (expect fragments)
|
|
|
|
*/
|
2013-08-13 01:25:36 +00:00
|
|
|
inline bool fragmented() const { return (((unsigned char)(*this)[ZT_PACKET_IDX_FLAGS] & ZT_PROTO_FLAG_FRAGMENTED) != 0); }
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Set this packet's fragmented flag
|
|
|
|
*
|
|
|
|
* @param f Fragmented flag value
|
|
|
|
*/
|
|
|
|
inline void setFragmented(bool f)
|
|
|
|
{
|
|
|
|
if (f)
|
2013-07-09 18:06:55 +00:00
|
|
|
(*this)[ZT_PACKET_IDX_FLAGS] |= (char)ZT_PROTO_FLAG_FRAGMENTED;
|
|
|
|
else (*this)[ZT_PACKET_IDX_FLAGS] &= (char)(~ZT_PROTO_FLAG_FRAGMENTED);
|
2013-07-04 20:56:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return True if compressed (result only valid if unencrypted)
|
|
|
|
*/
|
2013-08-13 01:25:36 +00:00
|
|
|
inline bool compressed() const { return (((unsigned char)(*this)[ZT_PACKET_IDX_VERB] & ZT_PROTO_VERB_FLAG_COMPRESSED) != 0); }
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @return ZeroTier forwarding hops (0 to 7)
|
|
|
|
*/
|
2013-07-09 18:06:55 +00:00
|
|
|
inline unsigned int hops() const { return ((unsigned int)(*this)[ZT_PACKET_IDX_FLAGS] & 0x07); }
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Increment this packet's hop count
|
|
|
|
*/
|
|
|
|
inline void incrementHops()
|
|
|
|
{
|
2014-10-02 17:54:34 +00:00
|
|
|
unsigned char &b = (*this)[ZT_PACKET_IDX_FLAGS];
|
|
|
|
b = (b & 0xf8) | ((b + 1) & 0x07);
|
2013-07-04 20:56:19 +00:00
|
|
|
}
|
|
|
|
|
2014-10-02 17:54:34 +00:00
|
|
|
/**
|
|
|
|
* @return Cipher suite selector: 0 - 7 (see #defines)
|
|
|
|
*/
|
2014-10-02 18:08:59 +00:00
|
|
|
inline unsigned int cipher() const
|
|
|
|
{
|
|
|
|
//return (((unsigned int)(*this)[ZT_PACKET_IDX_FLAGS] & 0x38) >> 3);
|
|
|
|
// Use DEPRECATED 0x80 "encrypted" flag -- this will go away once there are no more <1.0.0 peers on the net
|
2014-10-02 18:13:53 +00:00
|
|
|
return (((*this)[ZT_PACKET_IDX_FLAGS] & 0x80) == 0) ? ZT_PROTO_CIPHER_SUITE__C25519_POLY1305_NONE : ZT_PROTO_CIPHER_SUITE__C25519_POLY1305_SALSA2012;
|
2014-10-02 18:08:59 +00:00
|
|
|
}
|
2014-10-02 17:54:34 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Set this packet's cipher suite
|
|
|
|
*
|
|
|
|
* This normally shouldn't be called directly as armor() will set it after
|
|
|
|
* encrypting and MACing the packet.
|
|
|
|
*/
|
|
|
|
inline void setCipher(unsigned int c)
|
|
|
|
{
|
|
|
|
unsigned char &b = (*this)[ZT_PACKET_IDX_FLAGS];
|
2014-10-02 18:08:59 +00:00
|
|
|
b = (b & 0xc7) | (unsigned char)((c << 3) & 0x38);
|
|
|
|
// Set both the new cipher suite spec field and the old DEPRECATED "encrypted" flag as long as there's <1.0.0 peers online
|
|
|
|
if (c == ZT_PROTO_CIPHER_SUITE__C25519_POLY1305_SALSA2012)
|
|
|
|
b |= 0x80;
|
|
|
|
else b &= 0x7f;
|
2014-10-02 17:54:34 +00:00
|
|
|
}
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
/**
|
|
|
|
* Get this packet's unique ID (the IV field interpreted as uint64_t)
|
|
|
|
*
|
|
|
|
* @return Packet ID
|
|
|
|
*/
|
|
|
|
inline uint64_t packetId() const { return at<uint64_t>(ZT_PACKET_IDX_IV); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set packet verb
|
|
|
|
*
|
|
|
|
* This also has the side-effect of clearing any verb flags, such as
|
|
|
|
* compressed, and so must only be done during packet composition.
|
|
|
|
*
|
|
|
|
* @param v New packet verb
|
|
|
|
*/
|
2013-07-09 18:06:55 +00:00
|
|
|
inline void setVerb(Verb v) { (*this)[ZT_PACKET_IDX_VERB] = (char)v; }
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @return Packet verb (not including flag bits)
|
|
|
|
*/
|
2013-07-09 18:06:55 +00:00
|
|
|
inline Verb verb() const { return (Verb)((*this)[ZT_PACKET_IDX_VERB] & 0x1f); }
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @return Length of packet payload
|
|
|
|
*/
|
2013-07-09 18:06:55 +00:00
|
|
|
inline unsigned int payloadLength() const { return ((size() < ZT_PROTO_MIN_PACKET_LENGTH) ? 0 : (size() - ZT_PROTO_MIN_PACKET_LENGTH)); }
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
/**
|
2013-07-09 18:06:55 +00:00
|
|
|
* @return Raw packet payload
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
2013-07-09 18:06:55 +00:00
|
|
|
inline const unsigned char *payload() const
|
|
|
|
{
|
|
|
|
return field(ZT_PACKET_IDX_PAYLOAD,size() - ZT_PACKET_IDX_PAYLOAD);
|
|
|
|
}
|
2013-07-04 20:56:19 +00:00
|
|
|
|
|
|
|
/**
|
2013-09-24 21:35:05 +00:00
|
|
|
* Armor packet for transport
|
2013-07-04 20:56:19 +00:00
|
|
|
*
|
2013-09-24 21:35:05 +00:00
|
|
|
* @param key 32-byte key
|
|
|
|
* @param encryptPayload If true, encrypt packet payload, else just MAC
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
2013-09-24 21:35:05 +00:00
|
|
|
inline void armor(const void *key,bool encryptPayload)
|
2013-07-04 20:56:19 +00:00
|
|
|
{
|
2013-09-24 21:35:05 +00:00
|
|
|
unsigned char mangledKey[32];
|
|
|
|
unsigned char macKey[32];
|
2013-09-16 17:02:10 +00:00
|
|
|
unsigned char mac[16];
|
2013-09-24 21:35:05 +00:00
|
|
|
const unsigned int payloadLen = size() - ZT_PACKET_IDX_VERB;
|
|
|
|
unsigned char *const payload = field(ZT_PACKET_IDX_VERB,payloadLen);
|
|
|
|
|
|
|
|
// Set flag now, since it affects key mangle function
|
2014-10-02 17:54:34 +00:00
|
|
|
setCipher(encryptPayload ? ZT_PROTO_CIPHER_SUITE__C25519_POLY1305_SALSA2012 : ZT_PROTO_CIPHER_SUITE__C25519_POLY1305_NONE);
|
2013-09-24 21:35:05 +00:00
|
|
|
|
2014-10-02 17:54:34 +00:00
|
|
|
_salsa20MangleKey((const unsigned char *)key,mangledKey);
|
2013-10-18 21:39:48 +00:00
|
|
|
Salsa20 s20(mangledKey,256,field(ZT_PACKET_IDX_IV,8),ZT_PROTO_SALSA20_ROUNDS);
|
2013-09-24 21:35:05 +00:00
|
|
|
|
|
|
|
// MAC key is always the first 32 bytes of the Salsa20 key stream
|
2013-09-25 14:55:27 +00:00
|
|
|
// This is the same construction DJB's NaCl library uses
|
|
|
|
s20.encrypt(ZERO_KEY,macKey,sizeof(macKey));
|
2013-09-24 21:35:05 +00:00
|
|
|
|
|
|
|
if (encryptPayload)
|
|
|
|
s20.encrypt(payload,payload,payloadLen);
|
|
|
|
|
|
|
|
Poly1305::compute(mac,payload,payloadLen,macKey);
|
2013-09-16 17:02:10 +00:00
|
|
|
memcpy(field(ZT_PACKET_IDX_MAC,8),mac,8);
|
2013-07-04 20:56:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2013-09-24 21:35:05 +00:00
|
|
|
* Verify and (if encrypted) decrypt packet
|
2013-07-04 20:56:19 +00:00
|
|
|
*
|
2013-09-24 21:35:05 +00:00
|
|
|
* @param key 32-byte key
|
|
|
|
* @return False if packet is invalid or failed MAC authenticity check
|
2013-07-04 20:56:19 +00:00
|
|
|
*/
|
2013-09-24 21:35:05 +00:00
|
|
|
inline bool dearmor(const void *key)
|
2013-07-04 20:56:19 +00:00
|
|
|
{
|
2013-09-24 21:35:05 +00:00
|
|
|
unsigned char mangledKey[32];
|
|
|
|
unsigned char macKey[32];
|
2013-09-16 17:02:10 +00:00
|
|
|
unsigned char mac[16];
|
2013-09-24 21:35:05 +00:00
|
|
|
const unsigned int payloadLen = size() - ZT_PACKET_IDX_VERB;
|
|
|
|
unsigned char *const payload = field(ZT_PACKET_IDX_VERB,payloadLen);
|
2014-10-02 17:54:34 +00:00
|
|
|
unsigned int cs = cipher();
|
2013-07-04 20:56:19 +00:00
|
|
|
|
2014-10-02 17:54:34 +00:00
|
|
|
if ((cs == ZT_PROTO_CIPHER_SUITE__C25519_POLY1305_NONE)||(cs == ZT_PROTO_CIPHER_SUITE__C25519_POLY1305_SALSA2012)) {
|
|
|
|
_salsa20MangleKey((const unsigned char *)key,mangledKey);
|
|
|
|
Salsa20 s20(mangledKey,256,field(ZT_PACKET_IDX_IV,8),ZT_PROTO_SALSA20_ROUNDS);
|
2013-07-04 20:56:19 +00:00
|
|
|
|
2014-10-02 17:54:34 +00:00
|
|
|
s20.encrypt(ZERO_KEY,macKey,sizeof(macKey));
|
|
|
|
Poly1305::compute(mac,payload,payloadLen,macKey);
|
|
|
|
if (!Utils::secureEq(mac,field(ZT_PACKET_IDX_MAC,8),8))
|
|
|
|
return false;
|
2013-09-24 21:35:05 +00:00
|
|
|
|
2014-10-02 18:08:59 +00:00
|
|
|
if (cs == ZT_PROTO_CIPHER_SUITE__C25519_POLY1305_SALSA2012)
|
2014-10-02 17:54:34 +00:00
|
|
|
s20.decrypt(payload,payload,payloadLen);
|
2013-09-24 21:35:05 +00:00
|
|
|
|
2014-10-02 17:54:34 +00:00
|
|
|
return true;
|
|
|
|
} else if (cs == ZT_PROTO_CIPHER_SUITE__C25519_AES256_GCM) {
|
|
|
|
return false; // not implemented yet
|
|
|
|
} else return false; // unrecognized cipher suite
|
2013-07-04 20:56:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Attempt to compress payload if not already (must be unencrypted)
|
|
|
|
*
|
|
|
|
* This requires that the payload at least contain the verb byte already
|
|
|
|
* set. The compressed flag in the verb is set if compression successfully
|
|
|
|
* results in a size reduction. If no size reduction occurs, compression
|
|
|
|
* is not done and the flag is left cleared.
|
|
|
|
*
|
|
|
|
* @return True if compression occurred
|
|
|
|
*/
|
|
|
|
inline bool compress()
|
|
|
|
{
|
|
|
|
unsigned char buf[ZT_PROTO_MAX_PACKET_LENGTH * 2];
|
2013-07-09 18:06:55 +00:00
|
|
|
if ((!compressed())&&(size() > (ZT_PACKET_IDX_PAYLOAD + 32))) {
|
|
|
|
int pl = (int)(size() - ZT_PACKET_IDX_PAYLOAD);
|
|
|
|
int cl = LZ4_compress((const char *)field(ZT_PACKET_IDX_PAYLOAD,(unsigned int)pl),(char *)buf,pl);
|
2013-07-04 20:56:19 +00:00
|
|
|
if ((cl > 0)&&(cl < pl)) {
|
2013-07-09 18:06:55 +00:00
|
|
|
(*this)[ZT_PACKET_IDX_VERB] |= (char)ZT_PROTO_VERB_FLAG_COMPRESSED;
|
|
|
|
setSize((unsigned int)cl + ZT_PACKET_IDX_PAYLOAD);
|
|
|
|
memcpy(field(ZT_PACKET_IDX_PAYLOAD,(unsigned int)cl),buf,cl);
|
2013-07-04 20:56:19 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
2013-07-09 18:06:55 +00:00
|
|
|
(*this)[ZT_PACKET_IDX_VERB] &= (char)(~ZT_PROTO_VERB_FLAG_COMPRESSED);
|
2013-07-04 20:56:19 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Attempt to decompress payload if it is compressed (must be unencrypted)
|
|
|
|
*
|
|
|
|
* If payload is compressed, it is decompressed and the compressed verb
|
|
|
|
* flag is cleared. Otherwise nothing is done and true is returned.
|
|
|
|
*
|
|
|
|
* @return True if data is now decompressed and valid, false on error
|
|
|
|
*/
|
|
|
|
inline bool uncompress()
|
|
|
|
{
|
|
|
|
unsigned char buf[ZT_PROTO_MAX_PACKET_LENGTH];
|
2013-07-09 18:06:55 +00:00
|
|
|
if ((compressed())&&(size() >= ZT_PROTO_MIN_PACKET_LENGTH)) {
|
|
|
|
if (size() > ZT_PACKET_IDX_PAYLOAD) {
|
|
|
|
unsigned int compLen = size() - ZT_PACKET_IDX_PAYLOAD;
|
2014-07-30 22:34:15 +00:00
|
|
|
int ucl = LZ4_decompress_safe((const char *)field(ZT_PACKET_IDX_PAYLOAD,compLen),(char *)buf,compLen,sizeof(buf));
|
2013-07-04 20:56:19 +00:00
|
|
|
if ((ucl > 0)&&(ucl <= (int)(capacity() - ZT_PACKET_IDX_PAYLOAD))) {
|
2013-07-09 18:06:55 +00:00
|
|
|
setSize((unsigned int)ucl + ZT_PACKET_IDX_PAYLOAD);
|
|
|
|
memcpy(field(ZT_PACKET_IDX_PAYLOAD,(unsigned int)ucl),buf,ucl);
|
2013-07-04 20:56:19 +00:00
|
|
|
} else return false;
|
|
|
|
}
|
2013-09-24 21:35:05 +00:00
|
|
|
(*this)[ZT_PACKET_IDX_VERB] &= (char)(~ZT_PROTO_VERB_FLAG_COMPRESSED);
|
2013-07-04 20:56:19 +00:00
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
2013-09-25 14:55:27 +00:00
|
|
|
static const unsigned char ZERO_KEY[32];
|
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
/**
|
2013-09-16 17:02:10 +00:00
|
|
|
* Deterministically mangle a 256-bit crypto key based on packet
|
2013-07-04 20:56:19 +00:00
|
|
|
*
|
2014-10-02 17:54:34 +00:00
|
|
|
* This uses extra data from the packet to mangle the secret, giving us an
|
|
|
|
* effective IV that is somewhat more than 64 bits. This is "free" for
|
|
|
|
* Salsa20 since it has negligible key setup time so using a different
|
|
|
|
* key each time is fine.
|
|
|
|
*
|
2013-07-04 20:56:19 +00:00
|
|
|
* @param in Input key (32 bytes)
|
|
|
|
* @param out Output buffer (32 bytes)
|
|
|
|
*/
|
2014-10-02 17:54:34 +00:00
|
|
|
inline void _salsa20MangleKey(const unsigned char *in,unsigned char *out) const
|
2013-07-04 20:56:19 +00:00
|
|
|
{
|
2014-10-02 17:54:34 +00:00
|
|
|
const unsigned char *d = (const unsigned char *)data();
|
|
|
|
|
2013-09-24 21:35:05 +00:00
|
|
|
// IV and source/destination addresses. Using the addresses divides the
|
|
|
|
// key space into two halves-- A->B and B->A (since order will change).
|
2013-07-04 20:56:19 +00:00
|
|
|
for(unsigned int i=0;i<18;++i) // 8 + (ZT_ADDRESS_LENGTH * 2) == 18
|
2014-10-02 17:54:34 +00:00
|
|
|
out[i] = in[i] ^ d[i];
|
2013-09-16 17:02:10 +00:00
|
|
|
|
|
|
|
// Flags, but with hop count masked off. Hop count is altered by forwarding
|
|
|
|
// nodes. It's one of the only parts of a packet modifiable by people
|
|
|
|
// without the key.
|
2014-10-02 17:54:34 +00:00
|
|
|
out[18] = in[18] ^ (d[ZT_PACKET_IDX_FLAGS] & 0xf8);
|
2013-09-16 17:02:10 +00:00
|
|
|
|
|
|
|
// Raw packet size in bytes -- thus each packet size defines a new
|
|
|
|
// key space.
|
2013-07-09 18:06:55 +00:00
|
|
|
out[19] = in[19] ^ (unsigned char)(size() & 0xff);
|
|
|
|
out[20] = in[20] ^ (unsigned char)((size() >> 8) & 0xff); // little endian
|
2013-09-16 17:02:10 +00:00
|
|
|
|
2013-07-04 20:56:19 +00:00
|
|
|
// Rest of raw key is used unchanged
|
|
|
|
for(unsigned int i=21;i<32;++i)
|
|
|
|
out[i] = in[i];
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace ZeroTier
|
|
|
|
|
|
|
|
#endif
|