EAP.h

/*
    SPDX-License-Identifier: MIT
    Copyright © 1991-2024 Amebis
    Copyright © 2016 GÉANT
*/
 
 
#pragma once
 
#include "Common.h"
#include <eaphostpeerconfigapis.h>
#include <eaptypes.h>
#include <EapHostPeerTypes.h>
#include <eapmethodtypes.h>
#include <eappapis.h>
#include <WinSock2.h>
#include <memory>
 
#pragma warning(push)
#pragma warning(disable: 26812) // Windows EAP API is using unscoped enums
 
#pragma warning(push)
#pragma warning(disable: 4505) // Don't warn on unused code
 
 
static bool operator==(_In_ const EAP_METHOD_TYPE &a, _In_ const EAP_METHOD_TYPE &b) noexcept
{
    return
        a.eapType.type         == b.eapType.type         &&
        a.eapType.dwVendorId   == b.eapType.dwVendorId   &&
        a.eapType.dwVendorType == b.eapType.dwVendorType &&
        a.dwAuthorId           == a.dwAuthorId;
}
 
static bool operator!=(_In_ const EAP_METHOD_TYPE &a, _In_ const EAP_METHOD_TYPE &b) noexcept
{
    return !operator==(a, b);
}
 
 
#pragma warning(pop)
 
namespace winstd
{
 
    #pragma warning(suppress: 4480)
    enum class eap_type_t : unsigned char {
        undefined       =   0,          
        identity        =   1,          
        notification    =   2,          
        nak             =   3,          
        md5_challenge   =   4,          
        otp             =   5,          
        gtc             =   6,          
        tls             =  13,          
        ttls            =  21,          
        peap            =  25,          
        mschapv2        =  26,          
        ms_auth_tlv     =  33,          
 
        gtcp            = 128 + gtc,    
 
        legacy_pap      = 192,          
        legacy_mschapv2 = 193,          
 
        start           =   1,          
        end             = 192,          
        noneap_start    = 192,          
        noneap_end      = 254,          
    };
 
    struct EapHostPeerFreeMemory_delete
    {
        EapHostPeerFreeMemory_delete() noexcept {}
 
        template <class _T>
        void operator()(_T *_Ptr) const
        {
            EapHostPeerFreeMemory((BYTE*)_Ptr);
        }
    };
 
    typedef std::unique_ptr<BYTE[], EapHostPeerFreeMemory_delete> eap_blob;
 
    struct EapHostPeerFreeRuntimeMemory_delete
    {
        EapHostPeerFreeRuntimeMemory_delete() noexcept {}
 
        template <class _T>
        void operator()(_T *_Ptr) const
        {
            EapHostPeerFreeRuntimeMemory((BYTE*)_Ptr);
        }
    };
 
    typedef std::unique_ptr<BYTE[], EapHostPeerFreeRuntimeMemory_delete> eap_blob_runtime;
 
    struct EapHostPeerFreeErrorMemory_delete
    {
        EapHostPeerFreeErrorMemory_delete() noexcept {}
 
        void operator()(EAP_ERROR *_Ptr) const noexcept
        {
            EapHostPeerFreeErrorMemory(_Ptr);
        }
    };
 
    typedef std::unique_ptr<EAP_ERROR, EapHostPeerFreeErrorMemory_delete> eap_error;
 
    struct EapHostPeerFreeEapError_delete
    {
        EapHostPeerFreeEapError_delete() noexcept {}
 
        void operator()(EAP_ERROR *_Ptr) const noexcept
        {
            EapHostPeerFreeEapError(_Ptr);
        }
    };
 
    typedef std::unique_ptr<EAP_ERROR, EapHostPeerFreeEapError_delete> eap_error_runtime;
 
    #pragma warning(push)
    #pragma warning(disable: 26432) // Copy constructor and assignment operator are also present, but not detected by code analysis as they are using base type source object reference.
    class eap_attr : public EAP_ATTRIBUTE
    {
    public:
        eap_attr() noexcept
        {
            eaType   = eatReserved;
            dwLength = 0;
            pValue   = NULL;
        }
 
        eap_attr(_In_ const EAP_ATTRIBUTE &a)
        {
            eaType   = a.eaType;
            dwLength = a.dwLength;
            if (a.dwLength) {
                pValue = new BYTE[a.dwLength];
                memcpy(pValue, a.pValue, a.dwLength);
            } else
                pValue = NULL;
        }
 
        eap_attr(_Inout_ eap_attr &&a) noexcept
        {
            eaType   = a.eaType;
            dwLength = a.dwLength;
            if (a.dwLength) {
                pValue     = a.pValue;
                a.dwLength = 0;
                a.pValue   = NULL;
            } else
                pValue = NULL;
        }
 
        ~eap_attr()
        {
            if (pValue)
                delete [] pValue;
        }
 
        eap_attr& operator=(_In_ const EAP_ATTRIBUTE &a)
        {
            if (this != &a) {
                eaType   = a.eaType;
                dwLength = a.dwLength;
                if (a.dwLength) {
                    BYTE *pValueNew = new BYTE[a.dwLength];
                    if (pValue)
                        delete [] pValue;
                    memcpy(pValueNew, a.pValue, a.dwLength);
                    pValue = pValueNew;
                } else
                    pValue = NULL;
            }
            return *this;
        }
 
