subject_attribute.hpp

#ifndef SUBJECT_ATTRIBUTE_HPP_IRZLEB7C
#define SUBJECT_ATTRIBUTE_HPP_IRZLEB7C
 
#include <vanetza/security/v2/int_x.hpp>
#include <vanetza/security/v2/public_key.hpp>
#include <vanetza/security/v2/serialization.hpp>
#include <boost/variant/variant.hpp>
#include <cstdint>
#include <list>
 
namespace vanetza
{
namespace security
{
namespace v2
{
 
/// SubjectAssurance specified in TS 103 097 v1.2.1 in section 6.6 and 7.4.1
struct SubjectAssurance
{
    SubjectAssurance(uint8_t _raw = 0) : raw(_raw) {}
 
    static constexpr uint8_t assurance_mask = 0xE0;
    static constexpr uint8_t confidence_mask = 0x03;
 
    uint8_t raw;
 
    uint8_t assurance() const
    {
        return (raw & assurance_mask) >> 5;
    }
 
    uint8_t confidence() const
    {
        return raw & confidence_mask;
    }
};
 
/// ItsAidSsp specified in TS 103 097 v1.2.1, section 6.9
struct ItsAidSsp
{
    IntX its_aid;
    ByteBuffer service_specific_permissions;
};
 
/// SubjectAttributeType specified in TS 103 097 v1.2.1, section 6.5
enum class SubjectAttributeType : uint8_t {
    Verification_Key = 0,       //VerificationKey
    Encryption_Key = 1,         //EncryptionKey
    Assurance_Level = 2,        //SubjectAssurance
    Reconstruction_Value = 3,   //EccPoint
    ITS_AID_List = 32,          //std::list<IntX>
    ITS_AID_SSP_List = 33,      //std::list<ItsAidSsp>
};
 
/// VerificationKey specified in TS 103 097 v1.2.1, section 6.4
struct VerificationKey
{
    PublicKey key;
};
 
/// EncryptionKey specified in TS 103 097 v1.2.1, section 6.4
struct EncryptionKey
{
    PublicKey key;
};
 
/// SubjectAttribute specified in TS 103 097 v1.2.1, section 6.4
using SubjectAttribute = boost::variant<
    VerificationKey,
    EncryptionKey,
    SubjectAssurance,
    EccPoint,
    std::list<IntX>,
    std::list<ItsAidSsp>
>;
 
/**
 * \brief Determines SubjectAttributeType to a given SubjectAttribute
 * \param attribute
 * \return type
 */
SubjectAttributeType get_type(const SubjectAttribute&);
 
/**
 * \brief Calculates size of a SubjectAttribute
 * \param sub
 * \return number of octets needed to serialize the SubjectAttribute
 */
size_t get_size(const SubjectAttribute&);
 
/**
 * \brief Calculates size of a SubjectAssurance
 * \param sub
 * \return number of octets needed to serialize the SubjectAssurance
 */
size_t get_size(const SubjectAssurance&);
 
/**
 * \brief Calculates size of an ItsAidSsp
 * \param its_aid_ssp
 * \return number of octets needed to serialize the ItsAidSsp
 */
size_t get_size(const ItsAidSsp&);
 
/**
 * \brief Deserializes a SubjectAttribute from a binary archive
 * \param ar with a serialized SubjectAttribute at the beginning
 * \param sub to deserialize
 * \return size of the deserialized SubjectAttribute
 */
size_t deserialize(InputArchive&, SubjectAttribute&);
 
/**
 * \brief Deserializes an ItsAidSsp from a binary archive
 * \param ar with a serialized ItsAidSsp at the beginning
 * \param its_aid_ssp to deserialize
 * \return size of the deserialized ItsAidSsp
 */
size_t deserialize(InputArchive&, ItsAidSsp&);
 
/**
 * \brief Serializes a SubjectAttribute into a binary archive
 * \param ar to serialize in
 * \param sub to serialize
 */
void serialize(OutputArchive&, const SubjectAttribute&);
 
/**
 * \brief Serializes an ItsAidSsp into a binary archive
 * \param ar to serialize in
 * \param its_aid_ssp to serialize
 */
void serialize(OutputArchive&, const ItsAidSsp&);
 
namespace detail
{
 
template<SubjectAttributeType>
struct subject_attribute_type;
 
template<>
struct subject_attribute_type<SubjectAttributeType::Verification_Key>
{
    using type = VerificationKey;
};
 
template<>
struct subject_attribute_type<SubjectAttributeType::Encryption_Key>
{
    using type = EncryptionKey;
};
 
template<>
struct subject_attribute_type<SubjectAttributeType::Assurance_Level>
{
    using type = SubjectAssurance;
};
 
template<>
struct subject_attribute_type<SubjectAttributeType::Reconstruction_Value>
{
    using type = EccPoint;
};
 
template<>
struct subject_attribute_type<SubjectAttributeType::ITS_AID_List>
{
    using type = std::list<IntX>;
};
 
template<>
struct subject_attribute_type<SubjectAttributeType::ITS_AID_SSP_List>
{
    using type = std::list<ItsAidSsp>;
};
 
} // namespace detail
 
/**
 * \brief resolve type for matching SubjectAttributeType
 *
 * This is kind of the reverse function of get_type(const SubjectAttribute&)
 */
template<SubjectAttributeType T>
using subject_attribute_type = typename detail::subject_attribute_type<T>::type;
 
} // namespace v2
} // namespace security
} // namespace vanetza
 
#endif /* SUBJECT_ATTRIBUTE_HPP_IRZLEB7C */