Linux: Разбирался с GCC и динамическими библиотеками

В общем, дело обстояло так.

Есть некий проект, а точнее, CGI-приложение, написанное на C. Такие штуки, по-моему, должны обладать немаловажным свойством - они должны быть не сильно большими. Ведь при каждом обращении клиента создаётся копия всего кода в памяти. Соответственно, поднимать не требующиеся в данный момент громоздкие функции - это моветон.

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

1. Пусть, например, у нас есть проект, который состоит из трех файлов:

Файл FirstModule.c (и соответствующий ему заголовочный файл FirstModule.h):

char *FirstModule_Function1 (char *param) {...}
char *FirstModule_Function2 (char *param) {...}

Файл SecondModule.c (и заголовочный файл SecondModule.h), который активно пользуется функиями из первого файла:

#include "FirstModule.h"
char *SecondModule_Function1 (char *param) {...}
char *SecondModule_Function2 (char *param) {...}

И, наконец, файл Main.c, который, конечно, использует функции из обоих вышеуказанных файлов:

#include "FirstModule.h"
#include "SecondModule.h"
int main()
{
    ...
    char *val = SecondModule_Function1 ("некий параметр");
    ...
}

Как всё это богатство компилируется в один исполняемый файл Main? Примерно так:

gcc -c FirstModule.c -o FirstModule.o
gcc -c SecondModule.c -o SecondModule.o
gcc -c Main.c -o Main.o
gcc FirstModule.o SecondModule.o Main.o -o Main
rm -f *.o

2. Теперь предположим, что SecondModule.c неприлично растолстел. Превращаем его в Shared library (т.е. делаем динамическую библиотеку).

Во-первых, переписываем Main.c:

#include "FirstModule.h"
#include <dlfcn.h>
int main()
{
    void *lib_handle;
    char *lib_error;
    char *(*fn)(char *param);

    // пытаемся загрузить библиотеку из той же директории, что и исполняемый файл
    lib_handle = dlopen("./SecondModule.so", RTLD_LAZY);
    if (!lib_handle) 
    {
        fprintf(stderr, "1. %s\n", dlerror());
        exit(1);
     }

    // получаем ссылку на нужную нам функцию
    fn = dlsym(lib_handle, "SecondModule_Function1");
    if ((lib_error = dlerror()) != NULL)
    {
        fprintf(stderr, "2. %s\n", lib_error);
        exit(1);
    }

    // выполняем функцию
    char *val = (*fn)("некий параметр");

    // используем результат выполнения
    printf("%s\n", val);

    // выгружаем библиотеку
    dlclose(lib_handle);
    ...
}

Немножко длинно, но довольно понятно.

Во-вторых компилируем всё это так:

gcc -c FirstModule.c -o FirstModule.o
gcc -c -fPIC SecondModule.c -o SecondModule.o
gcc -shared SecondModule.o -o SecondModule.so
gcc -c Main.c -o Main.o
gcc -ldl FirstModule.o Main.o -o Main
rm -f *.o

В результате получаются исполняемый файл Main и использующаяся им по мере надобности библиотека SecondModule.so.

3. Теперь интересный момент. Выяснилось, что SecondModule.so по-прежнему активно использует функции, описанные в FirstModule.c и вкомпилированные в основной исполняемый файл. Соответственно, использовать этот SecondModule.so где-нибудь в левом проекте, который не знает про FirstModule, не получится.

Это обстоятельство можно обойти так - собрать SecondModule.so, включив в неё функции из FirstModule.c. То есть, проект в этом случае будет собираться так:

gcc -c -fPIC FirstModule.c -o FirstModule.o
gcc -c -fPIC SecondModule.c -o SecondModule.o
gcc -shared FirstModule.o SecondModule.o -o SecondModule.so
gcc -c Main.c -o Main.o
gcc -ldl FirstModule.o Main.o -o Main
rm -f *.o

Здесь, конечно, и в Main, и в SecondModule.so код из FirstModule будет дублироваться, но зато SecondModule.so станет автономной.

4. Однако, если теперь посмотреть командой nm -D SecondModule.so, то можно увидеть поразительный факт - в этой библиотеке одинаково хорошо видны как FirstModule_Function1, FirstModule_Function2, так и SecondModule_Function1, SecondModule_Function2 ! Если мы не хотим, чтобы были видны ВСЕ функции, придется добавить к проекту ещё один файл, SecondModule.lds, в котором указать, какие именно символы экспортировать:

{
    global:
        SecondModule_Function1;
        SecondModule_Function2;
    local: *;
}

И тогда уже можно проект собрать в окончательно замороченном виде:

gcc -c -fPIC FirstModule.c -o FirstModule.o
gcc -c -fPIC SecondModule.c -o SecondModule.o
gcc -shared -Wl,--version-script=SecondModule.lds FirstModule.o SecondModule.o -o SecondModule.so
gcc -c Main.c -o Main.o
gcc -ldl FirstModule.o Main.o -o Main
rm -f *.o

(Здесь -Wl,что-то-там - это указание передать линковщику параметр "что-то-там")

В результате получаются:
Программа Main, которая использует в нужный момент SecondModule.so.
Библиотека SecondModule.so, из которой видны две функции, SecondModule_Function1, SecondModule_Function2.

Вроде, неплохо. Если нигде не напутал.

А тут - источники знаний:
http://gcc.gnu.org/onlinedocs/gcc/Link-Options.html
http://www.yolinux.com/TUTORIALS/LibraryArchives-StaticAndDynamic.html
http://www.cprogramming.com/tutorial/shared-libraries-linux-gcc.html
http://stackoverflow.com/questions/8866790/do-shared-libraries-use-the-same-heap-as-the-application
ftp://ftp.gnu.org/old-gnu/Manuals/ld-2.9.1/html_node/ld_25.html

Как назвать новый АРМ?

Наверное, в жизни каждого разработчика возникает ситуация, когда надо придумать название своему новому детищу. Желательно, звучное и глубокомысленное. Мне вот нравятся хитрые аббревиатуры, например: СТЭЛС - Союз Транспортных Экспедиторов и Логистов Сибири, ИКС - Информационная комплексная система, СТЭК - Система Транспортного ЭКспедирования.

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

СИСКИ - Сетевая (можно Промышленная, тоже будет неплохо) Информационная Система Комплексной Интеграции
СЦУКО - Система Централизованного Управления Комплексом Организаций
САКУРА - Система Автоматизированного Комплексного Учета Разнородных Абстракций
КОРД - Комплекс Оперативной Работы с Документами
ВИРТ - Веб-Интерфейс Рабочих Технологий
СЕИФ - Сетевой Единый Интерфейс Функционирования
ВИННИ - Веб-Интерфейс Начального Накопления Информации
ПОНИ - Программный Интерфейс Накопления Информации
ПИВО - Простой Интерфейс Ведения Отчетности
ОИОИ - Открытый Интерфейс Обработки Информации
БАЛК - Базовый Аппаратно-Логический Комплекс
ПИОН - Простой Интерфейс Обработки и Накопления информации (а так же Перед Использованием Обработать Напильником)
ПОССУ - Программист Опять Сошел С Ума

Ubuntu 13.10: как получить root на DNS AirTab m100

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

Как давеча метко подметил Л.Каганов в своем блоге, пора в анкетах вводить новое правило: если там принято писать "английский - со словарём", то почему бы по аналогии не указывать "образование - с википедией"? Или, как в моём случае: "владение ПК - с гуглём". Так или иначе, гугление утвердило меня в мысли, что на этом планшете мне просто необходим рутовый доступ. Однако, как его получить?

Во-первых, на самом планшете в задаче "Настройки" есть пункт "{} Для разработчиков". В этом пункте есть подраздел "Отладка", в котором нужно поставить галочку напротив пункта "Отладка по USB". После этого при попытке подключить данный планшет к компьютеру на нем нарисуется уведомление "Отладка по USB разрешена".
(Говорят, в андроиде 4.2.x для включения пункта "для разработчиков" нужно будет семь раз постучать по вот этому пункту: Settings > About Phone > Build Number)

