easycert 0.1.0__tar.gz

easycert-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 lshdevtech
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

easycert-0.1.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.1
+Name: easycert
+Version: 0.1.0
+Summary: Simplified X.509 certificate generation and verification toolkit
+Author: lsh101123
+Author-email: lsh101123@163.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+License-File: LICENSE
+Requires-Dist: cryptography>=42.0.0
+Requires-Dist: pycryptodome>=3.20.0

easycert-0.1.0/README.md

@@ -0,0 +1,99 @@
+# easycert
+
+Simplified X.509 certificate generation and verification toolkit.
+
+## Features
+
+- Generate RSA key pairs
+- Create self-signed X.509 certificates
+- Verify certificate signatures
+- Check certificate validity periods
+- Object-oriented verification interface
+- Detailed error handling
+
+## Installation
+
+```bash
+pip install .
+```
+
+## Dependencies
+
+- cryptography
+- pycryptodome
+
+## Usage
+
+### Generate self-signed certificate
+
+```python
+import easycert
+
+# Generate self-signed certificate
+private_key_pem, cert = easycert.generate_self_signed_certificate(
+    common_name="example.com",
+    valid_days=365
+)
+
+# Save to files
+easycert.save_key_pair(private_key_pem, private_key_pem, "private.pem", "public.pem")
+easycert.save_certificate(cert, "cert.crt")
+```
+
+### Verify certificate
+
+```python
+import easycert
+
+# Using functional interface
+result = easycert.verify_certificate_from_file("cert.crt")
+easycert.print_verification_result(result)
+
+# Using object-oriented interface
+verifier = easycert.Verify("cert.crt")
+verifier.print_info()
+verifier.print_result()
+print(f"Certificate valid: {verifier.is_valid}")
+```
+
+## API Reference
+
+### Generation Module
+
+- `generate_key_pair(key_size=2048)`: Generate RSA key pair
+- `generate_certificate(private_key_pem, common_name="localhost", valid_days=365)`: Generate X.509 certificate
+- `generate_self_signed_certificate(common_name="localhost", key_size=2048, valid_days=365)`: Generate self-signed certificate
+- `save_key_pair(private_key_pem, public_key_pem, private_key_path, public_key_path)`: Save key pair to files
+- `load_key_pair(private_key_path, public_key_path)`: Load key pair from files
+- `save_certificate(cert, cert_path)`: Save certificate to file
+- `load_certificate(cert_path)`: Load certificate from file
+
+### Verification Module
+
+- `verify_certificate_signature(cert)`: Verify certificate signature
+- `verify_certificate_validity(cert, check_time=None)`: Verify certificate validity period
+- `verify_certificate(cert, check_time=None)`: Complete certificate verification
+- `verify_certificate_from_file(cert_path, check_time=None)`: Load and verify certificate from file
+- `print_certificate_info(cert)`: Print certificate information
+- `print_verification_result(result)`: Print verification result
+
+### Verify Class
+
+- `Verify(cert_input)`: Initialize verifier with certificate file path or object
+- `verify_signature()`: Verify certificate signature
+- `verify_validity(check_time=None)`: Verify certificate validity period
+- `verify(check_time=None)`: Complete certificate verification
+- `print_info()`: Print certificate information
+- `print_result(check_time=None)`: Print verification result
+- Properties: `subject`, `issuer`, `serial_number`, `not_valid_before`, `not_valid_after`, `is_valid`, `certificate`
+
+## Exceptions
+
+- `CertificateValidationError`: Base exception for certificate validation errors
+- `CertificateSignatureError`: Certificate signature verification failed
+- `CertificateExpiredError`: Certificate has expired
+- `CertificateNotYetValidError`: Certificate is not yet valid
+
+## License
+
+MIT License

easycert-0.1.0/easycert/__init__.py

