Revize 18588728

Re #8472 - Small changes in the documentation

proj/services/cryptography.py

@@ -72 +72 @@
         Creates a private key with the option to encrypt it using a passphrase.
         :param passphrase: A passphrase to be used when encrypting the key (if none is passed then the key is not
         encrypted at all). Empty passphrase ("") also results in a key that is not encrypted.
-        :return: A text representation of the generated private key.
+        :return: string containing the generated private key in PEM format
         """
         if passphrase is None or len(passphrase) == 0:
             return self._run_for_output(["genrsa", "2048"]).decode()
@@ -80 +80 @@
             return self._run_for_output(
                 ["genrsa", PRIVATE_KEY_ENCRYPTION_METHOD, "-passout", f"pass:{passphrase}", "2048"]).decode()
 
-    def create_sscrt(self, key, subject, config="", extensions="", key_passphrase=None):
+    def create_sscrt(self, key, subject, config="", extensions="", key_pass=None):
         """
         Creates a root CA
 
@@ -88 +88 @@
         :param subject: an instance of <Subject> representing the subject to be added to the certificate
         :param config: string containing the configuration to be used
         :param extensions: name of the section in the configuration representing extensions
-        :param key_passphrase: passphrase of the private key
+        :param key_pass: passphrase of the private key
 
-        :return: byte array containing the generated certificate
+        :return: string containing the generated certificate in PEM format
         """
         assert key is not None
         assert subject is not None
@@ -111 +111 @@
 
             #  add the passphrase even when None is passed. Otherwise when running tests with pytest some tests freeze
             # waiting for the passphrase to be typed in
-            args.extend(["-passin", f"pass:{key_passphrase}"])
+            args.extend(["-passin", f"pass:{key_pass}"])
 
             return self._run_for_output(args, proc_input=bytes(key, encoding="utf-8")).decode()
 
@@ -122 +122 @@
         :param subject: an instance of <Subject> representing the subject to be added to the CSR
         :param subject_key: the private key of the subject to be used to generate the CSR
         :param subject_key_pass: passphrase of the subject's private key
-        :return: byte array containing the generated certificate signing request
+        :return: string containing the generated certificate signing request in PEM format
         """
 
         subj_param = self.subject_to_param_format(subject)
@@ -167 +167 @@
 
             return self._run_for_output(params, proc_input=(bytes(proc_input, encoding="utf-8"))).decode()
 
-    def create_crt(self, subject, key, issuer_pem, issuer_key, key_pass=None, issuer_key_pass=None, config="",
+    def create_crt(self, subject, subject_key, issuer_pem, issuer_key, subject_key_pass=None, issuer_key_pass=None,
+                   config="",
                    extensions=""):
         """
         Signs the given CSR by the given issuer CA
         :param subject: subject to be added to the created certificate
-        :param key: string containing the private key to be used when creating the certificate in PEM format
+        :param subject_key: string containing the private key to be used when creating the certificate in PEM format
         :param issuer_key: string containing the private key of the issuer's certificate in PEM format
         :param issuer_pem: string containing the certificate of the issuer that will sign this CSR in PEM format
         :param issuer_key: string containing the private key of the issuer's certificate in PEM format
-        :param key_pass: string containing the passphrase of the private key used when creating the certificate in PEM
+        :param subject_key_pass: string containing the passphrase of the private key used when creating the certificate in PEM
         format
         :param issuer_key_pass: string containing the passphrase of the private key of the issuer's certificate in PEM
         format
         :param config: TODO NOT USED
         :param extensions: extensions to be applied when creating the certificate
-        :return: string containing the generated in PEM format
+        :return: string containing the generated certificate in PEM format
         """
-        csr = self.make_csr(subject, key, subject_key_pass=key_pass)
+        csr = self.make_csr(subject, subject_key, subject_key_pass=subject_key_pass)
         return self.sign_csr(csr, issuer_pem, issuer_key, issuer_key_pass=issuer_key_pass, extensions=extensions)
 
 

proj/tests/services/cryptography/create_crt_test.py

@@ -33 +33 @@
     # create root CA and encrypt the private key of the root CA
     root_key_passphrase = "barbaz"
     root_key = service.create_private_key(passphrase=root_key_passphrase)
-    root_ca = service.create_sscrt(root_key, Subject(common_name="foo"), key_passphrase=root_key_passphrase)
+    root_ca = service.create_sscrt(root_key, Subject(common_name="foo"), key_pass=root_key_passphrase)
 
     # create a private key to be used to make a CSR for the intermediate CA
     inter_key_passphrase = "foobazbar"
@@ -41 +41 @@
 
     # create a CA using the root CA
     inter_ca = service.create_crt(Subject(common_name="bar", country="CZ"), inter_key, root_ca, root_key,
-                                  key_pass=inter_key_passphrase, issuer_key_pass=root_key_passphrase)
+                                  subject_key_pass=inter_key_passphrase, issuer_key_pass=root_key_passphrase)
 
     inter_ca_printed = export_crt(inter_ca)
 
