【ex directui源码】【免费自动挂机源码】【横切机控制源码】socket培训源码

【ex directui源码】【免费自动挂机源码】【横切机控制源码】socket培训源码_socket源码分析

时间:2024-12-24 03:14:50 来源：雷达触控源码

1.信息安全课程8：套接字（socket）编程
2.å¦ä½ç¼åç®åçsocketç½ç»ç¨åº å¦ä½ç¼ååºäºTCPåè®®çç½ç»ç¨åº
3.几个代码伪装成高级黑客
4.2024年度Linux6.9内核最新源码解读-网络篇-server端-第一步创建--socket
5.一文从linux源码看socket的培训close基本概括
6.从Linux源码看Socket(TCP)的listen及连接队列

socket培训源码_socket源码分析

信息安全课程8：套接字（socket）编程

本文的socket介绍仅服务于课程目的，点到即止。源码源码如果希望继续深入学习socket，分析可以参照《Unix网络编程》等书籍以及参考文献。培训

套接字（socket）允许在相同或不同的源码源码机器上的两个不同进程之间进行通信。更准确地说，分析ex directui源码它是培训使用标准Unix文件描述符与其他计算机通信的一种方式。在Unix中，源码源码每个I/O操作都是分析通过写入或读取文件描述符来完成的。文件描述符只是培训与打开文件关联的整数，它可以是源码源码网络连接、文本文件、分析终端或其他内容。培训

对于程序员来说，源码源码套接字的分析使用和行为很像更底层的文件描述符。这是因为对于套接字，read（）和write（）等命令可以像在文件和管道编程中同样的使用。

套接字首先在BSD 2.1中引入，然后在BSD 4.2形成当前的稳定版本。现在，大多数最新的UNIX系统版本都提供了套接字功能。

Unix Socket用于客户端 - 服务器应用程序框架中。免费自动挂机源码服务器是根据客户端请求执行某些功能的过程。大多数应用程序级协议（如FTP、SMTP和POP3）都使用套接字在客户端和服务器之间建立连接，然后交换数据。

用户可以使用四种类型的套接字。前两个是最常用的，后两个使用较少。一般假定进程仅在相同类型的套接字之间进行通信，但是也没有限制阻止不同类型的套接字之间的通信。

使用socket的时候需要使用各种结构来保存有关地址和端口的信息以及其他信息。大多数套接字函数都需要一个指向套接字地址结构的指针作为参数。通常使用四元组来描述一个网络连接，使用socket的时候，往往也需要数据结构来描述这些信息。

这是一个通用的套接字地址结构，在大多数套接字函数调用中都需要使用它。成员字段的说明如下。sa_family包括以下可选值。每个值代表一种地址族（address family），在基于IP的情况中，都使用AF_INET。横切机控制源码

其中，sin_family和sockadd的sa_family一样，包括四个可选值：

sin_port是端口号，位长，网络字节序（network byte order）；sin_addr是IP地址，位长，网络字节序（network byte order）。sin_zero，8个字节，设置为0。

至于为何会使用两个数据结构sockaddr和sockaddr_in来表示地址，原因是如sa_family所指出的，socket设计之初本来就是准备支持多个地址协议的。不同的地址协议由自己不同的地址构造，譬如对于IPv4就是sockaddr_in， IPV6就是sockaddr_in6，以及对于AF_UNIX就是sockaddr_un。sockaddr是对这些地址的上一层的抽象。另外，像sockaddr_in将地址拆分为port和IP，对编程也更友好。贵阳手机麻将源码这样，在将所使用的的值赋值给sockaddr_in数据结构之后，通过强制类型转换，就可以转换为sockaddr。当然，从sockaddr也可以强制类型转换为sockaddr_in。

在sockaddr_in中还有一个结构体，struct in_addr，就是一个位的IP地址，同样是网络字节序。

为了允许具有不同字节顺序约定的机器相互通信，Internet协议为通过网络传输的数据指定了规范的字节顺序约定。这称为网络字节顺序。在建立Internet套接字连接时，必须确保sockaddr_in结构的sin_port和sin_addr成员中的数据在网络字节顺序中表示。

