flask-login和flask-wtf

一、表单验证
前言
在Flask项目开发中针对提交表单的校验,可以使用Flask-WTF扩展库进行快速的字段校验,也可以进行页面快速渲染,并提供跨站请求伪造的保护功能。

1. 安装Flask-WTF

pip install flask-wtf

注意:
可以新建一个requirement.txt文档,里面写入将要导入的包

flask
flask-script
flask-blueprint
flask-sqlalchemy
pymysql
redis
flask-session

在Terminal中输入:pip install -r requirement.txt

2. 实现注册功能

2.1 注册表单模型定义
在定义的表单类中定义需要验证的username、password和password2字段,并实现如下校验:

校验密码password2和password相等
校验用户名是否存在
校验用户名的长度是否符合规范

users->forms.py
“`
# 导入扩展类
from flask_wtf import FlaskForm
# 导入验证字段
from wtforms import StringField, SubmitField, ValidationError
# 导入表单验证
from wtforms.validators import DataRequired, EqualTo

 from user.models import User

 class UserForm(FlaskForm):
     """
     登录注册表单验证
     """
     username = StringField('用户名', validators=[DataRequired()])
     password = StringField('密码', validators=[DataRequired()])
     password2 = StringField('确认密码', validators=[DataRequired(),
                                                 EqualTo('password', '密码不一致')]
                             )
     submit = SubmitField('提交')

     def validate_username(self, field):
         # 验证用户名是否重复
         if User.query.filter(User.username == field.data).first():
             raise ValidationError('用户名已存在')

         # 对用户名的长度进行判断
         if len(field.data) < 3:
             raise ValidationError('用户名长度不能少于3个字符')

         if len(field.data) > 6:
             raise ValidationError('用户名长度不能大于6个字符')

```

注意: 验证字段的方法名为: validate_字段(self, field)

2.2 定义注册视图函数
当HTTP请求为GET时,将表单验证对象返回给页面。
当HTTP请求为POST时,通过方法validate_on_submit()方法进行字段校验和提交判断,如果校验失败,则可以从form.errors中获取错误信息。
如果验证通过,则从form.字段.data中获取到字段的值。
users->views

@blue.route('/register/', methods=['GET', 'POST'])
def register():
    form = UserForm()
    if request.method == 'GET':
        return render_template('register.html', form=form)

    if request.method == 'POST':
        # 判断表单中的数据是否通过验证
        if form.validate_on_submit():
            # 获取验证通过后的数据
            username = form.username.data
            password = form.password.data
            # 保存
            user = User()
            user.username = username
            #加密 generate_password_hash(password)
            user.password = generate_password_hash(password)
            user.save()
            return redirect(url_for('user.login'))
        return render_template('register.html', form=form)

2.3 模板展示
注册模板采用继承父模板base.html的形式。在register.html模压中分析如下:

1\. 定义字段名: {{ form.字段.label }}

2\. 定义input输入框: {{ form.字段 }}

3\. 展示错误信息: {{ form.errors.字段 }}

4\. 跨站请求伪造: {{ form.csrf_token }}

注册register.html页面如下:

{% extends 'base.html' %}

{% block title %}
    注册页面
{% endblock %}

{% block content %}
    <form action="" method="post">
        {{ form.csrf_token }}
        {{ form.username.label }}:{{ form.username(style='color:red;', placeholder='请输入用户名', onblur="alert('123')") }}
        {{ form.password.label }}:{{ form.password }}
        {{ form.password2.label }}:{{ form.password2 }}
        {{ form.submit }}

        {% if form.errors %}
            姓名错误信息:{{ form.errors.username }}
            密码错误信息:{{ form.errors.password2 }}
        {% endif %}
    </form>
{% endblock %}

注意: 通过form.字段解析的input标签中可以自定义样式,如{{ form.字段(class=’xxx’, style=’color:red’) }}

3. 常见字段类型

字段类型    说明
StringField 普通文本字段
PasswordField   密码文本字段
SubmitField 提交按钮
HiddenField 隐藏文本字段
TextAreaField   多行文本字段
DateField   文本字段,datetime.date格式
DateTimeField   文本字段,datetime.datetime格式
IntegerField    文本字段,整数类型
FloatField  文本字段,小数类型
BooleanField    复选框,值为True或False
RadioField  单选框
SelectField 下拉列表
FileField   文件上传字段

4. 验证器

验证器 说明
DataRequired    确保字段有值(并且if判断为真)
Email   邮箱地址
IPAddress   IPv4的IP地址
Length  规定字符长度
NumberRange 输入数值的范围
EqualTo 验证两个字段的一致性
URL 有效的URL
Regexp  正则验证

二、登录注册
前言
在flask中如何快速的实现登录注册注销功能,以及登录状态验证等功能? flask的扩展库中有Flask-Login库就可快速的实现以上的功能,实现起来是非常的便利。

1. 安装Flask-Login

pip install flask-login

2. 实现登录功能

2.1 定义login.html模板

{% extends 'base.html' %}

{% block title %}
    登录页面
{% endblock %}

{% block content %}
    <form action="" method="post">
        姓名:<input type="text" name="username">
        密码:<input type="text" name="password">
        <input type="submit" value="提交">
    </form>
{% endblock %}

2.2 实现登录功能
登录方法中定义被login_manager.user_loader装饰的回调函数,回调函数在如下两个地方被调用:
1)该函数表明当前用户登录成功时调用login_user()方法时,会被回调的函数。回调函数实现的功能是向会话上下文session中存储最为中间的键值对,key为user_id, value为当前登录用户的ID值。
2)回调函数在访问任何一个路由地址时也会被调用。
注意: 因为请求上下文在每次建立连接时,都需要获取当前登录用户并将当前登录用户设置为全局上下文current_user,因此回调函数返回的是当前登录系统的用户对象。
users->views.py

from flask_login import LoginManager, login_required, login_user, logout_user,current_user

# 获取登录管理对象
login_manager = LoginManager()  

@login_manager.user_loader
def load_user(user_id):
    # 必须编写一个函数用于从数据库加载用户。
    # 这个函数在login_user(user)存储当前登录用户到session中时,会被调用
    # 在每次访问地址的时候都被被调用,用于向请求上下文中绑定当前登录的用户信息
    return User.query.get(user_id)

@blue.route('/login/', methods=['GET', 'POST'])
def login():
    if request.method == 'GET':
        return render_template('login.html')

    if request.method == 'POST':
        username = request.form.get('username')
        password = request.form.get('password')
        # 校验用户名和密码是否填写完成
        if not all([username, password]):
            return render_template('login.html')
        # 通过用户名获取用户对象
        user = User.query.filter_by(username=username).first()
        # 校验密码是否正确
        if check_password_hash(user.password, password):
            # 实现登录
            # login_user()能够将已登录并通过load_user()的用户对应的User对象保存在session中
            # 在session中会创建一个键值对,key为user_id,value为当前登录用户的id值
            # 如果希望应用记住用户的登录状态, 只需要为 login_user()的形参 remember 传入 True 实参就可以了.
            login_user(user)
            return redirect(url_for('user.index'))
        else:
            flash('用户名或者密码错误')

        return redirect(url_for('user.index'))

2.3 启动文件进行配置
session_protection: 设置存储用户登录状态的安全级别
login_view: 设置登录验证失败的跳转地址

from user.views import login_manager

app.config['SECRET_KEY'] = os.urandom(24)

# 登录管理,初始化app
# 可以设置None,'basic','strong'以提供不同的安全等级,一般设置strong,如果发现异常会登出用户
# session_protection 能够更好的防止恶意用户篡改 cookies, 当发现 cookies 被篡改时, 该用户的 session 对象会被立即删除, 导致强制重新登录。
login_manager.session_protection='strong'

# 当登录认证不通过,则跳转到该地址
login_manager.login_view='user.login'
login_manager.init_app(app)

2.4 访问首页,登录校验
使用装饰器login_required()进行登录校验。
核心思想: 校验session中是否存在key为user_id的键值对。如果校验成功,则继续访问被装饰的函数。如果校验失败,则跳转到启动文件中定义的login_manager.login_view定义的视图函数。

@blue.route('/index/')
@login_required
def index():
    return render_template('index.html')

如果登录校验成功,则渲染index.html首页,在页面中可以解析全局变量current_user参数。

{% extends 'base.html' %}

{% block title %}
    首页页面
{% endblock %}

{% block content %}
    <p>我是首页</p>
    <p>当前登录系统用户为: {{ current_user.username }}</p>
{% endblock %}

2.5 注销
使用logout_user()方法实现注销,核心功能就是删除当前会话上下文session中的user_id键值对。
# 退出

@blue.route('/logout/', methods=['GET'])
@login_required
def logout():
    logout_user()
    return redirect(url_for('user.login'))

三、文件上传
1、配置路径
utils->settings.py

import os

# 基础路径
BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

# static路径
STATIC_DIR=os.path.join(BASE_DIR,'static')

#templates路径
TEMPLATES_DIR=os.path.join(BASE_DIR,'templates')

# 上传路径
UPLOAD_DIR=os.path.join(os.path.join(STATIC_DIR,'media'),'upload')

2、保存文件

       # 获取图片
        icons = request.files.get('icons')
        #保存save(path)
        #绝对路径
        file_path=os.path.join(UPLOAD_DIR,icons.filename)
        #保存图片到绝对路径中
        icons.save(file_path)
        # 保存user对象
        user=current_user
        #将文件保存到数据库中
        user.icons=os.path.join('upload',icons.filename)
        db.session.add(user)
        db.session.commit()

