AWSCredentials.h

 
 #pragma once
 
#include <aws/core/Core_EXPORTS.h>
#include <aws/core/client/UserAgent.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/DateTime.h>
#include <aws/core/platform/Security.h>
namespace Aws
{
    namespace Auth
    {
        class AWS_CORE_API CredentialsResolutionContext
        {
        public:
          // Default constructor - no features tracked
          CredentialsResolutionContext() = default;
 
          void AddUserAgentFeature(Aws::Client::UserAgentFeature feature)
          {
            m_features.insert(feature);
          }
 
          const Aws::Set<Aws::Client::UserAgentFeature> GetUserAgentFeatures() const
          {
            return m_features;
          }
 
        private:
          Aws::Set<Aws::Client::UserAgentFeature> m_features;
        };
 
        class AWS_CORE_API AWSCredentials
        {
        public:
            AWSCredentials() : m_expiration((std::chrono::time_point<std::chrono::system_clock>::max)())
            {
            }
 
            AWSCredentials(const Aws::String& accessKeyId, const Aws::String& secretKey) :
                m_accessKeyId(accessKeyId), m_secretKey(secretKey), m_expiration((std::chrono::time_point<std::chrono::system_clock>::max)())
            {
            }
 
            AWSCredentials(const Aws::String& accessKeyId, const Aws::String& secretKey, const Aws::String& sessionToken) :
                m_accessKeyId(accessKeyId), m_secretKey(secretKey), m_sessionToken(sessionToken), m_expiration((std::chrono::time_point<std::chrono::system_clock>::max)())
            {
            }
 
            AWSCredentials(const Aws::String& accessKeyId, const Aws::String& secretKey, const Aws::String& sessionToken, Aws::Utils::DateTime expiration) :
                m_accessKeyId(accessKeyId), m_secretKey(secretKey), m_sessionToken(sessionToken), m_expiration(expiration)
            {
            }
 
            AWSCredentials(const Aws::String& accessKeyId,
                           const Aws::String& secretKey,
                           const Aws::String& sessionToken,
                           Aws::Utils::DateTime expiration,
                           const Aws::String& accountId)
                : m_accessKeyId(accessKeyId),
                  m_secretKey(secretKey),
                  m_sessionToken(sessionToken),
                  m_expiration(expiration),
                  m_accountId(accountId) {}
 
            AWSCredentials(const AWSCredentials& other) = default;
 
            AWSCredentials(AWSCredentials&& other) noexcept = default;
 
            ~AWSCredentials()
            {
                // Securely clear sensitive credential data
                if (!m_secretKey.empty())
                {
                    Aws::Security::SecureMemClear(reinterpret_cast<unsigned char*>(&m_secretKey[0]), m_secretKey.size());
                }
                if (!m_sessionToken.empty())
                {
                    Aws::Security::SecureMemClear(reinterpret_cast<unsigned char*>(&m_sessionToken[0]), m_sessionToken.size());
                }
            }
 
            AWSCredentials& operator=(const AWSCredentials& other) = default;
 
            AWSCredentials& operator=(AWSCredentials&& other) noexcept = default;
 
            bool operator == (const AWSCredentials& other) const
            {
                return m_accessKeyId  == other.m_accessKeyId
                    && m_secretKey    == other.m_secretKey
                    && m_sessionToken == other.m_sessionToken
                    && m_expiration   == other.m_expiration
                    && m_accountId    == other.m_accountId;
 
            }
 
            bool operator != (const AWSCredentials& other) const
            {
                return !(other == *this);
            }
 
            inline bool IsEmpty() const { return m_accessKeyId.empty() && m_secretKey.empty(); }
 
            inline bool IsExpired() const { return m_expiration <= Aws::Utils::DateTime::Now(); }
 
            inline bool ExpiresSoon(int64_t millisecondThreshold = 5000) const { return (m_expiration - Aws::Utils::DateTime::Now()).count() < millisecondThreshold; }
 
            inline bool IsExpiredOrEmpty() const { return IsEmpty() || IsExpired(); }
 
            inline const Aws::String& GetAWSAccessKeyId() const
            {
                return m_accessKeyId;
            }
 
            inline const Aws::String& GetAWSSecretKey() const
            {
                return m_secretKey;
            }
 
            inline const Aws::String& GetSessionToken() const
            {
                return m_sessionToken;
            }
 
            inline Aws::Utils::DateTime GetExpiration() const
            {
                return m_expiration;
            }
 
            inline const Aws::String& GetAccountId() const
            {
              return m_accountId;
            }
 
            inline void SetAWSAccessKeyId(const Aws::String& accessKeyId)
            {
                m_accessKeyId = accessKeyId;
            }
 
            inline void SetAWSSecretKey(const Aws::String& secretKey)
            {
                m_secretKey = secretKey;
            }
 
            inline void SetSessionToken(const Aws::String& sessionToken)
            {
                m_sessionToken = sessionToken;
            }
 
            inline void SetAccountId(const Aws::String& accountId)
            {
                m_accountId = accountId;
            }
 
 
            inline void SetAWSAccessKeyId(const char* accessKeyId)
            {
                m_accessKeyId = accessKeyId;
            }
 
            inline void SetAWSSecretKey(const char* secretKey)
            {
                m_secretKey = secretKey;
            }
 
            inline void SetSessionToken(const char* sessionToken)
            {
                m_sessionToken = sessionToken;
            }
 
            inline void SetAccountId(const char* accountId)
            {
                m_accountId = accountId;
            }
 
            inline void SetExpiration(Aws::Utils::DateTime expiration)
            {
                m_expiration = expiration;
            }
 
            inline CredentialsResolutionContext GetContext() { return m_context; }
 
            inline void AddUserAgentFeature(Aws::Client::UserAgentFeature feature) { m_context.AddUserAgentFeature(feature); }
        private:
            Aws::String m_accessKeyId;
            Aws::String m_secretKey;
            Aws::String m_sessionToken;
            Aws::Utils::DateTime m_expiration;
            Aws::String m_accountId;
            CredentialsResolutionContext m_context;
        };
    }
}