npfs's blog

�Ὣ���¶�����

网络通信开发基础

脚本开发之网络通信开发基础

任务标题: 网络通信开发基础

任务目标:

建立 socket 连接通道,可以相互之间传输数据

推荐语言:

python、c、c#、powershell

任务描述:

在实际的渗透中,协议是建立据点网络通道的基础,可以通过网络通道对内部的服务器进行控制

本关主要锻炼大家对于协议的理解和对网络通道建立的使用方法,有了这个基础可以实现一些比如远控木马、端口扫描、服务爆破方面的工具。

报告要求

1、理解TCP、UDP协议的原理及特点

2、分别使用 TCP、UDP 协议实现数据通讯

扩展任务

客户端发送命令,服务端接收命令并执行


​ 对TCP/IP、UDP、Socket编程这些词你不会很陌生吧?随着网络技术的发展,这些词充斥着我们的耳朵。我们深谙信息交流的价值,那网络中进程之间如何通信,如我们每天打开浏览器浏览网页时,浏览器的进程怎么与web服务器通信的?当你用QQ聊天时,QQ进程怎么与服务器或你好友所在的QQ进程通信?这些都得靠socket?那什么是socket?本文将围绕以下几方面开展

  1. 什么是TCP/IP、UDP?
  2. Socket在哪里呢?
  3. Socket是什么呢?
  4. 如何使用它们?

网络中进程之间如何通信?

本地的进程间通信(IPC)有很多种方式,但可以总结为下面4类:

  • 消息传递(管道、FIFO、消息队列)
  • 同步(互斥量、条件变量、读写锁、文件和写记录锁、信号量)
  • 共享内存(匿名的和具名的)
  • 远程过程调用(Solaris门和Sun RPC)

网络中进程之间如何通信?首要解决的问题是如何唯一标识一个进程,否则通信无从谈起!在本地可以通过进程PID来唯一标识一个进程,但是在网络中这是行不通的。其实TCP/IP协议族已经帮我们解决了这个问题,网络层的“ip地址”可以唯一标识网络中的主机,而传输层的“协议+端口”可以唯一标识主机中的应用程序(进程)。这样利用三元组(ip地址,协议,端口)就可以标识网络的进程了,网络中的进程通信就可以利用这个标志与其它进程进行交互。

使用TCP/IP协议的应用程序通常采用应用编程接口:UNIX BSD的套接字(socket)和UNIX System V的TLI(已经被淘汰),来实现网络进程之间的通信。就目前而言,几乎所有的应用程序都是采用socket,而现在又是网络时代,网络中进程通信是无处不在,这就是我为什么说“一切皆socket”。

什么是Socket?

我们先通过一张图,大致的了解一下啊socket的位置

​ 所谓套接字(Socket),就是对网络中不同主机上的应用进程之间进行双向通信的端点的抽象。一个套接字就是网络上进程通信的一端,提供了应用层进程利用网络协议交换数据的机制。从所处的地位来讲,套接字上联应用进程,下联网络协议栈,是应用程序通过网络协议进行通信的接口,是应用程序与网络协议根进行交互的接口,它把复杂的TCP/IP协议族隐藏在Socket接口后面,对用户来说,一组简单的接口就是全部,让Socket去组织数据,以符合指定的协议。

那么,如何去使用socket呢?

​ 前人已经给我们做了好多的事了,网络间的通信也就简单了许多,但毕竟还是有挺多工作要做的。以前听到Socket编程,觉得它是比较高深的编程知识,但是只要弄清Socket编程的工作原理,神秘的面纱也就揭开了。
​ 举一个生活中的场景。你要打电话给一个朋友,先拨号,朋友听到电话铃声后提起电话,这时你和你的朋友就建立起了连接,就可以讲话了。等交流结束,挂断电话结束此次交谈。 生活中的场景就解释了这工作原理,也许TCP/IP协议族就是诞生于生活中,这也不一定。

​ 先从服务器端说起。服务器端先初始化Socket,然后与端口绑定(bind),对端口进行监听(listen),调用accept阻塞,等待客户端连接。在这时如果有个客户端初始化一个Socket,然后连接服务器(connect),如果连接成功,这时客户端与服务器端的连接就建立了。客户端发送数据请求,服务器端接收请求并处理请求,然后把回应数据发送给客户端,客户端读取数据,最后关闭连接,一次交互结束。

创建socket

这里已python为例,讲解如何创建socket

在python中,使用socket模块的函数就可以完成,基本格式如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import socket

