u/FeralAlgorithm

Google and others steal our data, and use it to manipulate and censor everyone. They're currently in the process of rolling out a new CAPTCHA that requires you to install Google Spyware if you want to be considered "human".

What can we do to poison that data, so that our data is useless or even detrimental for them to have and/or use?

For example, Google Home likes to listen to everything you say, and keeps transcripts forever in their datacenters, so that it can analyze what you're discussing, build up a profile on your personality, your habits, hobbies, etc.

By having an LLM & Text-to-Speech generate endless conversations about nonsense, it makes Google's collection of that data useless. Google will then have transcripts of us planning to take trips we'll never take, having arguments about things we've never done, etc. It will think we're having a baby or getting ready for a trip to Florida. This could be combined to generate searches to make it seem like we're looking for hotels in Florida, or new parent tips & diaper prices etc.

Google's "profile" on us would then be useless.

You let it generate files in a folder thats automatically sync'd with a cloud storage service (Like google drive for example). Tomorrow you delete the file and do it again. Bonus points if you use MultCloud.

You stay under your data limit becuase you delete your files. They need to keep a copy of the data for several months even after you delete it. Google holds onto everything forever. NSA's Utah datacenter likely keeps a copy. Its random data so it can't be deduplicated. It generates data that looks encrypted so they spend cpu cycles trying to decrypt. Its then actually encrypted with a randomly generated password. If they have weakened public encryption they'll have to spend cpu cycles decrypting it and trying to decrypt the random data.

>Prompt that will generate the script:

