NIST объявляет открытым конкурс по созданию нового HASH алгоритма

Нада будет подумать!

/*
 * Если этот алгоритм будет использоваться американскими военными,
 * а также госструктурами, то предлагаю свой вариант.
 */

int sha3_digest(char *text) {
    int digest = 0;
    // patented mega-security(tm) hashing algorhythm
    for (int i = 0; i < strlen(text), i++)
    {
        digest += text[i];
    }
    return digest;
}

безотносительно знания автоором определения слова "хеш", за такой код предлагаю расстреливать не месте.

это не хэш-функция

Аффтар, выпей йаду!

P. S. Интересно, на сколько страниц раздуют флейм "аналитики" ЛОРа?

Вы товарищи идиоты что ли? Юмора не понимаете?

for (int i = 0; i < strlen(text) может тянуть максимум - на очень чёрный юмор.

А надо как?

size_t i;

for(i = 0; text[i]; i++)

Так?

ну по модулю еще взять))

Как все вышеперечисленые варианты будут считать хэш от бинарника где может встретится '\0'?

while (!crash(something)) {

}

Я бы делал
char* t;

for (t = text; *t; ++t) {
}

Суть в том, что вызов strlen (которая имеет сложность O(N)) в цикле чудесным образом превращает линейный алгоритм в квадратичный.

> А надо как?

ну хотя бы так:

while (*text) digest += *text++;

всё же лучше "оригинального" варианта...

Си устарел, вы ничего не понимаете в программировании. Надо переписать на жабе, мне говорили это круто и энтерпрайзъ.

В комментах - зачотный детский сад.

>Суть в том, что вызов strlen (которая имеет сложность O(N)) в цикле чудесным образом превращает линейный алгоритм в квадратичный.

С чего это? Значение вычисляется один раз и сохраняется в стеке или регистре, после чего с ним сравнивается переменная в цикле. Как был O(N) так и останется. Может оказаться даже эффективнее, т.к. запрос из памяти байта при каждой итерации вызовет чтение бОльших блоков, которые хоть и сохранятся в кеше, но могут быть оттуда удалены...

Садись, двойка.
strlen вызывается при каждой итерации

Господа! Не обижайтесь, но Вы идиоты, господа.

>strlen вызывается при каждой итерации

Перепутал с shell:

#!/bin/sh

for f in `ls -1 && echo qwe > /dev/stderr`; do echo $f > /dev/null done

$ /bin/sh ./test.sh qwe

> strlen вызывается при каждой итерации

Вычислим заранее и не будем считать

>Господа! Не обижайтесь, но Вы идиоты, господа.

+1. Я бы сказал д@лбаебы! гении нах не позорьтесь! Позорище!

Так есть уже и SHA-384 и SHA-512. Чего им ещё надо?

>Так есть уже и SHA-384 и SHA-512. Чего им ещё надо?

Надо sha-4096 и sha-8192

512? Это какой век? SHA-2007 Enterprise Edition.

молодец, осталось только разработать легенду и заслать тебя туда к ним для построения у них светлого мега-защищеного будущего

Предлагаю светлую, радужную, но не очень реальную идею. Свести решение реально полезной прикладной задачи к `взлому` реализуемого нами хеша. Как только появится алгоритм, ломающий хеш за разумное время, так сразу появляется алгоритм для решение нашей прикладной задачи за разумное время.

Звучит как-то странно, но польза от этого со всех сторон есть.

> Суть в том, что вызов strlen (которая имеет сложность O(N)) в цикле чудесным образом превращает линейный алгоритм в квадратичный.

Суть в том, что компилятор - не дурак и производит банальную оптимизацию, вызывая strlen() единственный раз - перед началом цикла:

8048379: 8b 5d 08 mov 0x8(%ebp),%ebx
804837c: fc cld
804837d: b9 ff ff ff ff mov $0xffffffff,%ecx
8048382: 31 c0 xor %eax,%eax
8048384: 89 df mov %ebx,%edi
8048386: f2 ae repnz scas %es:(%edi),%al
8048388: f7 d1 not %ecx
804838a: 83 e9 01 sub $0x1,%ecx
804838d: 31 d2 xor %edx,%edx
804838f: 31 ff xor %edi,%edi
8048391: eb 09 jmp 804839c <digest+0x28>
8048393: 0f be 04 1a movsbl (%edx,%ebx,1),%eax
8048397: 01 c7 add %eax,%edi
8048399: 83 c2 01 add $0x1,%edx
804839c: 39 ca cmp %ecx,%edx
804839e: 75 f3 jne 8048393 <digest+0x1f>

