Python安全基础编写

python所写的程序都是应用程序

python的环境
编译型：一次性将所有程序编译成二进制文件
缺点：开发效率低，不能跨平台
优点：运行速度快
使用语言：C，C++等等

解释型：当程序执行时，一行一行的解释
优点：开发效率高，可以跨平台
缺点：运行速度慢
使用语言：python php JS

kali中默认安装了python2和python3
编写模式：VIM编辑和使用IDLE
python区分大小写
#表示单行注释，三个单引号表示多行注释
=表示赋值，==表示等于，!=表示不等于
#!python或/usr/bin/env 指定文件解释器或解释器路径
#coding:utf-8 指定字符编码有中文的话一定要指定
程序文件一般以.py作为后缀，脚本文件命名时不能太随意，尤其注意不要与python库重名
python脚本对缩进要求非常严格，每行代码的行首不能随意添加空格
程序文件中的前两行一般都采用固定格式：
#!python或/usr/bin/env
#coding:utf-8

基础语法：
变量
python中的变量不需要声明，可以直接通过赋值来创建变量，变量赋值通过=来实现
在为变量赋值时应注意数据类型 x='hallo'
可以同时为多个变量赋值，但变量与数值的个数必须相等 如x,y=3,5
变量名应尽量具有现实意义，而且不要使用系统保留关键字作为变量，比如pass等print

输出语句print
print语句可以同时输出多个元素，元素之间用逗号,隔开。print遇到逗号会输出一个空格。
如果希望在输出的内容之间没有空格，可以把他们作为字符串连接在一起，此时需要注意数据类型必须保持一致。
print语句在输出的内容后面会自动加上一个换行符号 ，如果在要输出的内容后面跟上逗号，换行就取消了。

字符串处理的常用方法：
在python中一切皆对象，每个字符串也是一个对象。
使用dir命令可以查看对象的使用方法。
使用help命令可以查看某个方法的帮助信息
我可以干什么？我可以对字符串做什么处理就叫做方法
（1）split方法
将字符串根据某个分隔符进行分割，分割之后得到一个列表。
如：c="I love python" c.split(以什么来进行分割) c.split(' ')
d="i.love.python" c.split(".") c.split(".")[1]输出love
（2）in
判断某个字符串是否在另外一个字符串内，如果包含，就返回True，否则返回False
site="www.baidu.com"
web="baidu"
web in site 返回true
"www" in site 返回true
（3）strip()方法
去除字符串头尾指定的字符，如果不指定，默认去除空格以及回车、换行等空白字符
注去除头和尾的，中间的不能去除
web="www.baidu.com"
web.strip(.com) 输出www.baidu
（4）upper()、lower()方法
upper()方法可以将字符串转换成大写形式。
lower()方法可以将字符串转换成小写形式
（5）center方法
使指定的字符串居中显示，两侧再加上指定数量的字符。
print "Welcome".center(30,'*')
***********Welcome************

列表元组和字典的作用就是在一个变量里面存放多个数据
列表
在列表中可以集中存放多个数据，并且数据类型不必统一，列表用[]表示。
ports=[21,22,80,3389]
可以通过索引来获取列表中的指定数据，索引从0开始
可以使用冒号表示一段连续的索引，比如[0:2]，这是一个左闭右开区向，它的作用是获取索引号是0和1的两个数据。如果冒号两侧的序号不写，则表示起点和终点的位置。
ports[1] ports[-1] ports[0:3]
在列表中可以根据元素查出对应的索引，这称为切件。
列表中也有自己的处理方式如下：
使用append()函数可以增加数据，只能增加一个数据
使用pop()可以去除数据，通过索引的方式
使用index()可以查找数据的索引号

使用list()函数可以讲一个字符串转为列表。
通过len()函数可以统计列表中元素的个数。
ip="192.168.0.1"
print ip.split(".")[0]+"."+p.split(".")[1]+"."+p.split(".")[2]+"."+p.split(".")[3]

元组：
元组与列表类似，不同之处在于元组中的数据只能被调用，而不能被修改，元组用（）表示
x=(1,2,3)
x 输出(1,2,3)
x[0] 输出1
x[0]="a" 则报错
如果元组中只有一个元素，那么在元素的后面必须加上逗号。
y=(1)
y 输出1
y[0] 则报错
y=(1,)
y 输出(1,)
y[0] 输出1

