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

Всего: 331

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

−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

#include <stdio.h>

void *labels[3];

void test(void *ptr)
{
    if(ptr == NULL)
    {
      labels[0] = &&l1;
      labels[1] = &&l2;
      labels[2] = &&l3;
      return;
    }
    goto *ptr;
l1:
    printf("test1\n");
    return;
l2:
    printf("test2\n");
    return;
l3:
    printf("test3\n");
    return;
}

int main(void)
{
   test(NULL);
   test(labels[0]);
   test(labels[1]);
   test(labels[2]);
}

Вот если б можно было делать метки указателей внутри функций видимыми извне, такой фигни б не было

j123123, 11 Апреля 2017

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

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

−14

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16

#include "string.hpp"
#include "execute.hpp"

#include <iostream>

using code = decltype(
    "push ebx "
    "pop eax "
    "exit"_s);
constexpr auto ret_val = cai::execute_code<code>;

int main()
{
    std::cout << std::hex << ret_val;
    return 0;
}

cai::execute_code will parse, tokenize, execute code and return value from eax register. Startup ebx value is 0xbada55. Above program will push ebx to stack and pop from stack to eax. So eax will eventually contain 0xbada55.

https://github.com/stryku/ctai compile time assembly interpreter

j123123, 10 Апреля 2017

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

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

−16

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

void subBytes(uint8_t* block, size_t count) {
	for (int i = 0; i < count; i++) {
		size_t x, y;
		char *temp = new char[2];
		sprintf(temp, "%02x", block[i]);
		temp = new char[4]{ temp[0], 0x00, temp[1], 0x00 };
		x = stoi(temp, 0, 16);
		y = stoi(temp + 2, 0, 16);
		block[i] = sBox[x][y];
		delete[] temp;
	}

}
void invSubBytes(uint8_t* block, size_t count) {
	for (int i = 0; i < count; i += 1) {
		size_t x, y;
		char *temp = new char[4];
		sprintf(temp, "%02x", block[i]);
		temp = new char[4]{ temp[0], 0x00, temp[1], 0x00 };
		x = stoi(temp, 0, 16);
		y = stoi(temp + 2, 0, 16);
		block[i] = invSbox[x][y];
		delete[] temp;
	}
}

https://github.com/VenkuSkirata/MyAES/blob/5f9161551f1a743c7ca6b0ebdf492904cc097d8d/AES.cpp#L123-L147

Тут один человек просил покритиковать его код, нувыпонели

j123123, 31 Марта 2017

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

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

−124

1
2

Открытая встреча Национальной рабочей группы по стандартизации C++.
https://youtu.be/FcCymlVAtP8?t=3622

Я тут вам немного ПОКУШАТЬ ПРИНЕС
Они там с этими constespr похоже окончательно двинулись.
Давайте мне constexpr-асмовставки cкорей, и чтоб с гомоиконностью

j123123, 28 Марта 2017

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

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

−18

1

https://aww.moe/0fmynm.mp4

Интересно, зачем он там редактирует выхлоп из hex-rays (32 секунда)? Исходники потеряли?

j123123, 21 Марта 2017

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

C# / Говнокод #22572

−23

001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052
053
054
055
056
057
058
059
060
061
062
063
064
065
066
067
068
069
070
071
072
073
074
075
076
077
078
079
080
081
082
083
084
085
086
087
088
089
090
091
092
093
094
095
096
097
098
099
100

