| |
| |
| """ |
| checkproxy.py — Check proxy HANG LOAT, TU DETECT loai (HTTP / SOCKS5 / SOCKS4). |
| Chi dung thu vien chuan (stdlib), khong can cai gi. |
| |
| Quang het proxy vao 1 file (moi dong 1 con), tool tu nhan dien & check: |
| |
| host:port:user:pass <- tu thu http -> socks5 -> socks4 |
| host:port:user:pass (Http) <- duoi (Http)/(Socks5)/(Socks4) -> check dung loai do |
| socks5://user:pass@host:port <- co scheme -> check dung loai do |
| http://host:port <- proxy khong auth cung duoc |
| user:pass@host:port |
| # dong bat dau bang # bi bo qua |
| |
| Dung: |
| python3 checkproxy.py proxies.txt # check file |
| cat proxies.txt | python3 checkproxy.py # doc stdin |
| python3 checkproxy.py proxies.txt -t 200 -T 10 # 200 luong, timeout 10s |
| python3 checkproxy.py proxies.txt -o alive.txt # luu proxy SONG ra file |
| """ |
| import sys, re, time, json, socket, struct, base64, argparse |
| from concurrent.futures import ThreadPoolExecutor, as_completed |
|
|
| |
| T_HOST, T_PORT = "ip-api.com", 80 |
| T_PATH = "/json/?fields=status,query,country,city,isp" |
|
|
| C = {"g": "\033[92m", "r": "\033[91m", "y": "\033[93m", "d": "\033[90m", |
| "c": "\033[96m", "x": "\033[0m"} |
|
|
| SCHEME_MAP = {"http": "http", "https": "http", "socks5": "socks5", "socks5h": "socks5", |
| "socks4": "socks4", "socks4a": "socks4", "socks": "socks5"} |
|
|
|
|
| def parse_line(line): |
| """Tra (scheme_or_None, host, port, user, pwd) hoac None.""" |
| line = line.strip() |
| if not line or line.startswith("#"): |
| return None |
| scheme = None |
| m = re.match(r"^(\w+)://(.*)$", line) |
| if m: |
| scheme = SCHEME_MAP.get(m.group(1).lower()) |
| line = m.group(2) |
| tag = re.search(r"\(([^)]*)\)\s*$", line) |
| if tag: |
| scheme = scheme or SCHEME_MAP.get(re.sub(r"[^a-z0-9]", "", tag.group(1).lower())) |
| line = line[:tag.start()].strip() |
| line = line.split()[0] if " " in line else line |
| if "@" in line: |
| cred, hp = line.rsplit("@", 1) |
| hpp = hp.split(":") |
| if len(hpp) < 2: |
| return None |
| host, port = hpp[0], hpp[1] |
| up = cred.split(":", 1) |
| user, pwd = up[0], (up[1] if len(up) > 1 else "") |
| else: |
| parts = line.split(":") |
| if len(parts) >= 4: |
| host, port, user, pwd = parts[0], parts[1], parts[2], ":".join(parts[3:]) |
| elif len(parts) == 2: |
| host, port, user, pwd = parts[0], parts[1], "", "" |
| else: |
| return None |
| if not port.isdigit(): |
| return None |
| return scheme, host, int(port), user, pwd |
|
|
|
|
| |
| def _read_all(s, cap=65536): |
| buf = b"" |
| while len(buf) < cap: |
| try: |
| chunk = s.recv(4096) |
| except socket.timeout: |
| break |
| if not chunk: |
| break |
| buf += chunk |
| return buf |
|
|
|
|
| def _parse_http(raw): |
| """Tra (status_code:int, body:str). Loi -> (-1, '').""" |
| if b"\r\n\r\n" not in raw: |
| return -1, "" |
| head, _, body = raw.partition(b"\r\n\r\n") |
| first = head.split(b"\r\n", 1)[0].decode("latin1", "ignore") |
| parts = first.split() |
| code = int(parts[1]) if len(parts) > 1 and parts[1].isdigit() else -1 |
| return code, body.decode("utf-8", "ignore") |
|
|
|
|
| def _http_request_line_via_target(s): |
| """Gui GET (path tuong doi) qua 1 socket DA tunnel toi target.""" |
| req = ("GET %s HTTP/1.0\r\nHost: %s\r\nUser-Agent: Mozilla/5.0\r\n" |
| "Connection: close\r\n\r\n" % (T_PATH, T_HOST)) |
| s.sendall(req.encode()) |
| return _parse_http(_read_all(s)) |
|
|
|
|
| |
| def via_http(host, port, user, pwd, timeout): |
| s = socket.create_connection((host, port), timeout) |
| s.settimeout(timeout) |
| try: |
| req = "GET http://%s%s HTTP/1.0\r\nHost: %s\r\n" % (T_HOST, T_PATH, T_HOST) |
| if user: |
| cred = base64.b64encode(("%s:%s" % (user, pwd)).encode()).decode() |
| req += "Proxy-Authorization: Basic %s\r\n" % cred |
| req += "User-Agent: Mozilla/5.0\r\nConnection: close\r\n\r\n" |
| s.sendall(req.encode()) |
| code, body = _parse_http(_read_all(s)) |
| if code == 200: |
| return body |
| raise RuntimeError("HTTP %s" % (code if code > 0 else "?")) |
| finally: |
| s.close() |
|
|
|
|
| def _recvn(s, n): |
| buf = b"" |
| while len(buf) < n: |
| c = s.recv(n - len(buf)) |
| if not c: |
| raise RuntimeError("conn closed") |
| buf += c |
| return buf |
|
|
|
|
| def via_socks5(host, port, user, pwd, timeout): |
| s = socket.create_connection((host, port), timeout) |
| s.settimeout(timeout) |
| try: |
| methods = b"\x00\x02" if user else b"\x00" |
| s.sendall(bytes([5, len(methods)]) + methods) |
| ver, method = _recvn(s, 2) |
| if method == 2: |
| if not user: |
| raise RuntimeError("can auth") |
| s.sendall(b"\x01" + bytes([len(user)]) + user.encode() |
| + bytes([len(pwd)]) + pwd.encode()) |
| if _recvn(s, 2)[1] != 0: |
| raise RuntimeError("sai user/pass") |
| elif method != 0: |
| raise RuntimeError("no method") |
| dh = T_HOST.encode() |
| s.sendall(b"\x05\x01\x00\x03" + bytes([len(dh)]) + dh + struct.pack(">H", T_PORT)) |
| rep = _recvn(s, 4) |
| if rep[1] != 0: |
| raise RuntimeError("connect rep %d" % rep[1]) |
| atyp = rep[3] |
| if atyp == 1: |
| _recvn(s, 6) |
| elif atyp == 3: |
| _recvn(s, _recvn(s, 1)[0] + 2) |
| elif atyp == 4: |
| _recvn(s, 18) |
| code, body = _http_request_line_via_target(s) |
| if code == 200: |
| return body |
| raise RuntimeError("HTTP %s" % (code if code > 0 else "?")) |
| finally: |
| s.close() |
|
|
|
|
| def via_socks4(host, port, user, pwd, timeout): |
| s = socket.create_connection((host, port), timeout) |
| s.settimeout(timeout) |
| try: |
| uid = (user or "").encode() |
| |
| s.sendall(b"\x04\x01" + struct.pack(">H", T_PORT) + b"\x00\x00\x00\x01" |
| + uid + b"\x00" + T_HOST.encode() + b"\x00") |
| r = _recvn(s, 8) |
| if r[1] != 0x5A: |
| raise RuntimeError("reject 0x%02X" % r[1]) |
| code, body = _http_request_line_via_target(s) |
| if code == 200: |
| return body |
| raise RuntimeError("HTTP %s" % (code if code > 0 else "?")) |
| finally: |
| s.close() |
|
|
|
|
| CHECKERS = {"http": via_http, "socks5": via_socks5, "socks4": via_socks4} |
| TRY_ORDER = ["http", "socks5", "socks4"] |
|
|
|
|
| def check(raw, timeout): |
| p = parse_line(raw) |
| if not p: |
| return {"raw": raw.strip(), "ok": False, "err": "format sai", "skip": True} |
| scheme, host, port, user, pwd = p |
| norm = "{}:{}:{}:{}".format(host, port, user, pwd) if user else "{}:{}".format(host, port) |
|
|
| |
| t0 = time.time() |
| try: |
| socket.create_connection((host, port), timeout).close() |
| except Exception as e: |
| return {"raw": norm, "ok": False, |
| "err": "connect: " + (str(e).split("] ")[-1][:24] or "timeout"), |
| "ms": int((time.time() - t0) * 1000)} |
|
|
| order = [scheme] if scheme else TRY_ORDER |
| last = "?" |
| for typ in order: |
| ts = time.time() |
| try: |
| body = CHECKERS[typ](host, port, user, pwd, timeout) |
| d = json.loads(body) |
| if d.get("status") != "success": |
| last = "resp la"; continue |
| return {"raw": norm, "ok": True, "type": typ, |
| "ms": int((time.time() - ts) * 1000), |
| "ip": d.get("query", "?"), |
| "geo": "{} · {}".format(d.get("country", "?"), (d.get("isp") or "")[:22])} |
| except Exception as e: |
| last = str(e)[:26] |
| return {"raw": norm, "ok": False, "err": last, "ms": int((time.time() - t0) * 1000), |
| "tried": "/".join(order)} |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser(description="Check proxy hang loat, tu detect HTTP/SOCKS5/SOCKS4.") |
| ap.add_argument("file", nargs="?", help="file proxy (moi dong 1 con). Bo trong = stdin.") |
| ap.add_argument("-t", "--threads", type=int, default=50, help="so luong song song (mac dinh 50)") |
| ap.add_argument("-T", "--timeout", type=int, default=12, help="timeout moi con, giay (mac dinh 12)") |
| ap.add_argument("-o", "--out", default="alive.txt", help="file luu proxy SONG (mac dinh alive.txt)") |
| a = ap.parse_args() |
|
|
| src = open(a.file, encoding="utf-8", errors="ignore") if a.file else sys.stdin |
| lines = [l for l in src.read().splitlines() if l.strip() and not l.strip().startswith("#")] |
| if a.file: |
| src.close() |
| if not lines: |
| print("Khong co proxy nao de check."); return |
|
|
| print("{}» Check {} proxy · {} luong · timeout {}s · tu detect HTTP/SOCKS5/SOCKS4{}\n".format( |
| C["y"], len(lines), a.threads, a.timeout, C["x"])) |
|
|
| alive, dead, done = [], 0, 0 |
| TCOL = {"http": C["c"], "socks5": C["g"], "socks4": C["y"]} |
| with ThreadPoolExecutor(max_workers=a.threads) as ex: |
| futs = [ex.submit(check, l, a.timeout) for l in lines] |
| for f in as_completed(futs): |
| r = f.result() |
| done += 1 |
| tag = "[{}/{}]".format(done, len(lines)) |
| if r["ok"]: |
| alive.append(r) |
| print("{}{} ✓{} {}{:<7}{} {:<22} {:>5}ms {} {}{}".format( |
| C["g"], tag, C["x"], TCOL.get(r["type"], ""), r["type"], C["x"], |
| r["raw"], r["ms"], r["ip"], r["geo"], C["x"])) |
| else: |
| dead += 1 |
| print("{}{} ✗ {:<22} {}{}".format( |
| C["d"], tag, r.get("raw", "")[:22], r["err"], C["x"])) |
|
|
| alive.sort(key=lambda x: x["ms"]) |
| with open(a.out, "w", encoding="utf-8") as fo: |
| for r in alive: |
| host_port = r["raw"] |
| fo.write("{}://{}\n".format(r["type"], host_port)) |
|
|
| by = {} |
| for r in alive: |
| by[r["type"]] = by.get(r["type"], 0) + 1 |
| print("\n{}━━━ KET QUA ━━━{}".format(C["y"], C["x"])) |
| print(" {}SONG: {}{} {}CHET: {}{} tong {} ({})".format( |
| C["g"], len(alive), C["x"], C["r"], dead, C["x"], len(lines), |
| ", ".join("{} {}".format(k, v) for k, v in by.items()) or "—")) |
| if alive: |
| a0 = alive[0] |
| print(" Nhanh nhat: {}{}://{} {}ms{}".format(C["g"], a0["type"], a0["raw"], a0["ms"], C["x"])) |
| print(" → Da luu {} proxy song (kem scheme) vao: {}{}{}".format(len(alive), C["y"], a.out, C["x"])) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