@@ -0,0 +1,54 @@
+"""
+easycert - Simplified X.509 certificate generation and verification toolkit
+"""
+
+from .generate import (
+    generate_key_pair,
+    load_private_key,
+    generate_certificate,
+    save_key_pair,
+    load_key_pair,
+    save_certificate,
+    load_certificate,
+    generate_self_signed_certificate,
+)
+
+from .verify import (
+    CertificateValidationError,
+    CertificateSignatureError,
+    CertificateExpiredError,
+    CertificateNotYetValidError,
+    Verify,
+    verify_certificate_signature,
+    verify_certificate_validity,
+    verify_certificate,
+    verify_certificate_from_file,
+    print_certificate_info,
+    print_verification_result,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    # Generation module
+    "generate_key_pair",
+    "load_private_key",
+    "generate_certificate",
+    "save_key_pair",
+    "load_key_pair",
+    "save_certificate",
+    "load_certificate",
+    "generate_self_signed_certificate",
+    # Verification module
+    "CertificateValidationError",
+    "CertificateSignatureError",
+    "CertificateExpiredError",
+    "CertificateNotYetValidError",
+    "Verify",
+    "verify_certificate_signature",
+    "verify_certificate_validity",
+    "verify_certificate",
+    "verify_certificate_from_file",
+    "print_certificate_info",
+    "print_verification_result",
+]

easycert-0.1.0/easycert/generate.py

@@ -0,0 +1,173 @@
+from Crypto.PublicKey import RSA
+from cryptography.hazmat.primitives import serialization
+from cryptography import x509
+from cryptography.x509.oid import NameOID
+from cryptography.hazmat.primitives import hashes
+import datetime
+from typing import Optional, Tuple
+
+
+def generate_key_pair(key_size: int = 2048) -> Tuple[bytes, bytes]:
+    """
+    Generate RSA key pair
+    
+    Args:
+        key_size: Key size in bits, default is 2048
+        
+    Returns:
+        (private_key_pem, public_key_pem) Private and public keys in PEM format
+    """
+    rsa_key = RSA.generate(key_size)
+    private_key_pem = rsa_key.export_key()
+    public_key_pem = rsa_key.publickey().export_key()
+    return private_key_pem, public_key_pem
+
+
+def load_private_key(private_key_pem: bytes, password: Optional[bytes] = None):
+    """
+    Load private key in PEM format
+    
+    Args:
+        private_key_pem: Private key in PEM format
+        password: Private key password (if any)
+        
+    Returns:
+        Loaded private key object
+    """
+    return serialization.load_pem_private_key(private_key_pem, password=password)
+
+
+def generate_certificate(
+    private_key_pem: bytes,
+    common_name: str = "localhost",
+    valid_days: int = 365,
+    custom_subject: Optional[x509.Name] = None,
+    custom_issuer: Optional[x509.Name] = None
+) -> x509.Certificate:
+    """
+    Generate X.509 certificate
+    
+    Args:
+        private_key_pem: Private key in PEM format
+        common_name: Certificate common name, default is localhost
+        valid_days: Certificate validity period in days, default is 365 days
+        custom_subject: Custom subject information
+        custom_issuer: Custom issuer information
+        
+    Returns:
+        Generated X.509 certificate object
+    """
+    private_key = load_private_key(private_key_pem)
+    
+    # Use custom subject or default subject
+    if custom_subject:
+        subject = custom_subject
+    else:
+        subject = x509.Name([
+            x509.NameAttribute(NameOID.COMMON_NAME, common_name),
+        ])
+    
+    # Use custom issuer or default issuer (self-signed)
+    issuer = custom_issuer if custom_issuer else subject
+    
+    # Build certificate
+    cert = x509.CertificateBuilder().subject_name(
+        subject
+    ).issuer_name(
+        issuer
+    ).public_key(
+        private_key.public_key()
+    ).serial_number(
+        x509.random_serial_number()
+    ).not_valid_before(
+        datetime.datetime.now(datetime.UTC)
+    ).not_valid_after(
+        datetime.datetime.now(datetime.UTC) + datetime.timedelta(days=valid_days)
+    ).sign(private_key, hashes.SHA256())
+    
+    return cert
+
+
+def save_key_pair(private_key_pem: bytes, public_key_pem: bytes, 
+                  private_key_path: str, 
+                  public_key_path: str) -> None:
+    """
+    Save key pair to files
+    
+    Args:
+        private_key_pem: Private key in PEM format
+        public_key_pem: Public key in PEM format
+        private_key_path: Private key save path
+        public_key_path: Public key save path
+    """
+    with open(private_key_path, "wb") as f:
+        f.write(private_key_pem)
+    with open(public_key_path, "wb") as f:
+        f.write(public_key_pem)
+
+
+def load_key_pair(private_key_path: str,
+                  public_key_path: str) -> Tuple[bytes, bytes]:
+    """
+    Load key pair from files
+    
+    Args:
+        private_key_path: Private key file path
+        public_key_path: Public key file path
+        
+    Returns:
+        (private_key_pem, public_key_pem) Private and public keys in PEM format
+    """
+    with open(private_key_path, "rb") as f:
+        private_key_pem = f.read()
+    with open(public_key_path, "rb") as f:
+        public_key_pem = f.read()
+    return private_key_pem, public_key_pem
+
+
+def save_certificate(cert: x509.Certificate, cert_path: str) -> None:
+    """
+    Save certificate to file
+    
+    Args:
+        cert: X.509 certificate object
+        cert_path: Certificate save path
+    """
+    with open(cert_path, "wb") as f:
+        f.write(cert.public_bytes(serialization.Encoding.PEM))
+
+
+def load_certificate(cert_path: str) -> x509.Certificate:
+    """
+    Load certificate from file
+    
+    Args:
+        cert_path: Certificate file path
+        
+    Returns:
+        X.509 certificate object
+    """
+    with open(cert_path, "rb") as f:
+        cert = x509.load_pem_x509_certificate(f.read())
+    return cert
+
+
+def generate_self_signed_certificate(
+    common_name: str = "localhost",
+    key_size: int = 2048,
+    valid_days: int = 365
+) -> Tuple[bytes, x509.Certificate]:
+    """
+    Generate self-signed certificate (includes key generation)
+    
+    Args:
+        common_name: Certificate common name
+        key_size: Key size in bits
+        valid_days: Certificate validity period in days
+        
+    Returns:
+        (private_key_pem, certificate) Private key and certificate
+    """
+    private_key_pem, _ = generate_key_pair(key_size)
+    cert = generate_certificate(private_key_pem, common_name, valid_days)
+    return private_key_pem, cert

