lime_crypto_primitives.hpp

Go to the documentation of this file.

/*
    lime_crypto_primitives.hpp
    @author Johan Pascal
    @copyright  Copyright (C) 2017  Belledonne Communications SARL

    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/>.
*/

#ifndef lime_crypto_primitives_hpp
#define lime_crypto_primitives_hpp

#include <memory>
#include <vector>

#include "lime_keys.hpp"
#include "lime_defines.hpp"

namespace lime {
/*************************************************************************************************/
/********************** Data Structures **********************************************************/
/*************************************************************************************************/

    void cleanBuffer(uint8_t *buffer, size_t size);

    template <size_t T>
    struct sBuffer : public std::array<uint8_t, T> {
        ~sBuffer() {cleanBuffer(this->data(), T);};
    };

    /****************************************************************/
    /* Key Exchange Data structures                                 */
    /****************************************************************/
    template <typename Curve, lime::Xtype dataType>
    class X : public sBuffer<static_cast<size_t>(Curve::Xsize(dataType))>{
        public :
            constexpr static size_t ssize(void) {return Curve::Xsize(dataType);};
            X(const std::vector<uint8_t>::const_iterator buffer) {std::copy_n(buffer, ssize(), this->begin());}
            X(const uint8_t * const buffer) {std::copy_n(buffer, ssize(), this->begin());}
            X() {this->fill(0);};
            void assign(const std::vector<uint8_t>::const_iterator buffer) {std::copy_n(buffer, ssize(), this->begin());}
    };

    template <typename Curve>
    class Xpair {
        private:
            X<Curve, lime::Xtype::publicKey> m_pubKey;
            X<Curve, lime::Xtype::privateKey> m_privKey;
        public:
            X<Curve, lime::Xtype::privateKey> &privateKey(void) {return m_privKey;};
            const X<Curve, lime::Xtype::privateKey> &cprivateKey(void) const {return m_privKey;};
            X<Curve, lime::Xtype::publicKey> &publicKey(void) {return m_pubKey;};
            const X<Curve, lime::Xtype::publicKey> &cpublicKey(void) const {return m_pubKey;};
            Xpair(const X<Curve, lime::Xtype::publicKey> &pub, const X<Curve, lime::Xtype::privateKey> &priv):m_pubKey(pub),m_privKey(priv) {};
            Xpair() :m_pubKey{},m_privKey{}{};
            bool operator==(Xpair<Curve> b) const {return (m_privKey==b.privateKey() && m_pubKey==b.publicKey());};

    };

    /****************************************************************/
    /* Key Encapsulation Data structures                            */
    /****************************************************************/
    template <typename Algo, lime::Ktype dataType>
    class K : public sBuffer<static_cast<size_t>(Algo::Ksize(dataType))>{
        public :
            constexpr static size_t ssize(void) {return Algo::Ksize(dataType);};
            K(const std::vector<uint8_t>::const_iterator buffer) {std::copy_n(buffer, ssize(), this->begin());}
            K(const uint8_t * const buffer) {std::copy_n(buffer, ssize(), this->begin());}
            K() {this->fill(0);};
            void assign(const std::vector<uint8_t>::const_iterator buffer) {std::copy_n(buffer, ssize(), this->begin());}
    };

    template <typename Algo>
    class Kpair {
        private:
            K<Algo, lime::Ktype::publicKey> m_pubKey;
            K<Algo, lime::Ktype::privateKey> m_privKey;
        public:
            K<Algo, lime::Ktype::privateKey> &privateKey(void) {return m_privKey;};
            const K<Algo, lime::Ktype::privateKey> &cprivateKey(void) const {return m_privKey;};
            K<Algo, lime::Ktype::publicKey> &publicKey(void) {return m_pubKey;};
            const K<Algo, lime::Ktype::publicKey> &cpublicKey(void) const {return m_pubKey;};
            Kpair(const K<Algo, lime::Ktype::publicKey> &pub, const K<Algo, lime::Ktype::privateKey> &priv):m_pubKey(pub),m_privKey(priv) {};
            Kpair() :m_pubKey{},m_privKey{}{};
            bool operator==(Kpair<Algo> b) const {return (m_privKey==b.privateKey() && m_pubKey==b.publicKey());};

    };