        eap_attr& operator=(_Inout_ eap_attr &&a) noexcept
        {
            if (this != &a) {
                eaType   = a.eaType;
                dwLength = a.dwLength;
                if (pValue)
                    delete [] pValue;
                if (a.dwLength) {
                    pValue     = a.pValue;
                    a.dwLength = 0;
                    a.pValue   = NULL;
                } else
                    pValue = NULL;
            }
            return *this;
        }
 
        void create_ms_mppe_key(_In_ BYTE bVendorType, _In_count_(nKeySize) LPCBYTE pbKey, _In_ BYTE nKeySize)
        {
            const BYTE nPaddingLength = static_cast<BYTE>((16 - (1 + static_cast<DWORD>(nKeySize))) % 16);
            const DWORD dwLengthNew =
                4              + // Vendor-Id
                1              + // Vendor type
                1              + // Vendor length
                2              + // Salt
                1              + // Key-Length
                nKeySize       + // Key
                nPaddingLength;  // Padding
 
        #pragma warning(push)
        #pragma warning(disable: 6386)
            LPBYTE p = new BYTE[dwLengthNew];
            p[0] = 0x00;                                    // Vendor-Id (0x137 = 311 = Microsoft)
            p[1] = 0x00;                                    // --|
            p[2] = 0x01;                                    // --|
            p[3] = 0x37;                                    // --^
            p[4] = bVendorType;                             // Vendor type
            p[5] = static_cast<BYTE>(dwLengthNew - 4);      // Vendor length
            p[6] = 0x00;                                    // Salt
            p[7] = 0x00;                                    // --^
            p[8] = nKeySize;                                // Key-Length
        #pragma warning(pop)
            memcpy(p + 9, pbKey, nKeySize);                 // Key
            memset(p + 9 + nKeySize, 0, nPaddingLength);    // Padding
 
            if (pValue)
                delete [] pValue;
 
            #pragma warning(suppress: 26812) // EAP_ATTRIBUTE_TYPE is unscoped.
            eaType   = eatVendorSpecific;
            dwLength = dwLengthNew;
            pValue   = p;
        }
    };
    #pragma warning(pop)
 
    static const EAP_ATTRIBUTE blank_eap_attr = {};
 
    class eap_method_prop : public EAP_METHOD_PROPERTY
    {
    public:
        eap_method_prop(_In_ EAP_METHOD_PROPERTY_TYPE type, _In_ BOOL value) noexcept
        {
            eapMethodPropertyType                  = type;
            eapMethodPropertyValueType             = empvtBool;
            eapMethodPropertyValue.empvBool.length = sizeof(BOOL);
            eapMethodPropertyValue.empvBool.value  = value;
        }
 
        eap_method_prop(_In_ EAP_METHOD_PROPERTY_TYPE type, _In_ DWORD value) noexcept
        {
            eapMethodPropertyType                   = type;
            eapMethodPropertyValueType              = empvtDword;
            eapMethodPropertyValue.empvDword.length = sizeof(DWORD);
            eapMethodPropertyValue.empvDword.value  = value;
        }
 
        eap_method_prop(_In_ EAP_METHOD_PROPERTY_TYPE type, _In_z_ LPCWSTR value) noexcept
        {
            eapMethodPropertyType                    = type;
            eapMethodPropertyValueType               = empvtString;
            eapMethodPropertyValue.empvString.length = static_cast<DWORD>(sizeof(WCHAR)*(wcslen(value) + 1));
            eapMethodPropertyValue.empvString.value  = const_cast<BYTE*>(reinterpret_cast<const BYTE*>(value));
        }
    };
 
    class eap_packet : public dplhandle<EapPacket*, NULL>
    {
        WINSTD_DPLHANDLE_IMPL(eap_packet, EapPacket*, NULL)
 
    public:
        virtual ~eap_packet()
        {
            if (m_h != invalid)
                free_internal();
        }
 
        bool create(_In_ EapCode code, _In_ BYTE id, _In_ WORD size) noexcept
        {
            assert(size >= 4); // EAP packets must contain at least Code, Id, and Length fields: 4B.
 
            handle_type h = static_cast<handle_type>(HeapAlloc(GetProcessHeap(), 0, size));
            if (h != NULL) {
                h->Code = static_cast<BYTE>(code);
                h->Id = id;
                *reinterpret_cast<WORD*>(h->Length) = htons(size);
 
                attach(h);
                return true;
            } else {
                SetLastError(ERROR_OUTOFMEMORY);
                return false;
            }
        }
 
        WORD size() const noexcept
        {
            return m_h != NULL ? ntohs(*(WORD*)m_h->Length) : 0;
        }
 
    protected:
        void free_internal() noexcept override
        {
            HeapFree(GetProcessHeap(), 0, m_h);
        }
 
