u/FeralAlgorithm

Output to a folder that is automatically sync'd by a cloud storage provider & use MultCloud to mirror the data between several cloud providers.

Companies are required to hold your data for months even after you delete or overwrite it. Deleted & overwritten files don't count towards your limit.

Randomized/encrypted files cant be de-duplicated.

Making it appear like valuable data will make them burn CPU cycles trying to decrypt it.

The Utah Datacenter will probably take a copy as well. If the NSA has decryption tricks, they'll decrypt this and wonder why their decryption didn't work, and try more methods.

This will consume tons of storage and burn tons of processing power.

#!/usr/bin/env python3

import argparse
import os
import sys
import random
import secrets
import subprocess
import time
from pathlib import Path
def generate_random_bytes(size: int) -> bytes:
"""Generate random bytes of specified size."""
return secrets.token_bytes(size)
def apply_padding(data: bytes, padding_type: str) -> bytes:
"""Apply padding to ensure 16-byte alignment."""
remainder = len(data) % 16
if remainder == 0:
return data

padding_len = 16 - remainder

if padding_type == 'pkcs':
# PKCS#7: all padding bytes have value equal to padding length
padding = bytes([padding_len] * padding_len)
elif padding_type == 'ansi':
# ANSI: only last byte indicates padding, rest are random
padding = generate_random_bytes(padding_len - 1) + bytes([padding_len])
else: # none
# All padding bytes random
padding = generate_random_bytes(padding_len)

return data + padding
def encrypt_data(data: bytes, encryption: str, tempdir: str) -> tuple:
"""Encrypt data using OpenSSL with specified algorithm."""
if encryption == 'none':
return data, None, None

# Generate random key and IV/salt
if encryption == 'aes256':
key = secrets.token_bytes(32) # 256-bit key
iv = secrets.token_bytes(16) # 128-bit IV
cipher = 'aes-256-cbc'
elif encryption == 'blowfish':
key = secrets.token_bytes(16) # 128-bit key
iv = secrets.token_bytes(8) # 64-bit IV for Blowfish
cipher = 'bf-cbc'
else: # chacha
key = secrets.token_bytes(32) # 256-bit key
iv = secrets.token_bytes(12) # 96-bit nonce for ChaCha20
cipher = 'chacha20'

# Create temp file for encryption
temp_input = os.path.join(tempdir, f'stormcloud_input_{os.getpid()}.tmp')
temp_output = os.path.join(tempdir, f'stormcloud_output_{os.getpid()}.tmp')

try:
# Write data to temp file
with open(temp_input, 'wb') as f:
f.write(data)

# Run OpenSSL encryption
cmd = [
'openssl', 'enc',
'-in', temp_input,
'-out', temp_output,
'-pbkdf2',
'-iter', '10000',
'-S', iv.hex(),
'-K', key.hex(),
'-' + cipher
]

result = subprocess.run(cmd, capture_output=True)
if result.returncode != 0:
raise RuntimeError(f"OpenSSL encryption failed: {result.stderr.decode()}")

# Read encrypted data
with open(temp_output, 'rb') as f:
encrypted_data = f.read()

# Cleanup temp files
os.remove(temp_input)
os.remove(temp_output)

return encrypted_data, key, iv
except FileNotFoundError:
raise RuntimeError("OpenSSL is not installed or not in PATH")
def write_file_with_progress(filepath: str, data: bytes, silent: bool = False):
"""Write data to file with progress indicator."""
chunk_size = 1024 * 1024 # 1MB chunks
total_size = len(data)
written = 0

with open(filepath, 'wb') as f:
for i in range(0, total_size, chunk_size):
chunk = data[i:i + chunk_size]
f.write(chunk)
written += len(chunk)

if not silent:
progress = (written / total_size) * 100
print(f"\rWriting: {progress:.1f}%", end='', flush=True)

if not silent:
print() # New line after progress
def main():
parser = argparse.ArgumentParser(
description='StormCloud - Generate fake encrypted files',
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog='''
Examples:
%(prog)s --size 100M --encryption aes256 --output secure.dat
%(prog)s --padding pkcs --encryption blowfish --silent
'''
)

parser.add_argument('--output', '-o', default='data.dat',
help='Output file path (default: data.dat)')
parser.add_argument('--size', '-s', default='500M',
help='Base file size (e.g., 500M, 1G, 100K) (default: 500M)')
parser.add_argument('--padding', '-p', default='ansi',
choices=['pkcs', 'ansi', 'none'],
help='Padding type (default: ansi)')
parser.add_argument('--encryption', '-e', default='none',
choices=['aes256', 'blowfish', 'chacha', 'none'],
help='Encryption algorithm (default: none)')
parser.add_argument('--tempdir', '-t', default='/tmp',
help='Temporary directory for encryption (default: /tmp)')
parser.add_argument('--silent', '-q', action='store_true',
help='Suppress all output except completion message')

args = parser.parse_args()

try:
# Parse size with unit
size_str = args.size.upper()
if size_str.endswith('G'):
base_size = int(size_str[:-1]) * 1024 * 1024 * 1024
elif size_str.endswith('K'):
base_size = int(size_str[:-1]) * 1024
elif size_str.endswith('M'):
base_size = int(size_str[:-1]) * 1024 * 1024
else:
base_size = int(size_str)

# Add random extra data (0-1MB)
extra_data = random.randint(0, 1024 * 1024)
total_size = base_size + extra_data

if not args.silent:
print(f"StormCloud Initializing...")
print(f" Target size: {base_size / (1024*1024):.0f}MB + {extra_data / 1024:.1f}KB random")
print(f" Padding: {args.padding}")
print(f" Encryption: {args.encryption}")

# Generate random data
if not args.silent:
print(f"Generating {total_size / (1024*1024):.1f}MB of random data...")

start_time = time.time()
data = generate_random_bytes(total_size)
gen_time = time.time() - start_time

if not args.silent:
print(f" Generated in {gen_time:.2f}s")

# Apply padding
if not args.silent:
print(f"Applying {args.padding} padding...")

padded_data = apply_padding(data, args.padding)

# Encrypt if needed
key = None
iv = None
if args.encryption != 'none':
if not args.silent:
print(f"Encrypting with {args.encryption}...")

start_time = time.time()
encrypted_data, key, iv = encrypt_data(padded_data, args.encryption, args.tempdir)
enc_time = time.time() - start_time

if not args.silent:
print(f" Encryption completed in {enc_time:.2f}s")
print(f" Key: {key.hex()}")
print(f" IV/Salt: {iv.hex()}")

final_data = encrypted_data
else:
final_data = padded_data

# Write to output file
if not args.silent:
print(f"Writing to {args.output}...")

write_file_with_progress(args.output, final_data, args.silent)

if not args.silent:
print(f" File size: {len(final_data) / (1024*1024):.2f}MB")

print("StormCloud Completed")
sys.exit(0)

except KeyboardInterrupt:
print("\nStormCloud Interrupted")
sys.exit(130)
except PermissionError:
print("Error: Permission denied")
sys.exit(1)
except FileNotFoundError:
print("Error: File or directory not found")
sys.exit(2)
except subprocess.CalledProcessError:
print("Error: Encryption process failed")
sys.exit(3)
except RuntimeError as e:
print(f"Error: {e}")
sys.exit(4)
except Exception as e:
print(f"Error: Unexpected error - {e}")
sys.exit(5)
if __name__ == '__main__':
main()