ddns 4.0.2__py2.py3-none-any.whl → 4.1.0b2__py2.py3-none-any.whl

ddns/provider/huaweidns.py

@@ -2,264 +2,141 @@
 """
 HuaweiDNS API
 华为DNS解析操作库
-https://support.huaweicloud.com/api-dns/zh-cn_topic_0037134406.html
-@author: cybmp3
+@author: NewFuture
 """
 
+from ._base import BaseProvider, TYPE_JSON, join_domain, encode_params
+from ._signature import hmac_sha256_authorization, sha256_hash
+from time import strftime, gmtime
+
+
+class HuaweiDNSProvider(BaseProvider):
+    endpoint = "https://dns.myhuaweicloud.com"
+    content_type = TYPE_JSON
+    algorithm = "SDK-HMAC-SHA256"
+
+    def _validate(self):
+        self.logger.warning(
+            "华为云 DNS 缺少充分的真实环境测试，请及时在 GitHub Issues 中反馈: %s",
+            "https://github.com/NewFuture/DDNS/issues",
+        )
+        super(HuaweiDNSProvider, self)._validate()
+
+    def _request(self, method, path, **params):
+        """
+        https://support.huaweicloud.com/api-dns/zh-cn_topic_0037134406.html
+        https://support.huaweicloud.com/devg-apisign/api-sign-algorithm-002.html
+        https://support.huaweicloud.com/devg-apisign/api-sign-algorithm-003.html
+        https://support.huaweicloud.com/devg-apisign/api-sign-algorithm-004.html
+        """
+        # type: (str, str, **Any) -> dict
+        params = {k: v for k, v in params.items() if v is not None}
+        if method.upper() == "GET" or method.upper() == "DELETE":
+            query = encode_params(params)
+            body = ""
+        else:
+            query = ""
+            body = self._encode_body(params)
+
+        now = strftime("%Y%m%dT%H%M%SZ", gmtime())
+        headers = {
+            "content-type": self.content_type,
+            "host": self.endpoint.split("://", 1)[1].strip("/"),
+            "X-Sdk-Date": now,
+        }
 
