import os
import base64
import hashlib
import json
import time
import uuid
from flask import Flask, request, render_template, send_file, jsonify, redirect, url_for
import qrcode
from cryptography.fernet import Fernet

app = Flask(__name__)

# --- 配置 ---
UPLOAD_FOLDER = 'uploads'
QR_CODE_FOLDER = 'qr_codes'
RECEIVED_FOLDER = 'received_files'
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
app.config['QR_CODE_FOLDER'] = QR_CODE_FOLDER
app.config['RECEIVED_FOLDER'] = RECEIVED_FOLDER

# 确保目录存在
os.makedirs(UPLOAD_FOLDER, exist_ok=True)
os.makedirs(QR_CODE_FOLDER, exist_ok=True)
os.makedirs(RECEIVED_FOLDER, exist_ok=True)

# 存储传输会话信息 {session_id: {'key': key, 'chunks': [...], 'metadata': {...}}}
transfer_sessions = {}

# --- 辅助函数 ---

def calculate_sha256(file_path):
    """计算文件的 SHA-256 哈希值"""
    sha256_hash = hashlib.sha256()
    with open(file_path, "rb") as f:
        # Read and update hash string value in blocks of 4K
        for byte_block in iter(lambda: f.read(4096), b""):
            sha256_hash.update(byte_block)
    return sha256_hash.hexdigest()

def split_data(data, chunk_size):
    """将字节数据分割成指定大小的块"""
    chunks = []
    for i in range(0, len(data), chunk_size):
        chunks.append(data[i:i + chunk_size])
    return chunks

def generate_qr_code(data_str, filename):
    """生成二维码并保存为文件"""
    qr = qrcode.QRCode(
        version=1,
        error_correction=qrcode.constants.ERROR_CORRECT_L,
        box_size=10,
        border=4,
    )
    qr.add_data(data_str)
    qr.make(fit=True)

    img = qr.make_image(fill_color="black", back_color="white")
    img.save(os.path.join(app.config['QR_CODE_FOLDER'], filename))

# --- 路由 ---

@app.route('/')
def index():
    """主页 - 文件上传"""
    return render_template('index.html')

@app.route('/upload', methods=['POST'])
def upload_file():
    """处理文件上传和二维码生成"""
    if 'files' not in request.files:
        return "No file part", 400
    files = request.files.getlist('files')
    
    if not files or all(f.filename == '' for f in files):
        return "No selected file", 400

    # 获取用户设置
    try:
        chunk_size_kb = int(request.form.get('chunk_size', 100)) # 默认100KB
        display_speed = int(request.form.get('display_speed', 2)) # 默认2张/秒
    except ValueError:
        return "Invalid input for chunk size or display speed", 400

    chunk_size_bytes = chunk_size_kb * 1024
    delay_ms = int(1000 / display_speed) if display_speed > 0 else 500

    # 为本次传输创建唯一会话ID和加密密钥
    session_id = str(uuid.uuid4())
    key = Fernet.generate_key()
    cipher_suite = Fernet(key)
    
    uploaded_files_info = []
    all_chunks_data = [] # 存储所有文件的加密块数据

    # 1. 处理每个上传的文件
    for file in files:
        if file:
            filename = file.filename
            filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
            file.save(filepath)
            
            file_size = os.path.getsize(filepath)
            file_hash = calculate_sha256(filepath)
            file_type = file.content_type or 'unknown'

            # 读取文件内容并Base64编码
            with open(filepath, 'rb') as f:
                file_content = f.read()
            encoded_content = base64.b64encode(file_content).decode('utf-8')

            # 准备元数据
            metadata = {
                'filename': filename,
                'size': file_size,
                'type': file_type,
                'sha256': file_hash
            }

            # 将元数据和内容组合，然后加密
            data_to_encrypt = json.dumps({
                'metadata': metadata,
                'content': encoded_content
            }).encode('utf-8')

            encrypted_data = cipher_suite.encrypt(data_to_encrypt)
            
            # 分割加密后的数据
            chunks = split_data(encrypted_data, chunk_size_bytes)
            all_chunks_data.extend([(chunk, filename) for chunk in chunks]) # 保存块和文件名关联

            uploaded_files_info.append({
                'name': filename,
                'size': file_size,
                'hash': file_hash
            })

    # 2. 为所有块创建二维码
    qr_filenames = []
    total_chunks = len(all_chunks_data)
    for i, (chunk_data, filename) in enumerate(all_chunks_data):
        # 构造二维码数据：会话ID, 块索引, 总块数, 文件名标识, 加密块数据
        # 为了简化，我们将密钥也编码进去（第一个二维码）
        qr_data_dict = {
            'session_id': session_id,
            'index': i,
            'total': total_chunks,
            'filename': filename,
            'data': base64.b64encode(chunk_data).decode('utf-8')
        }
        
        # 第一个二维码包含解密密钥
        if i == 0:
            qr_data_dict['key'] = key.decode('utf-8')

        qr_data_str = json.dumps(qr_data_dict)
        qr_filename = f"qr_{session_id}_{i}.png"
        generate_qr_code(qr_data_str, qr_filename)
        qr_filenames.append(qr_filename)


    # 3. 存储会话信息 (虽然本次简化了密钥分发，但保留结构)
    transfer_sessions[session_id] = {
        'key': key.decode('utf-8'), # 存储为字符串
        'total_chunks': total_chunks,
        'chunks_received': {}, # {index: data}
        'files_info': uploaded_files_info
    }

    # 4. 渲染展示页面
    return render_template('index.html', 
                           qr_files=qr_filenames, 
                           delay_ms=delay_ms,
                           session_id=session_id,
                           files_info=uploaded_files_info)


