精华内容
下载资源
问答
  • BoopSuite一套用Python编写工具套件,用于无线审核和安全测试
  • 工具类 Some useful tools written in python. You can star this repository to keep track of the project if it's ...邮箱安全性验证工具 计算器 计算器 ipLocQuery 根据IP获得地理位置信息 时钟 简易时钟 quer
  • Python编写的命令行Git实用程序 从pypi安装: python -m pip install git_python_utils git_python_tools.version_string 基于git历史记录自动生成版本字符串。 使用格式字符串或模板文件的可自定义版本字符串...
  • 库和工具集 枚举无线接口 sudo python3 -m boop interface 是否需要有关无线接口​​的其他信息? sudo python3 -m boop interface {INTERFACE} -vvvv 更改卡模式 sudo python3 -m boop mode {INTERFACE} {monitor|...
  • python信息安全工具之端口扫描器

    万次阅读 多人点赞 2018-11-08 19:59:51
    /usr/bin/env python3 #-*-coding:utf-8-*- import time import socket def get_ip_by_name(domain): ''' 提供域名转ip的功能,利用socket.gethostbyname,返回str ''' try: return socket....

    前言

    人生苦短,我用python。有人可能会文这样的问题,既然市面上已经十分完美的同种类型的工具,为什么还需要自己写呢?我个人认为通过一定限度”造轮子”才能提高能力,通过“造轮子”才能能脱离“脚本小子”的阵营。
    这个系列我将使用python写出端口扫描,端口爆破,服务识别,cms识别等工具。能力有限。

    正文

    端口扫描,就是对一段端口或指定的端口进行扫描。通过扫描结果可以知道一台计算机上都提供了哪些服务,然后就可以通过所提供的这些服务的己知漏洞就可进行攻击。其原理是当一个主机向远端一个服务器的某一个端口提出建立一个连接的请求,如果对方有此项服务,就会应答,如果对方未安装此项服务时,即使你向相应的端口发出请求,对方仍无应答,利用这个原理,如果对所有熟知端口或自己选定的某个范围内的熟知端口分别建立连接,并记录下远端服务器所给予的应答,便可知道哪些端口是开放的。

    著名的端口扫描器有namp等等

    在这里插入图片描述
    下面将使用Python提供socket模块制造一个简易的端口扫描器,分为三个版本,分别是最基础的版本,多线程版本以及最后的交互式版本,需要学习python3的socket和threading模块的简单使用。
    端口扫描的原理:

    调用socket.connect_ex((ip, port)),端口开放则返回0,否则返回错误代码,实现和nmap的全连接扫描类似的功能。

    单线程版本,对top50、top100、top1000以及自定义端口扫描,使用socket模块进行端口扫描。

    #!/usr/bin/env python3
    #-*-coding:utf-8-*-
    
    import time
    import socket
    
    def get_ip_by_name(domain):
        '''
        提供域名转ip的功能,利用socket.gethostbyname,返回str
        '''
        try:
            return socket.gethostbyname
        except Exception as e:
            print("%s:%s"%(domain, e))
    
    def __port_scan(ip, port_list, timeout):
        '''
        端口扫描核心代码
        '''
        START_MSG = ""
        OPEN_MSG = "% 6d [OPEN]"
        result_list = list()
    
        for port in port_list:
            try:
                s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                s.settimeout(timeout)
                result_code = s.connect_ex((ip, port)) #开放放回0
                if result_code == 0:
                    print(OPEN_MSG % port)
                    result_list.append(port)
                else:
                    continue
            except Exception as e:
                print(e)
            finally:
                s.close()
        return result_list
    
    
    def all_port_scan(ip, start_port = 1, end_port = 65535, timeout=3):
        '''
        扫描所有的端口(1-65535),返回一个包含所有开放的端口list,可以通过参数start_port和参数end_port自定义开始端口和结束端口
        '''
        port_list = range(start_port,end_port+1)
        result_list =  __port_scan(ip, port_list, timeout)
        return result_list
    
    def value_port_scan(ip, top = 1000, timeout = 3):
        '''
        扫描top的端口,top的值可以选择50、100、1000(default),返回一个包含所有开放的端口list,可以通过参数top设置top值
        '''
        top50_list = [21,22,25,53,80,110,113,135,139,143,179,199,443,445,465,514,548,554,587,646,993,995,1025,1026,1433,1720,1723,2000,3306,3389,5060,5666,5900,6001,8000,8008,8080,8443,8888,10000,32768,49152,49154]
        top100_list = [7,9,13,21,22,25,37,53,79,80,88,106,110,113,119,135,139,143,179,199,389,427,443,444,465,513,514,543,548,554,587,631,646,873,990,993,995,1025,1026,1027,1028,1110,1433,1720,1723,1755,1900,2000,2049,2121,2717,3000,3128,3306,3389,3986,4899,5000,5009,5051,5060,5101,5190,5357,5432,5631,5666,5800,5900,6000,6646,7070,8000,8008,8080,8443,8888,9100,9999,32768,49152,49153,49154,49155,49156]
        top1000_list = [1,3,6,9,13,17,19,20,21,22,23,24,25,30,32,37,42,49,53,70,79,80,81,82,83,84,88,89,99,106,109,110,113,119,125,135,139,143,146,161,163,179,199,211,222,254,255,259,264,280,301,306,311,340,366,389,406,416,425,427,443,444,458,464,481,497,500,512,513,514,524,541,543,544,548,554,563,587,593,616,625,631,636,646,648,666,667,683,687,691,700,705,711,714,720,722,726,749,765,777,783,787,800,808,843,873,880,888,898,900,901,902,911,981,987,990,992,995,999,1000,1001,1007,1009,1010,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1102,1104,1105,1106,1107,1110,1111,1112,1113,1117,1119,1121,1122,1123,1126,1130,1131,1137,1141,1145,1147,1148,1151,1154,1163,1164,1165,1169,1174,1183,1185,1186,1192,1198,1201,1213,1216,1217,1233,1236,1244,1247,1259,1271,1277,1287,1296,1300,1309,1310,1322,1328,1334,1352,1417,1433,1443,1455,1461,1494,1500,1503,1521,1524,1533,1556,1580,1583,1594,1600,1641,1658,1666,1687,1700,1717,1718,1719,1720,1723,1755,1761,1782,1801,1805,1812,1839,1862,1863,1875,1900,1914,1935,1947,1971,1974,1984,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2013,2020,2021,2030,2033,2034,2038,2040,2041,2042,2045,2046,2047,2048,2065,2068,2099,2103,2105,2106,2111,2119,2121,2126,2135,2144,2160,2170,2179,2190,2196,2200,2222,2251,2260,2288,2301,2323,2366,2381,2382,2393,2399,2401,2492,2500,2522,2525,2557,2601,2604,2607,2638,2701,2710,2717,2725,2800,2809,2811,2869,2875,2909,2920,2967,2998,3000,3003,3005,3006,3011,3013,3017,3030,3052,3071,3077,3128,3168,3211,3221,3260,3268,3283,3300,3306,3322,3323,3324,3333,3351,3367,3369,3370,3371,3389,3404,3476,3493,3517,3527,3546,3551,3580,3659,3689,3703,3737,3766,3784,3800,3809,3814,3826,3827,3851,3869,3871,3878,3880,3889,3905,3914,3918,3920,3945,3971,3986,3995,3998,4000,4001,4002,4003,4004,4005,4045,4111,4125,4129,4224,4242,4279,4321,4343,4443,4444,4445,4449,4550,4567,4662,4848,4899,4998,5000,5001,5002,5003,5009,5030,5033,5050,5054,5060,5080,5087,5100,5101,5120,5190,5200,5214,5221,5225,5269,5280,5298,5357,5405,5414,5431,5440,5500,5510,5544,5550,5555,5560,5566,5631,5633,5666,5678,5718,5730,5800,5801,5810,5815,5822,5825,5850,5859,5862,5877,5900,5901,5902,5903,5906,5910,5915,5922,5925,5950,5952,5959,5960,5961,5962,5987,5988,5998,5999,6000,6001,6002,6003,6004,6005,6006,6009,6025,6059,6100,6106,6112,6123,6129,6156,6346,6389,6502,6510,6543,6547,6565,6566,6580,6646,6666,6667,6668,6689,6692,6699,6779,6788,6792,6839,6881,6901,6969,7000,7001,7004,7007,7019,7025,7070,7100,7103,7106,7200,7402,7435,7443,7496,7512,7625,7627,7676,7741,7777,7800,7911,7920,7937,7999,8000,8001,8007,8008,8009,8010,8021,8031,8042,8045,8080,8081,8082,8083,8084,8085,8086,8087,8088,8089,8093,8099,8180,8192,8193,8200,8222,8254,8290,8291,8300,8333,8383,8400,8402,8443,8500,8600,8649,8651,8654,8701,8800,8873,8888,8899,8994,9000,9001,9002,9009,9010,9040,9050,9071,9080,9090,9099,9100,9101,9102,9110,9200,9207,9220,9290,9415,9418,9485,9500,9502,9535,9575,9593,9594,9618,9666,9876,9877,9898,9900,9917,9929,9943,9968,9998,9999,10000,10001,10002,10003,10009,10012,10024,10082,10180,10215,10243,10566,10616,10621,10626,10628,10778,11110,11967,12000,12174,12265,12345,13456,13722,13782,14000,14238,14441,15000,15002,15003,15660,15742,16000,16012,16016,16018,16080,16113,16992,17877,17988,18040,18101,18988,19101,19283,19315,19350,19780,19801,19842,20000,20005,20031,20221,20828,21571,22939,23502,24444,24800,25734,26214,27000,27352,27355,27715,28201,30000,30718,30951,31038,31337,32768,32769,32770,32771,32772,32773,32774,32775,32776,32777,32778,32779,32780,32781,32782,32783,32784,33354,33899,34571,34572,35500,38292,40193,40911,41511,42510,44176,44442,44501,45100,48080,49152,49153,49154,49155,49156,49157,49158,49159,49160,49163,49165,49167,49175,49400,49999,50000,50001,50002,50006,50300,50389,50500,50636,50800,51103,51493,52673,52822,52848,52869,54045,54328,55055,55555,55600,56737,57294,57797,58080,60020,60443,61532,61900,62078,63331,64623,64680,65000,65129,65389]
    
        if top == 50:
            port_list = top50_list
        elif top == 100:
            port_list = top100_list
        else:
            port_list = top1000_list
    
        result_list = __port_scan(ip, port_list, timeout)
        return result_list
    
    if __name__ == '__main__':
        #all_port_scan("127.0.0.1")
        value_port_scan("127.0.0.1")
    

    第一个版本的扫描器扫描全部端口结果:
    在这里插入图片描述
    单线程肯定是很慢的,端口个数是65535个一共花费了307秒钟,第二个版本就是多线程版本,优化第一个版本扫描的代码,并且对代码进行了封装。

    #!/usr/bin/env python3
    #-*-coding:utf-8-*-
    
    import time, sys
    import socket
    import queue
    import threading
    
    class PortScaner(object):
        '''
        这个版本(v2)的端口扫描器相对于上一个版本(v1),大概变化是:使用类(class)来封装,增加多线程,细节上的变化
        '''
    
        class PortScan(threading.Thread):
            def __init__(self, port_queue, ip, timeout = 3):
                '''
                初始化参数
                '''
                threading.Thread.__init__(self)
                self.__port_queue = port_queue
                self.__ip = ip
                self.__timeout = timeout
            def run(self):
                '''
                多线程实际调用的方法,如果端口队列不为空,循环执行
                '''
                while True:
                    if self.__port_queue.empty():
                        break
                    OPEN_MSG = "% 6d [OPEN]\n"
                    port = self.__port_queue.get(timeout = 0.5)
                    ip  = self.__ip
                    timeout = self.__timeout
    
                    try:
                        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                        s.settimeout(timeout)
                        result_code = s.connect_ex((ip, port)) #开放放回0
                        if result_code == 0:
                            #print(OPEN_MSG % port) # print不适合多线程
                            sys.stdout.write(OPEN_MSG % port)
                            #result_list.append(port)
                        # else:
                        #     sys.stdout.write("% 6d [CLOSED]\n" % port)
                    except Exception as e:
                        print(e)
                    finally:
                        s.close()
    
        def get_port_lists(self, top = None, start_port = 1, end_port = 65535):
            '''
            获取扫描的端口list,top == None, start_port和end_port有效,top取值为50,100,1000分为为前top端口,当top == None时,并且端口号无效返回[1-65535]
            '''
            top50_list = [21,22,25,53,80,110,113,135,139,143,179,199,443,445,465,514,548,554,587,646,993,995,1025,1026,1433,1720,1723,2000,3306,3389,5060,5666,5900,6001,8000,8008,8080,8443,8888,10000,32768,49152,49154]
            top100_list = [7,9,13,21,22,25,37,53,79,80,88,106,110,113,119,135,139,143,179,199,389,427,443,444,465,513,514,543,548,554,587,631,646,873,990,993,995,1025,1026,1027,1028,1110,1433,1720,1723,1755,1900,2000,2049,2121,2717,3000,3128,3306,3389,3986,4899,5000,5009,5051,5060,5101,5190,5357,5432,5631,5666,5800,5900,6000,6646,7070,8000,8008,8080,8443,8888,9100,9999,32768,49152,49153,49154,49155,49156]
            top1000_list = [1,3,6,9,13,17,19,20,21,22,23,24,25,30,32,37,42,49,53,70,79,80,81,82,83,84,88,89,99,106,109,110,113,119,125,135,139,143,146,161,163,179,199,211,222,254,255,259,264,280,301,306,311,340,366,389,406,416,425,427,443,444,458,464,481,497,500,512,513,514,524,541,543,544,548,554,563,587,593,616,625,631,636,646,648,666,667,683,687,691,700,705,711,714,720,722,726,749,765,777,783,787,800,808,843,873,880,888,898,900,901,902,911,981,987,990,992,995,999,1000,1001,1007,1009,1010,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1102,1104,1105,1106,1107,1110,1111,1112,1113,1117,1119,1121,1122,1123,1126,1130,1131,1137,1141,1145,1147,1148,1151,1154,1163,1164,1165,1169,1174,1183,1185,1186,1192,1198,1201,1213,1216,1217,1233,1236,1244,1247,1259,1271,1277,1287,1296,1300,1309,1310,1322,1328,1334,1352,1417,1433,1443,1455,1461,1494,1500,1503,1521,1524,1533,1556,1580,1583,1594,1600,1641,1658,1666,1687,1700,1717,1718,1719,1720,1723,1755,1761,1782,1801,1805,1812,1839,1862,1863,1875,1900,1914,1935,1947,1971,1974,1984,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2013,2020,2021,2030,2033,2034,2038,2040,2041,2042,2045,2046,2047,2048,2065,2068,2099,2103,2105,2106,2111,2119,2121,2126,2135,2144,2160,2170,2179,2190,2196,2200,2222,2251,2260,2288,2301,2323,2366,2381,2382,2393,2399,2401,2492,2500,2522,2525,2557,2601,2604,2607,2638,2701,2710,2717,2725,2800,2809,2811,2869,2875,2909,2920,2967,2998,3000,3003,3005,3006,3011,3013,3017,3030,3052,3071,3077,3128,3168,3211,3221,3260,3268,3283,3300,3306,3322,3323,3324,3333,3351,3367,3369,3370,3371,3389,3404,3476,3493,3517,3527,3546,3551,3580,3659,3689,3703,3737,3766,3784,3800,3809,3814,3826,3827,3851,3869,3871,3878,3880,3889,3905,3914,3918,3920,3945,3971,3986,3995,3998,4000,4001,4002,4003,4004,4005,4045,4111,4125,4129,4224,4242,4279,4321,4343,4443,4444,4445,4449,4550,4567,4662,4848,4899,4998,5000,5001,5002,5003,5009,5030,5033,5050,5054,5060,5080,5087,5100,5101,5120,5190,5200,5214,5221,5225,5269,5280,5298,5357,5405,5414,5431,5440,5500,5510,5544,5550,5555,5560,5566,5631,5633,5666,5678,5718,5730,5800,5801,5810,5815,5822,5825,5850,5859,5862,5877,5900,5901,5902,5903,5906,5910,5915,5922,5925,5950,5952,5959,5960,5961,5962,5987,5988,5998,5999,6000,6001,6002,6003,6004,6005,6006,6009,6025,6059,6100,6106,6112,6123,6129,6156,6346,6389,6502,6510,6543,6547,6565,6566,6580,6646,6666,6667,6668,6689,6692,6699,6779,6788,6792,6839,6881,6901,6969,7000,7001,7004,7007,7019,7025,7070,7100,7103,7106,7200,7402,7435,7443,7496,7512,7625,7627,7676,7741,7777,7800,7911,7920,7937,7999,8000,8001,8007,8008,8009,8010,8021,8031,8042,8045,8080,8081,8082,8083,8084,8085,8086,8087,8088,8089,8093,8099,8180,8192,8193,8200,8222,8254,8290,8291,8300,8333,8383,8400,8402,8443,8500,8600,8649,8651,8654,8701,8800,8873,8888,8899,8994,9000,9001,9002,9009,9010,9040,9050,9071,9080,9090,9099,9100,9101,9102,9110,9200,9207,9220,9290,9415,9418,9485,9500,9502,9535,9575,9593,9594,9618,9666,9876,9877,9898,9900,9917,9929,9943,9968,9998,9999,10000,10001,10002,10003,10009,10012,10024,10082,10180,10215,10243,10566,10616,10621,10626,10628,10778,11110,11967,12000,12174,12265,12345,13456,13722,13782,14000,14238,14441,15000,15002,15003,15660,15742,16000,16012,16016,16018,16080,16113,16992,17877,17988,18040,18101,18988,19101,19283,19315,19350,19780,19801,19842,20000,20005,20031,20221,20828,21571,22939,23502,24444,24800,25734,26214,27000,27352,27355,27715,28201,30000,30718,30951,31038,31337,32768,32769,32770,32771,32772,32773,32774,32775,32776,32777,32778,32779,32780,32781,32782,32783,32784,33354,33899,34571,34572,35500,38292,40193,40911,41511,42510,44176,44442,44501,45100,48080,49152,49153,49154,49155,49156,49157,49158,49159,49160,49163,49165,49167,49175,49400,49999,50000,50001,50002,50006,50300,50389,50500,50636,50800,51103,51493,52673,52822,52848,52869,54045,54328,55055,55555,55600,56737,57294,57797,58080,60020,60443,61532,61900,62078,63331,64623,64680,65000,65129,65389]
    
            if(top != None):
                if(top == 50):
                    return top50_list
                elif(top == 100):
                    return top100_list
                else:
                    return top1000_list
            else:
                if start_port >= 1 and end_port <= 65535 and start_port <= end_port:
                    return list(range(start_port, end_port+1))
                else:
                    return list(range(1, 65535+1))
    
        def get_ip_by_name(self, domain):
            '''
            提供域名转ip的功能,利用socket.gethostbyname,返回str
            '''
            try:
                return socket.gethostbyname
            except Exception as e:
                print("%s:%s"%(domain, e))
    
    def main():
        start_time = time.time() # 脚本开始执行的时间
        port_scner = PortScaner()
        port_queue = queue.Queue() # py3的写法,使用queue模块, 线程专用
        thread_num = 100 # 线程数量
        threads = [] # 保存新线程
        top = None # 取端口top数
        ip = "xxx.xxx.xx.xx" # 扫描的ip
        port_list = port_scner.get_port_lists(top = top) # 根据参数获取总端口list
        #print(port_list)
    
        for port in port_list:
            port_queue.put(port)
        for t in range(thread_num):
            threads.append(port_scner.PortScan(port_queue, ip, timeout = 3))
        # 启动线程
        for thread in threads:
            thread.start()
        # 阻塞线程
        for thread in threads:
            thread.join()
        end_time = time.time() # 脚本结束执行的时间
        print("[end time] %3ss"%(end_time-start_time,))
    if __name__ == '__main__':
        main()
    

    下面是第二版扫描器的运行结果,扫描本局域网中的另一台主机全部端口,大概需要十二秒钟。
    在这里插入图片描述
    如果是扫描top1000端口,扫描时间是0.15秒钟,默认100线程,当时top1000扫描的只是top1000的端口,不常用端口不能识别。
    在这里插入图片描述
    对比单线程版本,速度简直不要太快好吗?但是这个版本有一个较大的问题是所有的配置都需要在main()函数中修改,使用起来不是特别方便。

       thread_num = 100 # 线程数量
        threads = [] # 保存新线程
        top = None # 取端口top数
        ip = "xxx.xxx.xx.xx" # 扫描的ip
        port_list = port_scner.get_port_lists(top = top) # 根据参数获取总端口list
    

    而第三个版本则主要解决了这个问题,可以通过命令行进行交互,当然代码质量因为能力有限不是很好。

    #!/usr/bin/env python3
    #-*-coding:utf-8-*-
    
    import time, sys
    import socket
    import queue
    import threading
    import base64
    
    class PortScaner(object):
        '''
        这个版本(v3)的端口扫描器相对于上一个版本(v2),大概变化是:增加交互功能和LOGO
        '''
    
        class PortScan(threading.Thread):
            def __init__(self, port_queue, ip, timeout = 3):
                '''
                初始化参数
                '''
                threading.Thread.__init__(self)
                self.__port_queue = port_queue
                self.__ip = ip
                self.__timeout = timeout
            def run(self):
                '''
                多线程实际调用的方法,如果端口队列不为空,循环执行
                '''
                while True:
                    if self.__port_queue.empty():
                        break
                    OPEN_MSG = "% 6d [OPEN]\n"
                    port = self.__port_queue.get(timeout = 0.5)
                    ip  = self.__ip
                    timeout = self.__timeout
    
                    try:
                        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                        s.settimeout(timeout)
                        result_code = s.connect_ex((ip, port)) #开放放回0
                        if result_code == 0:
                            #print(OPEN_MSG % port) # print不适合多线程
                            sys.stdout.write(OPEN_MSG % port)
                            #result_list.append(port)
                        # else:
                        #     sys.stdout.write("% 6d [CLOSED]\n" % port)
                    except Exception as e:
                        print(e)
                    finally:
                        s.close()
    
        def get_port_lists(self, top = None, start_port = 1, end_port = 65535):
            '''
            获取扫描的端口list,top == None, start_port和end_port有效,top取值为50,100,1000分为为前top端口,当top == None时,并且端口号无效返回[1-65535]
            '''
            top50_list = [21,22,25,53,80,110,113,135,139,143,179,199,443,445,465,514,548,554,587,646,993,995,1025,1026,1433,1720,1723,2000,3306,3389,5060,5666,5900,6001,8000,8008,8080,8443,8888,10000,32768,49152,49154]
            top100_list = [7,9,13,21,22,25,37,53,79,80,88,106,110,113,119,135,139,143,179,199,389,427,443,444,465,513,514,543,548,554,587,631,646,873,990,993,995,1025,1026,1027,1028,1110,1433,1720,1723,1755,1900,2000,2049,2121,2717,3000,3128,3306,3389,3986,4899,5000,5009,5051,5060,5101,5190,5357,5432,5631,5666,5800,5900,6000,6646,7070,8000,8008,8080,8443,8888,9100,9999,32768,49152,49153,49154,49155,49156]
            top1000_list = [1,3,6,9,13,17,19,20,21,22,23,24,25,30,32,37,42,49,53,70,79,80,81,82,83,84,88,89,99,106,109,110,113,119,125,135,139,143,146,161,163,179,199,211,222,254,255,259,264,280,301,306,311,340,366,389,406,416,425,427,443,444,458,464,481,497,500,512,513,514,524,541,543,544,548,554,563,587,593,616,625,631,636,646,648,666,667,683,687,691,700,705,711,714,720,722,726,749,765,777,783,787,800,808,843,873,880,888,898,900,901,902,911,981,987,990,992,995,999,1000,1001,1007,1009,1010,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1102,1104,1105,1106,1107,1110,1111,1112,1113,1117,1119,1121,1122,1123,1126,1130,1131,1137,1141,1145,1147,1148,1151,1154,1163,1164,1165,1169,1174,1183,1185,1186,1192,1198,1201,1213,1216,1217,1233,1236,1244,1247,1259,1271,1277,1287,1296,1300,1309,1310,1322,1328,1334,1352,1417,1433,1443,1455,1461,1494,1500,1503,1521,1524,1533,1556,1580,1583,1594,1600,1641,1658,1666,1687,1700,1717,1718,1719,1720,1723,1755,1761,1782,1801,1805,1812,1839,1862,1863,1875,1900,1914,1935,1947,1971,1974,1984,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2013,2020,2021,2030,2033,2034,2038,2040,2041,2042,2045,2046,2047,2048,2065,2068,2099,2103,2105,2106,2111,2119,2121,2126,2135,2144,2160,2170,2179,2190,2196,2200,2222,2251,2260,2288,2301,2323,2366,2381,2382,2393,2399,2401,2492,2500,2522,2525,2557,2601,2604,2607,2638,2701,2710,2717,2725,2800,2809,2811,2869,2875,2909,2920,2967,2998,3000,3003,3005,3006,3011,3013,3017,3030,3052,3071,3077,3128,3168,3211,3221,3260,3268,3283,3300,3306,3322,3323,3324,3333,3351,3367,3369,3370,3371,3389,3404,3476,3493,3517,3527,3546,3551,3580,3659,3689,3703,3737,3766,3784,3800,3809,3814,3826,3827,3851,3869,3871,3878,3880,3889,3905,3914,3918,3920,3945,3971,3986,3995,3998,4000,4001,4002,4003,4004,4005,4045,4111,4125,4129,4224,4242,4279,4321,4343,4443,4444,4445,4449,4550,4567,4662,4848,4899,4998,5000,5001,5002,5003,5009,5030,5033,5050,5054,5060,5080,5087,5100,5101,5120,5190,5200,5214,5221,5225,5269,5280,5298,5357,5405,5414,5431,5440,5500,5510,5544,5550,5555,5560,5566,5631,5633,5666,5678,5718,5730,5800,5801,5810,5815,5822,5825,5850,5859,5862,5877,5900,5901,5902,5903,5906,5910,5915,5922,5925,5950,5952,5959,5960,5961,5962,5987,5988,5998,5999,6000,6001,6002,6003,6004,6005,6006,6009,6025,6059,6100,6106,6112,6123,6129,6156,6346,6389,6502,6510,6543,6547,6565,6566,6580,6646,6666,6667,6668,6689,6692,6699,6779,6788,6792,6839,6881,6901,6969,7000,7001,7004,7007,7019,7025,7070,7100,7103,7106,7200,7402,7435,7443,7496,7512,7625,7627,7676,7741,7777,7800,7911,7920,7937,7999,8000,8001,8007,8008,8009,8010,8021,8031,8042,8045,8080,8081,8082,8083,8084,8085,8086,8087,8088,8089,8093,8099,8180,8192,8193,8200,8222,8254,8290,8291,8300,8333,8383,8400,8402,8443,8500,8600,8649,8651,8654,8701,8800,8873,8888,8899,8994,9000,9001,9002,9009,9010,9040,9050,9071,9080,9090,9099,9100,9101,9102,9110,9200,9207,9220,9290,9415,9418,9485,9500,9502,9535,9575,9593,9594,9618,9666,9876,9877,9898,9900,9917,9929,9943,9968,9998,9999,10000,10001,10002,10003,10009,10012,10024,10082,10180,10215,10243,10566,10616,10621,10626,10628,10778,11110,11967,12000,12174,12265,12345,13456,13722,13782,14000,14238,14441,15000,15002,15003,15660,15742,16000,16012,16016,16018,16080,16113,16992,17877,17988,18040,18101,18988,19101,19283,19315,19350,19780,19801,19842,20000,20005,20031,20221,20828,21571,22939,23502,24444,24800,25734,26214,27000,27352,27355,27715,28201,30000,30718,30951,31038,31337,32768,32769,32770,32771,32772,32773,32774,32775,32776,32777,32778,32779,32780,32781,32782,32783,32784,33354,33899,34571,34572,35500,38292,40193,40911,41511,42510,44176,44442,44501,45100,48080,49152,49153,49154,49155,49156,49157,49158,49159,49160,49163,49165,49167,49175,49400,49999,50000,50001,50002,50006,50300,50389,50500,50636,50800,51103,51493,52673,52822,52848,52869,54045,54328,55055,55555,55600,56737,57294,57797,58080,60020,60443,61532,61900,62078,63331,64623,64680,65000,65129,65389]
    
            if(top != None):
                if(top == 50):
                    return top50_list
                elif(top == 100):
                    return top100_list
                else:
                    return top1000_list
            else:
                if start_port >= 1 and end_port <= 65535 and start_port <= end_port:
                    return list(range(start_port, end_port+1))
                else:
                    return list(range(1, 65535+1))
    
        def get_ip_by_name(self, domain):
            '''
            提供域名转ip的功能,利用socket.gethostbyname,返回str
            '''
            domain = (domain.replace("http://","")).replace("https://","") # py3
            print(domain)
            try:
                return socket.gethostbyname(domain)
            except Exception as e:
                print("%s:%s"%(domain, e))
        def split(self, args):
            port_temp = args[4].split("-")
            start_port = int(port_temp[0])
            end_port = int(port_temp[1])
            return int(start_port), int(end_port)
    
        def banber(self):
            logo = '''
     ____            _   ____
    |  _ \ ___  _ __| |_/ ___|  ___ __ _ _ __   ___ _ __
    | |_) / _ \| '__| __\___ \ / __/ _` | '_ \ / _ \ '__|
    |  __/ (_) | |  | |_ ___) | (_| (_| | | | |  __/ |
    |_|   \___/|_|   \__|____/ \___\__,_|_| |_|\___|_|   v3.0
            '''
            return logo
    
        def help(self):
            help = """
    [Usage]
        python portscaner_v3.py -i ip -p [port_scope|top_num] [-t thread_num]
        python portscaner_v3.py -u url -p [port_scope|top_num] [-t thread_num]\n\n[Example]
        python3 portscaner_v3.py -i 127.0.0.1 -p 1000 -t 100
        python3 portscaner_v3.py -u https://www.baidu.com -p 1-65535
    
    [Value]
        ip              0.0.0.0-255.255.255.255
        top_num         [50|100|1000(default)]
        port_scope      1-65535
        thread_num      [int|10(default)]
            """
            return help
    
    def main():
        start_time = time.time() # 脚本开始执行的时间
        port_scner = PortScaner()
        logo = port_scner.banber()
        #usage = port_scner.usage()
        port_queue = queue.Queue() # py3的写法,使用queue模块, 线程专用
        thread_num = 10 # 线程数量,default=10
        threads = [] # 保存新线程
        top = None # 取端口top数
        start_port = 0
        end_port = 0
        ip = "127.0.0.1" # 扫描的ip
    
        # 命令行交互
        print(logo)
        args = sys.argv
        if "-h" in args or "--help" in args:
            help = port_scner.help()
            print(help)
            sys.exit(1)
        if len(args) == 7:
            #['portscaner_v3.py', '-i', 'ip', '-p', '10-100', '-t', 'thread_num']
            if args[1] == "-i" and args[3] == "-p" and args[5] == "-t":
                ip = args[2]
                thread_num = args[6]
                if args[4].find("-")!=-1:
                    split = port_scner.split()
                    start_port = split[0]
                    end_port = split[1]
                else:
                    top = args[4]
    
            elif args[1] == "-u" and args[3] == "-p" and args[5] == "-t":
                ip = port_scner.get_ip_by_name(args[2])
                thread_num = args[6]
                if args[4].find("-")!=-1:
                    split = port_scner.split()
                    start_port = split[0]
                    end_port = split[1]
                else:
                    top = args[4]
            else:
                sys.exit(1)
        elif len(args) == 5: # thread_num default 10
            if args[1] == "-i" and args[3] == "-p":
                ip = args[2]
                if args[4].find("-")!=-1:
                    split = port_scner.split()
                    start_port = split[0]
                    end_port = split[1]
                else:
                    top = args[4]
            elif args[1] == "-u" and args[3] == "-p":
                ip = port_scner.get_ip_by_name(args[2])
                if args[4].find("-")!=-1:
                    split = port_scner.split()
                    start_port = split[0]
                    end_port = split[1]
                else:
                    top = args[4]
            else:
                sys.exit(1)
        else:
            help = port_scner.help()
            print(help)
            sys.exit(1)
        #print("ip:%s,top:%s,start_port:%s,end_port:%s,thread_num:%s"%(ip,type(top),type(start_port),type(end_port),type(thread_num)))
    
        if top != None:
            port_list = port_scner.get_port_lists(top = top) # 根据参数获取总端口list
        else:
            port_list = port_scner.get_port_lists(start_port = start_port, end_port = end_port)
    
        for port in port_list:
            port_queue.put(port)
    
        for t in range(int(thread_num)):
            threads.append(port_scner.PortScan(port_queue, ip, timeout = 3))
    
        print("[RESULT]\n")
        # 启动线程
        for thread in threads:
            thread.start()
        # 阻塞线程
        for thread in threads:
            thread.join()
        end_time = time.time() # 脚本结束执行的时间
        print("[end time] %3ss"%(end_time-start_time,))
    if __name__ == '__main__':
        main()
    

    下面是运行第三个版本扫描器的截图,帮助说明
    在这里插入图片描述
    扫描结果
    在这里插入图片描述

    后言

    共勉

    展开全文
  • SHTools-一些有用的bash工具用纯python编写。 关于 纯Python实现的一些bash命令工具集合。 要求 Python3 安装 通过pip命令安装: pip install shtools 或者通过下载源码包或clone代码至本地,然后通过如下命令安装...
  • python 实现的UDP通信,利用生产者消费者模式,通过线性安全队列实现多线程同步。如果要实现在不同电脑上通信,需要关闭防火墙。默认的是hostlocal(可以读程序)。基于python2.7。未打包exe。
  • Python安全测试工具合集

    千次阅读 2015-08-28 15:12:22
    Python安全测试工具合集 转自:http://netsecurity.51cto.com/art/201311/417021.htm ----------------------------------------------------------------------------------------------------------------------...

                                                    Python安全测试工具合集


    转自:http://netsecurity.51cto.com/art/201311/417021.htm

    -----------------------------------------------------------------------------------------------------------------------------------
    网络

    Scapy: send, sniff and dissect and forge network packets. Usable interactively or as a library pypcap, Pcapy and       pylibpcap: several different Python bindings for libpcap
              发送,嗅和解剖和伪造的网络数据包。可以和不同的库进行交互pypcap,Scapy的和pylibpcap:几种不同的Python绑定的libpcap

    libdnet: low-level networking routines, including interface lookup and Ethernet frame transmission
                低层次的网络例程,包括接口的查找和以太网帧传输

    dpkt: fast, simple packet creation/parsing, with definitions for the basic TCP/IP protocols
               快速,简单的数据包创建/解析,与基本的TCP / IP协议的
    定义(sendpkt :Python发包)

    Impacket: craft and decode network packets. Includes support for higher-level protocols such as NMB and SMB
                 制作和解码网络数据包。包括对高层协议如SMB和SMB支持

    pynids: libnids wrapper offering sniffing, IP defragmentation, TCP stream reassembly and port scan detection
                利用libnids包装产品嗅探,IP碎片整理,TCP流重组和端口扫描检测

    Dirtbags py-pcap: read pcap files without libpcap
                 阅读PCAP文件而不需要依赖libpcap库

    flowgrep: grep through packet payloads using regular expressions
                  使用正则表达式查找数据包的有效载荷

    Knock Subdomain Scan: enumerate subdomains on a target domain through a wordlist

                 通过字典枚举目标的子域名

    Mallory:  extensible TCP/UDP man-in-the-middle proxy, supports modifying non-standard protocols on the fly
                  扩展TCP/UDP的中间人代理,支持非标准的协议.

    Pytbull: flexible IDS/IPS testing framework (shipped with more than 300 tests)
                 灵活的IDS / IPS测试框架(附带超过300个测试)
    -----------------------------------------------------------------------------------------------------------------------------------
    调试和逆向工程

    Paimei: reverse engineering framework, includes PyDBG, PIDA, pGRAPH
                 逆向工程框架,包括PyDBG,PIDA,pGRAPH

    Immunity Debugger: scriptable GUI and command line debugger
                  编写脚本的GUI和命令行调试器

    mona.py: PyCommand for Immunity Debugger that replaces and improves on pvefindaddr
                  PyCommand作为Immunity调试器,取代并改善pvefindaddr

    IDAPython: IDA Pro plugin that integrates the Python programming language, allowing scripts to run in IDA Pro
                  IDA Pro的插件,集成了Python编程语言,允许脚本在IDA Pro的运行

    PyEMU: fully scriptable IA-32 emulator, useful for malware analysis
                 完全脚本IA-32仿真器,用于恶意软件分析有用

    pefile: read and work with Portable Executable (aka PE) files
                阅读和操作PE文件

    pydasm: Python interface to the libdasm x86 disassembling library
                Python分解libdasm X86的库

    PyDbgEng: Python wrapper for the Microsoft Windows Debugging Engine
               Python包装的Microsoft Windows调试引擎

    uhooker: intercept calls to API calls inside DLLs, and also arbitrary addresses within the executable file in memory
               拦截调用内存中的可执行文件中的DLL里面的API调用和任意的可执行文件在内存中的地址.

    diStorm: disassembler library for AMD64, licensed under the BSD license
               针对AMD64,基于BSD许可证授权的反汇编库

    python-ptrace: debugger using ptrace (Linux, BSD and Darwin system call to trace processes) written in Python
                 使用ptrace函数(Linux操作系统,BSD和达尔文的系统调用跟踪过程)用Python编写的调试器

    vdb / vtrace: vtrace is a cross-platform process debugging API implemented in python, and vdb is a debugger which uses it
                 vtrace是用python实现一个跨平台的程序调试API,并VDB是一个使用它的调试器

    Androguard: reverse engineering and analysis of Android applications Fuzzing
                逆向工程和Android应用分析模糊化工具
    -----------------------------------------------------------------------------------------------------------------------------------
    Fuzzing

    Sulley: fuzzer development and fuzz testing framework consisting of multiple extensible components
               模糊器开发和模糊测试框架包含多个可扩展的组件

    Peach Fuzzing Platform: extensible fuzzing framework for generation and mutation based fuzzing (v2 was written in Python)
                可扩展的模糊测试框架用于生成不同的模糊测试(V2是用Python编写的)

    antiparser: fuzz testing and fault injection API TAOF, (The Art of Fuzzing) including ProxyFuzz, a man-in-the-middle non-deterministic network fuzzer
               模糊测试和故障注入的API TAOF,(模糊测试的艺术),包括ProxyFuzz,一个中间人非确定性网络的fuzzer

    untidy: general purpose XML fuzzer
              通用的XML的fuzzer

    Powerfuzzer: highly automated and fully customizable web fuzzer (HTTP protocol based application fuzzer) SMUDGE
              高度自动化,完全可定制的Web模糊器(基于HTTP协议的应用程序的fuzzer)SMUDGE

    Mistress: probe file formats on the fly and protocols with malformed data, based on pre-defined patterns
             无线探针文件格式和异常的协议数据,基于预定义的模式

    Fuzzbox: multi-codec media fuzzer
            多编解码器的媒体的fuzzer

    Forensic Fuzzing Tools: generate fuzzed files, fuzzed file systems, and file systems containing fuzzed files in order to test the robustness of forensics tools and examination systems
            生成为了测试的取证工具和考试系统的鲁棒性模糊化文件,模糊化的文件系统,并包含模糊化文件的文件系统


    Windows IPC Fuzzing Tools: tools used to fuzz applications that use Windows Interprocess Communication mechanisms  
              使用Windows进程间通信机制模糊应用程序的工具

    WSBang: perform automated security testing of SOAP based web services
            执行基于SOAP的Web服务的自动安全测试
             
    Construct: library for parsing and building of data structures (binary or textual). Define your data structures in a declarative manner
              用于解析和构建数据结构(二进制或文本)的库。以声明的方式定义你的数据结构

    fuzzer.py (feliam): simple fuzzer by Felipe Andres Manzano
               简单的fuzzer


    Fusil: Python library used to write fuzzing programs Web
              Python用来编写Web模糊测试程序的库
    -----------------------------------------------------------------------------------------------------------------------------------
    Web

    Requests: elegant and simple HTTP library, built for human beings
                 优雅和简单的HTTP库,专为人类

    HTTPie: human-friendly cURL-like command line HTTP client
                人性化的类似CURL的命令行HTTP客户端

    ProxMon: processes proxy logs and reports discovered issues
               流程代理日志和报告发现的问题

    WSMap: find web service endpoints and discovery files
              找到Web服务端点和发现文件

    Twill: browse the Web from a command-line interface. Supports automated Web testing
             从一个命令行界面浏览网页接口。支持自动化的Web测试

    Ghost.py: webkit web client written in Python
             WebKit的Web客户端用Python编写

    Windmill: web testing tool designed to let you painlessly automate and debug your web application
             Web测试工具,旨在让您无痛自动化和调试你的Web应用程序

    FunkLoad: functional and load web tester
              Web功能和负载网络测试仪

    spynner: Programmatic web browsing module for Python with Javascript/AJAX support
              对于Python编程网页浏览模块的JavaScript/ AJAX支持

    python-spidermonkey: bridge to the Mozilla SpiderMonkey JavaScript engine; allows for the evaluation and calling of Javascript scripts and functions
                调用Mozilla的SpiderMonkey JavaScript引擎;允许使用Javascript脚本和函数

    mitmproxy: SSL-capable, intercepting HTTP proxy. Console interface allows traffic flows to be inspected and edited on the fly
               支持SSL的,拦截HTTP代理。无线控制台接口允许流量进行检查和编辑

    pathod / pathoc: pathological daemon/client for tormenting HTTP clients and servers
                 pathological守护进程/客户端tormentingHTTP客户端和服务器
    -----------------------------------------------------------------------------------------------------------------------------------
    取证

    Volatility: extract digital artifacts from volatile memory (RAM) samples
                  提取RAM的样本数字文物

    LibForensics: library for developing digital forensics applications TrIDLib, identify file types from their binary signatures. Now includes Python binding
                 用于开发数字取证应用TrIDLib,从他们的二进制特征码识别的文件类型的库。现在,包括Python绑定

    aft: Android forensic toolkit
           Android的法医工具包
    -----------------------------------------------------------------------------------------------------------------------------------
    恶意程序分析

    pyew: command line hexadecimal editor and disassembler, mainly to analyze malware
             命令行的十六进制编辑器和反汇编器,主要是分析恶意软件

    Exefilter: filter file formats in e-mails, web pages or files. Detects many common file formats and can remove active content
             过滤文件格式的电子邮件,网页或文件。检测多种常见的文件格式,并可以删除活动内容

    pyClamAV: add virus detection capabilities to your Python software jsunpack-n, generic JavaScript 
             新增的病毒检测能力到你的Python软件jsunpack-N,通用的JavaScript

    unpacker: emulates browser functionality to detect exploits that target browser and browser plug-in vulnerabilities
              模拟浏览器的功能,以检测针对浏览器和浏览器插件的漏洞攻击

    yara-python: identify and classify malware samples
               识别和分类的恶意软件样本

    phoneyc: pure Python honeyclient implementation
              纯Python honeyclient实施
    -----------------------------------------------------------------------------------------------------------------------------------
    PDF

    Didier Stevens' PDF tools: analyse, identify and create PDF files (includes PDFiD, pdf-parser and make-pdf and mPDF)
               分析,识别和创建PDF文件(包括PDFiD,PDF解析器和制作PDF和MPDF)

    Opaf: Open PDF Analysis Framework. Converts PDF to an XML tree that can be analyzed and modified.
              打开PDF格式分析框架。转换成PDF格式,可以分析和修改XML树。

    Origapy: Python wrapper for the Origami Ruby module which sanitizes PDF files
              Python包装的折纸的Ruby模块,清理了PDF文件

    pyPDF: pure Python PDF toolkit: extract info, spilt, merge, crop, encrypt, decrypt…
              纯Python的PDF工具包:提取信息,洒,合并,裁剪,加密,解密...

    PDFMiner: extract text from PDF files
              从PDF文件中提取文本


    python-poppler-qt4: Python binding for the Poppler PDF library, including Qt4 support Misc
                        Python绑定的poppler的PDF库,包括Qt4的支持杂项
    -----------------------------------------------------------------------------------------------------------------------------------
    Misc

    InlineEgg: toolbox of classes for writing small assembly programs in Python
                用Python编写小汇编程序的工具箱

    Exomind: framework for building decorated graphs and developing open-source intelligence modules and ideas, centered on social network services, search engines and instant messaging
             用于构建,装饰图形和开发的开源智能模块和思路的框架,围绕社交网络服务,搜索引擎和即时通讯

    RevHosts: enumerate virtual hosts for a given IP address
              枚举给定的IP地址的虚拟主机

    simplejson: JSON encoder/decoder, e.g. to use Google's AJAX API
               JSON编码器/解码器,例如使用谷歌的AJAX API

    PyMangle: command line tool and a python library used to create word lists for use with other penetration testing tools
             命令行工具,用于创建单词列表与其他渗透测试工具使用Python库

    Hachoir: view and edit a binary stream field by field
             查看和编辑二进制流

    py-mangle: command line tool and a python library used to create word lists for use with other penetration testing tools
             命令行工具,用于创建单词列表与其他渗透测试工具使用Python库


    pymsf是著名安全研究团队Spiderlabs实现的一个Python与Metasploit msgrpc进行通信的python模块,通过它,你可以利用Python玩转渗透测试框架Metasploit
    -----------------------------------------------------------------------------------------------------------------------------------
    其他有用的Py库和工具

    IPython: enhanced interactive Python shell with many features for object introspection, system shell access, and its own special command system
             增强的交互式Python的外壳采用了许多功能对象自省,系统shell访问,和自己的特殊指令系统

    Beautiful Soup: HTML parser optimized for screen-scraping
              简单强大易用的HTML解析器

    matplotlib: make 2D plots of arrays
               使阵列的2D绘图

    Mayavi: 3D scientific data visualization and plotting
              3D科学数据可视化和绘图

    RTGraph3D: create dynamic graphs in 3D
              在3D制作动态图表

    Twisted: event-driven networking engine
              事件驱动的网络引擎

    Suds: lightweight SOAP client for consuming Web Services
             轻量级SOAP客户端

    M2Crypto: most complete OpenSSL wrapper
              最完整的OpenSSL的包装

    NetworkX: graph library (edges, nodes)
               图形库(边缘,节点)

    Pandas: library providing high-performance, easy-to-use data structures and data analysis tools
               高性能,易使用的数据结构和数据分析工具

    pyparsing: general parsing module
               通用的解析模块

    lxml: most feature-rich and easy-to-use library for working with XML and HTML in the Python language
                功能最丰富的,易于使用的库,用于处理XML和HTML

    Whoosh: fast, featureful full-text indexing and searching library implemented in pure Python
             快速,多特征的全文索引和纯Python实现的搜索库

    Pexpect: control and automate other programs, similar to Don Libes `Expect` system Sikuli, visual technology to search and automate GUIs using screenshots. Scriptable inJython
              控制和自动化其他程序,类似于Don Libes `Expect` 系统Sikuli,可视化技术用于搜索和自动化的GUIS

    PyQt and PySide: Python bindings for the Qt application framework and GUI library
               Python绑定的Qt应用程序框架和GUI库


    -----------------------------------------------------------------------------------------------------------------------------------

    CTF工具

    pwntools:pwntools是一个ctf框架和漏洞利用开发库,用Python开发,由rapid设计,旨在让使用者简单快速的编写exploit。

    模块索引

    pwnlib.asm — Assembler functions

    pwnlib.atexception — Callbacks on unhandled exception

    pwnlib.atexit — Replacement for atexit

    pwnlib.constants — Easy access to header file constants

    pwnlib.context — Setting runtime variables

    pwnlib.dynelf — Resolving remote functions using leaks

    pwnlib.elf — Working with ELF binaries

    pwnlib.exception — Pwnlib exceptions

    pwnlib.gdb — Working with GDB

    pwnlib.log and — Logging stuff

    pwnlib.memleak — Helper class for leaking memory

    pwnlib.replacements — Replacements for various functions

    pwnlib.rop — Return Oriented Programming

    pwnlib.shellcraft — Shellcode generation

    pwnlib.term — Terminal handling

    pwnlib.timeout — Timeout handling

    pwnlib.tubes — Talking to the World!

    pwnlib.ui — Functions for user interaction

    pwnlib.useragents — A database of useragent strings

    pwnlib.util.crc — Calculating CRC-sums

    pwnlib.util.cyclic — Generation of unique sequences

    pwnlib.util.fiddling — Utilities bit fiddling

    pwnlib.util.hashes — Hashing functions

    pwnlib.util.iters — Extension of standard module itertools

    pwnlib.util.lists — Operations on lists

    pwnlib.util.misc — We could not fit it any other place

    pwnlib.util.net — Networking interfaces

    pwnlib.util.packing — Packing and unpacking of strings

    pwnlib.util.proc — Working with /proc/

    pwnlib.util.safeeval — Safe evaluation of python code

    pwnlib.util.web — Utilities for working with the WWW

    展开全文
  • Dlint是鼓励最佳编码实践并帮助确保Python代码安全工具。 近年来,作为程序员,我要做的最重要的事情是积极地进行静态代码分析。 与我预防的数百个严重错误相比,更有价值的是关于我查看软件可靠性和代码质量的...
  • python编写的MS17-010多线程扫描器
  • 能够理解和编写Python语句,将信息输出到屏幕,为变量赋值,获取通过键盘输入的信息,并执行计数循环。软件开发过程运行已经编写的程序很容易。较难的部分实际上是先得到一个程序。计算机是非常实在的,必须...

    参与文末每日话题讨论,赠送异步新书

    异步图书君

    学习目标

    知道有序的软件开发过程的步骤。

    了解遵循输入、处理、输出(IPO)模式的程序,并能够以简单的方式修改它们。

    了解构成有效Python标识符和表达式的规则。

    能够理解和编写Python语句,将信息输出到屏幕,为变量赋值,获取通过键盘输入的信息,并执行计数循环。

    软件开发过程

    运行已经编写的程序很容易。较难的部分实际上是先得到一个程序。计算机是非常实在的,必须告诉它们要做什么,直至最后的细节。编写大型程序是一项艰巨的挑战。如果没有系统的方法,几乎是不可能的。

    创建程序的过程通常被分成几个阶段,依据是每个阶段中产生的信息。简而言之,你应该做以下工作。

    分析问题确定要解决的问题是什么。尝试尽可能多地了解它。除非真的知道问题是什么,否则就不能开始解决它。

    确定规格说明准确描述程序将做什么。此时,你不必担心程序“怎么做”,而是要确定它“做什么”。对于简单程序,这包括仔细描述程序的输入和输出是什么以及它们的相互关系。

    创建设计规划程序的总体结构。这是描述程序怎么做的地方。主要任务是设计算法来满足规格说明。

    实现设计将设计翻译成计算机语言并放入计算机。在本书中,我们将算法实现为Python程序。

    测试/调试程序试用你的程序,看看它是否按预期工作。如果有任何错误(通常称为“缺陷”),那么你应该回去修复它们。定位和修复错误的过程称为“调试”程序。在调试阶段,你的目标是找到错误,所以应该尝试你能想到的“打破”程序的一切可能。记住这句老格言:“没有什么能防住人犯傻,因为傻子太聪明了。”

    维护程序继续根据用户的需求开发该程序。大多数程序从来没有真正完成,它们在多年的使用中不断演进。

    示例程序:温度转换器

    让我们通过一个真实世界的简单例子,来体验软件开发过程的步骤,其中涉及一个虚构的计算机科学学生Susan Computewell。

    Susan正在德国学习一年。她对语言没有任何问题,因为她能流利地使用许多语言(包括Python)。她的问题是,很难在早上弄清楚温度从而知道当天该穿什么衣服。Susan每天早上听天气报告,但温度以摄氏度给出,她习惯了华氏度。

    幸运的是,Susan有办法解决这个问题。作为计算机科学专业的学生,她去任何地方总是带着她的笔记本计算机。她认为计算机程序可能会帮助她。

    Susan开始分析她的问题。在这个例子中,问题很清楚:无线电广播员用摄氏度报气温,但Susan只能理解华氏温度。

    接下来,Susan考虑可能帮助她的程序的规格说明。输入应该是什么?她决定程序将允许她输入摄氏温度。输出呢?程序将显示转换后的华氏温度。现在她需要指定输出与输入的确切关系。

    苏珊快速估算了一下。她知道0摄氏度(冰点)等于32华氏度,100摄氏度(沸点)等于212华氏度。有了这个信息,她计算出华氏度与摄氏度的比率为(212−32)/(100−0) = (180/100) = 9/5。使用F表示华氏温度,C表示摄氏温度,转换公式的形式为F= (9/5)C+k,其中k为某个常数。代入0和32分别作为C和F,Susan立即得到k= 32。所以最后的关系公式是F= (9/5)C+ 32。这作为规格说明似乎足够了。

    请注意,这描述了能够解决这个问题的许多可能程序中的一个。如果Susan有人工智能(AI)领域的背景,她可能会考虑写一个程序,用语音识别算法实际收听收音机播音员,获得当前的温度。对于输出,她可以让计算机控制机器人进入她的衣柜,并根据转换后的温度选择适当的服装。这将是一个更有野心的项目,一点也不夸张!

    当然,机器人程序也会解决问题分析中识别的问题。规格说明的目的,是准确地决定这个特定的程序要做什么,从而解决一个问题。Susan知道,最好是先弄清楚她希望构建什么,而不是一头钻进去开始编程。

    Susan现在准备为她的问题设计一个算法。她马上意识到这是一个简单算法,遵循标准模式“输入、处理、输出”(IPO)。她的程序将提示用户输入一些信息(摄氏温度),处理它,产生华氏温度,然后在计算机屏幕上显示结果,作为输出。

    Susan可以用一种计算机语言来写她的算法。然而,正式将它写出来需要相当的精度,这常常会扼杀开发算法的创造性过程。作为替代,她用“伪代码”编写算法。伪代码只是精确的英语,描述了程序做的事。这意味着既可以交流算法,又不必让大脑承担额外的开销,正确写出某种特定编程语言的细节。

    下面是Susan的完整算法:

    输入摄氏度温度(称为celsius)

    计算华氏度为(9/5)celsius + 32

    输出华氏度

    下一步是将此设计转换为Python程序。这很直接,因为算法的每一行都变成了相应的Python代码行。

    # convert.py

    # A program to convert Celsius temps to Fahrenheit

    # by: Susan Computewell

    defmain():

    celsius = eval(input("What is the Celsius temperature? "))

    fahrenheit =9/5* celsius +32

    print("The temperature is", fahrenheit,"degrees Fahrenheit.")

    main()

    看看你是否能弄清楚这个程序的每一行做了什么。如果一些部分不是很清楚,也不要担心,下一节将详细讨论。

    完成程序后,Susan测试它,看看它工作得如何。她使用她知道正确答案的输入。下面是两个测试的输出:

    Whatisthe Celsius temperature?

    The temperatureis32.0degrees Fahrenheit.

    Whatisthe Celsius temperature?100

    The temperatureis212.0degrees Fahrenheit.

    你可以看到,Susan用值0和100来测试她的程序。看起来不错,她对解决方案感到满意。她特别高兴的是,似乎没有必要调试(这很不寻常)。

    程序要素

    既然已经知道了编程过程,你就“几乎”准备好开始自己编写程序了。在此之前,你需要更完整的基础,了解Python的基本知识。接下来的几节将讨论一些技术细节,这对编写正确程序至关重要。这种材料看起来有点乏味,但你必须掌握这些基础,然后再进入更有趣的领域。

    1 名称

    你已经看到,名称是编程的重要组成部分。我们为模块命名(例如convert),也为模块中的函数命名(例如main)。变量用于为值命名(例如celsius和fahrenheit)。从技术上讲,所有这些名称都称为“标识符”。Python对标识符的构成有一些规则。每个标识符必须以字母或下划线(“_”字符)开头,后跟字母、数字或下划线的任意序列。这意味着单个标识符不能包含任何空格。

    根据上述规则,以下都是Python中的合法名称:

    x

    celsius

    spam

    spam2

    SpamAndEggs

    Spam_and_Eggs

    标识符区分大小写,因此对Python来说,spam、Spam、sPam和SPAM是不同的名称。在大多数情况下,程序员可以自由选择符合这些规则的任何名称。好的程序员总是试图选择一些名字,它们能描述被命名的东西。

    需要注意一件重要的事情:一些标识符是Python本身的一部分。这些名称称为“保留字”或“关键字”,不能用作普通标识符。Python关键字的完整列表如表1所列。

    表1  Python关键字

    False

    class

    finally

    is

    return

    Python还包括相当多的内置函数,例如我们用过的print函数。虽然在技术上可以将内置的函数名称标识符用于其他目的,但这通常是一个“非常糟糕”的主意。例如,如果你重新定义print的含义,那么就无法再打印信息。你也会让所有阅读程序的Python程序员感到非常困惑,他们预期print指的是内置函数。内置函数的完整列表可在附录A中找到。

    2 表达式

    程序操作数据。到目前为止,我们已经在示例程序中看到了数字和文本两种不同类型的数据。我们将在后面的节中详细讨论这些不同的数据类型。现在,你只需要记住,所有的数据必须以一些数字格式存储在计算机上,不同类型的数据以不同的方式存储。

    产生或计算新数据值的程序代码片段称为“表达式”。最简单的表达式是字面量。字面量用于表示特定值。在chaos.py中,你可以找到数字3.9和1。convert.py程序包含9、5和32。这些都是数字字面量的例子,它们的含义显而易见:32就是代表32(数字32)。

    我们的程序还以一些简单的方式处理文本数据。计算机科学家将文本数据称为“字符串”。你可以将字符串视为可打印字符的序列。Python中通过将字符括在引号("")中来表示字符串字面量。如果你回头看看我们的示例程序,可以发现一些字符串字面量,例如"Hello"和"Enter a number between 0 and 1:"。这些字面量产生的字符串包含引号内的字符。请注意,引号本身不是字符串的一部分。它们只是告诉Python创建一个字符串的机制。

    将表达式转换为基础数据类型的过程称为“求值”。在Python shell中键入表达式时,shell会计算表达式并打印出结果的文本表示。请考虑以下简短的交互:

    >>>32

    32

    >>>"Hello"

    'Hello'

    >>>"32"

    '32'

    请注意,当shell显示字符串的值时,它将字符序列放在单引号中。这样让我们知道该值实际上是文本而不是数字(或其他数据类型)。在最后一次交互中,我们看到表达式"32"产生一个字符串,而不是一个数字。在这种情况下,Python实际上是存储字符“3”和“2”,而不是数字32的表示。如果你现在不太明白,不要太担心。我们在后面的节中讨论这些数据类型时,你的理解就会变得更加清晰。

    一个简单的标识符也可以是一个表达式。我们使用标识符作为变量来给名字赋值。当标识符作为表达式出现时,它的值会被取出,作为表达式的结果。下面是与Python解释器的交互,展示了变量作为表达式:

    >>> x =5

    >>> x

    5

    >>> print(x)

    5

    >>> print(spam)

    Traceback (most recent call last):

    File"", line1,in

    NameError:name'spam'isnotdefined

    首先,变量x被赋值为5(使用数字字面量5)。在第二行交互中,我们要求Python对表达式x求值。作为响应,Python shell打印出5,这是刚才赋给x的值。当然,如果我们明确要求Python用print语句打印x,也会得到相同的结果。最后一个交互展示了如果尝试使用未赋值的变量,会发生什么。Python找不到值,所以它报告NameError。这说明没有该名称的值。这里的要点是,变量总是必须赋一个值,然后才能在表达式中使用。

    较复杂、较有趣的表达式可以通过组合较简单的表达式和操作符来构造。对于数字,Python提供了一组标准的数学运算:加法、减法、乘法、除法和乘方。相应的Python运算符为“+”“-”“*”“/”和“**”。下面是一些来自chaos.py和convert.py的复杂表达式的例子:

    3.9* x *(1 - x)

    9/5 * celsius + 32

    空格在表达式中没有作用。最后一个表达式如果写成9/5*celsius+32,结果完全相同。通常,在表达式中加一些空格让它更容易阅读,是个好方法。

    Python的数学运算符遵循的优先级和结合律,与你在数学课上学到的相同,包括使用括号来改变求值的顺序。在自己的程序中构建复杂表达式应该没什么困难。请记住,只有圆括号在数字表达式中是允许的。如果需要,可以嵌套使用它们,创建如下的表达式:

    ((x1 - x2) / 2*n) + (spam / k**3)

    顺便说一句,Python还提供了字符串的运算符。例如,可以“加”字符串。

    >>>"Bat"+"man"

    'Batman'

    这被称为“连接”。如你所见,效果是创建一个新的字符串,把两个字符串“粘”在一起。

    3 输出语句

    既然有了基本的构建块(标识符和表达式),你就可以更完整地描述各种Python语句。 你已经知道信息可以使用Python的内置函数print在屏幕上显示。到目前为止,我们已经看了几个例子,但我还没有详细解释打印功能。像所有的编程语言一样,Python对每个语句的语法(形式)和语义(意义)有一套精确的规则。计算机科学家已经开发了复杂的符号表示法,称为“元语言”,用于描述编程语言。在本书中,我们将依靠一个简单的模板符号表示法来说明各种语句的语法。

    因为print是一个内置函数,所以print语句与任何其他函数调用具有相同的一般形式。我们键入函数名print,后面带上括号中列出的参数。下面是用我们的模板符号时print语句看起来的样子:

    print(,, ...,)

    print()

    这两个模板展示了两种形式的print语句。第一个表示print语句可以包含函数名print,后面带上带括号的表达式序列,用逗号分隔。模板中的尖括号符号()用于表示由Python代码的其他片段填充的“槽”。括号内的名称表示缺少什么,expr表示一个表达式。省略号(“...”)表示不确定的序列(在这个例子中是表达式)。你实际上不会输入圆点。第二个版本的print语句表明,不打印任何表达式的print也是合法的。

    就语义而言,print语句以文本形式显示信息。所有提供的表达式都从左到右求值,结果值以从左到右的方式显示在输出行上。默认情况下,在显示的值之间放置一个空格字符。作为示例,下面print语句的序列:

    print(3+4)

    print(3, 4, 3 + 4)

    print()

    print("The answer is", 3 + 4)

    产生的输出为:

    7

    347

    The answeris7

    最后一个语句说明了,字符串字面量表达式如何经常在print语句使用,作为标记输出的方便方法。

    注意,连续的print语句通常显示在屏幕的不同行上。空print(无参数)生成空行输出。在背后,真正发生的是,在打印所有提供的表达式之后,print函数自动附加某种结束文本。默认情况下,结束文本是表示行结束的特殊标记字符(表示为“ ”)。我们可以通过包含一个附加参数显式地覆盖这个默认值,从而改变这种行为。这里使用命名参数的特殊语法,或称为“关键字”参数。

    包含指定结束文本的关键字参数的print语句的模板如下:

    print(,, ...,, end=" ")

    命名参数的关键字是end,它使用“=”符号赋值,类似于变量赋值。注意,在模板中我已经显示其默认值,即行末字符。这是一种标准方式,用于显示在未明确指定某个其他值时,关键字参数具有的值。

    print语句中的end参数有一个常见用法,即允许多个print构建单行输出。例如:

    print("The answer is", end=" ")

    print(3 + 4)

    产生单行输出:

    The answeris7

    注意,第一个print语句的输出如何以空格(" ")而不是行末字符结束,第二个语句的输出紧跟在空格之后。

    4 赋值语句

    Python中最重要的语句之一是赋值语句。我们在前面的例子中已经看到了一些。

    简单赋值

    基本赋值语句具有以下形式:

    =

    这里variable是一个标识符,expr是一个表达式。赋值的语义是,右侧的表达式被求值,然后产生的值与左侧命名的变量相关联。

    下面是我们已经看到的一些赋值:

    x=3.9* x * (1- x)

    fahrenheit=9/5* celsius +32

    x=5

    变量可以多次赋值。它总是保留最新赋的值。下面的交互式Python会话展示了这一点:

    >>> myVar =

    >>> myVar

    >>> myVar =7

    >>> myVar

    7

    >>> myVar = myVar +1

    >>> myVar

    8

    最后一个赋值语句展示了如何使用变量的当前值来更新它的值。在这个例子中,我只是对以前的值加1。记住,变量的值可以改变,这就是为什么它们被称为变量的原因。

    有时,将变量看作计算机内存中的一种命名的存储位置是有帮助的,我们可以在其中放入一个值。当变量更改时,旧值将被删除,并写入一个新值。图1展示了用这个模型来描绘x=x+ 1的效果。这正是赋值在某些计算机语言中工作的方式。这也是查看赋值效果的一种非常简单的方式,你会在整本书中看到类似这样的图片。

    图1x=x+ 1的视图,变量就像盒子

    Python赋值语句实际上与“变量盒子”模型略有不同。在Python中,值可能最终放在内存中的任何位置,而变量用于引用它们。对变量赋值就像把一个黄色小粘贴便签放在值上,并说“这是x”。图2给出了一个更准确的Python赋值的效果。箭头用于显示变量引用的值。请注意,旧值不会被新值擦除,变量只需切换到引用新值。效果就像将粘贴便签从一个对象移动到另一个对象一样。这是赋值在Python中实际工作的方式,所以你会看到这样一些粘贴便签样式的图片散布在本书中。

    图2

    x=x+ 1的(Python)视图,变量就像便签

    顺便说一句,即使赋值语句不直接导致变量的旧值被擦除和覆盖,你也不必担心计算机内存中充满“被丢弃”的值。如果一个值不再被任何变量引用,它就不再有用。Python将自动从内存中清除这些值,以便空间可以用于存放新值。这就像检查你的衣柜,抛出没有粘贴便签标记的东西。实际上,这个自动内存管理的过程确实被称为“垃圾收集”。

    赋值输入

    输入语句的目的是从程序的用户那里获取一些信息,并存储到变量中。一些编程语言有一个特殊的语句来做到这一点。在Python中,输入是用一个赋值语句结合一个内置函数input实现的。输入语句的确切形式,取决于你希望从用户那里获取的数据类型。对于文本输入,语句如下所示:

    = input(

    )

    这里的

    是一个字符串表达式,用于提示用户输入。提示几乎总是一个字符串字面量(即引号内的一些文本)。

    当Python遇到对input的调用时,它在屏幕上打印提示。然后,Python暂停并等待用户键入一些文本,键入完成后按键。用户输入的任何东西都会存储为字符串。请考虑以下简单的交互:

    >>> name = input("Enter your name: ")

    Enter yourname:John Yaya

    >>> name

    'John Yaya'

    执行input语句导致Python打印输出提示“Enter your name:”,然后解释器暂停,等待用户输入。在这个例子中,我键入John Yaya。结果,字符串“John Yaya”被记在变量name中。对name求值将返回我键入的字符串。

    如果用户输入是一个数字,我们需要形式稍复杂一点的input语句:

    =eval(input(

    ))

    这里我添加了另一个内置的Python函数eval,它“包裹”了input函数。你可能会猜到,eval是“evaluate(求值)”的缩写。在这种形式中,用户键入的文本被求值为一个表达式,以产生存储到变量中的值。举例来说,字符串“32”就变成数字32。如果回头看看示例程序,到目前为止,你会看到几个例子,我们像这样从用户那里得到了数字。

    x= eval(input("Please enter a number between 0 and 1: "))

    celsius= eval(input("What is the Celsius temperature? "))

    重要的是要记住,如果希望得到一个数字,而不是一些原始文本(字符串),需要对input进行eval。

    如果你仔细阅读示例程序,可能会注意到所有这些提示结尾处的引号内的空格。我通常在提示的末尾放置一个空格,以便用户输入的内容不会紧接着提示开始。放上空格可以让交互更容易阅读和理解。

    虽然我们的数字示例特别提示用户输入数字,但在这个例子中,用户键入的只是一个数字字面量,即一个简单的Python表达式。事实上,任何有效的表达式都是可接受的。请考虑下面与Python解释器的交互:

    >>> ans = eval(input("Enter an expression: "))

    Enter anexpression:3+4*5

    >>> print(ans)

    23

    >>>

    这里,提示输入表达式时,用户键入“3 + 4 * 5”。Python对此表达式求值(通过eval),并将值赋给变量ans。打印时,我们看到ans的值为23,与预期一样。在某种意义上,input-eval组合就像一个延迟的表达式。示例交互产生完全相同的结果,就像我们简单地写成ans = 3 + 4 * 5一样。不同的是,表达式由用户在语句执行时提供,而不是由程序员在编程时输入。

    注意:eval函数功能非常强大,也有“潜在的危险”。如本例所示,当我们对用户输入求值时,本质上是允许用户输入一部分程序。Python将尽职尽责地对他们输入的任何内容求值。了解Python的人可以利用这种能力输入恶意指令。例如,用户可以键入记录计算机上的私人信息或删除文件的表达式。在计算机安全中,这被称为“代码注入”攻击,因为攻击者将恶意代码注入正在运行的程序中。

    作为一名新程序员,编程给自己个人使用,计算机安全不是很大的问题。如果你坐在一台运行Python程序的计算机前面,你可能拥有对系统的完全访问权限,并且可以找到更简单的方法来删除所有文件。然而,如果一个程序的输入来自不受信任的来源,例如来自互联网上的用户,使用eval可能是灾难性的。

    同时赋值

    有一个赋值语句的替代形式,允许我们同时计算几个值。它看起来像这样:

    ,, ...,=,, ...,

    这称为“同时赋值”。语义上,这告诉Python对右侧所有表达式求值,然后将这些值赋给左侧命名的相应变量。下面是一个例子:

    sum, diff = x+y, x-y

    这里,sum得到x和y的和,diff得到x和y的差。

    这种形式的赋值初看很奇怪,但实际上非常有用。这里有一个例子:假设有两个变量x和y,你希望交换它们的值。也就是说,你希望将当前存储在x中的值存储在y中,将当前存储在y中的值存储在x中。首先,你可能认为这可以通过两个简单的赋值来完成:

    x= y

    y= x

    这不行。我们可以一步一步地跟踪这些语句的执行,看看为什么。

    假设x和y开始的值是2和4。让我们检查程序的逻辑,看看变量是如何变化的。以下序列用注释描述了在执行这两个语句时变量会发生什么:

    # 变量 x y

    # 初始值 2 4

    x= y

    # 现在是 4 4

    y= x

    # 最后是 4 4

    看到第一个语句将y的值赋给x,从而修改了x的原始值吗?当我们在第二步将x的值赋给y时,最终得到了原始y值的两个副本。

    完成交换的一种方法是引入一个附加变量,它暂时记住x的原始值。

    temp= x

    x= y

    y= temp

    让我们来看看这个序列是如何工作的。

    # 变量 x y temp

    # 初始值 2 4 暂时无值

    temp= x

    # 2 4 2

    x= y

    # 4 4 2

    y= temp

    # 4 2 2

    从x和y的最终值可以看出,在这个例子中,交换成功。

    这种三变量交换的方式在其他编程语言中很常见。在Python中,同时赋值语句提供了一种优雅的选择。下面是更简单的Python等价写法:

    x, y = y, x

    因为赋值是同时的,所以它避免了擦除一个原始值。

    同时赋值也可以用单个input从用户那里获取多个数字。请考虑下面的程序,它求出考试平均分:

    # avg2.py

    # A simple program to average two exam scores

    # Illustrates use of multiple input

    defmain():

    print("This program computes the average of two exam scores.")

    score1, score2 = eval(input("Enter two scores separated by a comma: "))

    average = (score1 + score2) /2

    print("The average of the scores is:", average)

    main()

    该程序提示用逗号分隔两个分数。假设用户键入86,92。input语句的效果就像进行以下赋值:

    score1, score2 = 86, 92

    我们已经为每个变量获得了一个值。这个例子只用了两个值,但可以扩展到任意数量的输入。

    当然,我们也可以通过单独的input语句获得用户的输入:

    score1= eval(input("Enter the first score: "))

    score2= eval(input("Enter the second score: "))

    某种程度上,这可能更好,因为单独的提示对用户来说信息更准确。在这个例子中,决定采用哪种方法在很大程度上是品位问题。有时在单个input中获取多个值提供了更直观的用户接口,因此在你的工具包中,这是一项好技术。但要记住,多个值的技巧不适用于字符串(非求值)输入,如果用户键入逗号,它只是输入字符串中的一个字符。逗号仅在随后对字符串求值时,才成为分隔符。

    确定循环

    你已经知道,程序员用循环连续多次执行一系列语句。最简单的循环称为“确定循环”。这是会执行一定次数的循环。也就是说,在程序中循环开始时,Python就知道循环(或“迭代”)的次数。例如,前面介绍的chaos程序用了一个总是执行10次的循环:

    foriinrange(10):

    x = 3.9 * x * (1 - x)

    print(x)

    这个特定的循环模式称为“计数循环”,它用Python的for语句构建。在详细分析这个例子之前,让我们来看看什么是for循环。

    Python的for循环具有以下一般形式:

    forin:

    循环体可以是任意Python语句序列。循环体的范围通过它在循环头(for in :部分)下面的缩进来表示。

    关键字for后面的变量称为“循环索引”。它依次取sequence中的每个值,并针对每个值都执行一次循环体中的语句。通常,sequence部分由值“列表”构成。列表是Python中一个非常重要的概念,你将在后续节中了解更多。现在只要知道,可以在方括号中放置一系列表达式,从而创建一个简单的列表。下列交互示例有助于说明这一点:

    你能看到这两个例子做了什么吗?依次使用列表中的每个值执行了循环体。列表的长度决定了循环执行的次数。在第一个例子中,列表包含4个值,即0至3,并且简单地打印了这些连续的i值。在第二个例子中,odd取前5个奇数的值,循环体打印了这些数字的平方。

    现在,让我们回到这一节开始的例子(来自chaos.py)再看一下循环头:

    foriinrange(10):

    将它与for循环的模板进行比较可以看出,最后一个部分range(10)必定是某种序列。事实上,range是一个内置的Python函数,用于“当场”生成一个数字序列。你可以认为range是一种数字序列的隐性描述。要明白range实际上做了什么,我们可以要求Python用另一个内置函数list,将range转换为一个简单的旧式列表:

    >>> list(range(10))# turns range(10) into an explicit list

    [,1,2,3,4,5,6,7,8,9]

    你看到这里发生了什么吗?表达式range(10)产生数字0到9的序列。使用range(10)的循环等价于使用那些数字的列表的循环。

    foriin[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]:

    一般来说,range()将产生一个数字序列,从0开始,但不包括的值。如果你想一想,就会发现表达式的值确定了结果序列中的项数。在chaos.py中,我们甚至不关心循环索引变量使用了什么值(因为i没有在循环体中的任何位置引用)。我们只需要一个长度为10的序列,让循环体执行10次。

    正如前面提到的,这种模式称为“计数循环”,它是使用确定循环的一种很常见的方式。如果你希望在程序中做一定次数的某些事,请用一个带有合适range的for循环。下面一个反复出现的Python编程习语,你需要记住:

    forinrange():

    表达式的值确定了循环执行的次数。索引变量的名称实际上并不重要,程序员经常使用i或j作为计数循环的循环索引变量。只要确保使用的标识符没有用于任何其他目的,否则你可能会不小心清除稍后需要的值。

    循环的有趣和有用之处在于,它们改变程序“控制流”的方式。通常我们认为计算机是严格按顺序执行一系列指令。引入循环会导致Python退回去并重复执行一些语句。类似for循环的语句称为“控制结构”,因为它们控制程序其他部分的执行。

    一些程序员发现,用图片的方式来思考控制结构是有帮助的,即所谓的“流程图”。流程图用一些框来表示程序的不同部分,并用框之间的箭头表示程序运行时的事件序列。图3用流程图描述了for循环的语义。

    图3 for循环的流程图

    如果你在理解for循环时遇到困难,可能会发现学习流程图很有用。流程图中的菱形框表示程序中的决定。当Python遇到循环头时,它检查序列中是否有项。如果答案为“是”,则循环索引变量被赋予序列中的下一项,然后执行循环体。一旦循环体完成,程序返回到循环头并检查序列中的下一个值。如果没有更多的项,循环就退出,程序移动到循环之后的语句。

    示例程序:终值

    我们用另一个编程过程的例子来结束本文。我们希望开发一个程序来确定投资的终值。我们将从对问题的分析开始。你知道存入银行账户的钱会赚取利息,这个利息随着时间的推移而累积。从现在起10年后,一个账户将有多少钱?显然,这取决于我们开始有多少钱(本金)以及账户赚多少利息。给定本金和利率,程序应该能够计算未来10年投资的终值。

    我们继续制定程序的确切规格说明。记住,这是程序做什么的描述。输入应该是什么?我们需要用户输入初始投资金额,即本金。我们还需要说明账户赚多少利息。这取决于利率和计复利的频率。处理此问题的一种简单方法是让用户输入年度百分比率。无论实际利率和复利频率如何,年利率告诉我们一年内的投资收益。如果年利率为3%,那么100美元的投资将在一年的时间内增长到103美元。用户应如何表示年利率3%?有一些合理的选择。让我们假设用户提供一个小数,因此利率将输入为0.03。

    这样就得到以下规格说明:

    程序 终值

    输入

    principal 投资于美元的金额。

    APR 以十进制数表示的年度百分比利率。

    输出 投资10年后的终值。

    关系 一年后的价值由principal(1 + apr)给出。该公式需要应用10次。

    接下来为程序设计一个算法。我们将使用伪代码,这样就可以阐明我们的想法而又不必担心Python的所有规则。对于我们的规格说明,算法看起来很简单。

    打印介绍

    输入本金的金额(principal)

    输入年度百分比利率(apr)

    重复10次:

    principal = principal *(1 + apr)

    输出principal的值

    如果你知道一些金融数学(或者只是一些基本代数)的知识,可能会意识到,在这个设计中并不一定要用循环。有一个公式可以利用乘幂一步算出终值。我在这里用了一个循环来展示另一个计数循环,另一个原因是这个版本适合进行一些修改,在本文末尾的编程练习中将讨论。无论如何,这个设计说明有时算法的计算方式可以让数学更容易。知道如何计算一年的利息,就让我们能计算未来任意年数的利息。

    既然我们已经在伪代码中想明白了这个问题,现在该利用我们的Python新知识开发一个程序了。算法的每一行都转换为一条Python语句:

    打印介绍(print语句,第2.4节)

    print("This program calculates the future value")

    print("of a 10-year investment.")

    输入本金的金额(数值input,第2.5.2节)

    principal =eval(input("Enter the initial principal: "))

    输入年度百分比利率(数值input,第2.5.2节)

    apr =eval(input("Enter the annual interest rate: "))

    重复10次:(计数循环,第2.6节)

    foriinrange(10):

    计算principal = principal * (1 + apr)(简单赋值,第2.5.1节)

    principal = principal * (1 + apr)

    输出principal的值(print语句,第2.4节)

    print("The value in 10 years is:", principal)

    该程序中的所有语句类型都已在本文中详细讨论过。如果有任何问题,请回头查看相关说明。特别要注意的是,计数循环模式用于应用10次利息公式。

    就到这里了。下面是完成的程序:

    # futval.py

    # A program to compute the value of an investment

    # carried 10 years into the future

    defmain():

    print("This program calculates the future value")

    print("of a 10-year investment.")

    principal = eval(input("Enter the initial principal: "))

    apr = eval(input("Enter the annual interest rate: "))

    foriinrange(10):

    principal = principal * (1+ apr)

    print("The value in 10 years is:", principal)

    main()

    注意,我添加了几个空行来分隔程序的输入、处理和输出部分。策略性地放置“空行”能让程序更具有可读性。

    这就是我所举的例子,测试和调试是留给你的练习。

    小结

    本文介绍了开发程序的过程,以及实现简单程序所需的许多Python细节。下面是一些要点的快速小结。

    编写程序需要一种系统的方法来解决问题,包括以下步骤。

    1.问题分析:研究需要解决的问题。

    2.程序规格说明:确定程序要做什么。

    3.设计:用伪代码编写算法。

    4.实现:将设计翻译成编程语言。

    5.测试/调试:查找和修复程序中的错误。

    6.维护:让程序保持最新,满足不断变化的需求。

    许多简单的程序遵循输入、处理、输出(IPO)的模式。

    程序由标识符和表达式构成的语句组成。

    标识符是一些名称,它们以下划线或字母开头,后跟字母、数字或下划线字符的组合。Python中的标识符区分大小写。

    表达式是产生数据的程序片段。表达式可以由以下部件组成:

    字面量字面量是特定值的表示。例如,3是数字3的字面量表示。

    变量变量是存储值的标识符。

    运算符运算符用于将表达式组合为更复杂的表达式。例如,在x+ 3 *y中,使用了运算符+和*。

    数字的Python运算符包括加法(+)、减法(-)、乘法(*)、除法(/)和乘幂(**)等常见的算术运算。

    Python输出语句print将一系列表达式的值显示在屏幕上。

    在Python中,使用等号(=)表示将值赋给变量。利用赋值,程序可以从键盘获得输入。Python还允许同时赋值,这对于利用单个提示获取多个输入值很有作用。

    eval函数可用来对用户输入求值,但它是一种安全风险,不应该用于未知或不可信来源的输入。

    确定循环是执行次数已知的循环。Python的for语句是一个循环遍历一系列值的确定循环。Python列表通常在for循环中用于为循环提供一系列值。

    for语句的一个重要用途是实现计数循环,这是专门设计的循环,以便将程序的某些部分重复特定的次数。Python中的计数循环通过使用内置的range函数,来产生适当大小的数字序列。

    判断对错

    1.编写程序的最好方法是立即键入一些代码,然后调试它,直到它工作。

    2.可以在不使用编程语言的情况下编写算法。

    3.程序在写入和调试后不再需要修改。

    4.Python标识符必须以字母或下划线开头。

    5.关键词是好的变量名。

    6.表达式由文字、变量和运算符构成。

    7.在Python中,x=x+ 1是一个合法的语句。

    8.Python不允许使用单个语句输入多个值。

    9.计数循环被设计为迭代特定次数。

    10.在流程图中,菱形用于展示语句序列,矩形用于判断点。

    多项选择

    1.以下项不是软件开发过程中的一个步骤。

    a.规格说明     b.测试/调试    c.决定费用     d.维护

    2.将摄氏度转换为华氏度的正确公式是。

    a.F= 9/5(C) + 32         b.F= 5/9(C) − 32

    c.F=B2− 4ACd.F= (212 – 32)/(100 – 0)

    3.准确描述计算机程序将做什么来解决问题的过程称为。

    a.设计       b.实现     c.编程       d.规格说明

    4.以下项不是合法的标识符。

    a.     b.     c.     d.

    5.下列不在表达式中使用。

    a.变量      b.语句      c.操作符    d.字面量

    6.生成或计算新数据值的代码片段被称为。

    a.标识符     b.表达式    c.生成子句     d.赋值语句

    7.以下项不是IPO模式的一部分。

    a.输入       b.程序      c.处理       d.输出

    8.模板描述了。

    a.一般循环         b.赋值语句

    c.流程图             d.计数循环

    9.以下项是最准确的Python赋值模型。

    a.粘贴便签     b.变量盒子    c.同时       d.塑料尺

    10.在Python中,获取用户输入通过一个特殊的表达式来实现,称为。

    a.       b.     c.同时赋值     d.

    讨论

    1.列出并用你自己的语言描述软件开发过程中的六个步骤。

    2.写出chaos.py程序(第1.6节),并识别程序的各部分如下:

    圈出每个标识符。

    为每个表达式加下划线。

    在每一行的末尾添加注释,指示该行上的语句类型(输出、赋值、输入、循环等)。

    3.解释确定循环、for循环和计数循环几个概念之间的关系。

    4.显示以下片段的输出:

    a.

    b.

    c.

    d.

    5.先写出一个算法的伪代码而不是立即投入Python代码,为什么是一个好主意?

    6.除end之外,Python的函数还支持其他关键字参数。其中一个关键字参数是。你认为参数是什么?(提示:是分隔符的缩写。通过交互式执行或通过查阅Python文档来检验你的想法)。

    7.如果执行下面的代码,你认为会发生什么?

    print("start")

    foriinrange(0):

    print("Hello")

    print("end")

    看看本文的for语句的流程图,帮助你弄明白。然后在程序中尝试这些代码,检验你的预测。

    编程练习

    1.一个用户友好的程序应该打印一个介绍,告诉用户程序做什么。修改convert.py程序(第2.2节),打印介绍。

    2.在许多使用Python的系统上,可以通过简单地点击(或双击)程序文件的图标来运行程序。如果你能够以这种方式运行convert.py程序,你可能会发现另一个可用性问题。 程序在新窗口中开始运行,但程序一完成,窗口就会消失,因此你无法读取结果。在程序结束时添加一个输入语句,让它暂停,给用户一个读取结果的机会。下面这样的代码应该有效:

    input("Press the key to quit.")

    3.修改程序(第2.5.3节),找出三个考试成绩的平均值。

    4.使用循环修改程序(第2.2节),让它在退出前执行5次。每次通过循环,程序应该从用户获得另一个温度,并打印转换的值。

    5.修改程序(第2.2节),让它计算并打印一个摄氏温度和华氏度的对应表,从0℃到100℃,每隔10℃一个值。

    6.修改程序(第2.7节),让投资的年数也由用户输入。确保更改最后的消息,以反映正确的年数。

    7.假设你有一个投资计划,每年投资一定的固定金额。修改,计算你的投资的总累积值。该程序的输入将是每年投资的金额、利率和投资的年数。

    8.作为APR的替代方案,账户所产生的利息通常通过名义利率和复利期数来描述。例如,如果利率为3%,利息按季度计算复利,则该账户实际上每3个月赚取0.75%的利息。请修改程序,用此方法输入利率。程序应提示用户每年的利率(rate)和利息每年复利的次数(periods)。要计算10年的价值,程序将循环10 * periods次,并在每次迭代中累积rate/period的利息。

    9.编写一个程序,将温度从华氏温度转换为摄氏温度。

    10.编写一个程序,将以千米为单位的距离转换为英里。1千米约为0.62英里。

    11.编写一个程序以执行你自己选择的单位转换。确保程序打印介绍,解释它的作用。

    12.编写一个交互式Python计算器程序。程序应该允许用户键入数学表达式,然后打印表达式的值。加入循环,以便用户可以执行许多计算(例如,最多100个)。注意:要提前退出,用户可以通过键入一个错误的表达式,或简单地关闭计算器程序运行的窗口,让程序崩溃。在后续图书节中,你将学习终止交互式程序的更好方法。

    展开全文
  • Python编写EXP

    千次阅读 2020-08-10 21:04:27
    高考过后,你不用告诉我你考多少分,...1、python3 2、用到的模块requests 二、requests模块应用 1、获取网页的内容 # coding=utf-8 import requests res=requests.get("http://192.168.1.129/html/1.html")..
  • 再也不怕忘记MySQL的用户名和密码了,用这个工具可以秒破MySQL,冰河强烈建议收藏!!
  • Tools吐司论坛签到小工具,基于python简单方式编写
  • Python编写,取决于OpenCV。 最新版本: | | | | 快速安装:需要Python模块numpy ,OpenCV cv2和tqdm (可选)才能显示进度。 要通过具有所有依赖项的pip安装DVR-Scan,请执行以下操作: pip install dvr-...
  • Bandit 是一款 Python 源码分析框架,可用于 Python 代码的安全性分析。Bandit 使用标准库中的 AST 模块,将 Python 源码解析成 Python 语法节点构成的树。Bandit 允许用户编写自定义的测试。测试完成后,Bandit 会...
  • COS-upload基于腾讯COS云对象存储SDK,使用Python编写的文件上传工具,发布与github上,有需要的在下方访问。概念COS云对象存储,听起来是一个很玄的概念,官方的概念是对象存储服务(Cloud Object Service)是面向...
  • python 编写 cgi 脚本

    2017-11-25 13:19:52
    使用python编写cgi程序时,需要使用该模块;它还提供了一些调试脚本,以及处理文件上传请求的工具。 1 介绍cgi脚本由http server(Apache httpd,nginx)调用,通常处理一些用户提交的信息。CGI脚本的输出应该包括...
  •  Bandit是一款Python源码分析框架,可用于Python代码的安全性分析。Bandit使用标准库中的ast模块,将Python源码解析成Python语法节点构成的树。Bandit允许用户编写自定义的测试。测试完成后,Bandit会生成针对源码...
  • Python安全工具之Web目录扫描器

    千次阅读 2017-11-04 15:14:42
    本次的程序实质是Web目录的暴力破解,即基本过程为取出字典内容、和目标网站进行组合、然后进行请求识别,能否扫描出相应的Web目录主要看字典的强大与否。.../usr/bin/python #coding=utf-8 import random
  • 工具是由应用程序安全专家Barak Tawily用Python编写的。 XSSor旨在通过执行半自动反射和持久XSS检测测试来帮助安全测试人员。 安装 Download Burp Suite (obviously): http://portswigger.net/burp/download.html...
  • Trigger是一个用Python编写的强大的网络自动化工具包,旨在与网络设备接口以及管理网络配置和安全策略。 它提高了管理大型网络的速度和效率,同时降低了人为错误的风险。 Trigger由AOL网络安全团队于2006年成立,...
  • 本篇文章主要先从客户端和服务端分析AWVS扫描的特征,然后再稍微修改一下...Acunetix Web Vulnerability Scanner(简称AWVS)是一款知名的Web网络漏洞扫描工具,它通过网络爬虫测试你的网站安全,检测流行安全漏洞。
  • Python编写薅羊毛脚本经验分享

    千次阅读 多人点赞 2021-02-08 23:07:37
    提醒,本期不仅需要Python基础,还得理解面向对象和懂多线程。请酌情观看。 一、不同需求的难度差别 薅羊毛脚本,就是想用程序来做重复动作。这个重复,有简单有复杂,不同需求下,问题难度差别很大。我们从简单到...
  • NMAP是一款开源的网络探测和安全审核的工具,他能够快速的扫描出某个服务器对外暴露的端口信息。是在安全测试领域很常见的一个工具。今天我们用python的模拟实现一个简单版本...
  • 原标题:30分钟学会用Python编写简单程序参与文末每日话题讨论,赠送异步新书异步图书君 学习目标知道有序的软件开发过程的步骤。了解遵循输入、处理、输出(IPO)模式的程序,并能够以简单的方式修改它们。了解构成...
  • Bandit这款工具可以用来搜索Python代码中常见的安全问题,在检测过程中,Bandit会对每一份Python代码文件进行处理,并构建AST,然后针对每一个AST节点运行相应的检测插件。完成安全扫描之后,Bandit会直接给用户生成...
  • wfuzz 是一款Python开发的Web安全模糊测试工具
  • Creds Harvester是用 Python 3 编写的 Windows 密码恢复工具包,主要为 Technowlogger [高级键盘记录器] 编写 免责声明 :laptop: 该项目仅出于良好目的和个人用途而创建。 本软件“按原样”提供,不提供任何形式...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 66,353
精华内容 26,541
关键字:

python编写安全工具

python 订阅