check_dkim

#!/usr/bin/env python3
#-------------------------------------------------------------------------------

import os
import sys
import time
import subprocess
import argparse

from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.chrome.options import Options
from selenium.webdriver import ActionChains

from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

#-------------------------------------------------------------------------------

_candebug = False
def candebug():
    global _candebug
    return _candebug
def setcandebug(value):
    global _candebug
    _candebug = value

def infomsg(msg):
    if candebug() == True:
        print(msg, flush=True)

def exitnagios(status,message):
    if status=="OK":
        exitcode = 0
    elif status=="WARNING":
        exitcode = 1
    elif status=="CRITICAL":
        exitcode = 2
    elif status=="UNKNOWN":
        exitcode = 3
    else:
        exitcode = 4
    print(status+": "+message, flush=True)
    sys.exit(exitcode)

#-------------------------------------------------------------------------------

def generatedriver(proxy):
    chrome_options = Options()
    chrome_options.add_argument("--incognito")
    chrome_options.add_argument("--disk-cache-size=0")
    chrome_options.add_argument("--media-cache-size=0")
    chrome_options.add_argument("--enable-features=EphemeralGuestProfilesOnStartup")
    chrome_options.add_argument("--headless=new")
    chrome_options.add_argument("--disable-gpu")
    chrome_options.add_argument("--no-sandbox")
    chrome_options.add_argument("--disable-dev-shm-usage")
    chrome_options.add_argument("--in-process-gpu")
    chrome_options.add_argument("--use-gl=angle")
    chrome_options.add_argument("--use-angle=swiftshader-webgl")
    chrome_options.add_argument("--proxy-server="+proxy)

    chrome_service = webdriver.ChromeService(executable_path="/usr/bin/chromedriver")

    driver = webdriver.Chrome(options=chrome_options,service=chrome_service)
    #driver.implicitly_Wait(10, TimeUnit.SECONDS)

    return driver

def check_page_loaded(driver):
    #self.log.info("Checking if {} page is loaded.".format(self.driver.current_url))
    page_state = driver.execute_script("return document.readyState;")
    return page_state == "complete"

def wait_page_loaded(driver):
    timestamp = time.time()
    while True:
        if check_page_loaded(driver) == True:
            break
        if time.time() - timestamp > 20:
            break

#-------------------------------------------------------------------------------

def tryfindbyxpath(driver,xpath):
    result = []
    try:
        result = driver.find_elements(By.XPATH, xpath)
    except:
        pass
    return result

def tryfindbyid(driver,idname):
    result = []
    try:
        result = driver.find_elements(By.ID, idname)
    except:
        pass
    return result

def tryfindbyclassname(driver,classname):
    result = []
    try:
        result = driver.find_elements(By.CLASS_NAME, classname)
    except:
        pass
    return result

#-------------------------------------------------------------------------------

def dodnssecverisigncall(domain,selector,proxy):
    try:
        driver = generatedriver(proxy)

        wait = WebDriverWait(driver,20)
        action=ActionChains(driver)

        fullkey = selector+"._domainkey."+domain
        infomsg("testing "+fullkey)

        infomsg("browser OK")
        #url = "https://www.mailhardener.com/tools/dkim-validator?domain="+fullkey
        url = "https://www.mailhardener.com/tools/dkim-validator"
        driver.get(url)
        infomsg("asking for navigating "+url)

        time.sleep(1)
        wait_page_loaded(driver)
        infomsg("page loaded")

        infomsg("waiting for input element")
        wait.until(EC.presence_of_element_located((By.ID, "inspectBtn")))

        input_element = driver.find_element(By.ID, "address")
        input_element.send_keys(fullkey)
        input_element.send_keys(Keys.RETURN)

        infomsg("waiting for result element")
        wait.until(EC.presence_of_element_located((By.ID, "dkim_details")))

        infomsg("finding base element")
        element = []
        retries = 5
        counter = 0
        waittexts = ["Inspecting record, just a moment".lower()]
        while len(element)==0:
            #plain_text = driver.find_element(By.TAG_NAME, "body").text
            #print(plain_text,flush=True)
            element = tryfindbyid(driver,"success")
            if len(element)>0:
                statustext = element[0].text.strip()
                infomsg("--> "+statustext)
                if statustext.lower() in waittexts:
                    element = []
                    if counter<retries:
                        infomsg("waiting a bit")
                        time.sleep(5)
                        counter=counter+1
                    else:
                        infomsg("too many retries")
                        break
                else:
                    infomsg("this is not registered as a waiting text, so advancing")
                    break
        if len(element)==0:
            exitnagios("WARNING","no result from page")

        infomsg("finding error message")
        error = tryfindbyclassname(driver,"tool_alert_error")
        if len(error)>0:
            exitnagios("CRITICAL",error[0].text.strip())
        else:
            infomsg("finding valid message")
            valid = tryfindbyclassname(driver,"tool_alert_success")
            if len(valid)>0:
                exitnagios("OK",valid[0].text.strip())
            else:
                infomsg(element[0].text.strip())
                exitnagios("CRITICAL","unexpected scenario")

    except Exception as e:
        exitnagios("CRITICAL","unexpected error during the check "+str(e))

#-------------------------------------------------------------------------------

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('-H', '--host',                                    dest="host",                                                           help="Hostname")
    parser.add_argument("-s", "--selector",                                dest="selector",         default="",                                   help="DKIM selector to test")
    parser.add_argument("-p", "--proxy",                                   dest="proxy",            default="",                                   help="use a proxy")
    parser.add_argument("-®", "--debug",             action="store_true",  dest="debug",            default=False,                                help="be more verbose")
    args = parser.parse_args()

    setcandebug(args.debug)

    selector = args.selector
    proxy = args.proxy

    if selector=="":
        exitnagios("CRITICAL","the selector is empty")

    dodnssecverisigncall(args.host,selector,proxy)

if __name__ == "__main__":
    main()

#-------------------------------------------------------------------------------