0. 前言知识
- 应用层:就是程序员基于socket接口之上编写的具体逻辑,做了很多工作,都是和文本处理有关的--- 协议分析与处理
- http协议,一定会具有大量的文体分析和协议处理
- 如果用户想在url中包含url本身用来作为特殊字符的字符,url形式的时候,浏览器会自动给我们进行编码encode
- 一般服务端收到之后,需要进行转回特殊字符
1. 快速构建http请求和响应的报文格式
HttpServer.cc
#include <iostream>
#include <memory>
#include <cassert>
#include <fstream>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "HttpServer.hpp"
#include "Usage.hpp"
#include "Util.hpp"
// 一般http都要有自己的web根目录
#define ROOT "./wwwroot" // ./wwwroot/index.html
// 如果客户端只请求了一个/,我们返回默认首页
#define HOMEPAGE "index.html"
void HandlerHttpRequest(int sockfd)
{
// 1. 读取请求 for test
char buffer[10240];
ssize_t s = recv(sockfd, buffer, sizeof(buffer) - 1, 0);
if (s > 0)
{
buffer[s] = 0;
// std::cout << buffer << "--------------------\n" << std::endl;
}
std::vector<std::string> vline;
Util::cutString(buffer, "\n", &vline);
std::vector<std::string> vblock;
Util::cutString(vline[0], " ", &vblock);// 拿到请求行
std::string file = vblock[1];// cilent想要的文件名
std::string target = ROOT;
if(file == "/") file = "/index.html";
target += file;
std::cout << target << std::endl;
// 打开这个文件,再从这个文件中拿数据
std::string content;
std::ifstream in(target);
if(in.is_open())
{
std::string line;
while(std::getline(in, line))
{
content += line;
}
in.close();
}
std::string HttpResponse;
if(content.empty()) {
HttpResponse = "HTTP/1.1 404 NotFound\r\n";
}
else {
HttpResponse = "HTTP/1.1 200 OK\r\n";
}
HttpResponse += "\r\n";
HttpResponse += content;
// 2. 试着构建一个http的响应
send(sockfd, HttpResponse.c_str(), HttpResponse.size(), 0);
}
int main(int argc, char *argv[])
{
if (argc != 2)
{
Usage(argv[0]);
exit(0);
}
std::unique_ptr<HttpServer> httpserver(new HttpServer(atoi(argv[1]), HandlerHttpRequest));
httpserver->Start();
return 0;
}
HttpServer.hpp
#pragma once
#include <iostream>
#include <signal.h>
#include <functional>
#include "Sock.hpp"
class HttpServer
{
public:
using func_t = std::function<void(int)>;// 包装器->函数
private:
int listensock_;// 监听
uint16_t port_;
Sock sock;// 套接字
func_t func_;
public:
HttpServer(const uint16_t &port, func_t func): port_(port),func_(func)
{
listensock_ = sock.Socket();
sock.Bind(listensock_, port_);// 绑定
sock.Listen(listensock_);// 监听
}
void Start()
{
signal(SIGCHLD, SIG_IGN);// 解决父进程需要进程等待的问题
for( ; ; )
{
std::string clientIp;
uint16_t clientPort = 0;
int sockfd = sock.Accept(listensock_, &clientIp, &clientPort);
if(sockfd < 0) continue;
if(fork() == 0)
{
close(listensock_);
func_(sockfd);
close(sockfd);
exit(0);
}
close(sockfd);
}
}
~HttpServer()
{
if(listensock_ >= 0) close(listensock_);
}
};
Log.hpp
#pragma once
#include <iostream>
#include <cstdio>
#include <cstdarg>
#include <ctime>
#include <string>
// 日志是有日志级别的
#define DEBUG 0
#define NORMAL 1
#define WARNING 2
#define ERROR 3
#define FATAL 4
const char *gLevelMap[] = {
"DEBUG",
"NORMAL",
"WARNING",
"ERROR",
"FATAL"
};
#define LOGFILE "./calculator.log"
// 完整的日志功能,至少: 日志等级 时间 支持用户自定义(日志内容, 文件行,文件名)
void logMessage(int level, const char *format, ...)
{
#ifndef DEBUG_SHOW
if(level== DEBUG) return;
#endif
char stdBuffer[1024]; //标准部分
time_t timestamp = time(nullptr);
snprintf(stdBuffer, sizeof stdBuffer, "[%s] [%ld] ", gLevelMap[level], timestamp);
char logBuffer[1024]; //自定义部分
va_list args;
va_start(args, format);
vsnprintf(logBuffer, sizeof logBuffer, format, args);
va_end(args);
FILE *fp = fopen(LOGFILE, "a");
fprintf(fp, "%s%s\n", stdBuffer, logBuffer);
fclose(fp);
}
makefile
HttpServer:HttpServer.cc
g++ -o $@ $^ -std=c++11 -lpthread
.PHONY:clean
clean:
rm -f HttpServer
Sock.hpp
#pragma once
#include <iostream>
#include <string>
#include <cstring>
#include <cerrno>
#include <cassert>
#include <unistd.h>
#include <memory>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <ctype.h>
#include "Log.hpp"
class Sock
{
private:
const static int gbacklog = 20;
public:
Sock() {}
// 创建套接字
int Socket()
{
int listensock = socket(AF_INET, SOCK_STREAM, 0);
if (listensock < 0)
{
logMessage(FATAL, "create socket error, %d:%s", errno, strerror(errno));
exit(2);
}
logMessage(NORMAL, "create socket success, listensock: %d", listensock);
return listensock;
}
// 绑定
void Bind(int sock, uint16_t port, std::string ip = "0.0.0.0")
{
struct sockaddr_in local;
memset(&local, 0, sizeof local);
local.sin_family = AF_INET;
local.sin_port = htons(port);
inet_pton(AF_INET, ip.c_str(), &local.sin_addr);
if (bind(sock, (struct sockaddr *)&local, sizeof(local)) < 0)
{
logMessage(FATAL, "bind error, %d:%s", errno, strerror(errno));
exit(3);
}
}
// 监听
void Listen(int sock)
{
if (listen(sock, gbacklog) < 0)
{
logMessage(FATAL, "listen error, %d:%s", errno, strerror(errno));
exit(4);
}
logMessage(NORMAL, "init server success");
}
// 一般经验
// const std::string &: 输入型参数
// std::string *: 输出型参数
// std::string &: 输入输出型参数
int Accept(int listensock, std::string *ip, uint16_t *port)
{
struct sockaddr_in src;
socklen_t len = sizeof(src);
int servicesock = accept(listensock, (struct sockaddr *)&src, &len);
if (servicesock < 0)
{
logMessage(ERROR, "accept error, %d:%s", errno, strerror(errno));// 转移
return -1;
}
if(port) *port = ntohs(src.sin_port);
if(ip) *ip = inet_ntoa(src.sin_addr);
return servicesock;
}
// 连接
bool Connect(int sock, const std::string &server_ip, const uint16_t &server_port)
{
struct sockaddr_in server;
memset(&server, 0, sizeof(server));
server.sin_family = AF_INET;
server.sin_port = htons(server_port);
server.sin_addr.s_addr = inet_addr(server_ip.c_str());
if(connect(sock, (struct sockaddr*)&server, sizeof(server)) == 0) return true;
else return false;
}
~Sock() {}
};
Usage.hpp
#pragma once
#include <iostream>
#include <string>
void Usage(std::string proc)
{
std::cout << "\nUsage: " << proc << " port\n" << std::endl;
}
Util.hpp
#pragma once
#include <iostream>
#include <vector>
class Util
{
public:
// aaaa\r\nbbbbb\r\nccc\r\n\r\n
// 按sep分割符,分割字符
static void cutString(std::string s, const std::string &sep, std::vector<std::string> *out)
{
std::size_t start = 0;
while (start < s.size())
{
auto pos = s.find(sep, start);
if (pos == std::string::npos) break;
std::string sub = s.substr(start, pos - start);
// std::cout << "----" << sub << std::endl;
out->push_back(sub);
start += sub.size();
start += sep.size();
}
if(start < s.size()) {
out->push_back(s.substr(start));
}
}
};
2. HTTP协议格式
2.1 HTTP请求
- get方法通过url传参,回显输入的私密信息,不够私密
- post方法通过正文提交参数,不会回显,一般私密性是有保证的
- 注: 私密性不是安全,加密和解密才是安全
- Connection: keep-alive 长连接
- Connection:close 短连接
2.2 HTTP响应
2.3 HTTP的状态码
- 301是永久重定向,302和307是临时重定向
3. 会话管理
- http的特征:1.简单快速,2.无连接,3.无状态
- 虽然http没有状态,但是tpc套接字是有状态的
- 在我们使用网站并登上账号的时候,cookie会记录我们的信息,并通过算法形成唯一的ID
4. HTTPS协议介绍
- HTTPS实际就是在应用层和传输层协议之间加了一层加密层(SSL&TLS),
- 这层加密层本身也是属于应用层的,它会对用户的个人信息进行各种程度的加密。
- HTTPS在交付数据时先把数据交给加密层,由加密层对数据加密后再交给传输层。
4.1 对称加密 vs 非对称加密
- 采用单钥密码系统的加密方法,同一个密钥可以同时用作信息的加密和解密,这种加密方法称为对称加密。
- 采用公钥和私钥来进行加密和解密,用其中一个密钥进行加密就必须用另一个密钥进行解密,这种加密方法称为非对称加密
4.2 各种加密方案
4.3 MITL攻击
4.4 CA证书
当服务端申请CA证书的时候,CA机构会对该服务器进行审核,并专门为该网站形成数字签名,过程如下
- CA机构拥有非对称加密的私钥A和公钥A`
- CA机构对服务端申请的证书明文数据进行hash,形成数据摘要
- 然后对数据摘要用CA私钥A`加密,得到数字签名S
4.5 非对称加密 + 对称加密 + CA认证