计算机网络基础
一、网络开发两大架构
早期数据交互原理——>socket(套接字)的模型
socket(套接字)是收发数据的一个工具
a文件与b文件之间的交流是通过c文件实现的
a文件把数据放到c文件中,b文件从c文件中取
b文件把数据放到c文件中,a文件从c文件中取
出现网络后:
a文件中的数据,可以通过网络协议,转化成像101010这样的电信号,进行发送
a文件借助socket发送数据
b文件结束socket接收数据
1、C/S 架构
c => client 客户端
是具体的一个软件,像QQ,微信这种
s => server 服务端
天河三号 百亿亿次
2、B/S 架构
b => browser 浏览器
通过输入网址,访问对方的服务器,对方服务器响应请求之后,吧对应的数据给你返回,就可以你的浏览器上看到想要的内容
s => server 服务端
3、未来的发展方向
相对于C/S架构,B/S架构更好,也是未来的发展方向
(1)省去复杂漫长的下载安装环节,节省收集或者电脑的硬盘空间
(2)利用手机的便捷性,随时随地可以访问到网站和相应的服务,提升效率,加快速度
二、网络的概念
1、IP地址
IP地址(Internet Protocol Address)是指互联网协议地址,又译为网际协议地址。
查看IP的两种方式:
第一种:通过电脑中的网络和Internet设置查看本机网络信息
第二种:通过cmd中执行ipconfig命令查看本机网络信息
ip地址的最后一位0或255,不能使用;
255(1111)是广播地址,0(0000)是网络地址(网段)
2、MAC地址
mac地址即物理地址是唯一的,它是一个用来确认网络设备位置的位址。
3、网段
网段(network segment)一般指一个计算机网络中使用同一物理层设备(传输介质,中继器,集线器等)能够直接通讯的那一部分。
判别依据:如果IP地址和子网掩码想与,得到的值相同就是同一网段
子网掩码:区分网段和主机和一串IP
案例一:
ip 192.168.31.43
11000000 10101000 00011111 00101011
子网掩码 255.255.255.0
11111111 11111111 11111111 00000000
IP & 子网掩码
11000000 10101000 00011111 00000000
ip1的网段:192.168.31.0
ip 192.168.30.44
11000000 10101000 00011110 00101100
子网掩码 255.255.255.0
11111111 11111111 11111111 00000000
IP & 子网掩码
11000000 10101000 00011110 00000000
ip2的网段:192.168.30.0
ip1的网段和ip2的网段不同,不一样,所以不在同一个网段不能通信
案例二:
ip 192.168.30.44
11000000 10101000 00011110 00101100
子网掩码 255.255.0.0
11111111 11111111 00000000 00000000
ip & 子网掩码
11000000 10101000 00000000 00000000
ip1的网段:192.168.0.0
ip 192.168.30.44
11000000 10101000 00011110 00101100
子网掩码 255.255.0.0
11111111 11111111 00000000 00000000
ip & 子网掩码
11000000 10101000 00000000 00000000
ip2的网段:192.168.0.0
ip1的网段与ip2的网段完全相同,所以再同一个网段可以通信
注:ping 域名 可以查看网络是否通畅(顺便可以拿到IP)
4、端口
某个程序与外界通讯的出口
通过ip + 端口 可以找到世界上任何一台电脑的任何一个软件
端口的范围:0~65535
形式:192.168.2.1:8000
自定义端口号时,起8000以上
前1024个端口被系统占用了
20 端口:FTP 文件传输协议(默认数据口)
21 端口:FTP 文件传输协议(控制)
22 端口:SSH 远程登录协议
23 端口:telent(终端仿真协议),木马Tiny Telnet Server
25 端口:SMTP 服务器所开放的端口,用于发送邮件
80 端口:http,用于网页浏览,木马Executor开放此端口
443 端口:基于 TLS/SSL 的网页浏览端口,能提供加密和通过安全端口传输的另一种HTTP
3306端口:Mysql 开放此端口
三、OSI 网络七层模型
应用层(应用层,表示层,会话层):
封装数据
依据不同的协议,封装对应格式的数据消息
HTTP【超文本传输协议】
HTTPS【加密传输超文本协议】
FTP【文件传输协议】
SMTP【电子邮件传输协议】
传输层:
封装端口
指定传输的协议(TCP协议/UDP协议)
网络层:
封装IP
版本IPV4或IPV6
数据链路层:
封装mac地址
指定链路层的协议(arp协议(ip=>mac)/rarp协议(mac=>ip))
物理层:
打成数据包,变成二进制字节流,,通过网络进行传输
四、交换机与路由器
交换机:对同一网段的不同机器之间进行数据转发的设备(每一台机器和交换机相连,形成通信)
交换机解析的时候从下到上拆两层,拆物理层和数据,可以找到mac地址
路由器:对不同网段的不同机器之间进行数据转发的设备(每一个局域网和路由器相连,形成通信)
路由器解析的时候从下到上拆三层,拆物理层、数据链路层和网络层,可以找到ip
ARP协议:通过ip => mac (arp地址解析协议)
作用:通过交换机的一次广播和一次单播找到对应的mac地址
电脑a先发送一个arp的广播包,把mac标记一个全FF-FF-FF-FF-FF-FF的广播地址
交换机接收到arp的广播包,从下到上进行拆包,拆2层,到数据链路层得到mac
发现mac是全F的广播地址,重新打包,交换机开始广播,所有连接在交换的设备都会收到arp广播包
各个主机开始拆包,对应FF广播地址可以跳过,继续向上找,发现ip不符合,直接舍弃
路由器允许从下到上拆三层,拆到ip,得到对应的网段
打开路由器的对照表 网关->网段,重新打包,找到对应的接口发送数据包
对应的交换机得到数据包,重新从下到上拆包,2层,发现全F,开始广播
数据库的主机接收到广播包,从下到上拆包,ip正确,符合自己的条件
数据库主机会把ip->mac的映射关系的数据发送回当前的交换机,
此时,交换机通过单播,把对应的ip和mac发送回原来请求的主机
数据在通过路由器,交换机发送回去
原主机在得到了ip 和 mac 之后,
重新把真实数据进行打包,从而完成发送
如果没有mac,主机一开始会发送arp请求包(发出找mac的请求)
各大主机在接受arp请求包的时候,都会去对照自己本机当中的arp解析表(ip->mac)
如果没有,这个arp得请求包舍弃,
如果有,会把自己的ip和mac封装在arp的响应包当中给交换机进行单播
在回来的过程中,所有相应的主机都会拿响应包中的数据更新自己的arp解析表,方便下次使用.
arp协议: 通过ip -> mac
五、TCP/UDP协议
三次握手
SYN 创建连接
ACK 确认响应
FIN 断开连接
三次握手
客户端发送一个请求,与服务端建立连接
服务端接受这个请求,并且响应与客户端建立连接的请求
(服务端的响应和请求是在一次发送当中完成的)
客户端接受服务端的请求之后,把消息在响应给服务端
接下来客户端和服务端可以发送数据了.
每发送一个数据出去,对应的主机都会有一个回执消息,确认数据的接受情况,
如果没有得到回执消息,该数据会重发一次,保证数据的完整.
不会一直不停的发下去,有时间最大允许周期.
TCP(Transmission Control Protocol)一种面向链接的、可靠的、传输层通信协议(比如:打电话)
优点:可靠,稳定,传输完整稳定,不限制数据大小
缺点:慢,效率低,占用系统资源高,一发一收都需要对方确认
应用:Web浏览器,电子邮件,文件传输,大量数据传输的场景
UDP(User Datagram Protocol)一种面向无连接的、不可靠的传输层通信协议(比如:发短信)
优点:速度快,可以多人同时聊天,耗费资源少,不许要建立链接
缺点:不稳定,不能保证每次数据都能接收到
应用:IP电话,实时视频会议,聊天软件,少量数据传输的场景
客户端和服务端建立链接时:三次握手
客户端和服务端断开链接时:四次挥手
四次挥手MSL为最大报文段生存时间,默认规定MSL为2分钟,但实际应用中常用的是30秒,1分钟和2分钟等
六、socket
socket的意义:网络通信过程中,信息拼接的工具(中文:套接字)
在开发中,一个端口只对应一个程序生效,在测试时,允许端口重复捆绑(开发时删掉)
在bind方法之前加上这句话,可以让一个端口重复使用
sk.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
实现TCP发消息
# 服务端
import socket
# 1 创建socket对象
sk = socket.socket()
# 2 绑定对应的ip和端口(注册网络,让其他主机能够找到)
sk.bind(('127.0.0.1', 8000))
# 3 开启监听
sk.listen()
# 4 建立三次握手
conn, addr = sk.accept()
print(conn, addr)
# 5 收发数据(recv里面的参数单位是字节,代表一次最多接收多少数据)
ret = conn.recv(1024)
# print(ret)
print(ret.decode("utf-8"))
# 6 四次挥手
conn.close()
# 7 退还端口
sk.close()
# 客户端
import socket
# 1 创建一个socket对象
sk = socket.socket()
# 2 与服务器进行连接
sk.connect(('127.0.0.1', 8000))
# 3 发送数据(二进制字节流)
sk.send("今天风和日丽".encode("utf-8"))
# 4 关闭连接
sk.close()
实现TCP循环发消息:
在收发数据的时候不使用encode编码是不能传输中文的
因为传输的数据类型是二进制字节流
要使用b修饰字符串,代表是二进制字节流
注:里面的字符串必须是ascii编码中的字符,不能是中文,否则报错
# 客户端
import socket
sk = socket.socket()
# 让端口重复绑定多个程序(仅仅在测试阶段使用)
sk.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sk.bind(('127.0.0.1', 8000))
sk.listen()
conn, addr = sk.accept()
while True:
ret = conn.recv(1024)
print(ret.decode())
msg = input("服务端请输入:")
conn.send(msg.encode())
conn.close()
sk.close()
# 服务端
import socket
sk = socket.socket()
sk.connect(('127.0.0.1', 8000))
while True:
msg = input("客户端请输入:")
sk.send(msg.encode())
ret = sk.recv(1024)
print(ret.decode())
sk.close()
实现UDP发送消息:
# 服务端
import socket
# 1 创建udp对象
sk = socket.socket(type=socket.SOCK_DGRAM)
# 2 绑定地址端口
sk.bind(('127.0.0.1', 8000))
# 3 接收消息(udp作为服务端的时候,第一次一定是接收消息)
msg, cli_addr = sk.recvfrom(1024)
print(msg.decode())
print(cli_addr)
# 服务端给客户端发消息
msg = "你好,boy"
sk.sendto(msg.encode(), cli_addr)
# 4 关闭连接
sk.close()
# 客户端
import socket
# 1 创建udp对象
sk = socket.socket(type=socket.SOCK_DGRAM)
# 2 发送数据
msg = "你好,girl"
sk.sendto(msg.encode(), ("127.0.0.1", 8000))
# 客户端接受服务端发过来的数据
msg, ser_addr = sk.recvfrom(1024)
print(msg.decode())
print(ser_addr)
# 3 关闭文件
sk.close()
实现UDP循环发送消息:
# 服务端
import socket
sk = socket.socket(type=socket.SOCK_DGRAM)
sk.bind(('127.0.0.1', 8000))
while True:
ret, cli_addr = sk.recvfrom(1024)
print(ret.decode())
msg = input("服务端请输入:")
sk.sendto(msg.encode(), cli_addr)
sk.close()
# 客户端
import socket
sk = socket.socket(type=socket.SOCK_DGRAM)
while True:
msg = input("客户端输入:")
sk.sendto(msg.encode(), ("127.0.0.1", 8000))
ret, ser_addr = sk.recvfrom(1024)
print(ret.decode())
sk.close()
黏包问题
tcp协议在发送数据时,会出现黏包现象
(1)数据黏包是因为在客户端/服务器端都会有一个数据缓冲区,缓冲区用来临时保存数据,为了保证能够完整的接收到数据,因此缓冲区都会设置的比较大。
(2)在收发数据频繁时,由于tcp传输消息的无边界,不清楚应该截取多少长度导致客户端/服务器端,都有可能把多条数据当成是一条数据进行截取,造成黏包。
黏包出现的两种情况
(1)黏包现象一:
在发送端,由于两个数据短,发送的时间间隔短,所以在发送端形成黏包
(2)粘包现象二:
在发送端,由于两个数据几乎同时被发送到对方的缓存中,所以在接收端形成了黏包
粘包对比:TCP和UDP
tcp协议
缺点:接收数据之间无边界,有可能粘合几条数据成一条数据,造成粘包
优点:不限制数据包的大小,稳定传输不丢包
udp协议:
优点:接收时侯数据之间有边界,传输速度快,不粘包
缺点:限制数据包的大小(受带宽路由器等因素影响),传输不稳定,可能丢包
tcp和udp对于数据包来说都可以进行拆包和解包,理论上来讲,无论多大都能分次发送
但是tcp一旦发送失败,对方无响应(对方无回执),tcp可以选择再发,直到对应相应完毕为止
而udp一旦发送失败,是不会询问对方是否有相应的,数据量过大就会容易丢包
解决黏包问题
解决黏包场景:
应用场景在实时通讯时,需要阅读此次发送的消息是什么
不需要解决粘包场景:
下载或者上传文件的时候,最后要把包都结合在一起,粘包无所谓
# 普通解决粘包方式第一种是通过time.slee()阻塞
# 普通解决粘包方式第二种是先把长度发送过去在进行接收
# 服务端
import socket
sk = socket.socket()
sk.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sk.bind(('127.0.0.1', 8000))
sk.listen()
conn, addr = sk.accept()
conn.send('00000100'.encode())
msg = "hello" * 20
conn.send(msg.encode())
conn.send(",word".encode())
conn.close()
sk.close()
# 客户端
import socket
import time
sk = socket.socket()
sk.connect(('127.0.0.1', 8000))
ret = sk.recv(8)
num = int(ret.decode("utf-8"))
ret1 = sk.recv(num)
# time.sleep(0.1)
ret2 = sk.recv(1024)
print(ret1)
print(ret2)
sk.close()
struct模块
pack:把任意长度的数字转化成居右4个字节的固定长度的字节流
unpack:把四个字节值恢复成原本的数字,返回元组
参数i:int的简写,要转化的当前数据时整型
注:pack的数值范围不是无限的,上限大概在21个亿左右,不要超过这个值
# 服务端
import socket
import struct
sk = socket.socket()
sk.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sk.bind(('127.0.0.1', 8000))
sk.listen()
conn, addr = sk.accept()
strvar = input("服务端请输入:")
msg = strvar.encode()
length = len(msg)
res = struct.pack('i', length)
conn.send(res)
conn.send(msg)
conn.send(",world".encode())
conn.close()
sk.close()
# 客户端
import socket
import time
import struct
sk = socket.socket()
sk.connect(('127.0.0.1', 8000))
n = sk.recv(4)
tup = struct.unpack('i', n)
n = tup[0]
print(n)
res1 = sk.recv(n)
print(res1.decode())
res2 = sk.recv(1024)
print(res2.decode())
sk.close()
七、socketserver模块
基于原有的socket模块进行封装后的模块socketserver
网络协议的最底层就是socket
socketserver的作用:实现TCP协议,server端的并发
socket参数的详解:
socket.socket(family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None)
family参数:地址系列默认为AF_INET,AF_INET代表IPV4;AF_INET6代表IPV6
AF_UNIX,AF_CAN或AF_RDS.(AF_UNIX 域实际上是使用本地 socket [文件]来通信)同一机器
type参数:套接字类型应为SOCK_STREAM(默认值),SOCK_DGRAM,SOCK_RAW或其他SOCK_常量之一。
**SOCK_STREAM** 是基于TCP的,有保障的(即能保证数据正确传送到对方)面向连接的SOCKET,多用于资料传送。
**SOCK_DGRAM** 是基于UDP的,无保障的面向消息的socket,多用于在网络上发广播信息。
proto参数:协议号通常为零,可以省略,或者在地址族为AF_CAN的情况下,协议应为CAN_RAW或CAN_BCM之一。
fileno参数:如果指定了fileno,则其他参数将被忽略,导致带有指定文件描述符的套接字返回。
与socket.fromfd()不同,fileno将返回相同的套接字,而不是重复的。 这可能有助于使用socket.close()关闭一个独立的插座。
实例:
# 服务端
import socketserver
class MyServer(socketserver.BaseRequestHandler):
def handle(self):
conn = self.request
while True:
ret = conn.recv(1024)
print(ret.decode())
msg = input("服务端请输入:")
conn.send(msg.encode())
server = socketserver.ThreadingTCPServer(("127.0.0.1", 8000), MyServer)
server.serve_forever()
# 客户端
import socket
sk = socket.socket()
sk.connect(("127.0.0.1", 8000))
while True:
msg = input("客户端请输入:")
sk.send(msg.encode())
ret = sk.recv(1024)
print(ret.decode())
sk.close()
八、hashlib模块和hmac模块
hashlib模块:是一堆加密算法的集合,哈希算法的加密方式不止一种
https://www.cmd5.com/ md5解密
应用场景:在需要校验功能时使用
用户密码的 => 加密,解密
相关校验的 => 加密,解密
哈希算法也叫摘要算法,相同的数据始终得到相同的输出结果,不同的数据得到不同的输出结果
(1)哈希将不可变的任意长度的数据,变成具有固定长度的唯一值
(2)字典的键和集合的值是通过哈希计算存储的,存储的数据是散列(无序)
1、加密
import hashlib
import random
hs = hashlib.md5()
# hashlib基本用法
hs.update("12346".encode("utf-8"))
ret = hs.hexdigest()
print(ret, len(ret))
# 加盐
hs = hashlib.md5("pddf".encode())
ret = hs.hexdigest()
print(ret, len(ret))
# 动态加盐
ret = str(random.randrange(1000,100000))
print(ret)
hs = hashlib.md5(ret.encode("utf-8"))
hs.update("123456".encode())
ret = hs.hexdigest()
print(ret)
# sha算法
hs = hashlib.sha1()
hs.update('123456'.encode())
ret = hs.hexdigest()
print(ret, len(ret))
# hmac加密
import hmac
key = b"asd"
msg = b"1232456"
hm = hmac.new(key, msg)
ret = hm.hexdigest()
print(ret, len(ret))
# hmac动态加盐
import os
key = os.urandom(32)
msg = b'123456'
hm = hmac.new(key, msg)
ret = hm.hexdigest()
print(ret, "<1>", len(ret))
2、文件的验证
import hashlib
hm = hashlib.md5()
hm.update('123'.encode())
ret = hm.hexdigest()
print(ret, len(ret))
# 文件的验证:小文件的验证
def check_md5(file):
with open(file, mode="rb") as fp:
hs = hashlib.md5()
hs.update(fp.read())
return hs.hexdigest()
ret1 = check_md5("ceshi1.txt")
ret2 = check_md5("ceshi2.txt")
print(ret1, ret2)
# 文件的验证:大文件的验证
hs = hashlib.md5()
hs.update("今天是星期一".encode())
ret = hs.hexdigest()
print(ret)
hs = hashlib.md5()
hs.update("今天是".encode())
hs.update("星期一".encode())
ret = hs.hexdigest()
print(ret)
# 验证方式一:通过文件截取的方式验证
def check_md5(file):
hs = hashlib.md5()
with open(file, mode = "rb") as fp:
while True:
content = fp.read(5)
if content:
hs.update(content)
else:
break
return hs.hexdigest()
print(check_md5('ceshi1.txt'))
print(check_md5('ceshi2.txt'))
# 验证方式二:通过计算文件大小的方式验证
def check_md5(file):
hs = hashlib.md5()
num = os.path.getsize(file)
with open(file, mode="rb") as fp:
while num:
content = fp.read(5)
hs.update(content)
num -= len(content)
return hs.hexdigest()
4、服务器的合法性验证
# 服务端1(公司)
import socket
import hmac
import hashlib
def auth(sk,secret_key):
# 处理权限验证的逻辑
msg = sk.recv(32)
hm = hmac.new(secret_key.encode(),msg)
"""
# 在不知道加密算法的时候,只知道密钥也没用;
hs = hashlib.md5(secret_key.encode())
hs.update(msg)
res = hs.hexdigest()
"""
res = hm.hexdigest()
print(res)
sk.send(res.encode("utf-8"))
secret_key = "芝麻开门"
sk = socket.socket()
sk.connect( ("127.0.0.1" , 9000) )
# 验证服务端
auth(sk,secret_key)
# 发送数据
sk.send("请求调用支付宝刷脸支付接口".encode("utf-8"))
# 服务端2(支付宝)
import socket
import hmac
import os
def auth(conn,secret_key):
# 随机产生32位二进制字节流
msg = os.urandom(32)
conn.send(msg)
hm = hmac.new(secret_key.encode(),msg)
res_serve = hm.hexdigest()
print(res_serve)
res_client = conn.recv(1024).decode("utf-8")
if res_client == res_serve:
print("是合法的连接用户")
return True
else:
print("是不合法的连接用户")
return False