字典：
字典的优点是具有极快的查找速度，字典使用{}定义。
字典使用键-值（key-value）的形式存储，每一对键值称为一个项。
字典中的键不允许重复，而值是可以重复的
字典数据的存放是随机的
字典中的每个键和它的值都是以冒号分割，同事用逗号分割各个项。
>>> services={'ftp':21,'ssh':22,'http':80,'https':443}
>>> services
{'ftp':21,'ssh':22,'http':80,'https':443}
字典使用key来引用字典中某个键所对应的值。
>>> services['http']
80
可以通过len()函数统计字典中包含多少个项
>>> len(services)
4
用keys()方法返回字典中所有键的列表
>>> services.keys()
['ftp','ssh','http','https']
用has_key()方法验证字典中是否含有指定的键
>>> services.has_key('http')
True
往字典中添加新的项：
>>> services['mysql']=3306
>>> services
{'ftp':21,'ssh':22,'http':80,'https':443,'mysql':3306}
修改字典数据：
>>> services['ftp']=20
>>> services
{'ftp':20,'ssh':22,'http':80,'https':443,'mysql':3306}

迭代
通过for循环可以遍历列表，元组或是字典中的值，这种遍历就称为迭代。
(注意遍历完一定有冒号: 输出遍历的时候一定要在前面加tab缩进)
遍历列表
a=[123,'hallo','python']
for i in a:
print i
123
hallo
python
遍历字典的键
services={'ftp':21,'ssh':22,'http':80,'https':443}
for key in services:
print key
ftp
ssh
http
https
遍历字典的值
for key in services:
print services[key]
21
22
遍历字典的键和值（值的类型不同要进行转换）
for key in services:
print key+":"+str(services[key])
ftp:21
ssh:22
遍历字典的键和值
for key in services:
print key+":",services[key]
ftp: 21
ssh: 22

python利用工具获取banner
nc -nv IP 端口
telnet IP 端口

使用socket模块实现banner批量扫描和服务漏洞确认
import socket import使用模块
socket模块包含了 类 方法 属性
socket.setdefaulttimeout(2)
//设置超时时间，如果两秒内无法建立连接，就超时退出
s=socket.socket()
//定义了一个s对象，表示引用socket模块中的socket方法来创建一个socket
s.connect(("192.168.121.163",22))
//调用socket模块中的connect方法来连接目标主机。
s.recv(1024) //接收返回信息中的钱1024b数据
result=s.recv(1024) //保存结果到指定的变量
s.close() //断开连接
print result //输出接收到的信息
vim banner.py
运行python文件 python getbanner.py

if语句的语法格式
if True:
print "ok"
else:
print "no"

>>>b=[]
>>>if b:
... print "ok"
... else:
... print "no"
...
no
不要漏掉冒号，缩进必须统一。
所有的python合法表达式都可以作为条件表达式，只要表达式的值不是false、0、空值，python解释器都认为与true等价
if语句结束后就没有缩进了

异常处理：
程序运行过程中难免出现错误，当python检测到错误时，解释器就无法继续执行下去，于是抛出相应的信息，这些统称为异常信息
合理的使用异常处理可以使得程序更加健壮，具有更强的容错性，不会因为用户不小心的错误输入或其他运行时原因而造成程序终止，也可以使用异常处理结构为用户提供更加友好的提示。

try/except语句
try子句中的代码块包含可能会引发异常的语句，而except子句用来捕捉相应的异常。
程序执行时，如果try子句中没有异常发生，那么except子句在try语句执行之后被忽略；如果try子句中有异常发生，那么该部分的其他语句将被忽略，直接跳到except部分，执行其后面的子句。
>>> try:
... f=open("password.txt","r")
... except:
... print "file not exist"
...
file not exist
python根据引发异常的原因，将异常分为了很多种不同类别，在except子句中可以分别捕获指定类别的异常。
except Exception,e:
不管什么类别的异常，全部都捕获，并将具体的异常信息保存到变量e里
>>> try:
... f=open("password.txt","r")
... except Exception,e:
... print e
...
[Errno 2] No such file or directory: 'password.txt'
忽略处理：不需要显示具体的异常信息，出现异常之后只需将其忽略不理。
>>> try:
... f=open("password.txt","r")
... except:
... pass
...
>>>
函数：
函数提供了高效的可重用代码块
根据各自特定的作用，将程序分隔成相互独立的函数是一个良好的编程习惯，这样便于代码重用，并使程序更易于阅读。
通过def语句定义函数，函数中的内容必须缩进，return用于把函数的结果返回
如果没有return语句，函数执行后也会返回结果，只是结果为none。
return None可以简写为return
>>> def add(x,y):
... return x+y
...
>>> add(2,3)
5
if __name__=="__main__"就是用于判断当前的程序是在怎样运行。
放在它后面的代码部分在被调用时是不会执行的，当单独执行该脚本文件时，则会执行这部分代码。
每一个后缀为.py的文件都被视作一个python模块，可以被其它的python程序调用
每个python脚本在运行时都有一个__name__属性，通过它可以识别程序的使用方式，即程序是在作为模块被导入，还是独立运行。
如果程序是在作为模块被导入，那么__name__属性的值就被自动设置为模块名；
如果脚本是在独立运行，那么__name__属性的值会被自动设置为字符串"__main__"
#!/usr/bin/env python
#coding:utf-8
def add(x,y):
sumNum=x+y
return sumNum
if __name__=="__main__":
//只有在独立运行的时候才执行下面的代码，调用则不执行下面的代码
result=add(2,3)
print result
或脚本是直接运行的不当做模块可以直接定义main函数
def main()
a=1
b=2
c=a+b
print c
if __name__=="__main__":
main()

