import asyncio, os, struct, sys, time

CP_VID = bytes.fromhex("F4ED19E0C114EB516FAAAC0EE37DAF2807B4381F")
CCC_VID = bytes.fromhex("DEFB99E69A9F1F6E06F15006B1F166AE")
FRAG_VID = bytes.fromhex("4048B7D56EBCE88525E7DE7F00D6C2D3")
HDR = 28


def ike_payload(next_type, payload_type, body):
    return struct.pack(">BBH", next_type, payload_type, 4 + len(body)) + body


def sa_body():
    attrs = b""
    attrs += struct.pack(">HH", 0x8000 | 1, 12)    # AES-CBC
    attrs += struct.pack(">HH", 0x8000 | 2, 256)   # 256 bit
    attrs += struct.pack(">HH", 0x8000 | 3, 2)     # SHA1
    attrs += struct.pack(">HH", 0x8000 | 4, 3)     # RSA-SIG
    attrs += struct.pack(">HH", 0x8000 | 14, 2)    # DH group 2
    transform = struct.pack(">BBH", 0, 0, 8 + len(attrs)) + struct.pack(">BBBB", 1, 1, 0, 0) + attrs
    proposal = struct.pack(">BBHBBBB", 0, 0, 8 + len(transform), 1, 1, 0, 1) + transform
    return struct.pack(">II", 1, 1) + proposal


SA = sa_body()
PKT = None


def build_probe(cookie):
    ck = int.from_bytes(cookie, "big")
    parts = []
    parts.append(ike_payload(13, 1, SA))
    parts.append(ike_payload(13, 13, CP_VID + struct.pack(">IIIII", 2, 0, 0, 0, 0)))
    parts.append(ike_payload(13, 13, CCC_VID))
    parts.append(ike_payload(0, 13, FRAG_VID))
    body = b"".join(parts)
    return struct.pack(">QQBBBBII", ck, 0, 1, 0x10, 2, 0, 0, HDR + len(body)) + body


def parse_vids(data):
    if len(data) < HDR:
        return None
    off = HDR
    cur = data[16]
    vids = []
    while cur != 0 and off + 4 <= len(data):
        nxt, typ, ln = struct.unpack(">BBH", data[off:off + 4])
        if ln < 4 or off + ln > len(data):
            break
        if typ == 13:
            vids.append(data[off + 4:off + ln])
        cur = nxt
        off += ln
    cp = any(v.startswith(CP_VID) for v in vids)
    ccc = any(v.startswith(CCC_VID) for v in vids)
    return cp, ccc, [v[:20].hex() for v in vids]


class Proto(asyncio.DatagramProtocol):
    def __init__(self, out):
        self.out = out
        self.n = 0
        self.transport = None

    def connection_made(self, transport):
        self.transport = transport

    def datagram_received(self, data, addr):
        if len(data) < HDR:
            return
        try:
            exch = data[18]
            flags = data[19]
            mid = struct.unpack(">I", data[20:24])[0]
            r = parse_vids(data)
            cp = ccc = False
            vidstr = ""
            if r:
                cp, ccc, vids = r
                vidstr = ",".join(vids)[:160]
            self.out.write("%s\t%d\t%d\t%d\t%d\t%d\t%d\t%s\n" % (
                addr[0], addr[1], len(data), exch, flags, mid, 1 if cp else 0, vidstr))
            self.out.flush()
            self.n += 1
        except Exception:
            pass


async def main():
    src, dst = sys.argv[1], sys.argv[2]
    rate = int(sys.argv[3]) if len(sys.argv) > 3 else 3000
    sport = int(sys.argv[4]) if len(sys.argv) > 4 else 500
    out = open(dst, "w")
    loop = asyncio.get_running_loop()
    try:
        tr, proto = await loop.create_datagram_endpoint(lambda: Proto(out), local_addr=("0.0.0.0", sport))
    except OSError as e:
        print("bind", sport, "failed:", e, flush=True)
        tr, proto = await loop.create_datagram_endpoint(lambda: Proto(out), local_addr=("0.0.0.0", 0))
    batch = max(1, rate // 20)
    pause = 0.05
    sent = 0
    t0 = time.time()
    for line in open(src):
        parts = line.split()
        if not parts:
            continue
        ip = parts[3] if len(parts) > 3 else parts[-1]
        if not ip or ip[0] == "#":
            continue
        pkt = build_probe(os.urandom(8))
        tr.sendto(pkt, (ip, 500))
        sent += 1
        if sent % batch == 0:
            await asyncio.sleep(pause)
            if sent % (batch * 20) == 0:
                el = time.time() - t0
                print("sent", sent, "replies", proto.n, "rate %.0f/s" % (sent / el), flush=True)
    await asyncio.sleep(12)
    tr.close()
    out.close()
    print("sent total", sent, "replies", proto.n, "secs %.0f" % (time.time() - t0), flush=True)


asyncio.run(main())
