Cisco SYNful Knock全网检测

一、漏洞概要

Cisco SYNful Knock属于一个植入木马，它由一个经过篡改的思科IOS镜像组成，能允许攻击者保持匿名性，同时从网络上加载不同的功能模块。这个植入木马还使用了一个秘密的后门密码，能给攻击者提供非限制权限。每个模块都能通过HTTP协议来启用，只需向路由器的接口发送一个特别制作的TCP数据包。这些数据包都使用了非标准的序列号和相应的承认号。而这些模块可以把自己显示成路由器IOS中独立的可执行代码或hook，提供的功能与后门密码类似。后门密码通过控制台，远程登陆协议和权限提升，使用enable命令，能提供对路由器的访问。

二、影响范围

Cisco 1841 router，Cisco 2811 router， Cisco 3825 router，不排除其它型号Cisco网络设备也有可能受到影响，这些路由器的核心功能、IOS代码都很类似。

三、漏洞分析

1 . 后门通过特殊后门密码通过console或telnet登录路由器，后门密码认证后获得管理员权限，如果没有通过认证则转向设备本身的认证模块。

方式	后门提示	结果
Console	“User Access Verification”	普通访问和提权
Telnet	Username is the backdoor password	普通访问和提权
Elevation (enable)	Enable password	提权

2.植入后门程序监听TCP 80端口，攻击者通过伪造非标准的三次握手同后门程序建立TCP连接，后通过后门程序的自定义的指令在IOS中加载其它模块，可供加载的模块共100多种，但是重启后模块不再生效

1）SYN，构造tcp syn包发送给被植入后门设备，确保syn和ack的offset为0xC123D（如syn=791104，ack=3），ack号并不需要为0，offset必须为791102

2）SYN-ACK，后门程序返回的ack包为syn + 1，把初始SYN包中的ack号作为seq号（ack=791105 ，seq=3），其后的tcp option中的特殊编码为“02 04 05 b4 01 01 04 02 01 03 03 05”，tcp头中urgent指针=0x0001，urg flag=0（通常一般服务会随机产生一个seq序号，所以为非标准tcp）

3）ACK完成握手

4）控制端开始发送TCP控制信息，置push flag=1、 ack flag=1, tcp头的offset 0x62处写入“text”，0x67处写入命令，命令格式：[4 byte Command Length][CMD Data][4 byte checksum]，定义了5类命令，list、分配内存、植入、激活、卸载。

5）后门响应封装为静态HTTP/HTML服务器响应 HTTP/1.1 200 OK 。。。。

一、 漏洞验证

Kali下使用nping:

nping -c1 -v3 –tcp -p 80 –seq 791104 –ack 3 10.1.1.1

返回ack=791105 ，seq=3 ，tcpoption中出现02 04 05 b4 01 01 04 02 00 30 01 03 03 05

五、 公网检测：

1、从apnic上获取为中国区域分配的IP段，具体方式：

wget -c http://ftp.apnic.net/stats/apnic/delegated-apnic-latest

cat delegated-apnic-latest | awk -F ‘|’ ‘/CN/&&/ipv4/ {print $4 “/” 32-log($5)/log(2)}’|cat >ip.txt

生成可被zmap识别的文件格式：

2、检测开放80端口的设备：

zmap -w ip.txt -p 80 -o results.txt

对全网进行3次扫描，每次结果在6000000~6400000之间，相对误差并不是很大。

3、 POC制作：

制作思路：

POC分为两个部分，一个负责SYN包发送，另一个负责接收和分析SYN的应答包。

发送部分：

（1）向开放80端口的设备发送序列号和应答号之间差值为791101的SYN包。比如seq=791104，ack=3.

接收部分：

过滤出满足以下条件的数据包：

（1） SYN和ACK标识位被置1，来源端口为80的TCP包。

（2）紧急指针值为0x0001，但紧急标识位为0.

（3）序列号和应答号之间的差值为791102.

（4） TCP options string=

“\x02\x04\x05\xb4\x01\x01\x04\x02\x01\x03\x03\x05”

4、检测结果：

由于自己构造并发送TCP包，所以系统不再维护TCP SYN包的超时重传机制，为了避免漏报的情况，用POC对所有开80端口的设备进行了多次扫描，目前国内所有公网IP已未检测出此后门。

POC

发送部分(Python)：

from struct import *
import struct
import socket
import time
import random

