依云's Blog

Arch Linux 连接网络可以使用其官方开发的 netctl 系列命令行工具。要想在开机（以及从挂起/休眠状态唤醒）时自动连接到可用的无线网络，以下是设置步骤。

首先，你得告诉 Arch Linux 你知道哪些无线热点。Arch Linux 不会自动帮你破解别人的 Wi-Fi 密码的。就算 Wi-Fi 热点没有加密，你不说 Arch Linux 怎么知道它应当连接到那个热点呢，也许那是个钓鱼用的热点也说不定哦。

cd 到 /etc/netctl 目录下，可以看到 examples 目录下有一堆示例配置。复制你所需要的配置文件到上一层目录（/etc/netctl）。比如绝大多数 Wi-Fi 热点使用的是 WPA 加密，那就复制 examples/wireless-wpa 文件。目标文件名比较随意，起个方便自己的名字就行，比如 work、home 之类的。复制完成之后记得 chmod 600 禁止非 root 用户访问，因为配置文件里会包含你的 Wi-Fi 热点密码。

然后编辑配置文件，修改 ESSID 和 Key 为你的 Wi-Fi 热点 ID 和密码就可以了。之所以要先更改权限再编辑，是因为某些编辑器（如 Vim）会生成同权限的备份文件；那里有可能也会包含密码。可以放多份配置文件在这里，netctl-auto 默认会去找一个可用的连接。有多个可用的时候不太清楚它会连上哪一个，可以使用更复杂的配置文件来指定优先级（参见 examples/wireless-wpa-configsection 示例配置）。

配置文件写好之后，当然是启动相应的服务啦。Arch Linux 一贯的传统是不启动不必要的服务，除非用户说要启动之。netctl-auto 的 systemd 服务名是 netctl-auto@interface.service（当然 .service 后缀还是可以省略的）。interface 部分写你的无线网络接口的名字，可以通过 ip link、ifconfig、iwconfig 等命令看到。我禁用了 systemd 的可预测网络接口名称，所以我的无线网络接口名唤 wlan0。我使用如下命令启动服务：

$ sudo systemctl start netctl-auto@wlan0.service

如果一切顺利的话一小会儿之后就应该连上网了：

$ systemctl status netctl-auto@wlan0.service
● netctl-auto@wlan0.service - Automatic wireless network connection using netctl profiles
   Loaded: loaded (/usr/lib/systemd/system/netctl-auto@.service; enabled)
   Active: active (running) since 二 2014-09-02 20:23:31 CST; 2h 45min ago
     Docs: man:netctl.special(7)
  Process: 340 ExecStart=/usr/bin/netctl-auto start %I (code=exited, status=0/SUCCESS)
   CGroup: /system.slice/system-netctl\x2dauto.slice/netctl-auto@wlan0.service
           ├─402 wpa_supplicant -B -P /run/wpa_supplicant_wlan0.pid -i wlan0 -D nl80211,wext -c/run/network/wpa_supplicant_wlan0.conf -W
           ├─404 wpa_actiond -p /run/wpa_supplicant -i wlan0 -P /run/network/wpa_actiond_wlan0.pid -a /usr/lib/network/auto.action
           └─501 dhcpcd -4 -q -t 30 -K -L wlan0
...

或者通过 netctl-auto list 命令也可以看到连接上了哪个配置文件里指定的热点。

如果满意的话，就让它开机自启动啦：

$ sudo systemctl enable netctl-auto@wlan0.service

参考资料：ArchWiki 上的 netctl 条目。

需要 Python 3.4+，一个参数用来选择测试搜索服务还是 GAE 服务。测试 GAE 服务的话需要先修改开头的两个变量。从标准输入读取 IP 地址或者 IP 段（形如 192.168.0.0/16）列表，每行一个。可用 IP 输出到标准输出。实时测试结果输出到标准错误。50 线程并发。

#!/usr/bin/env python3

import sys
from ipaddress import IPv4Network
import http.client as client
from concurrent.futures import ThreadPoolExecutor
import argparse
import ssl
import socket