# --- 接收端模拟 (简化版，实际需要前端JS扫描) ---

@app.route('/scanner')
def scanner():
    """扫描页面"""
    return render_template('scanner.html')

# 模拟接收端扫描并重组文件的API端点
@app.route('/receive_chunk', methods=['POST'])
def receive_chunk():
    """接收扫描到的二维码数据块 (模拟)"""
    data = request.json
    qr_data_str = data.get('qr_data')
    
    if not qr_data_str:
        return jsonify({'status': 'error', 'message': 'No QR data received'}), 400

    try:
        qr_data = json.loads(qr_data_str)
    except json.JSONDecodeError:
        return jsonify({'status': 'error', 'message': 'Invalid QR data format'}), 400

    session_id = qr_data.get('session_id')
    index = qr_data.get('index')
    total = qr_data.get('total')
    filename = qr_data.get('filename')
    encrypted_chunk_b64 = qr_data.get('data')
    key_str = qr_data.get('key') # 可能来自第一个二维码

    if not session_id or index is None or total is None or not encrypted_chunk_b64:
        return jsonify({'status': 'error', 'message': 'Missing data in QR code'}), 400

    # 检查或创建会话
    if session_id not in transfer_sessions:
        transfer_sessions[session_id] = {
            'key': key_str, # 从第一个二维码获取
            'total_chunks': total,
            'chunks_received': {},
            'files_info': {} # 简化处理
        }
    elif key_str:
         transfer_sessions[session_id]['key'] = key_str # 更新密钥（如果第一个二维码后扫到）

    session = transfer_sessions[session_id]
    
    # 解密块
    try:
        cipher_suite = Fernet(session['key'].encode('utf-8'))
        encrypted_chunk = base64.b64decode(encrypted_chunk_b64)
        decrypted_chunk = cipher_suite.decrypt(encrypted_chunk)
        
        # 解析解密后的内容
        chunk_data = json.loads(decrypted_chunk.decode('utf-8'))
        # 这里可以进一步处理 chunk_data['metadata'] 和 chunk_data['content']
        
        # 存储解密后的内容（或原始加密块，取决于重组策略）
        session['chunks_received'][index] = {
            'data': chunk_data, # 存储解密后的完整数据
            'filename': filename
        }
        
    except Exception as e:
        return jsonify({'status': 'error', 'message': f'Decryption failed: {str(e)}'}), 500

    # 检查是否所有块都已接收
    if len(session['chunks_received']) == session['total_chunks']:
        # 重组文件
        try:
            # 按索引排序
            sorted_chunks = sorted(session['chunks_received'].items())
            
            # 假设只有一个文件，或按filename分组处理
            # 这里简化为处理第一个文件
            if sorted_chunks:
                # 重新组装内容 (需要按文件名分组)
                files_content = {}
                for idx, chunk_info in sorted_chunks:
                    fname = chunk_info['filename']
                    content = chunk_info['data']['content'] # Base64内容
                    if fname not in files_content:
                        files_content[fname] = []
                    files_content[fname].append(content)
                
                for fname, parts in files_content.items():
                    # Base64解码所有部分并合并
                    full_base64_content = "".join(parts)
                    file_content = base64.b64decode(full_base64_content)
                    
                    # 保存文件
                    output_path = os.path.join(app.config['RECEIVED_FOLDER'], f"received_{fname}")
                    with open(output_path, 'wb') as f:
                        f.write(file_content)
                    
                    # 可以在这里验证SHA256 (chunk_info['data']['metadata']['sha256'])
                
                # 清理会话
                del transfer_sessions[session_id]
                return jsonify({'status': 'success', 'message': 'File(s) received and saved.', 'download_url': url_for('download_file', filename=f"received_{list(files_content.keys())[0]}")})
            else:
                return jsonify({'status': 'error', 'message': 'No chunks to assemble'}), 500
        except Exception as e:
            return jsonify({'status': 'error', 'message': f'File assembly failed: {str(e)}'}), 500

    return jsonify({'status': 'success', 'message': f'Chunk {index+1}/{total} received'})


