Skip to content

秒拨 IP 怎么识别?从登录日志里挖出「打一枪换一个 IP」的黑产(Python 实现) ​

做风控的同学大概都遇到过这种局面:一夜之间冒出来两百多个新账号,注册地遍布十几个省,登录设备指纹还各不相同。你按 IP 去封,第二天它们换一批 IP 又回来了,封禁列表越堆越长,成本全在你这边。

这批流量背后大概率是秒拨。它不是高深的攻击手法,反而朴素得让人难受,但因为便宜,成了黑灰产做批量注册、薅羊毛、撞库的默认基础设施。这篇文章不聊黑产怎么拨号,只解决一个问题:手上只有登录日志和一批 IP,怎么把秒拨特征挖出来。

一、秒拨到底"秒"在哪 ​

秒拨的原理说穿了就是频繁重新拨号。运营商给家宽/专线分配的地址本来就是动态的,拨号一次换一个;灰产把这件事自动化:用一批宽带账号(很多是收购或租来的),写脚本控制光猫/路由器反复断线重连,几秒钟就能拿到一个新 IP,IP 归属地也跟着在几个省之间跳。

相比买代理池,秒拨有几个"优势":

  • IP 是真实的家宽地址,不是 IDC 机房段,很多只按机房黑名单拦截的策略直接漏掉;
  • 切换快、批量大,一个账号池几秒钟换一个 IP,够把单 IP 频次限制绕开;
  • 成本极低,几百块的宽带账号能撑起一天几千次的注册量。

所以"封 IP"这套打法在秒拨面前基本失效。真正能定住它的不是某个 IP,而是IP 序列的形状:正常用户一天换一两个城市都算多,秒拨账号的 IP 序列是一串高速跳变。

二、能拿来当证据的信号 ​

判断秒拨,本质是拿 IP 归属地做两条聚合:

第一条,按账号看 IP 序列。 同一个账号在短时间内的归属地分布,是它最诚实的轨迹。特征包括:独立 IP 数、出现过几个省几个城市、相邻两次登录城市不同的最小时间间隔、运营商数量。正常用户出差一天换一个省,秒拨账号是十分钟里换了五个省。归属地用 GET https://ip9.com.cn/get?ip=<IP> 查(免费版即可,不需要注册),prov、city、isp 三个字段就够支撑这轮聚合。

第二条,按 IP 看账号集合。 秒拨出来的 IP 存活时间很短,同一个 IP 上经常挂着几个互不相关的新账号,且这些账号的"生卒时间"高度重叠。反过来,正常家宽下同一 IP 长期只有一个主账号。

这里有个字段差别要提前说清楚:免费版只能拿到 isp 的名称(电信/联通/移动/某某宽带),判断这个 IP 是家宽还是 IDC 机房,要用 VIP 版的 ip_type(ISP 家庭 / BUS 企业 / IDC 机房)。秒拨的特征恰恰是"家宽 IP 却行为异常",ip_type 会让阈值好调很多。下面代码里对这两个字段做了兼容处理——拿到就用,没拿到就跳过。

三、Python 实现:读日志 → 查归属地 → 账密画像 ​

输入是一份登录日志,ts,account,ip 三列,时间戳支持 2026-10-10 21:03:11 或 Unix 秒。输出是一张按嫌疑分排序的账号表。

python
# miaobo_check.py
# 用法: python3 miaobo_check.py login.log --top 20
# 依赖: pip install requests
import argparse, csv, json, os, sys, time
from collections import Counter, defaultdict
from datetime import datetime

import requests

API = "https://ip9.com.cn/get"
CACHE_FILE = "ip_geo_cache.json"
GAP = 1.05          # 免费版 60 次/分钟/IP,留点余量
FAST_GAP = 600      # 10 分钟内换城市视为"快速跳变"


def load_cache():
    if os.path.exists(CACHE_FILE):
        with open(CACHE_FILE, encoding="utf-8") as f:
            return json.load(f)
    return {}


def save_cache(cache):
    tmp = CACHE_FILE + ".tmp"
    with open(tmp, "w", encoding="utf-8") as f:
        json.dump(cache, f, ensure_ascii=False)
    os.replace(tmp, CACHE_FILE)