# 先按自己的情况修改以下几行
APP_ID = 'your_id_here'
APP_PATH = '/fetch.py'

context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
context.verify_mode = ssl.CERT_REQUIRED
context.load_verify_locations('/etc/ssl/certs/ca-certificates.crt')

class HTTPSConnection(client.HTTPSConnection):
  def __init__(self, *args, hostname=None, **kwargs):
    self._hostname = hostname
    super().__init__(*args, **kwargs)

  def connect(self):
    super(client.HTTPSConnection, self).connect()

    if self._tunnel_host:
      server_hostname = self._tunnel_host
    else:
      server_hostname = self._hostname or self.host
      sni_hostname = server_hostname if ssl.HAS_SNI else None

    self.sock = self._context.wrap_socket(self.sock,
                                          server_hostname=sni_hostname)
    if not self._context.check_hostname and self._check_hostname:
      try:
        ssl.match_hostname(self.sock.getpeercert(), server_hostname)
      except Exception:
        self.sock.shutdown(socket.SHUT_RDWR)
        self.sock.close()
        raise

def check_ip_p(ip, func):
  if func(ip):
    print(ip, flush=True)

def check_for_gae(ip):
  return _check(APP_ID + '.appspot.com', APP_PATH, ip)

def check_for_search(ip):
  return _check('www.google.com', '/', ip)

def _check(host, path, ip):
  for chance in range(1,-1,-1):
    try:
      conn = HTTPSConnection(
        ip, timeout = 5,
        context = context,
        hostname = host,
      )
      conn.request('GET', path, headers = {
        'Host': host,
      })
      response = conn.getresponse()
      if response.status < 400:
        print('GOOD:', ip, file=sys.stderr)
      else:
        raise Exception('HTTP Error %s %s' % (
          response.status, response.reason))
      return True
    except KeyboardInterrupt:
      raise
    except Exception as e:
      if isinstance(e, ssl.CertificateError):
        print('WARN: %s is not Google\'s!' % ip, file=sys.stderr)
        chance = 0
      if chance == 0:
        print('BAD :', ip, e, file=sys.stderr)
        return False
      else:
        print('RE  :', ip, e, file=sys.stderr)

def main():
  parser = argparse.ArgumentParser(description='Check Google IPs')
  parser.add_argument('service', choices=['search', 'gae'],
                      help='service to check')
  args = parser.parse_args()
  func = globals()['check_for_' + args.service]

  count = 0
  with ThreadPoolExecutor(max_workers=50) as executor:
    for l in sys.stdin:
      l = l.strip()
      if '/' in l:
        for ip in IPv4Network(l).hosts():
          executor.submit(check_ip_p, str(ip), func)
          count += 1
      else:
        executor.submit(check_ip_p, l, func)
        count += 1
  print('%d IP checked.' % count)

if __name__ == '__main__':
  main()

脚本下载地址。

2014年9月3日重要更新：由于失误，之前的脚本没有检查 SSL/TLS 证书，所以将错误的 IP 认为是可用的。现已更新。

看到 ArchWiki 上 GoAgent 条目的亚全局代理方案，只是设置了代理相关环境变量。我就想，为什么不实现一个真正的全局 HTTP 代理呢？

最终，答案是：Linux 太灵活了，以至于想写一个脚本来搞定很麻烦。不过方案如下，有兴趣的可以折腾折腾。

首先，需要用到的工具：dnsmasq、iptables、redsocks，以及 HTTP 代理工具。dnsmasq 是用来缓存 DNS 请求的，iptables 把 TCP 流转接到 redsocks，而 redsocks 将 TCP 流转接到代理上。

最小 dnsmasq 配置如下：

listen-address=127.0.0.1
cache-size=500
server=127.0.0.1#5353
bogus-nxdomain=127.0.0.1

这里使用了本地的 dnscrypt 服务（假设其在 5353 端口上提供服务）。也可以使用国外服务器，只是需要更细致的配置来迫使其走 TCP。

iptables 命令如下：

# 创建一个叫 REDSOCKS 的链，查看和删除的时候方便
iptables -t nat -N REDSOCKS
# 所有输出的数据都使用此链
iptables -t nat -A OUTPUT -j REDSOCKS

