IOT入门 on Expl0rer.Ct

IOT-2

Tue, 11 Aug 2026 00:00:00 +0000

[TOC]

物联网通信协议

接入类协议：一般负责子网内设备间的组网及通信，市场上常见的有zigbee、蓝牙以及wifi协议等；

通信类协议：主要是运行在传统互联网TCP/IP协议之上的设备远程通讯协议，负责设各通过互联网进行数据交换及通信，例如GPRS/3G/4G等。

wlan指的是无线局域网络(Wireless Local Area Networks)，它是相当便利的数据传输系统，它利用射频（Radio Frequency；RF）的技术，使用电磁波来取代旧式的双绞铜线（Coaxial）所构成的局域网络，在空中进行通信连接：该技术的出现绝不是用来取代有线局域网络，而是用来弥补有线局域网络之不足，以达到网络延伸之日的，使得无线局域网络能利用简单的存取架构让用户透过它，实现无网线、无距离限制的通畅网络。

本文有参考其它文献材料，忽略了实操部分的描述，更多的是理论知识的了解。

WiFi协议

Wi-Fi

Wi-Fi在中文里又称作“行动热点”，是Wi-Fi联盟制造商的商标做为产品的品牌认证，是一个创建于IEEE 802.11标准的可以将个人电脑、手持设备（如pad、手机)等终端以无线方式互相连接的技术，事实上它也是一种高频无线电信号。

无线网相较于有线网来说，通信双方因为是通过无线进行通信，所以通信之前需要建立连接；有线网络就直接用线缆连接。

通信双方通信方式是半双工的通信方式；而有线网络可以是全双工。

但通信时在网络层以下出错的概率非常高；而有线网络出错概率非常小。

数据是在无线环境下进行的，所以抓包非常容易，存在安全隐惠。因为收发无线信号，所以功耗较大相对有线网络吞吐量低。

IEEE 802.11协议

Ethenet和Wifi采用的协议都属于IEEE 802协议集。其中，Ethenet以802.3协议做为其网络层以下的协议；而Wifi以802.11做为其网络层以下的协议。

802.11定义了两种类型的设备：

