Крипто примитив Хэш160 c Tea128

Поэтому сделаем этот самый пятиколесный велосипед.
Криптопримитив для лепки своих шифров или чего там вам вздумается. Выберем нестойкий хэш и сростим его на выходе с проверенным криптографическим алгоритмом.
Ну и по меньше кода, чтобы все наглядно.
Хэш 160 битный MurmurHash2_160
он быстрый, не крипто, но даст нам необходимые значения
Крипто алгоритм TEA
методом взлома 32 раундов не существует, есть что то только для 17 раундов, по всем тестам TEA примерно равен IDEA, и наврятли будет взломан в обозримое время.
И MurmurHash и TEA посторены на беззнаковых 4 байтных числах. Что удобно.
Если с выхода хэша с его 160 бит 128 подать на вход пароля, то нужно еще какое то значение (хотя бы 4+4 бита) для прокрутки TEA.
128 бит псевдо текста можно набить при промежуточных расчетах MurmurHash. Только бы значения были не совпадающими при большом массиве- выборке. Хотя это не важно, т к атака на TEA требует или кучу открытых известных до шифрования текстов, или еще большую кучу времени (из вики: Атака на 10 раундов TEA требует 2 на 52.5 выбранных открытых текстов и имеет временную сложность 2 на 84. Лучший результат — криптоанализ 17 раундов TEA. Данная атака требует всего 1920 выбранных открытых текстов, однако имеет временную сложность 2 на 123.37)