        handle_type duplicate_internal(_In_ handle_type h) const override
        {
            assert(h);
            const WORD n = ntohs(*reinterpret_cast<WORD*>(h->Length));
            handle_type h2 = static_cast<handle_type>(HeapAlloc(GetProcessHeap(), 0, n));
            if (h2 != invalid) {
                _Analysis_assume_(h2 != NULL); // VS2022 can't figure out `invalid` is `NULL`
                memcpy(h2, h, n);
                return h2;
            }
            throw std::bad_alloc();
        }
    };
 
    class eap_method_info_array : public EAP_METHOD_INFO_ARRAY
    {
        WINSTD_NONCOPYABLE(eap_method_info_array)
 
    public:
        eap_method_info_array() noexcept
        {
            dwNumberOfMethods = 0;
            pEapMethods       = NULL;
        }
 
        eap_method_info_array(_Inout_ eap_method_info_array &&other) noexcept
        {
            dwNumberOfMethods       = other.dwNumberOfMethods;
            pEapMethods             = other.pEapMethods;
            other.dwNumberOfMethods = 0;
            other.pEapMethods       = NULL;
        }
 
        ~eap_method_info_array()
        {
            if (pEapMethods)
                free_internal();
        }
 
        eap_method_info_array& operator=(_Inout_ eap_method_info_array &&other) noexcept
        {
            if (this != std::addressof(other)) {
                if (pEapMethods)
                    free_internal();
                dwNumberOfMethods       = other.dwNumberOfMethods;
                pEapMethods             = other.pEapMethods;
                other.dwNumberOfMethods = 0;
                other.pEapMethods       = NULL;
            }
            return *this;
        }
 
    protected:
 
        void free_internal() noexcept
        {
            for (DWORD i = 0; i < dwNumberOfMethods; i++)
                free_internal(pEapMethods + i);
 
            EapHostPeerFreeMemory(reinterpret_cast<BYTE*>(pEapMethods));
        }
 
        static void free_internal(_In_ EAP_METHOD_INFO *pMethodInfo) noexcept
        {
            if (pMethodInfo->pInnerMethodInfo)
                free_internal(pMethodInfo->pInnerMethodInfo);
 
            EapHostPeerFreeMemory(reinterpret_cast<BYTE*>(pMethodInfo->pwszAuthorName));
            EapHostPeerFreeMemory(reinterpret_cast<BYTE*>(pMethodInfo->pwszFriendlyName));
        }
 
    };
 
 
 
    class eap_runtime_error : public win_runtime_error
    {
    public:
        eap_runtime_error(_In_ const EAP_ERROR &err, _In_ const std::string& msg) :
            m_type           (err.type                   ),
            m_reason         (err.dwReasonCode           ),
            m_root_cause_id  (err.rootCauseGuid          ),
            m_root_cause_desc(err.pRootCauseString       ),
            m_repair_id      (err.repairGuid             ),
            m_repair_desc    (err.pRepairString          ),
            m_help_link_id   (err.helpLinkGuid           ),
            win_runtime_error(err.dwWinError, msg.c_str())
        {}
 
        eap_runtime_error(_In_ const EAP_ERROR &err) :
            m_type           (err.type            ),
            m_reason         (err.dwReasonCode    ),
            m_root_cause_id  (err.rootCauseGuid   ),
            m_root_cause_desc(err.pRootCauseString),
            m_repair_id      (err.repairGuid      ),
            m_repair_desc    (err.pRepairString   ),
            m_help_link_id   (err.helpLinkGuid    ),
            win_runtime_error(err.dwWinError      )
        {}
 
        eap_runtime_error(_In_ const EAP_ERROR &err, _In_z_ const char *msg) :
            m_type           (err.type            ),
            m_reason         (err.dwReasonCode    ),
            m_root_cause_id  (err.rootCauseGuid   ),
            m_root_cause_desc(err.pRootCauseString),
            m_repair_id      (err.repairGuid      ),
            m_repair_desc    (err.pRepairString   ),
            m_help_link_id   (err.helpLinkGuid    ),
            win_runtime_error(err.dwWinError, msg )
        {}
 
        const EAP_METHOD_TYPE& type() const noexcept
        {
            return m_type;
        }
 
        DWORD reason() const noexcept
        {
            return m_reason;
        }
 
        const GUID& root_cause_id() const noexcept
        {
            return m_root_cause_id;
        }
 
        const wchar_t* root_cause() const noexcept
        {
            return m_root_cause_desc.c_str();
        }
 
        const GUID& repair_id() const noexcept
        {
            return m_repair_id;
        }
 
        const wchar_t* repair() const noexcept
        {
            return m_repair_desc.c_str();
        }
 
        const GUID& help_link_id() const noexcept
        {
            return m_help_link_id;
        }
 
    protected:
        EAP_METHOD_TYPE m_type;         
 
        DWORD m_reason;                 
 
        GUID m_root_cause_id;           
        std::wstring m_root_cause_desc; 
 
        GUID m_repair_id;               
        std::wstring m_repair_desc;     
 
        GUID m_help_link_id;            
    };
 
}
 
#pragma warning(pop)