python加密解密
windows下使用AES时安装pycryptodome 模块，pip install pycryptodome
linux 下使用AES时安装pycrypto模块，pip install pycrypto
```
from Crypto.Cipherimport AES
from binasciiimport b2a_hex, a2b_hex
from Cryptoimport Random
import base64
import json
class AesEncry(object):
# aes秘钥 ，可根据自身需要手动生成
宴旁 key ="aes_keysaes_keysaes_keys"
def encrypt(self, data):
data = json.mps(data)
mode = AES.MODE_ECB
padding =lambda s: s + (16 -len(s) %16) *chr(16 -len(s) %16)
cryptos = AES.new(self.key.encode("utf-8"), mode)
cipher_text = cryptos.encrypt(padding(data).encode("utf-8"))
return base64.b64encode(cipher_text).decode("utf-8")
def decrypt(self, data):
cryptos = AES.new(self.key.encode("型祥握utf-8"), AES.MODE_ECB)
decrpytBytes = base64.b64decode(data)
卜庆 meg = cryptos.decrypt(decrpytBytes).decode('utf-8')
return meg[:-ord(meg[-1])]
aes_encry_util = AesEncry()
#明文
data ="mypwd_test"
#加密
encry_data = aes_encry_util.encrypt(data)
print(encry_data)
# 对密文进行解密
decry_data = aes_encry_util.decrypt(encry_data)
print(decry_data)
```
如上便完成了利用python进行AES的ECB加密
‘贰’ python3.6 AES 加密解密
本来以为这是个比较简单的东袜野西者梁，网上一搜一大把。搜索结告嫌喊果气的我自己看文档写了一个。
首先安装pycryptodome或者pycryptodomex 用pip 安装，安装之后需要修改包名crypto改为Crypto
我是采用ECB模式加密你也可以用其他模式加密，模式区别可以看这篇 https://www.cnblogs.com/liangxuehui/p/4651351.html 。
秘钥加密解密需要统一。
‘叁’ 如何使用Python进行Rijndael方式的加密解密
Rijndael,在高级加密标准（AES）中使用的基本密码算法。
概述 （美国）国家标准技术研究所（NIST）选择Rijndael作为美国政府加密标准（AES）的加密算法，AES取代早期的数据加密标准（DES）。Rijndael由比利时计算机科学家Vincent Rijmen和Joan Daemen开发，它可以使用128位，192位或者256位的密钥长度，使得它比56位的DES更健壮可靠。Rijndael也有一个非常小的版本（52位），合适用在蜂窝电话、个人数字处理器（PDA）和其他的小设备上。
近似读音：Rijn [rain] dael [del] (莱恩戴尔) Rijn 来源 Rhine [莱茵河]的荷兰语(Dutch)发音。
dael 是常用的人名 这词是两个科学家的名字各出一段拼成的。
Rijndael.h
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma once
#include <exception>
#include <string.h>
using namespace std;
class CRijndael
{
public:
enum { ECB=0, CBC=1, CFB=2 };
private:
enum { DEFAULT_BLOCK_SIZE=16 };
enum { MAX_BLOCK_SIZE=32, MAX_ROUNDS=14, MAX_KC=8, MAX_BC=8 };
static int Mul(int a, int b)
{
return (a != 0 && b != 0) ? sm_alog[(sm_log[a & 0xFF] + sm_log[b & 0xFF]) % 255] : 0;
}
static int Mul4(int a, char b[])
{
if(a == 0)
return 0;
a = sm_log[a & 0xFF];
int a0 = (b[0] != 0) ? sm_alog[(a + sm_log[b[0] & 0xFF]) % 255] & 0xFF : 0;
int a1 = (b[1] != 0) ? sm_alog[(a + sm_log[b[1] & 0xFF]) % 255] & 0xFF : 0;
int a2 = (b[2] != 0) ? sm_alog[(a + sm_log[b[2] & 0xFF]) % 255] & 0xFF : 0;
int a3 = (b[3] != 0) ? sm_alog[(a + sm_log[b[3] & 0xFF]) % 255] & 0xFF : 0;
return a0 << 24 | a1 << 16 | a2 << 8 | a3;
}
public:
CRijndael();
virtual ~CRijndael();
void MakeKey(char const* key, char const* chain,
int keylength=DEFAULT_BLOCK_SIZE, int blockSize=DEFAULT_BLOCK_SIZE);
private:
void Xor(char* buff, char const* chain)
{
if(false==m_bKeyInit)
throw exception(sm_szErrorMsg1);
for(int i=0; i<m_blockSize; i++)
*(buff++) ^= *(chain++);
}
void DefEncryptBlock(char const* in, char* result);
void DefDecryptBlock(char const* in, char* result);
public:
void EncryptBlock(char const* in, char* result);
void DecryptBlock(char const* in, char* result);
void Encrypt(char const* in, char* result, size_t n, int iMode=ECB);
void Decrypt(char const* in, char* result, size_t n, int iMode=ECB);
int GetKeyLength()
{
if(false==m_bKeyInit)
throw exception(sm_szErrorMsg1);
return m_keylength;
}
int GetBlockSize()
{
if(false==m_bKeyInit)
throw exception(sm_szErrorMsg1);
return m_blockSize;
}
int GetRounds()
{
if(false==m_bKeyInit)
throw exception(sm_szErrorMsg1);
return m_iROUNDS;
}
void ResetChain()
{
memcpy(m_chain, m_chain0, m_blockSize);
}
public:
static char const* sm_chain0;
private:
static const int sm_alog[256];
static const int sm_log[256];
static const char sm_S[256];
static const char sm_Si[256];
static const int sm_T1[256];
static const int sm_T2[256];
static const int sm_T3[256];
static const int sm_T4[256];
static const int sm_T5[256];
static const int sm_T6[256];
static const int sm_T7[256];
static const int sm_T8[256];
static const int sm_U1[256];
static const int sm_U2[256];
static const int sm_U3[256];
static const int sm_U4[256];
static const char sm_rcon[30];
static const int sm_shifts[3][4][2];
static char const* sm_szErrorMsg1;
static char const* sm_szErrorMsg2;
bool m_bKeyInit;
int m_Ke[MAX_ROUNDS+1][MAX_BC];
int m_Kd[MAX_ROUNDS+1][MAX_BC];
int m_keylength;
int m_blockSize;
int m_iROUNDS;
char m_chain0[MAX_BLOCK_SIZE];
char m_chain[MAX_BLOCK_SIZE];
int tk[MAX_KC];
int a[MAX_BC];
int t[MAX_BC];
};
‘肆’ 利用以下python代码编写栏栅加密和解密
修改后运行结果:
a. 加密
1.进行栅栏加密
2.进行栅栏解密
请选择: 1
请输入分组数目 2
请输入列排编号 21
请输明文 abcdefgh
b a
d c
f e
h g
b. 解密
1.进行栅栏加密
2.进行栅栏解密
请选择: 2
请输入分组数目 2
请输入列排编号 21
请输密文 b a d c f e h g
abcdefgh
修改后的代码:
def Encrypt(n,col,M):
row=len(M)/n
if len(M)%n>0:
row+=1
arr=[[""for x in range(0,n)] for y in range(0,row)]
x=0
for i in range(0,row):
for j in range(0,n):
if x<len(M):
arr[i][j]=M[x]
#print M[x],
x+=1
#print "\r\n"
for i in range(0,row):
for j in range(0,n):
m=int(col[j])-1
print arr[i][m],
print "\r\n"
def Decrypt(n, col, C):
C="".join(C.split())
row=len(C)/n
if len(C)%n>0:
row+=1
arr=[[""for x in range(0,n)] for y in range(0,row)]
x=0
for i in range(0,row):
for j in range(0,n):
if x<len(C):
arr[i][j]=C[x]
#print C[x],
x+=1
#print "\r\n"
M=""
for i in range(0,row):
for j in range(0,n):
m=int(col[j])-1
#print arr[i][m],
M+=arr[i][m]
#print "\r\n"
print M
print u"1.进行栅栏加密\r\n2.进行栅栏解密\r\n请选择:".encode("gb2312"),
sel=raw_input()
if int(sel)==1:
print u"请输入分组数目".encode("gb2312"),
n=int(raw_input())
print u"请输入列排编号".encode("gb2312"),
col=raw_input()
print u"请输明文".encode("gb2312"),
M=raw_input()
while len(M)<n*3:
print u"明文必须是分组数目的3倍".encode("gb2312")
M=raw_input()
Encrypt(n,col,M)
else :
print u"请输入分组数目".encode("gb2312"),
n=int(raw_input())
print u"请输入列排编号".encode("gb2312"),
col=raw_input()
print u"请输密文".encode("gb2312"),
C=raw_input()
while len(C)<n*3:
print u"密文必须是分组数目的3倍".encode("gb2312")
C=raw_input()
Decrypt(n,col,C)
‘伍’ python 写异或加密
from random import seed,randint
str_in=input('请输入一个字符串：')
you_seed=input('请输入密码：')
you_seed=int(you_seed)
#lock
def my_lock(lock_str,lock_seed):
seed(lock_seed)
li_out=[]
for i in lock_str:
li_out.append(chr(ord(i)^randint(0,65535)))
return ''.join(li_out)
my_lock_str=my_lock(str_in,you_seed)
print('原字符串：',str_in)
print('加密字符串：',my_lock_str)
print('还原后字符串：',my_lock(my_lock_str,you_seed))
input()
#python 3.4
‘陆’ Python编程实现加密解密读取文件
对Python加密时可能会有两种形式，一种是对Python转成的exe进行保护，另一种是直接对.py或者.pyc文件进行保护，下面将列举两种形式的保护流程。
1、对python转exe加壳
下载最新版VirboxProtector加壳工具，使用加壳工具直接对demo.exe进行加壳操作
2、对.py/.pyc加密
第一步，使用加壳工具对python安装目录下的python.exe进行加壳，将python.exe拖入到加壳工具VirboxProtector中，配置后直接点击加壳。
第二步，对.py/.pyc进行加密，使用DSProtector对.py/.pyc进行保护。
安全技术：
l虚拟机外壳：精锐5的外壳保护工具，创新性的引入了预分析和自动优化引擎，有效的解决了虚拟化保护代码时的安全性和性能平衡问题。
l碎片代码执行：利用自身成熟的外壳中的代码提取技术，抽取大量、大段代码，加密混淆后在安全环境中执行，最大程度上减少加密锁底层技术和功能的依赖，同时大量大段地移植又保证了更高的安全性。
lVirbox加密编译引擎：集编译、混淆等安全功能于一身，由于在编译阶段介入，可优化空间是普遍虚拟化技术无法比拟的，对代码、变量的混淆程度也有了根本的提升。
l反黑引擎：内置R0级核心态反黑引擎，基于黑客行为特征 的（反黑数据库）反制手段。精准打击调试、注入、内存修改等黑客行为，由被动挨打到主动防护。
加密效果：
加密之前
以pyinstall 的打包方式为例，使用pyinstxtractor.py文件对log_322.exe进行反编译，执行后会生成log_322.exe_extracted文件夹，文件夹内会生成pyc文件。
成功之后会在同目录下生成一个文件夹
‘柒’ 求python中的恺撒密码的加密，解密，以及破解的程序
凯撒密码作为一种最为古老的对称加密体制，在古罗马的时候都已经很流行，他的基本思想是：通过把字母移动一定的位数来实现加密和解密。明文中的所有字母都在字母表上向后（或向前）按照一个固定数目进行偏移后被替换成密文。例如，当偏移量是3的时候，所有的字母A将被替换成D，B变成E，以此类推X将变成A，Y变成B，Z变成C。由此可见，位数就是凯撒密码加密和解密的密钥。
如下代码是以偏移量为13展开计算的。123
源代码如下：
sr1="abcdefghijklmnopqrstuvwxyz"sr2=sr1.upper()
sr=sr1+sr1+sr2+sr2
st="The Zen of Python"sResult=""for j in st: if j==" ":
sResult = sResult +" "
continue
i=sr.find(j) if(i>-1):
sResult=sResult+sr[i+13]print sResult12345678910111213
运行结果为：
Gur Mra bs Clguba