Далее нужно настроить сам компьютер. Для windows постоянно попадаются какие-то инструкции, для убунты - что-то как-то не повезло. Но тоже есть, если поискать. Итак.

1. Ставим специальную утилиту adb (Android Debug Bridge) командой:
sudo aptitude install android-tools-adb
(Вообще-то можно было бы поставить сразу AndroidSDK, но хватило и этого)

2. Смотрим, как это наше устройство определяется в системе, командой dmesg:
[ 4384.675409] usb 1-5: USB disconnect, device number 9
[ 5822.172051] usb 1-5: new high-speed USB device number 10 using ehci-pci
[ 5822.304891] usb 1-5: New USB device found, idVendor=2207, idProduct=0010
[ 5822.304900] usb 1-5: New USB device strings: Mfr=2, Product=3, SerialNumber=4
[ 5822.304906] usb 1-5: Product: M100
[ 5822.304911] usb 1-5: Manufacturer: DNS
[ 5822.304916] usb 1-5: SerialNumber: 0123456789ABCDEF
Высвечивающееся idVendor=2207 означает, что это - галимая китайщина, и для того, чтобы её прикрутить, можно воспользоваться вот этой инструкцией. Дальше несколько пунктов из неё:

3. Создаём файл ~/.android/adb_usb.ini, в который записываем ровно шесть символов:
0x2207

4. Создаём файл /etc/udev/rules.d/51-android.rules со следующим содержимым:
SUBSYSTEM=="usb", ATTRS{idVendor}=="2207", MODE="0666"
Кое-где попадаются советы этот файл сделать chmod a+rx, по-моему, это перебор. Хватит и a+r.

5. Переподключаем планшет, и... лично у меня ничего не завелось. Зато dmesg стало выдавать кучу ошибок примерно такого вида:
[ 838.988045] usb 3-5: new full-speed USB device number 29 using ohci-pci
[ 839.172072] usb 3-5: device descriptor read/64, error -62
[ 839.460054] usb 3-5: device descriptor read/64, error -62

6. Перезагрузил компьютер целиком. После этого выполнил команду
adb devices
и - о, чудо - на экран вывалилось долгожданное:
List of devices attached
0123456789ABCDEF device

7. После этой победы можно воспользоваться архивом с 4pda.ru, из которого на самом деле потребуются лишь пять файлов:
su
busybox
SuperSU.apk
RootExplorer.apk
Файл же TPSparkyRoot.bat пришлось слегка подправить - чтобы можно было его выполнить в терминале убунты:

#!/bin/sh

clear
echo "*---* VonDroid.com N101 II Root Tool based on work by sunnydavid *---*"
echo "--- Plug in your device, make sure debugging is enabled in Developer Options"
echo "--- This script will now copy files over to your N101 II"
echo "--- Starting... This will take a while, be patient and wait..."
echo ""
adb shell mv /data/local/tmp /data/local/tmp.bak

adb shell ln -s /data /data/local/tmp
adb reboot
echo "--- Reboot 1/3 - Press Space Bar once the device has rebooted"
read -s -n 1

adb shell rm /data/local.prop > nul
adb shell "echo \"ro.kernel.qemu=1\" > /data/local.prop"
adb reboot
echo "--- Reboot 2/3 - Press Space Bar once the device has rebooted"
read -s -n 1

adb shell id
echo "--- If the ID shows as 0/root then continue, otherwise CTRL+C to cancel and start over"
read -s -n 1

adb remount
adb push su /system/bin/su
adb shell chown root.shell /system/bin/su
adb shell chmod 6755 /system/bin/su
adb push busybox /system/bin/busybox
adb shell chown root.shell /system/bin/busybox
adb shell chmod 0755 /system/bin/busybox
echo "--- Installing SuperSU"
adb push RootExplorer.apk /system/app/SuperSU.apk
adb shell chown root.root /system/app/SuperSU.apk
adb shell chmod 0644 /system/app/SuperSU.apk
echo "--- Installing Root Explorer"
adb push RootExplorer.apk /system/app/RootExplorer.apk
adb shell chown root.root /system/app/RootExplorer.apk
adb shell chmod 0644 /system/app/RootExplorer.apk
echo "Completing Root"

adb shell rm /data/local.prop
adb shell rm /data/local/tmp
adb shell mv /data/local/tmp.bak /data/local/tmp
adb reboot
echo "--- Reboot 3/3 - Your N101 II should now be rooted. Press SpaceBar to exit"
read -s -n 1

echo "done"

Вот, собственно, и всё. Не скажу, что это как-то сильно мне помогло, но теперь на планшете живёт некая загадочная аппликуха Root Explorer, а сборщик мусора Clean Master (установленный штатным образом из Google PlayMarket-а) научился сносить предустановленные приложения.

Хэш-функция ГОСТ 34.11-2012

Понадобилось тут давеча складировать пароли в базе данных. Точнее, хэши паролей. Можно было бы воспользоваться md5, но я почему-то решил, что полезно будет использовать что-нибудь более официальное. На глаза очень удачно попался алгоритм ГОСТ 34.11-2012, и я решил попробовать реализовать его на C.

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

Гипнотизирование мануала навело на мысль, что вся работа будет вестись с массивами из 64 байтов. Так как в C байтов не нашлось, решил использовать unsigned char[64]. Все названия функций предварил префиксом GOSThash_ - на будущее, чтобы было поменьше пересечений, а то мало ли, в каких проектах вздумается мне эту поделку использовать. Итак, поехали.

Первым делом, конечно, надо написать вывод результата:

static char *GOSThash_PrintArray (unsigned char *array, int size)
{
    char *result = (char *)calloc(size*2+1, sizeof(char));

    int i = 0;
    while (i < size)
    {
        sprintf(&(result[i*2]), "%02hhX", array[(size-1)-i]); 
        i++;
    }

    return result;
}

почему (size-1), будет объяснено дальше.

Затем началась медитация над операциями, которые применяются к этим самым массивам. В тексте документа встретились два плюса - плюс в кружочке и плюс в квадратике. Эти загадочные бинарные операции, оказывается, имеют простой смысл:

1) плюс в кружочке - это банальный xor соответствующих байтов в двух массивах:

static void GOSThash_xor (unsigned char *vectA, unsigned char *vectB, unsigned char *result)
{
    int i;
    for (i = 0; i < 64; i++)
        result[i] = vectA[i] ^ vectB[i];
}

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

static void GOSThash_plus (unsigned char *vectA, unsigned char *vectB, unsigned char *result)
{
    int i = 63, remain = 0;
    while (i >= 0)
    {
        int sum = (int)vectA[i] + (int)vectB[i] + remain;
        if (sum > 256)
            remain = (sum >> 8);
        else
            remain = 0;
        result[i] = (char)(sum & 0xFF);
        i--;
    }
}

Дальше пошла суровая математика. Вводятся три преобразования над 64-х байтными массивами: P, S и L. Первые два ещё ничего, а вот третье... Однако, по порядку:

1) Преобразование P - банальная перестановка элементов массива:

static void GOSThash_P (unsigned char *a, unsigned char *result)
{
    unsigned char tau[64] = {
         0,  8, 16, 24, 32, 40, 48, 56,
         1,  9, 17, 25, 33, 41, 49, 57,
         2, 10, 18, 26, 34, 42, 50, 58,
         3, 11, 19, 27, 35, 43, 51, 59,
         4, 12, 20, 28, 36, 44, 52, 60,
         5, 13, 21, 29, 37, 45, 53, 61,
         6, 14, 22, 30, 38, 46, 54, 62,
         7, 15, 23, 31, 39, 47, 55, 63};

    unsigned char internal[64] = {0};
    int i;
    for (i = 0; i < 64; i++)
        internal[i] = a[tau[i]];
    memcpy(result, internal, 64);
}

2) Преобразование S - по сути, тоже перестановка, но чуть менее банальная:

