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。

Web安全 on Expl0rer.Ct