KeyPack.hpp

Go to the documentation of this file.

//                                                                            //
// Copyright (C) 2021-2023 Crypto Lab Inc.                                    //
//                                                                            //
// - This file is part of HEaaN homomorphic encryption library.               //
// - HEaaN cannot be copied and/or distributed without the express permission //
//  of Crypto Lab Inc.                                                        //
//                                                                            //
 
#pragma once
 
#include <memory>
 
#include "HEaaN/Context.hpp"
#include "HEaaN/HEaaNExport.hpp"
#include "HEaaN/device/Device.hpp"
 
namespace HEaaN {
 
class EncryptionKey;
class EvaluationKey;
class SparseSecretEncapsulationKey;
class KeyPackImpl;
 
class HEAAN_API KeyPack {
    friend class KeyGenerator;
 
public:
    explicit KeyPack(const Context &context);
 
    explicit KeyPack(const Context &context, const Context &context_sparse);
 
    explicit KeyPack(const Context &context, const std::string &key_dir_path);
 
    explicit KeyPack(const Context &context, const Context &context_sparse,
                     const std::string &key_dir_path);
 
    // Functions for key loading //
 
    void loadEncKey(void);
    void loadEncKey(std::istream &stream);
 
    void loadMultKey(void);
    void loadMultKey(std::istream &stream);
 
    void loadConjKey(void);
    void loadConjKey(std::istream &stream);
 
    void loadLeftRotKey(const u64 rot);
    void loadLeftRotKey(const u64 rot, std::istream &stream);
 
    void loadRightRotKey(const u64 rot);
    void loadRightRotKey(const u64 rot, std::istream &stream);
 
    void loadSparseSecretEncapsulationKey(void);
    void loadSparseSecretEncapsulationKey(std::istream &stream);
 
    // Functions for checking keys in the main memory //
 
    bool isEncKeyLoaded(void) const;
 
    bool isMultKeyLoaded(void) const;
 
    bool isLeftRotKeyLoaded(const u64 rot) const;
 
    bool isRightRotKeyLoaded(const u64 rot) const;
 
    bool isConjKeyLoaded(void) const;
 
    bool isLeftRotKeyFileAvailable(const u64 rot) const;
 
    bool isSparseSecretEncapsulationKeyLoaded() const;
 
    // Key Getters //
 
    std::shared_ptr<EncryptionKey> getEncKey(void) const;
 
    std::shared_ptr<EvaluationKey> getMultKey(void) const;
 
    std::shared_ptr<EvaluationKey> getLeftRotKey(const u64 rot) const;
 
    std::shared_ptr<EvaluationKey> getRightRotKey(const u64 rot) const;
 
    std::shared_ptr<EvaluationKey> getConjKey(void) const;
 
    std::shared_ptr<SparseSecretEncapsulationKey>
    getSparseSecretEncapsulationKey(void) const;
 
    // Miscellaneous/Utility functions //
 
    void setKeyDirPath(const std::string &key_dir_path);
 
    void to(const Device &device);
 
    void save(std::ostream &stream) const;
 
    void load(std::istream &stream);
 
    void save(const std::string &dir_path) const;
 
private:
    std::shared_ptr<KeyPackImpl> impl_;
 
    u64 num_max_slots_;
};
 
HEAAN_API void save(const EvaluationKey &key, std::ostream &stream);
HEAAN_API void save(const EncryptionKey &key, std::ostream &stream);
HEAAN_API void save(const SparseSecretEncapsulationKey &key,
                    std::ostream &stream);
 
HEAAN_API void load(EvaluationKey &key, std::istream &stream);
HEAAN_API void load(EncryptionKey &key, std::istream &stream);
HEAAN_API void load(SparseSecretEncapsulationKey &key, std::istream &stream);
 
} // namespace HEaaN