Список говнокодов пользователя j123123

Всего: 338

Си / Говнокод #20309

−46

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

#include <stdio.h>
#include <inttypes.h>

#define REORDER3(b1,b2,b3,a1,a2,a3) do {uint32_t b1_tmp = a1; uint32_t b2_tmp = a2; b3 = a3; b1 = b1_tmp; b2 = b2_tmp;} while (0)
 
void uintprint3(uint32_t *a)
{
  printf("%u %u %u\n", a[0], a[1], a[2]);
}

void sort3(uint32_t a[3] )
{
  if (a[0] > a[1])
  {
    if (a[1] > a[2])
    {
      REORDER3 (
        a[0], a[1], a[2],
        a[2], a[1], a[0]);
      return;
    }
    else
    {
      if (a[0] > a[2])
      {
        REORDER3 (
          a[0], a[1], a[2],
          a[1], a[2], a[0]);
        return;
      }
      else
      {
        REORDER3 (
          a[0], a[1], a[2],
          a[1], a[0], a[2]);
        return;
      }
    }
  }
  else
  {
    if (a[1] <= a[2])
    {
      return; //NO REORDER
    }
    else
    {
      if (a[0] <= a[2])
      {
        REORDER3 (
          a[0], a[1], a[2],
          a[0], a[2], a[1] );
        return;
      }
      else
      {
        REORDER3 (
          a[0], a[1], a[2],
          a[2], a[0], a[1] );
        return;
      }
    }
  }
}
 
int main(void)
{
  uint32_t a[] = {0, 1, 2};
  uint32_t b[] = {0, 2, 1};
  uint32_t c[] = {1, 2, 0};
  uint32_t d[] = {1, 0, 2};
  uint32_t e[] = {2, 0, 1};
  uint32_t f[] = {2, 1, 0};
  sort3(a); sort3(b); sort3(c); sort3(d); sort3(e); sort3(f);
 
  uintprint3(a);
  uintprint3(b);
  uintprint3(c);
  uintprint3(d);
  uintprint3(e);
  uintprint3(f);
  return 0;
}

Вот как сортировать надо. А то всякие жабаскриптики http://govnokod.ru/20308 непонятные.

Это говно кстати можно автосгенерировать для произвольной длины, но мне что-то западло этим заниматься

j123123, 01 Июля 2016

Комментарии (10)

Си / Говнокод #20289

−47

1

http://ache.vniz.net/demos.html

> Cвоеобразный программисткий подвиг совершил Дима Бурков. В то время начали появляться первые PC. Unix на них выглядел неубедительно. Linux еще не появился, зато повился Venix. Хачить его было невозможно - не было исходных текстов ядра. Дима Бурков реассемблировал ядро, потом писал программы на Си, которые давали тот же текст ассемблера - так появились тексты ядра на Си ... работа не для слабонервных.

А вот интересно, можно ли сделать декомпилятор таким способом? Например, если известна точная версия GCC и флаги компиляции, которые использовались (ну и естественно исходники компилятора должны быть в наличии) то перебирать с эвристиками некий Си-код, пользуясь дизасм-листингом для подсказки и сравнения. Какой подход использует Hex-Rays например? Вряд ли они исходники GCC ковыряли

j123123, 28 Июня 2016

Комментарии (12)

Си / Говнокод #20245

−47

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

//                   ПРЕОБРАЗОВАНИЕ КОДА И КОНЕЧНЫЕ АВТОМАТЫ
//                   ---------------------------------------
//               (проектируем очень хуево дизассемблируемый код)

int T[256] =
{
  4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  //                      , -      0 1 2 3 4 5 6 7 8 9
  0,0,0,0,0,0,0,0,0,0,0,0,2,3,0,0, 1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,
  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
};

for(;;)
{
  int A;
  switch( S )
  {
    case 0:
            switch( T[*c] )
            {
              case 1:  { S=1; A=1; }; break;
              default: { S=5; A=2; }; break;
            }
            break;
    case 1:
            switch( T[*c] )
            {
              case 2:  { S=0; A=2; }; break;
              case 1:  { S=1; A=3; }; break;
              case 3:  { S=2;      }; break;
              case 4:  { S=4; A=2; }; break;
              case 0:  { S=5;      }; break;
            }
            break;
    case 2:
            switch( T[*c] )
            {
              case 1:  { S=3; A=4; }; break;
              default: { S=5;      }; break;
            }
            break;
    case 3:
            switch( T[*c] )
            {
              case 2:  { S=0; A=5; }; break;
              case 1:  { S=3; A=6; }; break;
              case 4:  { S=4; A=5; }; break;
              default: { S=5;      }; break;
            }
            break;
    case 4:
            A = 7;
            break;
    case 5:
            A = 8;
            break;
  }
  switch( A )
  {
    case 1: { l=*c-'0';      c++; }; break;
    case 2: { store(l,l);    c++; }; break;
    case 3: { l=l*10+*c-'0'; c++; }; break;
    case 4: { h=*c-'0';      c++; }; break;
    case 5: { store(l,h);    c++; }; break;
    case 6: { h=h*10+*c-'0'; c++; }; break;
    case 7: { exit();             }; break;
    case 8: { error();            }; break;
  }
}