def lookup(session, cache, ip, last=0.0):
    """查单个 IP 归属地。返回 (row, last_call_ts);失败返回 (None, last)"""
    if ip in cache:
        return cache[ip], last
    wait = last + GAP - time.monotonic()
    if wait > 0:
        time.sleep(wait)
    try:
        r = session.get(API, params={"ip": ip}, timeout=3,
                        headers={"Accept": "application/json"})
        r.raise_for_status()
        payload = r.json()
    except (requests.RequestException, ValueError) as exc:
        print(f"[warn] {ip} 查询失败: {exc}", file=sys.stderr)
        return None, time.monotonic()
    last = time.monotonic()

    if payload.get("ret") == 429:                 # 触发限速,本轮跳过
        print("[warn] 429 限速,等 2 秒", file=sys.stderr)
        time.sleep(2)
        return None, last
    if payload.get("ret") != 200 or not isinstance(payload.get("data"), dict):
        return None, last                         # 非法 IP 返回 400

    d = payload["data"]
    row = {
        "prov": d.get("prov") or "未知",
        "city": d.get("city") or "未知",
        "isp": d.get("isp") or "未知",
        # 这两个字段来自 VIP 版,免费版为 None,代码里按需使用
        "ip_type": d.get("ip_type"),
        "ip_asn": d.get("ip_asn"),
    }
    cache[ip] = row
    return row, last


def parse_ts(s):
    s = s.strip()
    if s.isdigit():
        return int(s)
    return int(datetime.strptime(s, "%Y-%m-%d %H:%M:%S").timestamp())


def load_rows(path):
    """读日志并按账号聚合,返回 {account: [(ts, ip, geo), ...]}"""
    per_account = defaultdict(list)
    with open(path, encoding="utf-8", errors="ignore") as f:
        for rec in csv.DictReader(f):
            try:
                per_account[rec["account"].strip()].append(
                    (parse_ts(rec["ts"]), rec["ip"].strip(), None))
            except (KeyError, ValueError):
                continue
    return per_account


def score_account(events):
    """events: 已按时间排序的 [(ts, ip, geo), ...],返回 (分数, 命中原因)"""
    events = sorted(e for e in events if e[2] is not None)
    if len(events) < 5:
        return 0, []

    ips = {e[1] for e in events}
    cities = {e[2]["city"] for e in events}
    provs = {e[2]["prov"] for e in events}
    isps = {e[2]["isp"] for e in events}

    # 相邻记录:时间近、城市不同
    switches = []
    for a, b in zip(events, events[1:]):
        if a[2]["city"] != b[2]["city"]:
            switches.append(b[0] - a[0])
    fast = [g for g in switches if g <= FAST_GAP]
    min_gap = min(switches) if switches else None

    reasons, score = [], 0
    if len(ips) >= 15 and len(cities) >= 6:
        score += 2
        reasons.append(f"{len(ips)} 个 IP / {len(cities)} 个城市")
    if fast:
        ratio = len(fast) / len(switches)
        if len(fast) >= 3 and ratio >= 0.3:
            score += 2
            reasons.append(f"{len(fast)} 次 10 分钟内跨城")
        if min_gap is not None and min_gap <= 120:
            score += 1
            reasons.append(f"最快 {min_gap}s 换一个城市")
    if len(provs) >= 4 and len(isps) >= 3:
        score += 1
        reasons.append(f"跨 {len(provs)} 省 {len(isps)} 家运营商")
    # 免费版拿不到 ip_type;VIP 版出现 IDC 反差时再加一档
    if any(e[2].get("ip_type") == "ISP" for e in events) and len(ips) >= 15:
        score += 1
        reasons.append("家宽 IP 却高频更换(VIP 字段)")
    return score, reasons


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("logfile")
    ap.add_argument("--top", type=int, default=20)
    ap.add_argument("--min-score", type=int, default=4)
    args = ap.parse_args()

    per_account = load_rows(args.logfile)
    all_ips = sorted({ip for evs in per_account.values() for _, ip, _ in evs})
    print(f"账号 {len(per_account)} 个,独立 IP {len(all_ips)} 个,开始查归属地…")

    cache, session, last = load_cache(), requests.Session(), 0.0
    geo_by_ip = {}
    try:
        for i, ip in enumerate(all_ips, 1):
            row, last = lookup(session, cache, ip, last)
            if row:
                geo_by_ip[ip] = row
            if i % 100 == 0:
                save_cache(cache)
                print(f"  进度 {i}/{len(all_ips)}", file=sys.stderr)
    finally:
        save_cache(cache)

    # 按 IP 反向聚合:同一 IP 挂了多少账号、存活多久
    ip_accounts = defaultdict(set)
    ip_span = {}
    for acc, evs in per_account.items():
        for ts, ip, _ in evs:
            if ip in geo_by_ip:
                ip_accounts[ip].add(acc)
                lo, hi = ip_span.get(ip, (ts, ts))
                ip_span[ip] = (min(lo, ts), max(hi, ts))

    shared = {ip for ip, accs in ip_accounts.items() if len(accs) >= 3}
    rows = []
    for acc, evs in per_account.items():
        evs = [(ts, ip, geo_by_ip.get(ip)) for ts, ip, _ in evs]
        s, reasons = score_account(evs)
        hit_shared = sum(1 for _, ip, _ in evs if ip in shared)
        if hit_shared >= 3:
            s += 1
            reasons.append(f"{hit_shared} 次登录踩在共享 IP 上")
        if s >= args.min_score:
            rows.append((s, acc, len(evs), reasons))

    rows.sort(reverse=True)
    print(f"\n疑似秒拨账号 {len(rows)} 个(阈值 {args.min_score} 分)")
    for s, acc, n, reasons in rows[:args.top]:
        print(f"  [{s}分] {acc:<22} 登录 {n:>4} 次  " + ";".join(reasons))

    # 秒拨 IP 的另一个特征:存活窗口短
    short = sorted(((hi - lo, ip, len(ip_accounts[ip]))
                    for ip, (lo, hi) in ip_span.items()
                    if len(ip_accounts[ip]) >= 3 and (hi - lo) <= 3600))[:10]
    if short:
        print("\n短命共享 IP(存活 ≤1 小时且挂 ≥3 个账号)")
        for span, ip, n in short:
            print(f"  {ip:<16} 存活 {span:>5}s  账号 {n} 个")


