Installieren Sie zuerst die Bibliothek
pip install pycrypto
Anfangsvektor (16 Bytes), Schlüssel Bei Verwendung von + α PBKDF wird auch ein Kennwort zum Generieren eines abgeleiteten Schlüssels erstellt. .Verschlüsselung → Binärdaten können erstellt werden Konvertieren Sie Binärdaten (verschlüsselte Daten) in Base64 oder eine Hexadezimalzahl, konvertieren Sie sie in eine URL-codierte Form und senden Sie sie an den Server
.URL-Dekodierung Konvertierung von Base64- und Hexadezimalzahlen in Binärzahlen Bereiten Sie denselben Anfangsvektor, Schlüssel usw. wie die verschlüsselte Seite vor. Anstatt den Anfangsvektor als festen Wert zu haben, ist es sicherer, jedes Mal einen anderen durch ein Verfahren zu erzeugen, das nur die Verschlüsselungs- und die Entschlüsselungsseite kennen können. Zusammengesetzt
Bereiten Sie den Anfangsvektor, das Salz und das Passwort vor. Es wird empfohlen, den Anfangsvektor jedes Mal zufällig zu generieren und nicht als festen Wert.
Hier wird als Beispiel der Anfangsvektor auf den aktuellen Zeitstempel verdaut → hexadezimal angezeigt → sha512. Ich dachte über die Generierungsmethode nach, um den gesamten Fluss zu erfassen.
*** Bitte verwenden Sie den ursprünglichen Vektor, das Salz und das Passwort nicht so wie sie sind. *** ***
# -*- coding: utf-8 -*-
import base64
import urllib.parse
from Crypto.Cipher import AES
from Crypto.Protocol.KDF import PBKDF2
from Crypto.Util import Padding
import requests
from datetime import datetime,timedelta,timezone
import hashlib
#Erstellen eines Anfangsvektors(Ich dachte über die Generierungsmethode nach, als hätte ich sie für sha512 verwendet.)Da es in einen hexadezimalen Bytetyp konvertiert wird, sollte die Anzahl der Zeichen gerade sein.
JST = timezone(timedelta(hours=9),"JST")
now = hex(int(datetime.now(JST).timestamp()))
hs = hashlib.sha512(now.encode()).hexdigest()
hex_iv = hs[0:100]
#Da es in den hexadezimalen Byte-Typ Salt konvertiert wird, sollte die Anzahl der Zeichen gerade sein.
hex_salt = "39ccc779ab356eb43b4f37aedbc891d2f891756710b7856d21a2fd691483fb17"
secret_key = "asd@dfdfdsds"
def encrypt(plainText):
#Die Länge des Anfangsvektors muss 16 Bytes betragen
iv = bytes.fromhex(hex_iv)[:AES.block_size]
#Anzahl der Strecken Je größer diese Anzahl ist, desto stärker ist die Verschlüsselungsstärke und desto langsamer ist die Ausführungsgeschwindigkeit der Verschlüsselung / Entschlüsselung.
secure_levels = 100
#Es gibt keine besonderen Einschränkungen hinsichtlich der Salzlänge
salt = bytes.fromhex(hex_salt)
#Abgeleitete Schlüsselgenerierung Bei AES beträgt die Schlüssellänge 16 Byte(AES-128), 24 bytes(AES-192), 32bytes(AES-256)Muss einer von sein
key = PBKDF2(password=secret_key, salt=salt, dkLen=16, count=secure_levels)
#Erstellung von Chiffren
cipher = AES.new(key, AES.MODE_CBC, iv)
#Polsterung
data = plainText.encode()
padding = AES.block_size - len(data) % AES.block_size
data += (chr(padding) * padding).encode()
#Verschlüsselung
encrypted = cipher.encrypt(data)
print(f"encrypted = {encrypted}\n")
#binary to HEX
hex_data = encrypted.hex()
print(f"hex_data : binary to HEX = {hex_data}\n")
#Base64-Codierung
base64_encoded = base64.b64encode(hex_data.encode())
print(f"base64_encoded : Hex to Base64 = {base64_encoded.decode()}\n")
#URL-Codierung Diesmal nicht erforderlich, aber bei Bedarf URL-Codierung
# url_encoded = urllib.parse.quote(base64_encoded)
return base64_encoded
if __name__ == "__main__":
plainText = "Testen Sie die Verschlüsselung."
print(f"\nPlain text = {plainText}\n")
#Verschlüsselung
encrypted = encrypt(plainText)
#Senden
requests.get("http://localhost:5000/get",params={"text" : encrypted,"now" : now})
# -*- coding: utf-8 -*-
import base64
import json
import urllib.parse
from Crypto.Cipher import AES
from Crypto.Protocol.KDF import PBKDF2
from Crypto.Util import Padding
from flask import Flask, render_template, request
import hashlib
app = Flask(__name__)
#Salz hexadezimale Zahl. Da es in den Bytetyp konvertiert wird, sollte die Anzahl der Zeichen gerade sein
hex_salt = "39ccc779ab356eb43b4f37aedbc891d2f891756710b7856d21a2fd691483fb17"
secret_key = "asd@dfdfdsds"
def decrypt(base64encoded_value,now):
#URL-Dekodierung Diesmal nicht erforderlich, aber URL-Dekodierung jederzeit, falls in anderen Sprachen usw. erforderlich.
# url_decoded = urllib.parse.unquote(base64encoded_value)
# print(f"url_decoded = {url_decoded}")
#Base64-Decodierung
hex_data = base64.b64decode(base64encoded_value).decode()
print(f"hex_data : Base64 to Hex = {hex_data}\n")
# HEX → binary
encrypted_data = bytes.fromhex(hex_data)
print(f"encrypted_data : Hex to binary = {encrypted_data}\n")
#Die Länge des Anfangsvektors muss 16 Bytes betragen
hs = hashlib.sha512(now.encode()).hexdigest()
hex_iv = hs[0:100]
iv = bytes.fromhex(hex_iv)[:AES.block_size]
#Anzahl der Strecken Je größer diese Anzahl ist, desto stärker ist die Verschlüsselungsstärke und desto langsamer ist die Ausführungsgeschwindigkeit der Verschlüsselung / Entschlüsselung.
secure_levels = 100
#Es gibt keine besonderen Einschränkungen hinsichtlich der Salzlänge
salt = bytes.fromhex(hex_salt)
#Abgeleitete Schlüsselgenerierung
key = PBKDF2(password=secret_key, salt=salt, dkLen=16, count=secure_levels)
#Erstellung von Chiffren
cipher = AES.new(key, AES.MODE_CBC, iv)
#Verbund
decrypted = cipher.decrypt(encrypted_data)
#Unpadding
response = decrypted[0: -int(decrypted[-1])].decode('utf-8')
return response
#Parameter abrufen Get
@app.route('/get')
def get():
text = ""
if "text" not in request.args or "now" not in request.args:
return json.dumps({"message": "send message"})
base64encoded_value = request.args.get('text')
now = request.args.get('now')
print(f"\nbase64encoded_value = {base64encoded_value}\n")
#Entschlüsselung
decrypted_data = decrypt(base64encoded_value,now)
print(f"decrypted_data = {decrypted_data}\n")
return json.dumps({"message": "OK"})
if __name__ == "__main__":
app.run(host='0.0.0.0',port=5000)
Recommended Posts