¿Cómo romper mi juguete? [duplicar]

Cuando era niño me encantaba jugar con los bloques de Lego, fue mágico. No puedo decir que haya cambiado por completo. Hoy jugaba con funciones hash y decidí crear mi propio ToyCipher , espero que nadie tenga una marca registrada ... Produce un valor de 256 bits que es xored con el texto plano. El valor se produce mediante hashing de un estado y una clave.

Ahora que he jugado con él y me he divertido, es hora de derribarlo y comenzar de nuevo, pero no sé cómo. ¿Alguno de ustedes, extraños, me ayudaría a encontrar la forma más sencilla de romperlo?

El código fuente del encabezado:

#ifndef TOY_CIPHER_H
#define TOY_CIPHER_H

typedef struct {
  unsigned char state[32];
  unsigned char key[32];
} ToyCtx;

void toycipher_init(ToyCtx* tc, unsigned char const* key,
                    unsigned char const* iv);

// must be a multiple of 32
void toycipher_encrypt(ToyCtx* tc, unsigned char const* in, int in_size,
                       unsigned char* out);
void toycipher_decrypt(ToyCtx* tc, unsigned char const* in, int in_size,
                       unsigned char* out);

#endif

y la implementación:

#include "toy_cipher.h"
#include <stdint.h>
#include <string.h>
#include <openssl/sha.h>
#include <assert.h>

// Private
static void _xor32(uint64_t* dest, uint64_t const* in, uint64_t const* key)
{
  for(int i = 0; i < 4; ++i)
    *dest++ = *in++ ^ *key++;
}

// Public
void toycipher_init(ToyCtx* tc, unsigned char const* key,
                    unsigned char const* iv)
{
  memcpy(tc->state, iv, 32);
  memcpy(tc->key, key, 32);
}

// must be a multiple of 32
void toycipher_encrypt(ToyCtx* tc, unsigned char const* in, int in_size,
                       unsigned char* out)
{
  assert((in_size % 32) == 0);

  int n = in_size >> 5; // in_size / 32
  while(n){
    uint64_t k[4];
    SHA256((unsigned char const*)tc, 64, (unsigned char*)k);
    _xor32((uint64_t*)out, (uint64_t*)in, k);
    memcpy(tc->state, out, 32);
    in += 32;
    out += 32;
    --n;
  }
}

void toycipher_decrypt(ToyCtx* tc, unsigned char const* in, int in_size,
                       unsigned char* out)
{
  assert((in_size % 32) == 0);

  int n = in_size >> 5; // in_size / 32
  while(n){
    uint64_t k[4];
    SHA256((unsigned char const*)tc, 64, (unsigned char*)k);
    memcpy(tc->state, in, 32);
    _xor32((uint64_t*)out, (uint64_t*)in, k);
    in += 32;
    out += 32;
    --n;
  }
}