基本for循环语句
对列表进行迭代
for i in [1,2,3]:
print i
1
2
3
通过range()函数生成连续数列
for i in range(1,5):
print i
1
2
3
4
range(初始值，终止值，步长)，range得到的是一个左闭右开的区间。
range(1,10)
[1,2,3,4,5,6,7,8,9]
range(1,9,2)
[1,3,5,7]
如果要对地址段192.168.80.1-10内主机的21/22/80端口进行扫描，如何得到“IP：端口号”形式的字符串。
>>> for i in range(1,11):
... ip="192.168.121."+str(i)
... for p in [21,22,80]:
... dest=ip+":"+str(p)
... print dest

文件操作的基本流程
1、调用open()函数打开文件，并创建一个File对象。
2、调用File对象的read()或write()等方法，对文件内容进行读写等操作。
3、调用File对象的close()方法，关闭并保存文件内容。（任何时候不要忘了关闭）
>>> f=open("/root/liu.txt","r")
>>> f.read()
'asdsadasfaf a fa fas fsafasfasfasf
>>> f.close()
通过open()函数以指定模式打开文件并创建文件对象：
文件对象=open(‘文件路径’，‘模式’)
文件打开模式主要包括：
r只读模式（默认）
w只写模式（如果文件已存在，先清空原有内容，文件不存在则创建文件）
a追加模式（不覆盖文件中原有内容）
如果传递给open()的文件名不存在，写模式和添加模式都会创建一个新的空文件

写入文件
write()方法不会在字符串的末尾自动添加换行字符
向文件中写入内容：
>>> f=open("/root/liu.txt","w")
>>> f.write("192.158.121.1 ")
>>> f.write("192.158.121.2 ")
>>> f.write("192.158.121.3 ")
>>> f.close()
向文件中追加内容
>>> f=open("/root/liu.txt","a")
>>> f.write("192.158.121.163 ")
>>> f.close()

读取文件
python文件对象提供了三种“读"方法
read() readline() readlines()
read()方法可以一次性读取文件的所有内容
read()方法也可以指定读取前几个字节的数据
>>> f=open("/root/liu.txt","r")
>>> f.read(12)
'192.158.121.'
>>> f.read(5)
'1 '
readline()方法可以从文件中读取一行并作为结果返回：
>>> f=open("/root/liu.txt","r")
>>> f.readline()
'192.158.121.1 '
>>> f.readline()
'192.168.121.2 '
>>> f.readline()
'192.168.121.163 '
>>> f.close()
readlines()方法返回一个列表，文件的每一行作为列表的一个元素
>>> f=open("/root/liu.txt","r")
>>> f.readlines()
['192.158.121.1 ', '192.168.121.2 ', '192.168.121.163 ', '192.168.121.1 ']
>>> f.readlines()[0]
'192.158.121.1 '
>>> f.close()
seek()方法可以将指针返回到指定位置
f.seek(0) //当文件读到底的时候使用seek方法返回到第一行
通过for循环对列表进行迭代，这是最常用的读取方法
>>> f=open("/root/liu.txt","r")
>>> for i in f.readlines():
... print i
...
192.158.121.1
192.168.121.2
192.168.121.163
192.168.121.1
通过字符串的strip()方法将文件中每行末尾的 去掉
>>> f=open("/root/liu.txt","r")
>>> for i in f.readlines():
... print i.strip(" ") //不指定默认也去除
windows换行是 所以要去除两个