socket.socket(AddressFamily, Type, protocal=0)

# 获取tcp/ip套接字
tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 获取udp/ip套接字
udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

# ...这里是使用套接字的功能(省略)...

# 不用的时候,关闭套接字
s.close()

Socket 类型

套接字格式:

socket(family,type[,protocal]) 使用给定的地址族、套接字类型、协议编号(默认为0)来创建套接字。

socket类型 描述
socket.AF_UNIX 只能够用于单一的Unix系统进程间通信
socket.AF_INET 服务器之间网络通信
socket.AF_INET6 IPv6
socket.SOCK_STREAM 流式socket , for TCP
socket.SOCK_DGRAM 数据报式socket , for UDP
socket.SOCK_RAW 原始套接字,普通的套接字无法处理ICMP、IGMP等网络报文,而SOCK_RAW可以;其次,SOCK_RAW也可以处理特殊的IPv4报文;此外,利用原始套接字,可以通过IP_HDRINCL套接字选项由用户构造IP头。
socket.SOCK_SEQPACKET 可靠的连续数据包服务
创建TCP Socket: s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
创建UDP Socket: s=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

Socket 函数

注意点:

1)TCP发送数据时,已建立好TCP连接,所以不需要指定地址。UDP是面向无连接的,每次发送要指定是发给谁。

2)服务端与客户端不能直接发送列表,元组,字典。需要字符串化repr(data)。

socket函数 描述
服务端socket函数
s.bind(address) 将套接字绑定到地址, 在AF_INET下,以元组(host,port)的形式表示地址.
s.listen(backlog) 开始监听TCP传入连接。backlog指定在拒绝连接之前,操作系统可以挂起的最大连接数量。该值至少为1,大部分应用程序设为5就可以了。
s.accept() 接受TCP连接并返回(conn,address),其中conn是新的套接字对象,可以用来接收和发送数据。address是连接客户端的地址。
客户端socket函数
s.connect(address) 连接到address处的套接字。一般address的格式为元组(hostname,port),如果连接出错,返回socket.error错误。
s.connect_ex(adddress) 功能与connect(address)相同,但是成功返回0,失败返回errno的值。
公共socket函数
s.recv(bufsize[,flag]) 接受TCP套接字的数据。数据以字符串形式返回,bufsize指定要接收的最大数据量。flag提供有关消息的其他信息,通常可以忽略。
s.send(string[,flag]) 发送TCP数据。将string中的数据发送到连接的套接字。返回值是要发送的字节数量,该数量可能小于string的字节大小。
s.sendall(string[,flag]) 完整发送TCP数据。将string中的数据发送到连接的套接字,但在返回之前会尝试发送所有数据。成功返回None,失败则抛出异常。
s.recvfrom(bufsize[.flag]) 接受UDP套接字的数据。与recv()类似,但返回值是(data,address)。其中data是包含接收数据的字符串,address是发送数据的套接字地址。
s.sendto(string[,flag],address) 发送UDP数据。将数据发送到套接字,address是形式为(ipaddr,port)的元组,指定远程地址。返回值是发送的字节数。
s.close() 关闭套接字。
s.getpeername() 返回连接套接字的远程地址。返回值通常是元组(ipaddr,port)。
s.getsockname() 返回套接字自己的地址。通常是一个元组(ipaddr,port)
s.setsockopt(level,optname,value) 设置给定套接字选项的值。
s.getsockopt(level,optname[.buflen]) 返回套接字选项的值。
s.settimeout(timeout) 设置套接字操作的超时期,timeout是一个浮点数,单位是秒。值为None表示没有超时期。一般,超时期应该在刚创建套接字时设置,因为它们可能用于连接的操作(如connect())
s.gettimeout() 返回当前超时期的值,单位是秒,如果没有设置超时期,则返回None。
s.fileno() 返回套接字的文件描述符。
s.setblocking(flag) 如果flag为0,则将套接字设为非阻塞模式,否则将套接字设为阻塞模式(默认值)。非阻塞模式下,如果调用recv()没有发现任何数据,或send()调用无法立即发送数据,那么将引起socket.error异常。
s.makefile() 创建一个与该套接字相关连的文件

TCP的原理及特点

TCP全称为 “传输控制协议(Transmission Control Protocol”). 从名字就能看出来,TCP协议 要对数据的传输进行一个详细的控制。

TCP协议特点:面向连接,提供可靠的服务,有流量控制,拥塞控制,无重复、无丢失、无差错,面向字节流(把应用层传下来的报文看成字节流,把字节流组织成大小不等的数据块),只能是点对点,首部 20 字节,全双工