@app.route('/download/<filename>')
def download_file(filename):
    """提供下载重组后的文件"""
    try:
        return send_file(os.path.join(app.config['RECEIVED_FOLDER'], filename), as_attachment=True)
    except FileNotFoundError:
        return "File not found", 404


if __name__ == '__main__':
    app.run(debug=True)

from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import serialization
import binascii
import os

def generate_public_key(private_key_hex: str) -> str:
    """
    根据给定的私钥（十六进制字符串）生成对应的公钥（压缩格式的十六进制字符串）。

    :param private_key_hex: 私钥，十六进制字符串
    :return: 公钥，压缩格式的十六进制字符串或错误信息
    """
    try:
        # 将十六进制字符串转换为字节
        private_key_bytes = binascii.unhexlify(private_key_hex)
        
        # 加载私钥
        private_key = ec.derive_private_key(
            int.from_bytes(private_key_bytes, byteorder='big'),
            ec.SECP256R1()
        )
        
        # 获取公钥
        public_key = private_key.public_key()
        
        # 序列化公钥为压缩格式（X9.62格式）
        public_key_bytes = public_key.public_bytes(
            encoding=serialization.Encoding.X962,
            format=serialization.PublicFormat.CompressedPoint
        )
        
        # 将公钥转换为十六进制字符串
        public_key_hex = binascii.hexlify(public_key_bytes).decode()
        
        return public_key_hex
    except Exception as e:
        return f"Error: {str(e)}"

def batch_convert(source_path: str, target_path: str):
    """
    批量转换私钥为公钥。

    :param source_path: 源TXT文件路径
    :param target_path: 目标TXT文件路径
    """
    try:
        with open(source_path, 'r') as src_file, open(target_path, 'w') as tgt_file:
            line_num = 0
            for line in src_file:
                line_num += 1
                # 去除空白字符
                private_key = line.strip()
                
                # 验证私钥长度
                if len(private_key) != 64:
                    error_msg = f"Line {line_num}: 私钥长度应为64个十六进制字符（256位）。"
                    tgt_file.write(f"{error_msg}\n")
                    continue
                
                # 生成公钥
                public_key = generate_public_key(private_key)
                
                # 写入目标文件
                tgt_file.write(f"{public_key}\n")
        
        print(f"转换完成。输出文件位于：{target_path}")
    except FileNotFoundError:
        print(f"错误：文件未找到。请检查路径：{source_path}")
    except Exception as e:
        print(f"发生错误：{str(e)}")

def main():
    print("ECC公钥批量转换器（基于secp256r1）")
    source_path = input("请输入源TXT文件的本地路径（例如：C:/keys/source.txt）：\n")
    
    # 检查文件是否存在
    if not os.path.isfile(source_path):
        print(f"错误：文件不存在。请检查路径：{source_path}")
        return
    
    # 生成目标文件路径
    directory, filename = os.path.split(source_path)
    filename_no_ext, ext = os.path.splitext(filename)
    target_filename = f"{filename_no_ext}_public_keys{ext}"
    target_path = os.path.join(directory, target_filename)
    
    # 开始转换
    batch_convert(source_path, target_path)

if __name__ == "__main__":
    main()

import os
import sys
import shutil
import base64
import hashlib
import pandas as pd
from Cryptodome.PublicKey import ECC
from Cryptodome.Cipher import AES
from Cryptodome.Util.Padding import pad, unpad
import qrcode
import io
import cv2
import numpy as np
from flask import Flask, request, jsonify, render_template_string, send_from_directory

# ============================== 配置根目录 ==============================
ROOT_DIR = r"C:\Users\lenovo\Documents\qrs"

