from Crypto.Cipher import DES
from Crypto.Random import get_random_bytes

# 鍵を生成
key = get_random_bytes(8)

# データを暗号化する関数
def encrypt_data(data, key):
    cipher = DES.new(key, DES.MODE_ECB)
    padded_data = data + b"\0" * (8 - len(data) % 8)
    encrypted_data = cipher.encrypt(padded_data)
    return encrypted_data

# データを復号化する関数
def decrypt_data(encrypted_data, key):
    cipher = DES.new(key, DES.MODE_ECB)
    decrypted_data = cipher.decrypt(encrypted_data)
    return decrypted_data.rstrip(b"\0")

# データ
data = b"otupy"

# 暗号化
encrypted_data = encrypt_data(data, key)
print("暗号化されたデータ:", encrypted_data)

# 復号化
decrypted_data = decrypt_data(encrypted_data, key)
print("復号化されたデータ:", decrypted_data.decode())

from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes

# 鍵を生成
key = get_random_bytes(16)

# データを暗号化する関数
def encrypt_data(data, key):
    cipher = AES.new(key, AES.MODE_ECB)
    padded_data = data + b"\0" * (16 - len(data) % 16)
    encrypted_data = cipher.encrypt(padded_data)
    return encrypted_data

# データを復号化する関数
def decrypt_data(encrypted_data, key):
    cipher = AES.new(key, AES.MODE_ECB)
    decrypted_data = cipher.decrypt(encrypted_data)
    return decrypted_data.rstrip(b"\0")

# データ
data = b"otupy"

# 暗号化
encrypted_data = encrypt_data(data, key)
print("暗号化されたデータ:", encrypted_data)

# 復号化
decrypted_data = decrypt_data(encrypted_data, key)
print("復号化されたデータ:", decrypted_data.decode())

from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives import hashes

# 秘密鍵の生成
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048
)
# 公開鍵
public_key = private_key.public_key()

# データを暗号化する関数
def encrypt_data(data, public_key):
    encrypted_data = public_key.encrypt(
        data,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label=None
        )
    )
    return encrypted_data

# データを復号化する関数
def decrypt_data(encrypted_data, private_key):
    decrypted_data = private_key.decrypt(
        encrypted_data,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label=None
        )
    )
    return decrypted_data

# データ
data = b"otupy"

# 暗号化
encrypted_data = encrypt_data(data, public_key)
print("暗号化されたデータ:", encrypted_data)

# 復号化
decrypted_data = decrypt_data(encrypted_data, private_key)
print("復号化されたデータ:", decrypted_data.decode())

import hashlib

# データをハッシュ化する関数
def hash_data(data):
    hash_object = hashlib.sha256()
    hash_object.update(data)
    hash_value = hash_object.hexdigest()
    return hash_value

# データ
data = b"otupy"

# ハッシュ値を計算
hashed_value = hash_data(data)
print("計算されたSHA-256ハッシュ値:", hashed_value)

import numpy as np
from qiskit import Aer, QuantumCircuit, transpile, assemble
from qiskit.circuit.library import QFT
from qiskit.visualization import plot_histogram
from math import gcd
from numpy.random import randint

def a_to_the_power_mod(a, power, N):
    result = 1
    for _ in range(power):
        result = (result * a) % N
    return result

def qpe_amod15(a):
    # 位相推定に使用する量子ビットの数
    n_count = 8
    # 量子回路を初期化
    qc = QuantumCircuit(4 + n_count, n_count)
    
    for q in range(n_count):
        qc.h(q)
    qc.x(3 + n_count)
    
    for q in range(n_count):
        # 各位相推定用の量子ビットに対して、逆量子フーリエ変換 QFT を適用
        qc.append(QFT(num_qubits=n_count, inverse=True).to_gate(), range(n_count))
        # a_to_the_power_mod 関数を使用してモジュラエクスポネンシエーションを計算し、その結果を量子回路に追加
        qc.append(a_to_the_power_mod(a, 2**q, 15), [q + n_count, n_count + 1, n_count + 2, n_count + 3])
    # 全ての位相推定用の量子ビットに対して再度逆量子フーリエ変換 QFT を適用
    qc.append(QFT(num_qubits=n_count, inverse=True).to_gate(), range(n_count))
    qc.measure(range(n_count), range(n_count))

    # Aer シミュレーターを使用して量子回路をシミュレーションし、結果を取得
    aer_sim = Aer.get_backend('qasm_simulator')
    t_qc = transpile(qc, aer_sim)
    qobj = assemble(t_qc)
    result = aer_sim.run(qobj).result()
    # 測定結果のカウントを返す
    counts = result.get_counts()
    return counts

N = 15
a = 7
counts = qpe_amod15(a)
plot_histogram(counts)

タグ ：

#Python

#プログラミング

#暗号

#量子コンピューター