tcp首部格式

  • 序号 用于对字节流进行编号,例如序号为 301,表示第一个字节的编号为 301,如果携带的数据长度为 100 字节,那么下一个报文段的序号应为 401。
  • 确认号 期望收到的下一个报文段的序号。例如 B 正确收到 A 发送来的一个报文段,序号为 501,携带的数据长度为 200 字节,因此 B 期望下一个报文段的序号为 701,B 发送给 A 的确认报文段中确认号就为 701。
  • 数据偏移 :指的是数据部分距离报文段起始处的偏移量,实际上指的是首部的长度。
  • 确认 ACK :当 ACK=1 时确认号字段有效,否则无效。TCP 规定,在连接建立后所有传送的报文段都必须把 ACK 置 1。
  • 同步 SYN 在连接建立时用来同步序号。当 SYN=1,ACK=0 时表示这是一个连接请求报文段。若对方同意建立连接,则响应报文中 SYN=1,ACK=1。
  • 终止 FIN 用来释放一个连接,当 FIN=1 时,表示此报文段的发送方的数据已发送完毕,并要求释放运输连接。
  • 窗口 窗口值作为接收方让发送方设置其发送窗口的依据。之所以要有这个限制,是因为接收方的数据缓存空间是有限的。

TCP连接:SYN ACK RST UTG PSH FIN

SYN:同步标志

同步序列编号(Synchronize Sequence Numbers)栏有效。该标志仅在三次握手建立TCP连接时有效。它提示TCP连接的服务端检查序列编号,该序列编号为TCP连接初始端(一般是客户端)的初始序列编号。

ACK:确认标志

确认编号(Acknowledgement Number)栏有效。大多数情况下该标志位是置位的。TCP报头内的确认编号栏内包含的确认编号(w+1,Figure-1)为下一个预期的序列编号,同时提示远端系统已经成功接收所有数据。

RST:复位标志

复位标志有效。用于复位相应的TCP连接。

URG:紧急标志

紧急(The urgent pointer) 标志有效。紧急标志置位,

PSH:推标志

该标志置位时,接收端不将该数据进行队列处理,而是尽可能快将数据转由应用处理。在处理 telnet 或 rlogin 等交互模式的连接时,该标志总是置位的。

FIN:结束标志

带有该标志置位的数据包用来结束一个TCP回话,但对应端口仍处于开放状态,准备接收后续数据。

在TCP层,有个FLAGS字段,这个字段有以下几个标识:SYN, FIN, ACK, PSH, RST, URG.其中,对于我们日常的分析有用的就是前面的五个字段。它们的含义是:SYN表示建立连接,FIN表示关闭连接,ACK表示响应,PSH表示有 DATA数据传输,RST表示连接重置。

其中,ACK是可能与SYN,FIN等同时使用的,比如SYN和ACK可能同时为1,它表示的就是建立连接之后的响应,如果只是单个的一个SYN,它表示的只是建立连接。

TCP的几次握手就是通过这样的ACK表现出来的。但SYN与FIN是不会同时为1的,因为前者表示的是建立连接,而后者表示的是断开连接。

RST一般是在FIN之后才会出现为1的情况,表示的是连接重置。一般地,当出现FIN包或RST包时,我们便认为客户端与服务器端断开了连接;

而当出现SYN和SYN+ACK包时,我们认为客户端与服务器建立了一个连接。

PSH为1的情况,一般只出现在DATA内容不为0的包中,也就是说PSH为1表示的是有真正的TCP数据包内容被传递。TCP的连接建立和连接关闭,都是通过请求-响应的模式完成的。

WireShark抓包的情况

其中目的端口为0885(16进制),转换成10进制就为2181

三次握手

所谓三次握手(Three-way Handshake),是指建立一个 TCP 连接时,需要客户端和服务器总共发送3个报文。

三次握手的目的是连接服务器指定端口,建立 TCP 连接,并同步连接双方的序列号和确认号,交换 TCP 窗口大小信息。在 socket 编程中,客户端执行 connect() 时。将触发三次握手。

三次握手过程的示意图如下:

用下面的比喻就是

C:约么?

S:约

C:好的