-from hashlib import sha256
-from hmac import new as hmac
-from binascii import hexlify
-from json import loads as jsondecode, dumps as jsonencode
-from logging import debug, info, warning
-from datetime import datetime
-
-try:  # python 3
-    from http.client import HTTPSConnection
-    from urllib.parse import urlencode
-except ImportError:  # python 2
-    from httplib import HTTPSConnection
-    from urllib import urlencode
-
-
-__author__ = 'New Future'
-BasicDateFormat = "%Y%m%dT%H%M%SZ"
-Algorithm = "SDK-HMAC-SHA256"
-
-
-# __all__ = ["request", "ID", "TOKEN", "PROXY"]
-
-
-class Config:
-    ID = "id"  # AK
-    TOKEN = "TOKEN"  # AS
-    PROXY = None  # 代理设置
-    TTL = None
-
-
-class API:
-    # API 配置
-    SCHEME = 'https'
-    SITE = 'dns.myhuaweicloud.com'  # API endpoint
-
-
-def HexEncodeSHA256Hash(data):
-    sha = sha256()
-    sha.update(data)
-    return sha.hexdigest()
-
-
-def StringToSign(canonical_request, t):
-    b = HexEncodeSHA256Hash(canonical_request)
-    return "%s\n%s\n%s" % (Algorithm, datetime.strftime(t, BasicDateFormat), b)
-
-
-def CanonicalHeaders(headers, signed_headers):
-    a = []
-    __headers = {}
-    for key in headers:
-        key_encoded = key.lower()
-        value = headers[key]
-        value_encoded = value.strip()
-        __headers[key_encoded] = value_encoded
-    for key in signed_headers:
-        a.append(key + ":" + __headers[key])
-    return '\n'.join(a) + "\n"
-
-
-def request(method, path, param=None, body=None, **params):
-    # path 是不带host但是 前面需要带 / , body json 字符串或者自己从dict转换下
-    # 也可以自己改成 判断下是不是post 是post params就是body
-    if param:
-        params.update(param)
-
-    query = urlencode(sorted(params.items()))
-    headers = {"content-type": "application/json"}  # 初始化header
-    headers["X-Sdk-Date"] = datetime.strftime(
-        datetime.utcnow(), BasicDateFormat)
-    headers["host"] = API.SITE
-    # 如何后来有需要把header头 key转换为小写 value 删除前导空格和尾随空格
-    sign_headers = []
-    for key in headers:
-        sign_headers.append(key.lower())
-    # 先排序
-    sign_headers.sort()
-
-    if body is None:
-        body = ""
-
-    hex_encode = HexEncodeSHA256Hash(body.encode('utf-8'))
-    # 生成文档中的CanonicalRequest
-    canonical_headers = CanonicalHeaders(headers, sign_headers)
-
-    # 签名中的path 必须 / 结尾
-    if path[-1] != '/':
-        sign_path = path + "/"
-    else:
-        sign_path = path
-
-    canonical_request = "%s\n%s\n%s\n%s\n%s\n%s" % (method.upper(), sign_path, query,
-                                                    canonical_headers, ";".join(sign_headers), hex_encode)
-
-    hashed_canonical_request = HexEncodeSHA256Hash(
-        canonical_request.encode('utf-8'))
-
-    # StringToSign
-    str_to_sign = "%s\n%s\n%s" % (
-        Algorithm, headers['X-Sdk-Date'], hashed_canonical_request)
-
-    secret = Config.TOKEN
-    # 计算签名  HexEncode(HMAC(Access Secret Key, string to sign))
-    signature = hmac(secret.encode(
-        'utf-8'), str_to_sign.encode('utf-8'), digestmod=sha256).digest()
-    signature = hexlify(signature).decode()
-    # 添加签名信息到请求头
-    auth_header = "%s Access=%s, SignedHeaders=%s, Signature=%s" % (
-        Algorithm, Config.ID, ";".join(sign_headers), signature)
-    headers['Authorization'] = auth_header
-    # 创建Http请求
-
-    if Config.PROXY:
-        conn = HTTPSConnection(Config.PROXY)
-        conn.set_tunnel(API.SITE, 443)
-    else:
-        conn = HTTPSConnection(API.SITE)
-    conn.request(method, API.SCHEME + "://" + API.SITE +
-                 path + '?' + query, body, headers)
-    info(API.SCHEME + "://" + API.SITE + path + '?' + query, body)
-    resp = conn.getresponse()
-    data = resp.read().decode('utf8')
-    resp.close()
-    if resp.status < 200 or resp.status >= 300:
-
-        warning('%s : error[%d]: %s', path, resp.status, data)
-        raise Exception(data)
-    else:
-        data = jsondecode(data)
-        debug('%s : result:%s', path, data)
+        # 使用通用签名函数
+        body_hash = sha256_hash(body)
+        # 华为云需要在签名时使用带尾斜杠的路径
+        sign_path = path if path.endswith("/") else path + "/"
+        authorization_format = "%s Access=%s, SignedHeaders={SignedHeaders}, Signature={Signature}" % (
+            self.algorithm,
+            self.id,
+        )
+        authorization = hmac_sha256_authorization(
+            secret_key=self.token,
+            method=method,
+            path=sign_path,
+            query=query,
+            headers=headers,
+            body_hash=body_hash,
+            signing_string_format=self.algorithm + "\n" + now + "\n{HashedCanonicalRequest}",
+            authorization_format=authorization_format,
+        )
+        headers["Authorization"] = authorization
+
+        # 使用原始路径发送实际请求
+        path = "{}?{}".format(path, query) if query else path
+        data = self._http(method, path, headers=headers, body=body)
         return data
 
