kdbx_xml.hh

Go to the documentation of this file.

/*
 * libkeepass - KeePass key database importer/exporter
 * Copyright (C) 2014 Christian Kindahl
 * Copyright (C) 2024 Dominik Krümpelmann
 *
 * 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/>.
 */
 
#pragma once
#include <array>
#include <cstdint>
#include <istream>
#include <memory>
#include <ostream>
#include <string>
#include <unordered_map>
 
#include "libkeepass/database.hh"
#include "libkeepass/detail/limits.hh"
#include "libkeepass/export.hh"
#include "libkeepass/secure.hh"
 
namespace pugi {
class xml_document;
class xml_node;
} // namespace pugi
 
namespace keepass {
 
class Binary;
class Entry;
class Group;
class Icon;
class Metadata;
class RandomObfuscator;
 
class LIBKEEPASS_API KdbxXml final {
public:
  using BinaryPool = std::unordered_map<std::string, std::shared_ptr<Binary>>;
 
  using IconPool = std::unordered_map<std::string, std::weak_ptr<Icon>>;
 
  using GroupPool = std::unordered_map<std::string, std::shared_ptr<Group>>;
 
  void set_kdbx4(bool kdbx4) { kdbx4_ = kdbx4; }
  bool kdbx4() const { return kdbx4_; }
 
  void set_kdbx41(bool kdbx41) { kdbx41_ = kdbx41; }
  bool kdbx41() const { return kdbx41_; }
 
  void set_resource_limits(const detail::ResourceLimits& limits) { resource_limits_ = limits; }
 
  const detail::ResourceLimits& resource_limits() const { return resource_limits_; }
 
  void Reset();
 
  BinaryPool& binary_pool() { return binary_pool_; }
 
  std::array<uint8_t, 32>& header_hash() { return header_hash_; }
  const std::array<uint8_t, 32>& header_hash() const { return header_hash_; }
 
 
  void Parse(std::istream& src, RandomObfuscator& obfuscator, Database& db);
 
 
  void Write(std::ostream& dst, RandomObfuscator& obfuscator, const Database& db);
 
#ifdef DEBUG
  void PrintXml(pugi::xml_document& doc);
#endif
 
private:
  BinaryPool binary_pool_;
  IconPool icon_pool_;
  GroupPool group_pool_;
  std::array<uint8_t, 32> header_hash_ = {{0}};
 
  detail::ResourceLimits resource_limits_ = {};
 
  uint64_t groups_seen_ = 0;
 
  uint64_t entries_seen_ = 0;
 
  uint64_t history_items_seen_ = 0;
 
  bool kdbx4_ = false;
  bool kdbx41_ = false;
 
  std::shared_ptr<Group> GetGroup(const std::string& uuid_str);
 
  std::time_t ParseDateTime(const char* text) const;
 
  std::string WriteDateTime(std::time_t time) const;
 
  static int64_t NeverSeconds();
 
  protect<secure_string> ParseProtectedString(const pugi::xml_node& node, const char* name,
                                              RandomObfuscator& obfuscator) const;
 
  static void WriteProtectedString(pugi::xml_node& node, const protect<secure_string>& str,
                                   RandomObfuscator& obfuscator);
 
  std::shared_ptr<Metadata> ParseMeta(const pugi::xml_node& meta_node,
                                      RandomObfuscator& obfuscator);
 
  void WriteMeta(pugi::xml_node& meta_node, RandomObfuscator& obfuscator,
                 const std::shared_ptr<Metadata>& meta);
 
 
  std::shared_ptr<Entry> ParseEntry(const pugi::xml_node& entry_node,
                                    std::array<uint8_t, 16>& entry_uuid,
                                    RandomObfuscator& obfuscator);
 
  void WriteEntry(pugi::xml_node& entry_node, RandomObfuscator& obfuscator,
                  const std::shared_ptr<Entry>& entry);
 
 
  std::shared_ptr<Group> ParseGroup(const pugi::xml_node& group_node, RandomObfuscator& obfuscator,
                                    uint32_t depth = 0);
 
  void WriteGroup(pugi::xml_node& group_node, RandomObfuscator& obfuscator,
                  const std::shared_ptr<Group>& group);
};
 
} // namespace keepass