| import os |
| import io |
| import wave |
| import struct |
| import logging |
| from flask import Flask, render_template, request, send_file, jsonify |
| from werkzeug.utils import secure_filename |
|
|
| app = Flask(__name__) |
|
|
| logging.basicConfig(level=logging.DEBUG) |
| logger = app.logger |
|
|
| UPLOAD_FOLDER = '/tmp' |
| ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg', 'gif', 'mp3', 'wav', 'txt', 'pdf'} |
|
|
| app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER |
|
|
| def allowed_file(filename): |
| return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS |
|
|
| @app.route('/') |
| def index(): |
| return render_template('index.html') |
|
|
| @app.route('/process', methods=['POST']) |
| def process_file(): |
| logger.info("Processing file request received") |
| if 'file' not in request.files: |
| logger.error("No file part in the request") |
| return jsonify({'error': 'No file part'}), 400 |
| file = request.files['file'] |
| if file.filename == '': |
| logger.error("No selected file") |
| return jsonify({'error': 'No selected file'}), 400 |
| if file and allowed_file(file.filename): |
| filename = secure_filename(file.filename) |
| filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename) |
| file.save(filepath) |
| logger.info(f"File saved: {filepath}") |
|
|
| factor = int(request.form['factor']) |
| is_decrypting = filename.lower().endswith('.wav') |
| logger.info(f"Processing file: {'decrypting' if is_decrypting else 'encrypting'} with factor {factor}") |
|
|
| try: |
| if is_decrypting: |
| output, output_filename, mimetype = decrypt_file(filepath, factor) |
| else: |
| output, output_filename, mimetype = encrypt_file(filepath, factor) |
|
|
| logger.info(f"File processed successfully. Output size: {len(output)} bytes") |
| os.remove(filepath) |
| logger.info(f"Temporary file removed: {filepath}") |
|
|
| return send_file( |
| io.BytesIO(output), |
| mimetype=mimetype, |
| as_attachment=True, |
| download_name=output_filename |
| ) |
| except Exception as e: |
| logger.error(f"Error processing file: {str(e)}") |
| os.remove(filepath) |
| return jsonify({'error': str(e)}), 500 |
|
|
| logger.error("Invalid file type") |
| return jsonify({'error': 'Invalid file type'}), 400 |
|
|
| def encrypt_file(filepath, factor): |
| logger.info(f"Encrypting file: {filepath}") |
| with open(filepath, 'rb') as file: |
| data = file.read() |
| |
| |
| samples = [ord(byte) * factor for byte in data.decode('latin-1')] |
| |
| |
| output = io.BytesIO() |
| with wave.open(output, 'wb') as wav_output: |
| wav_output.setnchannels(1) |
| wav_output.setsampwidth(2) |
| wav_output.setframerate(44100) |
| wav_output.writeframes(struct.pack(f'{len(samples)}h', *samples)) |
| |
| logger.info(f"Encryption complete. Output size: {output.getbuffer().nbytes} bytes") |
| return output.getvalue(), 'encrypted.wav', 'audio/wav' |
|
|
| def decrypt_file(filepath, factor): |
| logger.info(f"Decrypting file: {filepath}") |
| with wave.open(filepath, 'rb') as wav_file: |
| params = wav_file.getparams() |
| frames = wav_file.readframes(wav_file.getnframes()) |
| |
| samples = struct.unpack(f'{len(frames)//2}h', frames) |
| decrypted_data = ''.join(chr(int(sample / factor)) for sample in samples).encode('latin-1') |
| |
| logger.info(f"Decryption complete. Output size: {len(decrypted_data)} bytes") |
| return decrypted_data, 'decrypted_file', 'application/octet-stream' |
|
|
| if __name__ == '__main__': |
| app.run(debug=True) |
