fsstorage_read.cc

#include "fsstorage_read.h"

#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>

#include <iostream>
#include <utility>

#include <boost/lexical_cast.hpp>
#include <boost/scoped_array.hpp>
#include "json/json.h"

#include "logging/logging.h"
#include "utilities/utils.h"

FSStorageRead::FSStorageRead(const StorageConfig& config) : config_(config) {
  boost::filesystem::path images_path = config_.uptane_metadata_path.get(config_.path) / "repo";
  boost::filesystem::path director_path = config_.uptane_metadata_path.get(config_.path) / "director";
  // migrate from old unversioned Uptane root meta
  {
    for (auto repo : {Uptane::RepositoryType::Director, Uptane::RepositoryType::Images}) {
      boost::filesystem::path& meta_dir = repo == (Uptane::RepositoryType::Director) ? director_path : images_path;
      boost::filesystem::path meta_path = meta_dir / Uptane::Version().RoleFileName(Uptane::Role::Root());
      if (boost::filesystem::exists(meta_path)) {
        std::string data = Utils::readFile(meta_path);
        Uptane::Version version{Uptane::extractVersionUntrusted(data)};
        boost::filesystem::remove(meta_path);
        if (version.version() >= 0) {
          Utils::writeFile(meta_dir / version.RoleFileName(Uptane::Role::Root()), data);
        }
      }
    }
  }

  latest_director_root = findMaxVersion(director_path, Uptane::Role::Root());
  latest_images_root = findMaxVersion(images_path, Uptane::Role::Root());
}

bool FSStorageRead::loadPrimaryKeys(std::string* public_key, std::string* private_key) {
  return loadPrimaryPublic(public_key) && loadPrimaryPrivate(private_key);
}

bool FSStorageRead::loadPrimaryPublic(std::string* public_key) {
  boost::filesystem::path public_key_path = config_.uptane_public_key_path.get(config_.path);
  if (!boost::filesystem::exists(public_key_path)) {
    return false;
  }

  if (public_key != nullptr) {
    *public_key = Utils::readFile(public_key_path.string());
  }
  return true;
}

bool FSStorageRead::loadPrimaryPrivate(std::string* private_key) {
  boost::filesystem::path private_key_path = config_.uptane_private_key_path.get(config_.path);
  if (!boost::filesystem::exists(private_key_path)) {
    return false;
  }

  if (private_key != nullptr) {
    *private_key = Utils::readFile(private_key_path.string());
  }
  return true;
}

bool FSStorageRead::loadTlsCreds(std::string* ca, std::string* cert, std::string* pkey) {
  boost::filesystem::path ca_path(config_.tls_cacert_path.get(config_.path));
  boost::filesystem::path cert_path(config_.tls_clientcert_path.get(config_.path));
  boost::filesystem::path pkey_path(config_.tls_pkey_path.get(config_.path));
  if (!boost::filesystem::exists(ca_path) || boost::filesystem::is_directory(ca_path) ||
      !boost::filesystem::exists(cert_path) || boost::filesystem::is_directory(cert_path) ||
      !boost::filesystem::exists(pkey_path) || boost::filesystem::is_directory(pkey_path)) {
    return false;
  }
  if (ca != nullptr) {
    *ca = Utils::readFile(ca_path.string());
  }
  if (cert != nullptr) {
    *cert = Utils::readFile(cert_path.string());
  }
  if (pkey != nullptr) {
    *pkey = Utils::readFile(pkey_path.string());
  }
  return true;
}

bool FSStorageRead::loadTlsCommon(std::string* data, const BasedPath& path_in) {
  boost::filesystem::path path(path_in.get(config_.path));
  if (!boost::filesystem::exists(path)) {
    return false;
  }

  if (data != nullptr) {
    *data = Utils::readFile(path.string());
  }

  return true;
}

bool FSStorageRead::loadTlsCa(std::string* ca) { return loadTlsCommon(ca, config_.tls_cacert_path); }

