分享一个自己做的模块
本帖最后由 考不好不改名 于 2021-2-27 21:09 编辑不废话，代码如下：# 文档
'''
- 这个模块的作者·SYZ·于·公元2021年2月27日·学习了密码学的相关知识后开始制作这个·用以加解密·的模块，并于·当天· 竣工* 。
* 换字式密码部分开发存在困难，目前未竣工
- 作者希望被使用的 接口* 如下：
- KaiSa(s, n)
- aKaiSa(s, n)
- ZhaLan(s, n)
- aZhaLan(s, n)
- ZhuanZhi(s, n)
- aZhuanZhi(s, n)
- split(s, f, n, *i)
- allin(s, n)
- aallin(s, n)
* 更多帮助参见其文档
- 用以辅助模块制作的内容现可以被使用的 接口* 如下：
- mchr(n)
- get_list(lenth, seed = 5)
- class Square
- __init__(self, width, height, filler)
- test()
* 以上接口可能没有文档
- 可以正常使用的接口已全部列举，使用未列举的接口可能导致模块不可用。
——SYZ
'''
# 辅助函数
def mchr(n):
if n >= 0x110000:
return chr(n - 0x110000)
elif n < 0:
return chr(n + 0x110000)
else:
return chr(n)
def get_list(lenth, seed = 5):
r = []
import random as m
m.seed(seed)
l = tuple(range(lenth))
n = set()
for i in range(lenth):
while True:
t = m.choice(l)
if t in n:
continue
break
r +=
n.add(t)
return r
# 凯撒密码
def KaiSa(s, n):
'''
- KaiSa(s, n)
- 使用凯撒密码加密字符串s，以字符串返回密文，整数n表示将通用编码增大的长。
- 使用模块内aKaiSa函数解密。
'''
r = ''
for each in s:
r += mchr(ord(each) + n)
return r
def aKaiSa(s, n):
'''
- aKaiSa(s, n)
- 解密被模块内KaiSa函数加密的字符串s，以字符串返回明文，整数n是当初传给KaiSa函数的第二个参数。
'''
return KaiSa(s, -n)
# 栅栏密码
def ZhaLan(s, n):
'''
- ZhaLan(s, n)
- 使用栅栏密码加密字符串s，以字符串返回密文，整数n表示每组字符的个数。
- 使用模块内aZhaLan函数解密。
'''
r = ''
for i in range(n):
while True:
try:
r += s
except IndexError:
break
i += n
return r
class Square:
def __init__(self, width, height, filler):
self.width = width
self.height = height
self.dat = [ for i in range(height)]
def set_dat(self, pos, value):
self.dat]] = value
def get_dat(self, x, y):
return self.dat
def iter_x(self, x):
for y in range(self.height):
yield self.get_dat(x, y), (x, y)
def iter_y(self, y):
for x in range(self.width):
yield self.get_dat(x, y), (x, y)
def iter_by_right(self):
for y in range(self.height):
for x in range(self.width):
yield self.get_dat(x, y), (x, y)
def iter_by_down(self):
for x in range(self.width):
for y in range(self.height):
yield self.get_dat(x, y), (x, y)
def aZhaLan(s, n):
'''
- aZhaLan(s, n)
- 解密被模块内ZhaLan函数加密的字符串s，以字符串返回明文，整数n是当初传给ZhaLan函数的第二个参数。
'''
if len(s) % n:
r = ''
t = Square(n, len(s) // n + 1, '')
p = 0
i = t.iter_by_down()
for each in i:
if each == t.height - 1 and each >= len(s) % n:
continue
try:
t.set_dat(each, s)
except IndexError:
break
p += 1
i = t.iter_by_right()
for each in i:
r += each
return r
else:
return ZhaLan(s, n)
# 换字式密码
# 转置式密码
def ZhuanZhi(s, n):
'''
- ZhuanZhi(s, n)
- 使用转置式密码加密字符串s，以字符串返回密文，整数n表示随机的种子。
- 使用模块内aZhuanZhi函数解密。
'''
r = ''
l = get_list(len(s), n)
for i in l:
r += s
return r
def aZhuanZhi(s, n):
'''
- aZhuanZhi(s, n)
- 解密被模块内ZhuanZhi函数加密的字符串s，以字符串返回明文，整数n是当初传给ZhuanZhi函数的第二个参数。
'''
r = ''
d = {}
l = get_list(len(s), n)
for i in range(len(s)):
d] = i
for i in range(len(s)):
r += s[(d)]
return r
# 分割分别编译
def split(s, f, n, *i):
'''
- split(s, f, n, *i)
- 循环以收集参数i为步长分割字符串s，分别以分割后的各部分为第一个参数、整数n为第二个参数传给 函数f* 处理，返回各次处理所得字符串按顺序拼接的字符串。
* 应为模块内可用加解密函数，不保证非模块内可用加解密函数的运行结果
'''
while sum(i) < len(s):
i *= 2
while sum(i) > len(s):
i = i
if sum(i) != len(s):
i += (len(s) - sum(i),)
r = ''
p = 0
for each in i:
r += f(s, n)
p += each
return r
# 复合可用密码
def allin(s, n):
'''
- allin(s, n)
- 复合模块内全部可用加密函数* 加密字符串s，以字符串返回密文，整数n表示将传给各个子函数的第二个参数。
- 使用模块内aallin函数解密。
* 先后复合函数KaiSa、ZhaLan、ZhuanZhi
'''
return split(split(split(s, KaiSa, n, 5, 6, 7, 8, 9), \
ZhaLan, n, 5, 6, 7, 8, 9), \
ZhuanZhi, n, 5, 6, 7, 8, 9)
def aallin(s, n):
'''
- aallin(s, n)
- 解密被模块内allin函数加密的字符串s，以字符串返回明文，整数n是当初传给allin函数的第二个参数。
'''
return split(split(split(s, aZhuanZhi, n, 5, 6, 7, 8, 9), \
aZhaLan, n, 5, 6, 7, 8, 9), \
aKaiSa, n, 5, 6, 7, 8, 9)
# 模块测试
def test():
s = '中文字符 EnglishLetters 0123456789 ~!@#$%^&*()_+\n'
if s == aallin(allin(s, 5), 5):
return True
return False
if __name__ == '__main__':
if test():
print('Usual')
else:
print('Unusual')
页:
[1]