3、html文件

{% extends 'base.html' %}
{% block title %}
首页

{% endblock %}
{% block content %}
首页
<p>当前用户{{current_user.username}}e</p>
<img src="/static/media/{{current_user.icons}}" alt="">
<form action="" method="post" enctype="multipart/form-data">
    头像:<input type="file" name="icons">
    <input type="submit" value="上传">
</form>

{% endblock %}

四、完整的登录注册代码
manager.py

from flask import Flask
from flask_script import Manager

from users.models import db
from users.views import users_blue, login_manager

app = Flask(__name__)

# 注册蓝图
app.register_blueprint(blueprint=users_blue, url_prefix='/users')

# 定义密钥
app.config['SECRET_KEY'] = 'secret_key'

# 配置数据库
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://root:123456@127.0.0.1:3306/f_login'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

# 没有登录跳转地址(装饰器)
login_manager.login_view='users.user_login'

# 绑定
db.init_app(app)
# 绑定flask-login(登录验证)
login_manager.init_app(app)

# 定义manager管理
manager = Manager(app=app)

if __name__ == '__main__':
    manager.run()

users->views.py

import os

from flask import Blueprint, request, render_template, redirect, url_for
from flask_login import login_user, LoginManager, current_user, login_required, logout_user
from werkzeug.security import generate_password_hash, check_password_hash

from users.forms import UsersRegisterForm, UsersLoginForm

from users.models import db, User
from utils.settings import UPLOAD_DIR

# current_user是全局变量,可以输出user的说有信息

# 定义蓝图
users_blue = Blueprint('users', __name__)

login_manager = LoginManager()


@users_blue.route('/register/', methods=['GET', 'POST'])
def register():
    form = UsersRegisterForm()
    if request.method == 'GET':
        return render_template('register.html', form=form)
    if request.method == 'POST':
        # 验证提交的字段信息
        if form.validate_on_submit():
            username=form.username.data
            password=form.password.data
            #实现注册,保存用户信息到User模型中
            user = User()
            user.username = username
            user.password = generate_password_hash(password)
            db.session.add(user)
            db.session.commit()
            return redirect(url_for('users.user_login'))
        else:
            # 验证失败,form.errors中存在错误信息
            return render_template('register.html', form=form)


@users_blue.route('/create_table/')
def create_table():
    db.create_all()
    return '创建成功'


# 有点类似中间件
@login_manager.user_loader
def load_user(user_id):
    return User.query.get(user_id)


@users_blue.route('/login/', methods=['GET', 'POST'])
def login():
    form = UsersLoginForm()
    if request.method == 'GET':
        return render_template('login.html', form=form)
    if request.method == 'POST':
        if form.validate_on_submit():
            username=form.username.data
            password=form.password.data
            user = User.query.filter(User.username == username).first()
            # 校验用户名和密码是否填写完整
            if user:
                # 获取用户,进行密码判断
                if check_password_hash(user.password,password):
                    #密码正确
                    #实现功能
                    login_user(user)
                    return redirect(url_for('users.index'))
                else:
                    error_password = '密码错误'
                    return render_template('login.html', error_password=error_password,form=form)
            else:
                # 获取不到用户,返回错误信息给页面
                error_username = '该用户没有注册,请去注册'
                return render_template('login.html',error_username=error_username,form=form)
        else:
            return render_template('login.html', form=form)


# @users_blue.route('/user_login/', methods=['GET', 'POST'])
# def user_login():
#     if request.method == 'GET':
#         return render_template('login.html')
#     if request.method == 'POST':
#         username = request.form.get('username')
#         password = request.form.get('password')
#         user = User.query.filter(User.username == username).first()
#         # 校验用户名和密码是否填写完整
#         if not all([username,password]):
#             return render_template('login.html')
#         if user:
#             # 获取用户,进行密码判断
#             if check_password_hash(user.password,password):
#                 #密码正确
#                 #实现功能
#                 login_user(user)
#                 return redirect(url_for('users.index'))
#         else:
#             # 获取不到用户,返回错误信息给页面
#             error = '该用户没有注册,请去注册'
#             return render_template('login.html',error=error)


@users_blue.route('/index/',methods=['GET', 'POST'])
@login_required
def index():
    if request.method == 'GET':
        return render_template('index.html')
    if request.method == 'POST':
        # 获取图片
        icons = request.files.get('icons')
        #保存save(path)
        # 作业:只保存jpg,png。。。 实现中间件,
        # @user_blueprint.before_request
        # @user_blueprint.after_request
        # @user_blueprint.teardown_request
        file_path=os.path.join(UPLOAD_DIR,icons.filename)
        icons.save(file_path)
        # 保存user对象
        user=current_user
        user.icons=os.path.join('upload',icons.filename)
        db.session.add(user)
        db.session.commit()
        return redirect(url_for('users.index'))


@users_blue.route('/logout/')
@login_required
def logout():
    logout_user()
    return redirect(url_for('users.user_login'))

users->models.py

from flask_login import UserMixin
from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()


class User(UserMixin,db.Model):
    id = db.Column(db.Integer,primary_key=True,autoincrement=True)
    username = db.Column(db.String(20),unique=True,nullable=False)
    password = db.Column(db.String(130),nullable=False)
    icons = db.Column(db.String(100),nullable=True)

    __tablename__='user'

users->forms.py

from flask_wtf import FlaskForm
from wtforms import StringField, SubmitField, PasswordField
from wtforms.validators import DataRequired, EqualTo, ValidationError

from users.models import User


class UsersRegisterForm(FlaskForm):
    # 定义用户名和密码都是必填项
    username = StringField('姓 名', validators=[DataRequired()])
    password = PasswordField('密 码', validators=[DataRequired()])
    password2 = PasswordField('确认密码',
                              validators=[DataRequired(), EqualTo('password', '密码不一致')])
    submit = SubmitField('注册')

    def validate_username(self, field):
        user = User.query.filter(User.username == field.data).first()
        if len(field.data) < 3:
            raise ValidationError('用户名不能少于3个字符')
        if len(field.data) > 20:
            raise ValidationError('用户名不能大于20个字符')
        if user:
            raise ValidationError('用户名已存在')

    def validate_password(self, field):
        if len(field.data) < 6:
            raise ValidationError('密码不能少于6个字符')

    def validate_password2(self, field):
        if len(field.data) < 6:
            raise ValidationError('确认密码不能少于6个字符')


class UsersLoginForm(FlaskForm):
    username=StringField('用户名',validators=[DataRequired()])
    password = PasswordField('密码', validators=[DataRequired()])
    submit=SubmitField('登录')

    def validate_username(self, field):
        if len(field.data) < 3:
            raise ValidationError('用户名不能少于3个字符')
        if len(field.data) > 20:
            raise ValidationError('用户名不能大于20个字符')

    def validate_password(self, field):
        if len(field.data) < 6:
            raise ValidationError('密码不能少于6个字符')

utils->settings.py

import os

# 基础路径
BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

# static路径
STATIC_DIR=os.path.join(BASE_DIR,'static')

#templates路径
TEMPLATES_DIR=os.path.join(BASE_DIR,'templates')

# 上传路径
UPLOAD_DIR=os.path.join(os.path.join(STATIC_DIR,'media'),'upload')

templates->base.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>{% block title %}{% endblock %}</title>
    {% block css %}
    {% endblock %}

    {% block js %}
    {% endblock %}
</head>
<body>
{% block content %}
{% endblock %}
</body>
</html>

templates->base_main.html

{% extends 'base.html' %}
{% block js %}
    <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js"type="text/javascript"></script>
{% endblock %}

templates->register.html

{% extends 'base_main.html' %}
{% block title %}
注册
{% endblock %}
{% block content %}
<form action="" method="post">
    {{ form.csrf_token }}

    {% if form.errors.username %}
        {{ form.errors.username.0 }}
    {% endif %}
    <p>{{ form.username.label }}: {{ form.username }}</p>
    {% if form.errors.password %}
        {{ form.errors.password.0 }}
    {% endif %}
    <p>{{ form.password.label }}: {{ form.password }}</p>
    {% if form.errors.password2 %}
        {{ form.errors.password2.0 }}
    {% endif %}
    <p>{{ form.password2.label }}: {{ form.password2 }}</p>
    {{ form.submit() }}
</form>

{% endblock %}

templates->login.html

{% extends 'base_main.html' %}
{% block title %}
登录
{% endblock %}
{% block content %}
<form action="" method="post">
    {{ form.csrf_token }}

    {% if form.errors.username %}
    {{ form.errors.username.0 }}
    {% endif %}

    {% if error_username %}
    {{ error_username }}
    {% endif %}

    <p>{{ form.username.label }}: {{ form.username }}</p>

    {% if form.errors.password %}
    {{ form.errors.password.0 }}
    {% endif %}

    {% if error_password %}
    {{ error_password }}
    {% endif %}

    <p>{{ form.password.label }}:{{ form.password }}</p>

    {{ form.submit() }}
    <!--<p>姓名:<input type="text" name="username"></p>-->
    <!--<p>密码:<input type="password" name="password"></p>-->
    <!--<input type="submit" value="登录">-->
</form>

{% endblock %}

templates->index.html

{% extends 'base.html' %}
{% block title %}
首页

{% endblock %}
{% block content %}
首页
<p>当前用户{{current_user.username}}e</p>
<img src="/static/media/{{current_user.icons}}" alt="">
<form action="" method="post" enctype="multipart/form-data">
    头像:<input type="file" name="icons">
    <input type="submit" value="上传">
</form>

{% endblock %}