http://z0mbie.daemonlab.org/automaton.txt отсюда

Мне это напомнило вот эту вот ебанутейшую хуиту https://src.chromium.org/viewvc/native_client/trunk/src/native_client/src/trusted/validator_ragel/gen/validator_x86_64.c из хрома, которая делает валидацию опкодов из-под NaCl, его через какой-то ragel делают

j123123, 22 Июня 2016

Комментарии (15)

Assembler / Говнокод #20234

+70

1

https://youtu.be/hB6eY73sLV0?t=241

Исполнение произвольного кода(в данном случае Flappy Bird) в Super Mario World. Запись инструкций в память происходит посредством прыжков в нужных координатах.

j123123, 20 Июня 2016

Комментарии (7)

Си / Говнокод #20200

−47

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

int hardinfo_updata( struct UPINFO * headinfo, struct HARDINFO * hardinfo )
{
	char sbuf[128] ;
	int sn_len = 0 ;
	char *psn ;
	
	printf("%s\n",__FUNCTION__  ) ;
	memset( sbuf, 0xFF, 128 ) ;
	if( strcmp( hardinfo->flag, "hardinfo") != 0 )
	{
		psn = (char *)hardinfo ;
		sn_len = *psn ;
		psn += 1;
		memcpy( sbuf, psn , 127 ) ;
	}
	else
	{
		sn_len = hardinfo->sn_len ;
		memcpy(sbuf, hardinfo->sn, 128 ) ;
	}

	memcpy( hardinfo, &(headinfo->hardinfo), sizeof( struct HARDINFO ) ) ;
	hardinfo->sn_len = sn_len ;
	if( hardinfo->sn_len > 128 ) hardinfo->sn_len = 128 ;
	memcpy( hardinfo->sn, sbuf, hardinfo->sn_len ) ;
	
	memset( 0x30008000, 0xFF, 0x20000 ) ;
	memcpy( 0x30008000, hardinfo, sizeof( struct HARDINFO ) ) ;
	memset( sbuf, 0xFF, 128 ) ;
	sprintf( sbuf, "%s %x %x\0", "nand erase 80000 80000 ;nand write 0x30008000", 0x80000, 0x20000) ;
	run_command( sbuf,0);

	memset( sbuf, 0, 128 ) ;
	sprintf( sbuf, "%s %x\0", "nand read  0x31000000 80000 ", 0x20000 ) ;
	run_command(sbuf, 0 ) ;

	if( memcmp( 0x30008000, 0x31000000, sizeof( struct HARDINFO) ) != 0 )
	{
		printf("bootloader data crc error\n") ;
		return 0 ;
	}
	else
	{
		printf("update hardinfo is ok\n") ;
	}

	return 1 ;
}

CRC через memcpy. Из пропатченного китайцами u-boot

j123123, 15 Июня 2016

Комментарии (65)

Си / Говнокод #20170

−49

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

bool decode_hex(void *p, size_t max_len, const char *hexstr, size_t *out_len_)
{
static const unsigned char hexdigit_val[256] = {
        ['0'] = 0,
        ['1'] = 1,
        ['2'] = 2,
        ['3'] = 3,
        ['4'] = 4,
        ['5'] = 5,
        ['6'] = 6,
        ['7'] = 7,
        ['8'] = 8,
        ['9'] = 9,
        ['a'] = 0xa,
        ['b'] = 0xb,
        ['c'] = 0xc,
        ['d'] = 0xd,
        ['e'] = 0xe,
        ['f'] = 0xf,
        ['A'] = 0xa,
        ['B'] = 0xb,
        ['C'] = 0xc,
        ['D'] = 0xd,
        ['E'] = 0xe,
        ['F'] = 0xf,};

        if (!p || !hexstr)
                return false;
        if (!strncmp(hexstr, "0x", 2))
                hexstr += 2;
        if (strlen(hexstr) > (max_len * 2))
                return false;

        unsigned char *buf = p;
        size_t out_len = 0;

        while (*hexstr) {
                unsigned char c1 = (unsigned char) hexstr[0];
                unsigned char c2 = (unsigned char) hexstr[1];

                unsigned char v1 = hexdigit_val[c1];
                unsigned char v2 = hexdigit_val[c2];

                if (!v1 && (c1 != '0'))
                        return false;
                if (!v2 && (c2 != '0'))
                        return false;

                *buf = (v1 << 4) | v2;

                out_len++;
                buf++;
                hexstr += 2;
        }

        if (out_len_)
                *out_len_ = out_len;
        return true;
}