-
-def get_zone_id(domain):
-    """
-    切割域名获取主域名和对应ID https://support.huaweicloud.com/api-dns/dns_api_62003.html
-    优先匹配级数最长的主域名
-    """
-    zoneid = None
-    domain_slice = domain.split('.')
-    index = len(domain_slice)
-    root_domain = '.'.join(domain_slice[-2:])
-    zones = request('GET', '/v2/zones', limit=500, name=root_domain)['zones']
-    while (not zoneid) and (index >= 2):
-        domain = '.'.join(domain_slice[-index:]) + '.'
-        zone = next((z for z in zones if domain == (z.get('name'))), None)
-        zoneid = zone and zone['id']
-        index -= 1
-    return zoneid
-
-
-def get_records(zoneid, **conditions):
-    """
-        获取记录ID
-        返回满足条件的所有记录[]
-        https://support.huaweicloud.com/api-dns/dns_api_64004.html
-        TODO 大于500翻页
-    """
-    cache_key = zoneid + "_" + \
-        conditions.get('name', "") + "_" + conditions.get('type', "")
-    if not hasattr(get_records, 'records'):
-        get_records.records = {}  # "静态变量"存储已查询过的id
-        get_records.keys = ('id', 'type', 'name', 'records', 'ttl')
-
-    if zoneid not in get_records.records:
-        get_records.records[cache_key] = {}
-
-        data = request('GET', '/v2/zones/' + zoneid + '/recordsets',
-                       limit=500, **conditions)
-
-        # https://{DNS_Endpoint}/v2/zones/2c9eb155587194ec01587224c9f90149/recordsets?limit=&offset=
-        if data:
-            for record in data['recordsets']:
-                info(record)
-                get_records.records[cache_key][record['id']] = {
-                    k: v for (k, v) in record.items() if k in get_records.keys}
-    records = {}
-    for (zid, record) in get_records.records[cache_key].items():
-        for (k, value) in conditions.items():
-            if record.get(k) != value:
-                break
-        else:  # for else push
-            records[zid] = record
-    return records
-
-
-def update_record(domain, value, record_type='A'):
-    """
-        更新记录
-        update
-        https://support.huaweicloud.com/api-dns/UpdateRecordSet.html
-        add
-        https://support.huaweicloud.com/api-dns/dns_api_64001.html
-    """
-    info(">>>>>%s(%s)", domain, record_type)
-    zoneid = get_zone_id(domain)
-    if not zoneid:
-        raise Exception("invalid domain: [ %s ] " % domain)
-    domain += '.'
-    records = get_records(zoneid, name=domain, type=record_type)
-    cache_key = zoneid + "_" + domain + "_" + record_type
-    result = {}
-    if records:  # update
-        for (rid, record) in records.items():
-            if record['records'] != value:
-                """
-                PUT https://{endpoint}/v2/zones/{zone_id}/recordsets/{recordset_id}
-
-                {
-                    "name" : "www.example.com.",
-                    "description" : "This is an example record set.",
-                    "type" : "A",
-                    "ttl" : 3600,
-                    "records" : [ "192.168.10.1", "192.168.10.2" ]
-                }
-                """
-                body = {
-                    "name": domain,
-                    "description": "Managed by DDNS.",
-                    "type": record_type,
-                    "records": [
-                        value
-                    ]
-                }
-                # 如果TTL不为空，则添加到字典中
-                if Config.TTL is not None:
-                    body['ttl'] = Config.TTL
-                res = request('PUT', '/v2/zones/' + zoneid + '/recordsets/' + record['id'],
-                              body=str(jsonencode(body)))
-                if res:
-                    get_records.records[cache_key][rid]['records'] = value
-                    result[rid] = res.get("name")
-                else:
-                    result[rid] = "Update fail!\n" + str(res)
-            else:
-                result[rid] = domain
-    else:  # create
-        body = {
-            "name": domain,
-            "description": "Managed by DDNS.",
-            "type": record_type,
-            "records": [
-                value
-            ]
-        }
-        # 如果TTL不为空，则添加到字典中
-        if Config.TTL is not None:
-            body['ttl'] = Config.TTL
-        res = request('POST', '/v2/zones/' + zoneid + '/recordsets',
-                      body=str(jsonencode(body)))
-        if res:
-            get_records.records[cache_key][res['id']] = res
-            result = res
-        else:
-            result = domain + " created fail!"
-    return result
+    def _query_zone_id(self, domain):
+        """https://support.huaweicloud.com/api-dns/dns_api_62003.html"""
+        domain = domain + "." if not domain.endswith(".") else domain
+        data = self._request("GET", "/v2/zones", search_mode="equal", limit=500, name=domain)
+        zones = data.get("zones", [])
+        zone = next((z for z in zones if domain == z.get("name")), None)
+        zoneid = zone and zone["id"]
+        return zoneid
+
+    def _query_record(self, zone_id, subdomain, main_domain, record_type, line, extra):
+        """
+        v2.1 https://support.huaweicloud.com/api-dns/dns_api_64004.html
+        v2 https://support.huaweicloud.com/api-dns/ListRecordSetsByZone.html
+        """
+        domain = join_domain(subdomain, main_domain) + "."
+        data = self._request(
+            "GET",
+            "/v2.1/zones/" + zone_id + "/recordsets",
+            limit=500,
+            name=domain,
+            type=record_type,
+            line_id=line,
+            search_mode="equal",
+        )
+        records = data.get("recordsets", [])
+        record = next((r for r in records if r.get("name") == domain and r.get("type") == record_type), None)
+        return record
+
+    def _create_record(self, zone_id, subdomain, main_domain, value, record_type, ttl, line, extra):
+        """
+        v2.1 https://support.huaweicloud.com/api-dns/dns_api_64001.html
+        v2 https://support.huaweicloud.com/api-dns/CreateRecordSet.html
+        """
+        domain = join_domain(subdomain, main_domain) + "."
+        extra["description"] = extra.get("description", self.remark)
+        res = self._request(
+            "POST",
+            "/v2.1/zones/" + zone_id + "/recordsets",
+            name=domain,
+            type=record_type,
+            records=[value],
+            ttl=ttl,
+            line=line,
+            **extra
+        )
+        if res and res.get("id"):
+            self.logger.info("Record created: %s", res)
+            return True
+        self.logger.warning("Failed to create record: %s", res)
+        return False
+
+    def _update_record(self, zone_id, old_record, value, record_type, ttl, line, extra):
+        """https://support.huaweicloud.com/api-dns/UpdateRecordSets.html"""
+        extra["description"] = extra.get("description", self.remark)
+        # Note: The v2.1 update API does not support the line parameter in the request body
+        # The line parameter is returned in the response but cannot be modified
+        res = self._request(
+            "PUT",
+            "/v2.1/zones/" + zone_id + "/recordsets/" + old_record["id"],
+            name=old_record["name"],
+            type=record_type,
+            records=[value],
+            ttl=ttl if ttl is not None else old_record.get("ttl"),
+            **extra
+        )
+        if res and res.get("id"):
+            self.logger.info("Record updated: %s", res)
+            return True
+        self.logger.warning("Failed to update record: %s", res)
+        return False