Create a Python script called "StormCloud" that generates fake encrypted files by writing random bytes with configurable padding to ensure 16-byte alignment, plus optional OpenSSL encryption. The script should add random extra data (0-1MB) to the base size, support three padding types (pkcs: PKCS#7 with repeated padding bytes; ansi: only last byte indicates padding; none: all padding bytes random), and three encryption options (aes256: AES-256-CBC with 256-bit key; blowfish: Blowfish-CBC with 128-bit key; chacha: ChaCha20 with 256-bit key), each using random keys and salts. Default settings: output file=data.dat, size=500M (accepts K/M/G suffixes), padding=ansi, encryption=none, tempdir=/tmp. Include CLI arguments for all options plus a --silent flag to suppress output. **Write data directly to disk in chunks (not loaded entirely in memory) to handle large files efficiently.** Use only **one temporary file** for encryption (write raw data there, then encrypt in-place to output). Show progress during writing, display key/salt info when encrypting, and always print "StormCloud Completed" at the end. Handle errors gracefully with specific exit codes for different error types.

The script:

#!/usr/bin/env python3
"""
StormCloud - Generate fake encrypted files with configurable padding and encryption
"""
import argparse
import os
import sys
import random
import tempfile
import subprocess
import time
# Exit codes
EXIT_SUCCESS = 0
EXIT_INVALID_ARGS = 1
EXIT_FILE_ERROR = 2
EXIT_ENCRYPTION_ERROR = 3
EXIT_PADDING_ERROR = 4
def parse_size(size_str):
    """Parse size string with K/M/G suffix to bytes"""
    size_str = size_str.upper()
    if size_str.endswith('K'):
        return int(size_str[:-1]) * 1024
    elif size_str.endswith('M'):
        return int(size_str[:-1]) * 1024 * 1024
    elif size_str.endswith('G'):
        return int(size_str[:-1]) * 1024 * 1024 * 1024
    else:
        return int(size_str)
def generate_random_bytes(size):
    """Generate random bytes"""
    return os.urandom(size)
def write_random_data(filepath, size, chunk_size=65536, silent=False):
    """Write random data to file in chunks for memory efficiency"""
    written = 0
    start_time = time.time()
    
    with open(filepath, 'wb') as f:
        while written < size:
            chunk = min(chunk_size, size - written)
            data = generate_random_bytes(chunk)
            f.write(data)
            written += chunk
            
            if not silent and written % (chunk_size * 100) == 0:
                elapsed = time.time() - start_time
                speed = written / (1024 * 1024) / elapsed if elapsed > 0 else 0
                print(f"\rWriting: {written / (1024 * 1024):.1f}MB / {size / (1024 * 1024):.1f}MB ({speed:.1f} MB/s)", end='', flush=True)
    
    if not silent:
        print()
    
    return written
def apply_padding_to_file(input_path, output_path, padding_type, block_size=16):
    """Apply padding to file and write to output"""
    with open(input_path, 'rb') as f:
        data = f.read()
    
    if padding_type == 'pkcs':
        padding_len = block_size - (len(data) % block_size)
        if padding_len == 0:
            padding_len = block_size
        padding = bytes([padding_len] * padding_len)
    elif padding_type == 'ansi':
        padding_len = block_size - (len(data) % block_size)
        if padding_len == 0:
            padding_len = block_size
        padding = bytes([0] * (padding_len - 1)) + bytes([padding_len])
    elif padding_type == 'none':
        padding_len = block_size - (len(data) % block_size)
        if padding_len == 0:
            padding_len = block_size
        padding = generate_random_bytes(padding_len)
    else:
        raise ValueError(f"Unknown padding type: {padding_type}")
    
    padded_data = data + padding
    
    with open(output_path, 'wb') as f:
        f.write(padded_data)
    
    return len(padded_data)
def encrypt_file(input_path, output_path, encryption_type, silent=False):
    """Encrypt file using OpenSSL"""
    key_size = 32 if encryption_type == 'aes256' else 16
    key = generate_random_bytes(key_size)
    salt = generate_random_bytes(8)
    
    if encryption_type == 'aes256':
        cipher = 'aes-256-cbc'
    elif encryption_type == 'blowfish':
        cipher = 'blowfish-cbc'
    elif encryption_type == 'chacha':
        cipher = 'chacha20'
    else:
        raise ValueError(f"Unknown encryption type: {encryption_type}")
    
    if not silent:
        print(f"\nEncryption: {cipher}")
        print(f"Key: {key.hex()}")
        print(f"Salt: {salt.hex()}")
    
    # Encrypt using OpenSSL
    cmd = [
        'openssl', 'enc',
        '-in', input_path,
        '-out', output_path,
        '-pbkdf2',
        '-iter', '10000',
        '-S', salt.hex(),
        '-K', key.hex(),
        '-' + cipher
    ]
    
    result = subprocess.run(cmd, capture_output=True, text=True)
    
    if result.returncode != 0:
        raise RuntimeError(f"OpenSSL encryption failed: {result.stderr}")
def main():
    parser = argparse.ArgumentParser(description='StormCloud - Generate fake encrypted files')
    parser.add_argument('--output', '-o', default='data.dat', help='Output file path')
    parser.add_argument('--size', '-s', default='500M', help='File size (e.g., 500M, 1G, 100K)')
    parser.add_argument('--padding', '-p', default='ansi', choices=['pkcs', 'ansi', 'none'], help='Padding type')
    parser.add_argument('--encryption', '-e', default='none', choices=['aes256', 'blowfish', 'chacha', 'none'], help='Encryption type')
    parser.add_argument('--tempdir', '-t', default='/tmp', help='Temporary directory')
    parser.add_argument('--silent', action='store_true', help='Suppress output')
    
    args = parser.parse_args()
    
    try:
        # Parse size
        base_size = parse_size(args.size)
        
        # Add random extra data (0-1MB)
        extra_size = random.randint(0, 1024 * 1024)
        total_size = base_size + extra_size
        
        # Create temp file
        temp_fd, temp_path = tempfile.mkstemp(dir=args.tempdir, suffix='.tmp')
        os.close(temp_fd)
        
        try:
            # Write random data
            if not args.silent:
                print(f"Generating {total_size / (1024 * 1024):.1f}MB of random data...")
            
            write_random_data(temp_path, total_size, silent=args.silent)
            
            # Apply padding if needed
            if args.padding != 'none':
                padded_size = apply_padding_to_file(temp_path, temp_path, args.padding)
                total_size = padded_size
            
            # Encrypt if needed
            if args.encryption != 'none':
                encrypt_file(temp_path, args.output, args.encryption, args.silent)
                os.unlink(temp_path)
            else:
                # Just move temp file to output
                os.rename(temp_path, args.output)
            
            if not args.silent:
                print(f"\nOutput: {args.output}")
                print(f"Size: {total_size / (1024 * 1024):.1f}MB")
            
            print("StormCloud Completed")
            return EXIT_SUCCESS
        
        except Exception as e:
            if not args.silent:
                print(f"\nError: {e}")
            return EXIT_FILE_ERROR
    
    except ValueError as e:
        if not args.silent:
            print(f"Invalid argument: {e}")
        return EXIT_INVALID_ARGS
if __name__ == '__main__':
    sys.exit(main())

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()