KeyPair.h

Go to the documentation of this file.

#ifndef KEYPAIR_H_
#define KEYPAIR_H_

#include <openssl/evp.h>
#include "ByteArray.h"
#include "Engine.h"
#include "AsymmetricKey.h"
#include "RSAPublicKey.h"
#include "DSAPublicKey.h"
#include "ECDSAPublicKey.h"
#include "RSAPrivateKey.h"
#include "DSAPrivateKey.h"
#include "ECDSAPrivateKey.h"

#include <libcryptosec/exception/EngineException.h>
#include <libcryptosec/exception/EncodeException.h>
#include <libcryptosec/exception/AsymmetricKeyException.h>

class KeyPair
{
    public:
        //TODO Este construtor deve é obsoleto. Devem ser usados os construtores das classes especializadas RSAKeyPair, DSAKeyPair e ECDSAKeyPair
        KeyPair(AsymmetricKey::Algorithm algorithm, int length)
                throw (AsymmetricKeyException);
        
        KeyPair(Engine *engine, std::string keyId)
                throw (EngineException);
        KeyPair(std::string pemEncoded, ByteArray passphrase)
                throw (EncodeException);
        KeyPair(std::string pemEncoded)
                throw (EncodeException);
        KeyPair(ByteArray derEncoded)
                throw (EncodeException);
        
        KeyPair(const KeyPair &keyPair);
        
        virtual ~KeyPair();
        virtual PublicKey* getPublicKey()
                throw (AsymmetricKeyException, EncodeException);
        virtual PrivateKey* getPrivateKey()
            throw (AsymmetricKeyException);
        std::string getPemEncoded(SymmetricKey &passphrase, SymmetricCipher::OperationMode mode)
            throw (SymmetricCipherException, EncodeException);
        std::string getPemEncoded() throw (EncodeException);
        ByteArray getDerEncoded() throw (EncodeException);

        virtual AsymmetricKey::Algorithm getAlgorithm() throw (AsymmetricKeyException);;

        int getSize() throw (AsymmetricKeyException);
        int getSizeBits() throw (AsymmetricKeyException);
        
        EVP_PKEY* getEvpPkey() const;
        
        ENGINE* getEngine() const;
        
        std::string getKeyId() const;
    protected:
        KeyPair();
        static int passphraseCallBack(char *buf, int size, int rwflag, void *u);
        std::string getPublicKeyPemEncoded() throw (EncodeException);
        EVP_PKEY *key;
        std::string keyId;
        ENGINE *engine;
};

#endif /*KEYPAIR_H_*/