@@ -63 +63 @@
         # try to create it using a wrong issuer passphrase
         with pytest.raises(CryptographyException) as e:
             inter_ca = service.create_crt(Subject(common_name="bar", country="CZ"), inter_key, root_ca, root_key,
-                                          key_pass=key_pass, issuer_key_pass=issuer_key_pass)
+                                          subject_key_pass=key_pass, issuer_key_pass=issuer_key_pass)
         assert "bad decrypt" in e.value.message
 
 
@@ -71 +71 @@
     # create root CA and encrypt the private key of the root CA
     root_key_passphrase = "barbaz"
     root_key = service.create_private_key(passphrase=root_key_passphrase)
-    root_ca = service.create_sscrt(root_key, Subject(common_name="foo"), key_passphrase=root_key_passphrase)
+    root_ca = service.create_sscrt(root_key, Subject(common_name="foo"), key_pass=root_key_passphrase)
 
     # create a private key to be used to make a CSR for the intermediate CA
     inter_key_passphrase = "foofoo"
@@ -79 +79 @@
 
     # create a CA using the root CA
     inter_ca = service.create_crt(Subject(common_name="bar", country="CZ"), inter_key, root_ca, root_key,
-                                  key_pass=inter_key_passphrase, issuer_key_pass=root_key_passphrase,
+                                  subject_key_pass=inter_key_passphrase, issuer_key_pass=root_key_passphrase,
                                   extensions="authorityInfoAccess = caIssuers;URI:bar.cz/baz/cert\nbasicConstraints=critical,CA:TRUE")
 
     inter_ca_printed = export_crt(inter_ca)

proj/tests/services/cryptography/private_keys_test.py

@@ -1 @@
-import pytest
 import subprocess
 
+import pytest
+
 
 def test_private_key(service):
     private_key = service.create_private_key()
@@ -24 +25 @@
     # incorrect passphrase provided
     with pytest.raises(subprocess.CalledProcessError):
         subprocess.check_output(["openssl", "rsa", "-in", "-", "-passin", "pass:bazbaz", "-check"],
-                                input=bytes(private_key, encoding="utf-8"), stderr=subprocess.STDOUT)
+                                input=bytes(private_key, encoding="utf-8"), stderr=subprocess.STDOUT)

proj/tests/services/cryptography/self_signed_cert_test.py

@@ -1 @@
-import pytest
 import subprocess
 
+import pytest
+
 from proj.model.subject import Subject
-from proj.services.cryptography import CryptographyService, CryptographyException
+from proj.services.cryptography import CryptographyException
 
 
 def test_create_sscrt(service):
@@ -35 +36 @@
                                         email_address="[e-mail]"),
                                 config=config,
                                 extensions="root_ca_ext",
-                                key_passphrase="foobar")
+                                key_pass="foobar")
 
     cert_printed = subprocess.check_output(["openssl", "x509", "-noout", "-text", "-in", "-"],
                                            input=bytes(cert, encoding="utf-8"), stderr=subprocess.STDOUT).decode()
