— Morfeys (07/02/2018 13:25, исправлен 07/02/2018 13:27)   

Поэтому сделаем этот самый пятиколесный велосипед.
Криптопримитив для лепки своих шифров или чего там вам вздумается. Выберем нестойкий хэш и сростим его на выходе с проверенным криптографическим алгоритмом.
Ну и по меньше кода, чтобы все наглядно.
Хэш 160 битный MurmurHash2_160^[link3]
он быстрый, не крипто, но даст нам необходимые значения
Крипто алгоритм TEA^[link4]
методом взлома 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)

— Morfeys (07/02/2018 13:29)   
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]; }

— Morfeys (07/02/2018 13:48)   
Что тут уже можно?

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 (в тему :) битными значениями!

— Morfeys (13/02/2018 03:04)   
Разобравшись немного с тем, что написал в коде, понял две вещи

*) Что происходит не внятно и не понятно, поэтому может быть нестойким
**) В описании к 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++)

— Morfeys (13/02/2018 03:06)   
файл
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

— Morfeys (13/02/2018 03:12, исправлен 13/02/2018 03:13)   

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

#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 битным значением. К примеру тем же хэшем от не зашифрованного текста :)

— Morfeys (15/02/2018 23:18)   
Нашел 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

— Morfeys (28/02/2018 15:57)   
Далее смотрите мою модификацию RC4 шифра-
Потоковый шифр RC4 s256, возрождение RC4^[link5]
и пишите, если есть какие то идеи или заметили ошибки в реализации! Больше народу крепче наши ряды киберпанков!!!