Python中Socket编程

最新推荐文章于 2024-02-21 11:23:53 发布

6ri9ht

最新推荐文章于 2024-02-21 11:23:53 发布

阅读量3k

点赞数 15

分类专栏：安全文章标签： python 网络

本文链接：https://blog.csdn.net/weixin_45794666/article/details/112367758

版权

安全专栏收录该内容

15 篇文章 4 订阅

订阅专栏

Python中Socket编程 1

一、Socket概述 1

二、python中socket模块使用 1

三、socket之聊天室 3

四、socket之端口探测 7

五、scapy之tcp端口探测 11

Python中Socket编程

一、Socket概述

socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄，应用程序通常通过"套接字"向网络发出请求或者应答网络请求。

socket即是一种特殊的文件，socket函数就是对其进行的操作（读/写IO、打开、关闭）

socket模块是针对服务器端和客户端Socket 进行【打开】【读写】【关闭】

二、python中socket模块使用

通给指定地址簇和socket类型来进行创建

Socket地址簇	描述
socket.AF_UNIX	只能够用于单一的Unix系统进程间通信
socket.AF_INET	服务器之间网络通信IPv4
socket.AF_INET6	IPv6
socket类型	描述
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常用函数	描述
sk.bind(address)	将socket绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组（host,port）的形式表示地址。
sk.listen(backlog)	开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。
sk.connect(address)	连接到address处的socket。一般，address的格式为元组（hostname,port）,如果连接出错，返回socket.error错误。
sk.connect_ex(address)	同上，只不过会有返回值，连接成功时返回 0 ，连接失败时候返回编码，例如：10061
sk.close()	关闭socket
sk.recv(bufsize)	接受socket的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。
sk.send(string)	将string中的数据发送到连接的socket。
sk.sendall(string)	将string中的数据发送到连接的socket，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。
sk.settimeout(timeout)	设置socket操作的超时期，timeout是一个浮点数，单位是秒。超时期应该在刚创建socket时设置.
sk.accept()	接受连接并返回（conn,address）,其中conn是新的socket对象，可以用来接收和发送数据。address是连接客户端的地址。

三、socket之聊天室

简单收发

编程思路

服务端：

1 创建socket,因为socket是特殊的文件(需要close)，所以通过with
as来自动释放文件资源

with socket.socket(socket.AF_INET,socket.SOCK_STREAM) as sk:

2 绑定套接字到本地IP与端口,开始监听连接

s.bind((HOST,PORT))
s.listen()

3接受客户端的连接请求,

conn, addr = s.accept()

4 通过accept创建的新socket对象接收数据并发送给对方数据

为了保证能收到所有发送来的信息,通过while循环来一直接受数据,直到数据为空

服务器端代码

import socket

HOST = '127.0.0.1'
PORT = 33333

with socket.socket(socket.AF_INET,socket.SOCK_STREAM) as s:
    s.bind((HOST,PORT))
    s.listen()
    conn, addr = s.accept()
    with conn:
        print('conn by',addr)
        while True:
            data = conn.recv(1024)
            if not data:
                break
            print(data)
            conn.sendall(b'hello,client')

客户端代码

import socket

HOST = '127.0.0.1'
PORT = 33333

with socket.socket(socket.AF_INET,socket.SOCK_STREAM) as s:
    s.connect((HOST,PORT))
    s.sendall(b'hello,friend')
    data = s.recv(1024)

print('rece',repr(data))

socket聊天室

服务器

问题1:首先服务器能同时连接多个客户端

Socket.listen()后通过while循环

sk.accept()不断接收新的连接并创建socket

问题2:服务器要连接客户端后能一直接受数据,直到接受到空数据

多个连接之间肯定是独立的,并行的

所以通过线程的方式来实现

问题3:服务器要指定客户端端口和地址后进行回复信息

通过while 循环来一直接收input数据来指定发送

但是上面为了处理多个客户端时,也用了while