def check_sum(msg):
    s = 0
    for i in range(0, len(msg), 2):
        w = (ord(msg[i]) << 8) + (ord(msg[i + 1]) )
        s += w

    s = (s >> 16) + (s & 0xffff)
    s = ~s & 0xffff
    return s

def create_ip_header(source,destination):
    version = 4
    ihl = 5 # Internet Header Length
    tos = 0 # Type of Service
    tl = 0 # total length will be filled by kernel
    id = 54321
    flags = 0 # More fragments
    offset = 0
    ttl = 255
    protocol = socket.IPPROTO_TCP
    checksum = 0 # will be filled by kernel
    source = socket.inet_aton(source)
    destination = socket.inet_aton(destination)
    ver_ihl = (version << 4) + ihl
    flags_offset = (flags << 13) + offset
    ip_header = struct.pack("!BBHHHBBH4s4s",
        ver_ihl,
        tos,
        tl,
        id,
        flags_offset,
        ttl,
        protocol,
        checksum,
        source,
        destination)
    return ip_header

def create_tcp_syn_header(source_ip,source_port, dest_ip, dest_port):
    source = random.randrange(32000,62000,1)
    seq = 791104
    ack_seq = 3
    doff = 5
    # tcp flags
    fin = 0
    syn = 1
    rst = 0
    psh = 0
    ack = 0
    urg = 0
    window = socket.htons (8192)
    check = 0
    urg_ptr = 0
    offset_res = (doff << 4) + 0
    tcp_flags = fin + (syn<<1) + (rst<<2) + (psh<<3) + (ack<<4) + (urg<<5)
    tcp_header = pack('!HHLLBBHHH', source, dest_port, seq, ack_seq, offset_res, tcp_flags, window, check, urg_ptr)

    source_address = socket.inet_aton( source_ip )
    dest_address = socket.inet_aton( dest_ip )
    placeholder = 0
    protocol = socket.IPPROTO_TCP
    tcp_length = len(tcp_header)
    psh = pack('!4s4sBBH', source_address, dest_address, placeholder, protocol, tcp_length)
    psh = psh + tcp_header
    tcp_checksum = check_sum(psh)


    tcp_header = pack('!HHLLBBHHH', source, dest_port, seq, ack_seq, offset_res, tcp_flags, window, tcp_checksum, urg_ptr)
    return tcp_header


def send_syn_packet(dest_host,src_port):
 try:
  soc=socket.socket(socket.AF_INET,socket.SOCK_RAW,socket.IPPROTO_TCP)

  src_host="10.0.126.3"
  #Create IP Header
  iph=create_ip_header(src_host,dest_host)
  #Create TCP Header
  tcph=create_tcp_syn_header(src_host,src_port,dest_host,80)
  pkt=iph+tcph

  n=9
  while n<10:
   soc.sendto(tcph,(dest_host,0))
   n+=1
  time.sleep(0.001)
  soc.close()
 except:
  print "send_syn_packet error"


fd=open("results.txt","r")
if fd is None:
    print "Open file failed"
    exit()

src_port=999
count=0
n=1
while True:
    readLine=fd.readline()
    dest_host=readLine[:len(readLine)-1]
    if len(dest_host)<=5:
        fd.seek(0)
        print str(n)
        n+=1
        continue
    send_syn_packet(dest_host,src_port)
    count+=1
    #print str(count)+"  "+dest_host


print "finish:"+str(count)

接收部分(C)：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netinet/in.h>   // for sockaddr_in
#include <sys/types.h>    // for socket
#include <sys/socket.h>   // for socket
#include <arpa/inet.h>
#include <netinet/if_ether.h>
#include <pthread.h>
#include <math.h>

#define MAX_SIZE 65537

typedef struct DLC_Header
{
    unsigned char DesMAC[6];     //以太网目的地址
    unsigned char SrcMAC[6];     //以太网源地址
    unsigned short EtherType;    //帧类型
} DLCHEADER;

typedef struct ipheader
{
    unsigned char ip_hl:4;    /*header length(报头长度）*/
    unsigned char ip_v:4;    /*version(版本)*/
    unsigned char ip_tos;    /*type os service服务类型*/
    unsigned short int ip_len;   /*total length (总长度)*/
    unsigned short int ip_id;   /*identification (标识符)*/
    unsigned short int ip_off;   /*fragment offset field(段移位域)*/
    unsigned char ip_ttl;    /*time to live (生存时间)*/
    unsigned char ip_p;     /*protocol(协议)*/
    unsigned short int ip_sum;   /*checksum(校验和)*/
    unsigned int ip_src;    /*source address(源地址)*/
    unsigned int ip_dst;    /*destination address(目的地址)*/
} IP;         /* total ip header length: 20 bytes (=160 bits) */