MurmurHash2_160.h
/** Крипто примитив MurmurHash2_160+TeaCrypt128 считает простой (не крипто) хэш в 160 бит+ на основе этого хэша сразу выводит 128 бит зашифрованные TEA алгоритмом (для 1 такта потокового шифования), или как 128 бит крипто хэш. Murmur хэш идет в TEA как пароль, как 128 бит текст идет сгенерированные при промежуточном счете "случайные" данные, слабо связанные с ключем уже при проходе 12 символов хэшем. Это не важно, т к даже по открытым текстам требуется 2 в 34 степени известного текста для определения ключа! // текст unsigned char text88[19]={0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x10, 0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09}; // длинна текста int int_text88=19; // это ""семя" меняет хэш при одном и том же тексте unsigned int seed88=1; // тут будет сам 160 битный хэш unsigned int hash32_88[5]={0,0,0,0,0}; // тут будет шифрованная гамма 128 бит TEA unsigned int tea7[4] ={0,0,0,0}; //вызов функции хэша-Tea MurmurHash2_160(text88,int_text88,seed88,hash32_88,tea7); */ //Для Tea uint32_t tea_k[4]; uint32_t tea_v[2]; /** TEA шифрование- https://ru.wikipedia.org/wiki/TEA v — исходный текст состоящий из двух частей по 32 бита k — ключ состоящий из четырёх 32-битных частей */ void encrypt_tea (uint32_t* v, uint32_t* k) { /* set up */ uint32_t v0 = v[0]; uint32_t v1 = v[1]; uint32_t sum = 0; uint32_t i; /* a key schedule constant */ uint32_t delta = 0x9e3779b9; /* cache key */ uint32_t k0 = k[0]; uint32_t k1 = k[1]; uint32_t k2 = k[2]; uint32_t k3 = k[3]; /* basic cycle start */ for (i = 0; i < 32; i++) { sum += delta; v0 += ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1); v1 += ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3); } /* end cycle */ v[0] = v0; v[1] = v1; } /** Функция MurmurHash2_160+TeaCrypt128 //https://simonhf.wordpress.com/2010/09/25/murmurhash160/ Note - This code makes a few assumptions about how your machine behaves - 1. We can read a 4-byte value from any address without crashing 2. sizeof(int) == 4 And it has a few limitations - 1. It will not work incrementally. 2. It will not produce the same results on little-endian and big-endian machines. плюс я не стал в конце складывать все хэши в hash32[0] = h1 ^ h2 ^ h3 ^ h4 ^ h5; а сделал временный для этого-tmp и сдвинул его циклически вправо */ void MurmurHash2_160 ( const void * key, int len, unsigned int seed, unsigned int hash32[5], //"Мешалка" для Tеа unsigned int tea_vixod[4]) { // 'm' and 'r' are mixing constants generated offline. // They're not really 'magic', they just happen to work well. const unsigned int m1 = 0x5bd1e995; const unsigned int m2 = 0x19D699A5; const unsigned int m3 = 0xB11924E1; const unsigned int m4 = 0x16118B03; const unsigned int m5 = 0x53C93455; const int r = 24; // Initialize the hash to a 'random' value unsigned int h1 = seed ^ len; /* original */ unsigned int h2 = seed ^ len ^ m2; unsigned int h3 = seed ^ len ^ m3; unsigned int h4 = seed ^ len ^ m4; unsigned int h5 = seed ^ len ^ m5; //"Мешалка" для Tеа unsigned int tea[4]={0,0,0,0}; //приходится дублировать tea_vixod[4] //т к в дебаге не видно выхода вообще, и значение по 0 идут unsigned int tmp_ta; // "волшебные" числа для Мешалки unsigned int ta1 =0x5bd1e995;unsigned int ta2 =0x19D699A5; unsigned int ta3 =0xB11924E1;unsigned int ta4 =0x16118B03; unsigned int ta5 =0x53C93455;unsigned int ta6 =0x23D194F9; unsigned int ta7 =0x99610B45;unsigned int ta8 =0xE4B01507; //"Мешалка" для Tеа // Mix 4 bytes at a time into the hash const unsigned char * data = (const unsigned char *)key; while(len >= 4) { unsigned int k1 = *(unsigned int *)data; k1 *= m1; k1 ^= k1 >> r; k1 *= m1; h1 *= m1; h1 ^= k1; h1 ^= h2; h2 *= m2; h2 ^= k1; h2 ^= h3; h3 *= m3; h3 ^= k1; h3 ^= h4; h4 *= m4; h4 ^= k1; h4 ^= h5; h5 *= m5; h5 ^= k1; h5 ^= h1; data += 4; len -= 4; //"Мешалка" для Tеа //1) 8 зависимостей if ((h2>>24)<128) tea[0]^=ta1;else tea[0]^=ta2; tea[0]=tea[0]^h1; tea[0]=(tea[0]>>3)|(tea[0]<<(32-3)); tmp_ta=h3<<8; if ((tmp_ta>>24)<128) tea[1]^=ta3;else tea[1]^=ta4; tea[1]=tea[1]^h2; tea[1]=(tea[1]>>2)|(tea[1]<<(32-2)); tmp_ta=h4<<16;if ((tmp_ta>>24)<128) tea[2]^=ta5;else tea[2]^=ta6; tea[2]=tea[2]^h3; tea[2]=(tea[2]>>1)|(tea[2]<<(32-1)); tmp_ta=h5<<24;if ((tmp_ta>>24)<128) tea[3]^=ta7;else tea[3]^=ta8; tea[3]=tea[3]^h4; tea[3]=(tea[3]>>4)|(tea[3]<<(32-4)); //2)сдвиг на 1 с чем хэширую в 8 зависимостях tmp_ta=ta1;ta1=ta2;ta2=ta3;ta3=ta4;ta4=ta5; ta5=ta6;ta6=ta7;ta7=ta8;ta8=tmp_ta; //"Мешалка" для Tеа } // Handle the last few bytes of the input array switch(len) { case 3: h1 ^= data[2] << 16; h2 ^= data[2] << 16; h3 ^= data[2] << 16; h4 ^= data[2] << 16; h5 ^= data[2] << 16; case 2: h1 ^= data[1] << 8 ; h2 ^= data[1] << 8 ; h3 ^= data[1] << 8 ; h4 ^= data[1] << 8 ; h5 ^= data[1] << 8 ; case 1: h1 ^= data[0] ; h2 ^= data[0] ; h3 ^= data[0] ; h4 ^= data[0] ; h5 ^= data[0] ; h1 *= m1 ; h2 *= m2 ; h3 *= m3 ; h4 *= m4 ; h5 *= m5 ; }; // Do a few final mixes of the hash to ensure the last few // bytes are well-incorporated. h1 ^= h1 >> 13; h1 *= m1; h1 ^= h1 >> 15; h2 ^= h2 >> 13; h2 *= m2; h2 ^= h2 >> 15; h3 ^= h3 >> 13; h3 *= m3; h3 ^= h3 >> 15; h4 ^= h4 >> 13; h4 *= m4; h4 ^= h4 >> 15; h5 ^= h5 >> 13; h5 *= m5; h5 ^= h5 >> 15; //вставка для уравнивания хэшей unsigned int tmp=0; tmp= h1 ^ h2 ^ h3 ^ h4 ^ h5; tmp = (tmp>> 13)|(tmp<< (32 - 13)); //циклический сдвиг вправо hash32[0] = h1 ^ tmp; hash32[1] = h2 ^ tmp; hash32[2] = h3 ^ tmp; hash32[3] = h4 ^ tmp; hash32[4] = h5 ^ tmp; //вставка для уравнивания хэшей //"Мешалка" для Tеа tmp= tea[0]^tea[1]^tea[2]^ tea[3]; tea[0]=tea[0]^tmp;tea[1]=tea[1]^tmp; tea[2]=tea[2]^tmp;tea[3]=tea[3]^tmp; //"Мешалка" для Tеа // отправляем в TEA tea_k[0]=hash32[0];tea_k[1]=hash32[1]; //ключ tea_k[2]=hash32[2];tea_k[3]=hash32[3]; //ключ tea_v[0]=tea[0];tea_v[1]=tea[1]; //текст 1 encrypt_tea (tea_v,tea_k); tea[0]=tea_v[0];tea[1]=tea_v[1]; // "спасаем" значение крипты tea_v[0]=tea[2];tea_v[1]=tea[3]; //текст 2 encrypt_tea (tea_v,tea_k); tea[2]=tea_v[0];tea[3]=tea_v[1]; // "спасаем" значение крипты // отправляем в TEA tea_vixod[0]=tea[0];tea_vixod[1]=tea[1]; tea_vixod[2]=tea[2];tea_vixod[3]=tea[3]; }

Что тут уже можно?

1) Пройтись хэшем по номеру гаммы N и паролю (NNNN+password).
И получить на выходе 128 битный TEA блок.
Это не лучший вариант, т к хэш состоит на основе 4 байтных слов, а тут у нас, как обычно, 4 байта int будут повторятся и иметь вид для 1 и 2 номера 0001.0001.0001.0001 и
0002.0002.0002.0002. Что даст мало различий в хэше MurmurHash2_160.

