mirror of
https://github.com/zerotier/ZeroTierOne.git
synced 2024-12-19 04:57:53 +00:00
244 lines
7.0 KiB
C++
244 lines
7.0 KiB
C++
/*
|
|
* ZeroTier One - Network Virtualization Everywhere
|
|
* Copyright (C) 2011-2017 ZeroTier, Inc. https://www.zerotier.com/
|
|
*
|
|
* 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/>.
|
|
*
|
|
* --
|
|
*
|
|
* You can be released from the requirements of the license by purchasing
|
|
* a commercial license. Buying such a license is mandatory as soon as you
|
|
* develop commercial closed-source software that incorporates or links
|
|
* directly against ZeroTier software without disclosing the source code
|
|
* of your own application.
|
|
*/
|
|
|
|
#include "DBM.hpp"
|
|
|
|
#include "../version.h"
|
|
|
|
#include "../node/Salsa20.hpp"
|
|
#include "../node/Poly1305.hpp"
|
|
#include "../node/SHA512.hpp"
|
|
|
|
#include "../osdep/OSUtils.hpp"
|
|
|
|
#define ZT_STORED_OBJECT_TYPE__CLUSTER_NODE_STATUS (ZT_STORED_OBJECT__MAX_TYPE_ID + 1)
|
|
#define ZT_STORED_OBJECT_TYPE__CLUSTER_DEFINITION (ZT_STORED_OBJECT__MAX_TYPE_ID + 2)
|
|
|
|
namespace ZeroTier {
|
|
|
|
// We generate the cluster ID from our address and version info since this is
|
|
// not at all designed to allow interoperation between versions (or endians)
|
|
// in the same cluster.
|
|
static inline uint64_t _mkClusterId(const Address &myAddress)
|
|
{
|
|
uint64_t x = ZEROTIER_ONE_VERSION_MAJOR;
|
|
x <<= 8;
|
|
x += ZEROTIER_ONE_VERSION_MINOR;
|
|
x <<= 8;
|
|
x += ZEROTIER_ONE_VERSION_REVISION;
|
|
x <<= 40;
|
|
x ^= myAddress.toInt();
|
|
#if __BYTE_ORDER == __BIG_ENDIAN
|
|
++x;
|
|
#endif;
|
|
return x;
|
|
}
|
|
|
|
void DBM::onUpdate(uint64_t from,const _MapKey &k,const _MapValue &v,uint64_t rev)
|
|
{
|
|
char p[4096];
|
|
char tmp[ZT_DBM_MAX_VALUE_SIZE];
|
|
if (_persistentPath((ZT_StoredObjectType)k.type,k.key,p,sizeof(p))) {
|
|
// Reduce unnecessary disk writes
|
|
FILE *f = fopen(p,"r");
|
|
if (f) {
|
|
long n = (long)fread(tmp,1,sizeof(tmp),f);
|
|
fclose(f);
|
|
if ((n == (long)v.len)&&(!memcmp(v.data,tmp,n)))
|
|
return;
|
|
}
|
|
|
|
// Write to disk if file has changed or was not already present
|
|
f = fopen(p,"w");
|
|
if (f) {
|
|
if (fwrite(data,len,1,f) != 1)
|
|
fprintf(stderr,"WARNING: error writing to %s (I/O error)" ZT_EOL_S,p);
|
|
fclose(f);
|
|
if (type == ZT_STORED_OBJECT_IDENTITY_SECRET)
|
|
OSUtils::lockDownFile(p,false);
|
|
} else {
|
|
fprintf(stderr,"WARNING: error writing to %s (cannot open)" ZT_EOL_S,p);
|
|
}
|
|
}
|
|
}
|
|
|
|
void DBM::onDelete(uint64_t from,const _MapKey &k)
|
|
{
|
|
char p[4096];
|
|
if (_persistentPath((ZT_StoredObjectType)k.type,k.key,p,sizeof(p)))
|
|
OSUtils::rm(p);
|
|
}
|
|
|
|
DBM::_vsdm_cryptor::_vsdm_cryptor(const Identity &secretIdentity)
|
|
{
|
|
uint8_t s512[64];
|
|
SHA512::hash(h512,secretIdentity.privateKeyPair().priv.data,ZT_C25519_PRIVATE_KEY_LEN);
|
|
memcpy(_key,s512,sizeof(_key));
|
|
}
|
|
|
|
void DBM::_vsdm_cryptor::encrypt(void *d,unsigned long l)
|
|
{
|
|
if (l >= 24) { // sanity check
|
|
uint8_t key[32];
|
|
uint8_t authKey[32];
|
|
uint8_t auth[16];
|
|
|
|
uint8_t *const iv = reinterpret_cast<uint8_t *>(d) + (l - 16);
|
|
Utils::getSecureRandom(iv,16);
|
|
memcpy(key,_key,32);
|
|
for(unsigned long i=0;i<8;++i)
|
|
_key[i] ^= iv[i];
|
|
|
|
Salsa20 s20(key,iv + 8);
|
|
memset(authKey,0,32);
|
|
s20.crypt12(authKey,authKey,32);
|
|
s20.crypt12(d,d,l - 24);
|
|
|
|
Poly1305::compute(auth,d,l - 24,authKey);
|
|
memcpy(reinterpret_cast<uint8_t *>(d) + (l - 24),auth,8);
|
|
}
|
|
}
|
|
|
|
bool DBM::_vsdm_cryptor::decrypt(void *d,unsigned long l)
|
|
{
|
|
if (l >= 24) { // sanity check
|
|
uint8_t key[32];
|
|
uint8_t authKey[32];
|
|
uint8_t auth[16];
|
|
|
|
uint8_t *const iv = reinterpret_cast<uint8_t *>(d) + (l - 16);
|
|
memcpy(key,_key,32);
|
|
for(unsigned long i=0;i<8;++i)
|
|
_key[i] ^= iv[i];
|
|
|
|
Salsa20 s20(key,iv + 8);
|
|
memset(authKey,0,32);
|
|
s20.crypt12(authKey,authKey,32);
|
|
|
|
Poly1305::compute(auth,d,l - 24,authKey);
|
|
if (!Utils::secureEq(reinterpret_cast<uint8_t *>(d) + (l - 24),auth,8))
|
|
return false;
|
|
|
|
s20.crypt12(d,d,l - 24);
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
DBM::DBM(const Identity &secretIdentity,uint64_t clusterMemberId,const std::string &basePath,Node *node) :
|
|
_basePath(basePath),
|
|
_node(node),
|
|
_startTime(OSUtils::now()),
|
|
_m(_mkClusterId(secretIdentity.address()),clusterMemberId,false,_vsdm_cryptor(secretIdentity),_vsdm_watcher(this))
|
|
{
|
|
}
|
|
|
|
DBM::~DBM()
|
|
{
|
|
}
|
|
|
|
void DBM::put(const ZT_StoredObjectType type,const uint64_t key,const void *data,unsigned int len)
|
|
{
|
|
char p[4096];
|
|
if (_m.put(_MapKey(key,(uint16_t)type),Value(OSUtils::now(),(uint16_t)len,data))) {
|
|
if (_persistentPath(type,key,p,sizeof(p))) {
|
|
FILE *f = fopen(p,"w");
|
|
if (f) {
|
|
if (fwrite(data,len,1,f) != 1)
|
|
fprintf(stderr,"WARNING: error writing to %s (I/O error)" ZT_EOL_S,p);
|
|
fclose(f);
|
|
if (type == ZT_STORED_OBJECT_IDENTITY_SECRET)
|
|
OSUtils::lockDownFile(p,false);
|
|
} else {
|
|
fprintf(stderr,"WARNING: error writing to %s (cannot open)" ZT_EOL_S,p);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool DBM::get(const ZT_StoredObjectType type,const uint64_t key,Value &value)
|
|
{
|
|
char p[4096];
|
|
if (_m.get(_MapKey(key,(uint16_t)type),value))
|
|
return true;
|
|
if (_persistentPath(type,key,p,sizeof(p))) {
|
|
FILE *f = fopen(p,"r");
|
|
if (f) {
|
|
long n = (long)fread(value.data,1,sizeof(value.data),f);
|
|
value.len = (n > 0) ? (uint16_t)n : (uint16_t)0;
|
|
fclose(f);
|
|
value.ts = OSUtils::getLastModified(p);
|
|
_m.put(_MapKey(key,(uint16_t)type),value);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void DBM::del(const ZT_StoredObjectType type,const uint64_t key)
|
|
{
|
|
char p[4096];
|
|
_m.del(_MapKey(key,(uint16_t)type));
|
|
if (_persistentPath(type,key,p,sizeof(p)))
|
|
OSUtils::rm(p);
|
|
}
|
|
|
|
void DBM::clean()
|
|
{
|
|
}
|
|
|
|
bool DBM::_persistentPath(const ZT_StoredObjectType type,const uint64_t key,char *p,unsigned int maxlen)
|
|
{
|
|
switch(type) {
|
|
case ZT_STORED_OBJECT_IDENTITY_PUBLIC:
|
|
Utils::snprintf(p,maxlen,"%s" ZT_PATH_SEPARATOR_S "identity.public",_basePath.c_str());
|
|
return true;
|
|
case ZT_STORED_OBJECT_IDENTITY_SECRET:
|
|
Utils::snprintf(p,maxlen,"%s" ZT_PATH_SEPARATOR_S "identity.secret",_basePath.c_str());
|
|
return true;
|
|
case ZT_STORED_OBJECT_IDENTITY:
|
|
Utils::snprintf(p,maxlen,"%s" ZT_PATH_SEPARATOR_S "iddb.d" ZT_PATH_SEPARATOR_S "%.10llx",_basePath.c_str(),key);
|
|
return true;
|
|
case ZT_STORED_OBJECT_NETWORK_CONFIG:
|
|
Utils::snprintf(p,maxlen,"%s" ZT_PATH_SEPARATOR_S "networks.d" ZT_PATH_SEPARATOR_S "%.16llx.conf",_basePath.c_str(),key);
|
|
return true;
|
|
case ZT_STORED_OBJECT_PLANET:
|
|
Utils::snprintf(p,maxlen,"%s" ZT_PATH_SEPARATOR_S "planet",_basePath.c_str());
|
|
return true;
|
|
case ZT_STORED_OBJECT_MOON:
|
|
Utils::snprintf(p,maxlen,"%s" ZT_PATH_SEPARATOR_S "moons.d" ZT_PATH_SEPARATOR_S "%.16llx.moon",_basePath.c_str(),key);
|
|
return true;
|
|
case (ZT_StoredObjectType)ZT_STORED_OBJECT_TYPE__CLUSTER_DEFINITION:
|
|
Utils::snprintf(p,maxlen,"%s" ZT_PATH_SEPARATOR_S "cluster",_basePath.c_str());
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
} // namespace ZeroTier
|