约会

  • 第一次握手
    客户端将TCP报文标志位SYN置为1,随机产生一个序号值seq=J,保存在TCP首部的序列号(Sequence Number)字段里,指明客户端打算连接的服务器的端口,并将该数据包发送给服务器端,发送完毕后,客户端进入SYN_SENT状态,等待服务器端确认。
  • 第二次握手
    服务器端收到数据包后由标志位SYN=1知道客户端请求建立连接,服务器端将TCP报文标志位SYN和ACK都置为1,ack=J+1,随机产生一个序号值seq=K,并将该数据包发送给客户端以确认连接请求,服务器端进入SYN_RCVD状态。
  • 第三次握手
    客户端收到确认后,检查ack是否为J+1,ACK是否为1,如果正确则将标志位ACK置为1,ack=K+1,并将该数据包发送给服务器端,服务器端检查ack是否为K+1,ACK是否为1,如果正确则连接建立成功,客户端和服务器端进入ESTABLISHED状态,完成三次握手,随后客户端与服务器端之间可以开始传输数据了。

注意:我们上面写的ack和ACK,不是同一个概念:

  • 小写的ack代表的是头部的确认号Acknowledge number, 缩写ack,是对上一个包的序号进行确认的号,ack=seq+1。
  • 大写的ACK,则是我们上面说的TCP首部的标志位,用于标志的TCP包是否对上一个包进行了确认操作,如果确认了,则把ACK标志位设置成1。

至此,三次握手完成,一个TCP连接建立完成,接下来就是双端传输数据了

为什么需要三次握手?

我们假设client发出的第一个连接请求报文段并没有丢失,而是在某个网络结点长时间的滞留了,以致延误到连接释放以后的某个时间才到达server。

本来这是一个早已失效的报文段。但server收到此失效的连接请求报文段后,就误认为是client再次发出的一个新的连接请求。于是就向client发出确认报文段,同意建立连接。

假设不采用“三次握手”,那么只要server发出确认,新的连接就建立了。由于现在client并没有发出建立连接的请求,因此不会理睬server的确认,也不会向server发送数据。但server却以为新的运输连接已经建立,并一直等待client发来数据。这样,server的很多资源就白白浪费掉了。

所以,采用“三次握手”的办法可以防止上述现象发生。例如刚才那种情况,client不会向server的确认发出确认。server由于收不到确认,就知道client并没有要求建立连接。

四次挥手

四次挥手即终止TCP连接,就是指断开一个TCP连接时,需要客户端和服务端总共发送4个包以确认连接的断开。在socket编程中,这一过程由客户端或服务端任一方执行close来触发。
由于TCP连接是全双工的,因此,每个方向都必须要单独进行关闭,这一原则是当一方完成数据发送任务后,发送一个FIN来终止这一方向的连接,收到一个FIN只是意味着这一方向上没有数据流动了,即不会再收到数据了,但是在这个TCP连接上仍然能够发送数据,直到这一方向也发送了FIN。首先进行关闭的一方将执行主动关闭,而另一方则执行被动关闭。

四次挥手过程的示意图如下:

挥手请求可以是Client端,也可以是Server端发起的,我们假设是Client端发起:

  • 第一次挥手: Client端发起挥手请求,向Server端发送标志位是FIN报文段,设置序列号seq,此时,Client端进入FIN_WAIT_1状态,这表示Client端没有数据要发送给Server端了。
  • 第二次分手:Server端收到了Client端发送的FIN报文段,向Client端返回一个标志位是ACK的报文段,ack设为seq加1,Client端进入FIN_WAIT_2状态,Server端告诉Client端,我确认并同意你的关闭请求。
  • 第三次分手: Server端向Client端发送标志位是FIN的报文段,请求关闭连接,同时Client端进入LAST_ACK状态。
  • 第四次分手 : Client端收到Server端发送的FIN报文段,向Server端发送标志位是ACK的报文段,然后Client端进入TIME_WAIT状态。Server端收到Client端的ACK报文段以后,就关闭连接。此时,Client端等待2MSL的时间后依然没有收到回复,则证明Server端已正常关闭,那好,Client端也可以关闭连接了。

TCP实现socket的简单通信(python)

客户端编程

    以下代码是客户端向新浪新闻服务器发送TCP请求,然后将接收到的信息输出。

  1. 首先是创建一个socket连接,使用IPv4协议和TCP协议。
  2. 然后连接百度服务器,80端口是Web服务的标准端口,其他服务都有对应的标准端口号,例如SMTP服务是25端口,FTP服务是21端口,等等。
  3. 将接收到的数据进行输出。

这里以百度为例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
# -*- coding: utf-8 -*-
# @Time : 2021/9/26 10:23
# @Author : npfs
# @FileName: 客户端
# @Blog :http://npfs06.top

