Secure File Sharing App — End-to-End AES-256 Encryption

1. Introduction

The Secure File Sharing App Using AES Encryption delivers end-to-end protection by encrypting files locally with AES-256 before upload. Only recipients with the correct key can decrypt. The app provides a simple portal to upload → encrypt → share → decrypt, eliminating unauthorized access risks found in traditional methods. Ideal for personal, academic, and enterprise use.

2. Existing System vs Proposed System

3. Working

1. User Authentication: Register/login to access the portal.
2. File Upload: Choose a file for encryption.
3. Encryption: AES-256 with random key & IV; key never stored in plaintext.
4. Sharing: App generates an encrypted blob + secure download link.
5. Decryption: Recipient supplies the secret key to decrypt.
6. Logging: Access and share events recorded for auditing.

4. Technology Stack

• Language: Python
• Libraries: PyCryptodome, Flask, SQLite3, os, base64
• Algorithm: AES-256 (CBC/GCM)
• Backend: SQLite3 for file metadata & users
• Frontend: Flask web UI or Tkinter desktop UI
• Security: Random keys, salted hashing, token-based access

5. Modules

6. Advantages

• Strong AES-256 end-to-end encryption.
• No third-party access to keys or files.
• Simple UI for non-technical users.
• Extendable to cloud storage integrations.
• Prevents leaks during transfer and at rest.

7. Applications

• Secure corporate data exchange.
• Confidential sharing in healthcare/banking/education.
• Personal private document transfer.
• Integration with enterprise file management.

Python Integration Sketch (Flask + PyCryptodome)

from flask import Flask, request, send_file
from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
import base64, sqlite3, os

app = Flask(__name__)

def pad(b):  # for CBC example; prefer GCM for AEAD
    padlen = 16 - (len(b) % 16)
    return b + bytes([padlen])*padlen

def unpad(b):
    return b[:-b[-1]]

def encrypt_file(path):
    key = get_random_bytes(32)     # 256-bit
    iv  = get_random_bytes(16)
    cipher = AES.new(key, AES.MODE_CBC, iv=iv)
    with open(path, "rb") as f: pt = f.read()
    ct = cipher.encrypt(pad(pt))
    return key, iv, ct

def decrypt_bytes(key, iv, ct):
    cipher = AES.new(key, AES.MODE_CBC, iv=iv)
    pt = unpad(cipher.decrypt(ct))
    return pt

# Upload -> encrypt -> store blob/metadata -> return link (token)
# Download -> require token + key -> decrypt -> stream file
              

What You Get