static void GOSThash_S (unsigned char *a, unsigned char *result)
{
    unsigned char Pi[256] = {
        252, 238, 221,  17, 207, 110,  49,  22, 251, 196, 250,
        218,  35, 197,   4,  77, 233, 119, 240, 219, 147,  46,
        153, 186,  23,  54, 241, 187,  20, 205,  95, 193, 249,
         24, 101,  90, 226,  92, 239,  33, 129,  28,  60,  66,
        139,   1, 142,  79,   5, 132,   2, 174, 227, 106, 143,
        160,   6,  11, 237, 152, 127, 212, 211,  31, 235,  52,
         44,  81, 234, 200,  72, 171, 242,  42, 104, 162, 253,
         58, 206, 204, 181, 112,  14,  86,   8,  12, 118,  18,
        191, 114,  19,  71, 156, 183,  93, 135,  21, 161, 150,
         41,  16, 123, 154, 199, 243, 145, 120, 111, 157, 158,
        178, 177,  50, 117,  25,  61, 255,  53, 138, 126, 109,
         84, 198, 128, 195, 189,  13,  87, 223, 245,  36, 169,
         62, 168,  67, 201, 215, 121, 214, 246, 124,  34, 185,
          3, 224,  15, 236, 222, 122, 148, 176, 188, 220, 232,
         40,  80,  78,  51,  10,  74, 167, 151,  96, 115,  30,
          0,  98,  68,  26, 184,  56, 130, 100, 159,  38,  65,
        173,  69,  70, 146,  39,  94,  85,  47, 140, 163, 165,
        125, 105, 213, 149,  59,   7,  88, 179,  64, 134, 172,
         29, 247,  48,  55, 107, 228, 136, 217, 231, 137, 225,
         27, 131,  73,  76,  63, 248, 254, 141,  83, 170, 144,
        202, 216, 133,  97,  32, 113, 103, 164,  45,  43,   9,
         91, 203, 155,  37, 208, 190, 229, 108,  82,  89, 166,
        116, 210, 230, 244, 180, 192, 209, 102, 175, 194,  57,
        75,  99, 182};

    unsigned char internal[64] = {0};
    int i;
    for (i = 0; i < 64; i++)
        internal[i] = Pi[a[i]];
    memcpy(result, internal, 64);
}

3) И, наконец, преобразование L. В документации сказано, что это - умножение на некую матрицу, собственно, по сути так и есть, но осмыслить это удалось не сразу, и в голове получилась следующая картинка. Берётся наш исходный 64-х байтный массив B[64] и группируется по восемь байтов:

B[00] B[01] B[02] B[03] B[04] B[05] B[06] B[07] - группа 0
B[08] B[09] B[10] B[11] B[12] B[13] B[14] B[15] - группа 1
...
B[56] B[57] B[58] B[59] B[60] B[61] B[62] B[63] - группа 7

Кроме того, имеется данный свыше массив A[512] тоже идеологически распадающийся на 64 строчки по восемь байтов:

A[000] A[001] A[002] A[003] A[004] A[005] A[006] A[007] - строка 0
A[008] A[009] A[010] A[011] A[012] A[013] A[014] A[015] - строка 1
...
A[504] A[505] A[506] A[507] A[508] A[509] A[510] A[511] - строка 63

Всё это дело сворачивается в новый 64-х байтный массив так. Берётся очередная 8-и байтная группа рассматривается как набор из 64 бит. Каждый бит соотносится с соответствующей строкой массива A, если этот бит равен нулю, строка вычеркивается. Невычеркнутые строки xor-ятся, и получившиеся новые 8 байтов подставляются на место исходной группы. В общем, код получился такой:

static void GOSThash_L (unsigned char *a, unsigned char *result)
{
    unsigned char l[512] = {
        0x8e, 0x20, 0xfa, 0xa7, 0x2b, 0xa0, 0xb4, 0x70,
        0x47, 0x10, 0x7d, 0xdd, 0x9b, 0x50, 0x5a, 0x38,
        0xad, 0x08, 0xb0, 0xe0, 0xc3, 0x28, 0x2d, 0x1c,
        0xd8, 0x04, 0x58, 0x70, 0xef, 0x14, 0x98, 0x0e,
        0x6c, 0x02, 0x2c, 0x38, 0xf9, 0x0a, 0x4c, 0x07,
        0x36, 0x01, 0x16, 0x1c, 0xf2, 0x05, 0x26, 0x8d,
        0x1b, 0x8e, 0x0b, 0x0e, 0x79, 0x8c, 0x13, 0xc8,
        0x83, 0x47, 0x8b, 0x07, 0xb2, 0x46, 0x87, 0x64,

        0xa0, 0x11, 0xd3, 0x80, 0x81, 0x8e, 0x8f, 0x40,
        0x50, 0x86, 0xe7, 0x40, 0xce, 0x47, 0xc9, 0x20,
        0x28, 0x43, 0xfd, 0x20, 0x67, 0xad, 0xea, 0x10,
        0x14, 0xaf, 0xf0, 0x10, 0xbd, 0xd8, 0x75, 0x08,
        0x0a, 0xd9, 0x78, 0x08, 0xd0, 0x6c, 0xb4, 0x04,
        0x05, 0xe2, 0x3c, 0x04, 0x68, 0x36, 0x5a, 0x02,
        0x8c, 0x71, 0x1e, 0x02, 0x34, 0x1b, 0x2d, 0x01,
        0x46, 0xb6, 0x0f, 0x01, 0x1a, 0x83, 0x98, 0x8e,

        0x90, 0xda, 0xb5, 0x2a, 0x38, 0x7a, 0xe7, 0x6f,
        0x48, 0x6d, 0xd4, 0x15, 0x1c, 0x3d, 0xfd, 0xb9,
        0x24, 0xb8, 0x6a, 0x84, 0x0e, 0x90, 0xf0, 0xd2,
        0x12, 0x5c, 0x35, 0x42, 0x07, 0x48, 0x78, 0x69,
        0x09, 0x2e, 0x94, 0x21, 0x8d, 0x24, 0x3c, 0xba,
        0x8a, 0x17, 0x4a, 0x9e, 0xc8, 0x12, 0x1e, 0x5d,
        0x45, 0x85, 0x25, 0x4f, 0x64, 0x09, 0x0f, 0xa0,
        0xac, 0xcc, 0x9c, 0xa9, 0x32, 0x8a, 0x89, 0x50,

        0x9d, 0x4d, 0xf0, 0x5d, 0x5f, 0x66, 0x14, 0x51,
        0xc0, 0xa8, 0x78, 0xa0, 0xa1, 0x33, 0x0a, 0xa6,
        0x60, 0x54, 0x3c, 0x50, 0xde, 0x97, 0x05, 0x53,
        0x30, 0x2a, 0x1e, 0x28, 0x6f, 0xc5, 0x8c, 0xa7,
        0x18, 0x15, 0x0f, 0x14, 0xb9, 0xec, 0x46, 0xdd,
        0x0c, 0x84, 0x89, 0x0a, 0xd2, 0x76, 0x23, 0xe0,
        0x06, 0x42, 0xca, 0x05, 0x69, 0x3b, 0x9f, 0x70,
        0x03, 0x21, 0x65, 0x8c, 0xba, 0x93, 0xc1, 0x38,

        0x86, 0x27, 0x5d, 0xf0, 0x9c, 0xe8, 0xaa, 0xa8,
        0x43, 0x9d, 0xa0, 0x78, 0x4e, 0x74, 0x55, 0x54,
        0xaf, 0xc0, 0x50, 0x3c, 0x27, 0x3a, 0xa4, 0x2a,
        0xd9, 0x60, 0x28, 0x1e, 0x9d, 0x1d, 0x52, 0x15,
        0xe2, 0x30, 0x14, 0x0f, 0xc0, 0x80, 0x29, 0x84,
        0x71, 0x18, 0x0a, 0x89, 0x60, 0x40, 0x9a, 0x42,
        0xb6, 0x0c, 0x05, 0xca, 0x30, 0x20, 0x4d, 0x21,
        0x5b, 0x06, 0x8c, 0x65, 0x18, 0x10, 0xa8, 0x9e,

        0x45, 0x6c, 0x34, 0x88, 0x7a, 0x38, 0x05, 0xb9,
        0xac, 0x36, 0x1a, 0x44, 0x3d, 0x1c, 0x8c, 0xd2,
        0x56, 0x1b, 0x0d, 0x22, 0x90, 0x0e, 0x46, 0x69,
        0x2b, 0x83, 0x88, 0x11, 0x48, 0x07, 0x23, 0xba,
        0x9b, 0xcf, 0x44, 0x86, 0x24, 0x8d, 0x9f, 0x5d,
        0xc3, 0xe9, 0x22, 0x43, 0x12, 0xc8, 0xc1, 0xa0,
        0xef, 0xfa, 0x11, 0xaf, 0x09, 0x64, 0xee, 0x50,
        0xf9, 0x7d, 0x86, 0xd9, 0x8a, 0x32, 0x77, 0x28,

        0xe4, 0xfa, 0x20, 0x54, 0xa8, 0x0b, 0x32, 0x9c,
        0x72, 0x7d, 0x10, 0x2a, 0x54, 0x8b, 0x19, 0x4e,
        0x39, 0xb0, 0x08, 0x15, 0x2a, 0xcb, 0x82, 0x27,
        0x92, 0x58, 0x04, 0x84, 0x15, 0xeb, 0x41, 0x9d,
        0x49, 0x2c, 0x02, 0x42, 0x84, 0xfb, 0xae, 0xc0,
        0xaa, 0x16, 0x01, 0x21, 0x42, 0xf3, 0x57, 0x60,
        0x55, 0x0b, 0x8e, 0x9e, 0x21, 0xf7, 0xa5, 0x30,
        0xa4, 0x8b, 0x47, 0x4f, 0x9e, 0xf5, 0xdc, 0x18,

        0x70, 0xa6, 0xa5, 0x6e, 0x24, 0x40, 0x59, 0x8e,
        0x38, 0x53, 0xdc, 0x37, 0x12, 0x20, 0xa2, 0x47,
        0x1c, 0xa7, 0x6e, 0x95, 0x09, 0x10, 0x51, 0xad,
        0x0e, 0xdd, 0x37, 0xc4, 0x8a, 0x08, 0xa6, 0xd8,
        0x07, 0xe0, 0x95, 0x62, 0x45, 0x04, 0x53, 0x6c,
        0x8d, 0x70, 0xc4, 0x31, 0xac, 0x02, 0xa7, 0x36,
        0xc8, 0x38, 0x62, 0x96, 0x56, 0x01, 0xdd, 0x1b,
        0x64, 0x1c, 0x31, 0x4b, 0x2b, 0x8e, 0xe0, 0x83
        };

    unsigned char internal[64] = {0};
    int i, j, k, n, p;
    for (i = 7; i >= 0; i--)
        for (n = 0; n < 8; n++)
        {
            p = 63;
            for (j = 7; j >= 0; j--)
                for (k = 0; k < 8; k++)
                {
                    if ((a[i*8+j] >> k) & 1 != 0)
                        internal[i*8+n] ^= l[p*8+n];
                    p--;
                }
        }
    memcpy(result, internal, 64);
}