import socket

# 创建socket AF_INET指定使用IPv4协议(IPv6-AF_INET6) SOCK_STREAM指定使用面向流的TCP协议
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 80端口是Web服务的标准端口。
# 其他服务都有对应的标准端口号: SMTP服务是25端口,FTP服务是21端口。
s.connect(('www.baidu.com', 80))

# 发送TCP数据。将string中的数据发送到连接的套接字。同时接收数据
s.send(b'GET / HTTP/1.1\r\nHost: www.baidu.com\r\nConnection: close\r\n\r\n')
buffer = []

while True:
d = s.recv(1024) #接受TCP套接字的数据。数据以字符串形式返回,
if d:
# print(d)
buffer.append(d)
else:
break
data = b''.join(buffer)
header, html = data.split(b'\r\n\r\n')

print(data)
print(header.decode('utf-8'))
print(html.decode('utf-8'))
s.close()

服务端编程

    以下代码是服务器端代码。

  1. 首先创建一个基于IPv4和TCP协议的Socket。
  2. 绑定了本地的21567端口(小于1024的端口号必须要有管理员权限才能绑定)。
  3. 设置最大连接数为5,由于考虑到服务器可能同时响应多个客户端的请求,所以,每个连接都需要一个新的进程或者新的线程来处理。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# -*- coding: utf-8 -*-
# @Time : 2021/9/26 10:23
# @Author : npfs
# @FileName: TCP服务端
# @Blog :http://npfs06.top


from socket import *
from time import ctime

print("=====================时间戳TCP服务器=====================")

HOST = '127.0.0.1' #主机号为空白表示可以使用任何可用的地址。
PORT = 21567 #端口号
BUFSIZ = 1024 #接收数据缓冲大小
ADDR = (HOST, PORT)
tcpSerSock = socket(AF_INET, SOCK_STREAM) #创建TCP服务器套接字
tcpSerSock.bind(ADDR) #套接字与地址绑定
tcpSerSock.listen(5) #监听连接,同时连接请求的最大数目

while True:
print('等待客户端的连接...')
tcpCliSock, addr = tcpSerSock.accept() #接收客户端连接请求
print('取得连接:', addr)
while True:
data = tcpCliSock.recv(BUFSIZ) #连续接收指定字节的数据,接收到的是字节数组
if not data: #如果数据空白,则表示客户端退出,所以退出接收
break
#tcpCliSock.send('[%s] %s' % (bytes(ctime(), 'utf-8'), data))
tcpCliSock.send(bytes('[%s] %s' % (ctime(), data.decode('utf-8')), 'utf-8')) #向客户端发送时间戳数据,必须发送字节数组
tcpCliSock.close() #关闭与客户端的连接
tcpSerSock.close() #关闭服务器socket

客户端发送命令,服务端接收命令并执行

    为了实现客户端与以上的服务端通信,我们创建一个客户端,向服务端发送数据。连接建立后,服务器显示取得连接,然后等待客户端数据,并以时间戳的格式再发送给客户端。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# -*- coding: utf-8 -*-
# @Time : 2021/9/26 10:28
# @Author : npfs
# @FileName: TCP客户端
# @Blog :http://npfs06.top


from socket import *


print("=====================TCP客户端=====================")

HOST = '127.0.0.1' #服务器ip地址,等价于localhost
PORT = 21567 #通信端口号
BUFSIZ = 1024 #接收数据缓冲大小
ADDR = (HOST, PORT)
tcpCliSock = socket(AF_INET, SOCK_STREAM) #创建客户端套接字
tcpCliSock.connect(ADDR) #发起TCP连接
while True:
data = input('> ') #接收用户输入
if not data: #如果用户输入为空,直接回车就会发送"",""就是代表false
break
tcpCliSock.send(bytes(data, 'utf-8')) #客户端发送消息,必须发送字节数组
data = tcpCliSock.recv(BUFSIZ) #接收回应消息,接收到的是字节数组
if not data: #如果接收服务器信息失败,或没有消息回应
break
print(data.decode('utf-8')) #打印回应消息,或者str(data,"utf-8")
tcpCliSock.close() #关闭客户端socket

结果如下:

我们先运行服务端程序

然后再运行客户端程序,回到服务端就可以看到取得连接了

在客服端输入内容,就可以成功得到服务端的响应