ddns/provider/namesilo.py

@@ -0,0 +1,159 @@
+# coding=utf-8
+"""
+NameSilo API Provider
+DNS provider implementation for NameSilo domain registrar
+@doc: https://www.namesilo.com/api-reference
+@author: NewFuture & Copilot
+"""
+
+from ._base import BaseProvider, TYPE_JSON
+
+
+class NamesiloProvider(BaseProvider):
+    """
+    NameSilo DNS API Provider
+
+    Supports DNS record management through NameSilo's API including:
+    - Domain information retrieval
+    - DNS record listing
+    - DNS record creation
+    - DNS record updating
+    """
+
+    endpoint = "https://www.namesilo.com"
+    content_type = TYPE_JSON
+
+    def _validate(self):
+        """Validate authentication credentials"""
+        # NameSilo only requires API key (token), not ID
+        if not self.token:
+            raise ValueError("API key (token) must be configured for NameSilo")
+        if not self.endpoint:
+            raise ValueError("API endpoint must be defined in {}".format(self.__class__.__name__))
+
+        # Warn if ID is configured since NameSilo doesn't need it
+        if self.id:
+            self.logger.warning("NameSilo does not require 'id' configuration - only API key (token) is needed")
+
+        # Show pending verification warning
+        self.logger.warning("NameSilo provider implementation is pending verification - please test thoroughly")
+
+    def _request(self, operation, **params):
+        # type: (str, **(str | int | bytes | bool | None)) -> dict|None
+        """
+        Send request to NameSilo API
+
+        Args:
+            operation (str): API operation name
+            params: API parameters
+
+        Returns:
+            dict: API response data
+        """
+        # Filter out None parameters
+        params = {k: v for k, v in params.items() if v is not None}
+
+        # Add required authentication and format parameters
+        params.update({"version": "1", "type": "json", "key": self.token})
+
+        # Make API request
+        response = self._http("GET", "/api/" + operation, queries=params)
+
+        # Parse response
+        if response and isinstance(response, dict):
+            reply = response.get("reply", {})
+
+            # Check for successful response
+            if reply.get("code") == "300":  # NameSilo success code
+                return reply
+            else:
+                # Log error details
+                error_msg = reply.get("detail", "Unknown error")
+                self.logger.warning("NameSilo API error [%s]: %s", reply.get("code", "unknown"), error_msg)
+
+        return None
+
+    def _query_zone_id(self, domain):
+        # type: (str) -> str | None
+        """
+        Query domain information to get domain as zone identifier
+        @doc: https://www.namesilo.com/api-reference#domains/get-domain-info
+        """
+        response = self._request("getDomainInfo", domain=domain)
+
+        if response:
+            # Domain exists, return the domain name as zone_id
+            domain_info = response.get("domain", {})
+            if domain_info:
+                self.logger.debug("Domain found: %s", domain)
+                return domain
+
+        self.logger.warning("Domain not found or not accessible: %s", domain)
+        return None
+
+    def _query_record(self, zone_id, subdomain, main_domain, record_type, line, extra):
+        # type: (str, str, str, str, str | None, dict) -> dict | None
+        """
+        Query existing DNS record
+        @doc: https://www.namesilo.com/api-reference#dns/list-dns-records
+        """
+        response = self._request("dnsListRecords", domain=main_domain)
+
+        if response:
+            records = response.get("resource_record", [])
+
+            # Find matching record
+            for record in records:
+                if record.get("host") == subdomain and record.get("type") == record_type:
+                    self.logger.debug("Found existing record: %s", record)
+                    return record
+
+        self.logger.debug("No matching record found for %s.%s (%s)", subdomain, main_domain, record_type)
+        return None
+
+    def _create_record(self, zone_id, subdomain, main_domain, value, record_type, ttl, line, extra):
+        # type: (str, str, str, str, str, int | str | None, str | None, dict) -> bool
+        """
+        Create new DNS record
+        @doc: https://www.namesilo.com/api-reference#dns/add-dns-record
+        """
+        response = self._request(
+            "dnsAddRecord", domain=main_domain, rrtype=record_type, rrhost=subdomain, rrvalue=value, rrttl=ttl
+        )
+
+        if response:
+            record_id = response.get("record_id")
+            self.logger.info("DNS record created successfully: %s", record_id)
+            return True
+        else:
+            self.logger.error("Failed to create DNS record")
+            return False
+
+    def _update_record(self, zone_id, old_record, value, record_type, ttl, line, extra):
+        # type: (str, dict, str, str, int | str | None, str | None, dict) -> bool
+        """
+        Update existing DNS record
+        @doc: https://www.namesilo.com/api-reference#dns/update-dns-record
+        """
+        record_id = old_record.get("record_id")
+        if not record_id:
+            self.logger.error("No record_id found in old_record: %s", old_record)
+            return False
+
+        # In NameSilo, zone_id is the main domain name
+        response = self._request(
+            "dnsUpdateRecord",
+            rrid=record_id,
+            domain=zone_id,  # zone_id is main_domain in NameSilo
+            rrhost=old_record.get("host"),  # host field contains subdomain
+            rrvalue=value,
+            rrtype=record_type,
+            rrttl=ttl or old_record.get("ttl"),
+        )
+
+        if response:
+            self.logger.info("DNS record updated successfully: %s", record_id)
+            return True
+        else:
+            self.logger.error("Failed to update DNS record")
+            return False