@@ -89 +90 @@
     # create a self signed certificate with a PK that is protected by a passphrase
     private_key = service.create_private_key(passphrase="foobar")
 
-    cert = service.create_sscrt(private_key, Subject(common_name="Topnax", country="CZ"), key_passphrase="foobar")
+    cert = service.create_sscrt(private_key, Subject(common_name="Topnax", country="CZ"), key_pass="foobar")
 
     cert_printed = subprocess.check_output(["openssl", "x509", "-noout", "-text", "-in", "-"],
                                            input=bytes(cert, encoding="utf-8"), stderr=subprocess.STDOUT).decode()
@@ -105 +106 @@
 
     # incorrect passphrase provided when using a protected private key
     with pytest.raises(CryptographyException) as e:
-        service.create_sscrt(private_key, Subject(common_name="Topnax", country="CZ"), key_passphrase="bazfoo")
+        service.create_sscrt(private_key, Subject(common_name="Topnax", country="CZ"), key_pass="bazfoo")
     assert "bad decrypt" in e.value.message
 
     # no passphrase provided when using a protected private key
     with pytest.raises(CryptographyException) as e:
         service.create_sscrt(private_key, Subject(common_name="Topnax", country="CZ"))
     assert "bad decrypt" in e.value.message
-

proj/tests/services/cryptography/sign_csr_test.py

@@ -6 +6 @@
 from proj.services.cryptography import CryptographyException
 
 
-def export_csr(csr):
+def export_crt(csr):
     return subprocess.check_output(["openssl", "x509", "-noout", "-text", "-in", "-"],
                                    input=bytes(csr, encoding="utf-8"), stderr=subprocess.STDOUT).decode()
 
@@ -23 +23 @@
     # sign the created CSR with root CA
     inter_ca = service.sign_csr(csr, root_ca, root_key)
 
-    inter_ca_printed = export_csr(inter_ca)
+    inter_ca_printed = export_crt(inter_ca)
 
     # assert fields
     assert "Issuer: CN = foo" in inter_ca_printed
@@ -34 +34 @@
     # create root CA and encrypt the private key of the root CA
     root_key_passphrase = "barbaz"
     root_key = service.create_private_key(passphrase=root_key_passphrase)
-    root_ca = service.create_sscrt(root_key, Subject(common_name="foo"), key_passphrase=root_key_passphrase)
+    root_ca = service.create_sscrt(root_key, Subject(common_name="foo"), key_pass=root_key_passphrase)
 
     # create a private key to be used to make a CSR for the intermediate CA
     inter_key = service.create_private_key()
@@ -43 +43 @@
     # sign the created CSR with root CA and specify root key passphrase
     inter_ca = service.sign_csr(csr, root_ca, root_key, issuer_key_pass=root_key_passphrase)
 
-    inter_ca_printed = export_csr(inter_ca)
+    inter_ca_printed = export_crt(inter_ca)
 
     # assert fields
     assert "Issuer: CN = foo" in inter_ca_printed
@@ -66 +66 @@
     # create root CA and encrypt the private key of the root CA
     root_key_passphrase = "barbaz"
     root_key = service.create_private_key(passphrase=root_key_passphrase)
-    root_ca = service.create_sscrt(root_key, Subject(common_name="foo"), key_passphrase=root_key_passphrase)
+    root_ca = service.create_sscrt(root_key, Subject(common_name="foo"), key_pass=root_key_passphrase)
 
     # create a private key to be used to make a CSR for the intermediate CA
     inter_key = service.create_private_key()
@@ -77 +77 @@
                                 extensions="authorityInfoAccess = caIssuers;URI:bar.cz/baz/cert\nbasicConstraints=critical,CA:TRUE",
                                 issuer_key_pass=root_key_passphrase)
 
-    inter_ca_printed = export_csr(inter_ca)
+    inter_ca_printed = export_crt(inter_ca)
 
     # assert fields
     assert "Issuer: CN = foo" in inter_ca_printed