UDP的原理及特点

    UDP 是 User Datagram Protocol 的简称, 中文名用户数据报协议,是OSI(Open System Interconnection,开放式系统互联)参考模型中一种无连接的传输层协议,提供面向事务的简单不可靠信息传送服务,UDP 在 IP 报文的协议号是 17。

    与 TCP(传输控制协议)协议一样,UDP 协议直接位于 IP(网际协议)协议的顶层。根据 TCP/IP 参考模型,UDP 和TCP 都属于传输层协议。UDP 协议的主要作用是将数据压缩成数据包的形式。一个典型的数据包就是一个二进制数据的传输单位。每一个数据包的前 8 个字节用来包含报头信息,剩余字节则用来包含具体的传输数据。

   UDP协议与TCP协议的不同在于,它是面向无连接,不可靠的数据报协议。而且不需要建立连接就可以,只需要知道对方的IP地址和端口号,就可以直接发数据包。但是,能不能到达就不知道了。

UDP 报文的具体格式如下:

UDP 通信过程

UDP 协议的通信较 TCP 简单了很多,减少了 TCP 的握手、确认、窗口、重传、拥塞控制等机制,UDP 是一个无状态的传输协议。

UDP 客户端在发送数据时并不判断主机是否可达,服务器是否开启等问题,同样它不能确定数据是否成功送达服务器。它只是将数据简单的封了一个包,之后就丢出去了。

UDP通信的流程比较简单,因此要搭建这么一个常用的UDP通信框架也是比较简单的。以下是UDP的框架图

由以上框图可以看出,客户端要发起一次请求,仅仅需要两个步骤(socket和sendto),而服务器端也仅仅需要三个步骤即可接收到来自客户端的消息(socket、bind、recvfrom)

UDP实现socket的简单通信(python)

   和TCP类似,使用UDP的通信双方也分为客户端和服务器。

服务端编程

  1. SOCK_DGRAM指定了这个Socket的类型是UDP。
  2. recvfrom()方法返回数据和客户端的地址与端口,服务器收到数据后,直接调用sendto()就可以把数据用UDP发给客户端。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
# -*- coding: utf-8 -*-
# @Time : 2021/9/26 10:23
# @Author : npfs
# @FileName: 服务端
# @Blog :http://npfs06.top


from socket import *
from time import ctime

host = '' # 监听所有的ip
port = 21567 # 接口必须一致
bufsize = 1024
addr = (host, port)

udpServer = socket(AF_INET, SOCK_DGRAM)
udpServer.bind(addr) # 开始监听

while True:
print('等待客户端的连接...')
udpCliSock, addr = udpServer.recvfrom(bufsize) # 接收数据和返回地址
print('取得连接:', addr)
# 处理数据
while True:
data = udpCliSock.decode(encoding='utf-8').upper()
if not data: # 如果数据空白,则表示客户端退出,所以退出接收
break
data ='[%s] %s' % (bytes(ctime(), 'utf-8'), data)
udpServer.sendto(data.encode(encoding='utf-8'), addr)
# 发送数据
# print('...recevied from and return to :', addr)

udpServer.close()

客户端发送命令,服务端接收命令并执行

    为了实现客户端与以上的服务端通信,我们创建一个客户端,向服务端发送数据。连接建立后,服务器显示取得连接,然后等待客户端数据,并以时间戳的格式再发送给客户端。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# -*- coding: utf-8 -*-
# @Time : 2021/9/26 10:28
# @Author : npfs
# @FileName: 客服端2
# @Blog :http://npfs06.top


from socket import *

host = '127.0.0.1' # 这是客户端的电脑的ip
port = 21567 # 接口选择大于10000的,避免冲突
bufsize = 1024 # 定义缓冲大小

addr = (host, port) # 元祖形式
udpClient = socket(AF_INET, SOCK_DGRAM) # 创建客户端

while True:
data = input('>>> ')
if not data:
break
data = data.encode(encoding="utf-8")
udpClient.sendto(data, addr) # 发送数据
data, addr = udpClient.recvfrom(bufsize) # 接收数据和返回地址
print(data.decode(encoding="utf-8"), 'from', addr)

udpClient.close()

结果如下:

我们先运行服务端程序

然后再运行客户端程序,回到服务端就可以看到取得连接了

在客服端输入内容,就可以成功得到服务端的响应

后记

之前只是跟着学校课程学习过TCP/IP、UDP等协议,但是从来没有实践过

通过这次实践让我对通信协议有了更加深刻的理解,同时接下去准备利用所学的socket通信知识写一个简单的聊天室