Quick code to scramble / unscramble an image given a key.

permute-image.c

#include <ccan/array_size/array_size.h>
#include <ccan/asort/asort.h>
#include <ccan/crypto/sha256/sha256.h>
#include <ccan/err/err.h>
#include <ccan/str/hex/hex.h>
#include <ccan/short_types/short_types.h>
#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include <SDL2/SDL_pixels.h>

#define GRIDBITS 4
#define GRIDPIX (1 << GRIDBITS)

static u8 *pixpos(SDL_Surface *image, size_t x, size_t y)
{
	u8 *p = image->pixels;

	/* Get to correct row, then correct byte */
	return p + image->pitch * y + image->format->BytesPerPixel * x;
}

static u32 get_pixelval(const u8 *p, int bytes_per_pixel)
{
	if (bytes_per_pixel == 3)
		return ((u32)p[0] << 16) | ((u32)p[1] << 8) | p[2];
	else if (bytes_per_pixel == 4)
		return *(u32 *)p;
	else
		errx(1, "FIXME: Support %u BytesPerPixel!",
		     bytes_per_pixel);
}

static void put_pixelval(u8 *p, int bytes_per_pixel, u32 pixel)
{
	if (bytes_per_pixel == 3) {
		p[0] = pixel >> 16;
		p[1] = pixel >> 8;
		p[2] = pixel;
	} else if (bytes_per_pixel == 4)
		*(u32 *)p = pixel;
	else
		errx(1, "FIXME: Support %u BytesPerPixel!",
		     bytes_per_pixel);
}

struct coord {
	u16 key;
	u8 x, y;
};

static int cmp_key(const struct coord *a, const struct coord *b, void *unused)
{
	if (a->key < b->key)
		return -1;
	else if (a->key > b->key)
		return 1;
	return 0;
}

static u16 get_16_bits(struct sha256 *val, size_t *bytes_used)
{
	u16 v;

	/* Need more bits?  Hash again */
	if (*bytes_used + 2 > sizeof(*val)) {
		sha256(val, val, sizeof(*val));
		*bytes_used = 0;
	}

	v = ((u16)val->u.u8[*bytes_used] << 8) | val->u.u8[*bytes_used + 1];
	(*bytes_used) += 2;
	return v;
}

/* To make swap reversible, we can only swap pairs once.
 * Simplest algorithm is sort by a key, and swap in pairs.
 */
static void scramble_grid(SDL_Surface *image,
			  size_t x, size_t y,
			  struct sha256 *val)
{
	struct coord coords[GRIDPIX * GRIDPIX];
	size_t bytes_used = 0;

	for (size_t i = 0; i < ARRAY_SIZE(coords); i++) {
		coords[i].key = get_16_bits(val, &bytes_used);
		coords[i].x = i % GRIDPIX;
		coords[i].y = i / GRIDPIX;
	}

	asort(coords, ARRAY_SIZE(coords), cmp_key, NULL);

	for (size_t i = 0; i < ARRAY_SIZE(coords); i += 2) {
		u8 *p1 = pixpos(image, x + coords[i].x, y + coords[i].y);
		u8 *p2 = pixpos(image, x + coords[i+1].x, y + coords[i+1].y);
		u32 p1val = get_pixelval(p1, image->format->BytesPerPixel);
		u32 p2val = get_pixelval(p2, image->format->BytesPerPixel);
		put_pixelval(p1, image->format->BytesPerPixel, p2val);
		put_pixelval(p2, image->format->BytesPerPixel, p1val);
	}
}

int main(int argc, char *argv[])
{
	struct sha256 val;

	if (argc != 4)
		errx(1, "Usage: permute-image 64-hexchars in.png out.png");

	if (!hex_decode(argv[1], strlen(argv[1]), &val, sizeof(val)))
		errx(1, "Invalid seed");

	if (SDL_Init(SDL_INIT_VIDEO) == -1)
		errx(1, "SDL init failed: %s", SDL_GetError());

	SDL_Surface *image = IMG_Load(argv[2]);
	SDL_LockSurface(image);

	for (size_t x = 0; x + GRIDPIX <= image->w; x += GRIDPIX) {
		for (size_t y = 0; y + GRIDPIX <= image->h; y += GRIDPIX) {
			scramble_grid(image, x, y, &val);
		}
	}
	SDL_UnlockSurface(image);
	IMG_SavePNG(image, argv[3]);
	return 0;
}