https://gist.github.com/aido/9490244#file-der_test-L16 оптимизция!

j123123, 09 Июня 2016

Комментарии (48)

Си / Говнокод #20141

−49

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

#include <stdio.h>
#include <string.h>
#include <stdlib.h>


int digits(char **arr_ptr, void **func_ptr)
{
	char *a = *arr_ptr;
	if (*a == '9')
	{
		if ( *(func_ptr-1) == NULL )
		{
			return 0;
		}
		else
		{
			*a = '0';
			return ( *(int(*)(char **, void **)) *(func_ptr-1) )(arr_ptr-1,func_ptr-1);
		}
	}
	(*a)++;
	return 1;
}

int az_AZ(char **arr_ptr, void **func_ptr)
{
	char *a = *arr_ptr;
	if (*a == 'z')
	{
		*a = 'A';
		return 1;
	}
	if (*a == 'Z')
	{
		if ( *(func_ptr-1) == NULL )
		{
			return 0;
		}
		else
		{
			*a = 'a';
			return ( *(int(*)(char **, void **)) *(func_ptr-1) )(arr_ptr-1,func_ptr-1);
		}
	}
	(*a)++;
	return 1;
}


int main(void)
{
	char a[] = "$#hui"; // $ - azAZ ; # - 1234567890
	size_t len = strlen(a);

	char **char_ptr_arr = malloc(sizeof(char *) * len);
	char **char_ptr_arr_p = char_ptr_arr;

	void **func_ptr = malloc(sizeof(void *) * (len+1));
	func_ptr[0] = NULL;
	void **func_ptr_p = func_ptr+1;


	char *i = a;
	while (*i != 0)
	{
		if (*i == '$')
		{
			*char_ptr_arr_p = i;
			char_ptr_arr_p++;
			*func_ptr_p = (void *)az_AZ;
			func_ptr_p++;
			*i = 'a';
		}
		else if (*i == '#')
		{
			*char_ptr_arr_p = i;
			char_ptr_arr_p++;
			*func_ptr_p = (void *)digits;
			func_ptr_p++;
			*i = '0';
		}
		i++;
	}

	printf("%s ", a);
	while (( *(int(*)(char **, void **)) *(func_ptr_p-1) )(char_ptr_arr_p-1,func_ptr_p-1) != 0 )
	{
		printf("%s ", a);
	}
	printf("%s\n", a);
	fflush(stdout);
	free(char_ptr_arr);
	free(func_ptr);
	return 0;
}

Перебиралка всех кобенаций паролей по маске на сишке, где функции через стек из указателей на функции друг друга вызывают через воиды.

http://govnokod.ru/20137#comment333406 отсюда:
Надо конечно typedef всунуть для функции, но там жопа с рекурсивным определением функции X = (int()(char **, X **))
По сути, надо чтобы функция в качестве аргумента принимала указатель того же типа, что и та сама функция, а такое рекурсивное определение типа в Си нельзя делать

j123123, 06 Июня 2016

Комментарии (17)

Куча / Говнокод #20110

−17

1
2
3

(x) {
  if F(x,x) then { for(;;) }
}

http://www.michurin.net/computer-science/halting-problem.html
Неразрешимость проблемы остановки имеет много доказательств. В терминах функций её очень просто доказать от противного.

Допустим, у нас уже есть решение — функция F, которая принимает на вход некую функцию (вернее строку с текстом функции, байт-кодом или иной записью функции) и некие данные и отвечает на вопрос: «остановится ли функция-первый-аргумент, при работе с данными-вторым-аргументом, или будет работать вечно?»

Давайте создадим функцию P(x), такого вида (на C-образном языке):

P(x) {

  if F(x,x) then { for(;;) }

}

Строку, которая кодирует эту функцию обозначим p. Что будет, если мы вызовем функцию F(p,p)? Возможны два исхода:

True, если P останавливается. Но при этом P(p) как раз не останавливается, если F(p,p)=True, то запускается бесконечный цикл.
False, если P зависает. Но, как не трудно видеть, именно в этом случае P(p) не зависнет.

Мы получили противоречие потому, что наша начальная посылка о существовании магической функции F была не правильной.

