Стеганография в видео

import cv2
from PIL import Image
import numpy as np
 
def encrypt_message(message, key):
    # шифр Виженера
    encrypted_message = ""
    key_length = len(key)
 
    for i, char in enumerate(message):
        key_char = key[i % key_length]
        encrypted_char = chr(ord(char) ^ ord(key_char))  # Используем XOR с символами ключа
        encrypted_message += encrypted_char
 
    return encrypted_message
 
 
def decrypt_message(encrypted_message, key):
    decrypted_message = ""
    key_length = len(key)
 
    for i, char in enumerate(encrypted_message):
        key_char = key[i % key_length]
        decrypted_char = chr(ord(char) ^ ord(key_char))  # Используем XOR с символами ключа
        decrypted_message += decrypted_char
 
    return decrypted_message
 
 
def encrypt_image(text, key, pixels):
    # Создаем список битов текста (каждый символ текста должен представлять 8 бит в двоичном формате)
    encrypted_message = encrypt_message(text, key)
    symbols = "###"
    encrypted_message_with_symbols = encrypted_message + symbols
 
    bitmask = []
    for symbol in encrypted_message_with_symbols:
        # Преобразуем символы текста в бинарный формат и добавляем их к битовой маске
        bitmask_symbol = ["0" for i in range(8 - len(bin(ord(symbol))[2:]))] + [bit for bit in bin(ord(symbol))[2:]]
        bitmask.extend(bitmask_symbol)
 
    # Создаем список байтов изображения из списка пикселей (пиксель содержит 3 байта)
    pixel_bytes = []
    for pixel in pixels:
        pixel_bytes.extend(pixel)
 
    # Начинаем запись битов текста в байты изображения
    pixels_output = []
    for i, pxl_byte in enumerate(pixel_bytes):
        # Когда биты текста закончились, записываем последние пиксели
        if i > len(bitmask) - 1:
            pixels_output[-1].extend(pixel_bytes[i:3 - len(pixels_output[-1]) + i])  # заполняем отсутствующие байты в пикселе
            for pixel in pixels[len(pixels_output):]:
                pixels_output.append(list(pixel))
            pixels_output[-1][-1] = len(encrypted_message_with_symbols)  # Запоминаем длину текста, необходимую для чтения изображения
            break
 
        bin_byte = bin(pxl_byte)[2:-1] + bitmask[i]  # изменяем последний бит в байте изображения
 
        # Создаем новый пиксель
        if i % 3 == 0:
            pixels_output.append([int(bin_byte, 2)])
        else:
            pixels_output[-1].append(int(bin_byte, 2))
 
    return pixels_output
 
def decrypt_image(pixels, key):
    # Создаем список байтов изображения из списка пикселей (пиксель содержит 3 байта)
    pixel_bytes = []
    for pixel in pixels:
        pixel_bytes.extend(pixel)
 
    bin_text = []
    text_len = pixel_bytes[-1]
    bits_in_text = text_len * 8
    for i, byte in enumerate(pixel_bytes[:bits_in_text]):
        # Создаем байты текста
        if i % 8 == 0:
            bin_text.append(bin(byte)[2:][-1])
        else:
            bin_text[-1] += bin(byte)[2:][-1]
 
    # Создаем текст изображения
    text = ""
    for bin_symbol in bin_text:
        text += chr(int(bin_symbol, 2))
 
    symbols = "###"
 
    decrypted_message = text[:-len(symbols)]
    decrypted_message = decrypt_message(decrypted_message, key)
 
    return decrypted_message
 
def get_all_pixels(image):
    all_pixels = []
 
    for y in range(image.height):
        for x in range(image.width):
            all_pixels.append(image.getpixel((x, y)))
 
    return all_pixels
 
def create_image_with_text(original_image, text_pixels):
    width = original_image.width
    height = original_image.height
    image_with_text = Image.new("RGB", (width, height))
 
    for y in range(height):
        for x in range(width):
            image_with_text.putpixel((x, y), tuple(text_pixels.pop(0)))
 
    return image_with_text
 
def encode_vid_frame(video_path, result_path, frame_num, text, key):
    cap = cv2.VideoCapture(video_path)
    fps = cap.get(cv2.CAP_PROP_FPS)
    fourcc = cv2.VideoWriter_fourcc('m', 'p', '4', 'v')
    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
    out = cv2.VideoWriter(result_path, fourcc, fps, (width, height))
 
    i = 0
    while cap.isOpened():
        ret, frame = cap.read()
        if not ret:
            break
 
        if i == frame_num:
            image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
            pil_frame = Image.fromarray(image)
            pixels = get_all_pixels(pil_frame)
            pil_frame_pixels_with_text = encrypt_image(text, key, pixels)
            pil_frame_with_text = create_image_with_text(pil_frame, pil_frame_pixels_with_text)
            encoded_frame = cv2.cvtColor(np.array(pil_frame_with_text), cv2.COLOR_RGB2BGR)
 
 
            new_image = cv2.cvtColor(encoded_frame, cv2.COLOR_BGR2RGB)
            new_pil_frame = Image.fromarray(new_image)
            all_pixels = get_all_pixels(new_pil_frame)
            text_from_image = decrypt_image(all_pixels, key)
            print("Текст в картинке: " + text_from_image)
 
            out.write(encoded_frame)
        else:
            out.write(frame)
 
        i += 1
 
    cap.release()
    out.release()
    cv2.destroyAllWindows()
 
def decode_vid_frame(video_path, frame_num, key):
    cap = cv2.VideoCapture(video_path)
    i = 0
 
    while cap.isOpened():
        ret, frame = cap.read()
        if not ret:
            break
 
        if i == frame_num:
            image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
            pil_frame = Image.fromarray(image)
            pixels = get_all_pixels(pil_frame)
            decrypted_message = decrypt_image(pixels, key)
            return decrypted_message
 
        i += 1
 
    cap.release()
    cv2.destroyAllWindows()
 
encode_vid_frame("file_142.mp4", "file_stego.mp4", 2, "voskhod", "123")
print(decode_vid_frame("file_stego.mp4", 2, "123"))