# 确保根目录及其子目录存在
def ensure_root_directory():
    """
    确保根目录及其子目录存在。
    如果不存在，则创建它们。
    """
    if not os.path.exists(ROOT_DIR):
        os.makedirs(ROOT_DIR)
        print(f"已创建根目录: {ROOT_DIR}")

    # 确保子目录存在
    subdirs = ["uploads", "qrs", "templates", "static"]
    for subdir in subdirs:
        subdir_path = os.path.join(ROOT_DIR, subdir)
        if not os.path.exists(subdir_path):
            os.makedirs(subdir_path)
            print(f"已创建子目录: {subdir_path}")

# 获取资源文件的路径
def resource_path(relative_path):
    """
    动态获取资源文件的路径。
    - 在开发环境中，返回相对路径。
    - 在打包后的环境中，返回 PyInstaller 解压路径。
    """
    if hasattr(sys, '_MEIPASS'):
        return os.path.join(sys._MEIPASS, relative_path)
    return os.path.join(os.path.abspath("."), relative_path)

# 解压依赖文件到目标目录
def extract_dependencies():
    """
    将依赖文件解压到目标目录。
    如果文件已存在，则不会重复解压。
    """
    dependencies = {
        "key.xlsx": os.path.join(ROOT_DIR, "key.xlsx"),
        "templates/index.html": os.path.join(ROOT_DIR, "templates/index.html"),
    }

    for src, dst in dependencies.items():
        if not os.path.exists(dst):
            src_path = resource_path(src)
            shutil.copy(src_path, dst)
            print(f"已解压文件: {src} -> {dst}")

# 初始化根目录和依赖文件
ensure_root_directory()
extract_dependencies()

# 示例：加载 key.xlsx 文件
key_excel_path = os.path.join(ROOT_DIR, "key.xlsx")

# 示例：加载模板文件
template_html_path = os.path.join(ROOT_DIR, "templates/index.html")

# 初始化 Flask 应用
app = Flask(__name__, static_folder=resource_path("static"))

# ============================== 公共函数 ==============================

def load_keys_from_excel(file_path):
    """
    从 Excel 文件中加载私钥和临时私钥。
    返回两个列表：私钥和临时私钥。
    """
    if not os.path.exists(file_path):
        raise FileNotFoundError("Excel file not found")
    df = pd.read_excel(file_path)
    private_keys = df['私钥d'].tolist()
    temp_private_keys = df['临时私钥r'].tolist()
    return private_keys, temp_private_keys

def encrypt_data_aes(data, shared_key):
    """
    使用 AES 对称加密加密数据。
    返回加密后的数据（IV + 密文）。
    """
    key = shared_key[:32]  # 截取32字节作为AES密钥
    cipher = AES.new(key, AES.MODE_CBC)
    ct_bytes = cipher.encrypt(pad(data.encode('utf-8'), AES.block_size))
    iv = cipher.iv
    return iv.hex() + ct_bytes.hex()  # 返回IV和加密数据的十六进制表示

def decrypt_data_aes(encrypted_data, shared_key):
    """
    使用 AES 对称加密解密数据。
    返回解密后的原始数据。
    """
    key = shared_key[:32]  # 截取32字节作为AES密钥
    iv = bytes.fromhex(encrypted_data[:32])  # 提取IV
    ct = bytes.fromhex(encrypted_data[32:])  # 提取加密数据
    cipher = AES.new(key, AES.MODE_CBC, iv)
    decrypted_data = unpad(cipher.decrypt(ct), AES.block_size)
    return decrypted_data.decode('utf-8')

def compute_shared_key(temp_public_key, private_key):
    """
    计算共享密钥。
    使用 ECC 的规则，基于临时公钥和私钥计算共享密钥。
    """
    ecc_key = ECC.construct(curve='secp256r1', d=int(private_key, 16))
    temp_pub_key = ECC.import_key(temp_public_key)
    shared_key = ecc_key.d * temp_pub_key.pointQ  # 共享密钥
    compressed_shared_key = hashlib.sha256(str(shared_key.x).encode('utf-8')).digest()  # 压缩共享密钥
    return compressed_shared_key

# ============================== 输出端功能 ==============================

def analyze_and_convert(file_path):
    """
    分析文件并将其转换为 Base64 格式。
    返回文件的 SHA256、大小、类型和 Base64 内容。
    """
    try:
        with open(file_path, 'rb') as f:
            content = f.read()
        sha256_hash = hashlib.sha256(content).hexdigest()
        file_size = os.path.getsize(file_path)
        file_type = file_path.split('.')[-1]
        base64_content = base64.b64encode(content).decode('utf-8')
        return sha256_hash, file_size, file_type, base64_content
    except Exception as e:
        raise ValueError(f"File analysis failed: {str(e)}")