所以将连接多个客户端写入函数通过线程来实现,使之并行

服务器代码

from socket import *
import threading


def text_recv(CliSock,addr):
    while True:
            data = CliSock.recv(1024)
            print(addr,"send to you:",data)
            if not data:
                break


def socket_up():
    SerSock = socket(AF_INET, SOCK_STREAM)
    SerSock.bind(('127.0.0.1',58787))
    SerSock.listen()
    while True:
        CliSock, addr = SerSock.accept()
        print('connnecting from:', addr)
        Host[str(addr[1])] = CliSock
        t = threading.Thread(target=text_recv,args=(CliSock,addr))
        t.start()


if __name__ == '__main__':
    Host = {}
    t = threading.Thread(target=socket_up)
    t.start()
    while True:
        try:
            target_info = input('please input your target : msg,port >\n ').split(',')
            msg = target_info[0]
            port = target_info[1]
            conn = Host[port]
            conn.sendall(msg.encode())
        except Exception as e:
            print(e)

客户端

同服务端问题3一致

客户端代码

import threading
from socket import *


def text_recv(SerSock):
    while True:
            data = SerSock.recv(1024)
            print("send to you:",data)
            if not data:
                break


if __name__ == '__main__':
    CliSock = socket(AF_INET, SOCK_STREAM)
    CliSock.connect(('127.0.0.1',58787))
    t = threading.Thread(target=text_recv, args=(CliSock,))
    t.start()
    while True:
        data1 = input('please input want send > \n')
        CliSock.send(data1.encode())
        if not data1:
            break

四、socket之端口探测

探测原理:当通过socket连接目标主机未开放端口时会传出异常

例:ConnectionRefusedError: [WinError 10061]
由于目标计算机积极拒绝，无法连接。

编程思路

1 通过线程创建socket,对目标主机的范围端口进行尝试连接

2.对于没有抛出异常的端口尝试接受数据了解端口信息

问题:有些端口开放但不能接收到信息,就会将进程卡在接受数据那

解决:通过给socket对象设置settimeout()属性来限制超时时间,当超过时间时抛出新的异常:即timeout

所以 except timeout 也是存活端口,但是端口信息没有获取到

3.将存活端口和端口信息加入到字典中,最后遍历输出

实现代码

import threading
from socket import *


def port_find(p):
    try:
        with socket(AF_INET, SOCK_STREAM) as sk:
            sk.connect((HOST, p))
            sk.settimeout(3)
            alive[p] = sk.recv(1024).strip().decode()
            print("port[{}] is alive\n".format(p), end='')

    except timeout:
        print("port[{}] is alive\n".format(p), end='')
        alive[p] = 'this not have info'
    except:
        pass


if __name__ == '__main__':
    HOST = '10.30.25.199'
    alive = {}
    threads = []
    for p in range(1, 65535):
        t = threading.Thread(target=port_find, args=(p,))
        threads.append(t)
        t.start()
    for t1 in threads:
        t1.join()
    for k,v in alive.items():
        print(k,'--->',v)

connect_ex探究使用

connect_ex相对于connect来说多了返回值，连接成功时返回 0
，连接失败时候返回编码，例如：10061

那么就可以通过返回值来对是否存活进行判断

但是还是需要接收那些没有数据的端口,所以设置settimeout,然后在进一步尝试执行,成功就记录收到的数据,失败就表示端口开放但是没有数据

实现代码

import threading
from socket import *


def port_find(p):
        with socket(AF_INET, SOCK_STREAM) as sk:
            re = sk.connect_ex((HOST, p))
            sk.settimeout(3)
            if re == 0:
                print("port[{}] is alive\n".format(p), end='')
                try:
                    alive[p] = sk.recv(1024).strip().decode()
                except:
                    alive[p] = 'this not have info'
            else:
                print("port[{}] is dead\n".format(p), end='')


