sarcastic low-level freak.

Recommended reading:
59cd56fbd8d30284768237.jpeg

Fuck you, I won't do what you tell me. (C)

Достижения

Все достижения (76)

Наибольший вклад в теги

Все теги (305)

Лучшие ответы пользователя

Все ответы (1440)
  • Почему асимметричное шифрование слабее симметричного?

    jcmvbkbc
    @jcmvbkbc
    http://dilbert.com/strip/1998-08-24
    При одинаковой длине ключей, симметричных и асимметричных, криптостойкость алгоритмов разная. И криптостойкость симметричных выше. Асимметричных ниже. ...

    Как это объяснить?

    Это объясняется тем, что у симметричных и асимметричных алгоритмов разная природа.
    Симметричные (например AES) используют ключ для генерации преобразования входного блока в выходной. Количество бит в ключе напрямую определяет размер пространства преобразований -- 128-битный ключ даёт 2128 возможных значений выходного блока для каждого входного.
    Асимметричные используют ключ по-разному, поэтому нужно рассматривать конкретный алгоритм. RSA использует биты ключа для хранения произведения двух простых чисел. 128-битный ключ даёт 64-битные простые числа. Факторизация 128-битного числа не требует перебора 2128 вариантов и занимает на обычном современном железе порядка секунды.
    Ответ написан
  • Как работают исключения?

    jcmvbkbc
    @jcmvbkbc
    http://dilbert.com/strip/1998-08-24
    Может ли кто нибудь объяснить на низком уровне, пошагово, то как работают исключения в с++?

    Вот описание части Itanium ABI связанной с раскруткой стека:
    https://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html

    ABI процессоров других архитектур устроены в этом месте точно так же.

    Вот подробное описание структур, используемых при раскрутке стека в коде генерируемом gcc:
    www.airs.com/blog/archives/460
    www.airs.com/blog/archives/464

    Документы по ссылкам достаточно сложны для восприятия. Для облегчения понимания можно откомпилировать простой С++ код выбрасывающий и ловящий исключение и найти в нем части описанные в первом документе.
    Например
    void e_destructor();
    void s_destructor();
    
    struct E {
            int code;
    
            E(int c): code(c)
            {
            }
            ~E()
            {
                    e_destructor();
            }
    };
    
    struct S {
            ~S()
            {
                    s_destructor();
            }
    };
    
    void f(int v)
    {
            throw E(v);
    }
    
    int g(void (*p)(int v), int v)
    {
            try {
                    struct S s;
                    p(v);
            } catch(struct E e) {
                    return e.code;
            } catch (int i) {
                    return i;
            } catch (...) {
                    throw;
            }
            return 0;
    }

    после g++ -O2 -S превращается в следующие фрагменты:
    функция f:
    _Z1fi:
    .LFB9:
            .cfi_startproc
            pushq   %rbx
            .cfi_def_cfa_offset 16
            .cfi_offset 3, -16
            movl    %edi, %ebx
            movl    $4, %edi
            call    __cxa_allocate_exception
            movl    $_ZN1ED1Ev, %edx
            movl    %ebx, (%rax)  <---- инициализация E::code
            movl    $_ZTI1E, %esi
            movq    %rax, %rdi
            call    __cxa_throw
            .cfi_endproc

    Здесь видны вызовы __cxa_allocate_exception, конструктора объекта класса E и __cxa_throw
    функция g:
    _Z1gPFviEi:
    .LFB10:
            .cfi_startproc
            .cfi_personality 0x3,__gxx_personality_v0
            .cfi_lsda 0x3,.LLSDA10
            pushq   %rbp
            .cfi_def_cfa_offset 16
            .cfi_offset 6, -16
            pushq   %rbx
            .cfi_def_cfa_offset 24
            .cfi_offset 3, -24
            movq    %rdi, %rax
            movl    %esi, %edi
            subq    $8, %rsp
            .cfi_def_cfa_offset 32
    .LEHB0:
            call    *%rax  <--- вызов функции по указателю
    .LEHE0:
    .LEHB1:
            call    _Z12s_destructorv  <--- вызов деструктора объекта s при нормальном выходе из блока try
    .LEHE1:
            xorl    %eax, %eax
    .L17:
            addq    $8, %rsp
            .cfi_remember_state
            .cfi_def_cfa_offset 24
            popq    %rbx
            .cfi_def_cfa_offset 16
            popq    %rbp
            .cfi_def_cfa_offset 8
            ret

    Хвост с обработчиками исключений:
    .L13:
            .cfi_restore_state
            movq    %rdx, %rbx
            movq    %rax, %rbp
            call    _Z12s_destructorv
            movq    %rbx, %rdx
    .L6:
            cmpq    $1, %rdx
            je      .L8
            cmpq    $2, %rdx
            jne     .L22
            movq    %rbp, %rdi
            call    __cxa_begin_catch
            movl    (%rax), %ebx
            call    __cxa_end_catch
            movl    %ebx, %eax
            jmp     .L17
    .L14:
            movq    %rax, %rbp
            jmp     .L6
    .L22:
            movq    %rbp, %rdi
            call    __cxa_begin_catch
    .LEHB2:
            call    __cxa_rethrow
    .LEHE2:
    .L8:
            movq    %rbp, %rdi
            call    __cxa_get_exception_ptr
            movq    %rbp, %rdi
            movl    (%rax), %ebx
            call    __cxa_begin_catch
    .LEHB3:
            call    _Z12e_destructorv
    .LEHE3:
    .LEHB4:
            call    __cxa_end_catch
    .LEHE4:
            movl    %ebx, %eax
            jmp     .L17
    .L16:
            movq    %rax, %rbx
            call    __cxa_end_catch
            movq    %rbx, %rdi
    .LEHB5:
            call    _Unwind_Resume
    .LEHE5:
    .L15:
            movq    %rax, %rbx
            call    __cxa_end_catch
            movq    %rbx, %rdi
    .LEHB6:
            call    _Unwind_Resume
    .LEHE6:
            .cfi_endproc

    Здесь видны вызовы __cxa_begin_catch и __cxa_end_catch, __cxa_rethrow повторно выбрасывающий пойманное исключение, __cxa_get_exception_ptr и _Unwind_Resume, вызываемый если блок catch не ловит это исключение.

    Дальше идёт структура LSDA описанная в третьем документе.

    Сама раскрутка стека в этом коде отсутствует. Она выполняется следующим кодом libgcc: фаза 1 и фаза 2.
    Ответ написан
  • Как засунуть n - мерный массив в аргумент функции?

    jcmvbkbc
    @jcmvbkbc
    http://dilbert.com/strip/1998-08-24
    Ну вот, опять знатоки советуют добавить звёздочек и указателей на указатели ):

    Все примеры дальше передают в функцию трёхмерный массив и присваивают v значение его элемента p[1][2][3].

    Если функция принимает массив фиксированных размерностей, то прямо так можно и написать:
    int f(int p[][20][30])
    {
        int i = 1, j = 2, k = 3;
        int v = p[i][j][k];
    }
    ...
    int p[10][20][30];
    f(p);

    Первую размерность (самую старшую) можно опустить.

    Если же нет, то перед вами следующий выбор:

    - у вас старый стандарт С (до С99) -- передавайте указатель на самый первый элемент и значения размерностей. Внутри функции пересчитывайте набор индексов многомерного массива в линейный индекс:
    int f(int *p, int n2, int n3) // p[][n2][n3]
    {
        int i = 1, j= 2, k = 3;
        int v = p[(((i * n2) + j) * n3) + k]; // v = p[i][j][k];
    }
    ...
    int p[10][20][30];
    f(&p[0][0][0], 20, 30);


    - у вас С99 или новее: воспользуйтесь поддержкой языка:
    int f(int n2, int n3, int p[][n2][n3])
    {
        int i = 1, j = 2, k = 3;
        int v = p[i][j][k];
    }
    ...
    int p[10][20][30];
    f(20, 30, p);
    Ответ написан
  • Как увидеть входные параметры ассемблер?

    jcmvbkbc
    @jcmvbkbc
    http://dilbert.com/strip/1998-08-24
    Есть исходный код на Си, который вызывает функцию на ассемблере, но передаваемые аргументы как получить,

    Гуглить словосочетание "имя целевой процессорной архитектуры" + ABI.
    Например: x86_64 abi, x86 abi, arm64 abi...
    В найденном документе искать раздел "parameter passing".
    Ответ написан
  • Зачем нужен fakeroot, при сборке deb-пакета?

    jcmvbkbc
    @jcmvbkbc
    http://dilbert.com/strip/1998-08-24
    fakeroot делает так, что приложение, которое не имеет прав рута, но ожидающее, что оно имеет эти права, не завершается с ошибкой из-за недостатка прав, при выполнении некоторых функций, а продолжает работать. Т.е. он "проглатывает" ошибки вызванные недостатком привилегий.

    Например, обычный пользователь не может сделать chowh root:root для файла, которым он владеет:
    $ chown root:root test ; echo $?
    chown: changing ownership of 'test': Operation not permitted
    1

    fakeroot даёт приложению видимость того, что ошибки не происходит. Владелец файла при этом, конечно, не меняется:
    $ fakeroot chown root:root test ; echo $?
    0
    $ ls -la test
    -rw-rw-r--. 1 jcmvbkbc jcmvbkbc 1709 Jun  1  2011 test

    Всё.

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

    Почему в мануалах пишут так:
    fakeroot dpkg-deb --build ./path
    а вот так тоже работает:
    dpkg-deb --build ./path

    Потому что во время сборки пакета не выполнялись команды, которым нужны привилегии, либо ошибки их выполнения были проигнорированы.

    Андрей Буров, pfg21 всякие "песочницы", "не пускает во внешний мир", "скрипт может раскидать бинарники по системе, песочница его не выпустит" применительно к fakeroot -- это фантазия. Сборка пакетов может и должна производиться под обычным пользователем. Штатная система привилегий заботится о том, что приложение, запускаемое под непривилегированным пользователем ничего не сломало.
    Ответ написан

Лучшие вопросы пользователя

Все вопросы (2)