    /****************************************************************/
    /* Digital Signature Algorithm data structures                  */
    /****************************************************************/
    template <typename Curve, lime::DSAtype dataType>
    class DSA : public sBuffer<static_cast<size_t>(Curve::DSAsize(dataType))>{
        public :
            constexpr static size_t ssize(void) {return Curve::DSAsize(dataType);};
            DSA(const std::vector<uint8_t>::const_iterator buffer) {std::copy_n(buffer, ssize(), this->begin());}
            DSA() {this->fill(0);};
            void assign(const std::vector<uint8_t>::const_iterator buffer) {std::copy_n(buffer, ssize(), this->begin());}
    };

    template <typename Curve>
    class DSApair {
        private:
            DSA<Curve, lime::DSAtype::publicKey> m_pubKey;
            DSA<Curve, lime::DSAtype::privateKey> m_privKey;
        public:
            DSA<Curve, lime::DSAtype::privateKey> &privateKey(void) {return m_privKey;};
            const DSA<Curve, lime::DSAtype::privateKey> &cprivateKey(void) const {return m_privKey;};
            DSA<Curve, lime::DSAtype::publicKey> &publicKey(void) {return m_pubKey;};
            const DSA<Curve, lime::DSAtype::publicKey> &cpublicKey(void) const {return m_pubKey;};
            DSApair(const DSA<Curve, lime::DSAtype::publicKey> &pub, const DSA<Curve, lime::DSAtype::privateKey> &priv):m_pubKey(pub),m_privKey(priv) {};
            DSApair() :m_pubKey{},m_privKey{}{};
            bool operator==(DSApair<Curve> b) const {return (m_privKey==b.privateKey() && m_pubKey==b.publicKey());};
    };


/*************************************************************************************************/
/********************** Crypto Algo interface ****************************************************/
/*************************************************************************************************/

class RNG {
    public:
        virtual uint32_t randomize() = 0;

        virtual void randomize(uint8_t *buffer, const size_t size) = 0;

        virtual ~RNG() = default;
}; //class RNG

template <typename Curve>
class keyExchange {
    public:
        /* accessors */
        virtual const X<Curve, lime::Xtype::privateKey> get_secret(void) = 0;
        virtual const X<Curve, lime::Xtype::publicKey> get_selfPublic(void) = 0;
        virtual const X<Curve, lime::Xtype::publicKey> get_peerPublic(void) = 0;
        virtual const X<Curve, lime::Xtype::sharedSecret> get_sharedSecret(void) = 0;

        /* set keys in context, publics and private keys directly accept Signature formatted keys which are converted to keyExchange format */
        virtual void set_secret(const X<Curve, lime::Xtype::privateKey> &secret) = 0;
        virtual void set_secret(const DSA<Curve, lime::DSAtype::privateKey> &secret) = 0;
        virtual void set_selfPublic(const X<Curve, lime::Xtype::publicKey> &selfPublic) = 0; 
        virtual void set_selfPublic(const DSA<Curve, lime::DSAtype::publicKey> &selfPublic) = 0;
        virtual void set_peerPublic(const X<Curve, lime::Xtype::publicKey> &peerPublic) = 0; 
        virtual void set_peerPublic(const DSA<Curve, lime::DSAtype::publicKey> &peerPublic) = 0;

        virtual void createKeyPair(std::shared_ptr<lime::RNG> rng) = 0;

        virtual void deriveSelfPublic(void) = 0;

        virtual void computeSharedSecret(void) = 0;
        virtual ~keyExchange() = default;
}; //class keyExchange

template <typename Algo>
class KEM {
    public:
        virtual void createKeyPair(Kpair<Algo>&keyPair) = 0;

