Secure Chat Application — True End-to-End Encryption (AES + RSA)

1. Introduction

The Secure Chat Application Using End-to-End Encryption is a Python-based communication system for private messaging. It applies AES to encrypt messages on the sender’s device and uses RSA to share session keys securely. With authentication, key exchange, and a simple GUI, it prevents interception and unauthorized access while keeping chat responsive and lightweight.

2. Existing System vs Proposed System

3. Working

1. User Authentication: User logs in/creates account.
2. Key Generation: Per-user RSA keypair (public/private).
3. Session Setup: Sender encrypts a new AES key with recipient’s RSA public key.
4. Message Encryption: Each message encrypted with the AES session key.
5. Decryption: Recipient uses RSA private key to unwrap AES key, then decrypts messages.
6. Secure Communication: Server relays ciphertext only.

4. Technology Stack

• Language: Python
• Libraries: socket, threading, tkinter, PyCryptodome, base64
• Algorithms: AES (message), RSA (key exchange)
• Framework: Flask or socket-based real-time server
• Database: SQLite3 or JSON user records
• Security: Session auth, endpoint encryption/decryption

5. Modules

6. Advantages

• Strong E2EE keeps messages confidential
• Server and admins can’t read chats
• Efficient crypto suitable for real-time use
• Supports text, files, and attachments
• Scalable to groups/multi-user rooms

7. Applications

• Confidential personal/business chat
• Corporate/government secure comms
• Private academic/research discussions
• Enterprise intranet messaging

Python Integration Sketch (Sockets/Flask + PyCryptodome)

# RSA keypair per user
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP, AES
from Crypto.Random import get_random_bytes

# Generate user RSA keys (once)
def gen_user_keys():
    key = RSA.generate(2048)
    return key.export_key(), key.publickey().export_key()

# Start secure session: wrap AES key with recipient's RSA public key
def start_session(recipient_pub_pem):
    aes_key = get_random_bytes(32)    # AES-256
    iv = get_random_bytes(16)
    rsa_pub = RSA.import_key(recipient_pub_pem)
    wrapped = PKCS1_OAEP.new(rsa_pub).encrypt(aes_key)
    return aes_key, iv, wrapped        # send 'wrapped' + iv to recipient

# Encrypt message
def enc_msg(aes_key, iv, plaintext):
    cipher = AES.new(aes_key, AES.MODE_CBC, iv=iv)
    pad = 16 - (len(plaintext) % 16)
    ct = cipher.encrypt(plaintext + bytes([pad])*pad)
    return ct

# Decrypt session key (recipient side)
def unwrap_key(priv_pem, wrapped):
    rsa_priv = RSA.import_key(priv_pem)
    return PKCS1_OAEP.new(rsa_priv).decrypt(wrapped)

# Decrypt message
def dec_msg(aes_key, iv, ciphertext):
    cipher = AES.new(aes_key, AES.MODE_CBC, iv=iv)
    pt = cipher.decrypt(ciphertext)
    return pt[:-pt[-1]]
              

What You Get