作者:晓晓的忍儿
链接:https://www.jianshu.com/p/9e343d10f7a2
来源:简书
简书著作权归作者所有,任何形式的转载都请联系作者获得授权并注明出处。

flask插件系列之Flask-WTF表单

lask_wtf是flask框架的表单验证模块,可以很方便生成表单,也可以当做json数据交互的验证工具,支持热插拔。

安装

pip install Flask-WTF

Flask-WTF其实是对wtforms组件的封装,使其支持对flask框架的热插拔。

简单使用

# app.py
from flask import Flask, current_app, request, render_template
from forms import MyForm

app = Flask(__name__,template_folder='static/html')
@app.route('/',methods=['GET','POST'])
def login():
    form = MyForm()
    if form.validate_on_submit():
        return 'OK'
    return render_template('forms/index.html', form=form)
if __name__ == '__main__':
    app.run(host='127.0.0.1', port=80, debug=True)

# forms.py
from flask_wtf import FlaskForm
from wtforms import StringField
from wtforms.validators import DataRequired

class MyForm(FlaskForm):
    name = StringField('name', validators=[DataRequired()])

# forms/index.html
<form method="POST" action="/">
{{ form.csrf_token }}
{{ form.name.label }} {{ form.name(size=20) }}
<input type="submit" value="Go">
</form>

flask_wtf定义字段
flask_wtf完全使用wtforms组件的字段模型,wtforms对字段的定义在fields模块;又分为core和simple,core模块定义了普通使用的字段,simple在core模块的基础上扩展了一些字段,这些字段会自动进行字段级别的校验。

字段类型

# core.py
__all__ = (
    'BooleanField', 'DecimalField', 'DateField', 'DateTimeField', 'FieldList',
    'FloatField', 'FormField', 'IntegerField', 'RadioField', 'SelectField',
    'SelectMultipleField', 'StringField',
)
常用字段说明:
BooleanField:布尔类型,如Flask,True
StringField:字符串类型
DecimalField:小数点文本字段,如:‘1.23’
DateField:日期字段,格式:'%Y-%m-%d'
DateTimeField:日期字段,格式:'%Y-%m-%d %H:%M:%S'
FieldList:统一字段类型组成列表,如:FieldList(StringField('Name', [validators.required()]))
FloatField:浮点数类型
IntegerField:整形
SelectMultipleField:多选框
RadioField:单选框


# simple.py
TextAreaField:文本域,可接受多行输入
PasswordField:密码字段,输入的不会直接在浏览器明文显示
FileField:上传文件,但不会处理验证文件,需要手动处理
HiddenField:隐藏字段
SubmitField:按钮
TextField:字符串类型的别名,弃用

表单定义

# 参数:
class UserAdminForm(FlaskForm):
    username = StringField(label='用户名', validators=[DataRequired(),Length(4,20)])
    password_hash = PasswordField(label='密码',validators=[DataRequired(),Length(4,20)])
    limit = SelectField(label='用户权限',
                        choices=[('guest', '所有权限'),
                                 ('operation', '可读可写不可删除'),
                                 ('management', '可读不可写')],
                        default='guest')  # 权限

# 字段一般的参数
# label:字段的名字
# default:默认
# validators:字段的验证序列
# description:字段的描述
# choices:SelectField和他的子类有的字段,选择框,多选一

字段的验证序列
字段的参数validators可以指定提交表单的验证序列,按照从左到右的顺序,默认的可选验证在wtforms.validators模块,已经封装的验证方法有:

__all__ = (
    'DataRequired', 'data_required', 'Email', 'email', 'EqualTo', 'equal_to',
    'IPAddress', 'ip_address', 'InputRequired', 'input_required', 'Length',
    'length', 'NumberRange', 'number_range', 'Optional', 'optional',
    'Required', 'required', 'Regexp', 'regexp', 'URL', 'url', 'AnyOf',
    'any_of', 'NoneOf', 'none_of', 'MacAddress', 'mac_address', 'UUID'
)
模块中大小写有对应的方式,如DataRequired对应data_required。

DataRequired/data_required:验证数据是否真实存在,即不能为空,必须是非空白字符串,否则触发StopValidation错误。
InputRequired/input_required:和DataRequired的区别在于可以是空白字符串;
Required/required:data_required的别名
Email/email:验证符合邮件的格式,只有最基本的验证;
EqualTo/equal_to:比较两个字段的值,比如密码和确认密码,如果不相等就触发错误,equal_to(field,message),需要输入另一个字段的名字。
IPAddress/ip_address:验证是否是ip地址,默认验证IPV4地址。
MacAddress/mac_address:验证是否符合mac格式;
UUID:是否是uuid格式;
URL/url:验证是否符合url格式;
Regexp/regexp:用提供的正则表达式验证字段;Regexp(r"")
Length/length:设置字段值的长度,Length(min,max);
NumberRange/number_range:设置一个数字字段的取值范围,可以针对浮点数和小数;NumberRange(min,max)
Optional/optional:允许字段为空并停止验证;
NoneOf/none_of:将传入的数据和无效的比较,是抛出异常;Noneof(values).
Anyof/any_of:将传入的数据和预设的数据比较,不是异常。Anyof(values).

自定义字段验证
如果默认的验证序列不满足我们的要求,我们可以通过继承的方式自定义字段。

from wtforms.validators import DataRequired,Length,StopValidation
class NewStringField(StringField):
    """
    自定义一个新的字段
    """
    def pre_validate(self, form):
        """验证方法,在validators验证序列之前"""
        x:str = form.name.data
        if not x.startswith('g'):
            raise StopValidation("your data must be startswith 'g'")

    def post_validate(self, form, validation_stopped):
        """
        验证方法,在validators验证序列之后
        :param form:该字段所属的表单对象
        :param validation_stopped:前面验证序列的结果,True表示验证通过,False表示验证失败
        :return:
        """
        if not validation_stopped:
            raise ValueError("验证失败了!")
        pass

触发StopValidation异常会停止验证链;

自定义表单验证

一般来说,如果对表单有额外需要的验证,一般自定义表单的额外的验证方法而不是重新自定义新的字段,而form已经为我们提供了这种方法。
看Form对象的源码:

def validate(self):
    """
    Validates the form by calling `validate` on each field, passing any
    extra `Form.validate_<fieldname>` validators to the field validator.
    """
    extra = {}
    for name in self._fields:
        inline = getattr(self.__class__, 'validate_%s' % name, None)
        if inline is not None:
            extra[name] = [inline]

    return super(Form, self).validate(extra)

Form对象调用validate函数时会自动寻找validate_%s的方法添加到验证序列,并在原先字段的验证序列验证完毕后执行。

class MyForm(FlaskForm):
    name = StringField('name', validators=[DataRequired(), Length(4,20)])
    def validate_name(self, field):
        print(field.data)
        if hasattr(self, 'name') and len(self.name.data) > 5:
            print(self.name.data)
            return True
        raise ValidationError('超过5个字符')

# 在自定义的验证方法中,抛出异常使用ValidationError,validate会自动捕捉。

表单对象
flask_wtf推荐使用Form对象的子类FlaskForm代替,该对象提供了所有表单需要的属性和方法。那么Form对象是如何自动实现表单功能的呢?
分析FlaskForm对象源码:

class FlaskForm(Form):
    class Meta(DefaultMeta):
        def wrap_formdata(self, form, formdata):
            pass

    def __init__(self, formdata=_Auto, **kwargs):
        csrf_enabled = kwargs.pop('csrf_enabled', None)
        pass
    def is_submitted(self):
        pass
    def validate_on_submit(self):
        pass
    def hidden_tag(self, *fields):
        pass
    def validate(self):
        pass

FlaskForm内部定义了一个Meta类,该类添加csrf保护的一些方法,所以创建表单的时候一定要导入FlaskForm而不是Form.

is_submitted:检查是否有一个活跃的request请求;

validate_on_submit:调用is_submitted和validate方法,返回一个布尔值,用来判断表单是否被提交;

validate:字段级别的验证,每个字段都有一个validate方法,FlaskForm调用validate会对所有的字段调用validate方法验证,如果所有的验证都通过返回Ture,否则抛出异常。

hidden_tag:获取表单隐藏的字段;

wrap_formdata:获取request中的form,每次form对象初始化时会执行该函数从request获取form。

重要属性

form.data:字段名字和值组成的字典;
form.errors:验证失败的信息字典,在调用validate_on_submit方法后才有效;
form.name.data:字段name的值;
form.name.type:字段name的类型

常用场景
登录验证

# froms.py
class UserPasswordForm(FlaskForm):
    """
    登录提交的表单
    """
    username = StringField('User', validators=[DataRequired()])
    password = PasswordField('Password', validators=[DataRequired()])

# form.html
<form method="POST" action="/">
{{ form.csrf_token }}
{{ form.username.label }} {{ form.username(size=20) }}
{{ form.password.label }} {{ form.password }}
<input type="submit" value="Go">
</form>

# views.py
@app.route('/login',methods=['GET','POST'])
def login():
    form = UserPasswordForm()
    if form.validate_on_submit():
        # 验证表单
        if form.username.data == "xiaoming" and form.password.data == '123':
            return 'OK'
    return render_template('forms/index.html', form=form)

ajax请求转化表单
有时候我们没有html页面的表单,只有ajax请求的数据交互,但是想借用Form来定义接口和验证接收的数据,如果ajax的请求方法是(‘POST’, ‘PUT’, ‘PATCH’, ‘DELETE’)中的一种,FlaskForm会自动从request对象中调用request.form和request.get_json()方法来接收数据,因此这种方式十分方便。注意:get方法不再其中。

