Ejemplo n.º 1
0
CipherKey makeNewKey(EncfsConfig &config, const char *password, int passwdLen) {
  CipherKey userKey;
  shared_ptr<CipherV1> cipher = getCipher(config);

  EncryptedKey *key = config.mutable_key();

  unsigned char salt[20];
  if (!cipher->pseudoRandomize(salt, sizeof(salt))) {
    cout << _("Error creating salt\n");
    return userKey;
  }
  key->set_salt(salt, sizeof(salt));

  int iterations = key->kdf_iterations();
  userKey = cipher->newKey(password, passwdLen, &iterations,
                           key->kdf_duration(), salt, sizeof(salt));
  key->set_kdf_iterations(iterations);

  return userKey;
}
Ejemplo n.º 2
0
// Read a boost::serialization config file using an Xml reader..
bool readV6Config( const char *configFile, 
    EncfsConfig &cfg, ConfigInfo *info)
{
  (void)info;

  XmlReader rdr;
  if (!rdr.load(configFile))
  {
    LOG(ERROR) << "Failed to load config file " << configFile;
    return false;
  }

  XmlValuePtr serialization = rdr["boost_serialization"];
  XmlValuePtr config = (*serialization)["cfg"];
  if (!config) {
    config = (*serialization)["config"];
  }
  if (!config) {
    LOG(ERROR) << "Unable to find XML configuration in file " << configFile;
    return false;
  }

  int version;
  if (!config->read("version", &version) &&
      !config->read("@version", &version)) {
    LOG(ERROR) << "Unable to find version in config file";
    return false;
  }

  // version numbering was complicated by boost::archive 
  if (version == 20 || version >= 20100713)
  {
    VLOG(1) << "found new serialization format";
    cfg.set_revision(version);
  } else if (version == 26800)
  {
    VLOG(1) << "found 20080816 version";
    cfg.set_revision(20080816);
  } else if (version == 26797)
  {
    VLOG(1) << "found 20080813";
    cfg.set_revision(20080813);
  } else if (version < V5Latest)
  {
    LOG(ERROR) << "Invalid version " << version
      << " - please fix config file";
  } else
  {
    LOG(INFO) << "Boost <= 1.41 compatibility mode";
    cfg.set_revision(version);
  }
  VLOG(1) << "subVersion = " << cfg.revision();

  config->read("creator", cfg.mutable_creator());
  config->read("cipherAlg", cfg.mutable_cipher());
  config->read("nameAlg", cfg.mutable_naming());

  //(*config)["keySize"] >> cfg.keySize;
  int blockSize, blockMacBytes, blockMacRandBytes;
  bool uniqueIv, chainedNameIv, externalIv, allowHoles;

  config->read("blockSize", &blockSize);
  config->read("uniqueIV", &uniqueIv);
  config->read("chainedNameIV", &chainedNameIv);
  config->read("externalIVChaining", &externalIv);
  config->read("blockMACBytes", &blockMacBytes);
  config->read("blockMACRandBytes", &blockMacRandBytes);
  config->read("allowHoles", &allowHoles);

  cfg.set_block_size(blockSize);
  cfg.set_unique_iv(uniqueIv);
  cfg.set_chained_iv(chainedNameIv);
  cfg.set_external_iv(externalIv);
  cfg.set_block_mac_bytes(blockMacBytes);
  cfg.set_block_mac_rand_bytes(blockMacRandBytes);
  cfg.set_allow_holes(allowHoles);

  EncryptedKey *encryptedKey = cfg.mutable_key();
  int encodedSize;
  config->read("encodedKeySize", &encodedSize);
  unsigned char *key = new unsigned char[encodedSize];
  config->readB64("encodedKeyData", key, encodedSize);
  encryptedKey->set_ciphertext(key, encodedSize);
  delete[] key;
  
  int keySize;
  config->read("keySize", &keySize);
  encryptedKey->set_size(keySize / 8); // save as size in bytes

  if(cfg.revision() >= 20080816)
  {
    int saltLen;
    config->read("saltLen", &saltLen);
    unsigned char *salt = new unsigned char[saltLen];
    config->readB64("saltData", salt, saltLen);
    encryptedKey->set_salt(salt, saltLen);
    delete[] salt;

    int kdfIterations, desiredKDFDuration;
    config->read("kdfIterations", &kdfIterations);
    config->read("desiredKDFDuration", &desiredKDFDuration);
    encryptedKey->set_kdf_iterations(kdfIterations);
    encryptedKey->set_kdf_duration(desiredKDFDuration);
  } else
  {
    encryptedKey->clear_salt();
    encryptedKey->set_kdf_iterations(16);
    encryptedKey->clear_kdf_duration();
  }

  return true;
}