lime_keys.hpp

Go to the documentation of this file.

/*
    lime_keys.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_keys_hpp
#define lime_keys_hpp

#include <algorithm> //std::copy_n
#include <array>
#include <iterator>
#include "lime/lime.hpp"
#include "bctoolbox/crypto.hh"
#ifdef HAVE_BCTBXPQ
#include "postquantumcryptoengine/crypto.hh"
#endif /* HAVE_BCTBXPQ */

namespace lime {
    // Data structure type enumerations
    enum class Xtype {publicKey, privateKey, sharedSecret};
    enum class Ktype {publicKey, privateKey, cipherText, sharedSecret};

    enum class DSAtype {publicKey, privateKey, signature};

    /* define needed constant for the curves: self identificatio(used in DB and as parameter from lib users, data structures sizes)*/
    /* These structure are used as template argument to enable support for different key Exchznge and signature Algorithms */

    struct C255 {
        using EC = C255;
        static const std::string Id() {return std::string("CURVE25519");};
        static constexpr lime::CurveId curveId() {return lime::CurveId::c25519;};
        static constexpr size_t Xsize(lime::Xtype dataType) {return BCTBX_ECDH_X25519_PUBLIC_SIZE;};
        static constexpr size_t DSAsize(lime::DSAtype dataType) {return (dataType != lime::DSAtype::signature)?BCTBX_EDDSA_25519_PUBLIC_SIZE:BCTBX_EDDSA_25519_SIGNATURE_SIZE;};
    };

    struct C448 {
        using EC = C448;
        static const std::string Id() {return std::string("CURVE448");};
        static constexpr lime::CurveId curveId() {return lime::CurveId::c448;};
        static constexpr size_t Xsize(lime::Xtype dataType) {return BCTBX_ECDH_X448_PUBLIC_SIZE;};
        static constexpr size_t DSAsize(lime::DSAtype dataType) {return (dataType != lime::DSAtype::signature)?BCTBX_EDDSA_448_PUBLIC_SIZE:BCTBX_EDDSA_448_SIGNATURE_SIZE;};
    };

    struct genericKEM {
        static constexpr lime::CurveId curveId() {return lime::CurveId::unset;}; // KEM cannot be used directly in DR or X3DH -> no curveId
    };
#ifdef HAVE_BCTBXPQ

    struct K512: public genericKEM {
        static const std::string Id(void) {return std::string("KYBER512");};
        static constexpr size_t Ksize(lime::Ktype dataType) {
            switch (dataType) {
                case lime::Ktype::publicKey:
                    return bctoolbox::KYBER512::kPkSize;
                break;
                case lime::Ktype::privateKey:
                    return bctoolbox::KYBER512::kSkSize;
                break;
                case lime::Ktype::cipherText:
                    return bctoolbox::KYBER512::kCtSize;
                break;
                case lime::Ktype::sharedSecret:
                    return bctoolbox::KYBER512::kSsSize;
                break;
            }
            return 0; // make compiler happy
        };
    };

    struct MLK512: public genericKEM {
        static const std::string Id(void) {return std::string("MLKEM512");};
        static constexpr size_t Ksize(lime::Ktype dataType) {
            switch (dataType) {
                case lime::Ktype::publicKey:
                    return bctoolbox::MLKEM512::kPkSize;
                break;
                case lime::Ktype::privateKey:
                    return bctoolbox::MLKEM512::kSkSize;
                break;
                case lime::Ktype::cipherText:
                    return bctoolbox::MLKEM512::kCtSize;
                break;
                case lime::Ktype::sharedSecret:
                    return bctoolbox::MLKEM512::kSsSize;
                break;
            }
            return 0; // make compiler happy
        };
    };

    struct MLK1024: public genericKEM {
        static const std::string Id(void) {return std::string("MLKEM1024");};
        static constexpr size_t Ksize(lime::Ktype dataType) {
            switch (dataType) {
                case lime::Ktype::publicKey:
                    return bctoolbox::MLKEM1024::kPkSize;
                break;
                case lime::Ktype::privateKey:
                    return bctoolbox::MLKEM1024::kSkSize;
                break;
                case lime::Ktype::cipherText:
                    return bctoolbox::MLKEM1024::kCtSize;
                break;
                case lime::Ktype::sharedSecret:
                    return bctoolbox::MLKEM1024::kSsSize;
                break;
            }
            return 0; // make compiler happy
        };
    };

    // Hybrids: c25519/kyber512 c25519/mlkem512, c448/mlkem1024
    struct C255K512: public C255,K512 {
        static constexpr lime::CurveId curveId(void) {return lime::CurveId::c25519k512;};
        using EC = C255;
        using KEM = K512;
    };
    struct C255MLK512: public C255,MLK512 {
        static constexpr lime::CurveId curveId(void) {return lime::CurveId::c25519mlk512;};
        using EC = C255;
        using KEM = MLK512;
    };
    struct C448MLK1024: public C448,MLK1024 {
        static constexpr lime::CurveId curveId(void) {return lime::CurveId::c448mlk1024;};
        using EC = C448;
        using KEM = MLK1024;
    };
#endif // HAVE_BCTBXPQ

    // Hash function defines
    struct SHA512 {
        static constexpr size_t ssize() {return 64;}
    };

    // AEAD function defines
    struct AES256GCM {
        static constexpr size_t keySize(void) {return 32;};
        static constexpr size_t tagSize(void) {return 16;};
    };
}

#endif /* lime_keys_hpp */