wapysun

[转]网络安全工具开发函数库介绍

网络安全工具开发函数库介绍

作者：backend backend@nsfocus.com>
http://www.nsfocus.com>
日期：2000-07-16

---[[ 前言 ]]--------------------------------------------

本文主要介绍几个在UNIX系统平台上开发网络安全工具时最常用的library。此外还提供一些如何使用这些开发库进行网络安全工具开发的设计框架和流程。希望能和对网络安全工具开发有兴趣的朋友共同交流，互相促进。

众所周知，基于socket的网络编程已成为当今不可替代的编程方法。这种编程思想将网络通讯当作“文件”描述字进行处理，对这个“网络文件”(即 socket，套接字/套接口)的操作从编程者的角度来讲与普通的文件操作(如读、写、打开、关闭等)大同小异，从而极大地简化了网络程序开发过程。

在众多的网络安全程序、工具和软件中都是基于socket设计和开发的。由于在安全程序中通常需要对网络通讯的细节(如连接双方地址/端口、服务类型、传输控制等)进行检查、处理或控制，象数据包截获、数据包头分析、数据包重写、甚至截断连接等，都几乎在每个网络安全程序中必须实现。为了简化网络安全程序的编写过程，提高网络安全程序的性能和健壮性，同时使代码更易重用与移植，最好的方法就是将最常用和最繁复的过程函数，如监听套接口的打开/关闭、数据包截获、数据包构造/发送/接收等，封装起来，以API library的方式提供给开发人员使用。

---[[ C开发库简介 ]]-------------------------------------

在Unix系统平台上的网络安全工具开发中，目前最为流行的C API library有libnet、libpcap、libnids和libicmp等。它们分别从不同层次和角度提供了不同的功能函数。使网络开发人员能够忽略网络底层细节的实现，从而专注于程序本身具体功能的设计与开发。其中，

* libnet提供的接口函数主要实现和封装了数据包的构造和发送过程。

* libpcap提供的接口函数主要实现和封装了与数据包截获有关的过程。

* libnids提供的接口函数主要实现了开发网络入侵监测系统所必须的一些结构框架。

* libicmp等相对较为简单，它封装的是ICMP数据包的主要处理过程(构造、发送、接收等)。

利用这些C函数库的接口，网络安全工具开发人员可以很方便地编写出具有结构化强、健壮性好、可移植性高等特点的程序，如scanner、sniffer、firewall、IDS等。

---[[ libnet ]]------------------------------------------

libnet库的最新版本为1.0.0，它一共约7600行C源代码，33个源程序文件，12个C头文件，50余个自定义函数，提供的接口函数包含15种数据包生成器和两种数据包发送器(IP层和数据链路层)。目前只支持IPv4，不支持IPv6。已经过测试的系统平台包括：

* OpenBSD 2.6snap, 2.5, 2.4, 2.3, 2.2 (i386)
* FreeBSD 4.0-STABLE, 3.3-STABLE, 3.2-RELEASE, 3.1-CURRENT, 3.0, 2.2 (i386)
* NetBSD 1.3.2 (i386)
* BSD/OS 3.x (i386)
* BSDi 3.0 (i386)
* Linux 2.2.x, 2.0.3x, 2.1.124 (i386, alpha) (libc: 2.4.x, glibc: 2.0.x)
* Solaris 7 (SPARC, gcc 2.7.2[13], 2.8.2), 2.6 (SPARC, gcc 2.8.2),
2.5.x (SPARC, gcc 2.7.2[13])
* IRIX 6.2
* MacOS 5.3rhapsody (powerpc)

libnet提供的接口函数按其作用可分为四类：

* 内存管理(分配和释放)函数
* 地址解析函数
* 数据包构造函数
* 数据包发送函数

以下分别列出这些接口函数及其功能(其参数含义简单易懂，不再解释)：

★ 内存管理函数

单数据包内存初始化：
int libnet_init_packet(u_short packet_size, u_char **buf);

单数据包内存释放：
void libnet_destroy_packet(u_char **buf);

多数据包内存初始化：
int libnet_init_packet_arena(struct libnet_arena **arena,
u_short packet_num, u_short packet_size);

访问多数据包内存中的下一个数据包：
u_char *libnet_next_packet_from_arena(struct libnet_arena **arena,
u_short packet_size);

多数据包内存释放：
void libnet_destroy_packet_arena(struct libnet_arena **arena);

★ 地址解析函数

解析主机名：
u_char *libnet_host_lookup(u_long ip, u_short use_name);

解析主机名(可重入函数)：
void libnet_host_lookup_r(u_long ip, u_short use_name, u_char *buf);

域名解析：
u_long libnet_name_resolve(u_char *ip, u_short use_name);

获取接口设备IP地址：
u_long libnet_get_ipaddr(struct libnet_link_int *l,
const u_char *device, const u_char *ebuf);

获取接口设备硬件地址：
struct ether_addr *libnet_get_hwaddr(struct libnet_link_int *l,
const u_char *device,
const u_char *ebuf);

★ 数据包构造函数

ARP协议数据包：
int libnet_build_arp(u_short hrdw, u_short prot, u_short h_len,
u_short p_len, u_short op, u_char *s_ha,
u_char *s_pa, u_char *t_ha, u_char *t_pa,
const u_char *payload, int payload_len,
u_char *packet_buf);

DNS协议数据包：
int libnet_build_dns(u_short id, u_short flags, u_short num_q,
u_short num_answ_rr, u_short num_auth_rr,
u_short num_add_rr, const u_char * payload,
int payload_len, u_char *packet_buf);

以太网协议数据包：
int libnet_build_ethernet(u_char *daddr, u_char *saddr, u_short id,
const u_char *payload, int payload_len,
u_char *packet_buf);

ICMP协议数据包(ICMP_ECHO / ICMP_ECHOREPLY)：
int libnet_build_icmp_echo(u_char type, u_char code, u_short id,
u_short seq, const u_char *payload,
int payload_len, u_char *packet_buf);

ICMP协议数据包(ICMP_MASKREQ / ICMP_MASKREPLY)：
int libnet_build_icmp_mask(u_char type, u_char code, u_short id,
u_short seq, u_long mask,
const u_char *payload, int payload_len,
u_char *packet_buf);

ICMP协议数据包(ICMP_UNREACH)：
int libnet_build_icmp_unreach(u_char type, u_char code,
u_short orig_len, u_char orig_tos,
u_short orig_id, u_short orig_frag,
u_char orig_ttl, u_char orig_prot,
u_long orig_saddr, u_long orig_daddr,
const u_char *payload, int payload_len,
u_char *packet_buf);

ICMP协议数据包(ICMP_TIMEXCEED)：
int libnet_build_icmp_timeexceed(u_char type, u_char code,
u_short orig_len, u_char orig_tos,
u_short orig_id, u_short orig_frag,
u_char orig_ttl, u_char orig_prot,
u_long orig_saddr, u_long orig_daddr,
const u_char *payload, int payload_len,
u_char *packet_buf);

ICMP协议数据包(ICMP_REDIRECT)：
int libnet_build_icmp_redirect(u_char type, u_char code, u_long gateway,
u_short orig_len, u_char orig_tos,
u_short orig_id, u_short orig_frag,
u_char orig_ttl, u_char orig_prot,
u_long orig_saddr, u_long orig_daddr,
const u_char *payload, int payload_len,
u_char *packet_buf);

ICMP协议数据包(ICMP_TSTAMP / ICMP_TSTAMPREPLY)：
int libnet_build_icmp_timestamp(u_char type, u_char code, u_short id,
u_short seq, n_time otime, n_time rtime,
n_time ttime, const u_char *payload,
int payload_len, u_char *packet_buf);

IGMP协议数据包：
int libnet_build_igmp(u_char type, u_char code, u_long ip,
const u_char *payload, int payload_len,
u_char *packet_buf);

IP协议数据包：
int libnet_build_ip(u_short len, u_char tos, u_short ip_id, u_short frag,
u_char ttl, u_char protocol, u_long saddr,
u_long daddr, const u_char *payload, int payload_len,
u_char *packet_buf);

OSPF路由协议数据包：
int libnet_build_ospf(u_short len, u_char type, u_long router_id,
u_long area_id, u_short auth_type,
const char *payload, int payload_s, u_char *buf);

OSPF路由协议数据包(Hello)：
int libnet_build_ospf_hello(u_long netmask, u_short interval,
u_char options, u_char priority,
u_int dead_interval, u_long des_router,
u_long backup, u_long neighbor,
const char *payload, int payload_s,
u_char *buf);

OSPF路由协议数据包(DataBase Description (DBD))：
int libnet_build_ospf_dbd(u_short len, u_char options, u_char type,
u_int sequence_num, const char *payload,
int payload_s, u_char *buf);

OSPF路由协议数据包(Link State Request (LSR))：
int libnet_build_ospf_lsr(u_int type, u_int ls_id, u_long adv_router,
const char *payload, int payload_s,
u_char *buf);

OSPF路由协议数据包(Link State Update (LSU))：
int libnet_build_ospf_lsu(u_int num, const char *payload,
int payload_s, u_char *buf);

OSPF路由协议数据包(Link State Acknowledgement (LSA))：
int libnet_build_ospf_lsa(u_short age, u_char options, u_char type,
u_int ls_id, u_long adv_router,
u_int sequence_num, u_short len,
const char *payload, int payload_s,
u_char *buf);

OSPF路由协议数据包(OSPF Link Sate NetworkLink State Router)：
int libnet_build_ospf_lsa_net(u_long netmask, u_int router_id,
const char *payload, int payload_s,
u_char *buf);

OSPF路由协议数据包(Link State Router)：
int libnet_build_ospf_lsa_rtr(u_short flags, u_short num, u_int id,
u_int data, u_char type, u_char tos,
u_short metric, const char *payload,
int payload_s, u_char *buf);

OSPF路由协议数据包(Link State Summary)：
int libnet_build_ospf_lsa_sum(u_long netmask, u_int metric, u_int tos,
const char *payload, int payload_s,
u_char *buf);

OSPF路由协议数据包(Link State AS External)：
int libnet_build_ospf_lsa_as(u_long netmask, u_int metric,
u_long fwd_addr, u_int tag,
const char *payload, int payload_s,
u_char *buf);

RIP路由协议数据包：
int libnet_build_rip(u_char cmd, u_char ver, u_short domain,
u_short addr_fam, u_short route_tag, u_long ip,
u_long mask, u_long next_hop, u_long metric,
const u_char *payload, int payload_len,
u_char *packet_buf);

TCP协议数据包：
int libnet_build_tcp(u_short th_sport, u_short th_dport, u_long th_seq,
u_long th_ack, u_char th_flags, u_short th_win,
u_short th_urg, const u_char *payload,
int payload_len, u_char *packet_buf);

UDP协议数据包：
int libnet_build_udp(u_short sport, u_short dport, const u_char *payload,
int payload_len, u_char *packet_buf);

IP协议数据包选项：
int libnet_insert_ipo(struct ipoption *opt, u_char opt_len,
u_char *packet_buf);

TCP协议数据包选项：
int libnet_insert_tcpo(struct tcpoption *opt, u_char opt_len,
u_char *packet_buf);

★ 数据包发送函数

打开raw socket：
int libnet_open_raw_sock(int protocol);

关闭raw socket：
int libnet_close_raw_sock(int socket);

选择接口设备：
int libnet_select_device(struct sockaddr_in *sin,
u_char **device, u_char *ebuf);

打开链路层接口设备：
struct libnet_link_int *libnet_open_link_interface(char *device,
char *ebuf);

关闭链路层接口设备：
int libnet_close_link_interface(struct libnet_link_int *l);

发送IP数据包：
int libnet_write_ip(int socket, u_char *packet, int packet_size);

发送链路层数据包：
int libnet_write_link_layer(struct libnet_link_int *l,
const u_char *device, u_char *packet,
int packet_size);

检验和计算：
int libnet_do_checksum(u_char *packet, int protocol, int packet_size);

★ 相关的支持函数

随机数种子生成器：
int libnet_seed_prand();

获取随机数：
u_long libnet_get_prand(int modulus);

16进制数据输出：
void libnet_hex_dump(u_char * buf, int len, int swap, FILE *stream);

端口列表链初始化：
int libnet_plist_chain_new(struct libnet_plist_chain **plist,
char *token_list);

获取端口列表链的下一项(端口范围)：
int libnet_plist_chain_next_pair(struct libnet_plist_chain *plist,
u_short *bport, u_short *eport);

端口列表链输出显示：
int libnet_plist_chain_dump(struct libnet_plist_chain *plist);

获取端口列表链：
u_char *libnet_plist_chain_dump_string(struct libnet_plist_chain *plist);

端口列表链内存释放：
void libnet_plist_chain_free(struct libnet_plist_chain *plist);

★ 数据常量

==================================================================================
数据包头大小定义：

常量名数值(字节数)
LIBNET_ARP_H 28
LIBNET_DNS_H 12
LIBNET_ETH_H 14
LIBNET_ICMP_H 4
LIBNET_ICMP_ECHO_H 8
LIBNET_ICMP_MASK_H 12
LIBNET_ICMP_UNREACH_H 8
LIBNET_ICMP_TIMXCEED_H 8
LIBNET_ICMP_REDIRECT_H 8
LIBNET_ICMP_TS_H 20
LIBNET_IGMP_H 8
LIBNET_IP_H 20
LIBNET_RIP_H 24
LIBNET_TCP_H 20
LIBNET_UDP_H 8

==================================================================================
数据包内存常量：

常量名含义
LIBNET_PACKET TCP/UDP数据包头 + IP数据包头使用的内存
LIBNET_OPTS IP或TCP选项使用的内存
LIBNET_MAX_PACKET IP_MAXPACKET (65535字节)使用的内存

==================================================================================
随机数发生器常量(libnet_get_prand()函数使用)：

常量名数值
LIBNET_PRAND_MAX 65535
LIBNET_PR2 0 - 2
LIBNET_PR8 0 - 255
LIBNET_PR16 0 - 32767
LIBNET_PRu16 0 - 65535
LIBNET_PR32 0 - 2147483647
LIBNET_PRu32 0 - 4294967295

==================================================================================
错误消息常量(libnet_error()函数使用)：

常量名含义
LIBNET_ERR_WARNING 警告类型消息
LIBNET_ERR_CRITICAL 紧急类型消息
LIBNET_ERR_FATAL 致命错误消息

==================================================================================
libnet_host_lookup()、libnet_host_lookup_r()和libnet_name_resolve()函数使用的常量：