不用担心这几个数据结构以及字节序，因为socket接口非常贴心地准备好了各种友好的接口。

譬如对上面描述的过程，想要把地址...和端口绑定到一个socket，以下代码就足够了：

对于简单的socket应用编程，所需要做的涨停蓄力指标源码就是记住流程。

使用客户端-服务器端（client-server）模型作为一个例子。server一般打开端口，被动侦听，不需要知道客户端的IP和端口；而client发起请求，必须知道服务器端的IP和端口。

在这个过程中，所需要用到的函数如下：

再用一张图描述下客户端和服务器端的流程：

接下来，我们看C/S的代码实例。

客户端代码：

以及服务器端代码：

编译之后，就可以在两个进程间进行通信了。这个简单代码的作用是服务端收到客户端发来的字符串并回显。

如果将上面代码中的while循环部分修改为：

那么实现的功能就是两个进程之间进行输入交流。

接下来思考问题：能不能利用上面的socket通信，获得一个shell？上面的例子中，当我们输入一个字符串，服务器给我们一个字符串，如果有了shell，发送过去一个命令，能够返回执行的结果。

实际上，只要对上面的代码做很少的修改，就可以实现获得shell的目的。

这里，我们稍微讨论一下，以上代码到底做了什么事情。

首先要习惯一个概念：在Linux中，一切皆文件。普通的文本文件确实是文件，但是设备、socket、管道等都被当成文件处理。所以我们获得的connfd也就是一个文件描述符。在Linux的文件描述符中有三个是特殊的，任何进程都一样的，0、1、2，分别代表标准输入，标准输出和标准出错。而它们都指向同一个tty（teleType，终端）。如果此时再去打开一个新的文件，它的文件描述符会是3。

为了进一步理解文件描述符，可以使用下面的代码：

能讲清楚上面代码的过程吗？下面的代码呢？

上面的代码中，把0分别换成1、2、3有什么结果？

下面代码的运行结果是什么呢？

另外，能否描述shell的工作过程？

可以再看下一个简单实现：

以及打开shell是怎么回事呢？当我们在命令行中输入bash（调用/bin/bash）的时候，就会在shell中打开一个新的shell。所以，当使用execlp调用/bin/bash的时候，就是打开了新的shell。

请记住，在这里我们有大量的内容没有介绍，譬如getservbyname、select、多线程、信号等。再次地，如果需要进一步学习，请参阅《unix网络编程》。

另外：关于AF_INET和PF_INET

在一些文档中，可能会遇到"PF_INET"。出现AF_INET和PF_INET是历史原因。在网络设计之初，AF = Address Family，PF = Protocol Family，所以最好在指示地址的时候使用AF，在指示协议的时候使用PF。因为那时人们希望同一个地址族（ "AF" in "AF_INET" )可能支持多个协议族 ("PF" in "PF_INET" )。这样的话，就可以加以区分。

但是，并没有出现同一个地址族支持多个协议族的情况，现在在windows中，

所以在windows中AF_INET与PF_INET完全一样。在Linux中，虽然所以正确的做法是在struct sockaddr_in中使用AF_INET，以及在调用socket（）时使用PF_INET。但实际上，可以在任何地方使用AF_INET。而且，既然这就是W. Richard Stevens在他的书中所做的，那么我们这样做也毫无问题。

至于AF_PACKET 和 PF_PACKET，可以查看源代码：

可以发现：

也即，值是相同的。

利用nc实现正向shell和反向shell。正向shell：

受害者命令：nc -lvp -e /bin/sh；也即受害者在端口侦听，并且在这个端口上执行/bin/sh；

攻击者命令：nc ..1.2 ，也即攻击者去连端口，然后发送过去的数据在受害者主机执行，并将执行结果返回给攻击者；

反向shell的工作方式是远程计算机将自己的shell发送给特定的用户，而不是将shell绑定到一个端口上。之所以使用反向shell，主要是因为有时候防火墙可能会阻止正向的shell。反向shell：

