Random Pixel

import random, time, numpy
from PIL import Image
from secret import FLAG

def randomize(img, seed):
	random.seed(seed)
	new_y = list(range(img.shape[0]))
	new_x = list(range(img.shape[1]))
	random.shuffle(new_y)
	random.shuffle(new_x)

	new = numpy.empty_like(img)
	for i, y in enumerate(new_y):
		for j, x in enumerate(new_x):
			new[i][j] = img[y][x]
	return numpy.array(new)


if __name__ == "__main__":
	with Image.open(FLAG) as f:
		img = numpy.array(f)
		out = randomize(img, int(time.time()))
		image = Image.fromarray(out)
		image.save("encrypted.png")

import random
import numpy as np
from PIL import Image
import os

def get_seed_from_mtime(file_path):

    mtime = os.path.getmtime(file_path)
    unix_timestamp = int(mtime)
    return unix_timestamp

def reverse_randomize(encrypted_img, seed):
    random.seed(seed)
    height, width = encrypted_img.shape[:2]

    new_y = list(range(height))
    new_x = list(range(width))
    random.shuffle(new_y)
    random.shuffle(new_x)

    inverse_y = [0] * height
    inverse_x = [0] * width
    for i, y in enumerate(new_y):
        inverse_y[y] = i
    for j, x in enumerate(new_x):
        inverse_x[x] = j

    decrypted_img = np.empty_like(encrypted_img)

    for i in range(height):
        for j in range(width):
            decrypted_img[i][j] = encrypted_img[inverse_y[i]][inverse_x[j]]

    return decrypted_img

encrypted_image_path = 'encrypted.png'
decrypted_image_path = 'decrypted.png'

seed = get_seed_from_mtime(encrypted_image_path)

with Image.open(encrypted_image_path) as img:
    img = img.convert('RGB')
    encrypted_array = np.array(img)

decrypted_array = reverse_randomize(encrypted_array, seed)

decrypted_image = Image.fromarray(decrypted_array)
decrypted_image.save(decrypted_image_path)

print(f"Decrypted image saved as {decrypted_image_path}")

# from @tommy_kay

import random
import numpy as np
from PIL import Image


def reverse_randomize(shuffled_img, seed):
    random.seed(seed)
    new_y = list(range(shuffled_img.shape[0]))
    new_x = list(range(shuffled_img.shape[1]))
    shuffled_y = new_y.copy()
    shuffled_x = new_x.copy()
    random.shuffle(shuffled_y)
    random.shuffle(shuffled_x)
    original = np.empty_like(shuffled_img)
    for i, y in enumerate(shuffled_y):
        for j, x in enumerate(shuffled_x):
            original[y][x] = shuffled_img[i][j]
    return np.array(original)


shuffled_image_path = "encrypted.png"
epoch_time = 1727902960  # Obtain from file properties and convert to unix time

with Image.open(shuffled_image_path) as img:
    shuffled_img = np.array(img)
    original_img = reverse_randomize(shuffled_img, epoch_time)
    original_image_path = "original_image.png"  # Path to save the original image
    original_image = Image.fromarray(original_img)
    original_image.save(original_image_path)

# @rockandroll
import time

# Input date and time string
# date_string = "5 October 2024 19:00:35"
date_string = "3 October 2024 00:32:40"

# Convert the date string to a time struct
time_struct = time.strptime(date_string, "%d %B %Y %H:%M:%S")

# Convert the time struct to a timestamp
timestamp = time.mktime(time_struct)


import random
import numpy
from PIL import Image

def recover_image(img, seed):
    # Set the same seed used for randomization
    random.seed(seed)

    # Get the height and width of the image
    height, width = img.shape[0], img.shape[1]

    # Create the shuffled indices
    new_y = list(range(height))
    new_x = list(range(width))
    random.shuffle(new_y)
    random.shuffle(new_x)

    # Reverse the shuffling
    recovered = numpy.empty_like(img)
    for i, y in enumerate(new_y):
        for j, x in enumerate(new_x):
            recovered[y][x] = img[i][j]

    return numpy.array(recovered)

if __name__ == "__main__":
    with Image.open('encrypted.png') as f:
        img = numpy.array(f)
        recovered = recover_image(img, int(timestamp))
        image = Image.fromarray(recovered)
        image.save("recovered_flag.png")