常量名含义
LIBNET_DONT_RESOLVE 不将IP地址解析为FQDN名
LIBNET_RESOLVE 尝试将IP地址解析为FQDN名

==================================================================================
宏定义

宏名功能
LIBNET_GET_ARENA_SIZE(arena) 返回多数据包内存缓冲区大小(字节数)
LIBNET_GET_ARENA_REMAINING_BYTES(arena) 返回多数据包内存缓冲区剩余空间大小(字节数)
LIBNET_PRINT_ETH_ADDR(e) 输出显示ether_addr结构中的以太网地址

==================================================================================

---[[ libnet应用实例 ]]----------------------------------

利用libnet函数库开发应用程序的基本步骤非常简单：

1、数据包内存初始化；
2、网络接口初始化；
3、构造所需数据包；
4、计算数据包检验和；
5、发送数据包；
6、关闭网络接口；
7、释放数据包内存。

以下是四个使用了libnet接口函数编写的数据包发送程序。在编译前必须确保libnet库已成功安装。

============================ cut here ============================

/* Example 1 [raw socket api - TCP packet] */
/* gcc -Wall `libnet-config --defines` libnet-example-x.c -o libnet-example-x /
`libnet-config --libs` */

#include <libnet.h></libnet.h>

void usage(char *);

int main(int argc, char **argv)
{
int network, /* our network interface */
packet_size, /* packet size */
c; /* misc */
u_long src_ip, dst_ip; /* ip addresses */
u_short src_prt, dst_prt; /* ports */
u_char *cp, *packet; /* misc / packet */

printf("libnet example code:/tmodule 1/n/n");
printf("packet injection interface:/traw socket/n");
printf("packet type:/t/t/tTCP [no payload]/n");

src_ip = 0;
dst_ip = 0;
src_prt = 0;
dst_prt = 0;

while((c = getopt(argc, argv, "d:s:")) != EOF)
{
switch (c)
{
/*
* We expect the input to be of the form `ip.ip.ip.ip.port`. We
* point cp to the last dot of the IP address/port string and
* then seperate them with a NULL byte. The optarg now points to
* just the IP address, and cp points to the port.
*/
case 'd':
if (!(cp = strrchr(optarg, '.')))
{
usage(argv[0]);
}
*cp++ = 0;
dst_prt = (u_short)atoi(cp);
if (!(dst_ip = libnet_name_resolve(optarg, LIBNET_RESOLVE)))
{
libnet_error(LIBNET_ERR_FATAL,
"Bad destination IP address: %s/n", optarg);
}
break;
case 's':
if (!(cp = strrchr(optarg, '.')))
{
usage(argv[0]);
}
*cp++ = 0;
src_prt = (u_short)atoi(cp);
if (!(src_ip = libnet_name_resolve(optarg, LIBNET_RESOLVE)))
{
libnet_error(LIBNET_ERR_FATAL,
"Bad source IP address: %s/n", optarg);
}
break;
}
}
if (!src_ip || !src_prt || !dst_ip || !dst_prt)
{
usage(argv[0]);
exit(EXIT_FAILURE);
}

/*
* We're just going to build a TCP packet with no payload using the
* raw sockets API, so we only need memory for a TCP header and an IP
* header.
*/
packet_size = LIBNET_IP_H + LIBNET_TCP_H;

/*
* Step 1: Memory initialization (interchangable with step 2).
*/
libnet_init_packet(packet_size, &packet);
if (packet == NULL)
{
libnet_error(LIBNET_ERR_FATAL, "libnet_init_packet failed/n");
}

/*
* Step 2: Network initialization (interchangable with step 1).
*/
network = libnet_open_raw_sock(IPPROTO_RAW);
if (network == -1)
{
libnet_error(LIBNET_ERR_FATAL, "Can't open network./n");
}

/*
* Step 3: Packet construction (IP header).
*/
libnet_build_ip(LIBNET_TCP_H, /* size of the packet sans IP header */
IPTOS_LOWDELAY, /* IP tos */
242, /* IP ID */
0, /* frag stuff */
48, /* TTL */
IPPROTO_TCP, /* transport protocol */
src_ip, /* source IP */
dst_ip, /* destination IP */
NULL, /* payload (none) */
0, /* payload length */
packet); /* packet header memory */

/*
* Step 3: Packet construction (TCP header).
*/
libnet_build_tcp(src_prt, /* source TCP port */
dst_prt, /* destination TCP port */
0xa1d95, /* sequence number */
0x53, /* acknowledgement number */
TH_SYN, /* control flags */
1024, /* window size */
0, /* urgent pointer */
NULL, /* payload (none) */
0, /* payload length */
packet + LIBNET_IP_H); /* packet header memory */

/*
* Step 4: Packet checksums (TCP header only).
*/
if (libnet_do_checksum(packet, IPPROTO_TCP, LIBNET_TCP_H) == -1)
{
libnet_error(LIBNET_ERR_FATAL, "libnet_do_checksum failed/n");
}

/*
* Step 5: Packet injection.
*/
c = libnet_write_ip(network, packet, packet_size);
if (c {
libnet_error(LN_ERR_WARNING,
"libnet_write_ip only wrote %d bytes/n", c);
}
else
{
printf("construction and injection completed, wrote all %d bytes/n", c);
}

/*
* Shut down the interface.
*/
if (libnet_close_raw_sock(network) == -1)
{
libnet_error(LN_ERR_WARNING,
"libnet_close_raw_sock couldn't close the interface");
}

/*
* Free packet memory.
*/
libnet_destroy_packet(&packet);

return (c == -1 ? EXIT_FAILURE : EXIT_SUCCESS);
}

void usage(char *name)
{
fprintf(stderr, "usage: %s -s s_ip.s_port -d d_ip.d_port/n", name);
}

============================ cut here ============================

/* Example 2 [link layer api - ICMP_MASK] */
/* gcc -Wall `libnet-config --defines` libnet-example-x.c -o libnet-example-x `libnet-config --libs` */

#include <libnet.h></libnet.h>

void usage(char *);

u_char enet_src[6] = {0x0d, 0x0e, 0x0a, 0x0d, 0x00, 0x00};
u_char enet_dst[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};

int
main(int argc, char *argv[])
{
int packet_size, /* size of our packet */
c; /* misc */
u_long src_ip, dst_ip; /* source ip, dest ip */
u_char *packet; /* pointer to our packet buffer */
char err_buf[LIBNET_ERRBUF_SIZE]; /* error buffer */
u_char *device; /* pointer to the device to use */
struct libnet_link_int *network; /* pointer to link interface struct */

printf("libnet example code:/tmodule 2/n/n");
printf("packet injection interface:/tlink layer/n");
printf("packet type:/t/t/tICMP net mask [no payload]/n");

device = NULL;
src_ip = 0;
dst_ip = 0;

while ((c = getopt(argc, argv, "i:d:s:")) != EOF)
{
switch (c)
{
case 'd':
if (!(dst_ip = libnet_name_resolve(optarg, LIBNET_RESOLVE)))
{
libnet_error(LIBNET_ERR_FATAL,
"Bad destination IP address: %s/n", optarg);

if (!src_ip || !dst_ip)
{
usage(argv[0]);
exit(EXIT_FAILURE);
}

if ((network = libnet_open_link_interface(device, err_buf)) == NULL)
{
libnet_error(LIBNET_ERR_FATAL,
"libnet_open_link_interface: %s/n", err_buf);
}

/*
* We're going to build an ICMP packet with no payload using the
* link-layer API, so this time we need memory for a ethernet header
* as well as memory for the ICMP and IP headers.
*/
packet_size = LIBNET_IP_H + LIBNET_ETH_H + LIBNET_ICMP_MASK_H;

/*
* Step 2: Memory Initialization (interchangable with step 1).
*/
if (libnet_init_packet(packet_size, &packet) == -1)
{
libnet_error(LIBNET_ERR_FATAL, "libnet_init_packet failed/n");
}

/*
* Step 3: Packet construction (ethernet header).
*/
libnet_build_ethernet(enet_dst,
enet_src,
ETHERTYPE_IP,
NULL,
0,
packet);

/*
* Step 3: Packet construction (ICMP header).
*/
libnet_build_icmp_mask(ICMP_MASKREPLY, /* type */
0, /* code */
242, /* id */
0, /* seq */
0xffffffff, /* mask */
NULL, /* payload */
0, /* payload_s */
packet + LIBNET_ETH_H + LIBNET_IP_H);

/*
* Step 3: Packet construction (IP header).
*/
libnet_build_ip(ICMP_MASK_H,
0, /* IP tos */
242, /* IP ID */
0, /* Frag */
64, /* TTL */
IPPROTO_ICMP, /* Transport protocol */
src_ip, /* Source IP */
dst_ip, /* Destination IP */
NULL, /* Pointer to payload (none) */
0,
packet + LIBNET_ETH_H); /* Packet header memory */

/*
* Step 4: Packet checksums (ICMP header *AND* IP header).
*/
if (libnet_do_checksum(packet + ETH_H, IPPROTO_ICMP, LIBNET_ICMP_MASK_H) == -1)
{
libnet_error(LIBNET_ERR_FATAL, "libnet_do_checksum failed/n");
}
if (libnet_do_checksum(packet + ETH_H, IPPROTO_IP, LIBNET_IP_H) == -1)
{
libnet_error(LIBNET_ERR_FATAL, "libnet_do_checksum failed/n");
}

/*
* Shut down the interface.
*/
if (libnet_close_link_interface(network) == -1)
{
libnet_error(LN_ERR_WARNING,
"libnet_close_link_interface couldn't close the interface");
}

/*
* Free packet memory.
*/
libnet_destroy_packet(&packet);

return (c == -1 ? EXIT_FAILURE : EXIT_SUCCESS);
}

void usage(char *name)
{
fprintf(stderr, "usage: %s [-i interface] -s s_ip -d d_ip/n", name);
}

============================ cut here ============================

/* Example 3 [raw socket api - ICMP_ECHO using an arena] */
/* gcc -Wall `libnet-config --defines` libnet-example-x.c -o libnet-example-x /
`libnet-config --libs` */

#include <libnet.h></libnet.h>

void usage(char *);

int main(int argc, char **argv)
{
int network, n, c, number_of_packets, packet_size;
struct libnet_arena arena, *arena_p;
u_char *packets[10];
u_long src_ip, dst_ip;

printf("libnet example code:/tmodule 3/n/n");
printf("packet injection interface:/tlink layer/n");
printf("packet type:/t/t/tICMP_ECHO [no payload] using an arena/n");

src_ip = 0;
dst_ip = 0;
while((c = getopt(argc, argv, "d:s:")) != EOF)
{
switch (c)
{
case 'd':
if (!(dst_ip = libnet_name_resolve(optarg, LIBNET_RESOLVE)))
{
libnet_error(LIBNET_ERR_FATAL,
"Bad destination IP address: %s/n", optarg);
}
break;
case 's':
if (!(src_ip = libnet_name_resolve(optarg, LIBNET_RESOLVE)))
{
libnet_error(LIBNET_ERR_FATAL,
"Bad source IP address: %s/n", optarg);
}
break;
}
}
if (!src_ip || !dst_ip)
{
usage(argv[0]);
exit(EXIT_FAILURE);
}

/*
* We're just going to build an ICMP packet with no payload using the
* raw sockets API, so we only need memory for a ICMP header and an IP
* header.
*/
packet_size = LIBNET_IP_H + LIBNET_ICMP_ECHO_H;

/*
* Let's just build say, 10 packets.
*/
number_of_packets = 10;

arena_p = &arena;
if (libnet_init_packet_arena(&arena_p, number_of_packets, packet_size) == -1)
{
libnet_error(LIBNET_ERR_FATAL, "libnet_init_packet_arena failed/n");
}
else
{
printf("Allocated an arena of %ld bytes../n",
LIBNET_GET_ARENA_SIZE(arena));
}

network = libnet_open_raw_sock(IPPROTO_RAW);
if (network == -1)
{
libnet_error(LIBNET_ERR_FATAL, "Can't open the network./n");
}

for (n = 0; n {
printf("%ld bytes remaining in arena/n",
LIBNET_GET_ARENA_REMAINING_BYTES(arena));
packets[n] = libnet_next_packet_from_arena(&arena_p, packet_size);
if (!packets[n])
{
libnet_error(LIBNET_ERR_WARNING, "Arena is empty/n");
continue;
}

libnet_build_ip(ICMP_ECHO_H, /* Size of the payload */
IPTOS_LOWDELAY | IPTOS_THROUGHPUT, /* IP tos */
242, /* IP ID */
0, /* frag stuff */
48, /* TTL */
IPPROTO_ICMP, /* transport protocol */
src_ip, /* source IP */
dst_ip, /* destination IP */
NULL, /* pointer to payload */
0, /* payload length */
packets[n]); /* packet header memory */

libnet_build_icmp_echo(ICMP_ECHO, /* type */
0, /* code */
242, /* id */
5, /* seq */
NULL, /* pointer to payload */
0, /* payload length */
packets[n] + LIBNET_IP_H); /* packet header memory */

if (libnet_do_checksum(packets[n], IPPROTO_ICMP, LIBNET_ICMP_ECHO_H) == -1)
{
libnet_error(LIBNET_ERR_FATAL, "libnet_do_checksum failed/n");
}

c = libnet_write_ip(network, packets[n], packet_size);
if (c {
libnet_error(LN_ERR_WARNING,
"libnet_write_ip only wrote %d bytes/n", c);
}
else
{
printf("construction and injection of packet %d of %d completed, wrote all %d bytes/n",
n + 1, number_of_packets, c);
}
}

libnet_destroy_packet_arena(&arena_p);
return (c == -1 ? EXIT_FAILURE : EXIT_SUCCESS);
}

void usage(char *name)
{
fprintf(stderr, "usage: %s -s source_ip -d destination_ip/n ", name);
}

============================ cut here ============================

/* Example 4 [link-layer api - UDP packet using port list chaining] */
/* gcc -Wall `libnet-config --defines` libnet-example-x.c -o libnet-example-x /
`libnet-config --libs` */

#include <libnet.h></libnet.h>

#define MAX_PAYLOAD_SIZE 1024

void usage(char *);

u_char enet_src[6] = {0x0d, 0x0e, 0x0a, 0x0d, 0x00, 0x00};
u_char enet_dst[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};

int main(int argc, char *argv[])
{
int packet_size, /* size of our packet */
payload_size, /* size of our packet */
c; /* misc */
u_long src_ip, dst_ip; /* source ip, dest ip */
u_short bport, eport; /* beginning and end ports */
u_short cport; /* current port */
u_char payload[MAX_PAYLOAD_SIZE]; /* packet payload */
u_char *packet; /* pointer to our packet buffer */
char err_buf[LIBNET_ERRBUF_SIZE]; /* error buffer */
u_char *device; /* pointer to the device to use */
struct libnet_link_int *network; /* pointer to link interface struct */
struct libnet_plist_chain plist; /* plist chain */
struct libnet_plist_chain *plist_p; /* plist chain pointer */

printf("libnet example code:/tmodule 4/n/n");
printf("packet injection interface:/tlink layer/n");
printf("packet type:/t/t/tUDP [with payload] using port list chaining/n");

plist_p = NULL;
device = NULL;
src_ip = 0;
dst_ip = 0;

while ((c = getopt(argc, argv, "i:d:s:p:")) != EOF)
{
switch (c)
{
case 'd':
if (!(dst_ip = libnet_name_resolve(optarg, LIBNET_RESOLVE)))
{
libnet_error(LIBNET_ERR_FATAL,
"Bad destination IP address: %s/n", optarg);

}
break;
case 'i':
device = optarg;
break;
case 's':
if (!(src_ip = libnet_name_resolve(optarg, LIBNET_RESOLVE)))
{
libnet_error(LIBNET_ERR_FATAL,
"Bad source IP address: %s/n", optarg);
}
break;
case 'p':
plist_p = &plist;
if (libnet_plist_chain_new(&plist_p, optarg) == -1)
{
libnet_error(LIBNET_ERR_FATAL,
"Could not build port list/n");
}
break;
default:
usage(argv[0]);
exit(EXIT_FAILURE);
}
}

if (!src_ip || !dst_ip || !plist_p)
{
usage(argv[0]);
exit(EXIT_FAILURE);
}

c = argc - optind;
if (c != 1)
{
usage(argv[0]);
exit(EXIT_FAILURE);
}
memset(payload, 0, sizeof(payload));
strncpy(payload, argv[optind], strlen(argv[optind]));

/*
* Step 1: Network Initialization (interchangable with step 2).
*/
if (device == NULL)
{
struct sockaddr_in sin;
/*
* Try to locate a device.
*/
if (libnet_select_device(&sin, &device, err_buf) == -1)
{
libnet_error(LIBNET_ERR_FATAL,
"libnet_select_device failed: %s/n", err_buf);
}
printf("device:/t/t/t/t%s/n", device);
}
if ((network = libnet_open_link_interface(device, err_buf)) == NULL)
{
libnet_error(LIBNET_ERR_FATAL,
"libnet_open_link_interface: %s/n", err_buf);
}

/*
* Get the payload from the user. Hrm. This might fail on a Sparc
* if byte alignment is off...
*/
payload_size = strlen(payload);

/*
* We're going to build a UDP packet with a payload using the
* link-layer API, so this time we need memory for a ethernet header
* as well as memory for the ICMP and IP headers and our payload.
*/
packet_size = LIBNET_IP_H + LIBNET_ETH_H + LIBNET_UDP_H + payload_size;

/*
* Step 2: Memory Initialization (interchangable with step 1).
*/
if (libnet_init_packet(packet_size, &packet) == -1)
{
libnet_error(LIBNET_ERR_FATAL, "libnet_init_packet failed/n");
}

/*
* Step 3: Packet construction (ethernet header).
*/
libnet_build_ethernet(enet_dst,
enet_src,
ETHERTYPE_IP,
NULL,
0,
packet);

/*
* Step 3: Packet construction (IP header).
*/
libnet_build_ip(LIBNET_UDP_H + payload_size,
0, /* IP tos */
242, /* IP ID */
0, /* Frag */
64, /* TTL */
IPPROTO_UDP, /* Transport protocol */
src_ip, /* Source IP */
dst_ip, /* Destination IP */
NULL, /* Pointer to payload (none) */
0,
packet + LIBNET_ETH_H); /* Packet header memory */

while (libnet_plist_chain_next_pair(plist_p, &bport, &eport))
{

while (!(bport > eport) && bport != 0)
{
cport = bport++;
/*
* Step 3: Packet construction (UDP header).
*/
libnet_build_udp(242, /* source port */
cport, /* dest. port */
payload, /* payload */
payload_size, /* payload length */
packet + LIBNET_ETH_H + LIBNET_IP_H);

/*
* Step 4: Packet checksums (ICMP header *AND* IP header).
*/
if (libnet_do_checksum(packet + ETH_H, IPPROTO_UDP, LIBNET_UDP_H + payload_size) == -1)
{
libnet_error(LIBNET_ERR_FATAL, "libnet_do_checksum failed/n");
}
if (libnet_do_checksum(packet + ETH_H, IPPROTO_IP, LIBNET_IP_H) == -1)
{
libnet_error(LIBNET_ERR_FATAL, "libnet_do_checksum failed/n");
}

/*
* Step 5: Packet injection.
*/
c = libnet_write_link_layer(network, device, packet, packet_size);
if (c {
libnet_error(LN_ERR_WARNING,
"libnet_write_link_layer only wrote %d bytes/n", c);
}
else
{
printf("construction and injection completed, wrote all %d bytes, port %d/n",
c, cport);
}
}
}
/*
* Shut down the interface.
*/
if (libnet_close_link_interface(network) == -1)
{
libnet_error(LN_ERR_WARNING,
"libnet_close_link_interface couldn't close the interface");
}

/*
* Free packet memory.
*/
libnet_destroy_packet(&packet);

return (c == -1 ? EXIT_FAILURE : EXIT_SUCCESS);
}

void usage(char *name)
{
fprintf(stderr, "usage: %s [-i interface] -s s_ip -d d_ip -p port list payload/n", name);
}

---[[ libpcap ]]------------------------------------------

　　libpcap的英文意思是 Packet Capturelibrary，即数据包捕获函数库。该库提供的C函数接口可用于需要捕获经过网络接口（只要经过该接口，目标地址不一定为本机）数据包的系统开发上。由Berkeley大学Lawrence Berkeley National Laboratory研究院的Van Jacobson、CraigLeres和Steven McCanne编写，目前的最新版本为0.4。该函数库支持Linux、Solaris和*BSD系统平台。

　　主要接口函数说明如下：

pcap_t *pcap_open_live(char *device, int snaplen,
int promisc, int to_ms, char *ebuf)

获得用于捕获网络数据包的数据包捕获描述字。device参数为指定打开
的网络设备名。snaplen参数定义捕获数据的最大字节数。promisc指定
是否将网络接口置于混杂模式。to_ms参数指定超时时间（毫秒）。
ebuf参数则仅在pcap_open_live()函数出错返回NULL时用于传递错误消
息。

pcap_t *pcap_open_offline(char *fname, char *ebuf)

打开以前保存捕获数据包的文件，用于读取。fname参数指定打开的文
件名。该文件中的数据格式与tcpdump和tcpslice兼容。"-"为标准输
入。ebuf参数则仅在pcap_open_offline()函数出错返回NULL时用于传
递错误消息。

pcap_dumper_t *pcap_dump_open(pcap_t *p, char *fname)

打开用于保存捕获数据包的文件，用于写入。fname参数为"-"时表示
标准输出。出错时返回NULL。p参数为调用pcap_open_offline()或
pcap_open_live()函数后返回的pcap结构指针。fname参数指定打开
的文件名。如果返回NULL，则可调用pcap_geterr()函数获取错误消
息。

char *pcap_lookupdev(char *errbuf)

用于返回可被pcap_open_live()或pcap_lookupnet()函数调用的网络
设备名指针。如果函数出错，则返回NULL，同时errbuf中存放相关的
错误消息。

int pcap_lookupnet(char *device, bpf_u_int32 *netp,
bpf_u_int32 *maskp, char *errbuf)

获得指定网络设备的网络号和掩码。netp参数和maskp参数都是
bpf_u_int32指针。如果函数出错，则返回-1，同时errbuf中存放相
关的错误消息。

int pcap_dispatch(pcap_t *p, int cnt,
pcap_handler callback, u_char *user)

捕获并处理数据包。cnt参数指定函数返回前所处理数据包的最大值。
cnt=-1表示在一个缓冲区中处理所有的数据包。cnt=0表示处理所有
数据包，直到产生以下错误之一：读取到EOF；超时读取。callback
参数指定一个带有三个参数的回调函数，这三个参数为：一个从
pcap_dispatch()函数传递过来的u_char指针，一个pcap_pkthdr结构
的指针，和一个数据包大小的u_char指针。如果成功则返回读取到的
字节数。读取到EOF时则返回零值。出错时则返回-1，此时可调用
pcap_perror()或pcap_geterr()函数获取错误消息。

int pcap_loop(pcap_t *p, int cnt,
pcap_handler callback, u_char *user)

功能基本与pcap_dispatch()函数相同，只不过此函数在cnt个数据包
被处理或出现错误时才返回，但读取超时不会返回。而如果为
pcap_open_live()函数指定了一个非零值的超时设置，然后调用
pcap_dispatch()函数，则当超时发生时pcap_dispatch()函数会返回。
cnt参数为负值时pcap_loop()函数将始终循环运行，除非出现错误。

void pcap_dump(u_char *user, struct pcap_pkthdr *h,
u_char *sp)

向调用pcap_dump_open()函数打开的文件输出一个数据包。该函数可
作为pcap_dispatch()函数的回调函数。

int pcap_compile(pcap_t *p, struct bpf_program *fp,
char *str, int optimize, bpf_u_int32 netmask)

将str参数指定的字符串编译到过滤程序中。fp是一个bpf_program结
构的指针，在pcap_compile()函数中被赋值。optimize参数控制结果
代码的优化。netmask参数指定本地网络的网络掩码。

int pcap_setfilter(pcap_t *p, struct bpf_program *fp)

指定一个过滤程序。fp参数是bpf_program结构指针，通常取自
pcap_compile()函数调用。出错时返回-1；成功时返回0。

u_char *pcap_next(pcap_t *p, struct pcap_pkthdr *h)

返回指向下一个数据包的u_char指针。

int pcap_datalink(pcap_t *p)

返回数据链路层类型，例如DLT_EN10MB。

int pcap_snapshot(pcap_t *p)

返回pcap_open_live被调用后的snapshot参数值。

int pcap_is_swapped(pcap_t *p)

返回当前系统主机字节与被打开文件的字节顺序是否不同。

int pcap_major_version(pcap_t *p)

返回写入被打开文件所使用的pcap函数的主版本号。

int pcap_minor_version(pcap_t *p)

返回写入被打开文件所使用的pcap函数的辅版本号。

int pcap_stats(pcap_t *p, struct pcap_stat *ps)

向pcap_stat结构赋值。成功时返回0。这些数值包括了从开始
捕获数据以来至今共捕获到的数据包统计。如果出错或不支持
数据包统计，则返回-1，且可调用pcap_perror()或
pcap_geterr()函数来获取错误消息。

FILE *pcap_file(pcap_t *p)

返回被打开文件的文件名。

int pcap_fileno(pcap_t *p)

返回被打开文件的文件描述字号码。

void pcap_perror(pcap_t *p, char *prefix)

在标准输出设备上显示最后一个pcap库错误消息。以prefix参
数指定的字符串为消息头。

char *pcap_geterr(pcap_t *p)

返回最后一个pcap库错误消息。

char *pcap_strerror(int error)

如果strerror()函数不可用，则可调用pcap_strerror函数替代。

void pcap_close(pcap_t *p)

关闭p参数相应的文件，并释放资源。

void pcap_dump_close(pcap_dumper_t *p)

关闭相应的被打开文件。

---[[ libnids ]]------------------------------------------

一、简介

libnids的英文意思是 Network Intrusion Detect System library，即网络入侵监测系统函数库。它是在前面介绍的两种C函数接口库libnet和libpcap的基础上开发的，封装了开发NIDS所需的许多通用型函数。linids提供的接口函数监视流经本地的所有网络通信，检查数据包等。除此之外，还具有重组TCP数据段、处理IP分片包和监测TCP端口扫描的功能。利用libnids接口函数库，NIDS开发者不需要再编写底层的网络处理代码，只需专注于NIDS本身功能的实现即可。
libnids支持Linux、Solaris和*BSD系统平台，目前最新版本为1.13。

二、IP分片数据包

为了使libnids能接收所有的IP数据包(包括分片包、畸形包等)，程序员需要定义如下的回调函数：

void ip_frag_func(struct ip * a_packet)

在调用nids_init()函数初始化后，使用nids的函数进行注册：

nids_register_ip_frag(ip_frag_func);

这样回调函数ip_frag_func会在适当的时候由libnids调用，参数a_packet指针将指向接收到的数据报。
类似地，如果仅接收目标主机会接受的数据包(如非碎片包、重组包或头部校验正确的数据包等)，需要定义如下回调函数：

void ip_func(struct ip * a_packet)

然后注册：

nids_register_ip(ip_func);

三、TCP数据流重组

要接收TCP流在交换的数据，必须定义如下回调函数：

void tcp_callback(struct tcp_stream * ns, void ** param)

tcp_stream结构提供了一个TCP连接的所有信息。例如，它包含了客户端与服务器端的half_stream结构。下文会对该结构的字段进行解释。
tcp_stream结构有一个名为nids_state的字段。此字段的数值将决定tcp_callback的操作。

(a) ns->nids_state==NIDS_JUST_EST时，ns表示一个刚刚建立的连接。
tcp_callback可以据此决定是否对该连接的后续数据进行检查。如
需要检查，tcp_callback回调函数将通知libnids它希望接收哪些
数据(如到客户端的数据、到服务器端的数据、到客户端的紧急数
据或到服务器端的紧急数据等)，然后返回。
(b) ns->nids_state==NIDS_DATA时，表示ns连接接收到新的数据。
half_stream结构中的缓冲区用于存放这些数据。
(c) nids_state字段为其它数值(NIDS_CLOSE、NIDS_RESET、
NIDS_TIMEOUT)时，表示该连接已经关闭了。tcp_callback函数应
释放相关资源。

四、一个简单的实例

下面的源代码是一个非常简单的程序，它将libnids捕获的所有TCP连接交换的数据输出显示到标准输出设备上。

-----------------------BEGINING OF CODE--------------------------------

#include "nids.h"
#include <string.h> #include <stdio.h></stdio.h></string.h>

extern char * inet_ntoa(unsigned long);

// tuple4结构包含了TCP连接两端的IP地址和端口，以下函数将它们转换为字符串
// 格式，如10.0.0.1,1024, 10.0.0.2,23
char *
adres (struct tuple4 addr)
{
static char buf[256];
strcpy (buf, inet_ntoa (addr.saddr));
sprintf (buf + strlen (buf), ",%i,", addr.source);
strcat (buf, inet_ntoa (addr.daddr));
sprintf (buf + strlen (buf), ",%i", addr.dest);
return buf;
}

void
tcp_callback (struct tcp_stream *a_tcp, void ** this_time_not_needed)
{
char buf[1024];
strcpy (buf, adres (a_tcp->addr)); // we put conn params into buf
if (a_tcp->nids_state == NIDS_JUST_EST)
{
// a_tcp所定义的连接已经建立。此处可视程序需要添加额外
// 的判断处理。如if (a_tcp->addr.dest != 23) return;表
// 示不处理目标端口为23的数据包。
// 本例需要处理(显示)所有数据包，故：
a_tcp->client.collect++; // 需要处理客户端接收的数据
a_tcp->server.collect++; // 和服务器端接收的数据
a_tcp->server.collect_urg++; // 需要处理服务器端接收的紧急数据
#ifdef WE_WANT_URGENT_DATA_RECEIVED_BY_A_CLIENT
a_tcp->client.collect_urg++; // 需要处理客户端接收的紧急数据
// (打开编译选项才有效)
#endif
fprintf (stderr, "%s established/n", buf);
return;
}
if (a_tcp->nids_state == NIDS_CLOSE)
{
// TCP连接正常关闭
fprintf (stderr, "%s closing/n", buf);
return;
}
if (a_tcp->nids_state == NIDS_RESET)
{
// TCP连接因RST数据包而关闭
fprintf (stderr, "%s reset/n", buf);
return;
}

if (a_tcp->nids_state == NIDS_DATA)
{
// 接收到新数据，下面判断决定是否显示

struct half_stream *hlf;

if (a_tcp->server.count_new_urg)
{
// 服务器端接收的紧急数据
strcat(buf,"(urgent->)");
buf[strlen(buf)+1]=0;
buf[strlen(buf)]=a_tcp->server.urgdata;
write(1,buf,strlen(buf));
return;
}

#ifdef WE_WANT_URGENT_DATA_RECEIVED_BY_A_CLIENT
if (a_tcp->client.count_new_urg)
{
// 客户端接收的紧急数据
strcat(buf,"(urgent->)");
buf[strlen(buf)+1]=0;
buf[strlen(buf)]=a_tcp->server.urgdata;
write(1,buf,strlen(buf));
return;
}
#endif

if (a_tcp->client.count_new)
{
// 客户端接收的数据
hlf = &a_tcp->client; // 准备显示客户端接收的数据
strcat (buf, "( }
else
{
hlf = &a_tcp->server; // 准备显示服务器端接收的数据
strcat (buf, "(->)"); // 指示数据流方向
}
fprintf(stderr,"%s",buf); // 首先输出显示连接双方的IP地址、端口
// 和数据流方向

write(2,hlf->data,hlf->count_new); // 输出显示接收到的新数据

}
return ;
}

int
main ()
{
// 此处可自定义libnids的全局变量，如：
// nids_params.n_hosts=256;
if (!nids_init () )
{
fprintf(stderr,"%s/n",nids_errbuf);
exit(1);
}
nids_register_tcp (tcp_callback);
nids_run ();
// NOT REACHED
return 0;
}

---------------------------END OF CODE------------------------------------

五、libnids的数据结构及接口函数

libnids库的所有数据结构及接口函数都在"nids.h"头文件中声明。

struct tuple4 // TCP连接参数
{
unsigned short source,dest; // 客户端和服务器端的端口号
unsigned long saddr,daddr; // 客户端和服务器端的IP地址
};

struct half_stream // TCP连接一端的数据结构
{
char state; // 套接字状态(如TCP_ESTABLISHED)
char collect; // 如果大于0，则保存其数据到缓冲区中，否则忽略
char collect_urg; // 如果大于0，则保存紧急数据，否则忽略
char * data; // 正常数据的缓冲区
unsigned char urgdata; // 紧急数据缓冲区
int count; // 自从连接建立以来保存到"data"缓冲区的数据字节
// 数总和
int offset; // 保存到"data"缓冲区的首字节数据偏移量
int count_new; // 最近一次接收到的数据字节数；如果为0，则无数
// 到达
char count_new_urg; // 如果非0，表示有新的紧急数据到达

... // libnids库使用的辅助字段

};

struct tcp_stream
{
struct tuple4 addr; // TCP连接参数(saddr, daddr, sport, dport)
char nids_state; // TCP连接的逻辑状态
struct half_stream client,server; // 描述客户端与服务器端的数据结构
... // libnids库使用的辅助字段
};

在上面的实例程序中，回调函数tcp_callback输出显示hlf->data缓冲区中的数据到标准输出设备上。这些数据在tcp_callback函数返回后，由libnids自动释放这些数据所占用的内存空间。同时，hlf->offset字段将增加被丢弃数据的字节数，而新接收到的数据则存放到"data"缓冲区的起始处。
如果在其它应用中不进行如上例的操作(例如，数据处理过程至少需要N个字节的输入数据，而libnids只接收到的数据字节数count_new<n> void nids_discard(struct tcp_stream * a_tcp, int num_bytes) 此时，当回调函数tcp_callback返回后linids将"data"缓冲区的前num_bytes字节数据，同时计算调整offset字段的数值，并将剩余数据移动到缓冲区的起始处。 如果始终不调用nids_discard()函数(如上面实例)，hlf->data缓冲区中将包含hlf->count_new字节数据。通常情况下，在hlf->data缓冲区中的数据字节数等于hlf->count - hlf->offset。 有了nids_discard()函数，程序员就不必拷贝接收到的数据到另外的缓冲区中，hlf->data缓冲区将总是尽可能保存足够的数据。然后，有时会有保留数据包特定数据的需要。例如，我们希望能监测到针对wu-ftpd服务器的"CWD"溢出攻击，就需要跟踪检查ftp客户端发送的"CWD"命令。此时就需要tcp_callback回调函数具有第二个参数了。此参数是某TCP连接私有数据的指针。处理过程如下： void tcp_callback_2 (struct tcp_stream * a_tcp, struct conn_param **ptr) { if (a_tcp->nids_state==NIDS_JUST_EST) { struct conn_param * a_conn; if the connection is uninteresting, return; a_conn=malloc of some data structure init of a_conn *ptr=a_conn // this value will be passed to tcp_callback_2 in future // calls increase some of "collect" fields return; } if (a_tcp->nids_state==NIDS_DATA) { struct conn_param *current_conn_param=*ptr; using current_conn_param and the newly received data from the net we search for attack signatures, possibly modyfying current_conn_param return ; } ... } nids_register_tcp和nids_register_ip*函数可被任意次调用。在同一个TCP连接中使用两种不同的回调函数是允许的。 libnids库定义了一个全局变量结构nids_params，其声明如下： struct nids_prm { int n_tcp_streams; // 存放tcp_stream结构的hash表大小。 // 缺省值：1024 int n_hosts; // 存放IP分片信息的hash表大小 // 缺省值：256 char * device; // libnids监听的接口设备名 // 缺省值 == NULL，即由pcap_lookupdev函数确定 int sk_buff_size; // (Linux内核)sk_buff结构大小 // 缺省值：168 int dev_addon; // sk_buff为网络接口保留的字节数 // 如果dev_addon==-1，则由nids_init函数确定 // 缺省值：-1 void (*syslog)(); // 日志函数指针 int syslog_level; // 如果nids_params.syslog==nids_syslog，则此字段值 // 将确定日志等级loglevel // 缺省值：LOG_ALERT int scan_num_hosts;// 存放端口扫描信息的hash表大小。 // 如果为0，则关闭端口扫描监测功能。 // 缺省值：256 int scan_num_ports;// 来自同一IP地址所扫描的TCP端口数上限 // 缺省值：10 int scan_delay; // 在两次端口扫描中的间隔时间上限(毫秒) // 缺省值：3000 void (*no_mem)(); // 内存不足时被调用，此时应终止当前进程 int (*ip_filter)(struct ip*); // 当接收到一个IP数据包时调用。如返回值 // 非零，则处理该数据包，否则忽略。 // 缺省为(nids_ip_filter)且总返回1 char *pcap_filter; // 传递给pcap过滤器的字符串。 // 缺省值：NULL } nids_params; nids_params的syslog字段缺省时指向nids_syslog函数，声明如下： void nids_syslog (int type, int errnum, struct ip *iph, void *data); nids_params.syslog函数用于记录异常情况，如端口扫描企图，无效TCP头标志等。该字段应指向自定义的日志处理函数。nids_syslog()仅作为一个例子。nids_syslog()函数向系统守护服务syslogd发送日志消息。 使用nids_run有一个缺陷：应用程序将完全由数据包驱动(运行)。有时需要在没有数据包到达时也能处理一些任务，则作为nids_run()函数的替代，程序员可使用如下函数： int nids_next() 此函数将调用pcap_next()函数(而不是pcap_loop()函数)。(详细资料请参阅《网络安全工具开发函数库介绍之二 ——libpcap》。) nids_next()函数成功时返回1，出错时返回0，且nids_errbuf缓冲区存放相应错误消息。 典型地，当使用nids_next()函数时，应用程序调用I/O复用函数select()阻塞，监听套接字fd在“读”描述字集合fd_set中设置。该套接字可通过如下函数获得： int nids_getfd() 成功时返回一个文件描述字，出错时返回-1，且nids_errbuf缓冲区存放相应错误消息。 ---[[ libnids应用实例 ]]---------------------------------- 1、nids_next()函数的应用 ============================ cut here ============================ /* This is an example how one can use nids_getfd() and nids_next() functions. You can replace printall.c's function main with this file. */ #include <sys> #include <sys> #include <unistd.h></unistd.h></sys></sys> int main () { // here we can alter libnids params, for instance: // nids_params.n_hosts=256; int fd; int time = 0; fd_set rset; struct timeval tv; if (!nids_init ()) { fprintf(stderr,"%s/n",nids_errbuf); exit(1); } nids_register_tcp (tcp_callback); fd = nids_getfd (); for (;;) { tv.tv_sec = 1; tv.tv_usec = 0; FD_ZERO (&rset); FD_SET (fd, &rset); // add any other fd we need to take care of if (select (fd + 1, &rset, 0, 0, &tv)) { if (FD_ISSET(fd,&rset) // need to test it if there are other // fd in rset if (!nids_next ()) break; } else fprintf (stderr, "%i ", time++); } return 0; } ============================ cut here ============================ 2、Simple sniffer ============================ cut here ============================ /* Copyright (c) 1999 Rafal Wojtczuk nergal@avet.com.pl>. All rights reserved. See the file COPYING for license details. */ #include <sys> #include <sys> #include <netinet> #include <netinet> #include <arpa> #include <stdio.h> #include <fcntl.h> #include "nids.h"</fcntl.h></stdio.h></arpa></netinet></netinet></sys></sys> #define LOG_MAX 100 #define SZLACZEK "/n--------------------------------------------------/n" #define int_ntoa(x) inet_ntoa(*((struct in_addr *)&x)) char * adres (struct tuple4 addr) { static char buf[256]; strcpy (buf, int_ntoa (addr.saddr)); sprintf (buf + strlen (buf), ",%i,", addr.source); strcat (buf, int_ntoa (addr.daddr)); sprintf (buf + strlen (buf), ",%i : ", addr.dest); return buf; } int logfd; void do_log (char *adres_txt, char *data, int ile) { write (logfd, adres_txt, strlen (adres_txt)); write (logfd, data, ile); write (logfd, SZLACZEK, strlen (SZLACZEK)); } void sniff_callback (struct tcp_stream *a_tcp, void **this_time_not_needed) { int dest; if (a_tcp->nids_state == NIDS_JUST_EST) { dest = a_tcp->addr.dest; if (dest == 21 || dest == 23 || dest == 110 || dest == 143 || dest == 513) a_tcp->server.collect++; return; } if (a_tcp->nids_state != NIDS_DATA) { // seems the stream is closing, log as much as possible do_log (adres (a_tcp->addr), a_tcp->server.data, a_tcp->server.count - a_tcp->server.offset); return; } if (a_tcp->server.count - a_tcp->server.offset { // we haven't got enough data yet; keep all of it nids_discard (a_tcp, 0); return; } // enough data do_log (adres (a_tcp->addr), a_tcp->server.data, LOG_MAX); // Now procedure sniff_callback doesn't want to see this stream anymore. // So, we decrease all the "collect" fields we have previously increased. // If there were other callbacks following a_tcp stream, they would still // receive data a_tcp->server.collect--; } int main () { logfd = open ("./logfile", O_WRONLY | O_CREAT | O_TRUNC, 0600); if (logfd { perror ("opening ./logfile:"); exit (1); } if (!nids_init ()) { fprintf (stderr, "%s/n", nids_errbuf); exit (1); } nids_register_tcp (sniff_callback); nids_run (); return 0; } ============================ cut here ============================ 3、Wu-FTPd overflow attack detector ============================ cut here ============================ /* Copyright (c) 1999 Rafal Wojtczuk nergal@avet.com.pl>. All rights reserved. See the file COPYING for license details. */ /* This code attempts to detect attack against imapd (AUTHENTICATE hole) and wuftpd (creation of deep directory). This code is to ilustrate use of libnids; in order to improve readability, some simplifications were made, which enables an attacker to bypass this code (note, the below routines should be improved, not libnids) */ #include <sys> #include <sys> #include <netinet> #include <netinet> #include <arpa> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <syslog.h> #include "nids.h"</syslog.h></string.h></stdlib.h></stdio.h></arpa></netinet></netinet></sys></sys> #define int_ntoa(x) inet_ntoa(*((struct in_addr *)&x)) char * adres (struct tuple4 addr) { static char buf[256]; strcpy (buf, int_ntoa (addr.saddr)); sprintf (buf + strlen (buf), ",%i,", addr.source); strcat (buf, int_ntoa (addr.daddr)); sprintf (buf + strlen (buf), ",%i", addr.dest); return buf; } /* if we find a pattern AUTHENTICATE {an_int} in data stream sent to an imap server, where an_int >1024, it means an buffer overflow attempt. We kill the connection. */ #define PATTERN "AUTHENTICATE {" #define PATLEN strlen(PATTERN) void detect_imap (struct tcp_stream *a_tcp) { char numbuf[30]; int i, j, datalen, numberlen; struct half_stream *hlf; if (a_tcp->nids_state == NIDS_JUST_EST) { if (a_tcp->addr.dest == 143) { a_tcp->server.collect++; return; } else return; } if (a_tcp->nids_state != NIDS_DATA) return; hlf = &a_tcp->server; datalen = hlf->count - hlf->offset; if (datalen { // we have too small amount of data to work on. Keep all data in buffer. nids_discard (a_tcp, 0); return; } for (i = 0; i if (!memcmp (PATTERN, hlf->data + i, PATLEN)) //searching for a pattern break; if (i > datalen - PATLEN) { // retain PATLEN bytes in buffer nids_discard (a_tcp, datalen - PATLEN); return; } for (j = i + PATLEN; j if (*(hlf->data + j) == '}') break; if (j > datalen) { if (datalen > 20) { //number too long, perhaps we should log it, too } return; } numberlen = j - i - PATLEN; memcpy (numbuf, hlf->data + i + PATLEN, numberlen); //numbuf contains // AUTH argument numbuf[numberlen] = 0; if (atoi (numbuf) > 1024) { // notify admin syslog(nids_params.syslog_level, "Imapd exploit attempt, connection %s/n",adres(a_tcp->addr)); // kill the connection nids_killtcp (a_tcp); } nids_discard (a_tcp, datalen - PATLEN); return; } // auxiliary structure, needed to keep current dir of ftpd daemon struct supp { char *currdir; int last_newline; }; // the below function adds "elem" string to "path" string, taking care of // ".." and multiple '/'. If the resulting path is longer than 768, // return value is 1, otherwise 0 int add_to_path (char *path, char *elem, int len) { int plen; char * ptr; if (len > 768) return 1; if (len == 2 && elem[0] == '.' && elem[1] == '.') { ptr = rindex (path, '/'); if (ptr != path) *ptr = 0; } else if (len > 0) { plen = strlen (path); if (plen + len + 1 > 768) return 1; if (plen==1) { strncpy(path+1,elem,len); path[1+len]=0; } else { path[plen] = '/'; strncpy (path + plen + 1, elem, len); path[plen + 1 + len] = 0; } } return 0; } void do_detect_ftp (struct tcp_stream *a_tcp, struct supp **param_ptr) { struct supp *p = *param_ptr; int index = p->last_newline + 1; char *buf = a_tcp->server.data; int offset = a_tcp->server.offset; int n_bytes = a_tcp->server.count - offset; int path_index, pi2, index2, remcaret; for (;;) { index2 = index; while (index2 - offset index2++; if (index2 - offset >= n_bytes) break; if (!strncasecmp (buf + index - offset, "cwd ", 4)) { path_index = index + 4; if (buf[path_index - offset] == '/') { strcpy (p->currdir, "/"); path_index++; } for (;;) { pi2 = path_index; while (buf[pi2 - offset] != '/n' && buf[pi2 - offset] != '/') pi2++; if (buf[pi2-offset]=='/n' && buf[pi2-offset-1]=='/r') remcaret=1; else remcaret=0; if (add_to_path (p->currdir, buf + path_index-offset, pi2 - path_index-remcaret)) { // notify admin syslog(nids_params.syslog_level, "Ftpd exploit attempt, connection %s/n",adres(a_tcp->addr)); nids_killtcp (a_tcp); return; } if (buf[pi2 - offset] == '/n') break; path_index = pi2 + 1; } } index = index2 + 1; } p->last_newline = index - 1; nids_discard (a_tcp, index - offset); } void detect_ftpd (struct tcp_stream *a_tcp, struct supp **param) { if (a_tcp->nids_state == NIDS_JUST_EST) { if (a_tcp->addr.dest == 21) { struct supp *one_for_conn; a_tcp->server.collect++; one_for_conn = (struct supp *) malloc (sizeof (struct supp)); one_for_conn->currdir = malloc (1024); strcpy (one_for_conn->currdir, "/"); one_for_conn->last_newline = 0; *param=one_for_conn; } return; } if (a_tcp->nids_state != NIDS_DATA) { free ((*param)->currdir); free (*param); return; } do_detect_ftp (a_tcp, param); } int main () { if (!nids_init ()) { fprintf(stderr,"%s/n",nids_errbuf); exit(1); } nids_register_tcp (detect_imap); nids_register_tcp (detect_ftpd); nids_run (); return 0; } ============================ cut here ============================ >> libpcap使用举例 作者：小四 scz@nsfocus.com > 主页：<a href="http://www.nsfocus.com">http://www.nsfocus.com</a> 日期：2001-01-10 URL ：<a href="http://www.nsfocus.net/index.php?act=magazine&do=view&mid=760">http://www.nsfocus.net/index.php?act=magazine&do=view&mid=760</a> 我们曾经提供过>，比较详细地介绍了报文发送编程。始终 没有介绍libpcap报文捕捉编程的原因很多，tcpdump、snort等著名软件包都是基于 libpcap，加上W.Richard.Stevens的>第26章推 波助澜，实在觉得没有必要继续介绍libpcap编程。更真实的原因可能是BPF、DLPI、 SOCK_PACKET三种接口编程已经被演练得太多太滥。 今天讨论的不是效率，而是可能的移植性要求。没办法，第一次使用libpcap库，举 例能深入到什么地步，不知道。如果你也是第一次用这个库，跟我来，第N次使用？ 那还是忙你的去吧，别来看这篇无聊的灌水，:-P。我无聊是因为有程序要广泛可移 植，你无聊是为什么。 char * pcap_lookupdev ( char * errbuf ); 该函数返回一个网络设备接口名，类似libnet_select_device()，对于Linux就是 "eth0"一类的名字。pcap_open_live()、pcap_lookupnet()等函数将用到这个网络设 备接口名。失败时返回NULL，errbuf包含了失败原因。errbuf一般定义如下： /usr/include/pcap.h #define PCAP_ERRBUF_SIZE 256 char errbuf[ PCAP_ERRBUF_SIZE ]; pcap_t * pcap_open_live ( char * device, int snaplen, int promisc, int to_ms, char * errbuf ); 该函数用于获取一个抽象的包捕捉句柄，后续很多libpcap函数将使用该句柄，类似 文件操作函数频繁使用文件句柄。device指定网络接口设备名，比如"eth0。snaplen 指定单包最大捕捉字节数，为了保证包捕捉不至于太低效率，snaplen尽量适中，以 恰能获得所需协议层数据为准。promisc指定网络接口是否进入混杂模式，注意即使 该参数为false(0)，网络接口仍然有可能因为其他原因处在混杂模式。to_ms指定毫 秒级读超时，man手册上并没有指明什么值意味着永不超时，测试下来的结论，0可能 代表永不超时。如果调用失败返回NULL，errbuf包含失败原因。 -------------------------------------------------------------------------- /usr/include/pcap.h typedef struct pcap pcap_t; pcap-int.h里定义了struct pcap {} struct pcap { int fd; int snapshot; int linktype; int tzoff; /* timezone offset */ int offset; /* offset for proper alignment */ struct pcap_sf sf; struct pcap_md md; int bufsize; /* Read buffer */ u_char * buffer; u_char * bp; int cc; u_char * pkt; /* Place holder for pcap_next() */ struct bpf_program fcode; /* Placeholder for filter code if bpf not in kernel. */ char errbuf[PCAP_ERRBUF_SIZE]; }; -------------------------------------------------------------------------- int pcap_lookupnet ( char * device, bpf_u_int32 * netp, bpf_u_int32 * maskp, char * errbuf ); 该函数用于获取指定网络接口的IP地址、子网掩码。不要被netp的名字所迷惑，它对 应的就是IP地址，maskp对应子网掩码。 /usr/include/pcap.h typedef u_int bpf_u_int32; 显然简单理解成32-bit即可。如果调用失败则返回-1，errbuf包含失败原因。 int pcap_compile ( pcap_t * p, struct bpf_program * fp, char * str, int optimize, bpf_u_int32 netmask ); 该函数用于解析过滤规则串，填写bpf_program结构。str指向过滤规则串，格式参看 tcpdump的man手册，比如： tcpdump -x -vv -n -t ip proto <a href="file:////tcp">//tcp</a> and dst 192.168.8.90 and tcp[13] /& 2 = 2 这条过滤规则将捕捉所有携带SYN标志的到192.168.8.90的TCP报文。过滤规则串可以 是空串("")，表示抓取所有过路的报文。 optimize为1表示对过滤规则进行优化处理。netmask指定子网掩码，一般从 pcap_lookupnet()调用中获取。返回值小于零表示调用失败。 这个函数可能比较难于理解，涉及的概念源自BPF，Linux系统没有这种概念，但是 libpcap采用pcap_compile()和pcap_setfilter()结合的办法屏蔽了各种链路层支持 的不同，无论是SOCK_PACKET、DLPI。曾在华中Security版上写过一篇 >，参看该文加强理解。 -------------------------------------------------------------------------- # tcpdump -d ip proto <a href="file:////tcp">//tcp</a> and dst 192.168.8.90 and tcp[13] /& 2 = 2 (000) ldh [-4096] (001) jeq #0x800 jt 2 jf 13 (002) ldb [9] (003) jeq #0x6 jt 4 jf 13 (004) ld [16] (005) jeq #0xc0a8085a jt 6 jf 13 (006) ldh [6] (007) jset #0x1fff jt 13 jf 8 (008) ldxb 4*([0]&0xf) (009) ldb [x + 13] (010) and #0x2 (011) jeq #0x2 jt 12 jf 13 (012) ret #65535 (013) ret #0 # /usr/include/net/bpf.h /* Structure for BIOCSETF. */ struct bpf_program { u_int bf_len; struct bpf_insn * bf_insns; }; /* * The instruction data structure. */ struct bpf_insn { u_short code; u_char jt; u_char jf; bpf_int32 k; }; /* * Macros for insn array initializers. */ #define BPF_STMT(code, k) { (u_short)(code), 0, 0, k } #define BPF_JUMP(code, k, jt, jf) { (u_short)(code), jt, jf, k } -------------------------------------------------------------------------- int pcap_setfilter ( pcap_t * p, struct bpf_program * fp ); 该函数用于设置pcap_compile()解析完毕的过滤规则，如果你足够聪明(愚公？)，完 全可以自己提供过滤规则，无须pcap_compile()介入，就象你写 Password Sniffer For I386/FreeBSD时常做的那样。成功返回0，失败返回-1。 int pcap_dispatch ( pcap_t * p, int cnt, pcap_handler callback, u_char * user ); 该函数用于捕捉报文、分发报文到预先指定好的处理函数(回调函数)。 pcap_dispatch()接收够cnt个报文便返回，如果cnt为-1意味着所有报文集中在一个 缓冲区中。如果cnt为0，仅当发生错误、读取到EOF或者读超时到了(pcap_open_live 中指定)才停止捕捉报文并返回。callback指定如下类型的回调函数，用于处理 pcap_dispatch()所捕获的报文： typedef void ( *pcap_handler ) ( u_char *, const struct pcap_pkthdr *, const u_char * ); pcap_dispatch()返回捕捉到的报文个数，如果在读取静态文件(以前包捕捉过程中存 储下来的)时碰到EOF则返回0。返回-1表示发生错误，此时可以用pcap_perror()、 pcap_geterr()显示错误信息。 下面来看看那个回调函数，总共有三个参数，第一个形参来自pcap_dispatch()的第 三个形参，一般我们自己的包捕捉程序不需要提供它，总是为NULL。第二个形参指向 pcap_pkthdr结构，该结构位于真正的物理帧前面，用于消除不同链路层支持的差异。 最后的形参指向所捕获报文的物理帧。 -------------------------------------------------------------------------- /usr/include/pcap.h /* * Each packet in the dump file is prepended with this generic header. * This gets around the problem of different headers for different * packet interfaces. */ struct pcap_pkthdr { struct timeval ts; /* time stamp */ bpf_u_int32 caplen; /* length of portion present */ bpf_u_int32 len; /* length this packet (off wire) */ }; /usr/include/net/bpf.h /* * Structure prepended to each packet. */ struct bpf_hdr { struct timeval bh_tstamp; /* time stamp */ bpf_u_int32 bh_caplen; /* length of captured portion */ bpf_u_int32 bh_datalen; /* original length of packet */ u_short bh_hdrlen; /* length of bpf header (this struct plus alignment padding) */ }; /* * Because the structure above is not a multiple of 4 bytes, some compilers * will insist on inserting padding; hence, sizeof(struct bpf_hdr) won't work. * Only the kernel needs to know about it; applications use bh_hdrlen. */ #ifdef KERNEL #define SIZEOF_BPF_HDR 18 #endif -------------------------------------------------------------------------- void pcap_close ( pcap_t * p ); 该函数用于关闭pcap_open_live()获取的包捕捉句柄，释放相关资源。 void pcap_perror ( pcap_t * p, char * prefix ); 第一形参来自pcap_open_live()，第二行参的作用类似perror()的形参，指定错误信 息的前缀，与perror()一样，结尾自动输出一个换行。 pcap_perror( p, "pcap_compile" )的输出类似这个效果： pcap_compile: unknown ip proto ... pcap_perror并不自动exit()，与perror()一样，如果需要，应该显式调用exit()。 介绍到这里，已经可以写简单的sniffer。出于完整演示目的，提供这样一个sample code。请勿询问任何关于该代码的问题，烦了。 -------------------------------------------------------------------------- /* * File : sniffer program for I386/Linux using libpcap * Version: 0.01 aleph * Author : Anonymous ( Don't ask anything about this program, please. ) * Complie: gcc -O3 -o pcap pcap_sniffer.c -lpcap `libnet-config --defines --cflags` -Wall * : strip pcap * Usage : ./pcap -h * Date : 2000-12-15 16:35 */ /******************************************************************* * * * Head File * * * *******************************************************************/ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys> #include <pcap.h> #include <libnet.h> /* for LIBNET_TCP_H */</libnet.h></pcap.h></sys></string.h></stdlib.h></stdio.h> /******************************************************************* * * * Macro * * * *******************************************************************/ #define SUCCESS 0 #define FAILURE -1 typedef void Sigfunc ( int ); /* for signal handlers */ /******************************************************************* * * * Static Global Var * * * *******************************************************************/ static pcap_t * pcap_fd = NULL; /* 抽象的包捕捉句柄 */ /******************************************************************* * * * Function Prototype * * * *******************************************************************/ static void Atexit ( void ( * func ) ( void ) ); static void bpf_dump ( struct bpf_program * p, int option ); char * bpf_image ( struct bpf_insn * p, int n ); static void outputBinary ( const u_char * byteArray, const size_t byteArrayLen ); static void pcap_callback ( u_char * none, const struct pcap_pkthdr * pcap_head, const u_char * packet ); static pcap_t * pcap_init ( char * dev, char * filter, int snaplen, int timeout, int dumplevel ); static void pcap_read ( pcap_t * p ); static void sig_end ( int signo ); Sigfunc * signal ( int signo, Sigfunc * func ); static Sigfunc * Signal ( int signo, Sigfunc * func ); /* for our signal() function */ static void terminate ( void ); static void usage ( char * arg ); /*----------------------------------------------------------------------*/ static void Atexit ( void ( * func ) ( void ) ) { if ( atexit( func ) != 0 ) { exit( FAILURE ); } return; } /* end of Atexit */ static void bpf_dump ( struct bpf_program * p, int option ) { struct bpf_insn * insn; int i; int n = p->bf_len; insn = p->bf_insns; if ( option > 2 ) { fprintf( stderr, "%d/n", n ); for ( i = 0; i { fprintf( stderr, "%u %u %u %u/n", insn->code, insn->jt, insn->jf, insn->k ); } return; } if ( option > 1 ) { for ( i = 0; i { fprintf( stderr, "{ 0x%x, %d, %d, 0x%08x },/n", insn->code, insn->jt, insn->jf, insn->k ); } return; } for ( i = 0; i { puts( bpf_image( insn, i ) ); } } /* end of bpf_dump */ char * bpf_image ( struct bpf_insn * p, int n ) { int v; char * fmt; char * op; static char image[256]; char operand[64]; v = p->k; switch ( p->code ) { default: op = "unimp"; fmt = "0x%x"; v = p->code; break; case BPF_RET|BPF_K: op = "ret"; fmt = "#%d"; break; case BPF_RET|BPF_A: op = "ret"; fmt = ""; break; case BPF_LD|BPF_W|BPF_ABS: op = "ld"; fmt = "[%d]"; break; case BPF_LD|BPF_H|BPF_ABS: op = "ldh"; fmt = "[%d]"; break; case BPF_LD|BPF_B|BPF_ABS: op = "ldb"; fmt = "[%d]"; break; case BPF_LD|BPF_W|BPF_LEN: op = "ld"; fmt = "#pktlen"; break; case BPF_LD|BPF_W|BPF_IND: op = "ld"; fmt = "[x + %d]"; break; case BPF_LD|BPF_H|BPF_IND: op = "ldh"; fmt = "[x + %d]"; break; case BPF_LD|BPF_B|BPF_IND: op = "ldb"; fmt = "[x + %d]"; break; case BPF_LD|BPF_IMM: op = "ld"; fmt = "#0x%x"; break; case BPF_LDX|BPF_IMM: op = "ldx"; fmt = "#0x%x"; break; case BPF_LDX|BPF_MSH|BPF_B: op = "ldxb"; fmt = "4*([%d]&0xf)"; break; case BPF_LD|BPF_MEM: op = "ld"; fmt = "M[%d]"; break; case BPF_LDX|BPF_MEM: op = "ldx"; fmt = "M[%d]"; break; case BPF_ST: op = "st"; fmt = "M[%d]"; break; case BPF_STX: op = "stx"; fmt = "M[%d]"; break; case BPF_JMP|BPF_JA: op = "ja"; fmt = "%d"; v = n + 1 + p->k; break; case BPF_JMP|BPF_JGT|BPF_K: op = "jgt"; fmt = "#0x%x"; break; case BPF_JMP|BPF_JGE|BPF_K: op = "jge"; fmt = "#0x%x"; break; case BPF_JMP|BPF_JEQ|BPF_K: op = "jeq"; fmt = "#0x%x"; break; case BPF_JMP|BPF_JSET|BPF_K: op = "jset"; fmt = "#0x%x"; break; case BPF_JMP|BPF_JGT|BPF_X: op = "jgt"; fmt = "x"; break; case BPF_JMP|BPF_JGE|BPF_X: op = "jge"; fmt = "x"; break; case BPF_JMP|BPF_JEQ|BPF_X: op = "jeq"; fmt = "x"; break; case BPF_JMP|BPF_JSET|BPF_X: op = "jset"; fmt = "x"; break; case BPF_ALU|BPF_ADD|BPF_X: op = "add"; fmt = "x"; break; case BPF_ALU|BPF_SUB|BPF_X: op = "sub"; fmt = "x"; break; case BPF_ALU|BPF_MUL|BPF_X: op = "mul"; fmt = "x"; break; case BPF_ALU|BPF_DIV|BPF_X: op = "div"; fmt = "x"; break; case BPF_ALU|BPF_AND|BPF_X: op = "and"; fmt = "x"; break; case BPF_ALU|BPF_OR|BPF_X: op = "or"; fmt = "x"; break; case BPF_ALU|BPF_LSH|BPF_X: op = "lsh"; fmt = "x"; break; case BPF_ALU|BPF_RSH|BPF_X: op = "rsh"; fmt = "x"; break; case BPF_ALU|BPF_ADD|BPF_K: op = "add"; fmt = "#%d"; break; case BPF_ALU|BPF_SUB|BPF_K: op = "sub"; fmt = "#%d"; break; case BPF_ALU|BPF_MUL|BPF_K: op = "mul"; fmt = "#%d"; break; case BPF_ALU|BPF_DIV|BPF_K: op = "div"; fmt = "#%d"; break; case BPF_ALU|BPF_AND|BPF_K: op = "and"; fmt = "#0x%x"; break; case BPF_ALU|BPF_OR|BPF_K: op = "or"; fmt = "#0x%x"; break; case BPF_ALU|BPF_LSH|BPF_K: op = "lsh"; fmt = "#%d"; break; case BPF_ALU|BPF_RSH|BPF_K: op = "rsh"; fmt = "#%d"; break; case BPF_ALU|BPF_NEG: op = "neg"; fmt = ""; break; case BPF_MISC|BPF_TAX: op = "tax"; fmt = ""; break; case BPF_MISC|BPF_TXA: op = "txa"; fmt = ""; break; } /* end of switch */ ( void )sprintf( operand, fmt, v ); ( void )sprintf( image, ( BPF_CLASS( p->code ) == BPF_JMP && BPF_OP( p->code ) != BPF_JA ) ? "(%03d) %-8s %-16s jt %d/tjf %d" : "(%03d) %-8s %s", n, op, operand, n + 1 + p->jt, n + 1 + p->jf ); return image; } /* end of bpf_image */ static void outputBinary ( const u_char * byteArray, const size_t byteArrayLen ) { u_long offset; int i, j, k; fprintf( stderr, "byteArray [ %lu bytes ] ----> /n", ( long unsigned int )byteArrayLen ); if ( byteArrayLen { return; } i = 0; offset = 0; for ( k = byteArrayLen / 16; k > 0; k--, offset += 16 ) { fprintf( stderr, "%08X ", ( unsigned int )offset ); for ( j = 0; j { if ( j == 8 ) { fprintf( stderr, "-%02X", byteArray[i] ); } else { fprintf( stderr, " %02X", byteArray[i] ); } } fprintf( stderr, " " ); i -= 16; for ( j = 0; j { /* if ( isprint( (int)byteArray[i] ) ) */ if ( ( byteArray[i] >= ' ' ) && ( byteArray[i] { fprintf( stderr, "%c", byteArray[i] ); } else { fprintf( stderr, "." ); } } fprintf( stderr, "/n" ); } /* end of for */ k = byteArrayLen - i; if ( k { return; } fprintf( stderr, "%08X ", ( unsigned int )offset ); for ( j = 0 ; j { if ( j == 8 ) { fprintf( stderr, "-%02X", byteArray[i] ); } else { fprintf( stderr, " %02X", byteArray[i] ); } } i -= k; for ( j = 16 - k; j > 0; j-- ) { fprintf( stderr, " " ); } fprintf( stderr, " " ); for ( j = 0; j { if ( ( byteArray[i] >= ' ' ) && ( byteArray[i] { fprintf( stderr, "%c", byteArray[i] ); } else { fprintf( stderr, "." ); } } fprintf( stderr, "/n" ); return; } /* end of outputBinary */ static void pcap_callback ( u_char * none, const struct pcap_pkthdr * pcap_head, const u_char * packet ) { outputBinary( ( u_char * )packet, ( size_t )( pcap_head->caplen ) ); return; } /* end of pcap_callback */ static pcap_t * pcap_init ( char * dev, char * filter, int snaplen, int timeout, int dumplevel ) { pcap_t * p = NULL; char errbuf[ PCAP_ERRBUF_SIZE ]; struct bpf_program bpf; bpf_u_int32 ip, mask; if ( dev == NULL ) { if ( ( dev = pcap_lookupdev( errbuf ) ) == NULL ) { fprintf( stderr, "%s/n", errbuf ); exit( FAILURE ); } } fprintf( stderr, "[ device --> %s ]/n", dev ); /* 1表示进入混杂模式 */ if ( ( p = pcap_open_live( dev, snaplen, 1, timeout, errbuf ) ) == NULL ) { fprintf( stderr, "%s/n", errbuf ); exit( FAILURE ); } if ( pcap_lookupnet( dev, &ip, &mask, errbuf ) == -1 ) { exit( FAILURE ); } /* 1表示优化过滤规则 */ if ( pcap_compile( p, &bpf, filter, 1, mask ) { /* for example, pcap_compile: unknown ip proto ... */ pcap_perror( p, "pcap_compile" ); exit( FAILURE ); } if ( dumplevel >= 0 ) { bpf_dump( &bpf, dumplevel ); exit( SUCCESS ); } else if ( pcap_setfilter( p, &bpf ) == -1 ) { exit( FAILURE ); } return( p ); } /* end of pcap_init */ static void pcap_read ( pcap_t * p ) { // static u_long count = 0; while ( 1 ) { pcap_dispatch( p, 1, pcap_callback, NULL ); // fprintf( stderr, "count = %lu/n", ( long unsigned int )count ); // count++; } /* end of while */ return; } /* end of pcap_read */ static void sig_end ( int signo ) { fprintf( stderr, "/n/nsig_end = %d/n", signo ); exit( SUCCESS ); } /* end of sig_end */ Sigfunc * signal ( int signo, Sigfunc * func ) { struct sigaction act, oact; act.sa_handler = func; sigemptyset( &act.sa_mask ); act.sa_flags = 0; if ( signo == SIGALRM ) { #ifdef SA_INTERRUPT act.sa_flags |= SA_INTERRUPT; /* SunOS 4.x */ #endif } else { #ifdef SA_RESTART act.sa_flags |= SA_RESTART; /* SVR4, 44BSD */ #endif } if ( sigaction( signo, &act, &oact ) { return( SIG_ERR ); } return( oact.sa_handler ); } /* end of signal */ static Sigfunc * Signal ( int signo, Sigfunc * func ) /* for our signal() function */ { Sigfunc * sigfunc; if ( ( sigfunc = signal( signo, func ) ) == SIG_ERR ) { exit( FAILURE ); } return( sigfunc ); } /* end of Signal */ static void terminate ( void ) { if ( pcap_fd != NULL ) { pcap_close( pcap_fd ); } fprintf( stderr, "/n" ); return; } /* end of terminate */ static void usage ( char * arg ) { fprintf( stderr, " Usage: %s [-h] [-d dumplevel] [-i interface] [-s snaplen] [-t timeout]/n", arg ); exit( FAILURE ); } /* end of usage */ int main ( int argc, char * argv[] ) { char * dev = NULL; char filter[300] = ""; /* "ip proto <a href="file:////tcp">//tcp</a> and dst 192.168.8.90 and tcp[13] & 2 = 2" */ int snaplen = LIBNET_ETH_H + LIBNET_IP_H + LIBNET_TCP_H; int timeout = 0; /* 值为0是否表示不设置读超时 */ int dumplevel = -1; int c, i; opterr = 0; /* don't want getopt() writing to stderr */ while ( ( c = getopt( argc, argv, "d:hi:s:t:" ) ) != EOF ) { switch ( c ) { case 'd': dumplevel = atoi( optarg ); break; case 'i': dev = optarg; /* 指定网络接口设备 */ break; case 's': snaplen = atoi( optarg ); case 't': timeout = atoi( optarg ); break; case 'h': case '?': usage( argv[0] ); break; } /* end of switch */ } /* end of while */ argc -= optind; argv += optind; if ( argc > 0 ) { for ( i = 0; i { if ( ( strlen( filter ) + strlen( argv[i] ) ) > 256 ) { fprintf( stderr, "Checking your filter./n" ); return( FAILURE ); } strcat( filter, argv[i] ); strcat( filter, " " ); } } fprintf( stderr, "[ filter --> %s ]/n", filter ); Atexit( terminate ); for ( i = 1; i { Signal( i, sig_end ); } Signal( SIGTERM, sig_end ); pcap_fd = pcap_init( dev, filter, snaplen, timeout, dumplevel ); pcap_read( pcap_fd ); return( SUCCESS ); } /* end of main */ /*----------------------------------------------------------------------*/ -------------------------------------------------------------------------- Usage: ./pcap [-h] [-d dumplevel] [-i interface] [-s snaplen] [-t timeout] libpcap的好处还是很多，比如不需要为解析过滤规则耗费精力。这个程序再次演示 了很多经典Unix编程技巧，比如getopt()、signal()、atexit()，回调函数部分没有 做什么实际工作，看你自己发挥了。顺便提一句，即使是个小程序，也应该保持良好 的风格，在华中看到太多不负责任的提问中的垃圾代码，实在是有辱C语言的传奇。 </n>

你可能感兴趣的:(网络安全)

星河飞雪网络安全-安全见闻总篇小陈在努力ii 安全 python java 1024程序员节
声明学习视频笔记均来自B站UP主"泷羽sec",如涉及侵权马上删除文章笔记的只是方便各位师傅学习知识,以下网站只涉及学习内容,其他的都与本人无关,切莫逾越法律红线,否则后果自负安全见闻01-09已全部更新，后续将会持续更新的章节，感谢各位师傅的点赞关注，冲！目录声明1.常见编程语言（安全见闻01）1.1函数式编程语言1.2数据科学和机器学习领域1.3Web全栈开发1.4移动开发1.5嵌入式系统开发
详细介绍网关getway以及如何使用，常出现的面试题以及答案酷爱码经验分享 gateway 智能路由器分布式
网关（gateway）是计算机网络中一个重要的设备，用于连接不同网络之间进行数据交换和传输。网关的作用是在不同网络之间传递数据包，根据目标地址将数据包传送到合适的目标网络中。网关可以实现不同网络协议之间的转换，提供网络安全和管理功能。常见的网关包括路由器、防火墙等设备。使用网关的过程通常包括以下步骤：配置网关：设置网关的IP地址、子网掩码等网络参数。连接网络设备：将需要连接到网关的设备通过网线或无
2025年——【寒假】自学黑客计划（网络安全）网安CILLE web安全网络安全网络安全 linux
CSDN大礼包：基于入门网络安全/黑客打造的：黑客&网络安全入门&进阶学习资源包前言什么是网络安全网络安全可以基于攻击和防御视角来分类，我们经常听到的“红队”、“渗透测试”等就是研究攻击技术，而“蓝队”、“安全运营”、“安全运维”则研究防御技术。如何成为一名黑客很多朋友在学习安全方面都会半路转行，因为不知如何去学，在这里，我将这个整份答案分为黑客（网络安全）入门必备、黑客（网络安全）职业指南、黑客
2025年入职/转行网络安全，该如何规划？网络安全职业规划教网络安全的毛老师 web安全安全网络运维云计算
网络安全是一个日益增长的行业，对于打算进入或转行进入该领域的人来说，制定一个清晰且系统的职业规划非常重要。2025年，网络安全领域将继续发展并面临新的挑战，包括不断变化的技术、法规要求以及日益复杂的威胁环境。以下是一个关于网络安全职业规划的详细指南，涵盖了从入门到高级岗位的成长路径、技能要求、资源获取等方面的内容。第一部分：网络安全行业概述1.1网络安全的现状与未来网络安全已经成为全球企业和政府的
入门网络安全工程师要学习哪些内容【2025年寒假最新学习计划】白帽黑客2659 web安全学习安全网络安全密码学
基于入门网络安全/黑客打造的：黑客&网络安全入门&进阶学习资源包大家都知道网络安全行业很火，这个行业因为国家政策趋势正在大力发展，大有可为!但很多人对网络安全工程师还是不了解，不知道网络安全工程师需要学什么?知了堂小编总结出以下要点。网络安全工程师是一个概称，学习的东西很多，具体学什么看自己以后的职业定位。如果你以后想成为安全产品工程师，学的内容侧重点就和渗透测试工程师不一样，如果你想成为安全开发
入门网络安全工程师要学习哪些内容【2025年寒假最新学习计划】白帽黑客2659 web安全学习安全网络安全密码学
基于入门网络安全/黑客打造的：黑客&网络安全入门&进阶学习资源包大家都知道网络安全行业很火，这个行业因为国家政策趋势正在大力发展，大有可为!但很多人对网络安全工程师还是不了解，不知道网络安全工程师需要学什么?知了堂小编总结出以下要点。网络安全工程师是一个概称，学习的东西很多，具体学什么看自己以后的职业定位。如果你以后想成为安全产品工程师，学的内容侧重点就和渗透测试工程师不一样，如果你想成为安全开发
入门网络安全工程师要学习哪些内容【2025年寒假最新学习计划】白帽黑客2659 web安全学习安全 python 网络安全
基于入门网络安全/黑客打造的：黑客&网络安全入门&进阶学习资源包大家都知道网络安全行业很火，这个行业因为国家政策趋势正在大力发展，大有可为!但很多人对网络安全工程师还是不了解，不知道网络安全工程师需要学什么?知了堂小编总结出以下要点。网络安全工程师是一个概称，学习的东西很多，具体学什么看自己以后的职业定位。如果你以后想成为安全产品工程师，学的内容侧重点就和渗透测试工程师不一样，如果你想成为安全开发
入门网络安全工程师要学习哪些内容【2025年寒假最新学习计划】白帽黑客2659 web安全学习安全网络安全密码学
基于入门网络安全/黑客打造的：黑客&网络安全入门&进阶学习资源包大家都知道网络安全行业很火，这个行业因为国家政策趋势正在大力发展，大有可为!但很多人对网络安全工程师还是不了解，不知道网络安全工程师需要学什么?知了堂小编总结出以下要点。网络安全工程师是一个概称，学习的东西很多，具体学什么看自己以后的职业定位。如果你以后想成为安全产品工程师，学的内容侧重点就和渗透测试工程师不一样，如果你想成为安全开发
如何用3个月零基础入门网络安全？_网络安全零基础怎么学习白帽黑客啊一学习 web安全安全 python 网安入门
基于入门网络安全/黑客打造的：黑客&网络安全入门&进阶学习资源包前言写这篇教程的初衷是很多朋友都想了解如何入门/转行网络安全，实现自己的“黑客梦”。文章的宗旨是：1.指出一些自学的误区2.提供客观可行的学习表3.推荐我认为适合小白学习的资源.大佬绕道哈！基于入门网络安全/黑客打造的：黑客&网络安全入门&进阶学习资源包一、自学网络安全学习的误区和陷阱1.不要试图先成为一名程序员（以编程为基础的学习）
网站安全攻防：十大常见漏洞及其防范对策_网络安全攻防演练常用漏洞码农x马马安全 web安全运维 linux 人工智能漏洞
**数据来源：**ChatGPTTOP10漏洞TOP10漏洞是OWASP（OpenWebApplicationSecurityProject）每年发布的最常见的网络安全漏洞排名。下面介绍TOP10漏洞及其原理、检测方式和修复措施。1）SQL注入漏洞**原理：**攻击者通过构造恶意SQL语句注入到应用程序的数据库中，从而获取敏感信息或控制数据库服务器。**检测方式：**使用工具或手工输入特殊字符并观
网络防火墙指南 ManageEngine卓豪防火墙网络防护墙防火墙安全网络安全防火墙日志
网络防火墙安全是保护IT基础架构的一个关键方面。在本指南中，将介绍什么是网络防火墙、它在确保网络安全方面的作用、它是如何工作的、网络防火墙管理的最佳实践以及常见的故障排除技巧。什么是网络防火墙网络防火墙是一种用于保障网络安全的重要设备或软件，它负责监控和控制进出网络的数据流，从而有效防止未经授权的访问和潜在的安全威胁。网络防火墙在网络安全中的作用是什么所谓“防火墙”，是一种特殊的访问控制设施，是一
新型Android恶意软件模仿聊天应用窃取敏感数据，从零基础到精通，收藏这篇就够了！程序员霸哥程序员计算机工具网络安全网络 web安全安全生活服务器分布式 ddos
据CyberSecurityNews消息，Cyfirma的网络安全研究人员最近发现了一个针对南亚用户，尤其是印度克什米尔地区用户的复杂Android恶意软件活动，通过伪装成一款名为“Tanzeem”的聊天应用程序以窃取目标设备中的敏感数据。该恶意软件归因于臭名昭著的“DONOT”APT组织，具有印度国家背景。而“Tanzeem”在乌尔都语中意为“组织”，是一个经常与该地区的恐怖组织和执法机构联系在
科拓全智能停车收费系统T_SellFrom.aspx存在SQL注入漏洞(DVB-2025-9011) Byp0ss403 漏洞复现集合 SQL注入 web安全
免责声明仅供网络安全研究与教育目的使用。任何人不得将本文提供的信息用于非法目的或未经授权的系统测试。作者不对任何由于使用本文信息而导致的直接或间接损害承担责任。如涉及侵权，请及时与我们联系，我们将尽快处理并删除相关内容。一：产品介绍科拓全智能停车收费系统是一款集车牌识别、电子支付、车位引导等功能于一体的智能化停车管理平台，通过物联网技术和云计算实现无人值守停车管理，支持微信/支付宝等移动支付方式，
从事网络安全工作可以考哪些证书? 老男孩IT教育网络安全
对我们而言，无论从事什么工作，考取相关证书都有非常重要的作用，它是我们找工作时的加分项，同时也是对我们技术水平的验证，那么从事网络安全工作可以考哪些证书?本篇文章为大家介绍一下。1、CISP国家注册信息安全专业人员CISP，是经中国信息安全产品测评认证中心实施的国家认证，对信息安全人员执业资质的认可。是国内权威认证，有政府背景给认证做背书，如果想在政府、国企及重点行业从业，企业获取信息安全服务资质
**深度剖析与体验：钓鱼网站URL检测神器** 平奇群Derek
深度剖析与体验：钓鱼网站URL检测神器去发现同类优质开源项目:https://gitcode.com/互联网早已融入我们生活的每一个角落，然而随之而来的网络威胁也日渐增多，尤其是那些试图通过伪装网站进行信息盗取的钓鱼行为。在这个背景下，PhishingURLDetection——一个集数据科学与机器学习之力打造的反钓鱼利器应运而生。项目介绍：守护网络安全的第一道防线在当今数字化时代，个人信息安全成
基于Python爬虫的垃圾信息检测与识别技术：实现与优化 Python爬虫项目 2025年爬虫实战项目 python 爬虫开发语言信息可视化人工智能
引言在互联网时代，社交媒体、在线评论、论坛讨论等平台生成了海量的数据。虽然这些数据包含了许多有用的信息，但也充斥着大量的垃圾信息（Spam），这些垃圾信息不仅降低了数据的质量，还影响了用户体验，甚至可能引发网络安全问题。垃圾信息包括但不限于广告、恶意评论、垃圾邮件、钓鱼链接等。为了有效应对垃圾信息的问题，开发垃圾信息检测和识别系统显得尤为重要。本文将通过Python爬虫技术，结合自然语言处理（NL
网络安全面试分享：HVV行动题目及答案（非常详细）零基础入门到精通，收藏这一篇就够了网络安全大白网络安全科技程序员 web安全面试安全
hvv面试题owasptop10问漏洞原理和修复方法略内网渗透拿到webshell，查看本机权限、用户登录情况，是否需要提权查看本机是否存在域，是否有内网使用lcx或直接上线cs，建立隧道以便于对内网进一步进行攻击。(使用frp、nps也是一样的)目标机器上lcx.exe-slavevpsip12345127.0.0.13389vps上./lcx-m2-p112345-p26666探测内网存活主机
硬件防火墙配置与优化：给网络装上最稳的安全阀 Echo_Wish 让你快速入坑运维运维探秘网络开发语言运维
硬件防火墙配置与优化：给网络装上最稳的安全阀在当前威胁复杂的网络环境中，无论是企业还是个人用户，网络安全都像空气一样重要，特别是作为安全防线第一道关卡的硬件防火墙。如果防火墙配置不当，可能形同虚设，甚至给网络引入隐患。今天就来聊聊硬件防火墙的配置与优化，希望能帮你把“安全阀”拧得更紧。硬件防火墙的核心作用是什么？硬件防火墙本质上是部署在网络边缘的安全设备，负责筛查进出网络的流量，阻止未经授权的访问
【无标题】耶耶Norsea WEB web安全
BurpSuite高阶玩法：代理池渗透测试实战指南⚠️法律声明本文所述技术仅限授权测试场景使用，禁止用于非法用途。所有操作需遵守《网络安全法》及目标网站政策。更多工具信息：点击领取一、为什么要用代理池做渗透测试？1.1核心价值✅突破IP限制：绕过WAF的IP封禁策略✅流量匿名化：隐藏真实攻击源地址✅地理定位测试：模拟不同国家/地区访问1.2技术原理BurpSuite代理调度中心代理节点1代理节点2
入门网络安全工程师要学习哪些内容【2025年寒假最新学习计划】白帽黑客2659 web安全学习安全 python 网络安全
基于入门网络安全/黑客打造的：黑客&网络安全入门&进阶学习资源包大家都知道网络安全行业很火，这个行业因为国家政策趋势正在大力发展，大有可为!但很多人对网络安全工程师还是不了解，不知道网络安全工程师需要学什么?知了堂小编总结出以下要点。网络安全工程师是一个概称，学习的东西很多，具体学什么看自己以后的职业定位。如果你以后想成为安全产品工程师，学的内容侧重点就和渗透测试工程师不一样，如果你想成为安全开发
新手必看——ctf六大题型介绍及六大题型解析&举例解题沛哥网络安全 web安全 ctf 网络安全大赛 ctf比赛网络安全
CTF（CaptureTheFlag）介绍与六大题型解析一、什么是CTF？CTF（CaptureTheFlag），意为“夺旗赛”，是一种信息安全竞赛形式，广泛应用于网络安全领域。CTF竞赛通过模拟现实中的网络安全攻防战，让参赛者以攻防对抗的形式，利用各种信息安全技术进行解决一系列安全问题，最终获得“旗帜（Flag）”来获得积分。CTF赛事一般分为两种形式：Jeopardy（解题模式）：参赛者通过解
小白必看！2025 网络安全保姆级学习路线来啦~ 白帽黑客-晨哥学习 web安全安全数据库 php
关键词：网络安全入门、渗透测试学习、零基础学安全、网络安全学习路首先咱们聊聊，学习网络安全方向通常会有哪些问题1.初学者常见问题1.1如何开始学习网络安全？问题：网络安全领域广泛，初学者往往不知道从哪里入手。解答：从基础知识开始：学习计算机网络、操作系统、编程语言（如Python、Bash）。了解网络安全的基本概念，如加密、认证、漏洞、攻击类型等。使用在线资源（如Cybrary、OWASP）或书籍
网络安全法律法规简介菜根网络安全杂谈网络安全职业杂谈 web安全安全网络安全法律法规
一、法律1、《网络安全法》施行日期：2017年6月1日明确网络空间主权原则，规定网络运营者的安全义务（如等级保护制度）、关键信息基础设施保护要求、个人信息处理规则等。2、《数据安全法》施行日期：2021年9月1日建立数据分类分级保护制度，规范数据交易和跨境流动，要求重要数据出境需安全评估。3、《个人信息保护法》施行日期：2021年11月1日为了保护个人信息权益，规范个人信息处理活动，促进个人信息合
网络安全基础：五类安全服务、八种安全机制与OSI七层模型的全面解析网络小白不怕黑网络安全网络安全 OSI七层模型安全机制安全服务
目录引言五类安全服务2.1认证服务2.2访问控制2.3数据保密性2.4数据完整性2.5不可否认性八种安全机制3.1加密机制3.2数字签名3.3访问控制机制3.4数据完整性机制3.5认证交换机制3.6流量填充机制3.7路由控制机制3.8公证机制OSI七层模型与网络安全4.1物理层4.2数据链路层4.3网络层4.4传输层4.5会话层4.6表示层4.7应用层五类安全服务、八种安全机制与OSI七层模型的联
CDN节点对网络安全扫描的影响：挑战与应对策略网络小白不怕黑网络安全网络安全
引言在当今互联网环境中，内容分发网络(CDN)已成为提升网站性能和用户体验的关键技术。然而，CDN的广泛应用也为网络安全扫描带来了新的挑战。本文将深入探讨CDN节点如何影响各类安全扫描工作，分析由此产生的安全风险，并提供有效的应对策略。CDN技术概述CDN(内容分发网络)通过在全球范围内部署边缘节点服务器，将网站内容缓存到离用户更近的位置，从而显著提升访问速度。主要特点包括：分布式节点架构动态内容
深度剖析：域名与DNS安全的全方位解读 ivwdcwso 安全安全域名安全 DNS安全
导语在互联网的庞大体系中，域名如同我们访问网络资源的“门牌号”，而DNS则像是将门牌号翻译为具体地址的“翻译官”。然而，这看似平常的域名与DNS系统，却面临着诸多安全风险。一旦遭受攻击，可能导致网站无法访问、用户数据泄露等严重后果。了解域名与DNS安全知识，对保障网络安全和业务稳定运行至关重要。本文将深入探讨域名与DNS安全的方方面面，带你揭开其中的奥秘。一、域名与DNS基础概念域名域名是由一串用
入门网络安全工程师要学习哪些内容【2025年寒假最新学习计划】白帽黑客2659 web安全学习安全 python 网络安全
基于入门网络安全/黑客打造的：黑客&网络安全入门&进阶学习资源包大家都知道网络安全行业很火，这个行业因为国家政策趋势正在大力发展，大有可为!但很多人对网络安全工程师还是不了解，不知道网络安全工程师需要学什么?知了堂小编总结出以下要点。网络安全工程师是一个概称，学习的东西很多，具体学什么看自己以后的职业定位。如果你以后想成为安全产品工程师，学的内容侧重点就和渗透测试工程师不一样，如果你想成为安全开发
【网络安全 | 漏洞挖掘】IDOR+XSS=账户接管秋说 web安全 xss
未经许可，不得转载。文章目录正文攻击过程正文我已经测试这个应用程序一段时间了。这是一个事件组织应用程序，供活动管理者组织活动并管理注册者。我的目标是了解该应用程序如何处理请求的授权和认证。攻击过程1、我创建了两个账户，每个账户都使用了一些随机的客户ID。2、我尝试从账户一（攻击者账户）访问账户二的数据。3、我进入了“Customers”标签页，在我的账户下可以看到所有我的客户。4、我拦截了请求，并
【网络安全 | 漏洞挖掘】绕过管理员权限撤销的访问控制漏洞秋说 web安全漏洞挖掘
未经许可，不得转载。文章目录前言正文漏洞分析前言该应用程序是一个允许用户创建组织、跟踪其网站并提供多种功能的应用。此外，管理员可以邀请其他用户并为其分配自定义权限。我不清楚该应用的具体技术栈和开发语言，但我知道它的权限配置可能非常复杂，因为这个漏洞本身就十分奇特。正文在研究权限管理的过程中，我尝试像其他安全研究员一样寻找访问控制漏洞。我定期测试不同的权限设置，并尝试以低权限角色访问管理员端的API
录音管理系统接口index存在任意文件读取漏洞(DVB-2025-9007) Byp0ss403 漏洞复现集合 web安全任意文件读取
免责声明仅供网络安全研究与教育目的使用。任何人不得将本文提供的信息用于非法目的或未经授权的系统测试。作者不对任何由于使用本文信息而导致的直接或间接损害承担责任。如涉及侵权，请及时与我们联系，我们将尽快处理并删除相关内容。0x01漏洞描述录音管理系统index存在任意文件读取漏洞，攻击者可以通过此漏洞读取任意系统文件，通过可以用来配合图片木马，控制整个网站服务器权限，从而威胁系统数据安全并可能获取服
eclipse maven IXHONG eclipse
eclipse中使用maven插件的时候，运行run as maven build的时候报错 -Dmaven.multiModuleProjectDirectory system propery is not set. Check $M2_HOME environment variable and mvn script match. 可以设一个环境变量M2_HOME指
timer cancel方法的一个小实例 alleni123 多线程 timer
package com.lj.timer; import java.util.Date; import java.util.Timer; import java.util.TimerTask; public class MyTimer extends TimerTask { private int a; private Timer timer; pub
MySQL数据库在Linux下的安装 ducklsl mysql
1.建好一个专门放置MySQL的目录 /mysql/db数据库目录 /mysql/data数据库数据文件目录 2.配置用户，添加专门的MySQL管理用户 >groupadd mysql ----添加用户组 >useradd -g mysql mysql ----在mysql用户组中添加一个mysql用户 3.配置，生成并安装MySQL >cmake -D
spring------>>cvc-elt.1: Cannot find the declaration of element Array_06 spring bean
将-------- <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3
maven发布第三方jar的一些问题 cugfy maven
maven中发布第三方jar到nexus仓库使用的是 deploy:deploy-file命令有许多参数，具体可查看 http://maven.apache.org/plugins/maven-deploy-plugin/deploy-file-mojo.html 以下是一个例子： mvn deploy:deploy-file -DgroupId=xpp3
MYSQL下载及安装 357029540 mysql
好久没有去安装过MYSQL，今天自己在安装完MYSQL过后用navicat for mysql去厕测试链接的时候出现了10061的问题，因为的的MYSQL是最新版本为5.6.24，所以下载的文件夹里没有my.ini文件，所以在网上找了很多方法还是没有找到怎么解决问题，最后看到了一篇百度经验里有这个的介绍，按照其步骤也完成了安装，在这里给大家分享下这个链接的地址
ios TableView cell的布局张亚雄 tableview
cell.imageView.image = [UIImage imageNamed:[imageArray objectAtIndex:[indexPath row]]]; CGSize itemSize = CGSizeMake(60, 50); &nbs
Java编码转义 adminjun java 编码转义
import java.io.UnsupportedEncodingException; /** * 转换字符串的编码 */ public class ChangeCharset { /** 7位ASCII字符，也叫作ISO646-US、Unicode字符集的基本拉丁块 */ public static final Strin
Tomcat 配置和spring aijuans spring
简介 Tomcat启动时，先找系统变量CATALINA_BASE，如果没有，则找CATALINA_HOME。然后找这个变量所指的目录下的conf文件夹，从中读取配置文件。最重要的配置文件：server.xml 。要配置tomcat，基本上了解server.xml，context.xml和web.xml。 Server.xml -- tomcat主
Java打印当前目录下的所有子目录和文件 ayaoxinchao 递归 File
其实这个没啥技术含量，大湿们不要操笑哦，只是做一个简单的记录，简单用了一下递归算法。 import java.io.File; /** * @author Perlin * @date 2014-6-30 */ public class PrintDirectory { public static void printDirectory(File f
linux安装mysql出现libs报冲突解决 BigBird2012 linux
linux安装mysql出现libs报冲突解决安装mysql出现 file /usr/share/mysql/ukrainian/errmsg.sys from install of MySQL-server-5.5.33-1.linux2.6.i386 conflicts with file from package mysql-libs-5.1.61-4.el6.i686
jedis连接池使用实例 bijian1013 redis jedis连接池 jedis
实例代码： package com.bijian.study; import java.util.ArrayList; import java.util.List; import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPool; import redis.clients.jedis.JedisPoo
关于朋友 bingyingao 朋友兴趣爱好维持
成为朋友的必要条件：志相同，道不合，可以成为朋友。譬如马云、周星驰一个是商人，一个是影星，可谓道不同，但都很有梦想，都要在各自领域里做到最好，当他们遇到一起，互相欣赏，可以畅谈两个小时。志不同，道相合，也可以成为朋友。譬如有时候看到两个一个成绩很好每次考试争做第一，一个成绩很差的同学是好朋友。他们志向不相同，但他
【Spark七十九】Spark RDD API一 bit1129 spark
aggregate package spark.examples.rddapi import org.apache.spark.{SparkConf, SparkContext} //测试RDD的aggregate方法 object AggregateTest { def main(args: Array[String]) { val conf = new Spar
ktap 0.1 released bookjovi kernel tracing
Dear, I'm pleased to announce that ktap release v0.1, this is the first official release of ktap project, it is expected that this release is not fully functional or very stable and we welcome bu
能保存Properties文件注释的Properties工具类 BrokenDreams properties
今天遇到一个小需求：由于java.util.Properties读取属性文件时会忽略注释，当写回去的时候，注释都没了。恰好一个项目中的配置文件会在部署后被某个Java程序修改一下，但修改了之后注释全没了，可能会给以后的参数调整带来困难。所以要解决这个问题。 &nb
读《研磨设计模式》-代码笔记-外观模式-Facade bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ /* * 百度百科的定义： * Facade（外观）模式为子系统中的各类（或结构与方法）提供一个简明一致的界面， * 隐藏子系统的复杂性，使子系统更加容易使用。他是为子系统中的一组接口所提供的一个一致的界面 * * 可简单地
After Effects教程收集 cherishLC After Effects
1、中文入门 http://study.163.com/course/courseMain.htm?courseId=730009 2、videocopilot英文入门教程（中文字幕） http://www.youku.com/playlist_show/id_17893193.html 英文原址： http://www.videocopilot.net/basic/ 素
Linux Apache 安装过程 crabdave apache
Linux Apache 安装过程下载新版本： apr-1.4.2.tar.gz（下载网站：http://apr.apache.org/download.cgi） apr-util-1.3.9.tar.gz（下载网站：http://apr.apache.org/download.cgi） httpd-2.2.15.tar.gz（下载网站：http://httpd.apac
Shell学习之变量赋值和引用 daizj shell 变量引用赋值
本文转自：http://www.cnblogs.com/papam/articles/1548679.html Shell编程中，使用变量无需事先声明，同时变量名的命名须遵循如下规则：首个字符必须为字母（a-z，A-Z）中间不能有空格，可以使用下划线（_）不能使用标点符号不能使用bash里的关键字（可用help命令查看保留关键字）需要给变量赋值时，可以这么写：
Java SE 第一讲（Java SE入门、JDK的下载与安装、第一个Java程序、Java程序的编译与执行） dcj3sjt126com java jdk
Java SE 第一讲： Java SE：Java Standard Edition Java ME: Java Mobile Edition Java EE：Java Enterprise Edition Java是由Sun公司推出的（今年初被Oracle公司收购）。收购价格：74亿美金 J2SE、J2ME、J2EE JDK：Java Development
YII给用户登录加上验证码 dcj3sjt126com yii
1、在SiteController中添加如下代码： /** * Declares class-based actions. */ public function actions() { return array( // captcha action renders the CAPTCHA image displ
Lucene使用说明 dyy_gusi Lucene search 分词器
Lucene使用说明 1、lucene简介 1.1、什么是lucene Lucene是一个全文搜索框架，而不是应用产品。因此它并不像baidu或者googleDesktop那种拿来就能用，它只是提供了一种工具让你能实现这些产品和功能。 1.2、lucene能做什么要回答这个问题，先要了解lucene的本质。实际
学习编程并不难,做到以下几点即可! gcq511120594 数据结构编程算法
不论你是想自己设计游戏，还是开发iPhone或安卓手机上的应用，还是仅仅为了娱乐，学习编程语言都是一条必经之路。编程语言种类繁多，用途各异，然而一旦掌握其中之一，其他的也就迎刃而解。作为初学者，你可能要先从Java或HTML开始学，一旦掌握了一门编程语言，你就发挥无穷的想象，开发各种神奇的软件啦。 1、确定目标学习编程语言既充满乐趣，又充满挑战。有些花费多年时间学习一门编程语言的大学生到
Java面试十问之三：Java与C++内存回收机制的差别 HNUlanwei java C++finalize()堆栈内存回收
大家知道， Java 除了那 8 种基本类型以外，其他都是对象类型（又称为引用类型）的数据。 JVM 会把程序创建的对象存放在堆空间中，那什么又是堆空间呢？其实，堆（ Heap）是一个运行时的数据存储区，从它可以分配大小各异的空间。一般，运行时的数据存储区有堆（ Heap）和堆栈（ Stack），所以要先看它们里面可以分配哪些类型的对象实体，然后才知道如何均衡使用这两种存储区。一般来说，栈中存放的
第二章 Nginx+Lua开发入门 jinnianshilongnian nginx lua
Nginx入门本文目的是学习Nginx+Lua开发，对于Nginx基本知识可以参考如下文章： nginx启动、关闭、重启 http://www.cnblogs.com/derekchen/archive/2011/02/17/1957209.html agentzh 的 Nginx 教程 http://openresty.org/download/agentzh-nginx-tutor
MongoDB windows安装基本命令 liyonghui160com
windows安装安装目录： D:\MongoDB\ 新建目录 D:\MongoDB\data\db 4.启动进城： cd D:\MongoDB\bin mongod -dbpath D:\MongoDB\data\db &n
Linux下通过源码编译安装程序 pda158 linux
一、程序的组成部分　　Linux下程序大都是由以下几部分组成：　　二进制文件：也就是可以运行的程序文件　　库文件：就是通常我们见到的lib目录下的文件　　配置文件：这个不必多说，都知道　　帮助文档：通常是我们在linux下用man命令查看的命令的文档　　二、linux下程序的存放目录　　linux程序的存放目录大致有三个地方：　　/etc, /b
WEB开发编程的职业生涯４个阶段 shw3588 编程 Web 工作生活
觉得自己什么都会 2007年从学校毕业，凭借自己原创的ASP毕业设计，以为自己很厉害似的，信心满满去东莞找工作，找面试成功率确实很高，只是工资不高，但依旧无法磨灭那过分的自信，那时候什么考勤系统、什么OA系统、什么ERP，什么都觉得有信心，这样的生涯大概持续了约一年。根本不是自己想的那样 2008年开始接触很多工作相关的东西，发现太多东西自己根本不会，都需要去学，不管是asp还是js，
遭遇jsonp同域下变作post请求的坑 vb2005xu jsonp 同域post
今天迁移一个站点时遇到一个坑爹问题,同一个jsonp接口在跨域时都能调用成功,但是在同域下调用虽然成功,但是数据却有问题. 此处贴出我的后端代码片段 $mi_id = htmlspecialchars(trim($_GET['mi_id '])); $mi_cv = htmlspecialchars(trim($_GET['mi_cv '])); 贴出我前端代码片段: $.aj