攻击者侦听：nc -lvp ，攻击者打开了端口，等待连接；

被攻击者去连接攻击者，并且同时执行/bin/sh，连上攻击者之后，攻击者发送的命令可以在受害者主机执行，执行结果返回给攻击者。

在尝试nc -e选项的时候会出现

也即，nc有不同的版本，需要使用nc.traditional 才能使用-e选项。

可以使用 sudo apt-get install netcat命令，先安装nc.traditional 版本，然后使用update-alternatives来进行挑选。update-alternatives是Debian系统中专门维护系统命令链接符的工具，通过它可以很方便的设置系统默认使用哪个命令、哪个软件版本。

之后可以实现正向绑定和反向shell。

反向shell的代码，也即在client端打开shell：

参考：

ããä¸é¢æ¯ä¸ªäººå®å¨è½è¿è¡çä»£ç ï¼

ããæå¡å¨ç«¯æºç ï¼

ãã#include<stdio.h>

#include <Winsock2.h>

#pragma comment (lib,"ws2_.lib")

ããint main()

{

WORD wVersionRequested;

WSADATA wsaData;

int err;

wVersionRequested = MAKEWORD( 2, 2 );

err = WSAStartup( wVersionRequested, &wsaData );

if ( err != 0 ) {

return 0;

}

if ( LOBYTE( wsaData.wVersion ) != 2 ||

HIBYTE( wsaData.wVersion ) != 2 ) {

WSACleanup( );

return 0;

}

ããSOCKET socketServer=socket(AF_INET,SOCK_STREAM,0);

ããSOCKADDR_IN addrServer;

ããaddrServer.sin_family=AF_INET;

ããaddrServer.sin_addr.S_un.S_addr=htonl(INADDR_ANY);

ããaddrServer.sin_port=htons();

ããbind(socketServer, (struct sockaddr *)&addrServer, sizeof(struct sockaddr));

ããlisten(socketServer, 5);

ããSOCKADDR_IN addrClient;

ããint addrLen=sizeof(SOCKADDR_IN);

ããchar sendBuf[];

ããchar recvBuf[];

ããint i=1;

while(1)

{

printf("æå¡å¨ç«¯çå¾ç¬¬%dä¸ªå®¢æ·ç«¯è¿æ¥è¯·æ±...\n", i++);

ããSOCKET newsocketServer=accept(socketServer,(struct sockaddr *)&addrClient, &addrLen);

ããif(newsocketServer!=INVALID_SOCKET)

{

printf("æå¡å¨ç«¯ä¸å®¢æ·ç«¯è¿æ¥æå...\n");

}

ããmemset(sendBuf,0,);

ããsprintf(sendBuf,"Welcome you to come here");

ããsend(newsocketServer, sendBuf, strlen(sendBuf)+1,0);

ããmemset(recvBuf,0,);

ããrecv(newsocketServer,recvBuf,,0);

ããprintf("æå¡å¨ç«¯æ¶å°ä¿¡æ¯:%s\n",recvBuf);

ããclosesocket(newsocketServer);

}

ããWSACleanup();

ããreturn 0;

}

ããæ¤æç« æ¥èªäºä¸ªäººåå®¢ï¼ é¿æµªåå®¢ tl.h>

#include <sys/wait.h>

#define MAXDATASIZE

#define SERVPORT

#define BACKLOG

int SendFileToServ(const char *path, const char *FileName, const char *ip)

{

#define PORT

int sockfd;

int recvbytes;

char buf[MAXDATASIZE];

char send_str[MAXDATASIZE];

char filepath[] = { 0};

struct sockaddr_in serv_addr;

FILE *fp;

sprintf(filepath, "%s%s", path, FileName);

if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1)

{

perror("socket");

return 1;

}

bzero(&serv_addr,sizeof(struct sockaddr_in));

serv_addr.sin_family=AF_INET;

serv_addr.sin_port=htons(PORT);

inet_aton(ip, &serv_addr.sin_addr);

int IErrCount = 0;

again:

if(connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(struct sockaddr))==-1)

