import asyncio, ssl, socket, sys, json, ipaddress
from cryptography import x509
from cryptography.hazmat.backends import default_backend

CIDR = "139.162.0.0/16"
SNI = "loki.fansky.net"
PORT = 443
CONC = 1500
TIMEOUT = 2.5

out = open("/var/www/html/ARTEX-main/data/tasks/1/i90/scan_results.txt", "a")
live = open("/var/www/html/ARTEX-main/data/tasks/1/i90/live_hosts.txt", "a")
fansky = open("/var/www/html/ARTEX-main/data/tasks/1/i90/fansky_hosts.txt", "a")

ctx = ssl.create_default_context()
ctx.check_hostname = False
ctx.verify_mode = ssl.CERT_NONE

def parse_sans(der):
    try:
        c = x509.load_der_x509_certificate(der, default_backend())
        sans = []
        try:
            ext = c.extensions.get_extension_for_class(x509.SubjectAlternativeName)
            sans = ext.value.get_values_for_type(x509.DNSName)
        except x509.ExtensionNotFound:
            pass
        cn = c.subject.rfc4514_string()
        issuer = c.issuer.rfc4514_string()
        return cn, issuer, sans
    except Exception as e:
        return None, None, []

sem = asyncio.Semaphore(CONC)
done = 0
found = 0

async def probe(ip):
    global done, found
    async with sem:
        try:
            reader, writer = await asyncio.wait_for(
                asyncio.open_connection(ip, PORT, ssl=ctx, server_hostname=SNI), TIMEOUT)
            try:
                so = writer.get_extra_info('ssl_object')
                der = so.getpeercert(binary_form=True) if so else None
                if der:
                    cn, issuer, sans = parse_sans(der)
                    live.write(f"{ip}\t{cn}\t{sans}\n"); live.flush()
                    if any('fansky' in (s or '') for s in sans) or 'fansky' in (cn or ''):
                        found += 1
                        line = f"{ip}\tcn={cn}\tissuer={issuer}\tsans={sans}\n"
                        fansky.write(line); fansky.flush()
                        out.write("FANSKY " + line); out.flush()
                        print("FANSKY", line.strip(), flush=True)
                writer.close()
                try: await writer.wait_closed()
                except: pass
            except Exception:
                try: writer.close()
                except: pass
        except asyncio.TimeoutError:
            pass
        except (ConnectionRefusedError, OSError, ssl.SSLError, TimeoutError):
            pass
        except Exception as e:
            pass
        done += 1
        if done % 4096 == 0:
            print(f"progress {done}/65536 found={found}", flush=True)

async def main():
    ips = [str(ip) for ip in ipaddress.ip_network(CIDR, strict=False)]
    # chunk to bound memory
    tasks = []
    for ip in ips:
        tasks.append(asyncio.create_task(probe(ip)))
    for t in asyncio.as_completed(tasks):
        await t

asyncio.run(main())
print("DONE", flush=True)