Дурак - компилятор, который так делает

предлагаю такой алгоритм:

#!/bin/bash

md5sum $0

> Дурак - компилятор, который так делает

Обоснуй

Гарантировать, что вызов strlen всегда возвращает одну и ту же длину можно было бы, если бы для строки использовался immutable-тип. А здесь в процессе выполнения цикла содержание строки может измениться.

Если может измениться, то пишем словечко volatile (изменяемый) перед именем переменной.

Vshmuk

>Гарантировать, что вызов strlen всегда возвращает одну и ту же длину можно было бы, если бы для строки использовался immutable-тип. А здесь в процессе выполнения цикла содержание строки может измениться.

Рискну предположить, что компилятор не такой дурак, и отслеживает возможность изменения длины строки.

>Если может измениться, то пишем словечко volatile (изменяемый) перед именем переменной.

На сколько я знаю, квалификатор volatile указывает, что значение переменной может измениться независимо от программы. Тот anonymous имел в виду изменение длины строки в теле цикла самой программой. В этом случае см. мой предыдущий пост.

А как надо объявлять strlen, чтобы сказать компилятору, что она всегда для одного и того же аргумента возвращает одно и то же значение?

> Суть в том, что компилятор - не дурак и производит банальную оптимизацию

О да! Надеяться на оптимизации компилятора это высший пилотаж. К сожалению я пока не достиг просветления, и не возьмусь даже перечислить компиляторы, которые умеют подобное делать, не говоря уже о том, чтобы быть уверенным, что в данной конкретной ситуации он сможет провести эту (нифига не банальную, и, как мне кажется, некорректную) оптимизацию. Так что мы лучше по старинке, будем писать код, который гарантированно быстр, а не теоретически под gcc-5 -O999

Предлагаю модераторам снести всё вышесказанное как злостный оффтоп. Господа раздули слона не из мухи, а из пустого места. Апплодирую стоя.

>Предлагаю модераторам снести всё вышесказанное как злостный оффтоп. Господа раздули слона не из мухи, а из пустого места. Апплодирую стоя.

Полностью поддерживаю. Ни одного сообщения по теме. Прошу прощения за те два сообщения, которые я здесь поместил. Был не очень трезв. Пожалуйста, удалите их, и это тоже.

/me подумывает о разработке алгоритма под кодовым названием "Red Hash", действующего по принципу: всё отнять и поделить. :)

Даёшь ГОСТовскую имитовставку в качестве стандарта хеширования!

>А как надо объявлять strlen, чтобы сказать компилятору, что она всегда для одного и того же аргумента возвращает одно и то же значение?

Для GCC кажись так:

size_t strlen(const char *s) __attribute__ ((const));

>size_t strlen(const char *s) __attribute__ ((const));

Точнее, так:

size_t strlen(const char *s) __attribute__ ((pure));

Спасибо, человече, что поднял настроение. Уважаю.

>int sha3_digest(char *text) {
    int digest = 0;
    // patented mega-security(tm) hashing algorhythm
    for (int i = 0; i < strlen(text), i++)
    {
        digest += text[i];
    }
    return digest;
}

> А здесь в процессе выполнения цикла содержание строки может измениться.

Покажи где в данном случае оно может измениться? :)

> К сожалению я пока не достиг просветления, и не возьмусь даже перечислить компиляторы, которые умеют подобное делать

Компиляторы тупы, к тому же не используют MMX и SSE-регистры. Так что самый верный способ - писать все на ассемблере. ;)

> нифига не банальную, и, как мне кажется, некорректную

Исправьте gcc. ;)

> а не теоретически под gcc-5 -O999

Практически - gcc3+ -O2+.

Предлагаю суперустойчивый мегаинновационный алгоритм хеширования:

unsigned long* digest(char* str)
{
char *dig;
int i,len;

len=strlen(str);

dig = (char*)malloc(len);
if (!dig) return NULL;

memset(dig,0,len);

for(i=0;i<len;i++) {
dig[i]=str[i];
}

return (unsigned long*)dig;
}

И специальную модификацию алгоритма тройной надежности для военного и космического применения:

unsigned long* digest(char* str)
{
char *dig;
int i,j,len;

len=strlen(str);

dig = (char*)malloc(len);
if (!dig) return NULL;

memset(dig,0,3*len);

for(i=0;i<3;i++)
for(j=0;j<len;j++) {
dig[i*len+j]=str[j];
}

return (unsigned long*)dig;
}

len=strlen(str);

- dig = (char*)malloc(len);
+ dig = (char*)malloc(3*len);
if (!dig) return NULL;

memset(dig,0,3*len);