if __name__ == '__main__':
    HOST = '10.30.25.199'
    alive = {}
    threads = []
    for p in range(1, 65535):
        t = threading.Thread(target=port_find, args=(p,))
        threads.append(t)
        t.start()
    for t1 in threads:
        t1.join()
    for k,v in alive.items():
        print(k,'--->',v)

探究:因为线程开启太多会损害性能

那么如何用两个线程去完成socket的端口探测?

这里用到了python的队列(queue)

编程思想

将扫描的端口一次性put加入到队列中

调用二个子线程开始并行

回调函数中while不断利用get从队列取出端口号进行扫描

就实现了两个线程的并行扫描,互不干涉

实现代码

from socket import *
from queue import Queue
import threading


def port_find():
    while not port_que.empty():
        p = port_que.get()
        with socket(AF_INET, SOCK_STREAM) as sk:
            re = sk.connect_ex((HOST, p))
            sk.settimeout(3)
            if re == 0:
                print("port[{}] is alive\n".format(p), end='')
                try:
                    alive[p] = sk.recv(1024).strip().decode()
                except:
                    alive[p] = 'this not have info'
            else:
                print("port[{}] is dead\n".format(p), end='')


if __name__ == '__main__':
    HOST = '192.168.84.130'
    alive = {}
    threads = []
    port_que = Queue()
    for i in range(30):
        port_que.put(i)
    t1 = threading.Thread(target=port_find)
    t2 = threading.Thread(target=port_find)
    threads.append(t1)
    threads.append(t2)
    t1.start()
    t2.start()
    for t in threads:
        t.join()

    for k, v in alive.items():
        print(k, '--->', v)

五、scapy之tcp端口探测

抓包分析

失败流程:1.SYN-> 2.RST,ACK->

成功流程:1.SYN-> 2.SYN,ACK-> 3.ACK->

可知:Socket是通过tcp三次握手进行端口探测

scapy中TCP(flags=‘S’)可以实现第一次握手，发送SYN包

flags=‘SA’–SYN,ACK包,flags=’RA’—RST,ACK包

编程思路

先用scapy构造一个 flags 的值为 S 的报文，S 代表SYN，就是请求建立一个 TCP
连接，在接收到服务器返回的报文中，如果 flagw
上的值为SA（SYN,ACK），那么就代表服务器确定接收到发送的连接请求并同意建立连接，这时候客户端再回应一个AR（ACK,RST）报文，确定接收到服务器的响应，建立连接后又立刻断开。

实现代码

from scapy.all import *
from scapy.layers.inet import IP, TCP


def port_scan(port):
    packet = IP(dst=ip)/TCP(dport=port,flags='S')   # 构造一个 flags 的值为 S 的报文
    result = sr1(packet,timeout=2,verbose=0)
    if result.haslayer('TCP'):
        if result['TCP'].flags == 'SA':   # 判断目标主机是否返回 SYN+ACK
            send = sr1(IP(dst=ip)/TCP(dport=port,flags='AR'),timeout=2,verbose=0) # 向目标主机发送 ACK+RST
            print('[+] {} is open'.format(port))
        elif result['TCP'].flags == 'RA':
            pass


if __name__ == '__main__':
    ip = '192.168.84.130'
    threads = []
    for p in range(1, 30):
        t = threading.Thread(target=port_scan, args=(p,))
        threads.append(t)
        t.start()
    for t in threads:
        t.join()

6ri9ht

关注

15
点赞
踩
95

收藏

觉得还不错? 一键收藏
3
评论
Python中Socket编程

目录Python中Socket编程 1一、Socket概述 1二、python中socket模块使用 1三、socket之聊天室 3四、socket之端口探测 7五、scapy之tcp端口探测 11Python中Socket编程一、Socket概述socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄，应用程序通常通过"套接字"向网络发出请求或者应答网络请求。socket即是一种特殊的文件，socket函数就是对其进行的操作（读/写IO、打
复制链接

扫一扫