# form.py
class MyForm(FlaskForm):
    name = StringField('name', validators=[DataRequired(), Length(4,20)])
# view.py
@app.route('/form',methods=['GET','POST'])
def form():
    if request.method != "GET":
        form = MyForm() # form会获取请求数据
        print(form.data)
        return 'ok'
    return ''
# test.py
import requests as req
import json

class ProTest():
    baseurl = 'http://127.0.0.1:80'
    def test_form(self):
        url = self.baseurl + '/form'
        rsp = req.post(url,json={'name':'hhhh'})
        # rsp = req.get(url,json={'name':'hhhh'})
if __name__ == '__main__':
    test = ProTest()
    test.test_form()

form启用csrf保护
默认csrf保护是开启的,只要在html文件中添加{{ form.csrf_token }},app必须设置SECRET_KEY参数。

# 禁用保护
form = Form(csrf_enabled=False)
# 或配置app时
WTF_CSRF_ENABLED = False

一般数据csrf保护
同理必须设置SECRET_KEY参数。

from flask_wtf.csrf import CsrfProtect
csrf = CsrfProtect()

def create_app():
    app = Flask(__name__)
    csrf.init_app(app)

# 模板中添加一个隐藏域
<input type="hidden" name="csrf_token" value="{{ csrf_token() }}" />
<meta name="csrf-token" content="{{ csrf_token() }}">
# 如果是ajax请求,可以在脚本中
var csrftoken = "{{ csrf_token() }}"
# 然后每个请求添加 X-CSRFToken 头部

# 全局禁用csrf
WTF_CSRF_CHECK_DEFAULT = False

# 对一些视图跳过csrf检查
@csrf.exempt
@app.route('/foo', methods=('GET', 'POST'))
def my_handler():
    return 'ok'

参考
https://flask-wtf.readthedocs.io/en/stable/

http://www.pythondoc.com/flask-wtf/

https://www.cnblogs.com/sysnap/p/6568397.html # 表单验证器的总结

使用SSL证书为Windows(非Server)远程桌面RDP连接加密

远程桌面连接中“无法验证此远程计算机的身份。”这一问题,具体症状如下图所示,

本文主要介绍非Server系统中无法使用专用工具,转而修改注册表的方法
本文假定您已对SSL证书有一定的了解,或最好已经成功的申请到了服务器SSL/TLS证书
本文演示使用免费的StartSSL证书,其他机构签发的证书大同小异
使用SSL证书为Windows非Server远程桌面RDP连接加密
原理分析
操作步骤
第一步 导入证书
第二步 分配权限
第三步 编辑注册表

原理分析
也不知是从哪一个版本开始,微软开始为远程桌面加入了SSL加密功能,并且是默认开启。
导致这个问题的原因实际是系统使用了一个自签名的默认证书,而这个自签名证书对于客户端来说是不可信的,也就是说无法用于证明服务端的身份,客户端自然就会报告其不安全。
那么解决的思路就有了,那就是我们为服务端添加一个可信的证书,并在远程桌面连接中让系统使用这个证书。
首先获得一个这样的证书并不难,只要你已经有至少一个可用的域名,那么StartSSL便可以免费为你提供;
然后导入这个证书也不难,只要参照配置https服务的方法,直接导入就行了;
那么问题在哪儿呢?那就是证书导进去了,系统却不使用。
这个问题在Server版当中据说有专门的工具解决,但桌面版却并没有,所以最后就只好修改注册表,将要用的证书的指纹填进去,告诉系统该用哪个证书,然后问题就解决了。

操作步骤
第一步 导入证书
已经用证书配置好https的可以跳过第一步。

我之前已经申请好证书了,在这里就不演示申请过程了,关于StartSSL免费证书的教程很多,可以自行百度之。

申请到证书后,在我们手中的应该是一个 *.p12 的证书文件, 放在一边备用。

如果手上只有 私钥 *.key 和 证书 *.crt ,请使用StartSSL的控制台工具:Tool Box -> Create PKCS#12 (PFX) File,按照表单提示,提供私钥和证书内容,并设定一个密码,然后选择继续来生成.p12文件,熟悉linux的也可以用openssl命令行大法搞定。

首先按下‘Win + R’,进入“运行”,键入“mmc”,打开“管理控制台”。

在 文件 中选择 添加/删除管理单元 。

在左侧选中 证书 后点击 添加 。

在弹出的对话框中选择 计算机账户,点击 下一步 。

之后选择 本地计算机(保持默认) 然后点击 完成 ,再然后点击 确定 。

在 证书-个人 上点击 右键 ,选择 所有任务-导入 。

按照向导点击 下一步 ,之后选择你的 证书文件 (p12格式的证书文件选择时需要更改文件类型才可以找到),之后需要输入之前设置的密码,证书存储 选择 根据证书类型,自动选择证书存储 ,然后点击下一步即可



导入完成后如下图所示:

第二步 分配权限
首先在已经导入的证书上点击 右键 ,选择 所有任务-管理私钥 。

之后添加 NETWORK SERVICE 用户。

至少要将 读取 权限分配给 NETWORK SERVICE ,然后确定。

第三步 编辑注册表
首先是按下‘Win + R’,进入“运行”,键入“regedit”,打开“管理控制台”。

展开路径 HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp ,然后添加如下项:
名称: SSLCertificateSHA1Hash
类型: REG_BINARY

之后回到之前的证书管理,双击打开已经导入的证书,在 详细信息 中选择 指纹 ,并记录下方的值。

最后将记录的值填入之前新建注册表项的 数据 位置。

至此便大功告成!请尽情使用吧!

注意事项
这个方法以拥有域名为基础,这也是申请免费SSL证书的条件,没有特殊需要的话也很便宜。
证书设置完成后,访问远程桌面服务器就需要填写域名方式访问,而如果以局域网机器名访问的话,会提示名称不匹配。
实际上,SSL证书只是和FQDN (fully qualified domain name,全称域名)绑定对应的,所以IP是什么根本无所谓,通过本地host或者本地DNS解析的方式映射上域名理论上也都是可以的。
至此便大功告成!请尽情使用吧!

作者:李YD
来源:CSDN
原文:https://blog.csdn.net/a549569635/article/details/48831105
版权声明:本文为博主原创文章,转载请附上博文链接!

Windows RDP 证书问题导致无法远程了连接解决方案

打开 win+R 输入MMC 控制台,

复制 RDP 证书,如图:
展开 / Personal / Certificates 复制 RDP 证书 :

粘贴到 Remote Desktop 下 :

双击打开证书,选择 Details 下 Thumbprint 复制其中数值 :

以管理员身份运行 PowerShell :

$hash = read-host "Enter Certificate thumbprint: "
wmic /namespace:\\root\cimv2\TerminalServices PATH Win32_TSGeneralSetting Set SSLCertificateSHA1Hash="$hash"


更新 RDP 证书后,可以成功连接虚拟机 RDP 服务。

How to Manually Upgrade phpMyAdmin on Ubuntu

I have running Ubuntu 18.04 on my workstation. I have the phpMyAdmin older version installed on it. Initially, the phpMyAdmin was installed through the Apt package manager.

phpMyAdmin installation via Apt package manager create multiple directories:

/etc/phpmyadmin – Configuration files
/var/lib/phpmyadmin – Library and tmp directries
/usr/share/phpmyadmin – Main phpMyAdmin installation
Step 1 – Backup phpMyAdmin
You should take a back up of your current phpMyAdmin directory. However, I have just renamed it to phpmyadmin.bak at the same location.

sudo mv /usr/share/phpmyadmin/ /usr/share/phpmyadmin.bak
Step 2 – Download Latest phpMyAdmin
Now, download the latest phpMyAdmin archive file from its official download page. During last update of this article phpMyAdmin 4.8.5 is latest version available for download.

wget https://files.phpmyadmin.net/phpMyAdmin/4.8.5/phpMyAdmin-4.8.5-all-languages.zip
unzip phpMyAdmin-4.8.5-all-languages.zip
You will see a directory phpMyAdmin-4.8.5-all-languages in the current location. Move this latest directory to the appropriate location.

sudo mv phpMyAdmin-4.8.5-all-languages /usr/share/phpmyadmin
Step 3 – Update Configuration
As I told the existing phpMyAdmin was installed with Apt package manager. Therefore you need to specify the TEMP_DIR and CONFIG_DIR location under the vendor_config.php file.

Edit vendor_config.php file in your favorite text editor

sudo vim /usr/share/phpmyadmin/libraries/vendor_config.php
and update the following values.

define(‘TEMP_DIR’, ‘/var/lib/phpmyadmin/tmp/’);
define(‘CONFIG_DIR’, ‘/etc/phpmyadmin/’);
Save the file and access the phpMyAdmin in a web browser.


All done. In conclusion, You have the latest phpMyAdmin running on your Ubuntu system.

各种开发语言示例调用WebService接口

ASP示例:

