ctyun-cli 0.1.0a1__py3-none-any.whl

ctyun_cli/__init__.py

@@ -0,0 +1,22 @@
+"""
+天翼云CLI工具
+"""
+
+__version__ = "1.0.0"
+__author__ = "Your Name"
+__email__ = "your.email@example.com"
+
+from .client import CTYUNClient, CTYUNAPIError
+from .config.settings import ConfigManager, config
+
+__all__ = [
+    'CTYUNClient',
+    'CTYUNAPIError',
+    'ConfigManager',
+    'config'
+]
+
+def main():
+    """CLI主入口函数"""
+    from .cli.main import cli
+    cli()

ctyun_cli/auth/__init__.py

@@ -0,0 +1,5 @@
+"""认证模块"""
+
+from .signature import CTYUNAuth
+
+__all__ = ['CTYUNAuth']

ctyun_cli/auth/eop_signature.py

@@ -0,0 +1,235 @@
+"""
+天翼云EOP签名认证模块
+实现基于EOP规范的AK/SK签名认证机制
+"""
+
+import hashlib
+import hmac
+import base64
+import uuid
+from datetime import datetime
+from urllib.parse import quote
+from typing import Dict, Any, Optional
+
+
+class CTYUNEOPAuth:
+    """天翼云EOP签名认证类"""
+
+    def __init__(self, access_key: str, secret_key: str):
+        """
+        初始化认证器
+
+        Args:
+            access_key: 访问密钥（AK）
+            secret_key: 密钥（SK）
+        """
+        self.access_key = access_key
+        self.secret_key = secret_key
+
+    def sign_request(self, method: str, url: str, query_params: Optional[Dict[str, Any]] = None,
+                    body: Optional[str] = None, extra_headers: Optional[Dict[str, str]] = None) -> Dict[str, str]:
+        """
+        对请求进行签名，返回完整的请求头
+
+        Args:
+            method: HTTP方法
+            url: 请求URL
+            query_params: 查询参数
+            body: 请求体
+            extra_headers: 额外的请求头
+
+        Returns:
+            包含签名的请求头字典
+        """
+        # 生成必需的请求头
+        request_id = str(uuid.uuid4())
+        eop_date = self._get_eop_date()
+
+        # 构建基础请求头
+        headers = {
+            'Content-Type': 'application/json',
+            'ctyun-eop-request-id': request_id,
+            'Eop-date': eop_date
+        }
+
+        # 添加额外的请求头
+        if extra_headers:
+            headers.update(extra_headers)
+
+        # 步骤一：构造待签名字符串 signature
+        signature_string = self._build_signature_string(
+            headers, query_params, body
+        )
+
+        # 步骤二：构造动态密钥 kdate
+        kdate = self._build_kdate(eop_date)
+
+        # 步骤三：构造 signature
+        signature = self._build_signature(signature_string, kdate)
+
+        # 步骤四：构造 Eop-Authorization
+        eop_authorization = self._build_eop_authorization(signature, headers)
+
+        # 添加认证头
+        headers['Eop-Authorization'] = eop_authorization
+
+        return headers
+
+    def _get_eop_date(self) -> str:
+        """
+        获取EOP格式的日期时间
+        格式：yyyyMMdd'T'HHmmss'Z'
+        注意：实际传时间为北京东八区UTC+8时间，TZ仅为格式，非UTC时间
+
+        Returns:
+            EOP格式的日期时间字符串
+        """
+        # 获取当前北京时间（UTC+8）
+        now = datetime.now()
+        return now.strftime('%Y%m%dT%H%M%SZ')
+
+    def _build_signature_string(self, headers: Dict[str, str],
+                                query_params: Optional[Dict[str, Any]] = None,
+                                body: Optional[str] = None) -> str:
+        """
+        构造待签名字符串
+        sigture = 需要进行签名的Header排序后的组合列表 + "\n" + encode的query + "\n" + toHex(sha256(原封的body))
+
+        Args:
+            headers: 请求头字典
+            query_params: 查询参数
+            body: 请求体
+
+        Returns:
+            待签名字符串
+        """
+        # 1. 构造需要签名的Header排序后的组合列表
+        # EOP强制要求 ctyun-eop-request-id、eop-date 必须进行签名
+        signed_header_names = ['ctyun-eop-request-id', 'eop-date']
+        
+        # 按字母顺序排序
+        signed_header_names.sort()
+        
+        # 构造 header_name:header_value\n 格式
+        header_list = []
+        for header_name in signed_header_names:
+            # 注意：查找header时不区分大小写，但构造签名字符串时必须用小写
+            header_value = None
+            for k, v in headers.items():
+                if k.lower() == header_name.lower():
+                    header_value = v
+                    break
+            
+            if header_value:
+                header_list.append(f"{header_name.lower()}:{header_value}\n")
+        
+        header_string = ''.join(header_list)
+
+        # 2. 构造编码后的query字符串
+        query_string = ''
+        if query_params:
+            # 对参数按key排序
+            sorted_params = sorted(query_params.items())
+            encoded_params = []
+            for key, value in sorted_params:
+                # 值需要进行URL编码
+                encoded_value = quote(str(value), safe='')
+                encoded_params.append(f"{key}={encoded_value}")
+            query_string = '&'.join(encoded_params)
+
+        # 3. 对body进行SHA256摘要并转十六进制
+        if body is None or body == '':
+            body = ''
+        body_hash = hashlib.sha256(body.encode('utf-8')).hexdigest()
+
+        # 拼接最终的待签名字符串
+        # 格式：header_string + "\n" + query_string + "\n" + body_hash
+        signature_string = f"{header_string}\n{query_string}\n{body_hash}"
+
+        return signature_string
+
+    def _build_kdate(self, eop_date: str) -> bytes:
+        """
+        构造动态密钥 kdate
+
+        步骤：
+        1. ktime = hmacSHA256(eop_date, sk)
+        2. kAk = hmacSHA256(ak, ktime)
+        3. kdate = hmacSHA256(eop_date的年月日值, kAk)
+
+        Args:
+            eop_date: EOP格式的日期时间
+
+        Returns:
+            动态密钥 kdate
+        """
+        # 1. 使用eop_date作为数据，sk作为密钥，算出ktime
+        ktime = hmac.new(
+            self.secret_key.encode('utf-8'),
+            eop_date.encode('utf-8'),
+            hashlib.sha256
+        ).digest()
+
+        # 2. 使用ak作为数据，ktime作为密钥，算出kAk
+        kAk = hmac.new(
+            ktime,
+            self.access_key.encode('utf-8'),
+            hashlib.sha256
+        ).digest()
+
+        # 3. 使用eop_date的年月日值作为数据，kAk作为密钥，算出kdate
+        # eop_date格式：20221107T093029Z，提取年月日：20221107
+        date_part = eop_date.split('T')[0]
+        kdate = hmac.new(
+            kAk,
+            date_part.encode('utf-8'),
+            hashlib.sha256
+        ).digest()
+
+        return kdate
+
+    def _build_signature(self, signature_string: str, kdate: bytes) -> str:
+        """
+        构造 signature
+        使用kdate作为密钥、signature_string作为数据，进行HMAC-SHA256，然后Base64编码
+
+        Args:
+            signature_string: 待签名字符串
+            kdate: 动态密钥
+
+        Returns:
+            Base64编码的签名
+        """
+        signature_bytes = hmac.new(
+            kdate,
+            signature_string.encode('utf-8'),
+            hashlib.sha256
+        ).digest()
+
+        # Base64编码
+        signature = base64.b64encode(signature_bytes).decode('utf-8')
+
+        return signature
+
+    def _build_eop_authorization(self, signature: str, headers: Dict[str, str]) -> str:
+        """
+        构造 Eop-Authorization 请求头
+        格式：ak Headers=header1;header2 Signature=xxx
+
+        Args:
+            signature: 签名
+            headers: 请求头字典
+
+        Returns:
+            Eop-Authorization 字符串
+        """
+        # 构造 Headers 部分（需要签名的header，按字母排序，用分号分隔）
+        signed_header_names = ['ctyun-eop-request-id', 'eop-date']
+        signed_header_names.sort()
+        headers_part = ';'.join(signed_header_names)
+
+        # 构造完整的 Eop-Authorization
+        # 格式：ak Headers=xxx Signature=xxx
+        eop_authorization = f"{self.access_key} Headers={headers_part} Signature={signature}"
+
+        return eop_authorization