{

if (5 == IErrCount)

return 1;

IErrCount++;

perror("connect");

sleep(2);

goto again;

}

//if ((fp = fopen(FileName, "rb")) == NULL)

if ((fp = fopen(filepath, "rb")) == NULL)

{

perror("fopen ");

return 1;

}

recvbytes = write(sockfd, FileName, strlen(FileName));

recvbytes = read(sockfd, buf, MAXDATASIZE);

if (!memcmp(buf, "sendmsg", 7))

{

while(fgets(send_str, MAXDATASIZE, fp))

{

recvbytes = write(sockfd, send_str, strlen(send_str));

recvbytes = read(sockfd, buf, MAXDATASIZE);

if (recvbytes <= 0)

{

fclose(fp);

close(sockfd);

return 1;

}

if (memcmp(buf, "goon", 4))

{

fclose(fp);

close(sockfd);

return 1;

}

recvbytes = write(sockfd, "end", 3);

}

else

{

fclose(fp);

close(sockfd);

return 1;

}

memset(buf, 0, MAXDATASIZE);

if (read(sockfd, buf, MAXDATASIZE) <= 0)

{

close(sockfd);

return 2;

}

char *Eptr = "nginx reload error";

//printf("bf[%s]\n", buf);

int ret;

ret = strncmp(buf, Eptr, strlen(Eptr));

//printf("%d\n", ret);

if (!ret)

{

close(sockfd);

return 2;

}

close(sockfd);

return 0;

}

int mysyslog(const char * msg)

{

FILE *fp;

if ((fp = fopen("/tmp/tmp.log", "a+")) == NULL)

{

return 0;

}

fprintf(fp, "[%s]\n", msg);

fclose(fp);

return 0;

}

static void quit_handler(int signal)

{

kill(0, SIGUSR2);

syslog( LOG_NOTICE, "apuserv quit...");

// do something exit thing ,such as close socket ,close mysql,free list

// .....

//i end

exit(0);

}

static int re_conf = 0;

static void reconf_handler(int signal)

{

re_conf=1;

syslog(LOG_NOTICE,"apuserv reload configure file .");

// 请在循环体中判断，如果re_conf == 1，请再次加载配置文件。

}

static int isrunning(void)