typedef struct tcpheader
{
    unsigned short int sport;   /*source port (源端口号)*/
    unsigned short int dport;   /*destination port(目的端口号)*/
    unsigned int th_seq;    /*sequence number(包的序列号)*/
    unsigned int th_ack;    /*acknowledgement number(确认应答号)*/
    unsigned char th_x:4;    /*unused(未使用)*/
    unsigned char th_off:4;    /*data offset(数据偏移量)*/
    unsigned char Flags;    /*标志全*/
    unsigned short int th_win;   /*windows(窗口)*/
    unsigned short int th_sum;   /*checksum(校验和)*/
    unsigned short int th_urp;   /*urgent pointer(紧急指针)*/
} TCP;

unsigned char ACK_FLAG=1<<4;
unsigned char SYN_FLAG=1<<1;
unsigned char URG_FLAG=1<<5;

char *TCP_OPTIONS_STRING="\x02\x04\x05\xb4\x01\x01\x04\x02\x01\x03\x03\x05";

FILE *file=NULL;
int count=0;

int CreateSocket(int *soc)
{
    if((*soc=socket(PF_PACKET,SOCK_RAW,htons(ETH_P_IP)))<0)
        return 0;

    return 1;
}

void *show_count(void *para)
{
    while(1)
    {
        usleep(1000000);
        printf("%d\n",count);
    }
}

int Sniffer(int *soc)
{
    int i;
    IP *IPHeader=NULL;
    TCP *TCPHeader=NULL;
    char recvBuff[MAX_SIZE];
    char TCPStr[1000],tempStr[100];
    int RecvSize;
    uint16_t sport=htons(80);
    uint16_t th_urp=htons(0x0001);
    uint32_t seq,ack,offset;

    IPHeader=(IP *)(recvBuff+sizeof(DLCHEADER));
    TCPHeader=(TCP *)(recvBuff+sizeof(DLCHEADER)+sizeof(IP));

    while(1)
    {
        memset(recvBuff,NULL,sizeof(recvBuff));
        if((RecvSize=recvfrom(*soc,recvBuff,sizeof(recvBuff)-1,0,NULL,NULL))<sizeof(DLCHEADER)+sizeof(TCP)+sizeof(IP)) continue;

        if((TCPHeader->Flags & ACK_FLAG) && (TCPHeader->Flags & SYN_FLAG) && TCPHeader->sport==sport)
        {
            count++;
            if((TCPHeader->th_urp!=0x00) && !(TCPHeader->Flags & URG_FLAG))
            {
                seq=ntohl(TCPHeader->th_seq);
                ack=ntohl(TCPHeader->th_ack);
                offset=seq>ack?seq-ack:ack-seq;

                //printf("host %s,seq=%d,ack=%d,offset:%d\n",inet_ntoa(*(struct in_addr *)&IPHeader->ip_src),seq,ack,offset);
                if(offset==791102 && !memcmp(&((char *)TCPHeader)[20],TCP_OPTIONS_STRING,12))
                {
                    memset(TCPStr,NULL,sizeof(TCPStr));
                    for(i=0; i<12; i++)
                    {
                        memset(tempStr,NULL,sizeof(tempStr));
                        sprintf(tempStr,"0x%.2x ",((char *)TCPHeader)[20+i]);
                        strcat(TCPStr,tempStr);
                    }

                    printf("host %s,seq=%d,ack=%d,offset:%d,string:%s\n",inet_ntoa(*(struct in_addr *)&IPHeader->ip_src),seq,ack,offset,TCPStr);
                    fprintf(file,"%s\n",inet_ntoa(*(struct in_addr *)&IPHeader->ip_src));
                    fflush(file);
                }
            }
        }
    }

    return 1;
}

int main(int argc,char *argv[])
{
    int socket;
    pthread_t id;

    if(!CreateSocket(&socket))
    {
        printf("创建套接字失败。\n");
        return -1;
    }
    if((file=fopen("Data.txt","wt"))==NULL)
    {
        printf("创建文件失败。\n");
        return -1;
    }
    pthread_create(&id,NULL,show_count,NULL);
    printf("Start...\n");
    Sniffer(&socket);

    return 0;
}

打赏

Cisco SYNful Knock全网检测

[转]Python多线程和线程同步

[转]三层交换机与路由器的比较

You may also like

Leave a Comment Cancel Reply