Кроме того в тексте используется обозначение X[K](A), которое тоже оказалось банальным побайтовым xor-ом массивов K и a:

static void GOSThash_X(unsigned char *k, unsigned char *a, unsigned char *result)
{
    GOSThash_xor(k, a, result);
}

Может возникнуть закономерный вопрос: зачем во всех этих функциях я вводил какой-то промежуточный массив internal, не проще ли было бы сразу писать в result? Не проще, потому что result может указывать на ту же область памяти, что и исходные данные - для экономии места, и если исходные данные после выполнения функции уже не нужны. Следующая функция, реализующая суперпозицию операторов LPS, этот факт иллюстрирует:

static void GOSThash_LPS(unsigned char *a, unsigned char *result)
{
    GOSThash_S(     a, result);
    GOSThash_P(result, result);
    GOSThash_L(result, result);
}

Дальше вводится некое преобразование E, являющееся суперпозицией описанных выше операторов:

static void GOSThash_E(unsigned char *k, unsigned char *m, unsigned char *result)
{
    unsigned char C[768] = {
        0xb1, 0x08, 0x5b, 0xda, 0x1e, 0xca, 0xda, 0xe9, 0xeb, 0xcb, 0x2f, 0x81, 0xc0, 0x65, 0x7c, 0x1f,
        0x2f, 0x6a, 0x76, 0x43, 0x2e, 0x45, 0xd0, 0x16, 0x71, 0x4e, 0xb8, 0x8d, 0x75, 0x85, 0xc4, 0xfc,
        0x4b, 0x7c, 0xe0, 0x91, 0x92, 0x67, 0x69, 0x01, 0xa2, 0x42, 0x2a, 0x08, 0xa4, 0x60, 0xd3, 0x15,
        0x05, 0x76, 0x74, 0x36, 0xcc, 0x74, 0x4d, 0x23, 0xdd, 0x80, 0x65, 0x59, 0xf2, 0xa6, 0x45, 0x07,

        0x6f, 0xa3, 0xb5, 0x8a, 0xa9, 0x9d, 0x2f, 0x1a, 0x4f, 0xe3, 0x9d, 0x46, 0x0f, 0x70, 0xb5, 0xd7,
        0xf3, 0xfe, 0xea, 0x72, 0x0a, 0x23, 0x2b, 0x98, 0x61, 0xd5, 0x5e, 0x0f, 0x16, 0xb5, 0x01, 0x31,
        0x9a, 0xb5, 0x17, 0x6b, 0x12, 0xd6, 0x99, 0x58, 0x5c, 0xb5, 0x61, 0xc2, 0xdb, 0x0a, 0xa7, 0xca,
        0x55, 0xdd, 0xa2, 0x1b, 0xd7, 0xcb, 0xcd, 0x56, 0xe6, 0x79, 0x04, 0x70, 0x21, 0xb1, 0x9b, 0xb7,

        0xf5, 0x74, 0xdc, 0xac, 0x2b, 0xce, 0x2f, 0xc7, 0x0a, 0x39, 0xfc, 0x28, 0x6a, 0x3d, 0x84, 0x35,
        0x06, 0xf1, 0x5e, 0x5f, 0x52, 0x9c, 0x1f, 0x8b, 0xf2, 0xea, 0x75, 0x14, 0xb1, 0x29, 0x7b, 0x7b,
        0xd3, 0xe2, 0x0f, 0xe4, 0x90, 0x35, 0x9e, 0xb1, 0xc1, 0xc9, 0x3a, 0x37, 0x60, 0x62, 0xdb, 0x09,
        0xc2, 0xb6, 0xf4, 0x43, 0x86, 0x7a, 0xdb, 0x31, 0x99, 0x1e, 0x96, 0xf5, 0x0a, 0xba, 0x0a, 0xb2,

        0xef, 0x1f, 0xdf, 0xb3, 0xe8, 0x15, 0x66, 0xd2, 0xf9, 0x48, 0xe1, 0xa0, 0x5d, 0x71, 0xe4, 0xdd,
        0x48, 0x8e, 0x85, 0x7e, 0x33, 0x5c, 0x3c, 0x7d, 0x9d, 0x72, 0x1c, 0xad, 0x68, 0x5e, 0x35, 0x3f,
        0xa9, 0xd7, 0x2c, 0x82, 0xed, 0x03, 0xd6, 0x75, 0xd8, 0xb7, 0x13, 0x33, 0x93, 0x52, 0x03, 0xbe,
        0x34, 0x53, 0xea, 0xa1, 0x93, 0xe8, 0x37, 0xf1, 0x22, 0x0c, 0xbe, 0xbc, 0x84, 0xe3, 0xd1, 0x2e,

        0x4b, 0xea, 0x6b, 0xac, 0xad, 0x47, 0x47, 0x99, 0x9a, 0x3f, 0x41, 0x0c, 0x6c, 0xa9, 0x23, 0x63,
        0x7f, 0x15, 0x1c, 0x1f, 0x16, 0x86, 0x10, 0x4a, 0x35, 0x9e, 0x35, 0xd7, 0x80, 0x0f, 0xff, 0xbd,
        0xbf, 0xcd, 0x17, 0x47, 0x25, 0x3a, 0xf5, 0xa3, 0xdf, 0xff, 0x00, 0xb7, 0x23, 0x27, 0x1a, 0x16,
        0x7a, 0x56, 0xa2, 0x7e, 0xa9, 0xea, 0x63, 0xf5, 0x60, 0x17, 0x58, 0xfd, 0x7c, 0x6c, 0xfe, 0x57,

        0xae, 0x4f, 0xae, 0xae, 0x1d, 0x3a, 0xd3, 0xd9, 0x6f, 0xa4, 0xc3, 0x3b, 0x7a, 0x30, 0x39, 0xc0,
        0x2d, 0x66, 0xc4, 0xf9, 0x51, 0x42, 0xa4, 0x6c, 0x18, 0x7f, 0x9a, 0xb4, 0x9a, 0xf0, 0x8e, 0xc6,
        0xcf, 0xfa, 0xa6, 0xb7, 0x1c, 0x9a, 0xb7, 0xb4, 0x0a, 0xf2, 0x1f, 0x66, 0xc2, 0xbe, 0xc6, 0xb6,
        0xbf, 0x71, 0xc5, 0x72, 0x36, 0x90, 0x4f, 0x35, 0xfa, 0x68, 0x40, 0x7a, 0x46, 0x64, 0x7d, 0x6e,

        0xf4, 0xc7, 0x0e, 0x16, 0xee, 0xaa, 0xc5, 0xec, 0x51, 0xac, 0x86, 0xfe, 0xbf, 0x24, 0x09, 0x54,
        0x39, 0x9e, 0xc6, 0xc7, 0xe6, 0xbf, 0x87, 0xc9, 0xd3, 0x47, 0x3e, 0x33, 0x19, 0x7a, 0x93, 0xc9,
        0x09, 0x92, 0xab, 0xc5, 0x2d, 0x82, 0x2c, 0x37, 0x06, 0x47, 0x69, 0x83, 0x28, 0x4a, 0x05, 0x04,
        0x35, 0x17, 0x45, 0x4c, 0xa2, 0x3c, 0x4a, 0xf3, 0x88, 0x86, 0x56, 0x4d, 0x3a, 0x14, 0xd4, 0x93,

        0x9b, 0x1f, 0x5b, 0x42, 0x4d, 0x93, 0xc9, 0xa7, 0x03, 0xe7, 0xaa, 0x02, 0x0c, 0x6e, 0x41, 0x41,
        0x4e, 0xb7, 0xf8, 0x71, 0x9c, 0x36, 0xde, 0x1e, 0x89, 0xb4, 0x44, 0x3b, 0x4d, 0xdb, 0xc4, 0x9a,
        0xf4, 0x89, 0x2b, 0xcb, 0x92, 0x9b, 0x06, 0x90, 0x69, 0xd1, 0x8d, 0x2b, 0xd1, 0xa5, 0xc4, 0x2f,
        0x36, 0xac, 0xc2, 0x35, 0x59, 0x51, 0xa8, 0xd9, 0xa4, 0x7f, 0x0d, 0xd4, 0xbf, 0x02, 0xe7, 0x1e,

        0x37, 0x8f, 0x5a, 0x54, 0x16, 0x31, 0x22, 0x9b, 0x94, 0x4c, 0x9a, 0xd8, 0xec, 0x16, 0x5f, 0xde,
        0x3a, 0x7d, 0x3a, 0x1b, 0x25, 0x89, 0x42, 0x24, 0x3c, 0xd9, 0x55, 0xb7, 0xe0, 0x0d, 0x09, 0x84,
        0x80, 0x0a, 0x44, 0x0b, 0xdb, 0xb2, 0xce, 0xb1, 0x7b, 0x2b, 0x8a, 0x9a, 0xa6, 0x07, 0x9c, 0x54,
        0x0e, 0x38, 0xdc, 0x92, 0xcb, 0x1f, 0x2a, 0x60, 0x72, 0x61, 0x44, 0x51, 0x83, 0x23, 0x5a, 0xdb,

        0xab, 0xbe, 0xde, 0xa6, 0x80, 0x05, 0x6f, 0x52, 0x38, 0x2a, 0xe5, 0x48, 0xb2, 0xe4, 0xf3, 0xf3,
        0x89, 0x41, 0xe7, 0x1c, 0xff, 0x8a, 0x78, 0xdb, 0x1f, 0xff, 0xe1, 0x8a, 0x1b, 0x33, 0x61, 0x03,
        0x9f, 0xe7, 0x67, 0x02, 0xaf, 0x69, 0x33, 0x4b, 0x7a, 0x1e, 0x6c, 0x30, 0x3b, 0x76, 0x52, 0xf4,
        0x36, 0x98, 0xfa, 0xd1, 0x15, 0x3b, 0xb6, 0xc3, 0x74, 0xb4, 0xc7, 0xfb, 0x98, 0x45, 0x9c, 0xed,

        0x7b, 0xcd, 0x9e, 0xd0, 0xef, 0xc8, 0x89, 0xfb, 0x30, 0x02, 0xc6, 0xcd, 0x63, 0x5a, 0xfe, 0x94,
        0xd8, 0xfa, 0x6b, 0xbb, 0xeb, 0xab, 0x07, 0x61, 0x20, 0x01, 0x80, 0x21, 0x14, 0x84, 0x66, 0x79,
        0x8a, 0x1d, 0x71, 0xef, 0xea, 0x48, 0xb9, 0xca, 0xef, 0xba, 0xcd, 0x1d, 0x7d, 0x47, 0x6e, 0x98,
        0xde, 0xa2, 0x59, 0x4a, 0xc0, 0x6f, 0xd8, 0x5d, 0x6b, 0xca, 0xa4, 0xcd, 0x81, 0xf3, 0x2d, 0x1b,

        0x37, 0x8e, 0xe7, 0x67, 0xf1, 0x16, 0x31, 0xba, 0xd2, 0x13, 0x80, 0xb0, 0x04, 0x49, 0xb1, 0x7a,
        0xcd, 0xa4, 0x3c, 0x32, 0xbc, 0xdf, 0x1d, 0x77, 0xf8, 0x20, 0x12, 0xd4, 0x30, 0x21, 0x9f, 0x9b,
        0x5d, 0x80, 0xef, 0x9d, 0x18, 0x91, 0xcc, 0x86, 0xe7, 0x1d, 0xa4, 0xaa, 0x88, 0xe1, 0x28, 0x52,
        0xfa, 0xf4, 0x17, 0xd5, 0xd9, 0xb2, 0x1b, 0x99, 0x48, 0xbc, 0x92, 0x4a, 0xf1, 0x1b, 0xd7, 0x20
        };

    unsigned char K[64];
    memcpy(K, k, 64);

    unsigned char internal[64] = {0};
    GOSThash_X(K, m, internal);

    int i;
    for (i = 0; i < 12; i++)
    {
        GOSThash_LPS(internal, internal);
        GOSThash_xor(K, &(C[i*64]), K);
        GOSThash_LPS(K, K);
        GOSThash_X(K, internal, internal);
    }
    memcpy(result, internal, 64);
}