bool FSStorageRead::loadTlsCert(std::string* cert) { return loadTlsCommon(cert, config_.tls_clientcert_path); }

bool FSStorageRead::loadTlsPkey(std::string* pkey) { return loadTlsCommon(pkey, config_.tls_pkey_path); }

bool FSStorageRead::loadRoot(std::string* data, Uptane::RepositoryType repo, Uptane::Version version) {
  boost::filesystem::path metafile;
  switch (repo) {
    case (Uptane::RepositoryType::Director):
      if (version.version() < 0) {
        version = latest_director_root;
      }
      metafile =
          config_.uptane_metadata_path.get(config_.path) / "director" / version.RoleFileName(Uptane::Role::Root());
      break;

    case (Uptane::RepositoryType::Images):
      if (version.version() < 0) {
        version = latest_director_root;
      }
      metafile = config_.uptane_metadata_path.get(config_.path) / "repo" / version.RoleFileName(Uptane::Role::Root());
      break;

    default:
      return false;
  }

  if (version.version() < 0) {
    return false;
  }

  if (!boost::filesystem::exists(metafile)) {
    return false;
  }

  if (data != nullptr) {
    *data = Utils::readFile(metafile);
  }
  return true;
}

bool FSStorageRead::loadNonRoot(std::string* data, Uptane::RepositoryType repo, Uptane::Role role) {
  boost::filesystem::path metafile;
  switch (repo) {
    case (Uptane::RepositoryType::Director):
      metafile = config_.uptane_metadata_path.get(config_.path) / "director" / Uptane::Version().RoleFileName(role);
      break;

    case (Uptane::RepositoryType::Images):
      metafile = config_.uptane_metadata_path.get(config_.path) / "repo" / Uptane::Version().RoleFileName(role);
      break;

    default:
      return false;
  }

  if (!boost::filesystem::exists(metafile)) {
    return false;
  }

  if (data != nullptr) {
    *data = Utils::readFile(metafile);
  }
  return true;
}

bool FSStorageRead::loadDeviceId(std::string* device_id) {
  if (!boost::filesystem::exists(Utils::absolutePath(config_.path, "device_id").string())) {
    return false;
  }

  if (device_id != nullptr) {
    *device_id = Utils::readFile(Utils::absolutePath(config_.path, "device_id").string());
  }
  return true;
}

bool FSStorageRead::loadEcuRegistered() {
  return boost::filesystem::exists(Utils::absolutePath(config_.path, "is_registered").string());
}

bool FSStorageRead::loadEcuSerials(EcuSerials* serials) {
  std::string buf;
  std::string serial;
  std::string hw_id;

  const boost::filesystem::path serial_path = Utils::absolutePath(config_.path, "primary_ecu_serial");
  if (!boost::filesystem::exists(serial_path)) {
    return false;
  }
  serial = Utils::readFile(serial_path.string());
  // use default hardware ID for backwards compatibility
  const boost::filesystem::path hw_id_path = Utils::absolutePath(config_.path, "primary_ecu_hardware_id");
  if (!boost::filesystem::exists(hw_id_path)) {
    hw_id = Utils::getHostname();
  } else {
    hw_id = Utils::readFile(hw_id_path.string());
  }

  if (serials != nullptr) {
    serials->push_back({Uptane::EcuSerial(serial), Uptane::HardwareIdentifier(hw_id)});
  }

  // return true for backwards compatibility
  const boost::filesystem::path sec_list_path = Utils::absolutePath(config_.path, "secondaries_list");
  if (!boost::filesystem::exists(sec_list_path)) {
    return true;
  }
  std::ifstream file(sec_list_path.c_str());
  while (std::getline(file, buf)) {
    size_t tab = buf.find('\t');
    serial = buf.substr(0, tab);
    try {
      hw_id = buf.substr(tab + 1);
    } catch (const std::out_of_range& e) {
      if (serials != nullptr) {
        serials->clear();
      }
      file.close();
      return false;
    }
    if (serials != nullptr) {
      serials->push_back({Uptane::EcuSerial(serial), Uptane::HardwareIdentifier(hw_id)});
    }
  }
  file.close();
  return true;
}