easycert-0.1.0/easycert/verify.py

@@ -0,0 +1,300 @@
+from cryptography import x509
+from cryptography.hazmat.primitives.asymmetric import padding
+from cryptography.exceptions import InvalidSignature
+import datetime
+from typing import Dict, Any, Optional
+
+
+class CertificateValidationError(Exception):
+    """Base exception for certificate validation errors"""
+    pass
+
+
+class CertificateSignatureError(CertificateValidationError):
+    """Certificate signature verification failed"""
+    pass
+
+
+class CertificateExpiredError(CertificateValidationError):
+    """Certificate has expired"""
+    pass
+
+
+class CertificateNotYetValidError(CertificateValidationError):
+    """Certificate is not yet valid"""
+    pass
+
+
+def verify_certificate_signature(cert: x509.Certificate) -> bool:
+    """
+    Verify certificate signature
+    
+    Args:
+        cert: X.509 certificate object
+        
+    Returns:
+        Whether the signature is valid
+        
+    Raises:
+        CertificateSignatureError: Signature verification failed
+    """
+    try:
+        cert.public_key().verify(
+            cert.signature,
+            cert.tbs_certificate_bytes,
+            padding.PKCS1v15(),
+            cert.signature_hash_algorithm
+        )
+        return True
+    except InvalidSignature as e:
+        raise CertificateSignatureError("Certificate signature is invalid") from e
+
+
+def verify_certificate_validity(cert: x509.Certificate, 
+                                  check_time: Optional[datetime.datetime] = None) -> bool:
+    """
+    Verify certificate validity period
+    
+    Args:
+        cert: X.509 certificate object
+        check_time: Check time, default is current time
+        
+    Returns:
+        Whether the certificate is within validity period
+        
+    Raises:
+        CertificateNotYetValidError: Certificate is not yet valid
+        CertificateExpiredError: Certificate has expired
+    """
+    if check_time is None:
+        check_time = datetime.datetime.now(datetime.UTC)
+    
+    if cert.not_valid_before_utc > check_time:
+        raise CertificateNotYetValidError("Certificate is not yet valid")
+    
+    if cert.not_valid_after_utc < check_time:
+        raise CertificateExpiredError("Certificate has expired")
+    
+    return True
+
+
+def verify_certificate(cert: x509.Certificate, 
+                       check_time: Optional[datetime.datetime] = None) -> Dict[str, Any]:
+    """
+    Complete certificate verification (signature + validity)
+    
+    Args:
+        cert: X.509 certificate object
+        check_time: Check time, default is current time
+        
+    Returns:
+        Verification result dictionary containing valid status and detailed information
+        
+    Raises:
+        CertificateValidationError: Certificate verification failed
+    """
+    result = {
+        "valid": False,
+        "signature_valid": False,
+        "validity_valid": False,
+        "not_valid_before": cert.not_valid_before_utc.isoformat(),
+        "not_valid_after": cert.not_valid_after_utc.isoformat(),
+        "subject": cert.subject.rfc4514_string(),
+        "issuer": cert.issuer.rfc4514_string(),
+        "serial_number": str(cert.serial_number),
+        "errors": []
+    }
+    
+    # Verify signature
+    try:
+        verify_certificate_signature(cert)
+        result["signature_valid"] = True
+    except CertificateValidationError as e:
+        result["errors"].append(str(e))
+    
+    # Verify validity
+    try:
+        verify_certificate_validity(cert, check_time)
+        result["validity_valid"] = True
+    except CertificateValidationError as e:
+        result["errors"].append(str(e))
+    
+    # Overall validity
+    result["valid"] = result["signature_valid"] and result["validity_valid"]
+    
+    return result
+
+
+def verify_certificate_from_file(cert_path: str, 
+                                  check_time: Optional[datetime.datetime] = None) -> Dict[str, Any]:
+    """
+    Load certificate from file and verify it
+    
+    Args:
+        cert_path: Certificate file path
+        check_time: Check time, default is current time
+        
+    Returns:
+        Verification result dictionary
+    """
+    with open(cert_path, "rb") as f:
+        cert = x509.load_pem_x509_certificate(f.read())
+    return verify_certificate(cert, check_time)
+
+
+def print_certificate_info(cert: x509.Certificate) -> None:
+    """
+    Print certificate basic information
+    
+    Args:
+        cert: X.509 certificate object
+    """
+    print(f"Subject: {cert.subject.rfc4514_string()}")
+    print(f"Issuer: {cert.issuer.rfc4514_string()}")
+    print(f"Serial Number: {cert.serial_number}")
+    print(f"Valid From: {cert.not_valid_before_utc}")
+    print(f"Valid To: {cert.not_valid_after_utc}")
+    print(f"Signature Algorithm: {cert.signature_algorithm_oid._name}")
+
+
+def print_verification_result(result: Dict[str, Any]) -> None:
+    """
+    Print verification result
+    
+    Args:
+        result: Result dictionary returned by verify_certificate
+    """
+    if result["valid"]:
+        print("Certificate is fully valid (signature and validity are both normal)")
+    else:
+        print("Certificate is invalid")
+        for error in result["errors"]:
+            print(f"   - {error}")
+    
+    print(f"\nDetailed Information:")
+    print(f"  Subject: {result['subject']}")
+    print(f"  Issuer: {result['issuer']}")
+    print(f"  Serial Number: {result['serial_number']}")
+    print(f"  Valid From: {result['not_valid_before']}")
+    print(f"  Valid To: {result['not_valid_after']}")
+    print(f"  Signature Verification: {'Passed' if result['signature_valid'] else 'Failed'}")
+    print(f"  Validity Verification: {'Passed' if result['validity_valid'] else 'Failed'}")
+
+
+class Verify:
+    """
+    Certificate verification class with object-oriented interface
+    
+    Example:
+        verifier = Verify("cert.crt")
+        verifier.verify()
+        verifier.print_info()
+    """
+    
+    def __init__(self, cert_input: str | x509.Certificate):
+        """
+        Initialize verifier with certificate file path or certificate object
+        
+        Args:
+            cert_input: Certificate file path or x509.Certificate object
+        """
+        if isinstance(cert_input, str):
+            with open(cert_input, "rb") as f:
+                self.cert = x509.load_pem_x509_certificate(f.read())
+        elif isinstance(cert_input, x509.Certificate):
+            self.cert = cert_input
+        else:
+            raise TypeError("cert_input must be a file path (str) or x509.Certificate object")
+    
+    def verify_signature(self) -> bool:
+        """
+        Verify certificate signature
+        
+        Returns:
+            True if signature is valid
+            
+        Raises:
+            CertificateSignatureError: Signature verification failed
+        """
+        return verify_certificate_signature(self.cert)
+    
+    def verify_validity(self, check_time: Optional[datetime.datetime] = None) -> bool:
+        """
+        Verify certificate validity period
+        
+        Args:
+            check_time: Check time, default is current time
+            
+        Returns:
+            True if certificate is within validity period
+            
+        Raises:
+            CertificateNotYetValidError: Certificate is not yet valid
+            CertificateExpiredError: Certificate has expired
+        """
+        return verify_certificate_validity(self.cert, check_time)
+    
+    def verify(self, check_time: Optional[datetime.datetime] = None) -> Dict[str, Any]:
+        """
+        Complete certificate verification (signature + validity)
+        
+        Args:
+            check_time: Check time, default is current time
+            
+        Returns:
+            Verification result dictionary containing valid status and detailed information
+        """
+        return verify_certificate(self.cert, check_time)
+    
+    def print_info(self) -> None:
+        """Print certificate basic information"""
+        print_certificate_info(self.cert)
+    
+    def print_result(self, check_time: Optional[datetime.datetime] = None) -> None:
+        """
+        Print verification result
+        
+        Args:
+            check_time: Check time, default is current time
+        """
+        result = self.verify(check_time)
+        print_verification_result(result)
+    
+    @property
+    def subject(self) -> str:
+        """Get certificate subject"""
+        return self.cert.subject.rfc4514_string()
+    
+    @property
+    def issuer(self) -> str:
+        """Get certificate issuer"""
+        return self.cert.issuer.rfc4514_string()
+    
+    @property
+    def serial_number(self) -> int:
+        """Get certificate serial number"""
+        return self.cert.serial_number
+    
+    @property
+    def not_valid_before(self) -> datetime.datetime:
+        """Get certificate validity start time"""
+        return self.cert.not_valid_before_utc
+    
+    @property
+    def not_valid_after(self) -> datetime.datetime:
+        """Get certificate validity end time"""
+        return self.cert.not_valid_after_utc
+    
+    @property
+    def is_valid(self) -> bool:
+        """Check if certificate is currently valid (signature + validity)"""
+        try:
+            result = self.verify()
+            return result["valid"]
+        except CertificateValidationError:
+            return False
+    
+    @property
+    def certificate(self) -> x509.Certificate:
+        """Get the underlying certificate object"""
+        return self.cert