Там используются константы (я их байтовое представление свёл в один массив), которые причудливо xor-ятся с исходными данными, и всё это тщательно перемешивается.

И, наконец, код для того, что в документации называется функцией сжатия g:

static void GOSThash_g(unsigned char *N, unsigned char *h, unsigned char *m, unsigned char *result)
{
    unsigned char internal[64] = {0};
    GOSThash_xor (h, N, internal);

    GOSThash_LPS(internal, internal);

    GOSThash_E(internal, m, internal);
    GOSThash_xor (internal, h, internal);
    GOSThash_xor (internal, m, internal);
    memcpy(result, internal, 64);
}

С использованием этого богатства уже можно приступать к реализации собственно алгоритма. Однако выяснилась любопытная вещь. Попытка прохэшировать "в лоб" последовательности из примеров, приведенных в документации, выявила, что эти последовательности представлены в "перевернутом" виде (нулевой байт на последнем месте, т.е. 321 вместо 123), так что и все вышеприведенные функции по-хорошему должны работать с перевернутыми последовательностями. Какой удар от авторов! Чтобы не сломать себе мозг этим зеркалированием, добавил в инструментарий аналог memcpy:

static void GOSThash_memcpy(unsigned char *destination, unsigned char *source, size_t num)
{
    int s = num, d = 0;
    while (--s >= 0)
        destination[d++] = source[s];
}

