Appearance
秒拨 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 上有完整字段说明和额度说明。