【Linux网络编程七】网络序列化和反序列化(网络版本计算器)

最新推荐文章于 2024-10-10 22:13:52 发布
最新推荐文章于 2024-10-10 22:13:52 发布
阅读量1.1k 收藏 27
点赞数 30
分类专栏： Linux网络编程 文章标签： linux 网络 php
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/extreme_wei/article/details/136716018
版权

【Linux网络编程七】网络序列化和反序列化(网络版本计算器）

一.网络读取问题

在网络通信时，通信双方是无法保证读取时，能够正确的读取到想要的内容的。
这是什么意思呢？
在这里插入图片描述

【解决方案】

在这里插入图片描述

1.定制协议

什么叫定制协议呢？就是让双方都要能知道，约定好的一些字段，然后以结构化的形式发送和接收。
在这里插入图片描述
定制的协议双方都要能认识才可以通信。不然一方认识，另一方不认识就无法通信了。
在这里插入图片描述

2.序列化和反序列化

定制好结构体后，然后构建一个对象，是不是就可以直接发送过去了呢？
当然不可以！为什么呢？

1.我们不能直接将结构体对象直接发送给对端机器，因为双方可能机器不同，对于结构体的解读会不一样，最终就会解析错误。所以通常我们不直接发送结构化数据到网络里，而是发送字符串形式的数据给对端。
2.也就是我们需要在构建完结构化数据后，在发送到网络里之前还需要将它转换成字符串形式，才能发送。这个过程就叫做序列化
3.而对端机器从网络里接收到字符串后，它并不认识这个字符串是什么意思，只有将这个字符串转成结构化化数据，它才能知道对方发送的是什么信息。而将字符串数据再转成结构化数据，就叫做反序列化。
在这里插入图片描述

在这里插入图片描述

这里是引用

3.添加报头

那么问题又回来了，对端是如何正确获取到想要的完整报文的呢？
在这里插入图片描述

我们可以利用一些特殊字符，来区别报文与报文。而如果想要对方准确的接收到一个完整的报文，那么就可以通过在报文前面添加一个长度单位，标识这个报文总长度有多少，一旦对端读取到这个长度，就可以直接从后面截取报文的长度，就可以直接完整的获取到一个报文。
而在报文前面添加一个长度单位这个行为，我们可以称为添加一个报头。

添加报头的目的就是为了让对端在读取的时候，能够根据报头，来完整的获取一个报文。所以添加报头也是属于定制协议的部分。通信的双方都要能识别。

①封包

所以构建完结构化数据后，在发送到网络之前，需要将之转换成字符串形式，也就是序列化。然后为了让对端能够准确的获取到一个完整的报文，我们还需要对这个字符串添加报头。

这里是引用

②解包

对端获取到从网络里发送来的数据后，并不理解是什么意思，所以需要反序列化，将字符串数据转换成结构化数据，这样它就可以理解是什么意思了。
但是这里存在的问题就是：它并不能确定对方发送的是一个报文还是多个报文，还是半个报文。因为从网络里发送来的就是一个字符串形式的数据。它分析不出来。而反序列化，是以一个完整的报文进行反序列化的，因为当时序列化的时候就是一个完整的结构体数据进行序列化的。

所以定制协议的人，考虑到这点，就在报文的前面添加了一个报头：表明报文的长度的字段。这样只要对端接收到报文，然后依据报头，就能分析出对方发送的数据是否是完整的了。如果是完整的，那么直接获取有效的报文。如果不是完整的，那么重新去读取，如果是多个报文，那么我们只要一个完整的报文即可。剩下的等下次再处理。

这里是引用

4.框架总结

这里是引用

在这里插入图片描述
在这里插入图片描述

网络部分套接字：

Socket.hpp
#pragma once
//将网络套接字编程部分直接封装打包，因为服务器和客户端都需要使用创建套接字等操作。
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "Log.hpp"
#include <cstdlib>
#include <cstring>
#include <unistd.h>
enum
{
  SocketErr=1,
  BindErr,
  ListenErr,
};
const int backlog=10;
class Sock
{

public:
    Sock()
    {}
    ~Sock()
    {}

    void Socket()//创建套接字
    {
     _socket=socket(AF_INET,SOCK_STREAM,0);
     if(_socket<0)
     {
        lg(Fatal,"socket err:%s :%d",strerror(errno),errno);
        exit(SocketErr);
     }
    }
    void Bind(uint16_t &port)//绑定套接字
    {
      struct sockaddr_in local;
      memset(&local,0,sizeof(local));
      local.sin_addr.s_addr=INADDR_ANY;//将ip地址初始化成0
      local.sin_family=AF_INET;
      local.sin_port=htons(port);
      if(bind(_socket,(struct sockaddr*)&local,sizeof(local))<0)
      {
        lg(Fatal,"bind err :%s :%d",strerror(errno),errno);
        exit(BindErr);
      }
    }
    void Listen()//将套接字设置成监听状态
    {
       if(listen(_socket,backlog)<0)
       {
        lg(Fatal,"listen err :%s :%d",strerror(errno),errno);
        exit(ListenErr);
       }
    }
    int Accept(std::string *clientip,std::uint16_t* clientport)//服务器获取连接，并获取对方的网络信息,将获取的到的新连接交给服务函数操作
    {
        struct sockaddr_in client;
        socklen_t len=sizeof(client);
        int newsock=accept(_socket,(struct sockaddr*)&client,&len);
        if(newsock<0)
        {
            lg(Warning,"accept err :%s :%d",strerror(errno),errno);
            return -1;
        }
        *clientport=ntohs(client.sin_port);
        char Clientip[32];
        inet_ntop(AF_INET,&client.sin_addr,Clientip,sizeof(Clientip));
        *clientip=Clientip;
        return newsock;
    }
    bool Connect(const std::string &serverip,const uint16_t &serverport)//需要知道要连接的对方的网络信息
    {
        struct sockaddr_in local;
        socklen_t len=sizeof(local);
        memset(&local,0,sizeof(local));
        local.sin_family=AF_INET;
        local.sin_port=htons(serverport);
        inet_pton(AF_INET,serverip.c_str(),&local.sin_addr);
     
        int n=connect(_socket,(struct sockaddr*)&local,len);
        if(n==-1)
        {
            std::cerr<<"connect to"<<serverip<<":"<<serverport<<"error"<<std::endl;
            return false;
        }
        return true;
    }
    void Close()
    {
        close(_socket);
    }
    int Fd()
    {
      return _socket;
    }
private: 
  int _socket;
};

协议部分

Protocol.hpp
#pragma once
//#define MySelf 1
// 在网络通信之前，我们服务器端和客户端都需要知道协议。我们也可以自己定制协议，这个协议要被双方都能识别
// 比如我们可以定制一个计数器协议。协议就是一种约定，除了数据本身还有其他的字段。
// 1.我们要求将数据以结构化的形式保存这样双方都可以识别这个结构体对象，但传入网络里时，需要转换成字符类型。这个过程就是序列化.序列化的过程就是在构建有效载荷
// 2.对方接收到字符串类型的数据时，想要用服务操作时，发现是不能操作的，是因为它不认识，这时还需要将字符类型转成结构体类型，这个过程叫做反序列化。
// 3.为了能让对方接收时，能接收读取到对方想要的完整报文时，我们采取添加报头的形式来解决。
// 4.所以在将报文传入到网络里时，还需要添加报文，当对端接收到报文时，想要对它进行处理之前，还需要将报文的报头解包才可以正确处理。
#include <iostream>
#include <jsoncpp/json/json.h>
#include <string>
const std::string blank_space = " ";
const std::string protocol_space="\n";
// 封包：报文在发送到网络之前需要添加一些报头，来达到一些要求
std::string Encode(const std::string &content)//content就是有效载荷
{
  //"x + y"------>"len"\n"x + y"\n"   添加了一个报文长度和两个\n
  std::string packpage=std::to_string(content.size());
  packpage+=protocol_space;
  packpage+=content;
  packpage+=protocol_space;
  return packpage;
}

// 解包：对端读取到报文(可能读取到的不是想要的，根据原先添加上去的报头来获取准确想要的报文)，想要处理它，需要先解除报头才能处理
bool Decode(std::string &packpage, std::string *content)
{ 
  //"len"\n"x + y"\n"---->"x + y"
  std::size_t pos=packpage.find(protocol_space);
  if(pos==std::string::npos)
  return false;

  std::string len_str=packpage.substr(0,pos);
  //判断一下是否读取的内容是全部的
  std::size_t len =std::stoi(len_str);
  std::size_t total_len=len_str.size()+len+2;
  if(packpage.size()<total_len)//说明不是一个完整的报文
  return false;
  *content=packpage.substr(pos+1,len);
  //为了真正的拿走报文，还需要将响应inbuffer里的报文移除erase，这样才是真正的拿走报文
  
  packpage.erase(0,total_len);
  return true;
}

class Request
{
public:
  Request()
  {}
  Request(int data1, int data2, char op) : _x(data1), _y(data2), _op(op) // 最初形成结构化数据
  {
  }
  bool Serialize(std::string *out) // 序列化，单纯的就是将结构体转换成字符串
  {
#ifdef MySelf    // 构建报文的有效载荷
    // struct==》"x + y"
    std::string s = std::to_string(_x);
    s += blank_space;
    s += _op;
    s += blank_space;
    s += std::to_string(_y);
    *out = s;
    return true;
 #else
     Json::Value root;//定义一个万能对象，可以存储数据，k-v形式的结构体
     root["x"]=_x;
     root["y"]=_y;
     root["op"]=_op;
     //Json::FastWriter w;
     Json::StyledWriter w;
     *out=w.write(root);//序列化成字符串
     return true;   
    
 #endif

  }
  bool Deserialize(std::string &in) // 反序列化，就单纯的将字符串类型转成结构体
  {
#ifdef MySelf   
    //"x + y"==>struct
    //获取左操作数x
    std::size_t left=in.find(blank_space);
    if(left==std::string::npos)
    return false;
    std::string part_x=in.substr(0,left);
    //获取右操作数y
    std::size_t right=in.rfind(blank_space);
    if(right==std::string::npos)
    return false;
    std::string part_y=in.substr(right+1);
    //获取操作码op
    if(left+2!=right)
    return false;

    _op=in[left+1];
    _x=std::stoi(part_x);
    _y=std::stoi(part_y);
    return true;
#else
    Json::Value root;//定义一个万能对象，将序列化的数据存储在里面
    Json::Reader r;
    r.parse(in,root);
    //将数据存到万能对象里后，我们就可以根据key值找到
    _x=root["x"].asInt();
    _y=root["y"].asInt();
    _op=root["op"].asInt();
    return true;
#endif    
  }
    void DebugPrint()
    {
        std::cout<<"新请求构建完毕："<<_x<<_op<<_y<<"=???"<<std::endl;
    }
public: // x + y
  int _x;
  int _y;
  char _op;
};
class Response
{
public:
  Response(int reslut, int code) : _reslut(reslut), _code(code)
  {
  }
  Response()
  {}
  bool Serialize(std::string *out) // 序列化，单纯的就是将结构体转换成字符串
  {
#ifdef MySelf
    //"reslut code"
    //构建报文的有效载荷
    std::string s=std::to_string(_reslut);
    s+=blank_space;
    s+=std::to_string(_code);
    *out=s;
    return true;
#else
     Json::Value root;
     root["reslut"]=_reslut;
     root["code"]=_code;
     //Json::FastWriter w;
     Json::StyledWriter w;
     *out=w.write(root);
     return true;
#endif    
  }
   bool Deserialize(std::string &in)
   {
#ifdef MySelf
    //"reslut code"-->结构体类型
    std::size_t pos=in.find(blank_space);
    if(pos==std::string::npos)
    return false;

    std::string part_left=in.substr(0,pos);
    std::string part_right=in.substr(pos+1);

    _reslut=std::stoi(part_left);
    _code=std::stoi(part_right);
    return true;
#else
    Json::Value root;
    Json::Reader r;
    r.parse(in,root);//将字符串数据存到万能对象里

    _reslut=root["reslut"].asInt();
    _code=root["code"].asInt();
    return true;
#endif
   }

   void DebugPrint()
   {
    std::cout<<"结果响应完成,reslut: "<<_reslut<<",code: "<<_code<<std::endl;
   }

public:
  int _reslut;
  int _code;
};

服务器服务部分：

ServerCal.hpp
#pragma once
#include "Protocol.hpp"
#include <iostream>
#include <string>
// 服务器端，从网络里读取到数据后，就要进行处理服务。
// 1.首先需要对报文进行解包，2.解包后还需要将报文转成结构体类型对方才能识别
enum
{
  Div_Zero = 1,
  Mod_Zero,
  Other_Oper
} ;
class ServerCal
{
public:
  Response Calculatorhelpor(const Request &req)
  {
    Response resp(0, 0);
    switch (req._op)
    {
    case '+':
      resp._reslut = req._x + req._y;
      break;
    case '-':
      resp._reslut = req._x - req._y;
      break;
    case '*':
      resp._reslut = req._x * req._y;
      break;
    case '/':
    {
      if (req._y == 0)
        resp._code = Div_Zero;
      else
        resp._reslut = req._x / req._y;
    }
    break;
    case '%':
    {
      if (req._y == 0)
        resp._code = Mod_Zero;
      else
        resp._reslut = req._x % req._y;
    }
    break;

    default:
     resp._code=Other_Oper;
      break;
    }
    return resp;
  }

  std::string Calculator(std::string &package)
  {
    std::string content;                //"len""\n""20 + 10""\n"
    bool r = Decode(package, &content); //"20 + 10"
    if (!r)
      return "";
    Request req; // 反序列化
    r = req.Deserialize(content);
    if (!r)
      return "";

    // 服务器端解包获取到报文后，就可以进行计算，再将计算结果返回回到网络里,网络里需要序列化的数据

    Response res = Calculatorhelpor(req); // reslut=30  code=0
    content = "";
    res.Serialize(&content);   //"30 0"
    content = Encode(content); //"len""\n""30 0""\n"

    return content;
  }
};

二.自定义协议：网络计算器协议

Ⅰ.客户端发送请求，服务器端接收请求

ClientCal.cc
#include <iostream>
#include <time.h>
#include <unistd.h>
#include <assert.h>
#include "Socket.hpp"
#include "Protocol.hpp"
void Usage(std::string proc)
{
    std::cout<<"\n\rUsage: "<<proc<<" port[1024+]\n"<<std::endl;
}
//./tcpclient ip port
int main(int args,char* argv[])
{
    if(args!=3)
    {
     Usage(argv[0]);
     exit(1);
    }
    std::string serverip=argv[1];
    uint16_t serverport=std::stoi(argv[2]);
    
    Sock sockfd;
    sockfd.Socket();//创建套接字
    bool r=sockfd.Connect(serverip,serverport);//发起连接
    if(!r)return 1;

    
    srand(time(nullptr)^getpid());
    int cnt=1;
    std::string oper="+-*/%=$";
    std::string inbuffer_stream;
    while(cnt<=10)
    {
        std::cout<<"========第"<<cnt<<"次测试"<<"============"<<std::endl;
        //1.开始构建请求
        int x=rand()%100+1;
        usleep(1234);
        int y=rand()%100;
        usleep(4321);
        char op=oper[rand()%oper.size()];
        Request req(x,y,op);
        //2.请求构建完毕
        req.DebugPrint();
        //3.数据序列化形成报文
        std::string content;
        req.Serialize(&content);
        //4.添加报头
        std::string packpage=Encode(content);
        //5.发送到网络里
        write(sockfd.Fd(),packpage.c_str(),packpage.size());

        //6.接收服务器端发送来的响应
        char buffer[128];
        ssize_t n=read(sockfd.Fd(),buffer,sizeof(buffer));
       //6.1处理读取
        if(n>0)
        {
            buffer[n]=0;
            inbuffer_stream+=buffer;//接收到的是一个协议报文"len"\n"reslut code"\n
            std::cout<<std::endl;
            std::cout<<"获取到的网络答应："<<std::endl;
            std::cout<<inbuffer_stream<<std::endl;//将从网络里获取到的报文打印出来

            //7.首先需要解包检测
            std::string content;
            bool r =Decode(inbuffer_stream,&content);
            assert(r);
            //8.反序列化，将答应变成客户端可认识的形式
            Response resp;
            r=resp.Deserialize(content);
            assert(r);
            //9.结果响应完成
            resp.DebugPrint();
        }
        std::cout<<"============================="<<std::endl;
        sleep(1);
        cnt++;

    }

    sockfd.Close();
}

1.构建请求(结构化数据)

2.请求序列化

3.添加报头，发送到网络

4.服务器读取请求

5.解除报头

6.请求反序列化

Ⅱ.服务器端发送响应，客户端接收响应

Main.cc
#include "Tcpserver.hpp"
#include "ServerCal.hpp"
#include <memory>
void Usage(std::string proc)
{
    std::cout << "\n\rUsage: " << proc << " port[1024+]\n"
              << std::endl;
}

int main(int args, char *argv[])
{

    if (args != 2)
    {
        Usage(argv[0]);
        exit(0);
    }

    uint16_t port = std::stoi(argv[1]);
    ServerCal cal;
    Tcpserver *tcpsvr = new Tcpserver(port, std::bind(&ServerCal::Calculator, &cal, std::placeholders::_1));
    tcpsvr->Init();
    tcpsvr->Start();
    return 0;
}

Tcpserver.hpp
#pragma once
#include <iostream>
#include <string>
#include <functional>
#include "Log.hpp"
#include <signal.h>
#include "Socket.hpp"
#include "ServerCal.hpp"
Sock sock;
using func_t =std::function<std::string(std::string &package)>;

class Tcpserver
{

public:
    Tcpserver(uint16_t port,func_t callback) : _port(port),_callback(callback)
    {
    }
    bool Init()
    {
        _listensock.Socket();    // 创建套接字
        _listensock.Bind(_port); // 绑定套接字
        _listensock.Listen();    // 将套接字设置成监听状态
        lg(Info, "init server...done");
        return true;
    }
    void Start() // 启动服务器
    {            // 启动之前需要先忽略一些信号
        signal(SIGPIPE, SIG_IGN);
        signal(SIGCHLD, SIG_IGN);
        // 获取连接
        while (true)
        {
            std::string clientip;
            uint16_t clientport;
            int sockfd = _listensock.Accept(&clientip, &clientport);
            if (sockfd < 0)
                continue;
            lg(Info, "accept a new link, sockfd:%d, clientip：%s ,clientport: %d",sockfd,clientip.c_str(),clientport);
            
            // 提供服务-->让子进程提供服务
            if (fork() == 0)
            {
                _listensock.Close();
                std::string inbuffer_stream;
                while (true)
                {
                    // 1.读取网络中的数据流
                    char buffer[128];
                    size_t n = read(sockfd, buffer, sizeof(buffer));
                    if (n > 0)
                    {
                        buffer[n]=0;
                        //将读取的报文进行处理
                       inbuffer_stream+=buffer;//注意读取的内容必须是一个完整的内容，不然调用回调时，就回调用失败
                       lg(Debug,"获取的网络请求:\n %s",inbuffer_stream.c_str());
                       std::string info=_callback(inbuffer_stream);
                       
                       if(info.empty())continue;//如果进行计算时，发现报文有问题，就重新回来读取。

                       // 2.将处理的结果发送回网络中
                       write(sockfd,info.c_str(),info.size());
                    }
                    else if(n==0)break;
                    else break;

                    
                }
                exit(0);
            }
            close(sockfd);
        }
    }
    ~Tcpserver()
    {
    }

private:
    uint16_t _port;
    Sock _listensock;
    func_t _callback;
};

1.构建响应(结构化数据)

2.响应序列化

3.添加报头，发送到网络

4.客户端读取响应

5.解除报头

6.响应反序列化

三.自动序列化和反序列化Json

在这里插入图片描述

 bool Serialize(std::string *out) // 序列化，单纯的就是将结构体转换成字符串
  {
     Json::Value root;//定义一个万能对象，可以存储数据，k-v形式的结构体
     root["x"]=_x;
     root["y"]=_y;
     root["op"]=_op;
     //Json::FastWriter w;
     Json::StyledWriter w;
     *out=w.write(root);//序列化成字符串
     return true;  

  }
  bool Deserialize(std::string &in) // 反序列化，就单纯的将字符串类型转成结构体
  {
    Json::Value root;//定义一个万能对象，将序列化的数据存储在里面
    Json::Reader r;
    r.parse(in,root);
    //将数据存到万能对象里后，我们就可以根据key值找到
    _x=root["x"].asInt();
    _y=root["y"].asInt();
    _op=root["op"].asInt();
    return true;
  }

四.理解OSI七层协议

在这里插入图片描述

小陶来咯
关注
专栏目录
Linux 序列化、反序列化、实现网络版计算器
Han同学
04-16 863
Linux 序列化、反序列化
【Linux | 网络编程】序列化与反序列化
上上谦. 的博客
10-06 567
本章我们将重谈网络协议，了解主流的网络协议，学习序列化与反序列化，并通过自己手写一个简易版的网络协议，来了解网络传输中数据的变化过程。目标已经确定，办好小板凳，准备开讲啦……在学习本章内容之前，先复习之前的👉TcpServer本章代码详情：👉Gitee我们只是简单的实现一个网络计算器，不涉及到负载运算，目的在于学习了解制定协议的过程。1+12*310-75/9// ...x + y规定，编码之后的格式是，报头（长度）和字符之间用\r\n分隔，有效载荷最后用\r\n。
【Linux网络编程】自定义协议+序列化+反序列化
fight_p的博客
04-02 1755
本篇博客主要是对自定义协议、序列化、反序列化的学习，在前面我们只是从父亲儿子打电话的例子感性认识协议是一个约定。今天从网络版计算器的代码学习协议，序列化和反序列化如何编写，不过对于序列化和反序列化我们还有现成的，这里我们主要学习Json的使用，以后再也不用自己序列化和反序列化了，但是并没有说不能自定义协议。没有人规定我们网络通信的时候，只能有一种协议！！那如何让系统知道用的是那种协议呢？
网络和Linux网络_4(应用层)序列化和反序列化(网络计算器)
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-22 1426
网络和Linux网络_4（应用层）序列化和反序列化（网络版本计算器+守护进程+Json的使用，再理解了协议）协议的重新理解+计算器完整代码，下一篇：应用层_HTTP协议（方法+报头+状态码）。
【Linux】TCP网络套接字编程+协议定制+序列化和反序列化
The porters of knowledge
06-05 1325
单进程，多进程，多线程，线程池，守护进程化版本的TCP服务器设计，自定义协议和序列化/反序列化的TCP服务器，使用现成的json序列化方案，网络通信的本质和处理黏包问题的方式，OSI上三层模型和我们的软件分三层的对应…
网络版计算器（理解协议与序列化与反序列化）
m0_74910646的博客
08-18 734
Jsoncpp 是一个用于处理 JSON 数据的 C++ 库。它提供了将 JSON 数据序列化为字 符串以及从字符串反序列化为 C++ 数据结构的功能。Jsoncpp 是开源的，广泛用于各 种需要处理 JSON 数据的 C++ 项目中。
【Linux】自定义协议——实现网络序列化和反序列化
cefler的博客
04-22 688
【Linux】自定义协议——实现网络序列化和反序列化
【网络编程】协议定制+Json序列化与反序列化
学了就忘是正常现象
05-24 1882
网络编程自定义协议+json的使用。
【Linux网络编程】序列化与反序列化
zzxz8的博客
09-19 403
我们想象一个场景，在特种兵执行任务时，他们有特定的战术手语，这样他们就能根据手语进行相应的战术配合了。所以协议也是一样，客户端和服务器都遵循相同的协议，以某种格式把字符串变成结构体或把结构体变成字符串。我们网络收发数据实际上只能接收到字符串，但是在现实生活中描述一个客观物体都是以很多属性来描述的，所以在网络中结构体类型的数据更常见，那我们如何发送结构体数据呢？服务器利用套接字接收请求，进行反序列化后，对请求进行业务处理，处理完成把结果生成响应。简易网络计算器协议协议部分代码：定制自己的协议，确定数据格式。
科学计算器源代码
08-10
在这个C语言实现的科学计算器源代码中，开发者可能采用了结构化的编程方法，将各个功能模块化，便于代码的维护和扩展。可能的结构包括函数库，每个函数对应一个特定的计算操作。例如，`add()`、`subtract()`、`...
WebGoat JAVA反序列化漏洞分析复现_webgoat反序列化，苦熬一个月
2401_83974064的博客
04-18 367
Python编程学习，学习内容包含：语法、正则、文件、 网络、多线程等常用库，推荐《Python核心编程》，不要看完；在实际的渗透测试过程中，面对复杂多变的网络环境，当常用工具不能满足实际需求的时候，往往需要对现有工具进行扩展，或者编写符合我们要求的工具、自动化脚本，这个时候就需要具备一定的编程能力。该方法代码如下，首先第6行进行传参token，跟到第10行，在进行反序列化对象创建的时候，进行了base64解码并返回到ois变量。这部分内容对零基础的同学来说还比较遥远，就不展开细说了，附上学习路线。
[网络安全自学篇] 九十四.《Windows黑客编程技术详解》之提权技术（令牌权限提升和Bypass UAC）
杨秀璋的专栏
09-12 2万+
这是作者网络安全自学教程系列，主要是关于安全工具和实践操作的在线笔记，特分享出来与博友们学习，希望您喜欢，一起进步。这篇文章将带着大家来学习《Windows黑客编程技术详解》，其作者是甘迪文老师，推荐大家购买来学习。作者将采用实际编程和图文结合的方式进行分享，并且会进一步补充相关知识点。第六篇文章主要介绍木马病毒提权技术，包括进程访问令牌权限提升和Bypass UAC，希望对您有所帮助。
[网络安全自学篇] 八十五.《Windows黑客编程技术详解》之注入技术详解（全局钩子、远线程钩子、突破Session 0注入、APC注入）
杨秀璋的专栏
06-25 1万+
从这篇文章开始，作者将带着大家来学习《Windows黑客编程技术详解》，其作者是甘迪文老师，推荐大家购买来学习。作者将采用实际编程和图文结合的方式进行分享，并且会进一步补充知识点，希望对您有所帮助。第二篇文章主要介绍4种常见的注入技术，包括全局钩子、远线程钩子、突破SESSION 0隔离的远线程注入、APC注入，案例包括键盘钩子、计算器远线程注入实现、APC注入等，希望对您有所帮助。
[网络安全自学篇] 九十二.《Windows黑客编程技术详解》之病毒启动技术创建进程API、突破SESSION0隔离、内存加载详解（3）
热门推荐
杨秀璋的专栏
07-27 2万+
这是作者网络安全自学教程系列，主要是关于安全工具和实践操作的在线笔记，特分享出来与博友们学习，希望您喜欢，一起进步。这篇文章将带着大家来学习《Windows黑客编程技术详解》，其作者是甘迪文老师，推荐大家购买来学习。作者将采用实际编程和图文结合的方式进行分享，并且会进一步补充知识点。第三篇文章主要介绍木马病毒启动技术，包括创建进程API、突破SESSION0隔离、内存加载详解，希望对您有所帮助。
【linux】冯诺依曼架构
Quietcoder的博客
10-10 800
🔥个人主页Quitecoder🔥linux笔记仓。
【Linux】进程地址空间(初步了解)
weixin_69380220的博客
10-04 1464
进程虚拟地址空间相关内容
[Linux#63][TCP] 常见标志位 | 为什么是三次握手,四次挥手？
最新发布
2301_80171004的博客
10-10 491
本文介绍了 TCP 协议中 6 个标志位的作用、三次握手和四次挥手的具体过程，以及 TIME_WAIT 状态的处理方法
黑马linux笔记（转载）
pscool的博客
10-01 2104
我们所熟知的计算机是由硬件和软件组成的。计算机系统中由电子、机械和光电元件等组成的各种物理装置的总称。（看的见、摸得着的东西：CPU、内存硬盘、显示屏、鼠标等）是用户和计算机硬件之间的接口和桥梁，用户通过软件和计算机进行交流。（操作系统，就是软件的一类）学习Linux系统，就需要有一个可用的Linux系统。由于Linux系统并不适合日常办公使用，所以我们需要借助虚拟机来获得可用的Linux系统环境进行学习。借助虚拟化技术，我们可以在系统中，通过软件：模拟计算机硬件，并给虚拟硬件安装真实的操作系统。
序列化和反序列化在网络编程中的主要作用
05-20
在网络编程中，序列化和反序列化的主要作用是将数据从一个格式转换成另一种格式，以便在网络上进行传输。 具体来说，序列化是将对象或数据结构转换为二进制或其他格式，以便它们可以在网络上传输。这通常涉及到将...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小陶来咯

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值