И, наконец, получилась собственно функция хэширования файла:

char *GOSThash_FromFile (char *filename, int hashtype)
{
    char *result = NULL;

    unsigned char M [64] = {0};
    FILE *f;
    if (f = fopen(filename, "r"))
    {

        unsigned char e[64] = {0};
        unsigned char h[64] = {0};

        if (hashtype == 256)
        {
            int i;
            for (i = 0; i < 64; i++)
                h[i] = 1;
        }

        unsigned char N[64] = {0};
        unsigned char Z[64] = {0};

        unsigned char m[64] = {0};

        int total = 0;
        int sz = 0;
        while(sz = fread(M, sizeof(char), 64, f))
        {
            total += sz;
            if (sz == 64)
            {
                GOSThash_memcpy(m, M, 64);

                GOSThash_g (N, h, m, h);

                e[62] = (512 >> 8);
                e[63] = (512 & 0xFF);
                GOSThash_plus(N, e, N);

                GOSThash_plus(Z, m, Z);
            }
            else
            {
                memset(m, 0, 64);
                GOSThash_memcpy(&(m[64-sz]), M, sz);
                m[64-sz-1] = 1;

                GOSThash_g (N, h, m, h);

                e[62] = ((sz*8) >> 8);
                e[63] = ((sz*8) & 0xFF);

                GOSThash_plus(N, e, N);

                GOSThash_plus(Z, m, Z);

                e[62] = 0;
                e[63] = 0;
                GOSThash_g (e, h, N, h);

                GOSThash_g (e, h, Z, h);

                result = GOSThash_PrintArray(h, (hashtype == 256) ? 32 : 64);
            }
        }
        fclose(f);
    }

    return result;
}

И полностью аналогичная ей функция хэширования строки:

char *GOSThash_FromString (char *string, int hashtype)
{
    char *result = NULL;

    unsigned char e[64] = {0};
    unsigned char h[64] = {0};

    if (hashtype == 256)
    {
        int i;
        for (i = 0; i < 64; i++)
            h[i] = 1;
    }

    unsigned char N[64] = {0};
    unsigned char Z[64] = {0};

    unsigned char m[64] = {0};

    // Этап 2. Обработка длинных сообщений
    int start = 0;
    while (start + 64 <= strlen(string))
    {
        GOSThash_memcpy(m, &(string[start]), 64);

        GOSThash_g (N, h, m, h);

        e[62] = (512 >> 8);
        e[63] = (512 & 0xFF);
        GOSThash_plus(N, e, N);

        GOSThash_plus(Z, m, Z);

        start += 64;
    }

    // Этап 3.
    int sz = strlen(string) - start;
    memset(m, 0, 64);
    GOSThash_memcpy(&(m[64-sz]), &(string[start]), sz);
    m[64-sz-1] = 1;

    GOSThash_g (N, h, m, h);

    e[62] = ((sz*8) >> 8);
    e[63] = ((sz*8) & 0xFF);
    GOSThash_plus(N, e, N);

    GOSThash_plus(Z, m, Z);

    e[62] = 0;
    e[63] = 0;
    GOSThash_g (e, h, N, h);

    GOSThash_g (e, h, Z, h);

    result = GOSThash_PrintArray(h, (hashtype == 256) ? 32 : 64);
    return result;
}

Использовать всё это можно, например, так:

char *result;

// 512-битное хэширование
if (result = GOSThash_FromString ("Се ветри, Стрибожи внуци, веют с моря стрелами на храбрыя полкы Игоревы", 512))
{
    puts(result);
    free(result);
}

// 256-битное хэширование
if (result = GOSThash_FromString ("Се ветри, Стрибожи внуци, веют с моря стрелами на храбрыя полкы Игоревы", 256))
{
    puts(result);
    free(result);
}

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

Windows 7. Восстанавливаем работоспособность системы...

... с помощью убунты и нескольких непечатных слов.

В общем, принесли мне неделю назад ноутбук с такой проблемой. При загрузке Windows 7 starter запускается программа восстановления загрузки, некоторое время крутится, потом выдает ошибку, что восстановление системы невозможно, и предлагает отправить куда-то в майкрософт примерно такое сообщение:

Problem Event Name: StartupRepairOffline
Problem Sig 1: 6.1.7600.16385
Problem Sig 2: 6.1.7600.16385
Problem Sig 3: unknown
Ptrobel Sig 4: 21201028 (тут я не помню, какие на самом деле цифры)
Problem Sig 5: AutoFailover
Problem Sig 6: 11
Problem Sig 7: Corrupt File

Не очень информативно, честно говоря. После этого ноутбук перезагружается, и картина повторяется.

Первым делом захотелось сделать образ диска - с моими кривыми руками весьма своевременное желание. Но вот чем? Полез гуглить. После некоторого поиска набрёл на вот такую табличку. В представленном списке заинтересовали две программы: Clonezilla и Redo Backup and Recovery. Обе под лицензией GPL, обе устанавливаются на флэшку (на ноутбуке CD-привода нет), в общем, то, что нужно.

Сначала, конечно, попытался использовать Clonezilla (в названии прослеживаются аллюзии с мозиллой, значит, решил, солидный софт). Поставил эту ботву на подвернувшуюся под руку флэшку, попытался с нее загрузиться и... Ну, в общем, ясно - загрузиться мне с неё не удалось. Покопался fdisk-ом в разделах и решил, что дело вот в чём. По инструкции первый, загрузочный раздел начинается с 1 сектора, а у меня почему-то с 2048. Победить эту печаль удалось запустив команду fdisk следующим образом:

fdisk -c=dos /dev/sdb

Переразметил диск, распаковал на него архив этой Clonezillы, сделал его загрузочным, прицепил к свободному USB-порту внешний диск для образов, загрузился. Clonezilla пошуршала, и сообщила, что ей потребуется больше сорока часов для создания образа диска объемом 250Gb. Это немножко насторожило, но я согласился. На третьи сутки работы эта чудесная софтина вывалилась по эксепшену, не добежав до финиша примерно 20%.

Второй раз я решил не геройствовать и воспользовался Redo Backup and Recovery. Несмотря на её приятный графический интерфейс обнаружилась интересная особенность: для того, чтобы создать загрузочную флэшку, предлагается загрузиться с CD. Этакий pkunzip.zip в современном исполнении. Свой домашний компьютер перезагружать лень, поэтому воспользовался VirtualBox-ом - примонтировал образ диска, прицепил флэшку, загрузился и закинул на флэшку образ при помощи встроенной утилиты.

Но не тут-то было. Свежезаписанная флэшка грузиться отказалась. Опять. Стал выяснять, чем всё-таки этот чертов загрузочный диск можно на флэшку поместить. Оказалось, что под убунтой есть специальная утилита, usb-creator-gtk, которая подозрительно напомнила то, чем пытался сделать загрузочную флэшку оригинальный Redo B&R. И, как и следовало ожидать, результат получился тот же.

В конце концов обратился к варианту, который не рекомендуют авторы обеих этих утилит, а именно к UNetbootin. И - о, чудо - наконец-то удалось загрузиться почти без проблем. После этого Redo Backup and Recovery бодро проработал 7 часов, и у меня на руках оказался, наконец, вожделенный образ ноутбучного диска. Тогда я еще не знал, что это за образ...

После этого приступил к доламыванию Windows 7. С помощью ноутбучных утилит забрался в Recovery Console и попытался воспользоваться вот этой инструкцией. Безуспешно: в папке c:\windows\system32\config\RegBack файлы DEFAULT, SAM, SECURITY, SOFTWARE и SYSTEM оказались нулевого размера.