2) Пройтись с тем же по такой конструкции ((счетчик от N)+password).Уже не плохая идея. Если этот счетчик инициируется от пароля, имеет как минимум различных 8 символов, которые с каждым шагом меняются не зависимо друг от друга. К примеру счетчик из прошлой статьи (вверху Простой потоковый шифр).
Если счетчик будет еще и менять размер, и быть не четным по количеству символов (опять вспоминаем, что хэш построен на 4 байтных словах), то совсем хорошо.

3) Использовать в функции переменную int seed88=1;
При ее изменении можно проходить хэш по одному тексту с различными значениями. Как бы заменитель счетчика блока гаммы. Можно, но я бы выбрал 2)

Советы, как (а, да, с++)-

инклюдим к проекту #include "MurmurHash2_160.h" //хэш

ну и вызываем, как описано в примере-
// текст
unsigned char text88[19]={0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x10,
0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09};
// длинна текста
int int_text88=19;

// это ""семя" меняет хэш при одном и том же тексте
// тут будет сам 160 битный хэш
// тут будет шифрованная гамма 128 бит TEA

//вызов функции хэша-Tea

Помним!
Что это заготовка под потоковый шифр и еще боги знают какие извращения.
Делалась на скорую руку, вроде работает, еще позже проверю, пройдусь еще раз.
И да, солим наши пароли хотя бы 160 (в тему :) битными значениями!

Разобравшись немного с тем, что написал в коде, понял две вещи

*) Что происходит не внятно и не понятно, поэтому может быть нестойким
**) В описании к MurmurHash2_160 говорится, что параметр seed, который мог бы дать много хэшей при одном тексте работает криво. И с ним и без него у MurmurHash2_160 ищутся коллизии довольно быстро.

Поэтому пришлось составлять логическую схему
1) генерации 4-х int ов от хэша для "псевдо текста" через TEA шифр с паролем от хэша и seed
(т е получаем различный текст, зависящий от seed и хэша)
2) генерации выходного значения 4 int Tea шифра, как пароль хэш MurmurHash2_160, а текст, который шифруем, от пункта 1)

В итоге получили зашифрованный TEA текст 128 бит
а) до исходного текста 1) не добраться, не сломав TEA, и исходный текст пункта 1) все равно ничего не даст, т к.-т к "атака на TEA требует или кучу открытых известных до шифрования текстов, или еще большую кучу времени из вики"
б) до пароля, входящего в TEA тоже не добраться.
с) если а) и б) верны, то взлом крипто примитива Murmur160Tea128 v.02
сводится к взлому шифра TEA.

Кроме того получил 160 бит крипто хэша
схорив значения из 1) с хэшем

Итого, вот
потоковый шифр hifr_TEA128
крипто хэш 160бит
генератор псевдо случайных последовательностей
и это все на основе-
крипто примитива Murmur160Tea128 v.02
(все на c++)