        virtual void encaps(const K<Algo, lime::Ktype::publicKey> &publicKey, K<Algo, lime::Ktype::cipherText> &cipherText, K<Algo, lime::Ktype::sharedSecret> &sharedSecret) = 0;
    
        virtual void decaps(const K<Algo, lime::Ktype::privateKey> &privateKey, const K<Algo, lime::Ktype::cipherText> &cipherText, K<Algo, lime::Ktype::sharedSecret> &sharedSecret) = 0;


        virtual ~KEM() = default;
}; //class keyExchange

template <typename Curve>
class Signature {
    public:
        /* accessors */
        virtual const DSA<Curve, lime::DSAtype::privateKey> get_secret(void) = 0;
        virtual const DSA<Curve, lime::DSAtype::publicKey> get_public(void) = 0;

        virtual void set_secret(const DSA<Curve, lime::DSAtype::privateKey> &secretKey) = 0;
        virtual void set_public(const DSA<Curve, lime::DSAtype::publicKey> &publicKey) = 0;

        virtual void createKeyPair(std::shared_ptr<lime::RNG> rng) = 0;

        virtual void derivePublic(void) = 0;

        virtual void sign(const std::vector<uint8_t> &message, DSA<Curve, lime::DSAtype::signature> &signature) = 0;
        virtual void sign(const X<Curve, lime::Xtype::publicKey> &message, DSA<Curve, lime::DSAtype::signature> &signature) = 0;

        virtual bool verify(const std::vector<uint8_t> &message, const DSA<Curve, lime::DSAtype::signature> &signature) = 0;
        virtual bool verify(const X<Curve, lime::Xtype::publicKey> &message, const DSA<Curve, lime::DSAtype::signature> &signature) = 0;