def split_and_encrypt(data, private_key, temp_private_key, chunk_size=1000):
    """
    将数据分块并加密。
    每个组块包含临时公钥、加密数据、字母编号、数字编号、SHA256校验值和组块数量。
    返回加密后的组块列表。
    """
    chunks = [data[i:i + chunk_size] for i in range(0, len(data), chunk_size)]
    encrypted_chunks = []
    try:
        # ECC 密钥生成
        ecc_key = ECC.construct(curve='secp256r1', d=int(temp_private_key, 16))
        public_key = ecc_key.public_key()
        shared_key = int(private_key, 16) * int(ecc_key.d)  # 共享密钥
        compressed_shared_key = hashlib.sha256(str(shared_key).encode('utf-8')).digest()  # 压缩共享密钥

        for idx, chunk in enumerate(chunks):
            # 使用 AES 对称加密加密数据
            aes_encrypted_chunk = encrypt_data_aes(chunk, compressed_shared_key)
            # 组合数据：临时公钥 + AES 加密数据 + 字母编号 + 数字编号 + SHA256校验值 + 组块数量 + 文件后缀
            hex_index = f"{idx + 1:02X}"  # 十六进制编号（两位）
            encrypted_chunk = (
                str(public_key.export_key(format='PEM')) + '-' +
                aes_encrypted_chunk + '-' +
                "A" + hex_index + '-' +  # 字母编号（假设单个文件）
                hashlib.sha256(chunk.encode('utf-8')).hexdigest() + '-' +
                str(len(chunks)) + '-' +
                file_type  # 添加文件后缀
            )
            encrypted_chunks.append(encrypted_chunk)
    except Exception as e:
        raise ValueError(f"ECC encryption failed: {str(e)}")
    return encrypted_chunks

def generate_qr_codes_in_memory(chunks, file_name):
    """
    将加密后的组块生成二维码。
    返回二维码的二进制数据列表。
    """
    qr_images = []
    file_qr_folder = os.path.join(ROOT_DIR, "qrs", file_name)
    if not os.path.exists(file_qr_folder):
        os.makedirs(file_qr_folder)

    for idx, chunk in enumerate(chunks):
        qr = qrcode.QRCode(version=1, box_size=10, border=5)
        qr.add_data(chunk)
        qr.make(fit=True)
        img = qr.make_image(fill_color="black", back_color="white")
        buffer = io.BytesIO()
        img.save(buffer, format="PNG")
        buffer.seek(0)  # 将指针重置到文件开头
        qr_images.append(buffer.getvalue())

        # 保存二维码到文件夹
        qr_path = os.path.join(file_qr_folder, f"{file_name}_qr_{idx + 1}.png")
        with open(qr_path, 'wb') as f:
            f.write(buffer.getvalue())

    return qr_images

@app.route('/upload', methods=['POST'])
def upload_files():
    """
    处理文件上传请求。
    用户上传文件后，程序会分析文件、加密内容并生成二维码。
    返回 JSON 格式的响应，包含上传结果和二维码路径。
    """
    try:
        if 'files' not in request.files or not request.files.getlist('files'):
            return jsonify({'error': 'No files uploaded'}), 400

        files = request.files.getlist('files')
        saved_files = []

        # 加载私钥和临时私钥
        excel_path = os.path.join(ROOT_DIR, "key.xlsx")  # 私钥文件路径
        private_keys, temp_private_keys = load_keys_from_excel(excel_path)

        all_qr_paths = []

        for i, file in enumerate(files):
            if file.filename == '':
                continue  # 跳过空文件名
            file_path = os.path.join(ROOT_DIR, "uploads", file.filename)
            file.save(file_path)
            saved_files.append(file.filename)

            # 分析文件并生成二维码
            sha256_hash, file_size, file_type, base64_content = analyze_and_convert(file_path)
            header = f"{file_type}-{file_size}-{sha256_hash}-"
            data = header + base64_content
            encrypted_chunks = split_and_encrypt(data, private_keys[i], temp_private_keys[i])
            qr_images = generate_qr_codes_in_memory(encrypted_chunks, file.filename)

            # 保存二维码路径
            file_qr_folder = os.path.join(ROOT_DIR, "qrs", file.filename)
            qr_paths = [f"/static/qrs/{file.filename}/{file.filename}_qr_{j + 1}.png" for j in range(len(qr_images))]
            all_qr_paths.extend(qr_paths)

        return jsonify({
            'message': 'Files uploaded successfully!',
            'files': saved_files,
            'qr_paths': all_qr_paths
        })
    except Exception as e:
        return jsonify({'error': f'Server error: {str(e)}'}), 500