# 代理自己不要再被重定向，按自己的需求调整/添加。一定不要弄错，否则会造成死循环的
iptables -t nat -I REDSOCKS -m owner --uid-owner redsocks -j RETURN
iptables -t nat -I REDSOCKS -m owner --uid-owner goagent -j RETURN
iptables -t nat -I REDSOCKS -m owner --uid-owner dnscrypt -j RETURN

# 局域网不要代理
iptables -t nat -A REDSOCKS -d 0.0.0.0/8 -j RETURN
iptables -t nat -A REDSOCKS -d 10.0.0.0/8 -j RETURN
iptables -t nat -A REDSOCKS -d 169.254.0.0/16 -j RETURN
iptables -t nat -A REDSOCKS -d 172.16.0.0/12 -j RETURN
iptables -t nat -A REDSOCKS -d 192.168.0.0/16 -j RETURN
iptables -t nat -A REDSOCKS -d 224.0.0.0/4 -j RETURN
iptables -t nat -A REDSOCKS -d 240.0.0.0/4 -j RETURN

# HTTP 和 HTTPS 转到 redsocks
iptables -t nat -A REDSOCKS -p tcp --dport 80 -j REDIRECT --to-ports $HTTP_PORT
iptables -t nat -A REDSOCKS -p tcp --dport 443 -j REDIRECT --to-ports $HTTPS_PORT
# 如果使用国外代理的话，走 UDP 的 DNS 请求转到 redsocks，redsocks 会让其使用 TCP 重试
iptables -t nat -A REDSOCKS -p udp --dport 53 -j REDIRECT --to-ports $DNS_PORT
# 如果走 TCP 的 DNS 请求也需要代理的话，使用下边这句。一般不需要
iptables -t nat -A REDSOCKS -p tcp --dport 53 -j REDIRECT --to-ports $HTTPS_PORT

redsocks 的配置：

base {
  log_debug = off;
  log_info = off;
  daemon = on; 
  redirector = iptables;
}
// 处理 HTTP 请求
redsocks {
  local_ip = 127.0.0.1;
  local_port = $HTTP_PORT;
  ip = $HTTP_PROXY_IP;
  port = $HTTP_PROXY_PORT;
  type = http-relay; 
}
// 处理 HTTPS 请求，需要一个支持 HTTP CONNECT 的代理服务器，或者 socks 代理服务器
redsocks {
  local_ip = 127.0.0.1;
  local_port = $HTTPS_PORT;
  ip = $SSL_PROXY_IP;
  port = $SSL_PROXY_PORT;
  type = http-connect;  // or socks4, socks5
}
// 回应 UDP DNS 请求，告诉其需要使用 TCP 协议重试
dnstc {
  local_ip = 127.0.0.1;
  local_port = $DNS_PORT;
}

然后以相应的用户和配置文件启动 dnsmasq 以及 redsocks。修改/etc/resolv.conf：

nameserver 127.0.0.1

至于分流的事情，HTTP 部分可以交给 privoxy，但是 HTTPS 部分不好办。可以再设立一个像 GoAgent 那样的中间人型 HTTPS 代理，或者更简单地，直接根据 IP 地址，国内的直接RETURN掉。

以上就是整个方案了。有些麻烦而我又不需要所以没测试。反正就是这个意思。Android 软件 GAEProxy 就是这么干的（不过它没使用 iptables 的 owner 模块，导致我不小心弄出了死循环）。另外，BSD 系统也可以使用类似的方案。

我收取邮件一直用的是 getmail，然而它有个问题：在网络不好的时候会挂在 recv 系统调用上，等好几个小时都有可能。还好我用的 crond 是 dcron，它知道同一个任务，在上一次任务还没执行完时即使时间到了也不应该再次执行，省了我一堆 flock 锁。不过，这样子导致我收不到邮件也不行啊。

