Authentication & Credentials

class AccessKeyCredential:
    def __init__(self, access_key_id, access_key_secret):
        """
        Initialize access key credential for basic authentication.
        
        Parameters:
        - access_key_id (str): Access key ID from Alibaba Cloud console
        - access_key_secret (str): Access key secret from Alibaba Cloud console
        """
        self.access_key_id = access_key_id
        self.access_key_secret = access_key_secret

class StsTokenCredential:
    def __init__(self, sts_access_key_id, sts_access_key_secret, sts_token):
        """
        Initialize STS token credential for temporary authentication.
        
        Parameters:
        - sts_access_key_id (str): Temporary access key ID from STS
        - sts_access_key_secret (str): Temporary access key secret from STS
        - sts_token (str): Security token from STS
        """
        self.sts_access_key_id = sts_access_key_id
        self.sts_access_key_secret = sts_access_key_secret
        self.sts_token = sts_token

class RamRoleArnCredential:
    def __init__(self, sts_access_key_id, sts_access_key_secret, role_arn, session_role_name):
        """
        Initialize RAM role ARN credential for role-based authentication.
        
        Parameters:
        - sts_access_key_id (str): STS access key ID for role assumption
        - sts_access_key_secret (str): STS access key secret for role assumption
        - role_arn (str): ARN of the RAM role to assume
        - session_role_name (str): Session name for the assumed role
        """
        self.sts_access_key_id = sts_access_key_id
        self.sts_access_key_secret = sts_access_key_secret
        self.role_arn = role_arn
        self.session_role_name = session_role_name

class EcsRamRoleCredential:
    def __init__(self, role_name):
        """
        Initialize ECS RAM role credential for instance-based authentication.
        
        Parameters:
        - role_name (str): Name of the RAM role attached to the ECS instance
        """
        self.role_name = role_name

class RsaKeyPairCredential:
    def __init__(self, public_key_id, private_key, session_period=3600):
        """
        Initialize RSA key pair credential for public-key authentication.
        
        Parameters:
        - public_key_id (str): ID of the uploaded RSA public key
        - private_key (str): RSA private key content (PEM format)
        - session_period (int): Session duration in seconds, defaults to 3600
        """
        self.public_key_id = public_key_id
        self.private_key = private_key
        self.session_period = session_period

class AccessKeySigner:
    """Signer for access key authentication."""

class StsTokenSigner:
    """Signer for STS token authentication."""

class RamRoleArnSigner:
    """Signer for RAM role ARN authentication."""

class EcsRamRoleSigner:
    """Signer for ECS RAM role authentication."""

class RsaKeyPairSigner:
    """Signer for RSA key pair authentication."""

class SignerFactory:
    @staticmethod
    def create_signer(credential, region_id=None):
        """
        Create appropriate signer based on credential type.
        
        Parameters:
        - credential: Credential object (AccessKeyCredential, StsTokenCredential, etc.)
        - region_id (str, optional): Target region ID
        
        Returns:
        Signer: Appropriate signer instance for the credential type
        """

from aliyunsdkcore.client import AcsClient
from aliyunsdkcore.auth.credentials import AccessKeyCredential

# Create access key credential
credential = AccessKeyCredential(
    access_key_id="LTAI4Gxxxxxxxxxxxxxxxx",
    access_key_secret="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
)

# Initialize client with credential
client = AcsClient(credential=credential, region_id="cn-hangzhou")

from aliyunsdkcore.auth.credentials import StsTokenCredential

# Create STS token credential (typically obtained from STS service)
credential = StsTokenCredential(
    sts_access_key_id="STS.Nxxxxxxxxxxxxxxxx",
    sts_access_key_secret="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
    sts_token="CAIS8wF1q6Ft5B2yfSjIr5D2K..." # Long STS token
)

client = AcsClient(credential=credential, region_id="cn-beijing")

from aliyunsdkcore.auth.credentials import RamRoleArnCredential

# Create RAM role ARN credential
credential = RamRoleArnCredential(
    sts_access_key_id="LTAI4Gxxxxxxxxxxxxxxxx",
    sts_access_key_secret="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
    role_arn="acs:ram::123456789012****:role/MyRole",
    session_role_name="MySessionName"
)

client = AcsClient(credential=credential, region_id="cn-shanghai")

from aliyunsdkcore.auth.credentials import EcsRamRoleCredential

# Create ECS RAM role credential (for use on ECS instances)
credential = EcsRamRoleCredential(role_name="MyEcsRole")

client = AcsClient(credential=credential, region_id="cn-shenzhen")

from aliyunsdkcore.auth.credentials import RsaKeyPairCredential

# Load private key from file
with open("private_key.pem", "r") as f:
    private_key = f.read()

# Create RSA key pair credential
credential = RsaKeyPairCredential(
    public_key_id="your-public-key-id",
    private_key=private_key,
    session_period=7200  # 2 hours
)

client = AcsClient(credential=credential, region_id="cn-qingdao")

# Direct access key parameters (legacy approach)
client = AcsClient(
    ak="LTAI4Gxxxxxxxxxxxxxxxx",
    secret="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
    region_id="cn-hangzhou"
)

# RSA key pair parameters (legacy approach)
client = AcsClient(
    public_key_id="your-public-key-id",
    private_key=private_key_content,
    session_period=3600,
    region_id="cn-hangzhou"
)

from aliyunsdkcore.acs_exception.exceptions import ClientException

try:
    # Create client with credentials
    client = AcsClient(credential=credential, region_id="cn-hangzhou")
    
    # Test authentication with a simple request
    from aliyunsdkcore.request import CommonRequest
    request = CommonRequest()
    request.set_domain("ecs.cn-hangzhou.aliyuncs.com")
    request.set_version("2014-05-26")
    request.set_action_name("DescribeRegions")
    request.set_method("POST")
    
    response = client.do_action_with_exception(request)
    print("Authentication successful")
    
except ClientException as e:
    if "InvalidAccessKeyId" in e.get_error_code():
        print("Invalid access key ID")
    elif "SignatureDoesNotMatch" in e.get_error_code():
        print("Invalid access key secret or signature error")
    else:
        print(f"Authentication error: {e.get_error_msg()}")

import os
from aliyunsdkcore.auth.credentials import AccessKeyCredential

# Load credentials from environment variables
ak = os.environ.get("ALIBABA_CLOUD_ACCESS_KEY_ID")
secret = os.environ.get("ALIBABA_CLOUD_ACCESS_KEY_SECRET")

if ak and secret:
    credential = AccessKeyCredential(ak, secret)
    client = AcsClient(credential=credential, region_id="cn-hangzhou")
else:
    raise ValueError("Missing required environment variables")