internal unsafe static void Memcpy(byte* dest, byte* src, int len) {
            Contract.Assert(len >= 0, "Negative length in memcopy!");

            //
            // This is portable version of memcpy. It mirrors what the hand optimized assembly versions of memcpy typically do.
            //
            // Ideally, we would just use the cpblk IL instruction here. Unfortunately, cpblk IL instruction is not as efficient as
            // possible yet and so we have this implementation here for now.
            //

            switch (len)
            {
            case 0:
                return;
            case 1:
                *dest = *src;
                return;
            case 2:
                *(short *)dest = *(short *)src;
                return;
            case 3:
                *(short *)dest = *(short *)src;
                *(dest + 2) = *(src + 2);
                return;
            case 4:
                *(int *)dest = *(int *)src;
                return;
            case 5:
                *(int*)dest = *(int*)src;
                *(dest + 4) = *(src + 4);
                return;
            case 6:
                *(int*)dest = *(int*)src;
                *(short*)(dest + 4) = *(short*)(src + 4);
                return;
            case 7:
                *(int*)dest = *(int*)src;
                *(short*)(dest + 4) = *(short*)(src + 4);
                *(dest + 6) = *(src + 6);
                return;
            case 8:
#if WIN64
                *(long*)dest = *(long*)src;
#else
                *(int*)dest = *(int*)src;
                *(int*)(dest + 4) = *(int*)(src + 4);
#endif
                return;
            case 9:
#if WIN64
                *(long*)dest = *(long*)src;
#else
                *(int*)dest = *(int*)src;
                *(int*)(dest + 4) = *(int*)(src + 4);
#endif
                *(dest + 8) = *(src + 8);
                return;
            case 10:
#if WIN64
                *(long*)dest = *(long*)src;
#else
                *(int*)dest = *(int*)src;
                *(int*)(dest + 4) = *(int*)(src + 4);
#endif
                *(short*)(dest + 8) = *(short*)(src + 8);
                return;
            case 11:
#if WIN64
                *(long*)dest = *(long*)src;
#else
                *(int*)dest = *(int*)src;
                *(int*)(dest + 4) = *(int*)(src + 4);
#endif
                *(short*)(dest + 8) = *(short*)(src + 8);
                *(dest + 10) = *(src + 10);
                return;
            case 12:
#if WIN64
                *(long*)dest = *(long*)src;
#else
                *(int*)dest = *(int*)src;
                *(int*)(dest + 4) = *(int*)(src + 4);
#endif
                *(int*)(dest + 8) = *(int*)(src + 8);
                return;
case 13:
#if WIN64
                *(long*)dest = *(long*)src;
#else
                *(int*)dest = *(int*)src;
                *(int*)(dest + 4) = *(int*)(src + 4);
#endif
                *(int*)(dest + 8) = *(int*)(src + 8);
                *(dest + 12) = *(src + 12);
                return;
            case 14:
#if WIN64
                *(long*)dest = *(long*)src;
#else
                *(int*)dest = *(int*)src;

https://github.com/Microsoft/referencesource/blob/9da503f9ef21e8d1f2905c78d4e3e5cbb3d6f85a/mscorlib/system/buffer.cs#L266

Memcpy из Microsoft .NET Reference Source. Выглядит как типичный код на C

j123123, 13 Марта 2017

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

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

−28

1

https://i.kinja-img.com/gawker-media/image/upload/t_original/u0rtkjjphek24lmlvuet.png

Задание для истинных труЪ-кулхацкеров: даны распечатанные на бумаге исходники ядра с глючащим модулем и конфигурация железа, где это ядро запускается. Написать карандашом на листочке, как будет выглядеть кернелпаник
На самом деле - кадр из сериала Mr. Robot

https://www.youtube.com/watch?v=FQM5fU7V-MM еще там был прикольный диалог на тему Gnome KDE (странно что там он не спросил, как KDE2 под FreeBSD запатчить). И да, вот че он сразу про линукс заговорил, ведь кеды и гном и на бзд бывают? Явный косяк

j123123, 10 Марта 2017

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

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

−15

1

https://i.imgur.com/gqky9Fb.jpg

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

j123123, 04 Марта 2017

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

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

−12

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

#include "basic.hpp"


int main()
{
  _10: DIM F(10);
  _11: LET I = 0;
  _12: LET J = 0;
  _13: LET TMP = 0;
  _20: FOR I = 1 TO 10;
  _30: F(I) = RND();
  _35: PRINT F(I);
  _40: NEXT
  _50: FOR I = 1 TO 9;
  _60: FOR J = I + 1 TO 10;
  _70: IF F(J) > F(I) THEN GOTO _110;
  _80: TMP = F(I);
  _90: F(I) = F(J);
  _100: F(J) = TMP;
  _110: NEXT;
  _120: NEXT;
  _130: PRINT "reordered";
  _140: FOR I = 1 TO 10;
  _150: PRINT F(I);
  _160: NEXT
}

https://github.com/rollbear/basicpp/blob/master/examples/05.bubblesort.cpp бейсик на плюсах через гомоик плюсошаблоны и прочую плюсопитушню

https://github.com/rollbear/basicpp/blob/master/basic.hpp

j123123, 03 Марта 2017

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

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

−13

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

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

void secret(void) __attribute__ ((used,noinline,noreturn));
void brainfuck(void) __attribute__ ((noinline));
int main(void);

void secret(void)
{
  printf ("You win!\n");
  exit(0);
}

char *bfprog = "+++---";

void brainfuck(void)
{
    char *bfprog_p = bfprog;
    unsigned long long i;
    unsigned char arr[500] = {0};
    arr[499] = ( ((uintptr_t)secret ^ (uintptr_t)main) & 0xffffff00 ) >> 8*0;
    arr[0]   = ( ((uintptr_t)secret ^ (uintptr_t)main) & 0xffff00ff ) >> 8*1;
    arr[498] = ( ((uintptr_t)secret ^ (uintptr_t)main) & 0xff00ffff ) >> 8*2;
    arr[1]   = ( ((uintptr_t)secret ^ (uintptr_t)main) & 0x00ffffff ) >> 8*3;
    unsigned char *arr_p = &arr[249];                  
    for (i = 0;; i++)
    {
        switch (*bfprog_p)
        {
            case '>':
                arr_p++;
                break;
            case '<':
                arr_p--;
                break;
            case '+':
                (*arr_p)++;
                break;
            case '-':
                (*arr_p)--;
                break; 
/*           case '.':
                putchar(*arr_p);
                break;
            case ',':
                *arr_p = getchar();
                break;                   нинужно*/
            case '[':
                if (*arr_p == 0 )
                {
                    unsigned long long bracketcount = 0;
                    do
                    {
                      if (*bfprog_p == '[')
                          bracketcount++;
                      else if (*bfprog_p == ']')
                          bracketcount--;
                      bfprog_p++;
                    } while (bracketcount != 0);
                    bfprog_p-=1;
                }
                break;
            case ']': 
                if (*arr_p != 0 )
                {
                    unsigned long long bracketcount = 0;
                    do
                    {
                      if (*bfprog_p == ']')
                          bracketcount++;
                      else if (*bfprog_p == '[')
                          bracketcount--;
                      bfprog_p--;
                    } while (bracketcount != 0);
                }
                break;
            default: return;
        }
        bfprog_p++;
    }
    return;
}

int main(void)
{
    brainfuck();
    return 0;
}

Задача - подставить в char *bfprog такую строку, чтобы запустилась функция secret(). Менять что-либо еще в коде запрешено. Платформа - 32битные интели, компилятор - гцц. ОС - линукс или виндовс, на ваше усмотрение (хотя разницы по-идее не будет). Предполагаем, что тут применяется особо расширенный и улучшенный ASLR который при каждом запуске перетасовывает размещение функций, и secret от main находится на хуй знает каком расстоянии. Победившему - нихуя

j123123, 27 Февраля 2017

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

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