作者: hetao

  • nft monitor使用

    在rule中添加meta nftrace set 1就可以启用trace

    nft insert rule inet fw4 input meta l4proto {icmp,icmpv6} nftrace set 1 counter accept #监视icmp,icmpv6
    nft insert rule inet fw4 input ip protocol icmp  meta nftrace set 1 counter accept #监视icmp
    nft insert rule inet fw4 input ip6 nexthdr icmpv6 meta nftrace set 1 counter accept #监视icmpv6
    
    nft insert rule inet fw4 foward ip daddr 192.168.33.6 tcp dport 80 nftrace set 1 counter accept #监视转发的http
    nft insert rule inet fw4 prerouting ip daddr 192.168.33.6 tcp dport 80 nftrace set 1 counter accept #监视所有的http
    

    然后执行
    nft monitor trace
    就可以看到每个收到的包及各个链中rule处理结果

    Views: 3

  • coturn创建sturn服务器

    debian/ubuntu安装
    apt install coturn
    centos安装
    yum install coturn coturn-utils
    编辑配置文件/etc/turnserver.conf

    listening-port=3478
    listening-ip=172.31.25.80
    listening-ip=240b:4001:210:4a01:f788:1b78:de22:8707
    external-ip=8.218.139.135/172.31.25.80
    user=test:123456
    log-file=/var/log/turn.log
    

    如果监听的IP不是公网IP还需要指定external-ip
    systemctl enable coturn
    systemctl restart coturn
    然后防火墙开放3478端口,包括UDP和TCP

    Views: 13

  • wireguard配置生成器

    https://www.wireguardconfig.com/

    Views: 1

  • STUN技术

    RFC定义

    旧标准:
    https://datatracker.ietf.org/doc/rfc3489/
    RFC 3489 STUN协议设计,2003年发布
    https://datatracker.ietf.org/doc/rfc5389/
    RFC 5389 STUN工程实现和最佳实践,并对RFC3489进行了更新,2008年发布
    新标准:
    https://datatracker.ietf.org/doc/rfc5780/
    RFC 5780, STUN协议设计,2010年发布
    https://datatracker.ietf.org/doc/rfc8489/
    RFC 8489 STUN工程实现和最佳实践,2020年发布

    STUN的主要作用有两个:
    1. 获取通信双方的公网IP地址和端口
    2. 检测NAT类型(用于确定后续穿透方案)

    RFC 3489定义的四种NAT类型

    1. Full Cone NAT

      内网主机建立一个UDP socket(LocalIP:LocalPort) 第一次使用这个socket给外部主机发送数据时NAT会给其分配一个公网(PublicIP:PublicPort),以后用这个socket向外面任何主机发送数据都将使用这对(PublicIP:PublicPort)。此外,任何外部主机只要知道这个(PublicIP:PublicPort)就可以发送数据给(PublicIP:PublicPort),内网的主机就能收到这个数据包

    2. Restricted Cone NAT

      内网主机建立一个UDP socket(LocalIP:LocalPort) 第一次使用这个socket给外部主机发送数据时NAT会给其分配一个公网(PublicIP:PublicPort),以后用这个socket向外面任何主机发送数据都将使用这对(PublicIP:PublicPort)。此外,如果任何外部主机想要发送数据给这个内网主机,只要知道这个(PublicIP:PublicPort)并且内网主机之前用这个socket曾向这个外部主机IP发送过数据。只要满足这两个条件,这个外部主机就可以用自己的(IP,任何端口)发送数据给(PublicIP:PublicPort),内网的主机就能收到这个数据包

    3. Port Restricted Cone NAT

      内网主机建立一个UDP socket(LocalIP:LocalPort) 第一次使用这个socket给外部主机发送数据时NAT会给其分配一个公网(PublicIP:PublicPort),以后用这个socket向外面任何主机发送数据都将使用这对(PublicIP:PublicPort)。此外,如果任何外部主机想要发送数据给这个内网主机,只要知道这个(PublicIP:PublicPort)并且内网主机之前用这个socket曾向这个外部主机(IP,Port)发送过数据。只要满足这两个条件,这个外部主机就可以用自己的(IP,Port)发送数据给(PublicIP:PublicPort),内网的主机就能收到这个数据包

    4. Symmetric NAT

      内网主机建立一个UDP socket(LocalIP,LocalPort),当用这个socket第一次发数据给外部主机1时,NAT为其映射一个(PublicIP-1,Port-1),以后内网主机发送给外部主机1的所有数据都是用这个(PublicIP-1,Port-1); 如果内网主机同时用这个socket给外部主机2发送数据,第一次发送时,NAT会为其分配一个(PublicIP-2,Port-2), 以后内网主机发送给外部主机2的所有数据都是用这个(PublicIP-2,Port-2).

    RFC 5780定义的九种NAT类型

    这九种包含了RFC 3489中的四种类型
    RFC 5780中分为了映射类型和过滤类型

    • NAT映射类型

      如图1所示,假设一个内网主机HostX的内网IP地址为X,端口号为x,经NAT映射后的外网IP地址为M,端口号为m。为方便描述,将内网的Endpoint记为Endpoint(X,x),映射后外网的Endpoint记为Endpoint(M,m)。内网Endpoint(X,x)发往外网HostD1的IP地址和端口号记为目的Endpoint(D1,d1);发往外网HostD2的IP地址和端口号记为目的Endpoint(D2,d2)。

      1. EIM(Endpoint-Independent Mapping)外部地址无关映射:对于一个内网Endpoint(X,x),其映射的外网Endpoint(M,m)是固定的。即从相同的Endpoint(X,x)发送到任何外部IP地址和任何外部端口的报文在NAT设备上使用相同的映射。
      2. ADM(Address-Dependent Mapping)外部地址相关映射
        于一个内网Endpoint(X,x),发往目的Endpoint(D1,d1)的报文,Endpoint(X,x)被映射成Endpoint(M1,m1);发往目的Endpoint(D2,d2)的报文,Endpoint(X,x)被映射成Endpoint(M2,m2)。只要D1=D2,不管d1和d2是多少,都有Endpoint(M1,m1)=Endpoint(M2,m2)。即从相同的Endpoint(X,x)发送到相同外部IP地址和任何外部端口的报文在NAT设备上使用相同的映射。
      3. APDM(Address and Port-Dependent Mapping)外部地址和端口相关映射
        对于一个内网Endpoint(X,x),发往目的Endpoint(D1,d1)的报文,Endpoint(X,x)被映射成Endpoint(M1,m1);发往目的Endpoint(D2,d2)的报文,Endpoint(X,x)被映射成Endpoint(M2,m2)。只有当D1=D2,且d1=d2,才有Endpoint(M1,m1)=Endpoint(M2,m2)。即从相同的Endpoint(X,x)发送到相同外部IP地址和相同外部端口的报文在NAT设备上使用相同的映射。

      图1 NAT映射类型

    • NAT过滤类型

      如图2所示,假设一个内网主机HostX的内网IP地址为X,端口号为x,经NAT映射后的外网IP地址为M,端口号为m。为方便描述,将内网的Endpoint记为Endpoint(X,x),映射后外网的Endpoint记为Endpoint(M,m)。内网Endpoint(X,x)发往外网HostD1的IP地址和端口号记为目的Endpoint(D1,d1);发往外网HostD2的IP地址和端口号记为目的Endpoint(D2,d2)。
      图2 NAT过滤类型

      1. EIF(Endpoint-Independent Filtering)外部地址无关过滤
        对于一个内网Endpoint(X,x),只要它曾经向外网发送过数据,外网主机就可以获取到它经NAT映射后的外网Endpoint(M,m)。那么只要是发给Endpoint(M,m)的报文,不管来源于D1还是D2,都能被转换并发往内网,其他报文被过滤掉。
      2. ADF(Address-Dependent Filtering)外部地址相关过滤
        对于一个内网Endpoint(X,x),只有它曾经向IP地址为D1的外网主机发送过报文,那么来自外网HostD1返回的任何端口的报文,都能被转换并发往内网,其他报文被过滤掉。
      3. APDF(Address and Port-Dependent Filtering)外部地址和端口相关过滤
        对于一个内网Endpoint(X,x),只有它曾经向IP地址为D1,端口号为d1的外网目的Endpoint(D1,d1)发送过报文,那么也只有外网HostD1中来自Endpoint(D1,d1)返回的报文,才能被转换并发往内网,其他报文被过滤掉。

    把映射类型和过滤类型组合起来就是9种NAT类型,分别对应如下:

    以上只是RFC的分类方法,不同厂家设备实现细节上可能还有不一样。

    全椎型是打通速度最快的,受限锥型可能会延个几秒(防火墙需要等互相收到对方发过来的包才能建立会话),对称型虽然不能直接打通,但是猜测对方端口在一个范围内进行扫描也是可以的,大部分防火墙来说NAT端口分配都是连续的,下一个连接总是在上一个连接的端口号上加一,如果一次没猜中多猜几次就好了,再加上请求的时候 可以一次性打开多个端口,这样更容易猜中。

    STUN服务器实现

    https://github.com/coturn/coturn
    支持STUN,TURN,ICE,但是对STUN的支持并不完整,不支持探测NAT类型
    https://github.com/jselbie/stunserver
    仅支持STUN,但完整实现了RFC的所有特性,但是要开启所有特性需要服务器有两个公网IP

    STUN客户端

    https://github.com/HMBSbige/NatTypeTester/tree/master
    另外stunserver中自带的也有个客户端

    关于多出口

    如果网络是多出口的对NAT类型探测和穿透还是有很大影响的,在地址受限测试中客户端访问不同的STUN Server IP如果请求从不同的出口出去的话会导致IP和端口都发生变化,这样就成了端口地址受限NAT。在后面的穿透工作中如果访问NAT Server和实际通信用的不是一个出口(IP),就会出现通信振荡不稳定。所以对于多出口的环境最后能绑定线路,或者把有多出口的一端当成对称型NAT来用,由另一端进行穿透。这种情况在一端进行穿透反而比两端同时进行穿透要稳定。如果STUN能增加多线路的支持就更好了,还能利用多个线路同时传输数据。

    参考:

    https://arthurchiao.art/blog/how-nat-traversal-works-zh/#41-stun-%E5%8E%9F%E7%90%86
    https://blog.csdn.net/wh445306/article/details/127831832
    https://blog.csdn.net/momo0853/article/details/105387675/
    https://zhaoyanbai.com/articles/RFC8489_STUN_zh_CN
    https://gist.github.com/mondain/b0ec1cf5f60ae726202e

    Views: 5

  • 在NAT网络中测试UDP会话的超时时间

    创建stuntest.sh脚本,内容如下

    #!/bin/sh
    stunclient --protocol 2 --localport 21 stun.hetao.me
    echo "sleep 1"
    sleep1
    stunclient --protocol 2 --localport 21 stun.hetao.me
    

    然后以不同的时间间隔多次运行这个脚本(可以并行运行),看映射的端口有没有变化,有变化就是超时了
    ./stuntest.sh 235 udp #第一个参数是间隔时间
    test1

    Binding test: success
    Local address: 100.82.167.62:1233
    Mapped address: 117.143.55.240:13837
    sleep 238
    Binding test: success
    Local address: 100.82.167.62:1233
    Mapped address: 117.143.55.240:13837

    test2

    Binding test: success
    Local address: 100.82.167.62:1240
    Mapped address: 117.143.55.240:13853
    sleep 245
    Binding test: success
    Local address: 100.82.167.62:1240
    Mapped address: 117.143.55.240:14115
    经过了238秒,端口号没有变,但是245秒端口号就变了,说明超时时间应该不超过240秒也就是4分钟

    测试用到的stun服务端和客户端是用的这个项目的代码:
    https://github.com/jselbie/stunserver

    也可以用coturn中的turnutils_natdiscovery中的工具来测试
    turnutils_natdiscovery -m -f -t -T 500 stunserver2024.stunprotocol.org
    这样会在开始的时候发一次请求,500秒后再发一次请求

    openwrt修改NAT会话超时(其它系统方法类似)
    vi /etc/sysctl.d/11-nf-conntrack.conf
    修改
    net.netfilter.nf_conntrack_udp_timeout=240
    net.netfilter.nf_conntrack_udp_timeout_stream=300
    生效
    /etc/init.d/sysctl reload
    查看当前NAT会话超时
    sysctl net.netfilter.nf_conntrack_udp_timeout

    Views: 1

  • MTU测试

    可以用Ping命令来测试当前传输介质的MTU
    Windows用法
    ping -l 1464 -f 223.5.5.5
    -l指定的是ping包的载荷大小,由于ping包头是28字节,所以载荷加上28就是真实MTU大小,-f指定不可拆分包。
    Linux用法
    ping -s 1464 -M do 223.5.5.5
    使用-M do参数发送大包时是会自动提示MTU大小,不用再自己计算了
    如果是IPv6则要减去48字节(IP头40字节,ICMPv6头8字节),如下MTU 1500的icmpv6载荷为1452字节。
    ping -s 1452 -M do fe80::f8b3:a6ff:fece:7589
    不同介质/线路下MTU的大小
    – 以太网
    默认都是1500,一般以太网卡也可以配置超大帧
    – PPPOE拨号网络
    可以是1492,也可以是1480,国内一般都是1492
    – wireguard
    wireguar的报头是固定40个字节,IPV4的报头是20字节,IPV6报头是40字节,PPPOE是8个字节,所以在IPv4网络下wireguard的MTU是1500-40-20-8=1432,在IPv6网络下是1500-40-40-8=1412
    – IPSec
    因为PSec是高度可配置的,不同的配置下MTU是不一样的,需要实际去测试
    – udp2raw
    官方没有说udp2raw的报头是多长的,只说MTU是13xx(等于没说),我用命令实测是88个字节的头部(即faketcp头部,应该也是变长的)所以PPPOE+Udp2raw+Wireguard的MTU就是1500-40-88-20-8=1344,如果是IPV6则是1324。

    关于双方MtU不同的情况:

    如果通信是一对一的,则两边设置相同的MTU即可,如果是面向多个端点的通信则需要需要设置为所有端点MTU最低的那个。设置MTU考虑的是对方及与对方通信线路的接收和传输能力。是取决于别人,面不是自己(一般自己都是1500)。

    关于MSS钳制可以看这一篇:

    TCP MSS钳制解决Wireguard访问github超时问题

    这个网站列出了各个协义的头部长度:

    https://baturin.org/tools/encapcalc/

    参考:

    https://zhuanlan.zhihu.com/p/532370376

    Views: 9

  • windows创建每天每分钟执行的任务

    这里开始时间和持续时间共同确定一天内任务生效的时间段,哪果选选从0点开始持续时间12个小时,则每天的0点到12点任务生效。对于每天执行的任务最长持续时间不能超过一天,也可以选择无限期,效果跟一天是一样的。

    Views: 4

  • 用Cython把Python模块转换为纯C语言模块

    转换为C语言模块后可以与Python解释器编译到一起作为内置模块用,也可以外部模块import后使用。

    1. 创建嵌入式模块

    嵌入式模块可以嵌入到独立C语言程序中执行
    首先编写普通的python模块代码,然后在python代码的基础上创建pyx代码,通过cdef声明可以定义原生C语言函数,而不用通过Python解释器调用,可以更好的与C语言交互。
    pyx代码的写法可以参考cython官方文档
    hello.pyx文件

    cdef public char *say_hello_to(char* name):
        return name
    

    c-test.c文件

    #include "Python.h"
    #include "hello.h"
    int main(int argc, char *argv[])
    {
        PyObject *pmodule;
        char *result;
        wchar_t *program;
    
       // 读取命令行参数
        program = Py_DecodeLocale(argv[0], NULL);
        if (program == NULL) {
            fprintf(stderr, "Fatal error: cannot decode argv[0], got %d arguments\n", argc);
            exit(1);
        }
        /* 把模块注册为内置模块 */
    
        if (PyImport_AppendInittab("test", PyInit_hello) == -1) {
    
            fprintf(stderr, "Error: could not extend in-built modules table\n");
    
            exit(1);
    
        }
        /* 把命令行参数传给Python解释器 */
        Py_SetProgramName(program);
    
        /* 初始化Python,这一步是必须的. */
        Py_Initialize();
    
        /* 调用Python中的函数. */
        result = say_hello_to("hetao");
        // PyErr_Print();
        printf("result:%s\n", result);
    
          /* Clean up after using CPython. */
        PyMem_RawFree(program);
        Py_FinalizeEx();
    
        return 0;
    
        /* Clean up in the error cases above. */
    exit_with_error:
        PyMem_RawFree(program);
        Py_Finalize();
        return 1;
    }
    

    cython hello.pyx --3str
    执行cython后会生成hello.c和hello.h两个文件

    gcc -o libhello.so -shared  -fPIC -I/usr/include/python3.10 hello.c
    gcc -o test-c -I/usr/include/python3.10 -I./ -L./ -ltest -lpython3.10 -Wl,-rpath . test-c.c
    

    运行结果

    $ ./test-c
    result:hetao

    2. 创建外部模块

    hello.pyx文件

    def say_hello_to(name):
        return name
    

    setup.py文件

    from setuptools import setup
    from Cython.Build import cythonize
    
    setup(
        name='Hello',
        ext_modules=cythonize("hello.pyx"),
    )
    

    构建模块
    python setup.py build_ext --inplace

    test-hello.py文件

    import hello
    
    result = hello.say_hello_to("hetao")
    print(result)
    

    cdef、def 和 cpdef 的区别:

    在 Cython 中,有三种不同的函数声明方式:cdef、def 和 cpdef。
    cdef 声明的函数是纯 C 函数,只能从 Cython 代码中调用,不可从 Python 代码中访问。
    def 声明的函数是 Python 函数,可以从 Python 代码中调用,但会带来一些性能开销。
    cpdef 声明的函数是混合函数,既可以从 Cython 代码中调用,也可以从 Python 代码中调用,其底层其实生成了两个函数版本。

    关于编译参数:

    获取编译参数
    python3-config –cflags
    获取链接参数
    python3-config –ldflags

    Views: 1

  • C语言调用Python模块中的Python函数

    #include "Python.h"
    int main()
    {
            Py_Initialize();
            PyObject *pmodule = PyImport_ImportModule("os");
            //获取当前用户的id
            PyObject *pfunc = PyObject_GetAttrString(pmodule, "geteuid");
            PyObject *arg = Py_BuildValue("()");
            PyObject *result = PyObject_Call(pfunc, arg, NULL);
            long retval = PyLong_AsLong(result);
            printf("result: %ld\n", retval);
            Py_XDECREF(result);
            Py_FinalizeEx();
            return 0;
    }
    
    gcc -c -I/usr/include/python3.10  -L/usr/lib/python3.10/config-3.10-x86_64-linux-gnu -L/usr/lib/x86_64-linux-gnu -lpython3.10 -lcrypt -ldl  -lm -lm  test.c
    gcc -o test test.o  -L/usr/lib/python3.10/config-3.10-x86_64-linux-gnu -L/usr/lib/x86_64-linux-gnu -lpython3.10 -lcrypt -ldl  -lm
    

    执行后返回如下:

    $ ./test
    result: 1001
    这种方法可以调用普通Python函数

    Views: 1

  • C语言调用Python模块中的C函数

    C语言写的Python模块中可以有python函数,也可以有C函数。
    以下代码导入Python模块并执行其中的C函数
    ctest.c文件内容

    #include "Python.h"
    #include "test.h"
     int main(int argc, char *argv[])
    {
        PyObject *pmodule;
        int *result;
        wchar_t *program;
    
       // 读取命令行参数
        program = Py_DecodeLocale(argv[0], NULL);
        if (program == NULL) {
            fprintf(stderr, "Fatal error: cannot decode argv[0], got %d arguments\n", argc);
            exit(1);
        }
        /* 把模块注册为内置模块 */
    
        if (PyImport_AppendInittab("test", PyInit_test) == -1) {
    
            fprintf(stderr, "Error: could not extend in-built modules table\n");
    
            exit(1);
    
        }
        /* 把命令行参数传给Python解释器 */
        Py_SetProgramName(program);
    
        /* 初始化Python,这一步是必须的. */
        Py_Initialize();
    
        /* 调用Python中的函数. */
        result = hello(1, 2);
        // PyErr_Print();
        printf("result:%d,%d,%lu\n", result[0], result[2], sizeof(result));
    
          /* Clean up after using CPython. */
        PyMem_RawFree(program);
        Py_FinalizeEx();
    
        return 0;
    
        /* Clean up in the error cases above. */
    exit_with_error:
        PyMem_RawFree(program);
        Py_Finalize();
        return 1;
    }
    

    编译

    gcc -o ctest -I/usr/include/python3.10 -I./ -L./ -ltest -lpython3.10 -Wl,-rpath . ctest.c
    

    如果是调用python自带的内置函数则不需要执行PyImport_AppendInittab,直接调用即可。
    只有C语言写的模块才能注册为内置模块

    关于Python解释器初始化的问题:
    cython官方文档上说如果不调用Py_Initialize()进行初始化极有可能会发生程序崩溃,但并没有说明什么情况下会崩溃。经过我的测试如果所调用的C函数不涉及Python代码,也不会调用其它可能会执行Python代码的函数则不会崩溃,反之就会发生断错误。也就是说只能在C语言的内存空间内执行。对于一些Python内置的C语言写的函数是可以不初始化就调用的,如果是那种需要import的就不可以了。

    Views: 1