ctyun_cli/auth/signature.py

@@ -0,0 +1,225 @@
+"""
+天翼云API签名认证模块
+实现AK/SK签名认证机制
+"""
+
+import hashlib
+import hmac
+import time
+import uuid
+from urllib.parse import quote
+from typing import Dict, Any
+
+
+class CTYUNAuth:
+    """天翼云API签名认证类"""
+
+    def __init__(self, access_key: str, secret_key: str):
+        """
+        初始化认证器
+
+        Args:
+            access_key: 访问密钥
+            secret_key: 密钥
+        """
+        self.access_key = access_key
+        self.secret_key = secret_key
+
+    def _create_string_to_sign(self, method: str, uri: str, params: Dict[str, Any],
+                              headers: Dict[str, str], timestamp: str) -> str:
+        """
+        创建待签名字符串
+
+        Args:
+            method: HTTP方法
+            uri: 请求URI
+            params: 查询参数
+            headers: 请求头
+            timestamp: 时间戳
+
+        Returns:
+            待签名字符串
+        """
+        # 规范化URI
+        canonical_uri = quote(uri, safe='/')
+
+        # 规范化查询字符串
+        canonical_query = self._canonicalize_query(params)
+
+        # 规范化请求头
+        canonical_headers, signed_headers = self._canonicalize_headers(headers)
+
+        # 创建哈希载荷（如果有body）
+        payload_hash = hashlib.sha256(''.encode()).hexdigest()
+
+        # 构建待签名字符串
+        string_to_sign = f"{method.upper()}\n{canonical_uri}\n{canonical_query}\n"
+        string_to_sign += f"{canonical_headers}\n{signed_headers}\n{payload_hash}"
+
+        return string_to_sign
+
+    def _canonicalize_query(self, params: Dict[str, Any]) -> str:
+        """
+        规范化查询参数
+
+        Args:
+            params: 查询参数字典
+
+        Returns:
+            规范化的查询字符串
+        """
+        if not params:
+            return ""
+
+        # 对参数名进行编码和排序
+        encoded_params = []
+        for key in sorted(params.keys()):
+            encoded_key = quote(str(key), safe='')
+            encoded_value = quote(str(params[key]), safe='')
+            encoded_params.append(f"{encoded_key}={encoded_value}")
+
+        return "&".join(encoded_params)
+
+    def _canonicalize_headers(self, headers: Dict[str, str]) -> tuple:
+        """
+        规范化请求头
+
+        Args:
+            headers: 请求头字典
+
+        Returns:
+            (规范化请求头字符串, 已签名头列表)
+        """
+        # 过滤和规范化请求头
+        canonical_headers = {}
+        signed_headers = []
+
+        # 天翼云API要求包含的头
+        required_headers = ['host', 'x-ctyun-date', 'x-ctyun-nonce']
+
+        for key, value in headers.items():
+            lower_key = key.lower().strip()
+            if lower_key in required_headers or lower_key.startswith('x-ctyun-'):
+                canonical_headers[lower_key] = value.strip()
+                signed_headers.append(lower_key)
+
+        # 排序已签名头
+        signed_headers.sort()
+
+        # 构建规范化请求头字符串
+        header_lines = []
+        for header in signed_headers:
+            header_lines.append(f"{header}:{canonical_headers[header]}")
+
+        canonical_headers_str = "\n".join(header_lines) + "\n"
+        signed_headers_str = ";".join(signed_headers)
+
+        return canonical_headers_str, signed_headers_str
+
+    def sign_request(self, method: str, uri: str, params: Dict[str, Any] = None,
+                    headers: Dict[str, str] = None, body: str = None) -> Dict[str, str]:
+        """
+        为请求添加签名
+
+        Args:
+            method: HTTP方法
+            uri: 请求URI
+            params: 查询参数
+            headers: 请求头
+            body: 请求体
+
+        Returns:
+            包含签名信息的请求头
+        """
+        if params is None:
+            params = {}
+        if headers is None:
+            headers = {}
+        if body is None:
+            body = ""
+
+        # 生成时间戳和随机数
+        timestamp = time.strftime("%Y%m%dT%H%M%SZ", time.gmtime())
+        nonce = str(uuid.uuid4()).replace('-', '')
+
+        # 添加必要的请求头
+        headers['X-CTYUN-Date'] = timestamp
+        headers['X-CTYUN-Nonce'] = nonce
+
+        # 创建待签名字符串
+        string_to_sign = self._create_string_to_sign(method, uri, params, headers, timestamp)
+
+        # 计算签名
+        signature = self._calculate_signature(string_to_sign, timestamp)
+
+        # 添加认证头
+        auth_headers = {
+            'X-CTYUN-Signature': signature,
+            'X-CTYUN-SignedHeaders': self._get_signed_headers(headers),
+            'X-CTYUN-Date': timestamp,
+            'X-CTYUN-Nonce': nonce,
+            'X-CTYUN-Algorithm': 'CTYUN-HMAC-SHA256'
+        }
+
+        return auth_headers
+
+    def _calculate_signature(self, string_to_sign: str, timestamp: str) -> str:
+        """
+        计算签名
+
+        Args:
+            string_to_sign: 待签名字符串
+            timestamp: 时间戳
+
+        Returns:
+            签名值
+        """
+        # 创建签名密钥
+        date_key = hmac.new(
+            f'CTYUN{self.secret_key}'.encode(),
+            timestamp[:8].encode(),
+            hashlib.sha256
+        ).digest()
+
+        signature_key = hmac.new(
+            date_key,
+            'ctyun_request'.encode(),
+            hashlib.sha256
+        ).digest()
+
+        # 计算最终签名
+        signature = hmac.new(
+            signature_key,
+            string_to_sign.encode(),
+            hashlib.sha256
+        ).hexdigest()
+
+        return signature
+
+    def _get_signed_headers(self, headers: Dict[str, str]) -> str:
+        """
+        获取已签名头列表
+
+        Args:
+            headers: 请求头字典
+
+        Returns:
+            已签名头列表字符串
+        """
+        signed_headers = []
+        for key in headers:
+            lower_key = key.lower()
+            if lower_key in ['host', 'x-ctyun-date', 'x-ctyun-nonce'] or lower_key.startswith('x-ctyun-'):
+                signed_headers.append(lower_key)
+
+        signed_headers.sort()
+        return ";".join(signed_headers)
+
+    def get_bearer_token(self) -> str:
+        """
+        获取Bearer Token（简化认证方式）
+
+        Returns:
+            Bearer Token字符串
+        """
+        return f"Bearer {self.access_key}"

ctyun_cli/billing/__init__.py

@@ -0,0 +1,8 @@
+"""
+天翼云账务服务模块
+提供账单查询、费用查询等功能
+"""
+
+from .client import BillingClient
+
+__all__ = ['BillingClient']