VirgilAsymmetricCipher.h

#ifndef VIRGIL_CRYPTO_ASYMMETRIC_CIPHER_H
#define VIRGIL_CRYPTO_ASYMMETRIC_CIPHER_H

#include <cstdlib>
#include <memory>

#include "../VirgilByteArray.h"
#include "../VirgilKeyPair.h"
#include "asn1/VirgilAsn1Compatible.h"

namespace virgil { namespace crypto { namespace foundation {

class VirgilAsymmetricCipher : public virgil::crypto::foundation::asn1::VirgilAsn1Compatible {
public:

    VirgilAsymmetricCipher();


    size_t keySize() const;

    size_t keyLength() const;


    static bool isKeyPairMatch(
            const virgil::crypto::VirgilByteArray& publicKey,
            const virgil::crypto::VirgilByteArray& privateKey,
            const virgil::crypto::VirgilByteArray& privateKeyPassword = virgil::crypto::VirgilByteArray());


    static bool isPublicKeyValid(const virgil::crypto::VirgilByteArray& key);

    static void checkPublicKey(const virgil::crypto::VirgilByteArray& key);

    static bool checkPrivateKeyPassword(
            const virgil::crypto::VirgilByteArray& key,
            const virgil::crypto::VirgilByteArray& pwd);


    static bool isPrivateKeyEncrypted(const virgil::crypto::VirgilByteArray& privateKey);


    void setPrivateKey(
            const virgil::crypto::VirgilByteArray& key,
            const virgil::crypto::VirgilByteArray& pwd = virgil::crypto::VirgilByteArray());

    void setPublicKey(const virgil::crypto::VirgilByteArray& key);

    void genKeyPair(VirgilKeyPair::Type type);

    void genKeyPairFrom(const VirgilAsymmetricCipher& other);

    void genKeyPairFromKeyMaterial(VirgilKeyPair::Type type, const VirgilByteArray& keyMaterial);

    static VirgilByteArray computeShared(
            const VirgilAsymmetricCipher& publicContext,
            const VirgilAsymmetricCipher& privateContext);


    virgil::crypto::VirgilByteArray exportPrivateKeyToDER(
            const virgil::crypto::VirgilByteArray& pwd = virgil::crypto::VirgilByteArray()) const;

    virgil::crypto::VirgilByteArray exportPublicKeyToDER() const;

    virgil::crypto::VirgilByteArray exportPrivateKeyToPEM(
            const virgil::crypto::VirgilByteArray& pwd = virgil::crypto::VirgilByteArray()) const;

    virgil::crypto::VirgilByteArray exportPublicKeyToPEM() const;


    virgil::crypto::VirgilKeyPair::Type getKeyType() const;

    void setKeyType(virgil::crypto::VirgilKeyPair::Type keyType);

    virgil::crypto::VirgilByteArray getPublicKeyBits() const;

    void setPublicKeyBits(const virgil::crypto::VirgilByteArray& bits);


    virgil::crypto::VirgilByteArray encrypt(const virgil::crypto::VirgilByteArray& in) const;

    virgil::crypto::VirgilByteArray decrypt(const virgil::crypto::VirgilByteArray& in) const;


    virgil::crypto::VirgilByteArray sign(const virgil::crypto::VirgilByteArray& digest, int hashType) const;

    bool verify(
            const virgil::crypto::VirgilByteArray& digest,
            const virgil::crypto::VirgilByteArray& sign, int hashType) const;

    virtual size_t asn1Write(
            virgil::crypto::foundation::asn1::VirgilAsn1Writer& asn1Writer,
            size_t childWrittenBytes = 0) const override;

    virtual void asn1Read(virgil::crypto::foundation::asn1::VirgilAsn1Reader& asn1Reader) override;
public:
    VirgilAsymmetricCipher(VirgilAsymmetricCipher&& rhs) noexcept;

    VirgilAsymmetricCipher& operator=(VirgilAsymmetricCipher&& rhs) noexcept;

    virtual ~VirgilAsymmetricCipher() noexcept;

private:
    void checkState() const;

    size_t calculateExportedPublicKeySizeMaxDER() const;
    size_t calculateExportedPublicKeySizeMaxPEM() const;
    size_t calculateExportedPrivateKeySizeMaxDER(size_t encryptionOverhead) const;
    size_t calculateExportedPrivateKeySizeMaxPEM(size_t encryptionOverhead) const;
    VirgilByteArray generateParametersPBES() const;
    static VirgilByteArray adjustBufferWithPEM(const VirgilByteArray& buffer, int size);
    static VirgilByteArray adjustBufferWithDER(const VirgilByteArray& buffer, int size);

private:
    class Impl;

    std::unique_ptr<Impl> impl_;
};

}}}

#endif /* VIRGIL_CRYPTO_ASYMMETRIC_CIPHER_H */