certapi 1.0.0__tar.gz → 1.0.2__tar.gz

{certapi-1.0.0/src/certapi.egg-info → certapi-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: certapi
-Version: 1.0.0
+Version: 1.0.2
 Summary: Python Package for managing keys, request SSL certificates from ACME.
 Home-page: https://github.com/mesudip/certapi
 Author: Sudip Bhattarai
@@ -22,17 +22,18 @@ Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
-# CertApi
+CertApi
+=============================
 
-CertApi is a Python package for requesting SSL certificates from ACME.
-This is to be used as a base library for building other tools, or to integrate Certificate creation feature in you app.
+Certapi talks with DNS provider and ACME to issue SSL certificates and save it to a keystore.
+
+CertApi is a base library for building other tools, or to integrate Certificate creation feature in your app. CertAPI also provides HTTP api server and can be deployed using Docker
 
 [![Build Status](https://github.com/mesudip/certapi/actions/workflows/tests.yml/badge.svg?branch=master)](https://github.com/mesudip/certapi/actions/workflows/tests.yml)
 [![codecov](https://codecov.io/github/mesudip/certapi/graph/badge.svg?token=NYTNCH29IT)](https://codecov.io/github/mesudip/certapi)
 [![PyPI version](https://img.shields.io/pypi/v/certapi.svg)](https://pypi.org/project/certapi/)
 
 
-For a detailed list of changes, please refer to the [CHANGELOG.md](CHANGELOG.md).
 
 ## Installation
 
@@ -100,12 +101,11 @@ cert_manager = AcmeCertManager(
     key_store=key_store,
     cert_issuer=cert_issuer,
     challenge_solvers=[dns_solver], # other solvers can be used
-    renew_threshold_days=7
-)
+    )
 cert_manager.setup()
 
 # 4. Issue or Reuse Certificate
-# Automatically checks keystore and renews only if necessary
+# Automatically checks sand saves to keystore. Renews only if necessary.
 response = cert_manager.issue_certificate(["example.com", "www.example.com"])
 
 for cert_data in response.issued:

{certapi-1.0.0 → certapi-1.0.2}/README.md

@@ -1,14 +1,15 @@
-# CertApi
+CertApi
+=============================
 
-CertApi is a Python package for requesting SSL certificates from ACME.
-This is to be used as a base library for building other tools, or to integrate Certificate creation feature in you app.
+Certapi talks with DNS provider and ACME to issue SSL certificates and save it to a keystore.
+
+CertApi is a base library for building other tools, or to integrate Certificate creation feature in your app. CertAPI also provides HTTP api server and can be deployed using Docker
 
 [![Build Status](https://github.com/mesudip/certapi/actions/workflows/tests.yml/badge.svg?branch=master)](https://github.com/mesudip/certapi/actions/workflows/tests.yml)
 [![codecov](https://codecov.io/github/mesudip/certapi/graph/badge.svg?token=NYTNCH29IT)](https://codecov.io/github/mesudip/certapi)
 [![PyPI version](https://img.shields.io/pypi/v/certapi.svg)](https://pypi.org/project/certapi/)
 
 
-For a detailed list of changes, please refer to the [CHANGELOG.md](CHANGELOG.md).
 
 ## Installation
 
@@ -76,12 +77,11 @@ cert_manager = AcmeCertManager(
     key_store=key_store,
     cert_issuer=cert_issuer,
     challenge_solvers=[dns_solver], # other solvers can be used
-    renew_threshold_days=7
-)
+    )
 cert_manager.setup()
 
 # 4. Issue or Reuse Certificate
-# Automatically checks keystore and renews only if necessary
+# Automatically checks sand saves to keystore. Renews only if necessary.
 response = cert_manager.issue_certificate(["example.com", "www.example.com"])
 
 for cert_data in response.issued:

{certapi-1.0.0 → certapi-1.0.2}/setup.py

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

{certapi-1.0.0 → certapi-1.0.2}/src/certapi/__init__.py

@@ -21,3 +21,4 @@ from .challenge_solver import (
     DigitalOceanChallengeSolver,
 )
 from .issuers import CertIssuer, SelfCertIssuer, AcmeCertIssuer
+from .client import CertManagerClient

{certapi-1.0.0 → certapi-1.0.2}/src/certapi/acme/Acme.py

@@ -30,7 +30,7 @@ class Acme:
         self.jwk = account_key.jwk()
         self.alg_name = account_key.algorithm_name()
         self.nonce = []
-        self.acme_url = url if url else os.environ.get("ACME_API_URL", self.URL_STAGING)
+        self.acme_url = url if url else os.environ.get("ACME_API_URL", self.URL_PROD)
         self.key_id = None
         self.directory = None
         self._nonce_lock = threading.Lock()  # Mutex for safe access to nonce

{certapi-1.0.0 → certapi-1.0.2}/src/certapi/acme/AcmeError.py

@@ -28,21 +28,29 @@ class AcmeHttpError(AcmeError, requests.HTTPError):
 
     def __init__(self, response: requests.Response, step: str):
         requests.HTTPError.__init__(self, response=response)
-        self.response = response
         (message, detail) = self.extract_acme_response_error()
         AcmeError.__init__(self, message, detail, step)
+        self.response = response
 
     def extract_acme_response_error(self):
         message = None
         error = None
         try:
             res_json = self.response.json()
-            if res_json["status"] == "invalid":
-                if res_json["challenges"]:
-                    failed_challenge: dict = [x for x in res_json["challenges"] if x["status"] == "invalid"][0]
-                    error = failed_challenge["error"]
-                    err_detail: str = error.get("detail")
-                    err_type: str = error.get("type")
+            if res_json.get("status") == "invalid":
+                if res_json.get("challenges"):
+                    invalid_challenges = [x for x in res_json["challenges"] if x["status"] == "invalid"]
+                    if not invalid_challenges:
+                        # Fallback if no invalid challenge found but status is invalid
+                        return (None, res_json)
+
+                    failed_challenge: dict = invalid_challenges[0]
+                    error = failed_challenge.get("error")
+                    if not error:
+                        return (None, res_json)
+
+                    err_detail: str = error.get("detail", "")
+                    err_type: str = error.get("type", "")
                     validation_record: dict = failed_challenge.get("validationRecord")
                     error = {
                         "url": failed_challenge["url"],
@@ -51,7 +59,8 @@ class AcmeHttpError(AcmeError, requests.HTTPError):
                         # Search for the pattern and extract the content
                         if err_detail.startswith("DNS problem: NXDOMAIN"):
                             error["dns"] = {"error": "DNS record doesn't exist"}
-                            error["hostname"] = re.findall(r"looking up [A-Z]+ for ([\w.-]+)", err_detail)[0]
+                            hostnames = re.findall(r"looking up [A-Z]+ for ([\w.-]+)", err_detail)
+                            error["hostname"] = hostnames[0] if hostnames else "unknown"
                             message = error["hostname"] + " doesn't have a valid DNS record"
                         elif err_detail:
                             error["dns"] = {"error": err_detail}
@@ -60,7 +69,9 @@ class AcmeHttpError(AcmeError, requests.HTTPError):
                             error["dns"] = {"error": error}
                             message = err_detail
                     else:
-                        validation_record = validation_record[0]
+                        validation_record = (
+                            validation_record[0] if isinstance(validation_record, list) and validation_record else {}
+                        )
                         error["hostname"] = validation_record.get("hostname", "unknown")
                         error["dns"] = {
                             "resolved": validation_record.get("addressesResolved"),
@@ -103,8 +114,8 @@ class AcmeHttpError(AcmeError, requests.HTTPError):
                             match = re.search(pattern, err_detail)
 
                             if match:
-                                error["response"] = (match.group(1) if match is not None else err_detail,)
-                                error["status_code"] = (error.get("status"),)
+                                error["response"] = match.group(1) if match is not None else err_detail
+                                error["status_code"] = error.get("status")
                                 hostname = error.get("hostname", "unknown")
                                 status = error.get("status", "unknown")
                                 message = (
@@ -131,7 +142,7 @@ class AcmeHttpError(AcmeError, requests.HTTPError):
             return (message, error)
 
 
-class AcmeInvaliOrderError(AcmeHttpError):
+class AcmeInvalidOrderError(AcmeHttpError):
     def __init__(self, response: requests.Response, step: str):
         super().__init__(response, step)
 
@@ -140,4 +151,3 @@ class AcmeInvalidNonceError(AcmeHttpError):
     def __init__(self, response: requests.Response, step: str):
         super().__init__(response, step)
         self.can_retry = True
-        self.response = 0

{certapi-1.0.0 → certapi-1.0.2}/src/certapi/acme/Challenge.py

@@ -68,7 +68,7 @@ class Challenge:
                 self.verified = True
                 return True
             elif res_json["status"] == "invalid":
-                raise AcmeInvaliOrderError(res, "Query Challenge Status")
+                raise AcmeInvalidOrderError(res, "Query Challenge Status")
             else:
                 return False
 

{certapi-1.0.0 → certapi-1.0.2}/src/certapi/challenge_solver/ChallengeSolver.py

@@ -13,6 +13,9 @@ class ChallengeSolver(ABC):
     def supports_domain(self, domain: str) -> bool:
         pass
 
+    def supports_domain_strict(self, domain: str) -> bool:
+        return self.supports_domain(domain)
+
     @abstractmethod
     def save_challenge(self, key: str, value: str, domain: str = None):
         pass

certapi-1.0.2/src/certapi/challenge_solver/FileSystemChallengeSolver.py

@@ -0,0 +1,115 @@
+from typing import Literal
+from .ChallengeSolver import ChallengeSolver
+import os
+import random
+import string
+import requests
+import sys
+import re
+
+
+class FilesystemChallengeSolver(ChallengeSolver):
+    """
+    Filesystem implementation of the ChallengeSolver.
+    This should never be used, but extended for your webserver e.g. nginx, apache etc.
+    """
+
+    def __init__(self, directory: str):
+        self.directory = directory
+        os.makedirs(self.directory, exist_ok=True)
+
+    def supports_domain(self, domain: str) -> bool:
+        return "*" not in domain
+
+    def supports_domain_strict(self, domain: str) -> bool:
+        return self.verify_domain(domain) if self.supports_domain(domain) else False
+
+    def save_challenge(self, key: str, value: str, domain: str = None):
+        file_path = os.path.join(self.directory, key)
+        with open(file_path, "w") as file:
+            file.write(value)
+
+    def get_challenge(self, key: str, domain: str = None) -> str:
+        file_path = os.path.join(self.directory, key)
+        if not os.path.exists(file_path):
+            return None
+        with open(file_path, "r") as file:
+            return file.read()
+
+    def delete_challenge(self, key: str, domain: str = None):
+        file_path = os.path.join(self.directory, key)
+        if os.path.exists(file_path):
+            os.remove(file_path)
+
+    def supported_challenge_type(self) -> Literal["http-01"]:
+        return "http-01"
+
+    def cleanup_old_challenges(self):
+        for filename in os.listdir(self.directory):
+            file_path = os.path.join(self.directory, filename)
+            if os.path.isfile(file_path):
+                os.remove(file_path)
+
+    def __iter__(self):
+        return (f for f in os.listdir(self.directory) if os.path.isfile(os.path.join(self.directory, f)))
+
+    @staticmethod
+    def is_valid_hostname(hostname):
+        if not hostname or len(hostname) > 255:
+            return False
+        if hostname[-1] == ".":
+            hostname = hostname[:-1]
+
+        allowed = re.compile(r"(?!-)[A-Z\d-]{1,63}(?<!-)$", re.IGNORECASE)
+        return all(allowed.match(x) for x in hostname.split("."))
+
+    def verify_domain(self, _domain: list | str):
+        domain = [_domain] if type(_domain) is str else _domain
+
+        # Simple hostname validation
+        domain = [x for x in domain if self.is_valid_hostname(x)]
+        success = []
+        while True:
+            r1 = "".join([random.choice(string.ascii_letters + string.digits) for _ in range(32)])
+            file = os.path.join(self.directory, r1)
+            if os.path.exists(file):
+                continue
+            r2 = "".join([random.choice(string.ascii_letters + string.digits) for _ in range(256)])
+            with open(file, mode="wt") as file_descriptor:
+                file_descriptor.write(r2)
+            for d in domain:
+                try:
+                    url = "http://%s/.well-known/acme-challenge/%s" % (d, r1)
+                    response = requests.get(url, allow_redirects=False, timeout=3)
+                    if response.status_code == 200:
+                        if response.content.decode("utf-8") == r2:
+                            success.append(d)
+                            continue
+                    print(
+                        "[Error] ["
+                        + d
+                        + "] Not owned by this machine:"
+                        + "Status Code["
+                        + str(response.status_code)
+                        + "] -> "
+                        + url,
+                        file=sys.stderr,
+                    )
+                    continue
+                except requests.exceptions.RequestException as e:
+                    error = str(e)
+                    if error.find("Name does not resolve") > -1:
+                        print("[Error] [" + d + "] Domain Name could not be resolved", file=sys.stderr)
+                    elif error.find("Connection refused") > -1:
+                        print(
+                            "[Error] [" + d + "] Connection Refused! The port is filtered or not open.", file=sys.stderr
+                        )
+                    else:
+                        print("[ERROR] [" + d + "] Not owned by this machine : " + str(e))
+                    continue
+            os.remove(file)
+            break
+        if type(_domain) is str:
+            return len(success) > 0
+        else:
+            return success

certapi-1.0.2/src/certapi/client/__init__.py

@@ -0,0 +1 @@
+from .cert_manager_client import CertManagerClient

{certapi-1.0.0 → certapi-1.0.2}/src/certapi/client/cert_manager_client.py

@@ -1,11 +1,15 @@
 import requests
-from typing import List, Union, Dict, Optional, Any
+from typing import List, Union, Dict, Optional, Any, Literal
+from cryptography import x509
 from certapi.http.types import CertificateResponse, IssuedCert
+from certapi.keystore.KeyStore import KeyStore
+from certapi.crypto import Key
 
 
 class CertManagerClient:
-    def __init__(self, base_url: str):
+    def __init__(self, base_url: str, key_store: Optional[KeyStore] = None):
         self.base_url = base_url
+        self.key_store = key_store
 
     def _get(self, path: str, params: Optional[Dict[str, Any]] = None) -> Any:
         response = requests.get(f"{self.base_url}{path}", params=params)
@@ -24,19 +28,29 @@ class CertManagerClient:
         response.raise_for_status()
         return response.json()
 
-    def obtain_certificate(
+    def setup(self):
+        """
+        Check connection to the cert manager server.
+        """
+        try:
+            self._get("/keys")
+        except Exception as e:
+            print(f"Warning: CertManagerClient could not connect to {self.base_url}: {e}")
+
+    def issue_certificate(
         self,
-        hostnames: Union[str, List[str]],
-        key_type: str = "ecdsa",
+        hosts: Union[str, List[str]],
+        key_type: Literal["rsa", "ecdsa", "ed25519"] = "ecdsa",
         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,
+        renew_threshold_days: Optional[int] = None,
     ) -> CertificateResponse:
         params = {
-            "hostname": hostnames if isinstance(hostnames, str) else hostnames,
+            "hostname": hosts if isinstance(hosts, str) else hosts,
             "key_type": key_type,
             "expiry_days": expiry_days,
         }
@@ -50,11 +64,32 @@ class CertManagerClient:
             params["organization"] = organization
         if user_id:
             params["user_id"] = user_id
+        if renew_threshold_days is not None:
+            params["renew_threshold_days"] = renew_threshold_days
 
         data = self._get("/obtain", params=params)
-        return CertificateResponse.from_json(data)
+        res = CertificateResponse.from_json(data)
+
+        if self.key_store:
+            for cert_data in res.issued + res.existing:
+                if cert_data.privateKey and cert_data.certificate:
+                    try:
+                        key = Key.from_pem(cert_data.privateKey.encode("utf-8"))
+                        key_id = self.key_store.save_key(key, cert_data.domains[0])
+                        self.key_store.save_cert(key_id, cert_data.certificate, cert_data.domains)
+                    except Exception as e:
+                        print(f"Warning: Failed to save certificate for {cert_data.domains} to KeyStore: {e}")
+                        raise e
+        return res
+
+    def issue_certificate_for_csr(self, csr: Union[str, x509.CertificateSigningRequest]) -> str:
+        if not isinstance(csr, str):
+            from ..crypto import csr_to_pem
+
+            csr_pem = csr_to_pem(csr).decode("utf-8")
+        else:
+            csr_pem = csr
 
-    def sign_csr(self, csr_pem: str) -> str:
         response = requests.post(
             f"{self.base_url}/sign_csr", data=csr_pem, headers={"Content-Type": "application/x-pem-file"}
         )

{certapi-1.0.0 → certapi-1.0.2}/src/certapi/http/types.py

@@ -41,7 +41,7 @@ class IssuedCert:
         return f"IssuedCert(domains={self.domains})"
 
     def __str__(self):
-        return f"(hosts: {self.domains}, certificate:{self.certificate})"
+        return f"(domains: {self.domains}, certificate:{self.certificate})"
 
     def to_json(self):
         return {"privateKey": self.privateKey, "certificate": self.certificate, "domains": self.domains}

{certapi-1.0.0 → certapi-1.0.2}/src/certapi/issuers/AcmeCertIssuer.py

@@ -28,7 +28,7 @@ class AcmeCertIssuer(CertIssuer):
         account_key_name: str = "acme_account.key",
         acme_url: str = None,
     ) -> "AcmeCertIssuer":
-        account_key, _ = key_store._get_or_generate_key(account_key_name)
+        account_key, _ = key_store._get_or_generate_key(account_key_name, "rsa")
         return AcmeCertIssuer(account_key, challenge_solver, acme_url=acme_url)
 
     def setup(self):
@@ -103,7 +103,7 @@ class AcmeCertIssuer(CertIssuer):
     def generate_key_and_cert_for_domains(
         self,
         hosts: Union[str, List[str]],
-        key_type: Literal["rsa", "ecdsa", "ed25519"] = "rsa",
+        key_type: Literal["rsa", "ecdsa", "ed25519"] = "ecdsa",
         expiry_days: int = 90,
         country: Optional[str] = None,
         state: Optional[str] = None,
@@ -130,7 +130,7 @@ class AcmeCertIssuer(CertIssuer):
     def generate_key_and_cert_for_domain(
         self,
         host: str,
-        key_type: Literal["rsa", "ecdsa", "ed25519"] = "rsa",
+        key_type: Literal["rsa", "ecdsa", "ed25519"] = "ecdsa",
         expiry_days: int = 90,
         country: Optional[str] = None,
         state: Optional[str] = None,

{certapi-1.0.0 → certapi-1.0.2}/src/certapi/issuers/abstract_certissuer.py

@@ -30,7 +30,7 @@ class CertIssuer(ABC):
     def generate_key_and_cert_for_domains(
         self,
         hosts: Union[str, List[str]],
-        key_type: Literal["rsa", "ecdsa", "ed25519"] = "rsa",
+        key_type: Literal["rsa", "ecdsa", "ed25519"] = "ecdsa",
         expiry_days: int = 90,
         country: Optional[str] = None,
         state: Optional[str] = None,
@@ -57,7 +57,7 @@ class CertIssuer(ABC):
     def generate_key_and_cert_for_domain(
         self,
         host: str,
-        key_type: Literal["rsa", "ecdsa", "ed25519"] = "rsa",
+        key_type: Literal["rsa", "ecdsa", "ed25519"] = "ecdsa",
         expiry_days: int = 90,
         country: Optional[str] = None,
         state: Optional[str] = None,

{certapi-1.0.0 → certapi-1.0.2}/src/certapi/manager/acme_cert_manager.py

@@ -66,7 +66,7 @@ class AcmeCertManager:
     def issue_certificate(
         self,
         hosts: Union[str, List[str]],
-        key_type: Literal["rsa", "ecdsa", "ed25519"] = "rsa",
+        key_type: Literal["rsa", "ecdsa", "ed25519"] = "ecdsa",
         expiry_days: int = 90,
         country: Optional[str] = None,
         state: Optional[str] = None,

{certapi-1.0.0 → certapi-1.0.2}/src/certapi/server/api.py

@@ -3,8 +3,9 @@ import threading
 import os
 from flask import request, jsonify
 from cryptography.x509 import CertificateSigningRequest
-from flask_restx import Resource, reqparse, fields
-
+from flask_restx import Resource, reqparse, fields, inputs
+from certapi.challenge_solver import FilesystemChallengeSolver
+from certapi.http.types import CertificateResponse
 from certapi import AcmeCertManager
 
 
@@ -15,37 +16,38 @@ class RenewalQueueFullError(Exception):
 
 
 class RenewalLockManager:
-    def __init__(self, queue_size: int = 5):
+    def __init__(self, queue_size: int = 16):
         self.queue_size = queue_size
         self._lock = threading.Lock()
         self._condition = threading.Condition(self._lock)
-        self._renewing_domains = set()
+        self._busy = False
         self._waiting_threads = 0
 
-    def acquire(self, domains):
-        while True:
-            with self._lock:
-                # Check if any domain is already being renewed by another thread
-                if any(h in self._renewing_domains for h in domains):
-                    if self._waiting_threads >= self.queue_size:
-                        raise RenewalQueueFullError("Proper queue is full")
-
-                    self._waiting_threads += 1
-                    self._condition.wait()
-                    self._waiting_threads -= 1
-                    continue  # Re-check everything after waking up
-
-                # Mark as renewing
-                for h in domains:
-                    self._renewing_domains.add(h)
-                break
-
-    def release(self, domains):
+    def acquire(self, domains=None):
+        with self._lock:
+            while self._busy:
+                if self._waiting_threads >= self.queue_size:
+                    raise RenewalQueueFullError("Renewal queue is full, please try again later")
+
+                self._waiting_threads += 1
+                self._condition.wait()
+                self._waiting_threads -= 1
+
+            # Mark as busy
+            self._busy = True
+
+    def release(self, domains=None):
         with self._lock:
-            for h in domains:
-                self._renewing_domains.discard(h)
+            self._busy = False
             self._condition.notify_all()
 
+    def __enter__(self):
+        self.acquire()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.release()
+
 
 def create_api_resources(api_ns, cert_manager: AcmeCertManager, renew_queue_size: int = 5):
 
@@ -89,6 +91,12 @@ def create_api_resources(api_ns, cert_manager: AcmeCertManager, renew_queue_size
     obtain_parser.add_argument("organization", type=str, help="Organization name")
     obtain_parser.add_argument("user_id", type=str, help="User ID")
     obtain_parser.add_argument("renew_threshold_days", type=int, help="Threshold in days for certificate reuse")
+    obtain_parser.add_argument(
+        "skip_failing",
+        type=inputs.boolean,
+        default=False,
+        help="Allow issuance to proceed if some domains fail verification",
+    )
 
     @api_ns.route("/obtain")
     class ObtainCert(Resource):
@@ -102,10 +110,24 @@ def create_api_resources(api_ns, cert_manager: AcmeCertManager, renew_queue_size
         def get(self):
             args = obtain_parser.parse_args()
             hostnames = args["hostname"]
+            skip_failing = args.get("skip_failing", False)
+
+            with lock_manager:
+                verified_hostnames = []
+                for h in hostnames:
+                    # Find the first solver that supports this domain
+                    for solver in reversed(cert_manager.challenge_solvers):
+                        if solver.supports_domain_strict(h):
+                            verified_hostnames.append(h)
+
+                hostnames = verified_hostnames
+
+                if not hostnames and not skip_failing:
+                    api_ns.abort(400, message="None of the domains are owned by this machine or could be verified")
+
+                if not hostnames:
+                    return CertificateResponse().to_json()
 
-            # Acquire lock for the domains
-            lock_manager.acquire(hostnames)
-            try:
                 data = cert_manager.issue_certificate(
                     hostnames,
                     key_type=args["key_type"],
@@ -117,15 +139,13 @@ def create_api_resources(api_ns, cert_manager: AcmeCertManager, renew_queue_size
                     user_id=args["user_id"],
                     renew_threshold_days=args.get("renew_threshold_days"),
                 )
-            finally:
-                lock_manager.release(hostnames)
-
-            print(data)
-            print(data.to_json())
-            if data:
-                return data.to_json()
-            else:
-                api_ns.abort(500, message="something went wrong")
+
+                print(data)
+                if data:
+                    res_json = data.to_json()
+                    return res_json
+                else:
+                    api_ns.abort(500, message="something went wrong")
 
     @api_ns.route("/sign_csr")
     class SignCsr(Resource):