bool FSStorageRead::loadMisconfiguredEcus(std::vector<MisconfiguredEcu>* ecus) {
  if (!boost::filesystem::exists(Utils::absolutePath(config_.path, "misconfigured_ecus"))) {
    return false;
  }
  Json::Value content_json = Utils::parseJSONFile(Utils::absolutePath(config_.path, "misconfigured_ecus").string());

  for (Json::ValueIterator it = content_json.begin(); it != content_json.end(); ++it) {
    ecus->push_back(MisconfiguredEcu(Uptane::EcuSerial((*it)["serial"].asString()),
                                     Uptane::HardwareIdentifier((*it)["hardware_id"].asString()),
                                     static_cast<EcuState>((*it)["state"].asInt())));
  }
  return true;
}

std::string FSStorageRead::loadInstalledVersions(std::vector<Uptane::Target>* installed_versions) {
  std::string current_hash;
  if (!boost::filesystem::exists(Utils::absolutePath(config_.path, "installed_versions"))) {
    return current_hash;
  }
  Json::Value installed_versions_json =
      Utils::parseJSONFile(Utils::absolutePath(config_.path, "installed_versions").string());
  std::vector<Uptane::Target> new_versions;
  for (Json::ValueIterator it = installed_versions_json.begin(); it != installed_versions_json.end(); ++it) {
    if (!(*it).isObject()) {
      // We loaded old format, migrate to new one.
      Json::Value t_json;
      t_json["hashes"]["sha256"] = it.key();
      Uptane::Target t((*it).asString(), t_json);
      new_versions.push_back(t);
    } else {
      if ((*it)["is_current"].asBool()) {
        current_hash = (*it)["hashes"]["sha256"].asString();
      }
      Uptane::Target t(it.key().asString(), *it);
      new_versions.push_back(t);
    }
  }
  *installed_versions = new_versions;

  return current_hash;
}

bool FSStorageRead::loadInstallationResult(data::OperationResult* result) {
  if (!boost::filesystem::exists(Utils::absolutePath(config_.path, "installation_result").string())) {
    return false;
  }

  if (result != nullptr) {
    *result = data::OperationResult::fromJson(
        Utils::readFile(Utils::absolutePath(config_.path, "installation_result").string()));
  }
  return true;
}

bool FSStorageRead::splitNameRoleVersion(const std::string& full_name, std::string* role_name, int* version) {
  size_t dot_pos = full_name.find('.');

  // doesn't have a dot
  if (dot_pos == std::string::npos) {
    return false;
  }
  std::string prefix = full_name.substr(0, dot_pos);
  if (role_name != nullptr) {
    *role_name = full_name.substr(dot_pos + 1);
  }

  try {
    auto v = boost::lexical_cast<int>(prefix);
    if (version != nullptr) {
      *version = v;
    }
  } catch (const boost::bad_lexical_cast&) {
    return false;
  }
  return true;
}

Uptane::Version FSStorageRead::findMaxVersion(const boost::filesystem::path& meta_directory, Uptane::Role role) {
  int version = -1;
  if (!boost::filesystem::exists(meta_directory)) {
    return {};
  }

  boost::filesystem::directory_iterator it{meta_directory};
  for (; it != boost::filesystem::directory_iterator(); ++it) {
    if (!boost::filesystem::is_regular_file(it->path())) {
      continue;
    }
    std::string name = it->path().filename().native();
    int file_version;
    std::string file_role;
    if (splitNameRoleVersion(name, &file_role, &file_version)) {
      if (file_role == Uptane::Version().RoleFileName(role) && file_version > version) {
        version = file_version;
      }
    }
  }

  return Uptane::Version(version);
}