Получается, что задача останова неразрешима. Вернее, нельзя написать программу, которая бы решала эту задачу. Иными словами, нельзя написать парсер программного кода, который бы мог оценить, зависнет разбираемый код или нет.
В данном доказательстве на довольно глубинном уровне зарыто говно. Подробности в комментариях

j123123, 01 Июня 2016

Комментарии (123)

JavaScript / Говнокод #20105

+6

1
2
3
4

> var x = new String("eval(x.toString())");
undefined
> eval(x.toString());
RangeError: Maximum call stack size exceeded

Yo dawg, I heard you like evaluation. So I put evaluation in your evaluation so you could evaluate while you evaluate
Жаль что nodejs не осиливает заоптимизировать это как бесконечный цикл

j123123, 31 Мая 2016

Комментарии (20)

C++ / Говнокод #20095

0

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

//...
      /* See if this is something like X * C - X or vice versa or
	 if the multiplication is written as a shift.  If so, we can
	 distribute and make a new multiply, shift, or maybe just
	 have X (if C is 2 in the example above).  But don't make
	 something more expensive than we had before.  */

      if (SCALAR_INT_MODE_P (mode))
	{
	  rtx lhs = op0, rhs = op1;

	  wide_int coeff0 = wi::one (GET_MODE_PRECISION (mode));
	  wide_int coeff1 = wi::one (GET_MODE_PRECISION (mode));

	  if (GET_CODE (lhs) == NEG)
	    {
	      coeff0 = wi::minus_one (GET_MODE_PRECISION (mode));
	      lhs = XEXP (lhs, 0);
	    }
	  else if (GET_CODE (lhs) == MULT
		   && CONST_SCALAR_INT_P (XEXP (lhs, 1)))
	    {
	      coeff0 = std::make_pair (XEXP (lhs, 1), mode);
	      lhs = XEXP (lhs, 0);
	    }
	  else if (GET_CODE (lhs) == ASHIFT
		   && CONST_INT_P (XEXP (lhs, 1))
                   && INTVAL (XEXP (lhs, 1)) >= 0
		   && INTVAL (XEXP (lhs, 1)) < GET_MODE_PRECISION (mode))
	    {
	      coeff0 = wi::set_bit_in_zero (INTVAL (XEXP (lhs, 1)),
					    GET_MODE_PRECISION (mode));
	      lhs = XEXP (lhs, 0);
	    }

	  if (GET_CODE (rhs) == NEG)
	    {
	      coeff1 = wi::minus_one (GET_MODE_PRECISION (mode));
	      rhs = XEXP (rhs, 0);
	    }
	  else if (GET_CODE (rhs) == MULT
		   && CONST_INT_P (XEXP (rhs, 1)))
	    {
	      coeff1 = std::make_pair (XEXP (rhs, 1), mode);
	      rhs = XEXP (rhs, 0);
	    }
	  else if (GET_CODE (rhs) == ASHIFT
		   && CONST_INT_P (XEXP (rhs, 1))
		   && INTVAL (XEXP (rhs, 1)) >= 0
		   && INTVAL (XEXP (rhs, 1)) < GET_MODE_PRECISION (mode))
	    {
	      coeff1 = wi::set_bit_in_zero (INTVAL (XEXP (rhs, 1)),
					    GET_MODE_PRECISION (mode));
	      rhs = XEXP (rhs, 0);
	    }

	  if (rtx_equal_p (lhs, rhs))
	    {
	      rtx orig = gen_rtx_PLUS (mode, op0, op1);
	      rtx coeff;
	      bool speed = optimize_function_for_speed_p (cfun);

	      coeff = immed_wide_int_const (coeff0 + coeff1, mode);

	      tem = simplify_gen_binary (MULT, mode, lhs, coeff);
	      return (set_src_cost (tem, mode, speed)
		      <= set_src_cost (orig, mode, speed) ? tem : 0);
	    }
	}

https://gcc.gnu.org/viewcvs/gcc/trunk/gcc/simplify-rtx.c?view=markup&pathrev=232689#l2062 здоровенная такая функция из недр GCC, в которой делаются оптимизации, это сродни символьным вычислениям вообще говоря
https://godbolt.org/g/vcEqe7 но похоже эта хрень работает плохо, не смогло оно выявить тождественность умножения сдвигами и обычного умножения, сведя операции к return 1 в случае функции test1. Но я естественно находил и примеры кода, которые GCC смог успешно "редуцировать" своим оптимизатором, а clang тупил. Говно тут в том, что вместо того, чтобы впилить нормальную систему символьных вычислений, там нагородили какого-то ебучего говна... Хотя может быть я чего-то не понимаю в компиляторах. Надо будет дракона почитать

j123123, 30 Мая 2016

Комментарии (66)

Говнокод: по колено в коде.