mirror of
https://github.com/zerotier/ZeroTierOne.git
synced 2024-12-19 13:07:55 +00:00
317 lines
9.0 KiB
C++
317 lines
9.0 KiB
C++
/*
|
|
* ZeroTier One - Global Peer to Peer Ethernet
|
|
* Copyright (C) 2012-2013 ZeroTier Networks LLC
|
|
*
|
|
* 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/
|
|
*/
|
|
|
|
#ifndef ZT_IDENTITY_HPP
|
|
#define ZT_IDENTITY_HPP
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string>
|
|
|
|
#include "Constants.hpp"
|
|
#include "Array.hpp"
|
|
#include "Utils.hpp"
|
|
#include "Address.hpp"
|
|
#include "C25519.hpp"
|
|
#include "Buffer.hpp"
|
|
|
|
#define ZT_IDENTITY_MAX_BINARY_SERIALIZED_LENGTH (ZT_ADDRESS_LENGTH + 1 + ZT_C25519_PUBLIC_KEY_LEN + 1 + ZT_C25519_PRIVATE_KEY_LEN)
|
|
|
|
namespace ZeroTier {
|
|
|
|
/**
|
|
* A ZeroTier identity
|
|
*
|
|
* An identity consists of a public key, a 40-bit ZeroTier address computed
|
|
* from that key in a collision-resistant fashion, and a self-signature.
|
|
*
|
|
* The address derivation algorithm makes it computationally very expensive to
|
|
* search for a different public key that duplicates an existing address. (See
|
|
* code for deriveAddress() for this algorithm.)
|
|
*/
|
|
class Identity
|
|
{
|
|
public:
|
|
/**
|
|
* Identity types
|
|
*/
|
|
enum Type
|
|
{
|
|
IDENTITY_TYPE_C25519 = 0
|
|
};
|
|
|
|
Identity() :
|
|
_privateKey((C25519::Private *)0)
|
|
{
|
|
}
|
|
|
|
Identity(const Identity &id) :
|
|
_address(id._address),
|
|
_publicKey(id._publicKey),
|
|
_privateKey((id._privateKey) ? new C25519::Private(*(id._privateKey)) : (C25519::Private *)0)
|
|
{
|
|
}
|
|
|
|
Identity(const char *str)
|
|
throw(std::invalid_argument) :
|
|
_privateKey((C25519::Private *)0)
|
|
{
|
|
if (!fromString(str))
|
|
throw std::invalid_argument(std::string("invalid string-serialized identity: ") + str);
|
|
}
|
|
|
|
Identity(const std::string &str)
|
|
throw(std::invalid_argument) :
|
|
_privateKey((C25519::Private *)0)
|
|
{
|
|
if (!fromString(str))
|
|
throw std::invalid_argument(std::string("invalid string-serialized identity: ") + str);
|
|
}
|
|
|
|
template<unsigned int C>
|
|
Identity(const Buffer<C> &b,unsigned int startAt = 0)
|
|
throw(std::out_of_range,std::invalid_argument) :
|
|
_privateKey((C25519::Private *)0)
|
|
{
|
|
deserialize(b,startAt);
|
|
}
|
|
|
|
~Identity()
|
|
{
|
|
delete _privateKey;
|
|
}
|
|
|
|
inline Identity &operator=(const Identity &id)
|
|
{
|
|
_address = id._address;
|
|
_publicKey = id._publicKey;
|
|
if (id._privateKey) {
|
|
if (!_privateKey)
|
|
_privateKey = new C25519::Private();
|
|
*_privateKey = *(id._privateKey);
|
|
} else {
|
|
delete _privateKey;
|
|
_privateKey = (C25519::Private *)0;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
/**
|
|
* Generate a new identity (address, key pair)
|
|
*
|
|
* This is a time consuming operation.
|
|
*/
|
|
void generate();
|
|
|
|
/**
|
|
* Check the validity of this identity's pairing of key to address
|
|
*
|
|
* @return True if validation check passes
|
|
*/
|
|
bool locallyValidate() const;
|
|
|
|
/**
|
|
* @return True if this identity contains a private key
|
|
*/
|
|
inline bool hasPrivate() const throw() { return (_privateKey != (C25519::Private *)0); }
|
|
|
|
/**
|
|
* Sign a message with this identity (private key required)
|
|
*
|
|
* @param data Data to sign
|
|
* @param len Length of data
|
|
*/
|
|
inline C25519::Signature sign(const void *data,unsigned int len) const
|
|
throw(std::runtime_error)
|
|
{
|
|
if (_privateKey)
|
|
return C25519::sign(*_privateKey,_publicKey,data,len);
|
|
throw std::runtime_error("sign() requires a private key");
|
|
}
|
|
|
|
/**
|
|
* Verify a message signature against this identity
|
|
*
|
|
* @param data Data to check
|
|
* @param len Length of data
|
|
* @param signature Signature bytes
|
|
* @param siglen Length of signature in bytes
|
|
* @return True if signature validates and data integrity checks
|
|
*/
|
|
inline bool verify(const void *data,unsigned int len,const void *signature,unsigned int siglen) const
|
|
{
|
|
if (siglen != ZT_C25519_SIGNATURE_LEN)
|
|
return false;
|
|
return C25519::verify(_publicKey,data,len,signature);
|
|
}
|
|
|
|
/**
|
|
* Verify a message signature against this identity
|
|
*
|
|
* @param data Data to check
|
|
* @param len Length of data
|
|
* @param signature Signature
|
|
* @return True if signature validates and data integrity checks
|
|
*/
|
|
inline bool verify(const void *data,unsigned int len,const C25519::Signature &signature) const
|
|
{
|
|
return C25519::verify(_publicKey,data,len,signature);
|
|
}
|
|
|
|
/**
|
|
* Shortcut method to perform key agreement with another identity
|
|
*
|
|
* This identity must have a private key. (Check hasPrivate())
|
|
*
|
|
* @param id Identity to agree with
|
|
* @param key Result parameter to fill with key bytes
|
|
* @param klen Length of key in bytes
|
|
* @return Was agreement successful?
|
|
*/
|
|
inline bool agree(const Identity &id,void *key,unsigned int klen) const
|
|
{
|
|
if (_privateKey) {
|
|
C25519::agree(*_privateKey,id._publicKey,key,klen);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @return Identity type
|
|
*/
|
|
inline Type type() const throw() { return IDENTITY_TYPE_C25519; }
|
|
|
|
/**
|
|
* @return This identity's address
|
|
*/
|
|
inline const Address &address() const throw() { return _address; }
|
|
|
|
/**
|
|
* Serialize this identity (binary)
|
|
*
|
|
* @param b Destination buffer to append to
|
|
* @param includePrivate If true, include private key component (if present) (default: false)
|
|
* @throws std::out_of_range Buffer too small
|
|
*/
|
|
template<unsigned int C>
|
|
inline void serialize(Buffer<C> &b,bool includePrivate = false) const
|
|
throw(std::out_of_range)
|
|
{
|
|
_address.appendTo(b);
|
|
b.append((unsigned char)IDENTITY_TYPE_C25519);
|
|
b.append(_publicKey.data,_publicKey.size());
|
|
if ((_privateKey)&&(includePrivate)) {
|
|
b.append((unsigned char)_privateKey->size());
|
|
b.append(_privateKey->data,_privateKey->size());
|
|
} else b.append((unsigned char)0);
|
|
}
|
|
|
|
/**
|
|
* Deserialize a binary serialized identity
|
|
*
|
|
* If an exception is thrown, the Identity object is left in an undefined
|
|
* state and should not be used.
|
|
*
|
|
* @param b Buffer containing serialized data
|
|
* @param startAt Index within buffer of serialized data (default: 0)
|
|
* @return Length of serialized data read from buffer
|
|
* @throws std::out_of_range Serialized data invalid
|
|
* @throws std::invalid_argument Serialized data invalid
|
|
*/
|
|
template<unsigned int C>
|
|
inline unsigned int deserialize(const Buffer<C> &b,unsigned int startAt = 0)
|
|
throw(std::out_of_range,std::invalid_argument)
|
|
{
|
|
delete _privateKey;
|
|
_privateKey = (C25519::Private *)0;
|
|
|
|
unsigned int p = startAt;
|
|
|
|
_address.setTo(b.field(p,ZT_ADDRESS_LENGTH),ZT_ADDRESS_LENGTH);
|
|
p += ZT_ADDRESS_LENGTH;
|
|
|
|
if (b[p++] != IDENTITY_TYPE_C25519)
|
|
throw std::invalid_argument("unsupported identity type");
|
|
|
|
memcpy(_publicKey.data,b.field(p,_publicKey.size()),_publicKey.size());
|
|
p += _publicKey.size();
|
|
|
|
unsigned int privateKeyLength = (unsigned int)b[p++];
|
|
if (privateKeyLength) {
|
|
if (privateKeyLength != ZT_C25519_PRIVATE_KEY_LEN)
|
|
throw std::invalid_argument("invalid private key");
|
|
_privateKey = new C25519::Private();
|
|
memcpy(_privateKey->data,b.field(p,ZT_C25519_PRIVATE_KEY_LEN),ZT_C25519_PRIVATE_KEY_LEN);
|
|
p += ZT_C25519_PRIVATE_KEY_LEN;
|
|
}
|
|
|
|
return (p - startAt);
|
|
}
|
|
|
|
/**
|
|
* Serialize to a more human-friendly string
|
|
*
|
|
* @param includePrivate If true, include private key (if it exists)
|
|
* @return ASCII string representation of identity
|
|
*/
|
|
std::string toString(bool includePrivate) const;
|
|
|
|
/**
|
|
* Deserialize a human-friendly string
|
|
*
|
|
* Note: validation is for the format only. The locallyValidate() method
|
|
* must be used to check signature and address/key correspondence.
|
|
*
|
|
* @param str String to deserialize
|
|
* @return True if deserialization appears successful
|
|
*/
|
|
bool fromString(const char *str);
|
|
inline bool fromString(const std::string &str) { return fromString(str.c_str()); }
|
|
|
|
/**
|
|
* @return True if this identity contains something
|
|
*/
|
|
inline operator bool() const throw() { return (_address); }
|
|
|
|
inline bool operator==(const Identity &id) const throw() { return ((_address == id._address)&&(_publicKey == id._publicKey)); }
|
|
inline bool operator<(const Identity &id) const throw() { return ((_address < id._address)||((_address == id._address)&&(_publicKey < id._publicKey))); }
|
|
inline bool operator!=(const Identity &id) const throw() { return !(*this == id); }
|
|
inline bool operator>(const Identity &id) const throw() { return (id < *this); }
|
|
inline bool operator<=(const Identity &id) const throw() { return !(id < *this); }
|
|
inline bool operator>=(const Identity &id) const throw() { return !(*this < id); }
|
|
|
|
private:
|
|
Address _address;
|
|
C25519::Public _publicKey;
|
|
C25519::Private *_privateKey;
|
|
};
|
|
|
|
} // namespace ZeroTier
|
|
|
|
#endif
|