以前也研究过一次，看到 getmail 有设置 socket 的超时时间啊，没整明白。最近网络又老是抽风，而且相当严重，导致我得不断地用 htop 去看、去杀没有反应的 getmail 进程。烦了，于是一边阅读 getmail 源码，一边使用 strace 观察，再配合 iptables 这神器，以及 the Silver searcher，终于找到了问题所在。

原来，由于 Python 的 SSL 对非阻塞套接字的支持问题¹²，getmail 在使用 SSL 连接时会强制使用阻塞式的套接字（见代码getmailcore/_pop3ssl.py:39以及getmailcore/_retrieverbases.py:187）。也许 Python 2.7 已经解决了这个问题，但是看上去 getmail 还是比较关心 Python 2.3 和 2.4。不过就算是 SSL 支持不好，调用下alarm不要一直待在那里傻傻地等嘛……也许，大部分 getmail 用户很少遇到足够差的网络？

于是考虑 fetchmail。花了两三天的业余时间终于弄明白我的需求该怎么配置了：

set daemon 300
set logfile ~/etc/log/fetchmail.log

defaults proto pop3 timeout 120 uidl
keep fetchsizelimit 0 mda "procmail -f %T"

poll pop.163.com interval 2
username "username" password "password"

poll pop.gmail.com
username "username" password "password"
ssl

poll pop.qq.com interval 2016 # 7 days
username "username" password "password"

但结果就是，除了 GMail 好一点，我让它「对从现在起所收到的邮件启用 POP」就没太大问题之外，腾讯还好，没几封邮件。网易那边，几百封旧邮件全部拖回来了…………

其实这个问题也还好，毕竟是一次性的。可我看它的日志，又发现，它每次收到 GMail 时，都会打印有多少封邮件已读。难道说，它每次去收邮件时都要列出所有可以用 POP3 收取的邮件，然后挑出没有收取过的？想到如果是这样，以后它每次取邮件时都要先取几千上万条已读邮件列表……这不跟 Google App Engine SDK 操作数据库加 offset 时前边所有数据全部读一遍一样扯淡吗……

于是又回来折腾 getmail。其实就这么一个问题，解决了就好。本来是准备去学学ptrace怎么用的，结果忍不住了，直接拿 Python 调 strace 写了这个：

#!/usr/bin/env python3

'''wait and kill subprocess if it doesn't response (from network)'''

import os
import sys
import select
import tempfile
import subprocess

timeout = 60

def new_group():
  os.setpgrp()

def main(args):
  path = os.path.join('/dev/shm', '_'.join(args).replace('/', '-'))
  if not os.path.exists(path):
    os.mkfifo(path, 0o600)
  pipe = os.open(path, os.O_RDONLY | os.O_NONBLOCK)
  p = subprocess.Popen(['strace', '-o', path, '-e', 'trace=network'] + args, preexec_fn=new_group)

  try:
    while True:
      ret = p.poll()
      if ret is not None:
        return ret
      rs, ws, xs = select.select([pipe], (), (), timeout)
      if not rs:
        print('subprocess met network problem, killing...', file=sys.stderr)
        os.kill(-p.pid, 15)
      else:
        os.read(pipe, 1024)
  except KeyboardInterrupt:
    os.kill(-p.pid, 15)

  return -1

if __name__ == '__main__':
  try:
    import setproctitle
    setproctitle.setproctitle('killhung')
    del setproctitle
  except ImportError:
    pass
  sys.exit(main(sys.argv[1:]))

Python 果然快准狠 ^_^

代码在 winterpy 仓库里也有一份。

这还是我编程时第一次用到进程组呢。没办法，光杀 strace 进程没效果。嗯，还有非阻塞的命名管道。

PS: 去 GMail 设置页看完那个选项的具体名字后离开，结果遇到这个：

你这是让我「确定更改」呢还是「取消取消更改」呢……

