понедельник, 18 ноября 2013 г.

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

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

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

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

суббота, 16 ноября 2013 г.

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-а) научился сносить предустановленные приложения.

четверг, 7 ноября 2013 г.

Хэш-функция ГОСТ 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 и вышеиспользованная цитата про храбрыя полкы Игоревы, но представлены они так коряво, что не поймешь, то ли там в исходной последовательности байты отзеркалены, то ли в результирующем хэше их надо отзеркалить, а, может, вообще, надо не байты, а шестнадцатеричные цифры менять местами... Пришлось скачивать реализацию от авторов, чтобы понять, как оно должно быть на самом деле.

пятница, 1 ноября 2013 г.

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-)