Гуглю дальше. Согласно очередной инструкции попытался выполнить вот такой набор команд:

bootrec.exe  /fixmbr
bootrec.exe  /fixboot
bootrec.exe  /RebuildBcd

Последняя команда отрапортовала, что Total identified Windows installations: 0, и, соответственно, ничего она менять не будет. На этот счет обнаружилась другая инструкция, по совету которой выполнил еще несколько команд:

bcdedit /export c:\bcdbackup
attrib c:\boot\bcd -h -r -s
ren c:\boot\bcd bcd.old
bootrec.exe  /RebuildBcd

Ура, ура, на этот раз всё получилось.

Перезагрузил ноутбук. Картина радикально поменялась - Windows перестала запускать даже Recovery Console, зато честно сообщила, чего ей не хватает:

PCIIDEX.SYS
Status: 0xc0000098.
Info: Windows failed to load because a required file is missing, or corrupt

Заинтересовался, как же выглядит этот файл на пострадавшей машине. Самым простым способом, подумалось, будет примонтировать ранее созданный образ к своей убунте и там глянуть. И тут выяснилось, что полученный через тернии образ представляет собой набор из шестидесяти двухгигабайтных файлов, который как примонтировать к линуксу, похоже, не знают сами авторы. Попутно выяснилось, что Redo Backup and Recovery - всего лишь фронтенд для другой утилиты, partclone. Но образ partclone - вроде как один файл, и его убунта монтировать умеет:

sudo dpkg -i partclone-utils_0.1-1_i386.deb
sudo sudo apt-get install nbd-client
sudo imagemount -d /dev/nbd0 -f sda1-partclone.img
sudo mount /dev/nbd0 /media/temp

А тут вместо одного файла что-то хитрое. Решил не мучиться дальше и восстановить образ в виртуалке - благо, дисковое пространство позволяет. Развернул (потребовалось раза в три больше времени, чем на снятие образа), примонтировал командой:

sudo mount -t ntfs /dev/sdb2 /media/notebook-image

и обнаружил, что pciidex.sys, расположенный в папке \windows\system32\drivers, имеет нулевой размер.

Дальше уже дело техники - нашел живую машину с windows 7, сдернул с неё этот файл (он оказался размером 42560 байт), и с помощью всё той же загрузочной флэшки с Redo Backup and Recovery положил этот файл на место нулевого.

И - надо же - всё загрузилось 8-)

HASP HL - просмотр ключей

Для того, чтобы просмотреть информацию о ключах HASP HL, можно воспользоваться обычным браузером, перейдя по ссылке: http://localhost:1947/accrus/devices.html

UPD 2013-11-05: набрёл на faq

Ubuntu: работа с mkvtoolnix

Понадобилось тут достать субтитры из файла mkv. Оказывается, есть набор утилит для работы с этим форматом, называется он mkvtoolnix. Состоит как минимум из трех: mkvmerge, mkvinfo и mkvextract.

Посмотреть содержимое файла:

mkvinfo myFile.mkv

Извлечь нужный раздел в отдельный файл:

mkvextract tracks myFile.mkv (идентификатор раздела):newFile

Например: mkvextract tracks myFile.mkv 2:subtitles.ass.

Android: настраиваем IPTV

В общем, ситуация следующая: есть Android-планшет (DNS AirTab M100), который через WiFi подцеплен к роутеру D-Link DIR-300. Этот роутер, в свою очередь, общается с инетом через провайдера (Новотелеком, если кому интересно). У провайдера есть услуга IPTV. Возникает естественный вопрос - как это богатство завести на планшет?

Алгоритм такой:

1. Настраиваем роутер. В админке, в меню Advanced - Advanced network, устанавливаем галочки напротив пунктов Enable Multicast Streams и Wireless Enhance Mode.

2. Настраиваем планшет. Из Google Play Маркета устанавливаем MX Player - он вроде как нужен для проигрывания видео.

3. Из всё того же Google Play Маркета устанавливаем IPTV-плеер, в котором прописываем URL-адрес плей-листа (в формате m3u).

4. Этот IPTV-плеер что-то спрашивает про настройку UDP-прокси, я соответствующую галочку (использовать прокси) снял, ничего плохого от этого не случилось.

5. Вроде как всё.

Slackware: зависла мышь

С какого-то перепугу стала зависать мышь. Компьютер вроде бы работает, но курсор не двигается, и на нажатия кнопок/прокрутку колеса реакции ноль.
Помогли вот эти две команды в консоли:

sudo rmmod psmouse
sudo modprobe psmouse

Нормальный алгоритм Маркова

В общем, помыкавшись по интернету, обнаружил поразительную вещь: нечасто встречаются реализации нормального алгоритма Маркова, у которых корректно отрабатывает правило:
$0->0$$$$$$$$$$

Не знаю уж, почему так. Точнее, выяснилось, что как-то хитро себя ведет джаваскриптовская функция string.replace(), но дальше разбираться лень. Поэтому накидал свой собственный велосипед.

---

Введите начальную последовательность символов:



Нормальный алгоритм Маркова (например, a->b):
// Пример: простейший калькулятор // (сложение, вычитание, умножение натуральных чисел) // Алфавит: 1234567890+-*abcdefghioxyz^@$#? // переводим числа из унарной в десятичную систему (часть 2) z^->za o^->a a^->b b^->c c^->d d^->e e^->f f^->g g^->h h^->i i^->^o za->1z zb->2z zc->3z zd->4z ze->5z zf->6z zg->7z zh->8z zi->9z zo->0z z->. // переводим числа из десятичной в унарную систему счисления 1->0$ 2->1$ 3->2$ 4->3$ 5->4$ 6->5$ 7->6$ 8->7$ 9->8$ $0->0$$$$$$$$$$ 0-> // умножаем числа в унарной системе счисления x$->$?x x?->? x-> ?$->$? $$*$->$*x$ $*$->$ *$$->*$ *$-> ?->$ // преобразуем отрицательные числа в унарной системе счисления -$-># #$->## // убираем плюсы $+#->+ #+$->+ +-> // сокращаем пары #$-> $#-> // переводим положительные числа из унарной в десятичную систему (часть 1) ^$->^^ $->y^ y->zo // переводим отрицательные числа из унарной в десятичную систему (часть 1) ^#->^^ #->@^ @->-zo

Linux: Продолжаю осваивать git

Собственно, возникла простая задача:
1. Поднять на "сервере" сервер git (это не тавтология)
2. Научиться с репозиториями этого сервера работать по ssh.

Первая задача в первом приближении решилась просто: скачиваем исходники git одним архивом, разархивируем, читаем внимательно файл INSTALL, выполняем команды:

$ make configure
$ ./configure --prefix=/usr
$ make all doc
# make install install-doc install-html

в общем, на вид ничего сложного, справится даже такой тупень, как я.

Вторая задача, как оказалось, тоже не бином Ньютона. Если, конечно, внимательно прочитать инструкцию. Или полезные указания опытных людей. Или ещё что-нибудь.

Но это всё, конечно, не про меня. Узнав про команду ssh-keygen и обрадовавшись открывшимся возможностям я полез заводить юзера git, создавать домашнюю папку, давать разрешения и т.п. В результате каких-то вычурных команд репозиторий обосновался в домашней папке этого пользователя, а сам пользователь получил возможность интерактивного входа в систему. Кошмар. (Зато научился блокировать и разблокировать пользователя командами passwd -l git и passwd -u git)

Короче говоря, сделал так. В папке /opt создал символическую ссылку на папку с репозиторием (этот репозиторий с проектами будет жить на отдельном диске), и принял следующую схему работы при создании нового проекта.

На сервере выполняем команды:

$ cd /opt/git
$ mkdir newProject
$ cd newProject
$ git init --bare
$ git commit -m 'Initial commit'

На клиенте выполняем команды

$ cd newProject
$ git init
$ git remote add origin mylogin@myserver:/opt/git/newProject
$ git pull origin master

Если когда-нибудь этот репозиторий перекочует, можно будет сменить оригины командой

