certapi 0.4.0__tar.gz → 0.4.1__tar.gz

{certapi-0.4.0 → certapi-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: certapi
-Version: 0.4.0
+Version: 0.4.1
 Summary: Python Package for managing keys, request SSL certificates from ACME.
 Home-page: https://github.com/mesudip/certapi
 Author: Sudip Bhattarai
@@ -33,7 +33,7 @@ import json
 from certapi import FileSystemChallengeStore, FilesystemKeyStore, CertAuthority
 
 key_store = FilesystemKeyStore("data")
-challenge_store = FileSystemChallengeStore("./acme-challenges")  # this should be where your web server hosts the .well-known/acme-challenges.
+challenge_store = FileSystemChallengeStore("./acme-challenges")  # this should be where your web server hosts the .well-known/
 
 certAuthority = CertAuthority(challenge_store, key_store)
 certAuthority.setup()

{certapi-0.4.0 → certapi-0.4.1}/README.md

@@ -20,7 +20,7 @@ import json
 from certapi import FileSystemChallengeStore, FilesystemKeyStore, CertAuthority
 
 key_store = FilesystemKeyStore("data")
-challenge_store = FileSystemChallengeStore("./acme-challenges")  # this should be where your web server hosts the .well-known/acme-challenges.
+challenge_store = FileSystemChallengeStore("./acme-challenges")  # this should be where your web server hosts the .well-known/
 
 certAuthority = CertAuthority(challenge_store, key_store)
 certAuthority.setup()

{certapi-0.4.0 → certapi-0.4.1}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="certapi",
-    version="0.4.0",
+    version="0.4.1",
     packages=find_packages(where="src"),
     package_dir={"": "src"},
     install_requires=[

certapi-0.4.1/src/certapi/challenge_store/dns/cloudflare/cloudflare_challenge_store.py

@@ -0,0 +1,59 @@
+import os
+import time
+from collections.abc import MutableMapping
+from ...ChallengeStore import ChallengeStore
+from .cloudflare_client import Cloudflare
+
+
+class CloudflareChallengeStore(ChallengeStore):
+    def __init__(self,api_key:str=None):
+        self.cloudflare = Cloudflare(api_key)
+        self.challenges_map = {} 
+    
+    def supports_domain(self, domain: str) -> bool:
+        """
+        Checks if the Cloudflare account has access to the given domain (or its base domain)
+        as a registered zone.
+        """
+        try:
+            self.cloudflare.determine_registered_domain(domain)
+            return True
+        except Exception:
+            return False
+
+    def save_challenge(self, key: str, value: str, domain=None):
+        # key example: _acme-challenge.sub.example.com
+        # value example: ACME_CHALLENGE_TOKEN
+        base_domain = self.cloudflare.determine_registered_domain(domain)
+
+        record_id = self.cloudflare.create_record(name=key, data=value, domain=base_domain)
+        self.challenges_map[key] = record_id
+        print(f"CloudflareChallengeStore: Saved challenge for {key} with record ID {record_id}")
+        time.sleep(10) # wait for dns propagation. it may not be immediate
+
+    def get_challenge(self, key: str, domain: str) -> str:
+        base_domain = self.cloudflare.determine_registered_domain(domain)
+        records = self.cloudflare.list_txt_records(base_domain, name_filter=key)
+        for record in records:
+            if record["name"] == key:
+                return record["content"]
+        return None  # Return None if not found, as per ChallengeStore's __getitem__ behavior
+
+    def delete_challenge(self, key: str, domain: str):
+        if key not in self.challenges_map:
+            raise KeyError(f"Challenge {key} not found in store (no record_id stored).")
+
+        record_id = self.challenges_map[key]
+        base_domain = self.cloudflare.determine_registered_domain(domain)
+        self.cloudflare.delete_record(record=record_id, domain=base_domain)
+        del self.challenges_map[key]
+        print(f"CloudflareChallengeStore: Deleted challenge for {key} with record ID {record_id}")
+
+    def __iter__(self):
+        # This is tricky as we can't easily iterate all challenges across all domains
+        # If the user wants a full API-driven iteration, they need to clarify how to get all domains.
+        return iter(self.challenges_map)
+
+    def __len__(self):
+        # Similar to __iter__, this will count challenges managed by this store instance.
+        return len(self.challenges_map)

certapi-0.4.1/src/certapi/challenge_store/dns/cloudflare/cloudflare_client.py

@@ -0,0 +1,138 @@
+import json
+import time
+from os import getenv
+from urllib.request import urlopen, Request
+
+
+class Cloudflare(object):
+    name = "cloudflare"
+
+    def __init__(self,api_key:str):
+        self.token = api_key
+        self.api = "https://api.cloudflare.com/client/v4"
+        if not self.token:
+            self.token = getenv("CLOUDFLARE_API_KEY")
+            if not self.token:
+                raise Exception("CLOUDFLARE_API_KEY not found in environment")
+
+        self._zones_cache = None
+        self._zones_cache_time = 0  # Unix timestamp of last cache update
+
+    def _cloudflare_headers(self):
+        return {"Content-Type": "application/json", "Authorization": "Bearer " + self.token}
+
+    def _get_zones(self):
+        """Fetch and cache Cloudflare zones"""
+        # Cache for 1 day (86400 seconds)
+        if self._zones_cache and (time.time() - self._zones_cache_time) < 86400:
+            return self._zones_cache
+
+        request_headers = self._cloudflare_headers()
+        api_url = "{0}/zones?per_page=50".format(self.api)
+        response = urlopen(Request(api_url, headers=request_headers))
+        if response.getcode() != 200:
+            raise Exception(json.loads(response.read().decode("utf8")))
+
+        zones = json.loads(response.read().decode("utf8"))["result"]
+        self._zones_cache = zones
+        self._zones_cache_time = time.time()
+        return zones
+
+    def _get_zone_id(self, domain):
+        """Determine Cloudflare Zone ID for a given domain"""
+        zones = self._get_zones()
+        for zone in zones:
+            if zone["name"] == domain:
+                return zone["id"]
+        raise Exception("No Cloudflare zone found for domain: {0}".format(domain))
+
+    def determine_registered_domain(self, domain: str) -> str:
+        """
+        Determine the registered domain in Cloudflare for a given (sub)domain.
+        This method iterates through parts of the domain to find a matching Cloudflare zone.
+        """
+        parts = domain.split(".")
+        err = None
+        for i in range(len(parts)):
+            potential_domain = ".".join(parts[i:])
+            try:
+                self._get_zone_id(potential_domain)
+                return potential_domain
+            except Exception as e:
+                err = e
+                continue
+        if err:
+            raise err
+        else:
+            raise Exception("Could not determine Cloudflare registered domain for: {0}".format(domain))
+
+    def list_txt_records(self, domain: str, name_filter: str = None) -> list:
+        """
+        Lists TXT records for a given domain, optionally filtered by name.
+        Returns a list of dictionaries, each representing a TXT record.
+        """
+        registered_domain = self.determine_registered_domain(domain)
+        zone_id = self._get_zone_id(registered_domain)
+        api_url = f"{self.api}/zones/{zone_id}/dns_records?type=TXT"
+        if name_filter:
+            api_url += f"&name={name_filter}"
+
+        request_headers = self._cloudflare_headers()
+        response = urlopen(Request(api_url, headers=request_headers))
+
+        if response.getcode() != 200:
+            raise Exception(json.loads(response.read().decode("utf8")))
+
+        result = json.loads(response.read().decode("utf8"))
+        if not result.get("success"):
+            raise Exception(result.get("errors", "Unknown error listing TXT records"))
+
+        return result["result"]
+
+    def create_record(self, name, data, domain):
+        """
+        Create DNS record
+        Params:
+            name, string, record name (e.g., _acme-challenge.example.com)
+            data, string, record data (e.g., ACME challenge token)
+            domain, string, dns domain (e.g., example.com) - This will be used to determine the registered zone.
+        Return:
+            record_id, string, created record id
+        """
+        registered_domain = self.determine_registered_domain(domain)
+        zone_id = self._get_zone_id(registered_domain)
+        api_url = "{0}/zones/{1}/dns_records".format(self.api, zone_id)
+        request_headers = self._cloudflare_headers()
+        request_data = {
+            "type": "TXT",
+            "name": name,
+            "content": data,
+            "ttl": 120,  # Cloudflare minimum TTL for TXT is 120 seconds
+            "proxied": False,
+        }
+        response = urlopen(Request(api_url, data=json.dumps(request_data).encode("utf8"), headers=request_headers))
+
+        if response.getcode() != 200:
+            raise Exception(json.loads(response.read().decode("utf8")))
+        result = response.read().decode("utf8")
+        print("Cloudflare create record", name, result)
+        return json.loads(result)["result"]["id"]
+
+    def delete_record(self, record, domain):
+        """
+        Delete DNS record
+        Params:
+            record, string, record id number
+            domain, string, dns domain - This will be used to determine the registered zone.
+        """
+        registered_domain = self.determine_registered_domain(domain)
+        zone_id = self._get_zone_id(registered_domain)
+        api_url = "{0}/zones/{1}/dns_records/{2}".format(self.api, zone_id, record)
+        request_headers = self._cloudflare_headers()
+        request = Request(api_url, headers=request_headers)
+        request.get_method = lambda: "DELETE"
+        response = urlopen(request)
+        result = response.read().decode("utf8")
+        print(f"Delete dns record [{response.getcode()}]", result)
+        if response.getcode() != 200:
+            raise Exception(json.loads(response.read().decode("utf8")))

certapi-0.4.1/src/certapi/challenge_store/dns/digitalocean/digitalocean_challenge_store.py

@@ -0,0 +1,57 @@
+import os
+from collections.abc import MutableMapping
+from ...ChallengeStore import ChallengeStore
+from .digitalocean_client import DigitalOcean
+
+
+class DigitalOceanChallengeStore(ChallengeStore):
+    def __init__(self,api_key:str=None):
+        self.digitalocean = DigitalOcean(api_key)
+        self.challenges_map = {}  # Stores key: record_id (needed for deletion)
+
+    def supports_domain(self, domain: str) -> bool:
+        """
+        Checks if the DigitalOcean account has access to the given domain (or its base domain)
+        as a registered zone.
+        """
+        try:
+            self.digitalocean.determine_domain(domain)
+            return True
+        except Exception:
+            return False
+
+    def save_challenge(self, key: str, value: str, domain=None):
+        # key example: _acme-challenge.sub.example.com
+        # value example: ACME_CHALLENGE_TOKEN
+        base_domain = self.digitalocean.determine_domain(domain)
+
+        record_id = self.digitalocean.create_record(name=key, data=value, domain=base_domain)
+        self.challenges_map[key] = record_id
+        print(f"DigitalOceanChallengeStore: Saved challenge for {key} with record ID {record_id}")
+
+    def get_challenge(self, key: str, domain: str) -> str:
+        base_domain = self.digitalocean.determine_domain(domain)
+        records = self.digitalocean.list_records(base_domain, name_filter=key)
+        for record in records:
+            if record["name"] == key:
+                return record["data"]  # DigitalOcean API returns 'data' for TXT record content
+        return None  # Return None if not found, as per ChallengeStore's __getitem__ behavior
+
+    def delete_challenge(self, key: str, domain: str):
+        if key not in self.challenges_map:
+            raise KeyError(f"Challenge {key} not found in store (no record_id stored).")
+
+        record_id = self.challenges_map[key]
+        base_domain = self.digitalocean.determine_domain(domain)
+        self.digitalocean.delete_record(record=record_id, domain=base_domain)
+        del self.challenges_map[key]
+        print(f"DigitalOceanChallengeStore: Deleted challenge for {key} with record ID {record_id}")
+
+    def __iter__(self):
+        # This is tricky as we can't easily iterate all challenges across all domains
+        # If the user wants a full API-driven iteration, they need to clarify how to get all domains.
+        return iter(self.challenges_map)
+
+    def __len__(self):
+        # Similar to __iter__, this will count challenges managed by this store instance.
+        return len(self.challenges_map)

certapi-0.4.1/src/certapi/challenge_store/dns/digitalocean/digitalocean_client.py

@@ -0,0 +1,85 @@
+import json
+from os import getenv
+
+from urllib.request import urlopen, Request  # Python 3
+
+
+class DigitalOcean(object):
+    def __init__(self, api_key:str=None):
+        self.token = api_key
+        self.api = "https://api.digitalocean.com/v2/domains"
+        if not self.token:
+            self.token = getenv("DIGITALOCEAN_API_KEY")
+            if not self.token:
+                raise Exception("DIGITALOCEAN_API_KEY not found in environment")
+
+    def determine_domain(self, domain):
+        """Determine registered domain in API"""
+        request_headers = {"Content-Type": "application/json", "Authorization": "Bearer {0}".format(self.token)}
+        response = urlopen(Request(self.api, headers=request_headers))
+        if response.getcode() != 200:
+            raise Exception(json.loads(response.read().decode("utf8")))
+        domains = json.loads(response.read().decode("utf8"))["domains"]
+        for d in domains:
+            if d["name"] in domain:
+                return d["name"]
+
+    def create_record(self, name, data, domain):
+        """
+        Create DNS record
+        Params:
+            name, string, record name
+            data, string, record data
+            domain, string, dns domain
+        Return:
+            record_id, int, created record id
+        """
+        registered_domain = self.determine_domain(domain)
+        api = self.api + "/" + registered_domain + "/records"
+        request_headers = {"Content-Type": "application/json", "Authorization": "Bearer {0}".format(self.token)}
+        request_data = {"type": "TXT", "ttl": 300, "name": name, "data": data}
+        response = urlopen(Request(api, data=json.dumps(request_data).encode("utf8"), headers=request_headers))
+        if response.getcode() != 201:
+            raise Exception(json.loads(response.read().decode("utf8")))
+        return json.loads(response.read().decode("utf8"))["domain_record"]["id"]
+
+    def delete_record(self, record, domain):
+        """
+        Delete DNS record
+        Params:
+            record, int, record id number
+            domain, string, dns domain
+        """
+        registered_domain = self.determine_domain(domain)
+        api = self.api + "/" + registered_domain + "/records/" + str(record)
+        request_headers = {"Content-Type": "application/json", "Authorization": "Bearer {0}".format(self.token)}
+        request = Request(api, data=json.dumps({}).encode("utf8"), headers=request_headers)
+        request.get_method = lambda: "DELETE"
+        response = urlopen(request)
+        if response.getcode() != 204:
+            raise Exception(json.loads(response.read().decode("utf8")))
+
+    def list_records(self, domain, name_filter=None):
+        """
+        List DNS records for a domain, optionally filtered by name.
+        Params:
+            domain, string, dns domain
+            name_filter, string, optional filter for record name
+        Return:
+            records, list of dicts, matching DNS records
+        """
+        registered_domain = self.determine_domain(domain)
+        api = self.api + "/" + registered_domain + "/records"
+        request_headers = {"Content-Type": "application/json", "Authorization": "Bearer {0}".format(self.token)}
+        response = urlopen(Request(api, headers=request_headers))
+        if response.getcode() != 200:
+            raise Exception(json.loads(response.read().decode("utf8")))
+
+        all_records = json.loads(response.read().decode("utf8"))["domain_records"]
+
+        if name_filter:
+            filtered_records = [r for r in all_records if r["name"] == name_filter and r["type"] == "TXT"]
+        else:
+            filtered_records = [r for r in all_records if r["type"] == "TXT"]
+
+        return filtered_records

certapi-0.4.1/src/certapi/http/types.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+from typing import List, Dict, Any, Union, Optional
+from cryptography.x509 import Certificate
+from ..crypto.crypto import cert_to_pem, certs_to_pem
+from ..crypto.crypto_classes import Key
+
+class IssuedCert:
+    def __init__(self, *, key: Union[str, Key] = None, cert: Union[str, Certificate, List[Certificate]] = None, domains: List[str] = None):
+        if isinstance(key, Key):
+            key = key.to_pem().decode("utf-8")
+        elif isinstance(key, bytes):
+            key = key.decode("utf-8")
+
+        if isinstance(cert, list):
+            cert = certs_to_pem(cert).decode("utf-8")
+        elif isinstance(cert, Certificate):
+            cert = cert_to_pem(cert).decode("utf-8")
+        elif isinstance(cert, bytes):
+            cert = cert.decode("utf-8")
+
+        self.privateKey = key
+        self.certificate = cert
+        self.domains = domains
+
+    @staticmethod
+    def from_json(data: Dict[str, Any]) -> "IssuedCert":
+        return IssuedCert(
+            key=data.get('privateKey'),
+            cert=data.get('certificate'),
+            domains=data.get('domains', []),
+        )
+
+    def __repr__(self):
+        return f"IssuedCert(domains={self.domains})"
+
+    def __str__(self):
+        return f"(hosts: {self.domains}, certificate:{self.certificate})"
+
+    def to_json(self):
+        return {"privateKey": self.privateKey, "certificate": self.certificate, "domains": self.domains}
+
+
+class CertificateResponse:
+    def __init__(self, *, existing: List[IssuedCert] = None, issued: List[IssuedCert] = None):
+        self.existing: List[IssuedCert] = existing or []
+        self.issued: List[IssuedCert] = issued or []
+
+    @staticmethod
+    def from_json(data: Dict[str, Any]) -> "CertificateResponse":
+        return CertificateResponse(
+            existing=[IssuedCert.from_json(cert_data) for cert_data in data.get('existing', [])],
+            issued=[IssuedCert.from_json(cert_data) for cert_data in data.get('issued', [])]
+        )
+
+    def __repr__(self):
+        return f"CertificateResponse(existing={self.existing}, issued={self.issued})"
+
+    def __str__(self):
+        if self.issued:
+            return f"(existing: {self.existing}, new: {self.issued})"
+        else:
+            return f"(existing: {self.existing})"
+
+    def to_json(self):
+        return {
+            "existing": [x.to_json() for x in self.existing],
+            "issued": [x.to_json() for x in self.issued],
+        }

certapi-0.4.1/src/certapi/manager/acme_cert_manager.py

@@ -0,0 +1,155 @@
+import time
+from typing import List, Literal, Optional, Tuple, Union, Dict
+
+from certapi import crypto
+from ..acme import Challenge
+from ..challenge_store import ChallengeStore
+
+from ..issuers import AcmeCertIssuer,CertIssuer
+from ..http.types import CertificateResponse, IssuedCert
+from ..keystore.KeyStore import KeyStore
+from cryptography.x509 import Certificate,CertificateSigningRequest
+from ..crypto import Key,certs_to_pem, cert_to_pem,get_csr_hostnames
+
+
+class AcmeCertManager():
+    def __init__(
+        self,
+        key_store: KeyStore,
+        cert_issuer: AcmeCertIssuer,
+        challenge_stores: List[ChallengeStore] = [],
+    ):
+        self.key_store: KeyStore = key_store
+        self.cert_issuer : AcmeCertIssuer = cert_issuer
+        self.challenge_stores : List[ChallengeStore]= challenge_stores
+        print(f"AcmeCertManager initialized with challenge_stores: {self.challenge_stores}")
+
+    def setup(self):
+        self.cert_issuer.setup()
+    
+    def issue_certificate_for_csr(self, csr: CertificateSigningRequest)->str:
+        """
+        Returns Certificate
+        """
+        hostnames = get_csr_hostnames(csr)
+        if not hostnames:
+            raise ValueError("CSR does not contain any hostnames.")
+
+        # Find a challenge store that supports all hostnames in the CSR
+        selected_challenge_store = None
+        for store in self.challenge_stores:
+            if all(store.supports_domain(h) for h in hostnames):
+                selected_challenge_store = store
+                break
+
+        if selected_challenge_store is None:
+            raise ValueError(f"No challenge store found that supports all domains: {hostnames}")
+
+        fullchain_cert = self.cert_issuer.sign_csr(csr, challenge_store=selected_challenge_store)
+        if fullchain_cert:
+            # Assuming the private key associated with the CSR is not managed by CertManager directly
+            # and is handled by the caller or the cert_issuer's internal process.
+            # For now, we'll just return the certificate.
+            # If key saving is required here, the private key would need to be passed along with the CSR.
+            return fullchain_cert
+        else:
+            return None
+
+    def issue_certificate(self, hosts: Union[str, List[str]],
+                            key_type: Literal["rsa", "ecdsa", "ed25519"] = "rsa",
+                            expiry_days: int = 90,
+                            country: Optional[str] = None,
+                            state: Optional[str] = None,
+                            locality: Optional[str] = None,
+                            organization: Optional[str] = None,
+                            user_id: Optional[str] = None) -> CertificateResponse:
+         
+        if type(hosts) == str:
+            hosts = [hosts]
+        
+        existing :  Dict[str, Tuple[int | str, Key, List[Certificate] | str]]= {}
+        for h in hosts:
+            result = self.key_store.find_key_and_cert_by_domain(h)
+            if result is not None:
+                # result is (domain_id, key, cert_list)
+                existing[h] = result # Store the certificate list
+        
+        missing = [h for h in hosts if h not in existing]
+        if len(missing) > 0:
+            issued_certs_list = []
+            # Group missing hosts by the challenge store that supports them
+            domains_by_store: Dict[ChallengeStore, List[str]] = {}
+            for host in missing:
+                found_store = None
+                for store in self.challenge_stores:
+                    print(f"Debug: Checking store {store} for domain {host}. supports_domain: {store.supports_domain(host)}")
+                    if store.supports_domain(host):
+                        print(f"Supports domain: '{host}'",)
+                        found_store = store
+                        break
+                if found_store is not None:
+                    if found_store not in domains_by_store:
+                        domains_by_store[found_store] = []
+                    domains_by_store[found_store].append(host)
+                else:
+                    print(f"Debug: Current challenge_stores: {self.challenge_stores}")
+                    print(f"Warning: No challenge store found that supports domain: {host}. Skipping.")
+
+            # original_challenge_store = self.cert_issuer.challenge_store # Store original
+
+            for store, domains_to_issue in domains_by_store.items():
+                
+                private_key, fullchain_cert = self.cert_issuer.generate_key_and_cert_for_domains(
+                    domains_to_issue,
+                    key_type=key_type,
+                    expiry_days=expiry_days,
+                    country=country,
+                    state=state,
+                    locality=locality,
+                    organization=organization,
+                    user_id=user_id,
+                    challenge_store=store
+                    
+                )
+                
+                if fullchain_cert:
+                    key_id = self.key_store.save_key(private_key, domains_to_issue[0])
+                    self.key_store.save_cert(key_id, fullchain_cert, domains_to_issue)
+                    issued_certs_list.append(IssuedCert(key=private_key, cert=fullchain_cert, domains=domains_to_issue))
+                else:
+                    print(f"Failed to issue certificate for domains: {domains_to_issue}")
+            
+            # self.cert_issuer.challenge_store = original_challenge_store # Restore original
+            return createExistingResponse(existing, issued_certs_list)
+            
+        else:
+            return createExistingResponse(existing, [])
+
+
+def createExistingResponse(
+    existing: Dict[str, Tuple[int | str, Key, List[Certificate] | str]], issued_certs: List[IssuedCert]
+):
+    certs = []
+    certMap = {}
+
+    for h, (id, key, cert) in existing.items():
+        if id in certMap:
+            certMap[id][0].append(h)
+        else:
+            if isinstance(cert, str):
+                cert_pem = cert
+            elif isinstance(cert, list):
+                cert_pem = certs_to_pem(cert).decode("utf-8")
+            else:
+                cert_pem = cert_to_pem(cert).decode("utf-8")
+
+            certMap[id] = (
+                [h],
+                key,
+                cert_pem,
+            )
+
+    for hosts, key, cert in certMap.values():
+        certs.append(IssuedCert(key=key, cert=cert, domains=hosts))
+
+    return CertificateResponse(existing=certs, issued=issued_certs)

{certapi-0.4.0 → certapi-0.4.1}/src/certapi.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: certapi
-Version: 0.4.0
+Version: 0.4.1
 Summary: Python Package for managing keys, request SSL certificates from ACME.
 Home-page: https://github.com/mesudip/certapi
 Author: Sudip Bhattarai
@@ -33,7 +33,7 @@ import json
 from certapi import FileSystemChallengeStore, FilesystemKeyStore, CertAuthority
 
 key_store = FilesystemKeyStore("data")
-challenge_store = FileSystemChallengeStore("./acme-challenges")  # this should be where your web server hosts the .well-known/acme-challenges.
+challenge_store = FileSystemChallengeStore("./acme-challenges")  # this should be where your web server hosts the .well-known/
 
 certAuthority = CertAuthority(challenge_store, key_store)
 certAuthority.setup()

{certapi-0.4.0 → certapi-0.4.1}/src/certapi.egg-info/SOURCES.txt

@@ -22,11 +22,20 @@ src/certapi/challenge_store/FilesystemChallengeStore.py
 src/certapi/challenge_store/InmemoryChallengeStore.py
 src/certapi/challenge_store/__init__.py
 src/certapi/challenge_store/dns/__init__.py
+src/certapi/challenge_store/dns/cloudflare/__init__.py
+src/certapi/challenge_store/dns/cloudflare/cloudflare_challenge_store.py
+src/certapi/challenge_store/dns/cloudflare/cloudflare_client.py
+src/certapi/challenge_store/dns/digitalocean/__init__.py
+src/certapi/challenge_store/dns/digitalocean/digitalocean_challenge_store.py
+src/certapi/challenge_store/dns/digitalocean/digitalocean_client.py
 src/certapi/client/__init__.py
 src/certapi/client/cert_manager_client.py
 src/certapi/crypto/__init__.py
 src/certapi/crypto/crypto.py
 src/certapi/crypto/crypto_classes.py
+src/certapi/http/__init__.py
+src/certapi/http/client.py
+src/certapi/http/types.py
 src/certapi/issuers/AcmeCertIssuer.py
 src/certapi/issuers/SelfCertIssuer.py
 src/certapi/issuers/__init__.py
@@ -37,6 +46,8 @@ src/certapi/keystore/PostgresqlKeyStore.py
 src/certapi/keystore/RemoteKeyStore.py
 src/certapi/keystore/SqliteKeyStore.py
 src/certapi/keystore/__init__.py
+src/certapi/manager/__init__.py
+src/certapi/manager/acme_cert_manager.py
 src/certapi/server/__init__.py
 src/certapi/server/api.py
 src/certapi/server/cert_api.py