// clear methods, to clean the storage files after a migration

void FSStorageRead::clearPrimaryKeys() {
  boost::filesystem::remove(config_.uptane_public_key_path.get(config_.path));
  boost::filesystem::remove(config_.uptane_private_key_path.get(config_.path));
}

void FSStorageRead::clearTlsCreds() {
  boost::filesystem::remove(config_.tls_cacert_path.get(config_.path));
  boost::filesystem::remove(config_.tls_clientcert_path.get(config_.path));
  boost::filesystem::remove(config_.tls_pkey_path.get(config_.path));
}

void FSStorageRead::clearNonRootMeta(Uptane::RepositoryType repo) {
  boost::filesystem::path meta_path;
  switch (repo) {
    case Uptane::RepositoryType::Images:
      meta_path = config_.uptane_metadata_path.get(config_.path) / "repo";
      break;
    case Uptane::RepositoryType::Director:
      meta_path = config_.uptane_metadata_path.get(config_.path) / "director";
      break;
    default:
      return;
  }

  boost::filesystem::directory_iterator it{meta_path};
  for (; it != boost::filesystem::directory_iterator(); ++it) {
    for (auto role : Uptane::Role::Roles()) {
      if (role == Uptane::Role::Root()) {
        continue;
      }
      std::string role_name;
      std::string fn = it->path().filename().native();
      if (fn == Uptane::Version().RoleFileName(role) ||
          (splitNameRoleVersion(fn, &role_name, nullptr) && (role_name == Uptane::Version().RoleFileName(role)))) {
        boost::filesystem::remove(it->path());
      }
    }
  }
}

void FSStorageRead::clearMetadata() {
  for (const auto& meta_path : {config_.uptane_metadata_path.get(config_.path) / "repo",
                                config_.uptane_metadata_path.get(config_.path) / "director"}) {
    if (!boost::filesystem::exists(meta_path)) {
      return;
    }

    boost::filesystem::directory_iterator it{meta_path};
    for (; it != boost::filesystem::directory_iterator(); ++it) {
      boost::filesystem::remove(it->path());
    }
  }
}

void FSStorageRead::clearDeviceId() { boost::filesystem::remove(Utils::absolutePath(config_.path, "device_id")); }

void FSStorageRead::clearEcuRegistered() {
  boost::filesystem::remove(Utils::absolutePath(config_.path, "is_registered"));
}

void FSStorageRead::clearEcuSerials() {
  boost::filesystem::remove(Utils::absolutePath(config_.path, "primary_ecu_serial"));
  boost::filesystem::remove(Utils::absolutePath(config_.path, "primary_ecu_hardware_id"));
  boost::filesystem::remove(Utils::absolutePath(config_.path, "secondaries_list"));
}

void FSStorageRead::clearMisconfiguredEcus() {
  boost::filesystem::remove(Utils::absolutePath(config_.path, "misconfigured_ecus"));
}

void FSStorageRead::clearInstalledVersions() {
  if (boost::filesystem::exists(Utils::absolutePath(config_.path, "installed_versions"))) {
    boost::filesystem::remove(Utils::absolutePath(config_.path, "installed_versions"));
  }
}

void FSStorageRead::clearInstallationResult() {
  boost::filesystem::remove(Utils::absolutePath(config_.path, "installation_result"));
}

void FSStorageRead::cleanUpAll() {
  clearPrimaryKeys();
  clearTlsCreds();
  clearDeviceId();
  clearEcuSerials();
  clearEcuRegistered();
  clearMisconfiguredEcus();
  clearInstalledVersions();
  clearInstallationResult();
  clearMetadata();

  boost::filesystem::remove_all(config_.uptane_metadata_path.get(config_.path));
  boost::filesystem::remove_all(config_.path / "targets");
}