You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
243 lines
7.0 KiB
243 lines
7.0 KiB
/* |
|
* 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
|
|
|