raise ValueError("Invalid protocol")

class Verificator:

    def __init__(self, context: ssl.SSLContext):

        self.context = context

    def connect(self, domain: str, port: int, protocol: str) -> TLSDetails:

        handler = GenericHandler.create_handler(protocol)(domain, port, self.context)

        try:

            expiry = handler.connect(True)

            return TLSDetails(domain_name=domain, expires_in_days=expiry)

        except ssl.SSLCertVerificationError as e:

            if e.verify_code == EXPIRED:

                expiry = handler.connect(False)

                return TLSDetails(domain_name=domain, expires_in_days=expiry)

            elif e.verify_code == REVOKED:

                # This never happens, as we do not have any CRLs or OCSP set up :(

                # It's a massive pain and I'm not sure it's worth the considerable extra code

                # Maybe look into MetLife/OCSPChecker but idk

                return TLSDetails(domain_name=domain, error_message="was revoked.")

            elif e.verify_code == SELF_SIGNED:

                return TLSDetails(domain_name=domain, error_message="is self-signed.")

            elif e.verify_code == ROOT_NOT_TRUSTED:

                return TLSDetails(domain_name=domain, error_message="invalid: root not trusted.")

            else:

        except ssl.SSLError as e:

        except Exception as e:

#!/usr/bin/env python3

from rich.console import Console

import datetime

import math

EXPIRED = 10

REVOKED = 23

SELF_SIGNED = 18

ROOT_NOT_TRUSTED = 19

class TLSDetails:

    domain_name = None

    expires_in_days = None

    error_message = None

    connection_error = False

    def __init__(self, domain_name : str = None, expires_in_days : str = None, error_message : str = None, connection_error : bool = False):

        self.domain_name = domain_name

        self.expires_in_days = expires_in_days

        self.error_message = error_message

        self.connection_error = connection_error

    def print(self, console: Console):

        if self.connection_error:

        elif self.error_message != None:

        elif self.expires_in_days < 0:

        else:

def compare_expiry_timestamps(expiry_timestamp: int, now_timestamp: int = datetime.datetime.now(datetime.UTC).timestamp()) -> tuple[bool, int]:

    seconds_left = expiry_timestamp - now_timestamp

    valid = seconds_left >= 0

    # We use floor(), which, when negative, will round towards -1

    if not valid:

        seconds_left = -seconds_left

    days_left = math.floor(seconds_left / 86400)

    # We need to restore the inversion

    if not valid:

        days_left = -days_left

    return (valid, days_left)

# Returns if the cert is valid, and the number of days left until expiry (negative if expired)

def check_cert_validity(cert) -> tuple[bool, int]:

    # Get expiry date

    notAfter = cert['notAfter']

    notAfter_date = datetime.datetime.strptime(notAfter, '%b %d %H:%M:%S %Y %Z')

    # datetime to UNIX time

    notAfter_timestamp = notAfter_date.timestamp()

    expiry = compare_expiry_timestamps(notAfter_timestamp)

    return (expiry[0], expiry[1])