if __name__ == "__main__":
    main()

跑一份两万行的登录日志,典型输出是这样:

text
账号 4123 个,独立 IP 6802 个,开始查归属地…

疑似秒拨账号 37 个(阈值 4 分)
  [6分] u_8811442               登录  128 次  26 个 IP / 11 个城市;9 次 10 分钟内跨城;最快 47s 换一个城市;4 次登录踩在共享 IP 上
  [5分] u_8810927               登录   96 次  21 个 IP / 8 个城市;6 次 10 分钟内跨城;跨 5 省 3 家运营商
  ...

短命共享 IP(存活 ≤1 小时且挂 ≥3 个账号)
  116.21.44.33    存活   312s  账号 5 个
  117.136.8.190   存活   580s  账号 4 个

这些账号不用马上封,但它们已经足够被挑出来进"重点观察池":加图形验证码、限制发券、注册冷静期。封号留给设备指纹和支付数据交叉后的结论。

四、落地时的几个坑 ​

阈值要按业务错开,别一把尺子量所有端。 移动网络(4G/5G)的出口 IP 天然跳得比宽带勤,基站切换、漫游都会让归属地变化;iOS/Android 用户在 Wi-Fi 和蜂窝之间来回切也会换 IP。所以建议按客户端类型、登录方式分组设阈值:App 端放宽,Web 端收紧。这类误伤排查思路,和站内《IP 风控总误伤正常用户?》里讲共享出口豁免是一套逻辑。

一定要做缓存,不做缓存就是白烧额度。 秒拨场景里同一批 IP 会在几天内反复出现,脚本把查询结果落本地 JSON,第二次跑基本零消耗;限速间隔定在 1.05 秒,跑 6000 个 IP 大约 1 小时 45 分,放进凌晨的定时任务正好。

归属地只是证据链的一环,别单点定罪。 秒拨识别出来的是"高风险账号名单",不是"黑产名单"。正经做法是叠加设备指纹、注册时间、行为路径(是不是集中在某个接口、是不是都秒领券),把分数拉开档次再决定处置力度。仅凭 IP 归属地就封号,申诉压力会很大,也不合规。

数据保留要收敛。 登录 IP 属于个人信息,画像脚本产出的名单里只需要账号、分数、命中原因,不需要把完整 IP 清单长期留着;日志侧建议按站内《日志里的 IP 属于个人信息,但报表还要按地域统计?》那篇的思路做脱敏。

想再省点功夫,可以上 VIP 字段。 秒拨的 IP 是家宽,但挂着机房剧本的账号往往还会在别处露 IDC 的尾巴。VIP 版的 ip_type 能直接把 ISP 家庭 / BUS 企业 / IDC 机房分开,ip_asn 能把"同一家宽带运营商下的一批 IP"归到一处——用 ASN 聚合再数账号,比按省份聚合敏锐得多。额度与计费以官网为准。

总结 ​

秒拨难缠的地方在于它用的是"干净"的家宽 IP,单看任何一个都不像坏人。破局点不在 IP 本身,而在序列:账号维度的城市跳变速度、IP 维度的账号密度和存活时长。这三个特征用免费接口加一份登录日志就能算出来,成本几乎为零。

归属地查询用 https://ip9.com.cn/get?ip=<IP>(免费版无需注册,60 次/分钟/IP,IPv4 与 IPv6 都支持,返回国家、省市、运营商、经纬度等字段,area 区县字段为 VIP 专有);要做家宽/机房维度的细分,再上 VIP 版拿 ip_type 和 ip_asn,官网 https://www.ip9.com.cn 上有完整字段说明和额度说明。