cipher.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 <cassert>
#include <cstdint>
#include <iostream>
#include <memory>
 
#include "libkeepass/export.hh"
 
// Keep the public header independent of OpenSSL. The implementation files
// include <openssl/evp.h> and use the complete type; consumers only need the
// forward declaration to hold an AesCipher by value.
struct evp_cipher_ctx_st;
typedef struct evp_cipher_ctx_st EVP_CIPHER_CTX;
 
namespace keepass {
 
template <std::size_t N> class Cipher;
 
LIBKEEPASS_API std::array<uint8_t, 32> encrypt_ecb(const std::array<uint8_t, 32>& src,
                                                   const Cipher<16>& cipher);
 
LIBKEEPASS_API std::array<uint8_t, 32> decrypt_ecb(const std::array<uint8_t, 32>& src,
                                                   const Cipher<16>& cipher);
 
LIBKEEPASS_API void encrypt_cbc(std::istream& src, std::ostream& dst, const Cipher<16>& cipher);
 
LIBKEEPASS_API void decrypt_cbc(std::istream& src, std::ostream& dst, const Cipher<16>& cipher);
 
LIBKEEPASS_API void decrypt_cbc_stream(std::istream& src, std::ostream& dst,
                                       const Cipher<16>& cipher);
 
template <std::size_t N> class Cipher {
public:
  virtual ~Cipher() = default;
 
  virtual const std::array<uint8_t, N>& InitializationVector() const = 0;
 
  virtual void Decrypt(const std::array<uint8_t, N>& src, std::array<uint8_t, N>& dst) const = 0;
 
  virtual void Encrypt(const std::array<uint8_t, N>& src, std::array<uint8_t, N>& dst) const = 0;
};
 
class LIBKEEPASS_API AesCipher final : public Cipher<16> {
private:
  const std::array<uint8_t, 16> init_vec_;
  EVP_CIPHER_CTX* ctx_dec_ = nullptr;
  EVP_CIPHER_CTX* ctx_enc_ = nullptr;
 
public:
  explicit AesCipher(const uint8_t* key) : AesCipher(key, {0}) {}
 
  AesCipher(const uint8_t* key, const std::array<uint8_t, 16>& init_vec);
 
  ~AesCipher();
 
  const std::array<uint8_t, 16>& InitializationVector() const override { return init_vec_; }
 
  void Decrypt(const std::array<uint8_t, 16>& src, std::array<uint8_t, 16>& dst) const override;
 
  void Encrypt(const std::array<uint8_t, 16>& src, std::array<uint8_t, 16>& dst) const override;
};
 
class LIBKEEPASS_API TwofishCipher final : public Cipher<16> {
private:
  static const uint8_t kNumRounds = 16;
 
  struct Key {
    uint32_t sbox_keys[4];
    uint32_t sub_keys[40];
  } key_{};
 
  const std::array<uint8_t, 16> init_vec_;
 
  static inline uint32_t RotateLeft(uint32_t v, uint32_t n) {
    return (v << (n & 0x1f)) | (v >> (32 - (n & 0x1f)));
  }
 
  static inline uint32_t RotateRight(uint32_t v, uint32_t n) {
    return (v >> (n & 0x1f)) | (v << (32 - (n & 0x1f)));
  }
 
  static uint32_t ReedSolomonEncode(uint32_t k0, uint32_t k1);
 
  static uint32_t F32(uint32_t x, const uint32_t* k32);
 
  void InitializeKey(const uint8_t* key);
 
public:
  explicit TwofishCipher(const uint8_t* key) : TwofishCipher(key, {0}) {}
 
  TwofishCipher(const uint8_t* key, const std::array<uint8_t, 16>& init_vec);
 
  ~TwofishCipher();
 
  const std::array<uint8_t, 16>& InitializationVector() const override { return init_vec_; }
 
  void Decrypt(const std::array<uint8_t, 16>& src, std::array<uint8_t, 16>& dst) const override;
 
  void Encrypt(const std::array<uint8_t, 16>& src, std::array<uint8_t, 16>& dst) const override;
};
 
class LIBKEEPASS_API Salsa20Cipher final {
private:
  std::array<uint32_t, 16> input_ = {{0}};
 
  static inline uint32_t RotateLeft(uint32_t v, uint32_t n) {
    return (v << (n & 0x1f)) | (v >> (32 - (n & 0x1f)));
  }
 
  static std::array<uint8_t, 64> WordToByte(const std::array<uint32_t, 16>& input);
 
public:
  explicit Salsa20Cipher(const uint8_t* key) : Salsa20Cipher(key, {0}) {}
 
  Salsa20Cipher(const uint8_t* key, const std::array<uint8_t, 8>& init_vec);
 
  ~Salsa20Cipher();
 
  void Process(const std::array<uint8_t, 64>& src, std::array<uint8_t, 64>& dst);
};
 
class LIBKEEPASS_API ChaCha20Cipher final {
private:
  std::array<uint32_t, 16> state_ = {{0}};
 
  static inline uint32_t RotateLeft(uint32_t v, uint32_t n) {
    return (v << (n & 0x1f)) | (v >> (32 - (n & 0x1f)));
  }
 
  static std::array<uint8_t, 64> BlockFunction(const std::array<uint32_t, 16>& state);
 
public:
  ChaCha20Cipher(const uint8_t* key, const std::array<uint8_t, 12>& init_vec);
 
  ~ChaCha20Cipher();
 
  void Process(const std::array<uint8_t, 64>& src, std::array<uint8_t, 64>& dst);
};
 
} // namespace keepass