{

int fd;

int ret;

struct flock lock;

lock.l_type = F_WRLCK;

lock.l_whence = 0;

lock.l_start = 0;

lock.l_len = 0;

const char *lckfile = "/tmp/apuserv.lock";

fd = open(lckfile,O_WRONLY|O_CREAT);

if (fd < 0) {

syslog(LOG_ERR,"can not create lock file: %s\n",lckfile);

return 1;

}

if ((ret = fcntl(fd,F_SETLK,&lock)) < 0) {

ret = fcntl(fd,F_GETLK,&lock);

if (lock.l_type != F_UNLCK) {

close(fd);

return lock.l_pid;

}

else {

fcntl(fd,F_SETLK,&lock);

}

return 0;

}

int MyHandleBuff(const char *buf, char *str, char *FileName, char *pth)

{

sscanf(buf, "%s %s %s", pth, FileName, str);

printf("path=%s\nfilename=%s\nip=%s\n", pth, FileName, str);

return 0;

}

int main(int argc, char **argv)

{

int sockfd,client_fd;

socklen_t sin_size;

struct sockaddr_in my_addr,remote_addr;

char buff[MAXDATASIZE];

int recvbytes;

#if 1

int pid ;

char ch ;

int ret;

int debug = 0;

signal(SIGUSR1, SIG_IGN);

signal(SIGUSR2, SIG_IGN);

signal(SIGHUP, SIG_IGN);

signal(SIGTERM, quit_handler);

syslog(LOG_NOTICE,"apuserver start....");

while ((ch = getopt(argc, argv, "dhV")) != -1) {

switch (ch) {

case 'd':

debug = 1;

break;

case 'V':

printf("Version:%s\n","1.0.0");

return 0;

case 'h':

printf(" -d use daemon mode\n");

printf(" -V show version\n");

return 0;

default:

printf(" -d use daemon mode\n");

printf(" -V show version\n");

}

if (debug && daemon(0,0 ) ) {

return -1;

}

if (isrunning()) {

fprintf(stderr, "apuserv is already running\n");

syslog(LOG_INFO,"apuserv is already running\n");

exit(0);

}

while (1) {

pid = fork();

if (pid < 0)

return -1;

if (pid == 0)

break;

while ((ret = waitpid(pid, NULL, 0)) != pid) {

syslog(LOG_NOTICE, "waitpid want %d, but got %d", pid, ret);

if (ret < 0)

syslog(LOG_NOTICE, "waitpid errno:%d", errno);

}

kill(0, SIGUSR2);

sleep(1);

syslog(LOG_NOTICE,"restart apuserver");

}

signal(SIGHUP, reconf_handler);

signal(SIGPIPE, SIG_IGN);

signal(SIGUSR1,SIG_IGN);

signal(SIGUSR2, SIG_DFL);

signal(SIGTERM, SIG_DFL);

#endif

if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1)

{

perror("socket");

exit(1);

}

bzero(&my_addr,sizeof(struct sockaddr_in));

my_addr.sin_family=AF_INET;

my_addr.sin_port=htons(SERVPORT);

my_addr.sin_addr.s_addr = htonl(INADDR_ANY);

if(bind(sockfd,(struct sockaddr *)&my_addr,sizeof(struct sockaddr))==-1)

{

perror("bind");

exit(1);

}

if(listen(sockfd,BACKLOG)==-1)

{

perror("listen");

exit(1);

}

int nret;

while(1)

{

sin_size = sizeof(struct sockaddr_in);

if((client_fd = accept(sockfd, (struct sockaddr *)&remote_addr, &sin_size))==-1)

{

perror("falied accept");

continue;

}

memset(buff, 0, MAXDATASIZE);

recvbytes = read(client_fd, buff, MAXDATASIZE);

char str[] = { 0};

char FileName[] = { 0};

char path[] = { 0};

MyHandleBuff(buff, str, FileName, path);

if (recvbytes > 0)

{

nret = SendFileToServ(path, FileName, str);

printf("nret[%d]\n", nret);

if (1 == nret)

write(client_fd, "send file error", );

else if(2 == nret)

write(client_fd, "reload nginx error", );

else

write(client_fd, "succ", 4);

}

close(client_fd);

}

_________________________________________________

client:

#include <stdio.h>

#include <errno.h>

#include <unistd.h>

#include <signal.h>

#include <stdlib.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <arpa/inet.h>

#include <netinet/in.h>

#include <syslog.h>

#include <sys/time.h>

#include <string.h>

#include <fcntl.h>

#include <sys/wait.h>

#define MAXDATASIZE

#define SERVPORT

#define BACKLOG

int mysyslog(const char * msg)

{

FILE *fp;

if ((fp = fopen("/tmp/tmp.log", "a+")) == NULL)

{

return 0;

}

fprintf(fp, "[%s]\n", msg);

fclose(fp);

return 0;

}

static void quit_handler(int signal)

{

kill(0, SIGUSR2);

syslog( LOG_NOTICE, "apuserv quit...");

// do something exit thing ,such as close socket ,close mysql,free list

// .....

//i end

exit(0);

}

static int re_conf = 0;

static void reconf_handler(int signal)

{

re_conf=1;

syslog(LOG_NOTICE,"apuserv reload configure file .");

// ·1nf == 1￡′μ?

static int isrunning(void)

{

int fd;

int ret;

struct flock lock;

lock.l_type = F_WRLCK;

lock.l_whence = 0;

lock.l_start = 0;

lock.l_len = 0;

const char *lckfile = "/tmp/dstserver.lock";

fd = open(lckfile,O_WRONLY|O_CREAT);

if (fd < 0) {

syslog(LOG_ERR,"can not create lock file: %s\n",lckfile);

return 1;

}

if ((ret = fcntl(fd,F_SETLK,&lock)) < 0) {

ret = fcntl(fd,F_GETLK,&lock);

if (lock.l_type != F_UNLCK) {

close(fd);

return lock.l_pid;

}

else {

fcntl(fd,F_SETLK,&lock);

}

return 0;

}

int main(int argc, char **argv)

{

int sockfd,client_fd;

socklen_t sin_size;

struct sockaddr_in my_addr,remote_addr;

char buff[MAXDATASIZE];

int recvbytes;

#if 1

int pid ;

char ch ;

int ret;

int debug = 0;

signal(SIGUSR1, SIG_IGN);

signal(SIGUSR2, SIG_IGN);

signal(SIGHUP, SIG_IGN);

signal(SIGTERM, quit_handler);

syslog(LOG_NOTICE,"dstserver start....");

while ((ch = getopt(argc, argv, "dhV")) != -1) {

switch (ch) {

case 'd':

debug = 1;

break;

case 'V':

printf("Version:%s\n","1.0.0");

return 0;

case 'h':

printf(" -d use daemon mode\n");

printf(" -V show version\n");

return 0;

default:

printf(" -d use daemon mode\n");

printf(" -V show version\n");

}

if (debug && daemon(0,0 ) ) {

return -1;

}

if (isrunning()) {

fprintf(stderr, "dstserver is already running\n");

syslog(LOG_INFO,"dstserver is already running\n");

exit(0);

}

while (1) {

pid = fork();

if (pid < 0)

return -1;

if (pid == 0)

break;

while ((ret = waitpid(pid, NULL, 0)) != pid) {

syslog(LOG_NOTICE, "waitpid want %d, but got %d", pid, ret);

if (ret < 0)

syslog(LOG_NOTICE, "waitpid errno:%d", errno);

}

kill(0, SIGUSR2);

sleep(1);

syslog(LOG_NOTICE,"restart apuserver");

}

signal(SIGHUP, reconf_handler);

signal(SIGPIPE, SIG_IGN);

signal(SIGUSR1,SIG_IGN);

signal(SIGUSR2, SIG_DFL);

signal(SIGTERM, SIG_DFL);

#endif

if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1)

{

perror("socket");

exit(1);

}

bzero(&my_addr,sizeof(struct sockaddr_in));

my_addr.sin_family=AF_INET;

my_addr.sin_port=htons(SERVPORT);

my_addr.sin_addr.s_addr = htonl(INADDR_ANY);

if(bind(sockfd,(struct sockaddr *)&my_addr,sizeof(struct sockaddr))==-1)

{

perror("bind");

exit(1);

}

if(listen(sockfd,BACKLOG)==-1)

{

perror("listen");

exit(1);

}

char filepath[MAXDATASIZE]= { 0};

FILE *fp;

while(1)

{

sin_size = sizeof(struct sockaddr_in);

if((client_fd = accept(sockfd, (struct sockaddr *)&remote_addr, &sin_size))==-1)

{

perror("falied accept");

continue;

}

memset(buff, 0, MAXDATASIZE);

recvbytes = read(client_fd, buff, MAXDATASIZE);

sprintf(filepath, "/etc/nginx/url_rule/%s", buff);

if ((fp = fopen(filepath, "wb")) == NULL)

{

perror("fopen");

close(client_fd);

continue;

}

write(client_fd, "sendmsg", 7);

while(read(client_fd, buff, MAXDATASIZE))

{

if (!memcmp(buff, "end", 3))

{

fclose(fp);

break;

}

else

{

fprintf(fp, "%s", buff);

write(client_fd, "goon", 4);

}

//system("nginx -s reload");

char *Sptr = "nginx reload succ";

char *Eptr = "nginx reload error";

int ret;

ret = system("nginx -s reload");

printf("ret[%d]\n", ret);

if (ret != 0)

{

write(client_fd, Eptr, strlen(Eptr));

}

else

{

write(client_fd, Sptr, strlen(Sptr));

}

close(client_fd);

}

以前写的：内容忘记了。不是很复杂你可以自己看！

想知道更多资讯>>>点击进入“探索”频道

【ex directui源码】【免费自动挂机源码】【横切机控制源码】socket培训源码_socket源码分析

精选图文

热点推荐