файл
Murmur160_Tea128.h
// вызов и пример работы функции шифрования hifr_TEA128 см. внизу /**--------------------------------------------------------- Murmur160Tea128 v.02 крипто примитив MurmurHash2_160+TeaCrypt128 1)-считает защищенный криптой Tea хэш в 160 бит (используя "seed" параметр типа int для разных хэшей при одинаковом тексте) 2)-на основе этого хэша сразу выводит 128 бит зашифрованные TEA алгоритмом (для 1 такта потокового шифования), 3)-или как 128 бит псевдо случайной последовательности. // текст unsigned char text88[19]={0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x10, 0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09}; // длинна текста int int_text88=19; // параметр (номер блока) unsigned int seed88=1; //Крипто Хэш160 unsigned int hash32_88[5]={0,0,0,0,0}; //Для потокового шифра Tеа128 unsigned int tea7[4] ={0,0,0,0}; //вызов функции хэша-шифра Murmur160Tea128(text88,int_text88,seed88,hash32_88,tea7); */ //----------------------------------------------------------- /** TEA шифрование- https://ru.wikipedia.org/wiki/TEA v — исходный текст состоящий из двух частей по 32 бита k — ключ состоящий из четырёх 32-битных частей */ void encrypt_tea (uint32_t* v, uint32_t* k) { /* set up */ uint32_t v0 = v[0]; uint32_t v1 = v[1]; uint32_t sum = 0; uint32_t i; /* a key schedule constant */ uint32_t delta = 0x9e3779b9; /* cache key */ uint32_t k0 = k[0]; uint32_t k1 = k[1]; uint32_t k2 = k[2]; uint32_t k3 = k[3]; /* basic cycle start */ for (i = 0; i < 32; i++) { sum += delta; v0 += ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1); v1 += ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3); } /* end cycle */ v[0] = v0; v[1] = v1; } /** Murmur160Tea128 v.02 //https://simonhf.wordpress.com/2010/09/25/murmurhash160/ Note - This code makes a few assumptions about how your machine behaves - 1. We can read a 4-byte value from any address without crashing 2. sizeof(int) == 4 And it has a few limitations - 1. It will not work incrementally. 2. It will not produce the same results on little-endian and big-endian machines. */ void Murmur160Tea128 ( const void * key, int len, unsigned int seed, unsigned int hash32[5], //для Tеа unsigned int tea_vixod[4]) { // 'm' and 'r' are mixing constants generated offline. // They're not really 'magic', they just happen to work well. const unsigned int m1 = 0x5bd1e995; const unsigned int m2 = 0x19D699A5; const unsigned int m3 = 0xB11924E1; const unsigned int m4 = 0x16118B03; const unsigned int m5 = 0x53C93455; const int r = 24; // Initialize the hash to a 'random' value unsigned int h1 = seed ^ len; /* original */ unsigned int h2 = seed ^ len ^ m2; unsigned int h3 = seed ^ len ^ m3; unsigned int h4 = seed ^ len ^ m4; unsigned int h5 = seed ^ len ^ m5; // Mix 4 bytes at a time into the hash const unsigned char * data = (const unsigned char *)key; while(len >= 4) { unsigned int k1 = *(unsigned int *)data; k1 *= m1; k1 ^= k1 >> r; k1 *= m1; h1 *= m1; h1 ^= k1; h1 ^= h2; h2 *= m2; h2 ^= k1; h2 ^= h3; h3 *= m3; h3 ^= k1; h3 ^= h4; h4 *= m4; h4 ^= k1; h4 ^= h5; h5 *= m5; h5 ^= k1; h5 ^= h1; data += 4; len -= 4; } // Handle the last few bytes of the input array switch(len) { case 3: h1 ^= data[2] << 16; h2 ^= data[2] << 16; h3 ^= data[2] << 16; h4 ^= data[2] << 16; h5 ^= data[2] << 16; case 2: h1 ^= data[1] << 8 ; h2 ^= data[1] << 8 ; h3 ^= data[1] << 8 ; h4 ^= data[1] << 8 ; h5 ^= data[1] << 8 ; case 1: h1 ^= data[0] ; h2 ^= data[0] ; h3 ^= data[0] ; h4 ^= data[0] ; h5 ^= data[0] ; h1 *= m1 ; h2 *= m2 ; h3 *= m3 ; h4 *= m4 ; h5 *= m5 ; }; // Do a few final mixes of the hash to ensure the last few // bytes are well-incorporated. h1 ^= h1 >> 13; h1 *= m1; h1 ^= h1 >> 15; h2 ^= h2 >> 13; h2 *= m2; h2 ^= h2 >> 15; h3 ^= h3 >> 13; h3 *= m3; h3 ^= h3 >> 15; h4 ^= h4 >> 13; h4 *= m4; h4 ^= h4 >> 15; h5 ^= h5 >> 13; h5 *= m5; h5 ^= h5 >> 15; //V Tea тест unsigned int s=seed; //в h2-5Tea делаем "псевдо текст" (ключем s-h1-s-h1) // и шифруем его ключем h2-5 unsigned int h1Tea=h1; unsigned int h2Tea=h2; unsigned int h3Tea=h3; unsigned int h4Tea=h4; unsigned int h5Tea=h5; // V делаем "псевдо текст" //шифруем h2-h5 ключем s-h1-s-h1 unsigned int textTEA[2] ={0,0}; unsigned int keyTEA[4] ={0,0,0,0}; // h2 и h3 textTEA[0]=h2Tea;textTEA[1]=h3Tea; keyTEA[0]=s;keyTEA[1]=h1Tea;keyTEA[2]=s;keyTEA[3]=h1Tea; encrypt_tea (textTEA, keyTEA); h2Tea=textTEA[0];h3Tea=textTEA[1]; // спасаем зашифров // h4 и h5 textTEA[0]=h4Tea;textTEA[1]=h5Tea; encrypt_tea (textTEA, keyTEA); h4Tea=textTEA[0];h5Tea=textTEA[1]; // спасаем зашифров // на выходе у нас "псевдо текст"-h2Tea,h3Tea,h4Tea,h5Tea // ^ делаем "псевдо текст" //"спасаю", чтобы потом криптовать // хэш h2-h5 промежуточными значениями "псевдо текста" unsigned int for_h[4]={h2Tea,h3Tea,h4Tea,h5Tea}; //V шифруем "псевдо текст" ключем h2-5 textTEA[0]=h2Tea;textTEA[1]=h3Tea; keyTEA[0]=h2;keyTEA[1]=h3;keyTEA[2]=h4;keyTEA[3]=h5; encrypt_tea (textTEA, keyTEA); h2Tea=textTEA[0];h3Tea=textTEA[1]; // спасаем зашифров textTEA[0]=h4Tea;textTEA[1]=h5Tea; //ключ то же encrypt_tea (textTEA, keyTEA); h4Tea=textTEA[0];h5Tea=textTEA[1]; // спасаем зашифров // на выходе у нас Tea128-h2Tea,h3Tea,h4Tea,h5Tea //^ шифруем "псевдо текст" ключем h2-5 //"спасаем" Tea128 tea_vixod[0]=h2Tea;tea_vixod[1]=h3Tea; tea_vixod[2]=h4Tea;tea_vixod[3]=h5Tea; //V криптуем хэш h2-h5 промежуточными значениями "псевдо текста" h2=h2^for_h[0];h3=h3^for_h[1]; h4=h4^for_h[2];h5=h5^for_h[3]; //^ криптуем хэш h2-h5 промежуточными значениями "псевдо текста" //^ Tea тест hash32[0] = h1 ^ h2 ^ h3 ^ h4 ^ h5; hash32[1] = h2 ^ h1; hash32[2] = h3 ^ h1; hash32[3] = h4 ^ h1; hash32[4] = h5 ^ h1; } //MurmurHash2_160 //------------------------шифр //8 символов счетчика unsigned char t128_8[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}; //4 символа из int unsigned char t128_4[4]={0x00,0x00,0x00,0x00}; //V int4_t128 функция int в 4 символа void int4_t128 (int len_4) { t128_4[0] = len_4 >> 24;t128_4[1] = len_4 >> 16; t128_4[2] = len_4>> 8;t128_4[3] = len_4; } //^ int4_t128 функция int в 4 символа //V initil_t128 функция иницилизация- заполнение счетчика void initil_t128 (unsigned char *password, int int_passw) { // параметр (номер блока) unsigned int seed88=1; //Хэш160 unsigned int hash32_88[5]={0,0,0,0,0}; // Tеа128 unsigned int tea7[4] ={0,0,0,0}; // делаем хэш Murmur160Tea128(password,int_passw,seed88,hash32_88,tea7); //4 первых символа из хэша int4_t128 (hash32_88[0]); //в счетчик t128_8[0]=t128_4[0];t128_8[1]=t128_4[1]; t128_8[2]=t128_4[2];t128_8[3]=t128_4[3]; //4 вторых символа из хэша int4_t128 (hash32_88[1]); //в счетчик t128_8[4]=t128_4[0];t128_8[5]=t128_4[1]; t128_8[6]=t128_4[2];t128_8[7]=t128_4[3]; } //^ initil_t128 функция иницилизация- заполнение счетчика //v sdvig_t128- функция сдвига счетчика void sdvig_t128() { int tmp; //+1+3+7+11 tmp=(t128_8[0]+2)%255;t128_8[0]=tmp; tmp=(t128_8[1]+3)%255;t128_8[1]=tmp; tmp=(t128_8[2]+7)%255;t128_8[2]=tmp; tmp=(t128_8[3]+11)%255;t128_8[3]=tmp; //+11+7+1+3 tmp=(t128_8[4]+11)%255;t128_8[4]=tmp; tmp=(t128_8[5]+7)%255;t128_8[5]=tmp; tmp=(t128_8[6]+2)%255;t128_8[6]=tmp; tmp=(t128_8[7]+3)%255;t128_8[7]=tmp; } //^ sdvig_t128- функция сдвига счетчика // ---------------------------- вызов шифрования-void hifr_TEA128 /** v hifr_TEA128- функция потокового шифрования от TEA -Программа потокового шифрования методом гаммирования от прохода по (счетчику от N)+password хэша крипто примитива Murmur160Tea128 v.02 (см. описание и вызов в начале) -128 бит Tea шифра мы получаем из счетчика (8 байт)+пароль -счетчик иницилизируется от пароля и меняется по закону "разных колес" на подобии "Энигмы" как программа для теста ------------- //пароль unsigned char password55[10]={0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0x10}; //длинна пароля int int_passw55=10; // текст для шифрования unsigned char text55[20]={0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0x10, 0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0x10}; // длинна текста int int_text55=20; //шифрование hifr_TEA128 (password55,int_passw55, text55,int_text55); другие функции: 1)initil_t128- функция иницилизация- заполнение счетчика заполняются 8 байт счетчика из хэша от пароля пароля (и обратного пароля :) 2)int4_t128- функция int в 4 символа char 3)sdvig_t128- функция сдвига счетчика работает на основе "колесиков" с разным количеством зубьев так если +2, то выходит зубьев 255/2=127 +3, то выходит зубьев 255/3=85 +7, то выходит зубьев 255/7=36 +11, то выходит зубьев 255/11=23 итого 127*85*36*23=8 923 260 для 8 бит значений это будет много- 8 923 260*8 923 260 :) */ void hifr_TEA128 (unsigned char *password77, int int_passw77, unsigned char *text88, int int_text88) { // начало шифра initil_t128 (password77,int_passw77); // делаем 8 символов счетчика+ пароль unsigned char* pass_plus8 = new unsigned char[int_passw77+8]; //заполняем пароль for (int i = 0; i <int_passw77; i++) {pass_plus8[i+8]=password77[i];} int stet_16=0; //счетчик 1-16 для генерации нового TEA unsigned char stet_16t[16]={0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}; for (int i_128 = 0; i_128 <int_text88; i_128++)// цикл шифрования текста { sdvig_t128(); //сдвиг счетчика //запись счетчика к паролю for (int i2=0; i2 < 8; i2++)pass_plus8[i2]=t128_8[i2]; if(stet_16==0)//делаем гамму TEA128 { //хэш от счетчика+пароля // параметр (номер блока) unsigned int seed99=1; //Хэш160 unsigned int hash32_99[5]={0,0,0,0,0}; // Tеа128 unsigned int tea9[4] ={0,0,0,0}; // делаем хэш Murmur160Tea128(pass_plus8,(int_passw77+8),seed99,hash32_99,tea9); //TEA из int в unsigned char int4_t128 (tea9[0]); //из int в unsigned char t128_4 stet_16t[0]=t128_4[0];stet_16t[1]=t128_4[1]; stet_16t[2]=t128_4[2];stet_16t[3]=t128_4[3]; int4_t128 (tea9[1]); //из int в unsigned char t128_4 stet_16t[4]=t128_4[0];stet_16t[5]=t128_4[1]; stet_16t[6]=t128_4[2];stet_16t[7]=t128_4[3]; int4_t128 (tea9[2]); //из int в unsigned char t128_4 stet_16t[8]=t128_4[0];stet_16t[9]=t128_4[1]; stet_16t[10]=t128_4[2];stet_16t[11]=t128_4[3]; int4_t128 (tea9[3]); //из int в unsigned char t128_4 stet_16t[12]=t128_4[0];stet_16t[13]=t128_4[1]; stet_16t[14]=t128_4[2];stet_16t[15]=t128_4[3]; }//if(stet_16=0) // само шифрование text88[i_128]=text88[i_128]^stet_16t[stet_16]; stet_16++; if (stet_16==16){stet_16=0;} //TEA128 генерировать заново }// i_128 delete[] pass_plus8; //память от динамич массива //конец шифра } //v hifr_TEA128- функция потокового шифрования от TEA

