cSecurityAttributes.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cSecurityAttributes_H
#define _INC_cSecurityAttributes_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cWinHeap2.h"
 
#if defined(_WIN32) && ! defined(UNDER_CE)
#include <accctrl.h>
 
#ifdef __GNUC__
#define SDDL_REVISION_1 1
enum WELL_KNOWN_SID_TYPE
{
        WinNullSid = 0,
        WinWorldSid = 1,
        WinLocalSid = 2,
};
#define SID_MAX_SUB_AUTHORITIES 15
#define SECURITY_MAX_SID_SIZE  (sizeof(SID) - sizeof(DWORD) + (SID_MAX_SUB_AUTHORITIES * sizeof(DWORD)))
#endif
 
namespace Gray
{
        class GRAYCORE_LINK cSecurityId : private CWinLocalT < SID >
        {
 
                typedef CWinLocalT<SID> SUPER_t;
        public:
                cSecurityId();
                cSecurityId(WELL_KNOWN_SID_TYPE eWellKnownSidType);
                ~cSecurityId();
 
                SID* get_SID() const
                {
                        // like PSID and PISID // variable length?
                        return SUPER_t::get_Data();
                }
                operator SID*()
                {
                        return get_SID();
                }
                bool isValid() const
                {
                        if (get_Data() == nullptr)
                                return false;
                        return ::IsValidSid(get_Data());
                }
 
                size_t get_Length() const
                {
                        return ::GetLengthSid(get_SID());
                }
 
                bool SetSID(SID* pSID);
                cString GetStringSID() const;
                bool SetStringSID(const GChar_t* pszSID);
 
                HRESULT SetByUserName(const GChar_t* pszUserName);
        };
 
        class GRAYCORE_LINK cSecurityACL : private CWinLocalT < ACL >
        {
 
                typedef CWinLocalT<ACL> SUPER_t;
        public:
                cSecurityACL(SID* pSidFirst = nullptr, DWORD dwAccessMask = GENERIC_ALL);
                ~cSecurityACL();
 
                ACL* get_ACL() const
                {
                        return SUPER_t::get_Data();
                }
                operator ACL*()
                {
                        return get_ACL();
                }
                bool isValid() const
                {
                        if (get_ACL() == nullptr)
                                return false;
                        return(::IsValidAcl(get_ACL()));
                }
                int get_AceCount() const
                {
                        if (get_ACL() == nullptr)
                                return 0;
                        return get_ACL()->AceCount;
                }
 
                bool AddAllowedAce(SID* pSid, DWORD dwAccessMask = GENERIC_ALL);
        };
 
        class GRAYCORE_LINK cSecurityDesc : public CWinLocalT < SECURITY_DESCRIPTOR >
        {
 
        public:
                static const FILECHAR_t* k_szLowIntegrity;      // L"S:(ML;;NW;;;LW)";
 
        public:
                cSecurityDesc(ACL* pDacl = nullptr);
                cSecurityDesc(const FILECHAR_t* pszSaclName);
                ~cSecurityDesc();
 
                bool InitSecurityDesc(const FILECHAR_t* pszSaclName);
                bool InitLowIntegrity();
 
                operator SECURITY_DESCRIPTOR*()
                {
                        return get_Data();
                }
                static bool GRAYCALL IsValid(SECURITY_DESCRIPTOR* pSD) noexcept
                {
                        if (pSD == nullptr)     // null is valid.
                                return true;
                        return ::IsValidSecurityDescriptor(pSD);
                }
                bool isValid() const noexcept
                {
                        return IsValid(get_Data());
                }
                ACL* GetSacl(BOOL* pbSaclPresent = nullptr, BOOL* pbSaclDefaulted = nullptr) const
                {
                        ACL* pSacl = nullptr;
                        if (!::GetSecurityDescriptorSacl(get_Data(), pbSaclPresent, &pSacl, pbSaclDefaulted))
                        {
                                return nullptr;
                        }
                        return(pSacl);
                }
                BOOL SetSacl(ACL* pSacl, bool bSaclPresent = true, bool bSaclDefaulted = false)
                {
                        return ::SetSecurityDescriptorSacl(get_Data(), bSaclPresent, pSacl, bSaclDefaulted);
                }
#if 0
                BOOL SetSaclRules(size_t nCount, EXPLICIT_ACCESS* pRules)
                {
                        ACL* pSacl = nullptr;
                        LSTATUS iRet = ::SetEntriesInAcl(nCount, pRules, nullptr, &pSacl);
                        if (iRet != NO_ERROR)
                                return false;
                        return SetSacl(pSacl);
                }
#endif
 
                ACL* GetDacl(BOOL* pbDaclPresent = nullptr, BOOL* pbDaclDefaulted = nullptr) const
                {
                        ACL* pDacl = nullptr;
                        if (!::GetSecurityDescriptorDacl(get_Data(), pbDaclPresent, &pDacl, pbDaclDefaulted))
                        {
                                return nullptr;
                        }
                        return(pDacl);
                }
                BOOL SetDacl(ACL* pDacl, bool bDaclPresent = true, bool bDaclDefaulted = false)
                {
                        return ::SetSecurityDescriptorDacl(get_Data(), bDaclPresent, pDacl, bDaclDefaulted);
                }
                BOOL SetOwner(PSID pOwner = nullptr, BOOL bOwnerDefaulted = true)
                {
                        // default = clear.
                        return ::SetSecurityDescriptorOwner(get_Data(), pOwner, bOwnerDefaulted);
                }
 
                bool AttachToObject(HANDLE hObject, SE_OBJECT_TYPE type = SE_KERNEL_OBJECT) const;
        };
 
        class GRAYCORE_LINK cSecurityAttributes : public SECURITY_ATTRIBUTES
        {
 
        public:
                cSecurityDesc m_sd;     
 
        protected:
                void UpdateSecurityDescriptor();
 
        public:
                cSecurityAttributes(bool bInheritHandle = false, ACL* pDacl = nullptr);
                cSecurityAttributes(bool bInheritHandle, const FILECHAR_t* pszSaclName);
                ~cSecurityAttributes(void);
 
                operator SECURITY_ATTRIBUTES*()
                {
                        return static_cast<SECURITY_ATTRIBUTES*>(this);
                }
                bool isValid() const noexcept;
 
                UNITTEST_FRIEND(cSecurityAttributes);
        };
 
        class GRAYCORE_LINK cSecurityAttribsLowIntegrity : public cSecurityAttributes
        {
        public:
                cSecurityAttribsLowIntegrity(bool bInheritHandle = false)
                : cSecurityAttributes(bInheritHandle, cSecurityDesc::k_szLowIntegrity)
                {
                }
                ~cSecurityAttribsLowIntegrity()
                {
                }
        };
 
        class GRAYCORE_LINK cSecurityAttribsWKS : public cSecurityAttributes
        {
        public:
                cSecurityAttribsWKS(WELL_KNOWN_SID_TYPE eWellKnownSidType = WinLocalSid, DWORD dwAccess = GENERIC_ALL, bool bInheritHandle = true)
                : cSecurityAttributes(bInheritHandle)
                , m_sid(eWellKnownSidType)
                , m_dacl(m_sid, dwAccess)
                {
                        m_sd.SetDacl(m_dacl);
                        UpdateSecurityDescriptor();
                }
                ~cSecurityAttribsWKS()
                {
                }
        public:
                cSecurityId m_sid;      
                cSecurityACL m_dacl;
        };
};
#endif  // _WIN32
#endif  // cSecurityAttributes