easycert-0.1.0/easycert.egg-info/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.1
+Name: easycert
+Version: 0.1.0
+Summary: Simplified X.509 certificate generation and verification toolkit
+Author: lsh101123
+Author-email: lsh101123@163.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+License-File: LICENSE
+Requires-Dist: cryptography>=42.0.0
+Requires-Dist: pycryptodome>=3.20.0

easycert-0.1.0/easycert.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+setup.py
+easycert/__init__.py
+easycert/generate.py
+easycert/verify.py
+easycert.egg-info/PKG-INFO
+easycert.egg-info/SOURCES.txt
+easycert.egg-info/dependency_links.txt
+easycert.egg-info/requires.txt
+easycert.egg-info/top_level.txt

easycert-0.1.0/easycert.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

easycert-0.1.0/easycert.egg-info/requires.txt

@@ -0,0 +1,2 @@
+cryptography>=42.0.0
+pycryptodome>=3.20.0

easycert-0.1.0/easycert.egg-info/top_level.txt

@@ -0,0 +1 @@
+easycert

easycert-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

easycert-0.1.0/setup.py

@@ -0,0 +1,20 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="easycert",
+    version="0.1.0",
+    description="Simplified X.509 certificate generation and verification toolkit",
+    author="lsh101123",
+    author_email="lsh101123@163.com",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.8",
+    install_requires=[
+        "cryptography>=42.0.0",
+        "pycryptodome>=3.20.0"
+    ]
+)