шифрование:
инклюдим к проекту-

#include "Murmur160_Tea128.h"

само шифрование пример описан в коде Murmur160_Tea128.h внизу:

как программа для теста

---

//пароль
unsigned char password55[10]={0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0x10};
//длинна пароля
int int_passw55=10;
// текст для шифрования
unsigned char text55[20]={0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0x10,
0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0x10};
// длинна текста
int int_text55=20;
//шифрование
hifr_TEA128 (password55,int_passw55,
text55,int_text55);

И не забываем, что это потоковый шифр, солите пароли 160 битным значением. К примеру тем же хэшем от не зашифрованного текста :)

Нашел 1 ошибку, устранил 2 слабости алгоритма
версия 02_1

Murmur160_Tea128.h
// вызов и пример работы функции шифрования hifr_TEA128 см. внизу /**--------------------------------------------------------- Murmur160Tea128 v.02_1 крипто примитив MurmurHash2_160+TeaCrypt128 1)-считает защищенный криптой Tea хэш в 160 бит (используя "seed" параметр типа int для разных хэшей при одинаковом тексте) 2)-на основе этого хэша сразу выводит 128 бит зашифрованные TEA алгоритмом (для 1 такта потокового шифования), 3)-или как 128 бит псевдо случайной последовательности. // текст unsigned char text88[19]={0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x10, 0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09}; // длинна текста int int_text88=19; // параметр (номер блока) unsigned int seed88=1; //Крипто Хэш160 unsigned int hash32_88[5]={0,0,0,0,0}; //Для потокового шифра Tеа128 unsigned int tea7[4] ={0,0,0,0}; //вызов функции хэша-шифра Murmur160Tea128(text88,int_text88,seed88,hash32_88,tea7); */ //----------------------------------------------------------- /** TEA шифрование- https://ru.wikipedia.org/wiki/TEA v — исходный текст состоящий из двух частей по 32 бита k — ключ состоящий из четырёх 32-битных частей */ void encrypt_tea (uint32_t* v, uint32_t* k) { /* set up */ uint32_t v0 = v[0]; uint32_t v1 = v[1]; uint32_t sum = 0; uint32_t i; /* a key schedule constant */ uint32_t delta = 0x9e3779b9; /* cache key */ uint32_t k0 = k[0]; uint32_t k1 = k[1]; uint32_t k2 = k[2]; uint32_t k3 = k[3]; /* basic cycle start */ for (i = 0; i < 32; i++) { sum += delta; v0 += ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1); v1 += ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3); } /* end cycle */ v[0] = v0; v[1] = v1; } /** Murmur160Tea128 v.02 //https://simonhf.wordpress.com/2010/09/25/murmurhash160/ Note - This code makes a few assumptions about how your machine behaves - 1. We can read a 4-byte value from any address without crashing 2. sizeof(int) == 4 And it has a few limitations - 1. It will not work incrementally. 2. It will not produce the same results on little-endian and big-endian machines. */ void Murmur160Tea128 ( const void * key, int len, unsigned int seed, unsigned int hash32[5], //для Tеа unsigned int tea_vixod[4]) { // 'm' and 'r' are mixing constants generated offline. // They're not really 'magic', they just happen to work well. const unsigned int m1 = 0x5bd1e995; const unsigned int m2 = 0x19D699A5; const unsigned int m3 = 0xB11924E1; const unsigned int m4 = 0x16118B03; const unsigned int m5 = 0x53C93455; const int r = 24; // Initialize the hash to a 'random' value unsigned int h1 = seed ^ len; /* original */ unsigned int h2 = seed ^ len ^ m2; unsigned int h3 = seed ^ len ^ m3; unsigned int h4 = seed ^ len ^ m4; unsigned int h5 = seed ^ len ^ m5; // Mix 4 bytes at a time into the hash const unsigned char * data = (const unsigned char *)key; while(len >= 4) { unsigned int k1 = *(unsigned int *)data; k1 *= m1; k1 ^= k1 >> r; k1 *= m1; h1 *= m1; h1 ^= k1; h1 ^= h2; h2 *= m2; h2 ^= k1; h2 ^= h3; h3 *= m3; h3 ^= k1; h3 ^= h4; h4 *= m4; h4 ^= k1; h4 ^= h5; h5 *= m5; h5 ^= k1; h5 ^= h1; data += 4; len -= 4; } // Handle the last few bytes of the input array switch(len) { case 3: h1 ^= data[2] << 16; h2 ^= data[2] << 16; h3 ^= data[2] << 16; h4 ^= data[2] << 16; h5 ^= data[2] << 16; case 2: h1 ^= data[1] << 8 ; h2 ^= data[1] << 8 ; h3 ^= data[1] << 8 ; h4 ^= data[1] << 8 ; h5 ^= data[1] << 8 ; case 1: h1 ^= data[0] ; h2 ^= data[0] ; h3 ^= data[0] ; h4 ^= data[0] ; h5 ^= data[0] ; h1 *= m1 ; h2 *= m2 ; h3 *= m3 ; h4 *= m4 ; h5 *= m5 ; }; // Do a few final mixes of the hash to ensure the last few // bytes are well-incorporated. h1 ^= h1 >> 13; h1 *= m1; h1 ^= h1 >> 15; h2 ^= h2 >> 13; h2 *= m2; h2 ^= h2 >> 15; h3 ^= h3 >> 13; h3 *= m3; h3 ^= h3 >> 15; h4 ^= h4 >> 13; h4 *= m4; h4 ^= h4 >> 15; h5 ^= h5 >> 13; h5 *= m5; h5 ^= h5 >> 15; //V Tea тест unsigned int s=seed; //в h2-5Tea делаем "псевдо текст" (ключем s-h1-s-h1) // и шифруем его ключем h2-5 unsigned int h1Tea=h1; // выходит не используется :) unsigned int h2Tea=h2; unsigned int h3Tea=h3; unsigned int h4Tea=h4; unsigned int h5Tea=h5; //1) V делаем "псевдо текст" //шифруем h2-h5 ключем s-h1-s-h1 unsigned int textTEA[2] ={0,0}; unsigned int keyTEA[4] ={0,0,0,0}; // h2 и h3 textTEA[0]=h2Tea;textTEA[1]=h3Tea;//делает тект для его шифрования keyTEA[0]=s^h5;keyTEA[1]=h1^h3;//делаем ключ keyTEA[2]=s^h4;keyTEA[3]=h1^h2;//делаем ключ encrypt_tea (textTEA, keyTEA);//шифруем TEA h2Tea=textTEA[0];h3Tea=textTEA[1]; // спасаем зашифров // h4 и h5 textTEA[0]=h4Tea;textTEA[1]=h5Tea;//делает тект для его шифрования //ключ тот же encrypt_tea (textTEA, keyTEA);//шифруем TEA h4Tea=textTEA[0];h5Tea=textTEA[1]; // спасаем зашифров // на выходе у нас "псевдо текст"-h2Tea,h3Tea,h4Tea,h5Tea // ^ делаем "псевдо текст" //"спасаю", чтобы потом криптовать // хэш h2-h5 промежуточными значениями "псевдо текста" unsigned int for_h[4]={h2Tea,h3Tea,h4Tea,h5Tea}; //2)V шифруем "псевдо текст" ключем h2-5 textTEA[0]=h2Tea;textTEA[1]=h3Tea;// текст для шифрования keyTEA[0]=h2;keyTEA[1]=h3;keyTEA[2]=h4;keyTEA[3]=h5; encrypt_tea (textTEA, keyTEA);//шифруем TEA h2Tea=textTEA[0];h3Tea=textTEA[1]; // спасаем зашифров textTEA[0]=h4Tea;textTEA[1]=h5Tea;// текст для шифрования //ключ то же encrypt_tea (textTEA, keyTEA);//шифруем TEA h4Tea=textTEA[0];h5Tea=textTEA[1]; // спасаем зашифров // на выходе у нас Tea128-h2Tea,h3Tea,h4Tea,h5Tea //^ шифруем "псевдо текст" ключем h2-5 //"спасаем" Tea128 tea_vixod[0]=h2Tea;tea_vixod[1]=h3Tea; tea_vixod[2]=h4Tea;tea_vixod[3]=h5Tea; //3)V криптуем хэш h2-h5 промежуточными значениями "псевдо текста" h1=h1^for_h[0];h2=h2^for_h[1]; h3=h3^for_h[2];h4=h4^for_h[3]; h5=h5^(h2^h3); //^ криптуем хэш h2-h5 промежуточными значениями "псевдо текста" //^ Tea тест hash32[0] = h1 ^ h2 ^ h3 ^ h4 ^ h5; hash32[1] = h2 ^ h1; hash32[2] = h3 ^ h1; hash32[3] = h4 ^ h1; hash32[4] = h5 ^ h1; } //MurmurHash2_160 //------------------------шифр //8 символов счетчика unsigned char t128_8[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}; //4 символа из int unsigned char t128_4[4]={0x00,0x00,0x00,0x00}; //V int4_t128 функция int в 4 символа void int4_t128 (int len_4) { t128_4[0] = len_4 >> 24;t128_4[1] = len_4 >> 16; t128_4[2] = len_4>> 8;t128_4[3] = len_4; } //^ int4_t128 функция int в 4 символа //V initil_t128 функция иницилизация- заполнение счетчика void initil_t128 (unsigned char *password, int int_passw) { // параметр (номер блока) unsigned int seed88=1; //Хэш160 unsigned int hash32_88[5]={0,0,0,0,0}; // Tеа128 unsigned int tea7[4] ={0,0,0,0}; // делаем хэш Murmur160Tea128(password,int_passw,seed88,hash32_88,tea7); //4 первых символа из хэша int4_t128 (hash32_88[0]); //в счетчик t128_8[0]=t128_4[0];t128_8[1]=t128_4[1]; t128_8[2]=t128_4[2];t128_8[3]=t128_4[3]; //4 вторых символа из хэша int4_t128 (hash32_88[1]); //в счетчик t128_8[4]=t128_4[0];t128_8[5]=t128_4[1]; t128_8[6]=t128_4[2];t128_8[7]=t128_4[3]; } //^ initil_t128 функция иницилизация- заполнение счетчика //v sdvig_t128- функция сдвига счетчика void sdvig_t128() { int tmp; //+1+3+7+11 tmp=(t128_8[0]+2)%255;t128_8[0]=tmp; tmp=(t128_8[1]+3)%255;t128_8[1]=tmp; tmp=(t128_8[2]+7)%255;t128_8[2]=tmp; tmp=(t128_8[3]+11)%255;t128_8[3]=tmp; //+11+7+1+3 tmp=(t128_8[4]+11)%255;t128_8[4]=tmp; tmp=(t128_8[5]+7)%255;t128_8[5]=tmp; tmp=(t128_8[6]+2)%255;t128_8[6]=tmp; tmp=(t128_8[7]+3)%255;t128_8[7]=tmp; } //^ sdvig_t128- функция сдвига счетчика // ---------------------------- вызов шифрования-void hifr_TEA128 /** v hifr_TEA128- функция потокового шифрования от TEA -Программа потокового шифрования методом гаммирования от прохода по (счетчику от N)+password хэша крипто примитива Murmur160Tea128 v.02 (см. описание и вызов в начале) -128 бит Tea шифра мы получаем из счетчика (8 байт)+пароль -счетчик иницилизируется от пароля и меняется по закону "разных колес" на подобии "Энигмы" как программа для теста ------------- //пароль unsigned char password55[10]={0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0x10}; //длинна пароля int int_passw55=10; // текст для шифрования unsigned char text55[20]={0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0x10, 0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0x10}; // длинна текста int int_text55=20; //шифрование hifr_TEA128 (password55,int_passw55, text55,int_text55); другие функции: 1)initil_t128- функция иницилизация- заполнение счетчика заполняются 8 байт счетчика из хэша от пароля пароля (и обратного пароля :) 2)int4_t128- функция int в 4 символа char 3)sdvig_t128- функция сдвига счетчика работает на основе "колесиков" с разным количеством зубьев так если +2, то выходит зубьев 255/2=127 +3, то выходит зубьев 255/3=85 +7, то выходит зубьев 255/7=36 +11, то выходит зубьев 255/11=23 итого 127*85*36*23=8 923 260 для 8 бит значений это будет много- 8 923 260*8 923 260 :) */ void hifr_TEA128 (unsigned char *password77, int int_passw77, unsigned char *text88, int int_text88) { // начало шифра initil_t128 (password77,int_passw77); // делаем 8 символов счетчика+ пароль unsigned char* pass_plus8 = new unsigned char[int_passw77+8]; //заполняем пароль for (int i = 0; i <int_passw77; i++) {pass_plus8[i+8]=password77[i];} int stet_16=0; //счетчик 1-16 для генерации нового TEA unsigned char stet_16t[16]={0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}; for (int i_128 = 0; i_128 <int_text88; i_128++)// цикл шифрования текста { if(stet_16==0)//делаем гамму TEA128 { sdvig_t128(); //сдвиг счетчика //запись счетчика к паролю for (int i2=0; i2 < 8; i2++)pass_plus8[i2]=t128_8[i2]; //хэш от счетчика+пароля // параметр (номер блока) unsigned int seed99=1; //Хэш160 unsigned int hash32_99[5]={0,0,0,0,0}; // Tеа128 unsigned int tea9[4] ={0,0,0,0}; // делаем хэш Murmur160Tea128(pass_plus8,(int_passw77+8),seed99,hash32_99,tea9); //TEA из int в unsigned char int4_t128 (tea9[0]); //из int в unsigned char t128_4 stet_16t[0]=t128_4[0];stet_16t[1]=t128_4[1]; stet_16t[2]=t128_4[2];stet_16t[3]=t128_4[3]; int4_t128 (tea9[1]); //из int в unsigned char t128_4 stet_16t[4]=t128_4[0];stet_16t[5]=t128_4[1]; stet_16t[6]=t128_4[2];stet_16t[7]=t128_4[3]; int4_t128 (tea9[2]); //из int в unsigned char t128_4 stet_16t[8]=t128_4[0];stet_16t[9]=t128_4[1]; stet_16t[10]=t128_4[2];stet_16t[11]=t128_4[3]; int4_t128 (tea9[3]); //из int в unsigned char t128_4 stet_16t[12]=t128_4[0];stet_16t[13]=t128_4[1]; stet_16t[14]=t128_4[2];stet_16t[15]=t128_4[3]; }//if(stet_16=0) // само шифрование text88[i_128]=text88[i_128]^stet_16t[stet_16]; stet_16++; if (stet_16==16){stet_16=0;} //TEA128 генерировать заново }// i_128 delete[] pass_plus8; //память от динамич массива //конец шифра } //v hifr_TEA128- функция потокового шифрования от TEA

Далее смотрите мою модификацию RC4 шифра-
Потоковый шифр RC4 s256, возрождение RC4
и пишите, если есть какие то идеи или заметили ошибки в реализации! Больше народу крепче наши ряды киберпанков!!!