@app.route('/')
def index():
    """
    渲染首页。
    """
    return render_template_string(open(template_html_path, 'r', encoding='utf-8').read())

# ============================== 输入端功能 ==============================

def scan_qr_code():
    """
    扫描二维码。
    使用 OpenCV 打开摄像头，实时扫描二维码并返回扫描到的数据。
    """
    cap = cv2.VideoCapture(0)  # 打开摄像头
    scanned_data = []

    while True:
        ret, frame = cap.read()
        if not ret:
            print("无法读取摄像头画面")
            break

        # 使用 OpenCV 检测二维码
        detector = cv2.QRCodeDetector()
        data, bbox, _ = detector.detectAndDecode(frame)

        if data:
            scanned_data.append(data)
            print(f"已扫描二维码: {data}")

            # 显示扫描到的二维码编号
            cv2.putText(frame, f"Scanned: {len(scanned_data)}", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)

        # 显示摄像头画面
        cv2.imshow("QR Code Scanner", frame)

        # 按下 'q' 键退出
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

    cap.release()
    cv2.destroyAllWindows()
    return scanned_data

def process_scanned_data(scanned_data, private_keys):
    """
    处理解密和文件还原。
    根据扫描到的二维码数据，解密并拼接成原始文件。
    返回还原的文件内容和文件扩展名。
    """
    decrypted_chunks = {}
    file_extension = None

    for data in scanned_data:
        parts = data.split('-')
        temp_public_key = parts[0]
        encrypted_chunk = parts[1]
        file_info = parts[2]  # 包含字母编号、SHA256 和组块数量
        sha256_hash = parts[3]
        total_chunks = int(parts[4])
        extension = parts[5]  # 文件后缀

        # 确定文件后缀（仅需一次）
        if not file_extension:
            file_extension = extension

        # 获取对应的私钥
        private_key = private_keys[ord(file_info[0]) - ord('A')]  # 根据字母索引获取私钥

        # 计算共享密钥
        shared_key = compute_shared_key(temp_public_key, private_key)

        # 解密数据
        decrypted_data = decrypt_data_aes(encrypted_chunk, shared_key)
        decrypted_chunks[file_info] = decrypted_data

    # 按顺序拼接数据
    sorted_keys = sorted(decrypted_chunks.keys())  # 按文件编号排序
    full_data = ''.join([decrypted_chunks[key] for key in sorted_keys])

    # 还原文件
    file_content = base64.b64decode(full_data)
    return file_content, file_extension

def input_end_main():
    """
    输入端主函数。
    启动摄像头扫描二维码，并将扫描到的内容解密还原为文件。
    """
    excel_path = os.path.join(ROOT_DIR, "key.xlsx")  # 私钥文件路径
    private_keys = load_keys_from_excel(excel_path)

    print("开始扫描二维码...")
    scanned_data = scan_qr_code()

    if not scanned_data:
        print("未扫描到任何二维码")
        return

    print("正在处理扫描数据...")
    try:
        file_content, file_extension = process_scanned_data(scanned_data, private_keys)
        output_file = os.path.join(ROOT_DIR, f"output_file.{file_extension}")
        with open(output_file, 'wb') as f:
            f.write(file_content)
        print(f"文件已保存为: {output_file}")
    except Exception as e:
        print(f"处理失败: {str(e)}")

# ============================== 主程序入口 ==============================

def main():
    """
    主程序入口。
    用户可以选择运行输出端功能或输入端功能。
    """
    try:
        print("请选择功能：")
        print("1. 输出端功能（上传文件并生成二维码）")
        print("2. 输入端功能（扫描二维码并还原文件）")
        choice = input("请输入选项（1 或 2）：")

        if choice == '1':
            print("启动 Flask 服务器...")
            app.run(host='0.0.0.0', debug=False, port=8000)
        elif choice == '2':
            print("启动输入端功能...")
            input_end_main()
        else:
            print("无效选项，请重新运行程序。")
    except Exception as e:
        print(f"程序运行失败: {str(e)}")

if __name__ == '__main__':
    main()