无线站(STA）
无线接入点(AP）

频谱划分

2.4gWiFi总共有14个信道：

SSID和BSSID

1、基本服务集（BSS）：

基本服务集是802.11 LAN的基本组成模块。能互相进行无线通信的STA可以组成一个BSS (Basic Service Set）.如果一个站移出BSS的覆盖范围，它将不能再与BSS的其它成员通信。

2、扩展服务集（ESS）

多个BSS可以构成一个扩展网络，称为扩展服务集（ESS）网络，一个ESS网络内部的STA可以互相通信，是采用相同的SSID的多个BSS形成的更大规模的虚拟BSS。连接BSS的组件称为分布式系统（Distribution System， DS）。

无线接入过程的三个阶段

STA启动初始化、开始正式使用AP传送数据帧前，要经过三个阶段才能够接入：

扫描阶段（SCAN）
认证阶段（Authentication）
关联（Association）

认证连接方式

分为有认证和无认证这两种。

有认证：

SSID-密码认证
- wep
- wpa/wpa2
WPS

WEP

WEP是有线等效保密(Wired Equivalent Privacy)的简称，一种在链路层加密的方式来防止非法用户窃听或侵入无线网络。

由于安全性底下，且可以通过大量抓包来嗅探出其密钥，所以它早在2003年被WPA所淘汰。

WPA/WPA2

WPA主要采用的是临时密钥完整性协议（TKIP1）加密算法，TKIP旨在改进WEP，且无需依赖全新硬件来运行；WPA2则强制使用AES-CCMP算法来进行加密，比TKIP更强大、更坚固。

WPA和WPA2支持两种身份验证机制：

企业：基于EAP的身份验证
个人：基于预共享密钥的身份验证（WPA-PSK）

WPA握手流程

PTK所需参数：

网络的SSID
无线AP随机数A-Nonce(Authenticator Nonce）
申请者随机数S-Nonce(Supplicant Nonce）
无线AP MAC地址
申请者MAC地址

WPS的安全问题

WPS（Wi-Fi Protected Setup）是WiFi保护设置的英文缩写，主要致力于简化无线局域网安装及安全性能的配置工作。在WPS认证中PIN码是网络设备间获得接入的唯一要求，不需要其他身份识别方式，这就让暴力破解变得可行。

WPS PIN码的第8位数是一个校验，因此暴力破解只需算出前7位，而在实施PIN身份识别时，接入点实际上是要找出这个PIN的前4位和后3位是否分别正确。

$$ 10^8 ➔ 10^7 ➔ 10^4 + 10^3 $$

AIR无线攻击套件

查看无线网卡名：ifconfig

关掉占用网卡进程：airmon-ng check kill

设置网卡为监听模式：airmon-ng start INTERFACE

扫描附近：wifiairodump-ng INTERFACE

监听制定路由器流量并保存到本地：airodump-ng -c CHANNEL --bssid AP_MAC -w FILENAME INTERFACE

攻击路由器使连接设备断线重新连接：airplay-ng -0 50 -a BSSID INTERFACE

使用字典对抓取到的握手包暴力破解：aircrack-ng -w PASSWORD_FILENAME FILENAME

Zigbee协议

架构

ZigBee是IEEE 802.15.4标准的低功耗局域网协议，是一种短距离、低功耗的无线通信技术主要适合用于自动控制和远程控制领域，可以嵌入各种设备。

ZigBee拓扑有三种功能节点：

协调器
路由器
终端设备

ZigBee架构：

PHY/MAC 管无线电；

NWK 管怎么组网找路；

APS 管上层数据投递；

AF 跑你的业务；

ZDO 管设备本身的网络行为。

ZigBee 整体分层自下而上：PHY → MAC → NWK → APL（应用层），其中 PHY、MAC 遵循 IEEE 802.15.4；NWK、APL 由 ZigBee 联盟定义。

1 PHY 物理层（IEEE802.15.4）

最底层，硬件射频层。
功能：无线信号调制解调、射频收发、信道选择、信号强度检测。
工作频段：2.4GHz、868MHz、915MHz。

2 MAC 介质访问控制层（IEEE802.15.4）

管理无线信道接入，使用 CSMA‑CA 避免信号冲突。
功能：帧封装解析、数据确认 ACK、设备入网 / 脱离网络、信标同步、帧校验。

3 NWK 网络层（ZigBee 定义）

负责组网、路由。
功能：建立维护 ZigBee 网络；设备加入 / 离开网络；路由发现与转发；分配网络短地址；支持协调器、路由器、终端节点三种设备角色。

4 APL 应用层（ZigBee 定义，顶层）

由 APS（应用支持子层）、AF（应用框架）、ZDO（ZigBee 设备对象） 三部分组成

（1）APS 应用支持子层

连接网络层和上层应用，起到承上启下。

功能：数据的收发转发；绑定功能；设备与服务发现；报文分段重组；安全加密。

（2）AF 应用框架

用户实际应用运行的环境。

提供端点（Endpoint）机制，一个设备可以有多个端点，运行不同应用；定义簇（Cluster），实现设备之间命令、数据交互；用户开发的业务应用就跑在 AF 之上。

（3）ZDO ZigBee 设备对象

设备管理核心。

功能：定义设备类型（协调器 / 路由器 / 终端）；设备网络管理；设备发现、服务发现；绑定管理；网络启动、入网请求；处理设备配置。

APL（应用层）内部又分为 APS、AF、ZDO三部分，和图中结构完全对应。

数据流向：用户应用 (AF) ↔ ZDO ↔ APS ↔ NWK ↔ MAC ↔ PHY ↔空中无线信号。

安全机制

在ZigBee标准中使用三种类型的128位对称密钥：

主密钥：用来协商生成 link key；
网络密钥：全网 NWK 层加密密钥；
链接密钥：信任中心 ↔ 待入网设备之间点对点 APS 加密，用来安全分发网络密钥。

默认信任中心连接密钥Trust‑Center Link Key：它属于 链接密钥（Link Key），是广为人知的默认全局链接密钥（well‑known key），用于集中式安全网络（存在信任中心 Trust Center，一般就是协调器 ZC）。

`1`	`0x5A 0x69 0x67 0x42 0x65 0x65 0x 41 0x6c 0x6c 0x69 0x61 0xe 0x63 0x65 0x 30 0x39`

⚠️安全缺陷：所有厂商设备默认都带这个密钥，攻击者抓包后可以用这个公开密钥解密，拿到网络密钥，直接入侵整个 ZigBee 网络。ZigBee3.0 推荐不再使用这个默认密钥，改用安装码 Install Code 生成唯一链接密钥做入网。

Zigbee采用了AES-CCM* 和帧计数器的来保证数据的完整性、机密性、真实性。

BlueTooth_BLE协议

蓝牙-BLE协议简介

BlueTooth_BLE协议是一种无线个人局域网技术，用于在较小距离上交换数据。

于1994年发明2.4 GHz至2.485 GHz （ISM）频段蓝牙网络称为微微网，互连微微网的形成散射网：

1代：748~810Kbpsemtc跳频抗干扰；
2代：1.8~2.1MbpsWW提高2倍待机时间；
3代：24Mbps；
4代：整合传统，高速和低功耗蓝牙技术最远传输距离扩大到100米；
5代：工作距离300米导航,室内定位。

BLE协议

低功耗蓝牙BLE(Bluetooth Low Energy）是蓝牙技术联盟设计和销售的一种个人局域网技术，旨在用于医疗健康、安防娱乐等领域的新兴应用一可与传统蓝牙保持同等通信范围的同时显著降低功耗和成本蓝牙4.0被引入，也被称为Bluetooth Smart。

蓝牙-BLE的比较：

	传统蓝牙	BLE
信道	79个信道	40个信道（37/38/39广播信道）
发现/连接	查询	广播
连接延时	100ms	6ms
最大数据率	1-3Mbps	1Mbps
工作距离	10米	最远100米
最大输出功率	1-00mW	10mW
主要应用	无线播放、控制器	智能家居、穿戴设备

连接过程

传统蓝牙：跳频链接

BLE：广播连接

大致就这么多，具体实操你可以上Wireshark抓包去看看。

RFID

简介

RFID是射频识别(Radio FrequencyIdentification)的缩写，利用无线射频方式进行非接触双向数据通信,通过对记录媒体（电子标签）进行读写，从而达到识别目标和数据交换的目的。

由于RFID具有读写速度快,无需接触，设备简单等特点，在生活中被广泛使用，常见的应用有物流标签、公交门禁、购物就餐卡等。

组成

RFID系统由控制系统阅读器和电子标签组成：

阅读器将采集到的阅读器通过天线Rfld电子标签接收到阅读器；

标签数据传送到发出射频信号发出的信号之后激活并返回；

计算机系统进行处理信号给阅读器。

阅读器（Reader）通过天线与RFID电子标签进行无线通信，可以实现对标签识别码和内存数据的读出或写入操作。

典型的阅读器包含有高频模块（发送器和接收器）、控制单元以及阅读器天线。

电子标签(Tag)由耦合元件及芯片组成，每个标签具有唯一的电子编码。当电子标签进入由阅读器产生的无线电射频信号区域时获得能量，然后向阅读器发送储存的信息及数据。有时也被称作射频卡。

分类

有无内置电源：

无源电子标签
有源电子标签
半有源电子标签

工作频率：

低频段 30kHZ~300kHZ
中高频段 3MHz~30MHz
超高频段 862MHz~928MHz
微波范围 3GHz以上

高频卡

NXP Mifare S5O (M1）高频13.56MHz 是最常见的射频卡，每张卡独一无二UID号，可存储、修改扇区数据（一卡通，门禁，电梯卡）。

NXP Mifare S7O Mifare S7O可容纳4KB数据，S50的卡类型(ATQA)是0004HS70的卡类型(ATQA）是0002H。

NXP DESFire/JCOP基于微处理器的芯片卡广泛应用如银行与金融，移动通信，公共交通，访客访问和网络接入等领域。文持接触式、非接触式读写，JCOP版本内含操作系统，并提供40-80K字节EEPROM存储器。

低频卡

EM41008

工作频率125kHz 卡内只存储卡号日无法修改；
成本低广泛用于门禁、身份识别，安防医疗系统。

HID ProxCard II

与EM4系列卡片类似只存储卡号名片大小厚度较厚。

T5577卡

可写入数据可设置密码的低频卡；
可用于复制ID和HID卡；
共有8个块，共可存储256b数据。

T5577结构

共有8个块每个块存32b数据
第0块表示调制方式和卡片类型

第7块表示加密的密码，无密则表示普通数据

T5577结构：

[0]	0x000148040  [0]	0x000148050
[1]	0xFF992002   [1]	0xFF992002
[2]	0xB6C91B7C   [2]	0xB6C91B7C
[3]	0x00000000   [3]	0x00000000
[4]	0x00000000   [4]	0x00000000
[5]	0x00000000   [5]	0x00000000
[6]	0x00000000   [6]	0x00000000
[7]	0x00000000   [7]	0x00000000

	ID	HID
无密码	00148040	00107060
加密	00148050	00107070

应用场景：

项目	低频 LF	高频 HF (13.56MHz)
频率	125‑134.2kHz	13.56MHz
读取距离	≤10cm	几厘米～1m
手机 NFC 可读	❌不能	✅可以（NFC）
抗水 / 潮湿	很好	一般
数据速率	低	高
典型用途	动物耳标、传统门禁、车钥匙	公交卡、校园卡、图书、NFC

UID：卡片身份证号；

KeyA/KeyB：打开这个扇区的两把密码；

Access Bits：门禁权限表，规定密码 A、B 分别能干什么操作；

BCC：检查 UID 有没有读错的校验码。

MQTT

MQTT （Message Queuing Telemetry Transport，消息队列遥测传输协议），是一种基于发布/订阅（publish/subscribe）模式的"轻量级"通讯协议，该协议构建于TCP/IP协议上，由IBM在1999年发布。

实现过程

设计原则与特性

精简,把传输量降到最低;

发布/订阅（Pub/Sub）模式,提供一对多的消息

发布，解除应用程序耦合；

允许用户动态创建主题；

把低带宽、高延迟、不稳定的网络等因素考虑在内；

提供服务质量管理；

有三种消息发布服务质量(Qos)：

至多次
至少次
只有一次

使用遗嘱(Last Will特性通知有关各方客户端异常中断的机制；

消息报文格式

MOTT协议是应用层协议，需要借助TCP/IP协议进行传输，类似HTTP协议。

MQTT协议也有自己的格式：固定头部+可变头部+消息载体。

固定头部:通过固定头部区分多种消息类型，如连接，发布，订阅等；
可变头部:有些协议类型中存在，在有些协议中不存在；
消息载体：消息的主要内容。

固定头包含两部分内容，首字节+剩余消息报文长度。

首字节：首字节用于表示MQTT消息的报文类型以及某些类型的控制标记高4位(bit7~bit4)表示协议类型。

报文类型	字段值	描述
保留	0	保留
CONNECT	1	客户端连接到服务器
CONNACK	2	连接确认
PUBLISH	3	发布消息
PUBACK	4	发布确认
PUBREC	5	消息已接收 (QoS2 第一阶段)
PUBREL	6	消息释放 (QoS2 第二阶段)
PUBCOMP	7	发布结束 (QoS2 第三阶段)
SUBSCRIBE	8	客户端订阅请求
SUBACK	9	服务端订阅确认
UNSUBACRIBE	10	客户端取消订阅
UNSUBACK	11	服务端取消订阅确认
PINGREQ	12	客户端发送心跳
PINGRESP	13	服务端回复心跳

30H=0011 0000

报文类型	Bit 3	Bit 2	Bit 1	Bit 0
PUBLISH	DUP	QoS	QoS	保留

Z-Wave协议

Z-Wave简介

Z-Wave是无线传感器网络和家庭自动化领域的热门协议之一，在美国使用908.42M Hz，在欧洲使用868.42M Hz。

Z-Wave攻击准备：

使用Z-Wave的设备
硬件：HackF
软件:EZ-Wave (https://github.com/AFITWiSec/EZ-Wave）

EZ-Wave包含的工具：

Device discovery and enumeration-EZStumbler(设备发现和枚举）

Reconnaissance on identified devices-EZRecon(识别设备的EZ-Recon）

Exploitation-EZFingerprint(利用EZ指纹）

选择重播数据包或修改,然后根据想要实现的日标重播；对Z-Wave的另一类攻击是对Z-Wave设备节点网络攻击、欺骗攻击、干扰和拒绝服务攻击等。

IOT-1

Sun, 09 Aug 2026 00:00:00 +0000

[TOC]

IOT全名物联网 ，在网络安全行业中又称IOT安全、物联网安全，是我们二进制安全方向的一个实战方向的重要体现，多在摄像头、WiFi路由器，甚至更高端的比如车联网娱乐车载系统等，都将是网络空间中所需要重点关注的电子设备，CTF-PWN多在内核态和用户态等虚拟世界中进行漏洞的大做文章·，那么IOT就是现实生活与网络空间的碰撞。

传统安全其实代指就是Web安全渗透测试、安全服务、应急响应。对于IOT二进制安全方向其实也就是电子信息与软件工程的交叉方向，所以说补全Web安全知识也是相当重要的，作者此前是一位纯二进制选手，Web底子不好，这次专开一篇记录Web安全的文章。

HTTP协议

现在很多嵌入式设备的通信都是遵循使用HTTP协议的，并且都有一些Web界面的，所以Web安全基础的知识相当重要。

HTTP常见请求方法

1、GET：请求指定页面信息，并返回实体主体；

2、POST：向指定资源提交数据并进行处理请求，数据被包含在请求体中，POST请求可能会导致新的资源的建立或已有资源的修改；

3、HEAD：类似GET请求，只不过返回的响应中没有具体内容，用于获取报头；

4、PUT：从客服端向服务器传送的数据取代指定的文档内容；

5、DELETE：请求服务器删除指定的内容；

6、CONNECT：HTTP1.1协议中预留给能够将连接改为管道方式的代理服务器；

7、TRANCE：回显服务器收到的请求，主要用于测试或诊断；

这个其实可以在Burpsuite能看到...但我之前是完全不认识的，所以还是写出来吧。

Host: https://expl0rer.top/ //请求的目标域名和端口号

Origin: http://localhost:1313/ //请求的来源域名和端口号（跨域请求时，浏览器会自动带上这个头信息）

Referer: https:/localhost:8081/link?query=xxxxx //请求资源的完整URI

User-Agent //浏览器信息

Cookie: //当前域名下的Cookie

Accept: text/html,image/apng //代表客户端希望接受的数据类型是html或者是png图片类型

Accept-Encoding: gzip, deflate //代表客户端能支持gzip和deflate格式的压缩

Accept-Language: zh-CN,zh;q=0.9 //代表客户端可以支持语言zh-CN或者zh

Connection: keep-alive //告诉服务器，客户端需要的tcp连接是一个长连接

If-None-Match //如果内容未改变返回304代码，对应Etag

If-Modified-Since //对应last-midified，未被修改则返回304代码

Date: //服务端发送资源时的服务器时间

Expires: //缓存过期时间

Cache-Control: no-cache // 缓存方式

Etag // 文件内容hash

Last-Modified //最近一次文件修改时间

Content-Type: text/html; charset=utf-8 //编码格式

Content-Encoding: gzip //采用gzip对资源进行解码

Connection: keep-alive //tcp是长连接

Set-Cookie //设置Http Cookie

Web安全通信原理

如果说你此时在本科阶段学过计算机大类专业的《计算机网络》或者通信工程相关专业的专业课的话，这部分对你来说可能比较简单。

客户端与服务端通信

流程步骤

这张图描述浏览器访问 Web 服务器一次完整的 HTTP 交互流程（基于 TCP），一共 11 个步骤：

用户发起请求：用户输入网址、点击链接，向浏览器发出访问指令。
TCP 三次握手：浏览器与服务端程序建立 TCP 可靠连接。
封装 HTTP 请求报文：浏览器把用户请求封装成符合 HTTP 协议格式的数据包。
发送数据包：通过socket send()函数把数据包发给服务端。
服务端解包：服务端程序接收数据，按照 HTTP 格式解析请求内容。
业务执行：服务端执行后端逻辑（查询数据库、业务运算等）。
生成返回结果：业务处理完成，得到响应数据。
封装响应报文：将处理结果封装为 HTTP 协议格式数据包。
回传数据包：服务端调用send()，把 HTTP 响应包传回浏览器。
浏览器解包：浏览器解析收到的 HTTP 响应数据包。
渲染展示：浏览器解析 HTML/CSS，把页面结果展示给用户。

分层关系：HTTP 是应用层协议，下层依赖TCP 传输层；先建立 TCP 连接，再收发 HTTP 数据。

用户操作 → TCP 建连 → 浏览器封装 HTTP 请求 → 发给服务器 → 服务器解析 + 执行业务 → 封装 HTTP 响应 → 返回浏览器 → 浏览器解析渲染页面。

HTTP协议的工作流程

HTTP全称是(HyperText Transfer Protocol)超文本传输协议。

HTTP请求报文格式：

响应报文：

Tinyhttpd源码分析

可以用linux下的NC去查看：

一开始这是一个报头，NC相当于一个“通信”或者当成“微信”一样能互相聊天通信发信息。

那我们在终端复制粘贴进一段前端代码+http响应头进去。

HTTP/1.1 200 OK
Content-Type: text/html;charset=UTF-8
Content-Length: 927
Connection: close
Cache-control: no-cache

<html>
<body>
<h1>hello!!!!</h1>
</body>
</html>

最终在浏览器中可以看到：

这样其实就是一种监听。

httpd源代码

/* J. David's webserver */
/* This is a simple webserver.
 * Created November 1999 by J. David Blackstone.
 * CSE 4344 (Network concepts), Prof. Zeigler
 * University of Texas at Arlington
 */
/* This program compiles for Sparc Solaris 2.6.
 * To compile for Linux:
 *  1) Comment out the #include <pthread.h> line.
 *  2) Comment out the line that defines the variable newthread.
 *  3) Comment out the two lines that run pthread_create().
 *  4) Uncomment the line that runs accept_request().
 *  5) Remove -lsocket from the Makefile.
 */
#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <ctype.h>
#include <strings.h>
#include <string.h>
#include <sys/stat.h>
#include <pthread.h>
#include <sys/wait.h>
#include <stdlib.h>
 
#define ISspace(x) isspace((int)(x))
//函数说明：检查参数c是否为空格字符，
//也就是判断是否为空格(' ')、定位字符(' t ')、CR(' r ')、换行(' n ')、垂直定位字符(' v ')或翻页(' f ')的情况。
//返回值：若参数c 为空白字符，则返回非 0，否则返回 0。
 
 
#define SERVER_STRING "Server: jdbhttpd/0.1.0rn"//定义server名称
 
void accept_request(int);//接收请求
 
void bad_request(int);//无效请求
void cat(int, FILE *);
void cannot_execute(int);
void error_die(const char *);
void execute_cgi(int, const char *, const char *, const char *);
int get_line(int, char *, int);
void headers(int, const char *);
void not_found(int);
void serve_file(int, const char *);
int startup(u_short *);
void unimplemented(int);
 
/**********************************************************************/
/* A request has caused a call to accept() on the server port to
 * return.  Process the request appropriately.
 * Parameters: the socket connected to the client */
/**********************************************************************/
//接收客户端的连接，并读取请求数据
void accept_request(int client)
{
 char buf[1024];
 int numchars;
 char method[255];
 char url[255];
 char path[512];
 size_t i, j;
 struct stat st;
 int cgi = 0;      /* becomes true if server decides this is a CGI
                    * program */
 char *query_string = NULL;
//获取一行HTTP报文数据
 numchars = get_line(client, buf, sizeof(buf));
 //
 i = 0; j = 0;
 //对于HTTP报文来说，第一行的内容即为报文的起始行，格式为<method> <request-URL> <version>，
 //每个字段用空白字符相连
 while (!ISspace(buf[j]) && (i < sizeof(method) - 1))
 {
 //提取其中的请求方式是GET还是POST
  method[i] = buf[j];
  i++; j++;
 }
 method[i] = '';
//函数说明：strcasecmp()用来比较参数s1 和s2 字符串，比较时会自动忽略大小写的差异。
//返回值：若参数s1 和s2 字符串相同则返回0。s1 长度大于s2 长度则返回大于0 的值，s1 长度若小于s2 长度则返回小于0 的值。
 if (strcasecmp(method, "GET") && strcasecmp(method, "POST"))
 {
 //tinyhttp仅仅实现了GET和POST
  unimplemented(client);
  return;
 }
//cgi为标志位，置1说明开启cgi解析
 if (strcasecmp(method, "POST") == 0)
//如果请求方法为POST，需要cgi解析
  cgi = 1;
 
 i = 0;
 //将method后面的后边的空白字符略过
 while (ISspace(buf[j]) && (j < sizeof(buf)))
  j++;
 //继续读取request-URL
 while (!ISspace(buf[j]) && (i < sizeof(url) - 1) && (j < sizeof(buf)))
 {
  url[i] = buf[j];
  i++; j++;
 }
 url[i] = '';
//如果是GET请求，url可能会带有?,有查询参数
 if (strcasecmp(method, "GET") == 0)
 {
  query_string = url;
  while ((*query_string != '?') && (*query_string != ''))
   query_string++;
  if (*query_string == '?')
  {
  //如果带有查询参数，需要执行cgi，解析参数，设置标志位为1
   cgi = 1;
  //将解析参数截取下来
   *query_string = '';
   query_string++;
  }
 }
//以上已经将起始行解析完毕
//url中的路径格式化到path
 sprintf(path, "htdocs%s", url);
//学习到这里明天继续TODO
//如果path只是一个目录，默认设置为首页index.html
 if (path[strlen(path) - 1] == '/')
  strcat(path, "index.html");
 
 //函数定义:    int stat(const char *file_name, struct stat *buf);
 //函数说明:    通过文件名filename获取文件信息，并保存在buf所指的结构体stat中
 //返回值:     执行成功则返回0，失败返回-1，错误代码存于errno（需要include <errno.h>）
 if (stat(path, &st) == -1) {
 //假如访问的网页不存在，则不断的读取剩下的请求头信息，并丢弃即可
  while ((numchars > 0) && strcmp("n", buf))  /* read & discard headers */
   numchars = get_line(client, buf, sizeof(buf));
  //最后声明网页不存在
  not_found(client);
 }
 else
 {
 //如果访问的网页存在则进行处理
  if ((st.st_mode & S_IFMT) == S_IFDIR)//S_IFDIR代表目录
 //如果路径是个目录，那就将主页进行显示
   strcat(path, "/index.html");
  if ((st.st_mode & S_IXUSR) ||
      (st.st_mode & S_IXGRP) ||
      (st.st_mode & S_IXOTH)    )
      //S_IXUSR:文件所有者具可执行权限
      //S_IXGRP:用户组具可执行权限
      //S_IXOTH:其他用户具可读取权限
   cgi = 1;
  if (!cgi)
  //将静态文件返回
   serve_file(client, path);
  else
  //执行cgi动态解析
   execute_cgi(client, path, method, query_string);
 
 }
 
 close(client);//因为http是面向无连接的，所以要关闭
}
 
/**********************************************************************/
/* Inform the client that a request it has made has a problem.
 * Parameters: client socket */
/**********************************************************************/
void bad_request(int client)
{
 char buf[1024];
//发送400
 sprintf(buf, "HTTP/1.0 400 BAD REQUESTrn");
 send(client, buf, sizeof(buf), 0);
 sprintf(buf, "Content-type: text/htmlrn");
 send(client, buf, sizeof(buf), 0);
 sprintf(buf, "rn");
 send(client, buf, sizeof(buf), 0);
 sprintf(buf, "<P>Your browser sent a bad request, ");
 send(client, buf, sizeof(buf), 0);
 sprintf(buf, "such as a POST without a Content-Length.rn");
 send(client, buf, sizeof(buf), 0);
}
 
/**********************************************************************/
/* Put the entire contents of a file out on a socket.  This function
 * is named after the UNIX "cat" command, because it might have been
 * easier just to do something like pipe, fork, and exec("cat").
 * Parameters: the client socket descriptor
 *             FILE pointer for the file to cat */
/**********************************************************************/
void cat(int client, FILE *resource)
{
//发送文件的内容
 char buf[1024];
//读取文件到buf中
 fgets(buf, sizeof(buf), resource);
 while (!feof(resource))//判断文件是否读取到末尾
 {
 //读取并发送文件内容
  send(client, buf, strlen(buf), 0);
  fgets(buf, sizeof(buf), resource);
 }
}
 
/**********************************************************************/
/* Inform the client that a CGI script could not be executed.
 * Parameter: the client socket descriptor. */
/**********************************************************************/
void cannot_execute(int client)
{
 char buf[1024];
//发送500
 sprintf(buf, "HTTP/1.0 500 Internal Server Errorrn");
 send(client, buf, strlen(buf), 0);
 sprintf(buf, "Content-type: text/htmlrn");
 send(client, buf, strlen(buf), 0);
 sprintf(buf, "rn");
 send(client, buf, strlen(buf), 0);
 sprintf(buf, "<P>Error prohibited CGI execution.rn");
 send(client, buf, strlen(buf), 0);
}
 
/**********************************************************************/
/* Print out an error message with perror() (for system errors; based
 * on value of errno, which indicates system call errors) and exit the
 * program indicating an error. */
/**********************************************************************/
void error_die(const char *sc)
{
 perror(sc);
 exit(1);
}
 
/**********************************************************************/
/* Execute a CGI script.  Will need to set environment variables as
 * appropriate.
 * Parameters: client socket descriptor
 *             path to the CGI script */
/**********************************************************************/
//执行cgi动态解析
void execute_cgi(int client, const char *path,
                 const char *method, const char *query_string)
{
 char buf[1024];
 int cgi_output[2];//声明的读写管道，切莫被名称给忽悠，会给出图进行说明
 int cgi_input[2];//
 pid_t pid;
 int status;
 int i;
 char c;
 int numchars = 1;
 int content_length = -1;
 
 buf[0] = 'A'; buf[1] = '';
 if (strcasecmp(method, "GET") == 0)
 //如果是GET请求
 //读取并且丢弃头信息
  while ((numchars > 0) && strcmp("n", buf))
   numchars = get_line(client, buf, sizeof(buf));
 else  
 {
 //处理的请求为POST
  numchars = get_line(client, buf, sizeof(buf));
  while ((numchars > 0) && strcmp("n", buf))
  {//循环读取头信息找到Content-Length字段的值
   buf[15] = '';//目的是为了截取Content-Length:
 
   if (strcasecmp(buf, "Content-Length:") == 0)
    //"Content-Length: 15"
    content_length = atoi(&(buf[16]));//获取Content-Length的值
   numchars = get_line(client, buf, sizeof(buf));
  }
  if (content_length == -1) {
  //错误请求
   bad_request(client);
   return;
  }
 }
//返回正确响应码200
 sprintf(buf, "HTTP/1.0 200 OKrn");
 send(client, buf, strlen(buf), 0);
//#include<unistd.h>
//int pipe(int filedes[2]);
//返回值：成功，返回0，否则返回-1。参数数组包含pipe使用的两个文件的描述符。fd[0]:读管道，fd[1]:写管道。
//必须在fork()中调用pipe()，否则子进程不会继承文件描述符。
//两个进程不共享祖先进程，就不能使用pipe。但是可以使用命名管道。
//pipe(cgi_output)执行成功后，cgi_output[0]:读通道 cgi_output[1]:写通道，这就是为什么说不要被名称所迷惑
 if (pipe(cgi_output) < 0) {
  cannot_execute(client);
  return;
 }
 if (pipe(cgi_input) < 0) {
  cannot_execute(client);
  return;
 }
 
 if ( (pid = fork()) < 0 ) {
  cannot_execute(client);
  return;
 }
 //fork出一个子进程运行cgi脚本
 if (pid == 0)  /* 子进程: 运行CGI 脚本 */
 {
  char meth_env[255];
  char query_env[255];
  char length_env[255];
 
  dup2(cgi_output[1], 1);//1代表着stdout，0代表着stdin，将系统标准输出重定向为cgi_output[1]
  dup2(cgi_input[0], 0);//将系统标准输入重定向为cgi_input[0]，这一点非常关键，
                        //cgi程序中用的是标准输入输出进行交互
  close(cgi_output[0]);//关闭了cgi_output中的读通道
  close(cgi_input[1]);//关闭了cgi_input中的写通道
  //CGI标准需要将请求的方法存储环境变量中，然后和cgi脚本进行交互
  //存储REQUEST_METHOD
  sprintf(meth_env, "REQUEST_METHOD=%s", method);
  putenv(meth_env);
  if (strcasecmp(method, "GET") == 0) {
  //存储QUERY_STRING
   sprintf(query_env, "QUERY_STRING=%s", query_string);
   putenv(query_env);
  }
  else {   /* POST */
    //存储CONTENT_LENGTH
   sprintf(length_env, "CONTENT_LENGTH=%d", content_length);
   putenv(length_env);
  }
 // 表头文件#include<unistd.h>
 // 定义函数
 // int execl(const char * path,const char * arg,....);
 // 函数说明
 // execl()用来执行参数path字符串所代表的文件路径，接下来的参数代表执行该文件时传递过去的argv(0)、argv[1]……，最后一个参数必须用空指针(NULL)作结束。
 // 返回值
 // 如果执行成功则函数不会返回，执行失败则直接返回-1，失败原因存于errno中。
  execl(path, path, NULL);//执行CGI脚本
  exit(0);
 } else {    /* 父进程 */
  close(cgi_output[1]);//关闭了cgi_output中的写通道，注意这是父进程中cgi_output变量和子进程要区分开
  close(cgi_input[0]);//关闭了cgi_input中的读通道
  if (strcasecmp(method, "POST") == 0)
   for (i = 0; i < content_length; i++) {
    //开始读取POST中的内容
    recv(client, &c, 1, 0);
    //将数据发送给cgi脚本
    write(cgi_input[1], &c, 1);
   }
   //读取cgi脚本返回数据
  while (read(cgi_output[0], &c, 1) > 0)
    //发送给浏览器
   send(client, &c, 1, 0);
//运行结束关闭
  close(cgi_output[0]);
  close(cgi_input[1]);
//定义函数：pid_t waitpid(pid_t pid, int * status, int options);
//函数说明：waitpid()会暂时停止目前进程的执行, 直到有信号来到或子进程结束.
//如果在调用wait()时子进程已经结束, 则wait()会立即返回子进程结束状态值. 子进程的结束状态值会由参数status 返回,
//而子进程的进程识别码也会一快返回.
//如果不在意结束状态值, 则参数status 可以设成NULL. 参数pid 为欲等待的子进程识别码, 其他数值意义如下：
//1、pid<-1 等待进程组识别码为pid 绝对值的任何子进程.
//2、pid=-1 等待任何子进程, 相当于wait().
//3、pid=0 等待进程组识别码与目前进程相同的任何子进程.
//4、pid>0 等待任何子进程识别码为pid 的子进程.
  waitpid(pid, &status, 0);
 }
}
 
/**********************************************************************/
/* Get a line from a socket, whether the line ends in a newline,
 * carriage return, or a CRLF combination.  Terminates the string read
 * with a null character.  If no newline indicator is found before the
 * end of the buffer, the string is terminated with a null.  If any of
 * the above three line terminators is read, the last character of the
 * string will be a linefeed and the string will be terminated with a
 * null character.
 * Parameters: the socket descriptor
 *             the buffer to save the data in
 *             the size of the buffer
 * Returns: the number of bytes stored (excluding null) */
/**********************************************************************/
//解析一行http报文
int get_line(int sock, char *buf, int size)
{
 int i = 0;
 char c = '';
 int n;
 
 while ((i < size - 1) && (c != 'n'))
 {
  n = recv(sock, &c, 1, 0);
  /* DEBUG printf("%02Xn", c); */
  if (n > 0)
  {
   if (c == 'r')
   {
    n = recv(sock, &c, 1, MSG_PEEK);
    /* DEBUG printf("%02Xn", c); */
    if ((n > 0) && (c == 'n'))
     recv(sock, &c, 1, 0);
    else
     c = 'n';
   }
   buf[i] = c;
   i++;
  }
  else
   c = 'n';
 }
 buf[i] = '';
 
 return(i);
}
 
/**********************************************************************/
/* Return the informational HTTP headers about a file. */
/* Parameters: the socket to print the headers on
 *             the name of the file */
/**********************************************************************/
void headers(int client, const char *filename)
{
 char buf[1024];
 (void)filename;  /* could use filename to determine file type */
//发送HTTP头
 strcpy(buf, "HTTP/1.0 200 OKrn");
 send(client, buf, strlen(buf), 0);
 strcpy(buf, SERVER_STRING);
 send(client, buf, strlen(buf), 0);
 sprintf(buf, "Content-Type: text/htmlrn");
 send(client, buf, strlen(buf), 0);
 strcpy(buf, "rn");
 send(client, buf, strlen(buf), 0);
}
 
/**********************************************************************/
/* Give a client a 404 not found status message. */
/**********************************************************************/
void not_found(int client)
{
 char buf[1024];
 //返回404
 sprintf(buf, "HTTP/1.0 404 NOT FOUNDrn");
 send(client, buf, strlen(buf), 0);
 sprintf(buf, SERVER_STRING);
 send(client, buf, strlen(buf), 0);
 sprintf(buf, "Content-Type: text/htmlrn");
 send(client, buf, strlen(buf), 0);
 sprintf(buf, "rn");
 send(client, buf, strlen(buf), 0);
 sprintf(buf, "<HTML><TITLE>Not Found</TITLE>rn");
 send(client, buf, strlen(buf), 0);
 sprintf(buf, "<BODY><P>The server could not fulfillrn");
 send(client, buf, strlen(buf), 0);
 sprintf(buf, "your request because the resource specifiedrn");
 send(client, buf, strlen(buf), 0);
 sprintf(buf, "is unavailable or nonexistent.rn");
 send(client, buf, strlen(buf), 0);
 sprintf(buf, "</BODY></HTML>rn");
 send(client, buf, strlen(buf), 0);
}
 
/**********************************************************************/
/* Send a regular file to the client.  Use headers, and report
 * errors to client if they occur.
 * Parameters: a pointer to a file structure produced from the socket
 *              file descriptor
 *             the name of the file to serve */
/**********************************************************************/
//将请求的文件发送回浏览器客户端
void serve_file(int client, const char *filename)
{
 FILE *resource = NULL;
 int numchars = 1;
 char buf[1024];
 
 buf[0] = 'A'; buf[1] = '';//这个赋值不清楚是干什么的
 while ((numchars > 0) && strcmp("n", buf)) //将HTTP请求头读取并丢弃
  numchars = get_line(client, buf, sizeof(buf));
//打开文件
 resource = fopen(filename, "r");
 if (resource == NULL)
 //如果文件不存在，则返回not_found
  not_found(client);
 else
 {
 //添加HTTP头
  headers(client, filename);
 //并发送文件内容
  cat(client, resource);
 }
 fclose(resource);//关闭文件句柄
}
 
/**********************************************************************/
/* This function starts the process of listening for web connections
 * on a specified port.  If the port is 0, then dynamically allocate a
 * port and modify the original port variable to reflect the actual
 * port.
 * Parameters: pointer to variable containing the port to connect on
 * Returns: the socket */
/**********************************************************************/
//启动服务端
int startup(u_short *port)
{
 int httpd = 0;
 struct sockaddr_in name;
//设置http socket
 httpd = socket(PF_INET, SOCK_STREAM, 0);
 if (httpd == -1)
  error_die("socket");
 memset(&name, 0, sizeof(name));
 name.sin_family = AF_INET;
 name.sin_port = htons(*port);
 name.sin_addr.s_addr = htonl(INADDR_ANY);
 //绑定端口
 if (bind(httpd, (struct sockaddr *)&name, sizeof(name)) < 0)
  error_die("bind");
 if (*port == 0)  /*动态分配一个端口 */
 {
  int namelen = sizeof(name);
  if (getsockname(httpd, (struct sockaddr *)&name, &namelen) == -1)
   error_die("getsockname");
  *port = ntohs(name.sin_port);
 }
 //监听连接
 if (listen(httpd, 5) < 0)
  error_die("listen");
 return(httpd);
}
 
/**********************************************************************/
/* Inform the client that the requested web method has not been
 * implemented.
 * Parameter: the client socket */
/**********************************************************************/
void unimplemented(int client)
{
 char buf[1024];
//发送501说明相应方法没有实现
 sprintf(buf, "HTTP/1.0 501 Method Not Implementedrn");
 send(client, buf, strlen(buf), 0);
 sprintf(buf, SERVER_STRING);
 send(client, buf, strlen(buf), 0);
 sprintf(buf, "Content-Type: text/htmlrn");
 send(client, buf, strlen(buf), 0);
 sprintf(buf, "rn");
 send(client, buf, strlen(buf), 0);
 sprintf(buf, "<HTML><HEAD><TITLE>Method Not Implementedrn");
 send(client, buf, strlen(buf), 0);
 sprintf(buf, "</TITLE></HEAD>rn");
 send(client, buf, strlen(buf), 0);
 sprintf(buf, "<BODY><P>HTTP request method not supported.rn");
 send(client, buf, strlen(buf), 0);
 sprintf(buf, "</BODY></HTML>rn");
 send(client, buf, strlen(buf), 0);
}
 
/**********************************************************************/
 
int main(void)
{
 int server_sock = -1;
 u_short port = 0;
 int client_sock = -1;
 struct sockaddr_in client_name;
 int client_name_len = sizeof(client_name);
 pthread_t newthread;
//启动server socket
 server_sock = startup(&port);
 
 printf("httpd running on port %dn", port);
 
 while (1)
 {
 //接受客户端连接
  client_sock = accept(server_sock,
                       (struct sockaddr *)&client_name,
                       &client_name_len);
  if (client_sock == -1)
   error_die("accept");
 /*启动线程处理新的连接 */
 if (pthread_create(&newthread , NULL, accept_request, client_sock) != 0)
   perror("pthread_create");
 }
//关闭server socket
 close(server_sock);
 
 return(0);
}

SOAP协议

基本介绍

SOAP(Simple Object Accrss Protocol，简单对象访问协议的)是一种简单的基于XML的协议，可以使应用程序在分散或分布式的环境中通过HTTP，SMTP等协议来交互信息。

XML：一种可拓展标记语言，被设计用来传输和存储数据；
XML命名空间：用来避免元素命名冲突。

<?xml version="1.0"encoding="UTF-8"?>
<name>Expl0rer</name>
<age input="num">18</age>
<sex>male</sex>
</info>

XMLNS：前缀标识="用于标示命名空间的地址"

<?xml version="1.0"encoding="UTF-8"?>
<h:info xmlns:h="http://test.gov/id=001">
	<h:name>Expl0rer</h:name>
	<h:age input="num">18</h:age>
	<h:sex>male</h:sex>
</h:info>

SOAP 协议的组成

SOAP 消息封装（SOAP Envelope）

定义整个 SOAP 消息的框架。描述消息内容、接收者、处理方式，就是前面讲的 Envelope、Header、Body、Fault 整套信封结构。
SOAP 编码规则（SOAP Encoding Rules）

定义数据序列化机制，规定如何把程序的数据类型对象编码成 XML，用于交换自定义数据。
SOAP RPC 表示（SOAP RPC Representation）

定义远程过程调用（RPC）与返回应答的表示方法，描述如何用 SOAP 实现函数调用。
SOAP 绑定（SOAP Binding）

定义 SOAP 信封怎么映射到底层传输协议（HTTP、SMTP 等），最常用绑定 HTTP 协议传输 SOAP 报文。

语法规则

SOAP消息必须使用XML来编码
SOAP消息必须使用SOAP Envelope命名空间
SOAP消息必须使用SOAP EncodingStyle命名空间
SOAP消息不能包含DTD引用
SOAP消息不能包含XML处理指令

SOAP消息的基本结构

一条 SOAP 消息就是 XML 文档，4 个部分：

Envelope（信封）

根标签，标识这是一条 SOAP 消息，是整个报文的容器。
Header（消息头）

存放附加控制信息：鉴权、token、路由、事务。可以被中间节点处理。没有业务数据。
Body（消息体）

存放真正业务数据，RPC 调用方法、参数、返回结果都在这里。
Fault（故障）

只有出错的时候才出现，保存错误码、错误描述信息。

<soap:Envelope>
    <soap:Header>
        <!-- 可选：认证、路由等控制信息 -->
    </soap:Header>
    <soap:Body>
        <!-- 业务请求/响应数据 -->
        <soap:Fault>
            <!-- 可选，发生错误才存在，错误信息 -->
        </soap:Fault>
    </soap:Body>
</soap:Envelope>

这个就是SOAP报文实例了，它是用wireshark抓到的报文：

左边图片中：红色的是请求部分，蓝色的是响应部分。

IOT-Web安全分析

常见的嵌入式Web系统：

Lighttpd
Goahead
Shttpd
Thttpd
Boa
Mini_httpd
Appweb

这些全部都是嵌入式轻量 Web 服务器（IoT 设备常见）

而我们生活中计算机常见的比如阿帕奇等这些服务器系统适用于大型的服务器，而路由设备这些都是属于小型固件。

常见漏洞类型

敏感信息泄露
任意文件下载/读取
未授权访问
XSS
（远程）命令执行

信息泄露

（1）漏洞描述：敏感信息包括但不限于口令，秘钥，证书，会话标识，License,隐私数据，授权凭据,个人数据(如姓名,地址，电话等),在程序文件，配置文件,日志文件，备份文件，固件中都有可能包含敏感信息。

（2) 检测方法：

工具,爬虫等扫描获得敏感信息,敏感文件路径；、
手工挖据，根据web容器或网页源代码获得敏感信息。

任意文件下载

（1）漏洞描述：任意文件下载漏洞，正常的利用手段是下载服务器文件，如脚本代码，服务器配置或者是系统配置等等，在能提取固件的情况下能够很好的获得文件路径；

（2) 任意文件下载危害：下载服务器任意文件，如脚本代码、服务及系统配置文件等，在这些文件中能获得一些敏感的信息等数据。

在Linux操作系统中，/etc/passwd文件中的每个用户都有一个对应的记录行，记录着这个用户的一下基本属性，该文件对所有用户可读。

/etc/passwd中一行记录对应着一个用户，每行记录又被冒号:分隔为7个字段：

用户名（login name）
口令（passwd）
用户标识号(UID）
组标识号(GD）
注释性描述(users）
主目录(home directory）
登录Shell (Shell）

/etc/shadow是/etc/passwd的影子文件，漏洞影响版本：固件< 2.27 漏洞防御：中间件配置时严格限定用户访问权限。

如果root密码较简单就能直接暴力破解获root权限密码。

未授权访问

（1）漏洞描述：服务端未授权访问可以理解为需要安全配置或权限认证的地址、授权页面存在缺陷，导致其他用户可以直接访问，从而引发重要权限可被操作、网站口录等敏感信息泄露；

（2) 未授权访问危害：未授权访问能引发重要权限可被操作、任意用户登录、网站日录、用户密码等敏感信息泄露。

命令执行

（1）漏洞原理：命令执行漏洞介绍当应用需要调用一些外部程序去处理内容的情况下，就会用到，一些执行系统命令的函数；

（2）命令执行危害：根据不同用户权限,能执行任意命令，造成的后果十分严重，稍加利用就能够获得shell。