src/keyDerivation.cpp

   1 /*
   2  *  anytun
   3  *
   4  *  The secure anycast tunneling protocol (satp) defines a protocol used
   5  *  for communication between any combination of unicast and anycast
   6  *  tunnel endpoints.  It has less protocol overhead than IPSec in Tunnel
   7  *  mode and allows tunneling of every ETHER TYPE protocol (e.g.
   8  *  ethernet, ip, arp ...). satp directly includes cryptography and
   9  *  message authentication based on the methodes used by SRTP.  It is
  10  *  intended to deliver a generic, scaleable and secure solution for
  11  *  tunneling and relaying of packets of any protocol.
  12  *
  13  *
  14  *  Copyright (C) 2007-2009 Othmar Gsenger, Erwin Nindl,
  15  *                          Christian Pointner <satp@wirdorange.org>
  16  *
  17  *  This file is part of Anytun.
  18  *
  19  *  Anytun is free software: you can redistribute it and/or modify
  20  *  it under the terms of the GNU General Public License as published by
  21  *  the Free Software Foundation, either version 3 of the License, or
  22  *  any later version.
  23  *
  24  *  Anytun is distributed in the hope that it will be useful,
  25  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  26  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27  *  GNU General Public License for more details.
  28  *
  29  *  You should have received a copy of the GNU General Public License
  30  *  along with anytun.  If not, see <http://www.gnu.org/licenses/>.
  31  */
  32
  33
  34 #include "log.h"
  35 #include "anytunError.h"
  36 #include "keyDerivation.h"
  37 #include "threadUtils.hpp"
  38 #include "datatypes.h"
  39 #include "endian.h"
  40
  41 #include <stdexcept>
  42 #include <iostream>
  43 #include <sstream>
  44 #include <string>
  45 #include <cstring>
  46
  47 #ifndef NO_CRYPT
  48 #ifndef NO_PASSPHRASE
  49 #ifdef USE_SSL_CRYPTO
  50 #include <openssl/sha.h>
  51 #endif
  52 #endif
  53 #endif
  54
  55 void KeyDerivation::setRole(const role_t role)
  56 {
  57   WritersLock lock(mutex_);
  58   role_ = role;
  59   cLog.msg(Log::PRIO_NOTICE) << "KeyDerivation: using role " << role_;
  60 }
  61
  62 #ifndef NO_CRYPT
  63 #ifndef NO_PASSPHRASE
  64 void KeyDerivation::calcMasterKey(std::string passphrase, u_int16_t length)
  65 {
  66   cLog.msg(Log::PRIO_NOTICE) << "KeyDerivation: calculating master key from passphrase";
  67   if(!length) {
  68     cLog.msg(Log::PRIO_ERROR) << "KeyDerivation: bad master key length";
  69     return;
  70   }
  71
  72 #ifndef USE_SSL_CRYPTO
  73   if(length > gcry_md_get_algo_dlen(GCRY_MD_SHA256)) {
  74 #else
  75   if(length > SHA256_DIGEST_LENGTH) {
  76 #endif
  77     cLog.msg(Log::PRIO_ERROR) << "KeyDerivation: master key too long for passphrase algorithm";
  78     return;
  79   }
  80
  81 #ifndef USE_SSL_CRYPTO
  82   Buffer digest(static_cast<u_int32_t>(gcry_md_get_algo_dlen(GCRY_MD_SHA256)));
  83   gcry_md_hash_buffer(GCRY_MD_SHA256, digest.getBuf(), passphrase.c_str(), passphrase.length());
  84 #else
  85   Buffer digest(u_int32_t(SHA256_DIGEST_LENGTH));
  86   SHA256(reinterpret_cast<const unsigned char*>(passphrase.c_str()), passphrase.length(), digest.getBuf());
  87 #endif
  88   master_key_.setLength(length);
  89
  90   std::memcpy(master_key_.getBuf(), &digest.getBuf()[digest.getLength() - master_key_.getLength()], master_key_.getLength());
  91 }
  92
  93 void KeyDerivation::calcMasterSalt(std::string passphrase, u_int16_t length)
  94 {
  95   cLog.msg(Log::PRIO_NOTICE) << "KeyDerivation: calculating master salt from passphrase";
  96   if(!length) {
  97     cLog.msg(Log::PRIO_ERROR) << "KeyDerivation: bad master salt length";
  98     return;
  99   }
 100
 101 #ifndef USE_SSL_CRYPTO
 102   if(length > gcry_md_get_algo_dlen(GCRY_MD_SHA1)) {
 103 #else
 104   if(length > SHA_DIGEST_LENGTH) {
 105 #endif
 106     cLog.msg(Log::PRIO_ERROR) << "KeyDerivation: master key too long for passphrase algorithm";
 107     return;
 108   }
 109
 110 #ifndef USE_SSL_CRYPTO
 111   Buffer digest(static_cast<u_int32_t>(gcry_md_get_algo_dlen(GCRY_MD_SHA1)));
 112   gcry_md_hash_buffer(GCRY_MD_SHA1, digest.getBuf(), passphrase.c_str(), passphrase.length());
 113 #else
 114   Buffer digest(u_int32_t(SHA_DIGEST_LENGTH));
 115   SHA1(reinterpret_cast<const unsigned char*>(passphrase.c_str()), passphrase.length(), digest.getBuf());
 116 #endif
 117   master_salt_.setLength(length);
 118
 119   std::memcpy(master_salt_.getBuf(), &digest.getBuf()[digest.getLength() - master_salt_.getLength()], master_salt_.getLength());
 120 }
 121 #endif
 122 #endif
 123
 124 satp_prf_label_t KeyDerivation::convertLabel(kd_dir_t dir, satp_prf_label_t label)
 125 {
 126   switch(label) {
 127   case LABEL_ENC: {
 128     if(dir == KD_OUTBOUND) {
 129       if(role_ == ROLE_LEFT) return LABEL_LEFT_ENC;
 130       if(role_ == ROLE_RIGHT) return LABEL_RIGHT_ENC;
 131     }
 132     else {
 133       if(role_ == ROLE_LEFT) return LABEL_RIGHT_ENC;
 134       if(role_ == ROLE_RIGHT) return LABEL_LEFT_ENC;
 135     }
 136     break;
 137   }
 138   case LABEL_SALT: {
 139     if(dir == KD_OUTBOUND) {
 140       if(role_ == ROLE_LEFT) return LABEL_LEFT_SALT;
 141       if(role_ == ROLE_RIGHT) return LABEL_RIGHT_SALT;
 142     }
 143     else {
 144       if(role_ == ROLE_LEFT) return LABEL_RIGHT_SALT;
 145       if(role_ == ROLE_RIGHT) return LABEL_LEFT_SALT;
 146     }
 147     break;
 148   }
 149   case LABEL_AUTH: {
 150     if(dir == KD_OUTBOUND) {
 151       if(role_ == ROLE_LEFT) return LABEL_LEFT_AUTH;
 152       if(role_ == ROLE_RIGHT) return LABEL_RIGHT_AUTH;
 153     }
 154     else {
 155       if(role_ == ROLE_LEFT) return LABEL_RIGHT_AUTH;
 156       if(role_ == ROLE_RIGHT) return LABEL_LEFT_AUTH;
 157     }
 158     break;
 159   }
 160   }
 161
 162   return label;
 163 }
 164
 165 //****** NullKeyDerivation ******
 166
 167 bool NullKeyDerivation::generate(kd_dir_t dir, satp_prf_label_t label, seq_nr_t seq_nr, Buffer& key)
 168 {
 169   std::memset(key.getBuf(), 0, key.getLength());
 170   return true;
 171 }
 172
 173 #ifndef NO_CRYPT
 174 //****** AesIcmKeyDerivation ******
 175
 176 AesIcmKeyDerivation::AesIcmKeyDerivation() : KeyDerivation(DEFAULT_KEY_LENGTH)
 177 {
 178 #ifndef USE_SSL_CRYPTO
 179   for(int i=0; i<2; i++)
 180     handle_[i] = NULL;
 181 #endif
 182 }
 183
 184 AesIcmKeyDerivation::AesIcmKeyDerivation(u_int16_t key_length) : KeyDerivation(key_length)
 185 {
 186 #ifndef USE_SSL_CRYPTO
 187   for(int i=0; i<2; i++)
 188     handle_[i] = NULL;
 189 #endif
 190 }
 191
 192 AesIcmKeyDerivation::~AesIcmKeyDerivation()
 193 {
 194   WritersLock lock(mutex_);
 195 #ifndef USE_SSL_CRYPTO
 196   for(int i=0; i<2; i++)
 197     if(handle_[i])
 198       gcry_cipher_close(handle_[i]);
 199 #endif
 200 }
 201
 202 void AesIcmKeyDerivation::init(Buffer key, Buffer salt, std::string passphrase)
 203 {
 204   WritersLock lock(mutex_);
 205
 206   is_initialized_ = false;
 207 #ifndef NO_PASSPHRASE
 208   if(passphrase != "" && !key.getLength())
 209     calcMasterKey(passphrase, key_length_/8);
 210   else
 211     master_key_ = SyncBuffer(key);
 212
 213   if(passphrase != "" && !salt.getLength())
 214     calcMasterSalt(passphrase, SALT_LENGTH);
 215   else
 216     master_salt_ = SyncBuffer(salt);
 217 #else
 218   master_key_ = SyncBuffer(key);
 219   master_salt_ = SyncBuffer(salt);
 220 #endif
 221
 222   updateMasterKey();
 223 }
 224
 225 void AesIcmKeyDerivation::updateMasterKey()
 226 {
 227   if(master_key_.getLength()*8 != key_length_) {
 228     cLog.msg(Log::PRIO_ERROR) << "KeyDerivation::updateMasterKey: key lengths don't match";
 229     return;
 230   }
 231
 232   if(master_salt_.getLength() != SALT_LENGTH) {
 233     cLog.msg(Log::PRIO_ERROR) << "KeyDerivation::updateMasterKey: salt lengths don't match";
 234     return;
 235   }
 236
 237 #ifndef USE_SSL_CRYPTO
 238   int algo;
 239   switch(key_length_) {
 240   case 128: algo = GCRY_CIPHER_AES128; break;
 241   case 192: algo = GCRY_CIPHER_AES192; break;
 242   case 256: algo = GCRY_CIPHER_AES256; break;
 243   default: {
 244     cLog.msg(Log::PRIO_ERROR) << "KeyDerivation::updateMasterKey: cipher key length of " << key_length_ << " Bits is not supported";
 245     return;
 246   }
 247   }
 248
 249   for(int i=0; i<2; i++) {
 250     if(handle_[i])
 251       gcry_cipher_close(handle_[i]);
 252
 253     gcry_error_t err = gcry_cipher_open(&handle_[i], algo, GCRY_CIPHER_MODE_CTR, 0);
 254     if(err) {
 255       cLog.msg(Log::PRIO_ERROR) << "KeyDerivation::updateMasterKey: Failed to open cipher: " << AnytunGpgError(err);
 256       return;
 257     }
 258
 259     err = gcry_cipher_setkey(handle_[i], master_key_.getBuf(), master_key_.getLength());
 260     if(err) {
 261       cLog.msg(Log::PRIO_ERROR) << "KeyDerivation::updateMasterKey: Failed to set cipher key: " << AnytunGpgError(err);
 262       return;
 263     }
 264   }
 265 #else
 266   for(int i=0; i<2; i++) {
 267     int ret = AES_set_encrypt_key(master_key_.getBuf(), master_key_.getLength()*8, &aes_key_[i]);
 268     if(ret) {
 269       cLog.msg(Log::PRIO_ERROR) << "KeyDerivation::updateMasterKey: Failed to set ssl key (code: " << ret << ")";
 270       return;
 271     }
 272   }
 273 #endif
 274   is_initialized_ = true;
 275 }
 276
 277 std::string AesIcmKeyDerivation::printType()
 278 {
 279   ReadersLock lock(mutex_);
 280
 281   std::stringstream sstr;
 282   sstr << "AesIcm" << key_length_ << "KeyDerivation";
 283   return sstr.str();
 284 }
 285
 286 bool AesIcmKeyDerivation::calcCtr(kd_dir_t dir, satp_prf_label_t label, seq_nr_t seq_nr)
 287 {
 288   if(master_salt_.getLength() != SALT_LENGTH) {
 289     cLog.msg(Log::PRIO_ERROR) << "KeyDerivation::calcCtr: salt lengths don't match";
 290     return false;
 291   }
 292   std::memcpy(ctr_[dir].salt_.buf_, master_salt_.getBuf(), SALT_LENGTH);
 293   ctr_[dir].salt_.zero_ = 0;
 294   ctr_[dir].params_.label_ ^= SATP_PRF_LABEL_T_HTON(convertLabel(dir, label));
 295   ctr_[dir].params_.seq_ ^= SEQ_NR_T_HTON(seq_nr);
 296
 297   return true;
 298 }
 299
 300 bool AesIcmKeyDerivation::generate(kd_dir_t dir, satp_prf_label_t label, seq_nr_t seq_nr, Buffer& key)
 301 {
 302   ReadersLock lock(mutex_);
 303
 304   if(!is_initialized_)
 305     return false;
 306
 307   if(!calcCtr(dir, label, seq_nr)) {
 308     return false;
 309   }
 310
 311 #ifndef USE_SSL_CRYPTO
 312   gcry_error_t err = gcry_cipher_reset(handle_[dir]);
 313   if(err) {
 314     cLog.msg(Log::PRIO_ERROR) << "KeyDerivation::generate: Failed to reset cipher: " << AnytunGpgError(err);
 315   }
 316
 317   err = gcry_cipher_setctr(handle_[dir], ctr_[dir].buf_, CTR_LENGTH);
 318   if(err) {
 319     cLog.msg(Log::PRIO_ERROR) << "KeyDerivation::generate: Failed to set CTR: " << AnytunGpgError(err);
 320     return false;
 321   }
 322
 323   std::memset(key.getBuf(), 0, key.getLength());
 324   err = gcry_cipher_encrypt(handle_[dir], key, key.getLength(), NULL, 0);
 325   if(err) {
 326     cLog.msg(Log::PRIO_ERROR) << "KeyDerivation::generate: Failed to generate cipher bitstream: " << AnytunGpgError(err);
 327   }
 328 #else
 329   if(CTR_LENGTH != AES_BLOCK_SIZE) {
 330     cLog.msg(Log::PRIO_ERROR) << "AesIcmCipher: Failed to set cipher CTR: size don't fits";
 331     return false;
 332   }
 333   unsigned int num = 0;
 334   std::memset(ecount_buf_[dir], 0, AES_BLOCK_SIZE);
 335   std::memset(key.getBuf(), 0, key.getLength());
 336   AES_ctr128_encrypt(key.getBuf(), key.getBuf(), key.getLength(), &aes_key_[dir], ctr_[dir].buf_, ecount_buf_[dir], &num);
 337 #endif
 338
 339   return true;
 340 }
 341 #endif
 342