<%
uid=”账号”
pwd=”密码”
tos=”13900041123″
msg=”你们好”
url = “http://URL/Service.asmx/SendMessages
SoapRequest=”uid=”&uid&”&pwd=”&pwd&”&tos=”&tos&”&msg=”&msg&”&otime=”
”””””””””””””以下代码不变””””””””””””””””””””””””””””””””””””””””
Set xmlhttp = server.CreateObject(“Msxml2.XMLHTTP”)
xmlhttp.Open “POST”,url,false
xmlhttp.setRequestHeader “Content-Type”, “application/x-www-form-urlencoded”‘注意
xmlhttp.setRequestHeader “HOST”,”URL”
xmlhttp.setRequestHeader “Content-Length”,LEN(SoapRequest)
xmlhttp.Send(SoapRequest)
If xmlhttp.Status = 200 Then
Set xmlDOC = server.CreateObject(“MSXML.DOMDocument”)
xmlDOC.load(xmlhttp.responseXML)
showallnode “string”,xmlDOC’调用SHOWALLNODE
Set xmlDOC = nothing
Else
Response.Write xmlhttp.Status&”&nbsp;”
Response.Write xmlhttp.StatusText
End if
Set xmlhttp = Nothing

Function showallnode(rootname,myxmlDOC)
set nodeobj=myxmlDOC.documentElement.selectSingleNode(“//”&rootname&””)’当前结点对像
if nodeobj.text<>”” then
returnstring=returnstring&”返回值:”&nodeobj.text
end if
response.write returnstring
set nodeobj=nothing
End Function
%>

或者

function SendMessages(uid,pwd,tos,msg,otime)
SoapRequest=”<?xml version=”&CHR(34)&”1.0″&CHR(34)&” encoding=”&CHR(34)&”utf-8″&CHR(34)&”?>”& _
“<soap:Envelope xmlns:xsi=”&CHR(34)&”http://www.w3.org/2001/XMLSchema-instance”&CHR(34)&” “& _
“xmlns:xsd=”&CHR(34)&”http://www.w3.org/2001/XMLSchema”&CHR(34)&” “& _
“xmlns:soap=”&CHR(34)&”http://schemas.xmlsoap.org/soap/envelope/”&CHR(34)&”>”& _
“<soap:Body>”& _
“<SendMessages xmlns=”&CHR(34)&”http://tempuri.org/”&CHR(34)&”>”& _
“<uid>”&uid&”</uid>”& _
“<pwd>”&pwd&”</pwd>”& _
“<tos>”&tos&”</tos>”& _
“<msg>”&msg&”</msg>”& _
“<otime>”&otime&”</otime>”& _
“</SendMessages>”& _
“</soap:Body>”& _
“</soap:Envelope>”

Set xmlhttp = server.CreateObject(“Msxml2.XMLHTTP”)
xmlhttp.Open “POST”,url,false
xmlhttp.setRequestHeader “Content-Type”, “text/xml;charset=utf-8”
xmlhttp.setRequestHeader “HOST”,”URL”
xmlhttp.setRequestHeader “Content-Length”,LEN(SoapRequest)
xmlhttp.setRequestHeader “SOAPAction”, “http://tempuri.org/SendMessages” ‘一定要与WEBSERVICE的命名空间相同,否则服务会拒绝
xmlhttp.Send(SoapRequest)
”样就利用XMLHTTP成功发送了与SOAP示例所符的SOAP请求.’检测一下是否返回200=成功:

If xmlhttp.Status = 200 Then
Set xmlDOC = server.CreateObject(“MSXML.DOMDocument”)
xmlDOC.load(xmlhttp.responseXML)
SendMessages=xmlDOC.documentElement.selectNodes(“//SendMessagesResult”)(0).text ‘显示节点为GetUserInfoResult的数据(返回字符串)
Set xmlDOC = nothing
Else
SendMessages=xmlhttp.Status&”&nbsp;”
SendMessages=xmlhttp.StatusText
End if
Set xmlhttp = Nothing
end function

Delphi示例:

procedure TForm1.Button2Click(Sender: TObject);
var
uid,pwd,mob,txt:WideString;
Iservice:   Service1Soap;
back_info:string;
begin
HTTPRIO1.URL:=service_url.Text;
HTTPRIO1.HTTPWebNode.Agent := ‘Borland SOAP 1.2’;
HTTPRIO1.HTTPWebNode.UseUTF8InHeader := true;
Iservice:= HTTPRIO1 as Service1Soap;
//______________

uid:=euid.Text;
pwd:=epwd.Text;
mob:=emobno.Text;
txt:=econtent.Text;

back_info:=Iservice.SendMessages(uid,pwd,mob,txt,”);
memo2.Text:=back_info;
if length(trim(back_info))>3 then begin
showmessage(‘短信发送成功’+back_info);
end else begin
showmessage(‘短信发送失败’+back_info);
end;
end;

注:

initialization
InvRegistry.RegisterInterface(TypeInfo(Service1Soap), ‘http://tempuri.org/’, ‘utf-8’);
InvRegistry.RegisterDefaultSOAPAction(TypeInfo(Service1Soap), ‘http://tempuri.org/%operationName%’);
//delphi调用net2.0需要加这一行。否则会出错。
InvRegistry.RegisterInvokeOptions(TypeInfo(Service1Soap), ioDocument);

end.

JAVA示例:

需要导入axis.jar

package server;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.URLConnection;
import java.net.*;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

public class smsService {

private String getSoapSmssend(String userid,String pass,String mobiles,String msg,String time)
{
try
{
String soap = “”;
soap = “<?xml version=\”1.0\” encoding=\”utf-8\”?>”
+”<soap:Envelope xmlns:xsi=\”http://www.w3.org/2001/XMLSchema-instance\” xmlns:xsd=\”http://www.w3.org/2001/XMLSchema\” xmlns:soap=\”http://schemas.xmlsoap.org/soap/envelope/\“>”
+”<soap:Body>”
+”<SendMessages xmlns=\”http://tempuri.org/\“>”
+”<uid>”+userid+”</uid>”
+”<pwd>”+pass+”</pwd>”
+”<tos>”+mobiles+”</tos>”
+”<msg>”+msg+”</msg>”
+”<otime>”+time+”</otime>”
+”</SendMessages>”
+”</soap:Body>”
+”</soap:Envelope>”;
return soap;
}
catch (Exception ex)
{
ex.printStackTrace();
return null;
}
}

private InputStream getSoapInputStream(String userid,String pass,String mobiles,String msg,String time)throws Exception
{
URLConnection conn = null;
InputStream is = null;
try
{
String soap=getSoapSmssend(userid,pass,mobiles,msg,time);
if(soap==null)
{
return null;
}
try{

URL url=new URL(“http://URL/Service.asmx“);

conn=url.openConnection();
conn.setUseCaches(false);
conn.setDoInput(true);
conn.setDoOutput(true);
conn.setRequestProperty(“Content-Length”, Integer.toString(soap.length()));
conn.setRequestProperty(“Content-Type”, “text/xml; charset=utf-8”);
conn.setRequestProperty(“HOST”,”URL”);
conn.setRequestProperty(“SOAPAction”,”\”http://tempuri.org/SendMessages\“”);

OutputStream os=conn.getOutputStream();
OutputStreamWriter osw=new OutputStreamWriter(os,”utf-8″);
osw.write(soap);
osw.flush();
}catch(Exception ex){
System.out.print(“SmsSoap.openUrl error:”+ex.getMessage());
}
try{
is=conn.getInputStream();
}catch(Exception ex1){
System.out.print(“SmsSoap.getUrl error:”+ex1.getMessage());
}

return is;
}
catch(Exception e)
{
System.out.print(“SmsSoap.InputStream error:”+e.getMessage());
return null;
}
}

//发送短信
public String sendSms(String userid,String pass,String mobiles,String msg,String time)
{
String result = “-12”;
try
{
Document doc;
DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
dbf.setNamespaceAware(true);
DocumentBuilder db=dbf.newDocumentBuilder();
InputStream is=getSoapInputStream(userid,pass,mobiles,msg,time);
if(is!=null){
doc=db.parse(is);
NodeList nl=doc.getElementsByTagName(“SendMessagesResult”);
Node n=nl.item(0);
result=n.getFirstChild().getNodeValue();
is.close();
}
return result;
}
catch(Exception e)
{
System.out.print(“SmsSoap.sendSms error:”+e.getMessage());
return “-12”;
}
}

}

PHP示例:

<?php
$uid = “账号”;//用户账户
$pwd = “密码”;//用户密码
$mobno = “手机号码”;//发送的手机号码,多个请以英文逗号隔开如”138000138000,138111139111″
$content = “发送内容”;//发送内容
$otime = ”;//定时发送,暂不开通,为空
$client = new SoapClient(“URL/Service.asmx?WSDL“);
$param = array(‘uid’ => $uid,’pwd’ => $pwd,’tos’ => $mobno,’msg’ => $content,’otime’=>$otime);
$result = $client->__soapCall(‘SendMessages’,array(‘parameters’ => $param));
var_dump($result);
die();
?>

VB.NET示例:

Protected Sub Button1_Click(ByVal sender As Object, ByVal e As EventArgs) Handles Button1.Click
Dim objSoap As Object, url As String
url = “URL/Service.asmx?wsdl
objSoap = CreateObject(“MSSOAP.SOAPClient30”)
objSoap.ClientProperty(“ServerHTTPRequest”) = True
objSoap.MSSoapInit(url)

txtReturn.Text = objSoap.SendMessages(txtName.Text, txtPwd.Text, txtPhone.Text, txtContent.Text, “”)

End Sub

VB示例:

Private Sub Command1_Click()

Dim mySoap As New MSSOAPLib30.SoapClient30
mySoap.ClientProperty(“ServerHTTPRequest”) = True
mySoap.MSSoapInit “URL/Service.asmx?WSDL
txtReturn.Text = mySoap.SendMessages(txtName.Text, txtPwd.Text, txtPhone.Text, txtContent.Text, “”)
Set mySoap = Nothing

End Sub

VC示例:

private: System::Void button1_Click(System::Object^  sender, System::EventArgs^  e) {

TService:: Service1 ^v = gcnew TService:: Service1;//添加Web引用

txtReturn ->Text = v -> SendMessages(txtName ->Text,txtPwd->Text,txtPhone->Text,txtContent->Text,””);
}
};

VS自带工具:dumpbin的使用查看Lib,dll等

有时候我们想查看一个exe引用了哪些动态库,或者我们想看某个动态库包含哪些接口函数,这个时候可以使用dumpbin.exe工具:

1.输入Dumpbin -imports calldll.exe查看它的输入信息,可以看到它加载了***.dll
2.输入dumpbin –exports dlltest.dll,列出导出函数

开始->所有程序->Microsoft Visual Studio 2010->Visual Studio Tools ->“Visual Studio 命令提示(2010)”后,

就像普通的cmd一样的命令行环境,就可以正常使用VS的一些工具,其中就包括dumpbin。

输入如下命令,查看dll信息:

D:\Program Files (x86)\Microsoft Visual Studio 10.0\VC>

dumpbin -exports D:\WorkSpace\DLLTutorial\Debug\DLLTutorial.dll

输出如下:

其中可以看到,我们在DLL中写的两个函数:

1 0 000110FA Add = @ILT+245(_Add)

2 1 00011208 Function = @ILT+515(_Function)

dumpbin使用方式:dumpbin 选项 文件名

其中多个选项间用空格分开,多个文件名间也用空格分开,文件名可以为后缀为.obj、.lib、.dll、.exe,如 dumpbin /ALL/RAWDATA:NONE /OUT:1.txt text.obj (dmpbin /ALL /RAWDATA:NONE test.obj >1.txt)。如果没有给dumpbin指定任何选项,它将等同于使用了/SUMMARY参数。如果没有指定任何输入文件,它将列出所有的选项。

选项说明:参数的使用可以用”-”或者”/”(如-ALL等于/ALL)后面跟选项名。有些选项可以在选项名后接”:”。使用空格或制表符(Tab)分割命令选项。选项名,关键字和文件名是不区分大小写的。大多数的参数可以应用于所有的二进制文件,有少部分参数只能用于特定的文件。

(1)、/ALL :此选项显示除代码反汇编外的所有可用信息。使用/DISASM显示反汇编。可以与/ALL一起使用/RAWDATA:NONE来省略文件的原始二进制详细资料。

(2)、/ARCHIVEMEMBERS:此选项显示有关库成员对象的最少信息。 (3)、/CLRHEADER file:其中file为用/clr生成的图像文件。CLRHEADER显示有关在任何托管程序中使用的.net头的信息。输出显示.net头及其中各节的位置和大小(以字节计算)。

(3)、/DIRECTIVES:此选项转储图像中由编译器生成的.directive节。

(4)、/DEPENDENTS:转储图像从中导入函数的DLL的名称。不要转储导入函数名。

(5)、/DISASM:此选项显示代码段的反汇编,如果出现在文件中则使用符号。

(6)、/EXPORTS:此选项显示从可执行文件或DLL导出的所有定义。

(7)、/FPO:此选项显示框架指针优化(FPO)记录。

(8)、/HEADERS:此选项显示文件头和每节的头。当用于库时,显示每个成员对象的头。

(9)、/IMPORTS[:file]:此选项显示导入到可执行文件或DLL的DLL列表(静态链接的和延迟加载)和上述每个DLL的各个导入。可选file规范允许指定仅显示某个DLL的导入。

(10)、/LINENUMBERS:此选项显示COFF行号。如果对象文件是用程序数据库(/Zi)、C7兼容(/Z7)或仅限行号(/Zd)编译的,则它包含行号。如果可执行文件或DLL是与生成调试信息(/DEBUG)链接的,则它包含COFF行号。

(11)、/LINKERMEMBER[:{1|2}]:此选项显示库中定义的公共符号。指定参数1将按对象顺序显示符号及其偏移量。指定参数2将显示对象的偏移量和索引号,然后按字母顺序列车这些符号及每个符号的对象索引。若要两个输出都获得,指定不带数字参数的/LINKERMEMBER。

(12)、/LOADCOMFIG:此选项转储IMAGE_LOAD_CONFIG_DIRECTORY结构,此结构是由WindowsNT加载程序使用并在WIINNT.H中定义的可选结构。

(13)、/OUT:filename:此选项指定输出的filename。默认情况下,DUMPBIN将信息显示到标准输出。

(14)、/PDBPATH[:VERBOSE]filename:filename为要为其查找匹配.pdb文件的.dll或.exe文件名。VERBOSE(可选)为报告曾尝试在其中定位.pdb文件的所有目录。/PDBPATH将沿调试器搜索.pdb文件的同一路径搜索计算机,并将报告那些.pdb文件(若有)和filename中指定的文件相对应。

(15)、/RAWDATA[:{1|2|4|8|NONE}[,number]]:此选项显示文件中每节的原始内容。参数说明:1,默认值,内容以十六进制字节显示,如果内容具有打印的表示形式,则还显示为ASCII字符;2,内容显示为十六进制的2字节值;4,内容显示为十六进制的恶4字节值;8,内容显示为十六进制的8字节值;NONE,取消显示原始数据,此参数对控制/ALL输出很有用;number,显示的行被设置为每行具有number个值的宽度。

(16)、/RELOCATIONS:此选项显示对象或图像中的任何重定位。

(17)、/SECTION:section:此选项限制与指定的section有关的信息的输出。

(18)、/SUMMARY:此选项显示有关节的最少信息(包括总大小)。如果未指定其它选项,则此选项为默认值。

(19)、/SYMBOLS:此选项显示COFF符号表。符号表存在于所有对象文件中。而对于图像文件,只有当它是与/DEBUG链接时,它才包含COFF符号表。

(20)、/UNWINDINFO:在程序图像(例如exe和dll)中转储结构化异常处理(SHE)表的展开描述符。/UNWINDINFO仅适用于IA64图像。

以上所有只有/HEADERS DUMPBIN选项可用于由/GL编译器选项产生的文件。

如果查看a.dll库中包含哪些函数,可以使用:dumpbin /exports a.dll >1.txt

如果查看b.exe中加载了哪些动态库,可以使用:dumpbin /imports b.exe >2.txt

如果查看c.lib中包含哪些函数,可以使用:dumpbin /all /rawdata:none c.lib >3.txt

如果查看d.obj中包含哪些函数,可以使用:dumpbin /all /rawdata:none d.obj >4.txt

php curl 分离header和body信息

php中可以通过curl来模拟http请求,同时可以获取http response header和body,当然也设置参数可以只获取其中的某一个。当设置同时获取response header和body时候,它们会一同作为结果返回。这时需要我们自己来分离它们。

下面代码是模拟向google一个http GET请求

function httpGet() {
$url = ‘http://www.google.com.hk’;
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_HEADER, TRUE); //表示需要response header
curl_setopt($ch, CURLOPT_NOBODY, FALSE); //表示需要response body
curl_setopt($ch, CURLOPT_RETURNTRANSFER, TRUE);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, FALSE);
curl_setopt($ch, CURLOPT_AUTOREFERER, TRUE);
curl_setopt($ch, CURLOPT_TIMEOUT, 120);
$result = curl_exec($ch);
if (curl_getinfo($ch, CURLINFO_HTTP_CODE) == ‘200’) {
return $result;
}
return NULL;
}

调用上述方法后看到如下类似输出:

HTTP/1.1 200 OK
Date: Tue, 09 Jul 2013 14:21:08 GMT
Expires: -1
Cache-Control: private, max-age=0
Content-Type: text/html; charset=UTF-8
Set-Cookie: PREF=ID=75e996a7ad21f47b:FF=0:NW=1:TM=1373379668:LM=1373379668:S=TTLQQN-jwGDYnkkY; expires=Thu, 09-Jul-2015 14:21:08 GMT; path=/; domain=.google.com.hk
Set-Cookie: NID=67=PPu7FfFeuZqwfsrUifgzjidX4JZxxCPLe9xFHjdXhfHpzs3gaykFSH5uGXy2esWTlp_rdqIYkjFDMollzI_sA-8owxD3mDh6KCRwdMa9-g5VChj0E5XAGNjo9d-sZfLN; expires=Wed, 08-Jan-2014 14:21:08 GMT; path=/; domain=.google.com.hk; HttpOnly
P3P: CP=”This is not a P3P policy! See http://www.google.com/support/accounts/bin/answer.py?hl=en&answer=151657 for more info.”
Server: gws
X-XSS-Protection: 1; mode=block
X-Frame-Options: SAMEORIGIN
Transfer-Encoding: chunked
Google(function(){
window.google={kEI:”VBzcUdWuHOmtiQf64IHoCw”,getEI:function(a){for(var b;a&&(!a.getAttribute||!(b=a.getAttribute(“eid”)));
……
这里可以看到结果中header和body信息是在一起的,那么如何分离它们呢。方法有二种,一是通过curl自带的curl_getinfo()方法获取头的长度,然后使用substr来分割字符串。示例代码如下:

$response = curl_exec($ch);
if (curl_getinfo($ch, CURLINFO_HTTP_CODE) == ‘200’) {
$headerSize = curl_getinfo($ch, CURLINFO_HEADER_SIZE);
$header = substr($response, 0, $headerSize);
$body = substr($response, $headerSize);
}
第二种方法基于header和body是通过两个回车换行来分割的,所以可以通过如下代码实现:

$response = curl_exec($ch);
if (curl_getinfo($ch, CURLINFO_HTTP_CODE) == ‘200’) {
list($header, $body) = explode(“\r\n\r\n”, response, 2);
}

python 各种加密

背景
加密学习
对称加密
对称密钥加密 , 又叫私钥加密。即信息发送的方和接受方用一个密钥去加密和揭秘数据。 最大的优势是 加解密速度快,适合对大量数据进行加密, 对称加密的缺点是密钥的管理和分配, 换句话说就是 如何把密钥发送到需要解密你的消息的人手里的问题。在发送密钥的过程中, 密钥有很大的风险被黑客拦截。 现实中的做法是将对称加密的密钥进行非对称加密然后传给需要他的人。
非对称加密
非对称加密系统, 又称公钥密钥加密。 非对称加密为数据的加密与解密提供了一种非常安全的方式。她使用了一对密钥, 私钥和公钥。 私钥只能有一方安全保管, 不能外泄, 而公钥可以发给任何请求她的人。非对称加密使用这对密钥中的一个进行加密, 而解密却需要一个另外一个密钥。 比如你去银行 你向银行请求公钥,银行将公钥发给你,你使用公钥对消息加密,那么只有私钥的持有人–银行才能对你的消息解密。 与对称加密的不同之处是, 银行不需要将私钥通过网络发送出去。因此安全性大大提高。 目前最常用的非对称加密算法是RSA算法。公钥机制灵活,但加密和解密速度却比对称密钥加密慢得多。 公钥机制灵活, 但是加密和解密速度却要比堆成加密慢很多。
1) Alice需要在银行的网站做一笔交易,她的浏览器首先生成了一个随机数作为对称密钥。
(2) Alice的浏览器向银行的网站请求公钥。
(3) 银行将公钥发送给Alice。
(4) Alice的浏览器使用银行的公钥将自己的对称密钥加密。
(5) Alice的浏览器将加密后的对称密钥发送给银行。
(6) 银行使用私钥解密得到Alice浏览器的对称密钥。
(7) Alice与银行可以使用对称密钥来对沟通的内容进行加密与解密了。
加密1
(三)总结
(1) 对称加密加密与解密使用的是同样的密钥,所以速度快,但由于需要将密钥在网络传输,所以安全性不高。
(2) 非对称加密使用了一对密钥,公钥与私钥,所以安全性高,但加密与解密速度慢。
(3) 解决的办法是将对称加密的密钥使用非对称加密的公钥进行加密,然后发送出去,接收方使用私钥进行解密得到对称加密的密钥,然后双方可以使用对称加密来进行沟通。

base64 加密
python3 输入的都是 二进制 byte类型
注意:用于base64编码的,要么是ASCII包含的字符,要么是二进制数据
base64 是对称加密

base64 的加密和解密
———————–我是华丽的分界线,以下是代码————————–
import base64

s = ‘hello, world’
s = “你好”
# 加密
bs = base64.b64encode(s.encode(“utf8”))
print(bs)

# 解密
decode = base64.b64decode(bs)
print(decode)
print(decode.decode(“utf8”))
————————-我是华丽的分界线,以上是代码————————–
base64 是 一种用64 个字符来表示任意的二进制数据的方法。base64 可以成为密码学的基石。可以将任意二进制数据进行Base64 编码。 所有的数据都能被编码为并只有64个字符就能表示的文本文件。( 64字符:A~Z a~z 0~9 + / )编码后的数据~=编码前数据的4/3,会大1/3左右。
Base64编码的原理
加密2

1 将所有字符转化为ASCII码。
2 将ASCII码转化为8位二进制 。
3 将二进制3个归成一组(不足3个在后边补0)共24位,再拆分成4组,每组6位。
4 统一在6位二进制前补两个0凑足8位。
5 将补0后的二进制转为十进制。
6 从Base64编码表获取十进制对应的Base64编码。

Base64编码的说明

1 转换的时候,将三个byte的数据,先后放入一个24bit的缓冲区中,先来的byte占高位。
2 数据不足3byte的话,于缓冲区中剩下的bit用0补足。然后,每次取出6个bit,按照其值选择查表选择对应的字符作为编码后的输出。
3 不断进行,直到全部输入数据转换完成。
4 如果最后剩下两个输入数据,在编码结果后加1个“=”。
5 如果最后剩下一个输入数据,编码结果后加2个“=”。
6 如果没有剩下任何数据,就什么都不要加,这样才可以保证资料还原的正确性。

MD5
由于MD5模块在python3中被移除,在python3中使用hashlib模块进行md5操作
——————-我是华丽的分界线,以下是代码—————————–
import hashlib

str = “我真帅”

# 创建一个md5 对象
h1 = hashlib.md5()
# 此处必须声明encode
# 若写法为hl.update(str) 报错为: Unicode-objects must be encoded before hashing
h1.update(str.encode())
print(“加密前”, str)
print(“加密后”, h1.hexdigest())
——————–我是华丽的分界线,以上是代码——————————
sha1 加密
——————–我是华丽的分界线,以下是代码——————————
import hashlib
def str_encrypt(str):
“””
使用sha1加密算法,返回str加密后的字符串
“””
sha = hashlib.sha1(str)
encrypts = sha.hexdigest()
return encrypts
———————–我是华丽的分界线,以上是代码—————————-
简介
message-digest algorithm 5(信息-摘要算法)。经常说的“MD5加密”,就是它→信息-摘要算法。

md5,其实就是一种算法。可以将一个字符串,或文件,或压缩包,执行md5后,就可以生成一个固定长度为128bit的串。这个串,基本上是唯一的。

不可逆性
每个人都有不同的指纹,看到这个人,可以得出他的指纹等信息,并且唯一对应,但你只看一个指纹,是不可能看到或读到这个人的长相或身份等信息。

特点

1 压缩性:任意长度的数据,算出的MD5值长度都是固定的。
2 容易计算:从原数据计算出MD5值很容易。
3 抗修改性:对原数据进行任何改动,哪怕只修改1个字节,所得到的MD5值都有很大区别。
4 强抗碰撞:已知原数据和其MD5值,想找到一个具有相同MD5值的数据(即伪造数据)是非常困难的。

MD5长度

md5的长度,默认为128bit,也就是128个0和1的二进制串。这样表达是很不友好的。所以将二进制转成了16进制,每4个bit表示一个16进制,所以128/4 = 32 换成16进制表示后,为32位了。

为什么网上还有md5是16位的呢?

其实16位的长度,是从32位md5值来的。是将32位md5去掉前八位,去掉后八位得到的。

DES

Python加密库PyCryptodome
PyCrytodome 取代了 PyCrypto 。
安装与导入
Windows安装之前需要先安装Microsoft Visual c++ 2015。

下载地址:https://www.microsoft.com/en-us/download/details.aspx?id=48145

在Linux上安装,可以使用以下 pip 命令:
pip install pycryptodome
import Crypto

在Windows 系统上安装则稍有不同:
pip install pycryptodomex
import Cryptodome

DES算法为密码体制中的对称密码体制,又被称为美国数据加密标准。

DES是一个分组加密算法,典型的DES以64位为分组对数据加密,加密和解密用的是同一个算法。

DES算法的入口参数有三个:Key、Data、Mode。其中Key为7个字节共56位,是DES算法的工作密钥;Data为8个字节64位,是要被加密或被解密的数据;Mode为DES的工作方式,有两种:加密或解密。

密钥长64位,密钥事实上是56位参与DES运算(第8、16、24、32、40、48、56、64位是校验位,使得每个密钥都有奇数个1),分组后的明文组和56位的密钥按位替代或交换的方法形成密文组。

加密原理
DES 使用一个 56 位的密钥以及附加的 8 位奇偶校验位,产生最大 64 位的分组大小。这是一个迭代的分组密码,使用称为 Feistel 的技术,其中将加密的文本块分成两半。使用子密钥对其中一半应用循环功能,然后将输出与另一半进行“异或”运算;接着交换这两半,这一过程会继续下去,但最后一个循环不交换。DES 使用 16 个循环,使用异或,置换,代换,移位操作四种基本运算。

算法步骤
1)初始置换
其功能是把输入的64位数据块按位重新组合,并把输出分为L0、R0两部分,每部分各长3 2位,其置换规则为将输入的第58位换到第一位,第50位换到第2位……依此类推,最后一位是原来的第7位。L0、R0则是换位输出后的两部分,L0是输出的左32位,R0是右32位,例:设置换前的输入值为D1D2D3……D64,则经过初始置换后的结果为:L0=D58D50……D8;R0=D57D49……D7。
其置换规则见下表:
58,50,42,34,26,18,10,2,60,52,44,36,28,20,12,4,
62,54,46,38,30,22,14,6,64,56,48,40,32,24,16,8,
57,49,41,33,25,17,9,1,59,51,43,35,27,19,11,3,
61,53,45,37,29,21,13,5,63,55,47,39,31,23,15,7,
2)逆置换
经过16次迭代运算后,得到L16、R16,将此作为输入,进行逆置换,逆置换正好是初始置换的逆运算,由此即得到密文输出。
此算法是对称加密算法体系中的代表,在计算机网络系统中广泛使用.

加密和解密的过程
——————-我是华丽的分界线,以下是代码—————————–
from Cryptodome.Cipher import DES

key = b’abcdefgh’ # 密钥 8位或16位,必须为bytes
def pad(text):
“””
# 加密函数,如果text不是8的倍数【加密文本text必须为8的倍数!】,那就补足为8的倍数
:param text:
:return:
“””
while len(text) % 8 != 0:
text += ‘ ‘
return text

des = DES.new(key, DES.MODE_ECB) # 创建一个DES实例
text = ‘Python rocks!’
padded_text = pad(text)
encrypted_text = des.encrypt(padded_text.encode(‘utf-8’)) # 加密
print(encrypted_text)
# rstrip(‘ ‘)返回从字符串末尾删除所有字符串的字符串(默认空白字符)的副本
plain_text = des.decrypt(encrypted_text).decode().rstrip(‘ ‘) # 解密
print(plain_text)
———————我是华丽的分界线,以下是代码—————————
from Cryptodome.Cipher import DES
import binascii

# 这是密钥
key = b’abcdefgh’
# 需要去生成一个DES对象
des = DES.new(key, DES.MODE_ECB)
# 需要加密的数据
text = ‘python spider!’
text = text + (8 – (len(text) % 8)) * ‘=’
# 加密的过程
encrypto_text = des.encrypt(text.encode())
# 加密过后二进制转化为ASCII
encrypto_text = binascii.b2a_hex(encrypto_text)
print(encrypto_text)
# 解密需要ASCII 先转化为二进制 然后再进行解密
plaint = des.decrypt(binascii.a2b_hex(encrypto_text))
print(plaint)

———————我是华丽的分界线,以上是代码—————————
3DES
简介

3DES(或称为Triple DES)是三重数据加密算法(TDEA,Triple Data Encryption Algorithm)块密码的通称。它相当于是对每个数据块应用三次DES加密算法。

由于计算机运算能力的增强,原版DES密码的密钥长度变得容易被暴力破解。3DES即是设计用来提供一种相对简单的方法,即通过增加DES的密钥长度来避免类似的攻击,而不是设计一种全新的块密码算法。

3DES(即Triple DES)是DES向AES过渡的加密算法(1999年,NIST将3-DES指定为过渡的加密标准),加密算法,其具体实现如下:设Ek()和Dk()代表DES算法的加密和解密过程,K代表DES算法使用的密钥,M代表明文,C代表密文,这样:

3DES加密过程为:C=Ek3(Dk2(Ek1(M)))

3DES解密过程为:M=Dk1(EK2(Dk3(C)))

AES
简介

高级加密标准(英语:Advanced Encryption Standard,缩写:AES),在密码学中又称Rijndael加密法,是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES,已经被多方分析且广为全世界所使用。经过五年的甄选流程,高级加密标准由美国国家标准与技术研究院(NIST)于2001年11月26日发布于FIPS PUB 197,并在2002年5月26日成为有效的标准。2006年,高级加密标准已然成为对称密钥加密中最流行的算法之一。

AES在软件及硬件上都能快速地加解密,相对来说较易于实作,且只需要很少的存储器。作为一个新的加密标准,目前正被部署应用到更广大的范围。
特点与思想
1,抵抗所有已知的攻击。
2,在多个平台上速度快,编码紧凑。
3,设计简单。

加密3

AES为分组密码,分组密码也就是把明文分成一组一组的,每组长度相等,每次加密一组数据,直到加密完整个明文。在AES标准规范中,分组长度只能是128位,也就是说,每个分组为16个字节(每个字节8位)。密钥的长度可以使用128位、192位或256位。密钥的长度不同,推荐加密轮数也不同。

一般常用的是128位
———————我是华丽的分界线,以下是代码—————————
from Cryptodome.Cipher import AES
from Cryptodome import Random

from binascii import a2b_hex

# 要加密的明文
data = ‘南来北往’
# 密钥key必须为 16(AES-128), 24(AES-192), 32(AES-256)
key = b’this is a 16 key’
# 生成长度等于AES 块大小的不可重复的密钥向量
iv = Random.new().read(AES.block_size)
print(iv)
# 使用 key 和iv 初始化AES 对象, 使用MODE_CFB模式
mycipher = AES.new(key, AES.MODE_CFB, iv)
print(mycipher)
# 加密的明文长度必须为16的倍数, 如果长度不为16的倍数, 则需要补足为16的倍数
# 将iv(密钥向量)加到加密的密钥开头, 一起传输
ciptext = iv + mycipher.encrypt(data.encode())
# 解密的话需要用key 和iv 生成的AES对象
print(ciptext)
mydecrypt = AES.new(key, AES.MODE_CFB, ciptext[:16])
# 使用新生成的AES 对象, 将加密的密钥解密
decrytext = mydecrypt.decrypt(ciptext[16:])

print(decrytext.decode())
———————我是华丽的分界线,以上是代码—————————
RSA
非对称加密
典型的非对称加密
典型的如RSA等,常见方法,使用openssl ,keytools等工具生成一对公私钥对,使用被公钥加密的数据可以使用私钥来解密,反之亦然(被私钥加密的数据也可以被公钥解密) 。

在实际使用中私钥一般保存在发布者手中,是私有的不对外公开的,只将公钥对外公布,就能实现只有私钥的持有者才能将数据解密的方法。 这种加密方式安全系数很高,因为它不用将解密的密钥进行传递,从而没有密钥在传递过程中被截获的风险,而破解密文几乎又是不可能的。

但是算法的效率低,所以常用于很重要数据的加密,常和对称配合使用,使用非对称加密的密钥去加密对称加密的密钥。

简介
RSA加密算法是一种非对称加密算法。在公开密钥加密和电子商业中RSA被广泛使用。

该算法基于一个十分简单的数论事实:将两个大素数相乘十分容易,但那时想要对其乘积进行因式分解却极其困难,因此可以将乘积公开作为加密密钥,即公钥,而两个大素数组合成私钥。公钥是可发布的供任何人使用,私钥则为自己所有,供解密之用

而且,因为RSA加密算法的特性,RSA的公钥私钥都是10进制的,但公钥的值常常保存为16进制的格式,所以需要将其用int()方法转换为10进制格式。
————————我是华丽的分界线,以下是代码—————————

import rsa

# rsa加密
def rsaEncrypt(str):
# 生成公钥、私钥
(pubkey, privkey) = rsa.newkeys(512)
print(“pub: “, pubkey)
print(“priv: “, privkey)
# 明文编码格式
content = str.encode(‘utf-8’)
# 公钥加密
crypto = rsa.encrypt(content, pubkey)
return (crypto, privkey)

# rsa解密
def rsaDecrypt(str, pk):
# 私钥解密
content = rsa.decrypt(str, pk)
con = content.decode(‘utf-8’)
return con

(a, b) = rsaEncrypt(“hello”)
print(‘加密后密文:’)
print(a)
content = rsaDecrypt(a, b)
print(‘解密后明文:’)
print(content)
———————我是华丽的分界线,以下是代码—————————
import rsa
import binascii

def rsa_encrypt(rsa_n, rsa_e, message):
key = rsa.PublicKey(rsa_n, rsa_e)
message = rsa.encrypt(message.encode(), key)
message = binascii.b2a_hex(message)
return message.decode()

pubkey_n = ‘8d7e6949d411ce14d7d233d7160f5b2cc753930caba4d5ad24f923a505253b9c39b09a059732250e56c594d735077cfcb0c3508e9f544f101bdf7e97fe1b0d97f273468264b8b24caaa2a90cd9708a417c51cf8ba35444d37c514a0490441a773ccb121034f29748763c6c4f76eb0303559c57071fd89234d140c8bb965f9725’
pubkey_e = ‘10001’
rsa_n = int(pubkey_n, 16)
rsa_e = int(pubkey_e, 16)
message = ‘南北今天很忙’
print(“公钥n值长度:”, len(pubkey_n))

aa = rsa_encrypt(rsa_n, rsa_e, message)
print(aa)

———————我是华丽的分界线,以下是代码—————————
”’

RSA算法

”’

from Cryptodome.PublicKey import RSA

from Cryptodome.Cipher import PKCS1_OAEP, PKCS1_v1_5

class MyRSA():
def create_rsa_key(self, password):
“””

创建RSA密钥

步骤说明:

1、从 Crypto.PublicKey 包中导入 RSA,创建一个密码

2、生成 1024/2048 位的 RSA 密钥

3、调用 RSA 密钥实例的 exportKey 方法,传入密码、使用的 PKCS 标准以及加密方案这三个参数。

4、将私钥写入磁盘的文件。

5、使用方法链调用 publickey 和 exportKey 方法生成公钥,写入磁盘上的文件。

“””

key = RSA.generate(1024)

encrypted_key = key.exportKey(passphrase=password.encode(“utf-8″), pkcs=8,

protection=”scryptAndAES128-CBC”)

with open(“my_private_rsa_key.bin”, “wb”) as f:
f.write(encrypted_key)

with open(“my_rsa_public.pem”, “wb”) as f:
f.write(key.publickey().exportKey())

def encrypt(self, plaintext):
# 加载公钥

recipient_key = RSA.import_key(

open(“my_rsa_public.pem”).read()

)

cipher_rsa = PKCS1_v1_5.new(recipient_key)

en_data = cipher_rsa.encrypt(plaintext.encode(“utf-8”))

return en_data

# print(len(en_data), en_data)

def decrypt(self, en_data, password):
# 读取密钥

private_key = RSA.import_key(

open(“my_private_rsa_key.bin”).read(),

passphrase=password

)

cipher_rsa = PKCS1_v1_5.new(private_key)

data = cipher_rsa.decrypt(en_data, None)

return data

# print(data)

mrsa = MyRSA()

mrsa.create_rsa_key(‘123456’)

e = mrsa.encrypt(‘hello’)

d = mrsa.decrypt(e, ‘123456’)

print(e)

print(d)
———————我是华丽的分界线,以上是代码—————————