Come rompere il mio giocattolo? [duplicare]

Quando ero bambino adoravo giocare con i blocchi Lego, era magico. Non posso dire che sono cambiato completamente. Oggi stavo giocando con le funzioni di hash e ho deciso di costruire il mio ToyCipher , spero che nessuno abbia un marchio su di esso ... Produce un valore a 256 bit che è xored con il testo normale. Il valore è prodotto da hash uno stato e una chiave.

Ora che ci ho giocato e mi sono divertito, è tempo di buttarlo giù e ricominciare da capo, ma non so come. Qualcuno di voi estranei gentili, per favore, aiutami a trovare il modo più semplice per romperlo?

Il codice sorgente dell'intestazione:

#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

e l'implementazione:

#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;
  }
}