        virtual ~Signature() = default;
}; //class EdDSA

template <typename hashAlgo>
void HMAC(const uint8_t *const key, const size_t keySize, const uint8_t *const input, const size_t inputSize, uint8_t *hash, size_t hashSize);
/* declare template specialisations */
template <> void HMAC<SHA512>(const uint8_t *const key, const size_t keySize, const uint8_t *const input, const size_t inputSize, uint8_t *hash, size_t hashSize);

template <typename hashAlgo>
void HMAC_KDF(const uint8_t *const salt, const size_t saltSize, const uint8_t *const ikm, const size_t ikmSize, const char *info, const size_t infoSize, uint8_t *output, size_t outputSize);
/* declare template specialisations */
template <> void HMAC_KDF<SHA512>(const uint8_t *const salt, const size_t saltSize, const uint8_t *const ikm, const size_t ikmSize, const char * info, const size_t infoSize, uint8_t *output, size_t outputSize);


/************************ AEAD interface *************************************/

template <typename AEADAlgo>
void AEAD_encrypt(const uint8_t *const key, const size_t keySize, const uint8_t *const IV, const size_t IVSize,
        const uint8_t *const plain, const size_t plainSize, const uint8_t *const AD, const size_t ADSize,
        uint8_t *tag, const size_t tagSize, uint8_t *cipher);

template <typename AEADAlgo>
bool AEAD_decrypt(const uint8_t *const key, const size_t keySize, const uint8_t *const IV, const size_t IVSize,
        const uint8_t *const cipher, const size_t cipherSize, const uint8_t *const AD, const size_t ADSize,
        const uint8_t *const tag, const size_t tagSize, uint8_t *plain);

/* declare AEAD template specialisations */
template <> void AEAD_encrypt<AES256GCM>(const uint8_t *const key, const size_t keySize, const uint8_t *const IV, const size_t IVSize,
        const uint8_t *const plain, const size_t plainSize, const uint8_t *const AD, const size_t ADSize,
        uint8_t *tag, const size_t tagSize, uint8_t *cipher);

template <> bool AEAD_decrypt<AES256GCM>(const uint8_t *const key, const size_t keySize, const uint8_t *const IV, const size_t IVSize,
        const uint8_t *const cipher, const size_t cipherSize, const uint8_t *const AD, const size_t ADSize,
        const uint8_t *const tag, const size_t tagSize, uint8_t *plain);


/*************************************************************************************************/
/********************** Factory Functions ********************************************************/
/*************************************************************************************************/
/* Use these to instantiate an object as they will pick the correct underlying implemenation of virtual classes */
std::shared_ptr<RNG> make_RNG();

template <typename Curve>
std::shared_ptr<keyExchange<Curve>> make_keyExchange();

template <typename Curve>
std::shared_ptr<Signature<Curve>> make_Signature();

template <typename Algo>
std::shared_ptr<KEM<Algo>> make_KEM();

/*************************************************************************************************/
/********************** Template Instanciation ***************************************************/
/*************************************************************************************************/
/* this templates are instanciated once in the lime_crypto_primitives.cpp file, explicitly tell anyone including this header that there is no need to re-instanciate them */

#ifdef EC25519_ENABLED
    extern template std::shared_ptr<keyExchange<C255>> make_keyExchange();
    extern template std::shared_ptr<Signature<C255>> make_Signature();
    extern template class X<C255, lime::Xtype::publicKey>;
    extern template class X<C255, lime::Xtype::privateKey>;
    extern template class X<C255, lime::Xtype::sharedSecret>;
    extern template class Xpair<C255>;
    extern template class DSA<C255, lime::DSAtype::publicKey>;
    extern template class DSA<C255, lime::DSAtype::privateKey>;
    extern template class DSA<C255, lime::DSAtype::signature>;
    extern template class DSApair<C255>;
#endif // EC25519_ENABLED

#ifdef EC448_ENABLED
    extern template std::shared_ptr<keyExchange<C448>> make_keyExchange();
    extern template std::shared_ptr<Signature<C448>> make_Signature();
    extern template class X<C448, lime::Xtype::publicKey>;
    extern template class X<C448, lime::Xtype::privateKey>;
    extern template class X<C448, lime::Xtype::sharedSecret>;
    extern template class Xpair<C448>;
    extern template class DSA<C448, lime::DSAtype::publicKey>;
    extern template class DSA<C448, lime::DSAtype::privateKey>;
    extern template class DSA<C448, lime::DSAtype::signature>;
    extern template class DSApair<C448>;
#endif // EC448_ENABLED

#ifdef HAVE_BCTBXPQ
    // Kyber512
    extern template std::shared_ptr<KEM<K512>> make_KEM();
    extern template class K<K512, lime::Ktype::publicKey>;
    extern template class K<K512, lime::Ktype::privateKey>;
    extern template class K<K512, lime::Ktype::cipherText>;
    extern template class K<K512, lime::Ktype::sharedSecret>;
    extern template class Kpair<K512>;
    // MLKEM 512
    extern template std::shared_ptr<KEM<MLK512>> make_KEM();
    extern template class K<MLK512, lime::Ktype::publicKey>;
    extern template class K<MLK512, lime::Ktype::privateKey>;
    extern template class K<MLK512, lime::Ktype::cipherText>;
    extern template class K<MLK512, lime::Ktype::sharedSecret>;
    extern template class Kpair<MLK512>;
    // MLKEM 1024
    extern template std::shared_ptr<KEM<MLK1024>> make_KEM();
    extern template class K<MLK1024, lime::Ktype::publicKey>;
    extern template class K<MLK1024, lime::Ktype::privateKey>;
    extern template class K<MLK1024, lime::Ktype::cipherText>;
    extern template class K<MLK1024, lime::Ktype::sharedSecret>;
    extern template class Kpair<MLK1024>;
#endif //HAVE_BCTBXPQ
} // namespace lime

#endif //lime_crypto_primitives_hpp