ddns/provider/noip.py

@@ -0,0 +1,103 @@
+# coding=utf-8
+"""
+No-IP (noip.com) Dynamic DNS API
+@author: GitHub Copilot
+"""
+
+import base64
+from ._base import SimpleProvider, TYPE_FORM
+
+
+class NoipProvider(SimpleProvider):
+    """
+    No-IP (www.noip.com) Dynamic DNS Provider
+
+    No-IP is a popular dynamic DNS service that provides simple HTTP-based
+    API for updating DNS records. This provider supports the standard
+    No-IP update protocol.
+    """
+
+    endpoint = "https://dynupdate.no-ip.com"
+    content_type = TYPE_FORM
+    accept = None  # No-IP returns plain text response
+    decode_response = False  # Response is plain text, not JSON
+
+    def _validate(self):
+        """
+        Validate authentication credentials for No-IP
+        """
+        if not self.id:
+            raise ValueError("No-IP requires username as 'id'")
+        if not self.token:
+            raise ValueError("No-IP requires password as 'token'")
+
+    def set_record(self, domain, value, record_type="A", ttl=None, line=None, **extra):
+        """
+        Update DNS record using No-IP Dynamic Update API
+
+        No-IP API Reference:
+        - URL: https://dynupdate.no-ip.com/nic/update
+        - Method: GET or POST
+        - Authentication: HTTP Basic Auth (username:password)
+        - Parameters:
+          - hostname: The hostname to update
+          - myip: The IP address to set (optional, uses client IP
+                  if not provided)
+
+        Response codes:
+        - good: Update successful
+        - nochg: IP address is current, no update performed
+        - nohost: Hostname supplied does not exist
+        - badauth: Invalid username/password combination
+        - badagent: Client disabled
+        - !donator: An update request was sent including a feature that
+                    is not available
+        - abuse: Username is blocked due to abuse
+        """
+        self.logger.info("%s => %s(%s)", domain, value, record_type)
+
+        # Prepare request parameters
+        params = {"hostname": domain, "myip": value}
+
+        # Prepare HTTP Basic Authentication headers
+        auth_string = "{0}:{1}".format(self.id, self.token)
+        if not isinstance(auth_string, bytes):  # Python 3
+            auth_bytes = auth_string.encode("utf-8")
+        else:  # Python 2
+            auth_bytes = auth_string
+
+        auth_b64 = base64.b64encode(auth_bytes).decode("ascii")
+        headers = {
+            "Authorization": "Basic {0}".format(auth_b64),
+        }
+
+        try:
+            # Use GET request as it's the most common method for DDNS
+            response = self._http("GET", "/nic/update", queries=params, headers=headers)
+
+            if response is not None:
+                response_str = str(response).strip()
+                self.logger.info("No-IP API response: %s", response_str)
+
+                # Check for successful responses
+                if response_str.startswith("good") or response_str.startswith("nochg"):
+                    return True
+                elif response_str.startswith("nohost"):
+                    self.logger.error("Hostname %s does not exist under No-IP account", domain)
+                elif response_str.startswith("badauth"):
+                    self.logger.error("Invalid No-IP username/password combination")
+                elif response_str.startswith("badagent"):
+                    self.logger.error("No-IP client disabled")
+                elif response_str.startswith("!donator"):
+                    self.logger.error("Feature not available for No-IP free account")
+                elif response_str.startswith("abuse"):
+                    self.logger.error("No-IP account blocked due to abuse")
+                else:
+                    self.logger.error("Unexpected No-IP API response: %s", response_str)
+            else:
+                self.logger.error("Empty response from No-IP API")
+
+        except Exception as e:
+            self.logger.error("Error updating No-IP record for %s: %s", domain, e)
+
+        return False