$ git remote set-url origin mylogin@myserver:/new-git-repository/newProject

(кстати, текущие значения этих оригинов в текстовом виде хранятся в папке проекта в файле .git/config)

Ну, эта схема ещё явно не окончательная.

Кстати, набрёл еще на одну памятку. Может, пригодится...

Важное дополнение: клиент git под Windows как-то странно рисует кириллические имена файлов. Вроде бы научить его русскому языку удалось командой:

$ git config --global core.quotepath false

Slackware: DosBox 0.74

Пытался тут себе поставить этот самый DosBox 0.74. Всё бы ничего, но команда make при компиляции из исходников ругается примерно так: expected primary-expression before «,» token.

Как выяснилось, есть специальный патч:
http://slackbuilds.org/slackbuilds/14.0/system/dosbox/dosbox-0.74-gcc46.patch

С этим патчем получилось весело. Содержимое этого чудесного файла представляет из себя коротенький текст, но текст не простой, а набор команд для специальной утилиты patch, о существовании которой я - позор, позор - доселе и не подозревал.

В общем, скачиваем файл, кладём его в папку с исходником DosBox-а, выполняем команду

patch -p0 dosbox-0.74-gcc46.patch

и спокойно компилируем.

Linux: терминал

Почему-то в терминале перестала работать клавиша Delete. Вместо того, чтобы удалять символ, рисует тильду (~).

Решение такое: в ~/.inputrc добавить строку:

"\e[3~": delete-char

Debian: устанавливаем I2P

Захотелось тут подключиться к I2P. Нет, мамаша, дети могут не выходить. Нет, не весна. Просто совпало. В общем, установка всего этого богатства расписана тут. Вкратце:

1. Выполняем команду:

sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys EB2CC88B

2. Создаём файл /etc/apt/sources.list.d/i2p.list со строками:

deb http://ppa.launchpad.net/i2p-maintainers/i2p/ubuntu natty main 
deb-src http://ppa.launchpad.net/i2p-maintainers/i2p/ubuntu natty main

3. Выполняем команду:

sudo apt-get update

4. Инсталлируем требуемый софт:

sudo apt-get install i2p

Дальше конфигурируем способ запуска роутера командой

sudo dpkg-reconfigure i2p

прописываем в браузере прокси для HTTP - 127.0.0.1:4444, и для HTTPS - 127.0.0.1:4445, и вроде как всё.

Но этого оказалось мало.

Во-первых, захотелось, чтобы эта штука жила на отдельном компе, который у меня "сервер" для всяких tor-ов, торрентов и т.п. Выяснилось, что по умолчанию i2p-роутер сконфигурирован так, чтобы принимать клиентские подключения только с 127.0.0.1. Однако, если зайти в админку,

http://localhost:7657/i2ptunnel/edit.jsp?tunnel=0

то можно там изменить настройки точки доступа на сетевой интерфейс 192.168.xxx.xxx.

Во-вторых, захотелось, чтобы Opera пользовалась этой штукой хитро: на обычные сайты ходила по-прежнему через tor, а на сайты с именами вида *.i2p - через этот новый i2p-роутер. Оказывается, нужно отредактировать файл ~/.opera/override.ini примерно так:

[Overrides]
...
i2p

...

[i2p]
Proxy|Use HTTP=1
Proxy|HTTP server=192.168.xxx.xxx:4444
Proxy|HTTPS server=192.168.xxx.xxx:4445

Вот тогда стало всё ок.

SQL Server: Показать разрешения пользователя на объект

Оказывается, просто:

EXECUTE AS LOGIN = 'WanidaBenshoof';
SELECT * FROM fn_my_permissions('AdventureWorks2012.HumanResources.Employee', 'OBJECT') 
    ORDER BY subentity_name, permission_name ;  
REVERT;
GO

Windows: MiKTeX и расстановка переносов

Обнаружилось, что древний(?) MiKTeX 2.6 не расставляет переносы.

Как оказалось, проблема решается следующим способом:

1. В файле \tex\generic\config\language.dat нужно найти и раскомментировать (или добавить, как повезёт) следующие строки:

\russian  ruenhyph.tex  
=russian

2. Зайти в папку \tex\generic\ruhyphen и скопировать в папку \texmf\tex\generic\hyphen все файлы вида ru*.tex и enru*.tex.

3. Зайти в папку \miktex\bin и выполнить команду:

initexmf --dump

И вот тут начинаются чудеса.

4. Команда из предыдущего пункта ругается LaTeX source files more than 5 years old! и ничего не делает. Как выяснилось, это обходится так:
- открываем файл \tex\latex\base\latex.ltx
- находим там строку \ifnum\count@>65 и меняем её на \ifnum\count@>100

5. После этого читерства команда из п.3 выполняется без ошибок.

Windows: ошибка в MS Office Document Imaging

Неожиданно стал дохнуть Microsoft Office Document Imaging при попытке зайти в меню "Файл" вот с такой ошибкой:
Faulting application mspview.exe, version 11.0.8166.2, stamp 4616c203, faulting module mspview.exe, version 11.0.8166.2, stamp 4616c203, debug? 0, fault address 0x00016537.

Говорят, есть специальный патч:
http://support.microsoft.com/kb/938813

Поставил. Не помогло. Оказывается, надо было читать дальше 8-). Дело было в длинном имени файла, фигурирующем в следующей ветке реестра:
HKEY_CURRENT_USER\Software\Microsoft\MSPaper 11.0\Recent File List

Почистил виновный параметр, и всё заработало.

Windows: где находится мастер работы со сканером

Оказывается, здесь:
C:\WINDOWS\system32\wiaacmgr.exe

А вот тут есть еще некоторое количество команд:
http://jitendra07.blogspot.ru/2007/03/hidden-command-line-which-u-should-know.html
http://www.brighthub.com/computing/windows-platform/articles/58574.aspx

Где я никогда не побываю

Slackware: компьютер не виден по netbios

Если с других рабочих станций локальной сети ваш компьютер не может быть найден по его netbios(wins)-имени, можно попробовать сделать следующее:

1. проверить, что это имя корректно прописано в /etc/samba/smb.conf (раздел global, секция netbios name)

2. перезапустить самбу:

sudo /etc/rc.d/rc.samba restart

3. посмотреть логи самбы - вдруг, она почему-то не стартовала.

Пышные блинчики

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

Вкратце:

2 яйца
300 мл молока
2 ст.л. сахара (у меня ушла столовая ложка плюс пакетик ванильного сахара)
щепотка соли
300 г муки (полтора граненых стакана)
2,5 ч.л. разрыхлителя (один пакетик 10 г)
60 г растопленного сливочного масла

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

У меня была сковорода с керамическим покрытием (ну эта, белая внутренность, "эффект лотоса", то-сё), так что смазывать её маслом оказалось необязательно. Ставим переключатель на 2.5, греем сковроду, начинаем жарить, уменьшаем до 2. Пары минут достаточно для жарки одной стороны. В общем, продукт должен быть такой, светло-коричневый.

Получилось не сильно много, но вкусно.

Debian: настройка apache2 для работы с SSL

Собственно, вот здесь всё описано подробно:
Создание самоподписного SSL-сертификата и настройка хоста Apache 2 для работы по https
Apache 2 с SSL/TLS: Шаг за Шагом

Вкратце:

Включаем в апаче mod_ssl:
sudo a2enmod ssl

Создаем сертификат:
openssl genrsa -des3 -out server.key.secure 1024
openssl rsa -in server.key.secure -out server.key
openssl req -new -key server.key -out server.csr
openssl x509 -req -days 365 -in server.csr -signkey server.key -out server.crt

Копируем сертификат в хранилище:
sudo cp server.crt /etc/ssl/certs
sudo cp server.key /etc/ssl/private

В конфиг сайта добавляем строки:
SSLEngine on
SSLOptions +FakeBasicAuth +ExportCertData +StrictRequire
SSLCertificateFile /etc/ssl/certs/server.crt
SSLCertificateKeyFile /etc/ssl/private/server.key

Проверяем, что в ports.conf указано слушать порт 443.

Перезапускаем апач.