script (2).py

# Now let's create the secure messaging system
import base64
from cryptography.fernet import Fernet
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
import os
import json
from datetime import datetime

class SecureMessenger:
    def __init__(self, password):
        """Initialize the messenger with a password-derived key"""
        self.password = password.encode()
        self.key = self._derive_key(self.password)
        self.cipher_suite = Fernet(self.key)
    
    def _derive_key(self, password):
        """Derive encryption key from password"""
        salt = b'stable_salt_for_demo'  # In production, use random salt per user
        kdf = PBKDF2HMAC(
            algorithm=hashes.SHA256(),
            length=32,
            salt=salt,
            iterations=100000,
        )
        key = base64.urlsafe_b64encode(kdf.derive(password))
        return key
    
    def encrypt_message(self, message):
        """Encrypt a plaintext message"""
        try:
            encrypted_message = self.cipher_suite.encrypt(message.encode())
            # Encode to base64 for easier transmission/storage
            return base64.urlsafe_b64encode(encrypted_message).decode()
        except Exception as e:
            return f"Encryption error: {str(e)}"
    
    def decrypt_message(self, encrypted_message):
        """Decrypt an encrypted message"""
        try:
            # Decode from base64
            encrypted_data = base64.urlsafe_b64decode(encrypted_message.encode())
            decrypted_message = self.cipher_suite.decrypt(encrypted_data)
            return decrypted_message.decode()
        except Exception as e:
            return f"Decryption error: {str(e)}"
    
    def create_message_package(self, message, sender_name):
        """Create a complete message package with metadata"""
        encrypted_msg = self.encrypt_message(message)
        package = {
            "sender": sender_name,
            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
            "encrypted_message": encrypted_msg
        }
        return json.dumps(package, indent=2)
    
    def read_message_package(self, package_json):
        """Read and decrypt a message package"""
        try:
            package = json.loads(package_json)
            decrypted_msg = self.decrypt_message(package["encrypted_message"])
            
            return {
                "sender": package["sender"],
                "timestamp": package["timestamp"],
                "message": decrypted_msg
            }
        except Exception as e:
            return f"Package reading error: {str(e)}"

# Demo the encryption system
print("=== Secure Messenger Demo ===\n")

# Create messenger instances for two users with the same password
password = "MySecretPassword123!"
alice_messenger = SecureMessenger(password)
bob_messenger = SecureMessenger(password)

# Alice sends a message
original_message = "Hello Bob! This is a secret message. Meet me at the cafe at 3 PM."
print(f"Original message from Alice: {original_message}\n")

# Create encrypted message package
encrypted_package = alice_messenger.create_message_package(original_message, "Alice")
print(f"Encrypted message package:\n{encrypted_package}\n")

# Bob receives and decrypts the message
decrypted_package = bob_messenger.read_message_package(encrypted_package)
print(f"Decrypted message received by Bob:")
print(f"From: {decrypted_package['sender']}")
print(f"Time: {decrypted_package['timestamp']}")
print(f"Message: {decrypted_package['message']}\n")

# Test with wrong password
print("=== Testing with wrong password ===")
wrong_messenger = SecureMessenger("WrongPassword")
failed_decrypt = wrong_messenger.read_message_package(encrypted_package)
print(f"Decryption with wrong password: {failed_decrypt}")