ICMP 套接字是两年前 Linux 内核新加入的功能，目的是允许不需要 set-user-id 和CAP_NET_RAW权限的 ping 程序的实现。大家都知道，set-user-id 程序经常成为本地提权的途径。在 Linux 内核加入此功能之前，以安全为目标的 Openwall GNU/*/Linux 实现了除 ping 程序之外的所有程序去 suid 化……这个功能也是由他们提出并加入的。

我并没有在 man 手册中看到关于 ICMP 套接字的信息。关于 ICMP 套接字使用的细节来自于内核邮件列表。

使用 ICMP 套接字的好处：

1. 程序不需要特殊的权限；
2. 内核会帮助搞定一些工作。

坏处是：

1. 基本没有兼容性可讲；
2. 需要调整一个内核参数。

这个内核参数是net.ipv4.ping_group_range，是一对整数，指定了允许使用 ICMP 套接字的组 ID的范围。默认值为1 0，意味着没有人能够使用这个特性。手动修改下：

sudo sysctl -w net.ipv4.ping_group_range='0 10'

当然你可以直接去写/proc/sys/net/ipv4/ping_group_range文件。

如果系统不支持这个特性，在创建套接字的时候会得到「Protocol not supported」错误，而如果没有权限，则会得到「Permission denied」错误。

创建 ICMP 套接字的方法如下：

import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_ICMP)

它的类型和 UDP 套接字一样，是SOCK_DGRAM，不是SOCK_RAW哦。这意味着你不会收到 20 字节的 IP 头。不仅仅如此，使用 ICMP 套接字不需要手工计算校验和，因为内核会重新计算的。ICMP id 也是由内核填的。在接收的时候，内核会只把相应 id 的 ICMP 回应返回给程序，不需要自己或者要求内核过滤了。

所以，要组装一个 ICMP ECHO 请求包头很容易了：

header = struct.pack('bbHHh', 8, 0, 0, 0, seq)

这五项依次是：类型（ECHO_REQUEST）、code（只能为零）、校验和（不需要管）、id（不需要管）、序列号。

接收起来也简单，只要看一下序列号知道是回应自己发的哪个包的就行了。

这里是我的一个很简单的实例。

附注：Mac OS X 在 Linux 之前实现了类似的功能。但是行为可能不太一样。有报告校验和需要自己计算的，也有报告发送正确但是返回报文是乱码的。另，FreeBSD 和 OpenBSD 不支持这个特性。

人们都说 Google Chrome 浏览器安全，可是——

昨日，有网友告诉我 php.net 被挂马了。于是我在火狐浏览器中访问，果然得到了警告：

再去 Google 搜索一下，果然也被标记上了：

直接点击搜索结果会得到 Google 的警告：

但是，Google Chrome 浏览器访问竟然没有任何提示。

今天，这个警告已经移除了。php.net 官方发布了一些消息，证实它确实被攻破了。为了以防万一，他们吊销了 php.net 所使用的 SSL 证书。我于是尝试使用火狐访问使用了 SSL 的子站，比如这个 https://wiki.php.net/，火狐很明确地告诉我，它的证书已经被废弃了：

但是，Google Chrome 浏览器访问依然没有任何提示，表示安全的小绿锁依然鲜亮。

难道是 Google 认为 Google Chrome 浏览器本身已经足够安全，不仅能抵御任何它能检测出来的恶意网页，而且能在证书已被吊销的情况下判断出网页是否被篡改？

注：以上均为浏览器默认安全配置，我没有手动修改任何安全相关的选项。

更新：在 Google Chrome 的「设置」中，点击「显示高级设置…」，往后滚，找到「HTTPS/SSL」，把「检查服务器证书吊销状态」前边的框勾上，Google Chrome 就也会报告证书不可信了。

再次更新：通过 GoAgent 访问，没有收到任何关于服务器证书已经失效的提示。证实了我之前关于通过 GoAgent 访问 HTTPS 站点会降低安全性的猜测。

感谢 Eleven.i386 提供了部分截图。

上篇成功让 mosh 走 UDP 洞，连接上了在 NAT 后边的主机。然而，很多有用的协议都是走 TCP 的，比如能传文件的 ssh、访问我的 MediaWiki 的 HTTP。TCP 洞难打，于是在想，OpenVPN 可以使用 UDP 协议，那么把双方用 OpenVPN 连起来，不是可以想用什么传输层的协议都可以了吗！于是，有了新的脚本。

与 mosh 相比，打洞部分主要的不同有：

1. OpenVPN 的可配置性强，不需要 hack 即可让它绑定到需要的端口。
2. OpenVPN 本身使用证书认证，因此把证书部分保存在客户端，余下的部分（包含双方使用的 IP 地址和端口号）可以通过打好的洞明文发送，不用怕被攻击。所以跑我这个脚本的话，当前工作目录要可写，以便保存双方即将使用的配置文件。
3. OpenVPN 客户端会自动忽略对方发过来它不认识的配置信息，不用想办法避免。
4. OpenVPN 需要 root 权限，因此脚本调用了 sudo，需要及时输入密码。

在实验过程中也遇到了一些坑：

1. Python 里没办法将已连接的 UDP socket「断开连接」，即将一个已经connect的 UDP socket 恢复到初始时可接收任意地址数据的状态。原本以为connect(('0.0.0.0', 0))可以的，结果客户端这边始终收不到服务端发送的 OpenVPN 配置信息。Wireshark 抓包看到内核收到数据后发了 ICMP Port Unreachable 错误之后才明白过来。
2. MTU 的问题。默认值会导致刚开始传输正常，但随后收不到数据的情况。添加mssfix 1400配置解决。（其实这个 OpenVPN man 手册里有写。）
3. 超时的问题。先是没注意到 OpenVPN 服务端说没有配置keepalive的警告，结果连接空闲几分钟之后，「洞」就失效了。加上keepalive 10 60解决。

配置中没有加默认路由，所以连接上之后唯一的效果就是，两个主机分别多出了同一网段的两个 IP 地址，相互间可以进行 TCP 通信了～～

对了，客户端连接时需要一个包含 OpenVPN 证书信息的文件，其格式为：

<ca>
# ca.crt 文件内容
</ca>

<cert>
# crt 文件内容（只需要 BEGIN 和 END 标记的那部分）
</cert>

<key>
# key 文件内容
</key>

PS: 有这个想法后不久，发现 None 已经做过类似的事情了。不过脚本有点多，是使用第三方服务器而不是像我这样手工交换地址的。

又是一篇关于 UDP 打洞的文章。之前写过关于在完全圆锥型（full cone）NAT的文章中如何使用 socat 命令打洞。根据那篇文章里的知识，连接到一个 full cone NAT 后边的 mosh 不成问题。不过，我现在的网络是受限圆锥型（restricted cone）NAT 了呢！

也就是复杂了一些。双方要向中间服务器和对方都发送数据包才可以。另外就是，客户端（mosh-client）这边得使用在打洞期间使用的端口号才行。

打洞流程根据维基百科，双方通过中间服务器（还是我的 udpaddr 啦）交换地址，双方均向得到的地址发送一数据包，然后开始正常通讯。比较麻烦，于是有了这个脚本：

#!/usr/bin/env python3

import socket
import re
import sys
import subprocess

udp_server = ('xmpp.vim-cn.com', 2727)
addr_re = re.compile(r"\('(?P<ip>[^']+)', (?P<port>\d+)(?:, (?P<cport>\d+))?")

def main(server):
  sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  sock.settimeout(2)
  print('Send message...')
  sock.sendto(b'req from holepunch.py\n', udp_server)
  msg, addr = sock.recvfrom(1024)
  print('Got answer from %s: %s' % (addr, msg))
  m = addr_re.search(msg.decode())
  if not m:
    print("Error: can't parse answer.")
    sys.exit(1)
  m_ip = m.group('ip')
  m_port = int(m.group('port'))
  port = sock.getsockname()[1]
  print('Got my IP and Port: (%r, %s, %s).' % (m_ip, m_port, port))

  msg = input('> Peer address: ')
  m = addr_re.search(msg)
  if not m:
    print("Error: can't parse input.")
    sys.exit(2)
  p_ip = m.group('ip')
  p_port = int(m.group('port'))
  c_port = int(m.group('cport'))

  print('send initial packet and wait for answer...')
  sock.sendto(b'HELO\n', (p_ip, p_port))
  try:
    msg = sock.recvfrom(1024)
    print('Received:', msg)
  except socket.timeout:
    print("Timed out (it's normal).")

  if server:
    sock.close()
    print('Starting mosh server...')
    msg = subprocess.check_output(['mosh-server', 'new', '-p', str(port)])
    secret = msg.split()[3].decode()
    print('Connect with:\nMOSH_KEY=%s MOSH_CPORT=%s mosh-client %s %s' % (secret, c_port, m_ip, m_port))
  else:
    print('done.')

if __name__ == '__main__':
  server = len(sys.argv) == 2 and sys.argv[1] == '-s'
  main(server)

如果 mosh 服务器端位于受限 NAT 后，还需要给 mosh-client 打个（我随手写的很 dirty 的）补丁以便指定客户端使用的 UDP 端口号：

diff --git a/src/network/network.cc b/src/network/network.cc
index 2f4e0bf..718f6c5 100644
--- a/src/network/network.cc
+++ b/src/network/network.cc
@@ -176,6 +176,11 @@ Connection::Socket::Socket()
     perror( "setsockopt( IP_RECVTOS )" );
   }
 #endif
+
+  if ( getenv("MOSH_CPORT") ) {
+    int port = atoi(getenv("MOSH_CPORT"));
+    try_bind( _fd, INADDR_ANY, port, port);
+  }
 }

 void Connection::setup( void )

然后，连接流程如下：

1. mosh 服务端运行holepunch.py -s命令，客户端运行holepunch.py；
2. 双方看到自己的地址信息（依次是IP, 外网端口, 本地端口）后，复制并发送给对方；
3. 双方输入对方的地址。为了节省时间（mosh-server 只会等一分钟，NAT 上的端口映射也是有时效的），只要输入的一行内包含上述地址信息的文本即可，前后可以有不小心复制过来的多余字符；
4. 服务端将得到一行包含 mosh 的密钥的命令。将此命令发送对客户端；客户端运行此命令连接。如果 mosh-client 的名字不是标准名字，需要自行修改；
5. 一切顺利的话就连接上啦！

mosh 服务端输出示例：

>>> holepunch.py -s
Send message...
Got answer from ('202.133.113.62', 2727): b"Your address is ('180.109.80.47', 3169)\n"
Got my IP and Port: ('180.109.80.47', 3169, 8127).
> Peer address:  Port: ('222.95.148.73', 5223, 55473). 
send initial packet and wait for answer...
Timed out (it's normal).
Starting mosh server...

mosh-server (mosh 1.2.4)
Copyright 2012 Keith Winstein <mosh-devel@mit.edu>
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

[mosh-server detached, pid = 5202]
Connect with:
MOSH_KEY=1apguNqtfN/K4JSvllnJxA MOSH_CPORT=55473 mosh-client 222.95.148.73 5223

mosh 客户端输出示例：

>>> holepunch.py
Send message...
Got answer from ('202.133.113.62', 2727): b"Your address is ('222.95.148.73', 5223)\n"
Got my IP and Port: ('222.95.148.73', 5223, 55473).
> Peer address: rt: ('180.109.80.47', 3169, 8127)
send initial packet and wait for answer...
Timed out (it's normal).
done.

2013年10月20日更新：想要通过打出来的 UDP 洞进行 TCP 通信吗？参见文章通过 OpenVPN 让 TCP 使用 UDP 洞。

在 Android 这个奇怪的平台想弄点 Linux-style 的东西用真不容易。网上现成的东西也比较少，这里有 stunnel、redsocks 和 iptables 等。另外 GAEProxy 里有 redsocks、iptables 和 Python 2.7，在/data/data/org.gaeproxy目录下。但它的 Python 不支持 readline，redsocks 不支持 UDP。

下边是我自己编译的几个工具和其特点（全部没有第三方库依赖）：

• redsocks：取自 git 版本，支持 UDP。其中，支持 UDP 需要search.h头和相关库函数，但是 Android 的 C 库中没有。我使用了 musl 这个 C 库中的相关文件。
• socat：支持 readline 和 OpenSSL。openssl 这个命令行工具也作为附加文件得到了，但是感觉用处不大。
• tcpdump：著名的网络抓包工具。没什么特别的。

编译全部使用的是 Android NDK。编译命令基本上类似于：

CC='arm-linux-androideabi-gcc --sysroot=/opt/android-ndk/platforms/android-14/arch-arm' \
  ./configure --host=arm-linux-androideabi --prefix=/ldata/media/temp/android/installed_binaries

但是不同的软件通常都会需要一些修改。比如上边说到的 redsocks。最无痛编译成功的是 LuaJIT 了，但是我这里没找到什么实际用途。另外记得把生成的可执行文件用arm-linux-androideabi-strip处理下，减小体积。

以上三个工具打包下载请点击这里（备用地址）。

防 ssh 暴力破解

一直以来，面对 Vim 显示的 auth.log 里满屏的红色 ssh 登录失败记录，要么容忍，要么换端口号，要么是 fail2ban。换端口号显然会造成很多不便，尤其是使用者比较多的时候。fail2ban 以前也用得挺好的，但是需要手工编辑配置文件，阅读其中长长的注释并且小心翼翼地修改参数。配置好之后还会经常收到 fail2ban 发出的邮件。这些都可以忍受。直到有一天，某位使用者不小心登录失败多次以后，那个 IP 被封掉了。我从 /etc/hosts.deny 中删除了对应的项目，但是没有用，因为 fail2ban 会去检查 auth.log，然后把那个 IP 给加回去……

前两天本来是寻找限速的命令的，却无意之中看到了防 ssh 暴力破解的命令，如下：

iptables -I INPUT -p tcp --dport 22 -i eth0 -m state --state NEW -m recent --set
iptables -I INPUT -p tcp --dport 22 -i eth0 -m state --state NEW -m recent --update --seconds 60 --hitcount 4 -j DROP

第一句是说，对于外来数据，如果是 TCP 协议，目标端口号是 22，网络接口是 eth0，状态是新连接，那么把它加到最近列表中。第二句是说，对于这样的连接，如果在最近列表中，并且在 60 秒内达到或者超过四次，那么丢弃该数据。其中的-m是模块的意思。

也就是说，如果有人从一个 IP 一分钟内连接尝试四次 ssh 登录的话，那么它就会被加入黑名单，后续连接将会被丢弃。这是对付 ssh 暴力破解的绝佳规则了。不用修改 openssh，也不用另启一个容易招麻烦的服务。不过不知道多久以后那个 IP 才能重新连接上。

我实际使用时正有一北京 IP 在尝试 ssh 登录。命令执行后，auth.log 里的红色失败消息又出现了四次，然后就没有了。后来再查看时，虽然还是能看到不少红色，但是没有以前那么密集了。更重要的是，每四条登录失败消息间的时间间隔比较大了。可谓效果显著啊。

网络限速

这是我这次搜索 iptables 相关信息的本意。起因是这样子的，在本地测试的时候，经常会发现本地连接的速度实在是太快了。对于网站，不能反映其真实的使用体验；对于网络程序，无法测试其在网络不良时的表现，由于测试的规模小，一些真实使用时容易出现的竞态也由于操作完成得太快而无法重现。

很早就知道 iptables 能够对转发流量进行限速。既然是 iptables 而不是某些商业软件，它就没理由只能对外部流量而不对本地接口 lo 进行限速。于是最后弄到如下命令：

iptables -A INPUT -s 127.0.0.1 -p tcp -d 127.0.0.1 --dport 6900:6901 -m limit --limit 1/s -j ACCEPT
iptables -A INPUT -s 127.0.0.1 -p tcp -d 127.0.0.1 --dport 6900:6901 -j DROP

这两条规则组合起来是说，对于所有从 127.0.0.1 到同样的地址的 6900 到 6901 端口的 TCP 连接，每秒只接受一个数据包，多余的丢弃。后边那句是必要的，如果不写的话就没作用了，因为默认策略是接受。

要注意的是，如果使用域名localhost的话，很可能会使用 IPv6 地址::1而不是127.0.0.1了。

参考链接

• Using iptables to rate-limit incoming connections