Наверное, в жизни каждого разработчика возникает ситуация, когда надо придумать название своему новому детищу. Желательно, звучное и глубокомысленное. Мне вот нравятся хитрые аббревиатуры, например: СТЭЛС - Союз Транспортных Экспедиторов и Логистов Сибири, ИКС - Информационная комплексная система, СТЭК - Система Транспортного ЭКспедирования.
Однако, в очередной раз случился творческий кризис, и чтобы в дальнейшем не устраивать мозговой штурм, решил я записывать все варианты, что приходят в голову. Итак:
СИСКИ - Сетевая (можно Промышленная, тоже будет неплохо) Информационная Система Комплексной Интеграции
СЦУКО - Система Централизованного Управления Комплексом Организаций
САКУРА - Система Автоматизированного Комплексного Учета Разнородных Абстракций
КОРД - Комплекс Оперативной Работы с Документами
ВИРТ - Веб-Интерфейс Рабочих Технологий
СЕИФ - Сетевой Единый Интерфейс Функционирования
ВИННИ - Веб-Интерфейс Начального Накопления Информации
ПОНИ - Программный Интерфейс Накопления Информации
ПИВО - Простой Интерфейс Ведения Отчетности
ОИОИ - Открытый Интерфейс Обработки Информации
БАЛК - Базовый Аппаратно-Логический Комплекс
ПИОН - Простой Интерфейс Обработки и Накопления информации (а так же Перед Использованием Обработать Напильником)
ПОССУ - Программист Опять Сошел С Ума
понедельник, 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 пришлось слегка подправить - чтобы можно было его выполнить в терминале убунты:
Вот, собственно, и всё. Не скажу, что это как-то сильно мне помогло, но теперь на планшете живёт некая загадочная аппликуха Root Explorer, а сборщик мусора Clean Master (установленный штатным образом из Google PlayMarket-а) научился сносить предустановленные приложения.
Как давеча метко подметил Л.Каганов в своем блоге, пора в анкетах вводить новое правило: если там принято писать "английский - со словарём", то почему бы по аналогии не указывать "образование - с википедией"? Или, как в моём случае: "владение ПК - с гуглём". Так или иначе, гугление утвердило меня в мысли, что на этом планшете мне просто необходим рутовый доступ. Однако, как его получить?
Во-первых, на самом планшете в задаче "Настройки" есть пункт "{} Для разработчиков". В этом пункте есть подраздел "Отладка", в котором нужно поставить галочку напротив пункта "Отладка по 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_ - на будущее, чтобы было поменьше пересечений, а то мало ли, в каких проектах вздумается мне эту поделку использовать. Итак, поехали.
Первым делом, конечно, надо написать вывод результата:
Затем началась медитация над операциями, которые применяются к этим самым массивам. В тексте документа встретились два плюса - плюс в кружочке и плюс в квадратике. Эти загадочные бинарные операции, оказывается, имеют простой смысл:
1) плюс в кружочке - это банальный xor соответствующих байтов в двух массивах:
2) плюс в квадратике - это немного хитрее: берутся два массива, интерпретируются каждый как одно большое число, и эти числа складываются. При этом переполнение, если возникнет, игнорируется:
Дальше пошла суровая математика. Вводятся три преобразования над 64-х байтными массивами: P, S и L. Первые два ещё ничего, а вот третье... Однако, по порядку:
1) Преобразование P - банальная перестановка элементов массива:
2) Преобразование S - по сути, тоже перестановка, но чуть менее банальная:
3) И, наконец, преобразование L. В документации сказано, что это - умножение на некую матрицу, собственно, по сути так и есть, но осмыслить это удалось не сразу, и в голове получилась следующая картинка. Берётся наш исходный 64-х байтный массив B[64] и группируется по восемь байтов:
Кроме того в тексте используется обозначение X[K](A), которое тоже оказалось банальным побайтовым xor-ом массивов K и a:
Может возникнуть закономерный вопрос: зачем во всех этих функциях я вводил какой-то промежуточный массив internal, не проще ли было бы сразу писать в result? Не проще, потому что result может указывать на ту же область памяти, что и исходные данные - для экономии места, и если исходные данные после выполнения функции уже не нужны. Следующая функция, реализующая суперпозицию операторов LPS, этот факт иллюстрирует:
Дальше вводится некое преобразование E, являющееся суперпозицией описанных выше операторов:
И, наконец, код для того, что в документации называется функцией сжатия g:
С использованием этого богатства уже можно приступать к реализации собственно алгоритма. Однако выяснилась любопытная вещь. Попытка прохэшировать "в лоб" последовательности из примеров, приведенных в документации, выявила, что эти последовательности представлены в "перевернутом" виде (нулевой байт на последнем месте, т.е. 321 вместо 123), так что и все вышеприведенные функции по-хорошему должны работать с перевернутыми последовательностями. Какой удар от авторов! Чтобы не сломать себе мозг этим зеркалированием, добавил в инструментарий аналог memcpy:
И, наконец, получилась собственно функция хэширования файла:
Использовать всё это можно, например, так:
А в целом, думается, как-то не по-людски написанный документ, особенно часть с примерами. Вроде используются понятные последовательности, 12345678901234567890123456789012345678901234567890123456789012 и вышеиспользованная цитата про храбрыя полкы Игоревы, но представлены они так коряво, что не поймешь, то ли там в исходной последовательности байты отзеркалены, то ли в результирующем хэше их надо отзеркалить, а, может, вообще, надо не байты, а шестнадцатеричные цифры менять местами... Пришлось скачивать реализацию от авторов, чтобы понять, как оно должно быть на самом деле.
Я - любитель мастерить собственные велосипеды с квадратными колёсами. Поэтому подумал, что веселее написать собственную программу с нуля, нежели воспользоваться готовыми реализациями. То, что получилось, правда, представляет чисто академический интерес, поскольку очень нерационально использует память, вычислительные мощности и работает крайне медленно, но с хэшированием коротеньких строк вроде бы справляется. Может, кому и пригодится для зачёта по информатике.
Гипнотизирование мануала навело на мысль, что вся работа будет вестись с массивами из 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 запускается программа восстановления загрузки, некоторое время крутится, потом выдает ошибку, что восстановление системы невозможно, и предлагает отправить куда-то в майкрософт примерно такое сообщение:
Первым делом захотелось сделать образ диска - с моими кривыми руками весьма своевременное желание. Но вот чем? Полез гуглить. После некоторого поиска набрёл на вот такую табличку. В представленном списке заинтересовали две программы: Clonezilla и Redo Backup and Recovery. Обе под лицензией GPL, обе устанавливаются на флэшку (на ноутбуке CD-привода нет), в общем, то, что нужно.
Сначала, конечно, попытался использовать Clonezilla (в названии прослеживаются аллюзии с мозиллой, значит, решил, солидный софт). Поставил эту ботву на подвернувшуюся под руку флэшку, попытался с нее загрузиться и... Ну, в общем, ясно - загрузиться мне с неё не удалось. Покопался fdisk-ом в разделах и решил, что дело вот в чём. По инструкции первый, загрузочный раздел начинается с 1 сектора, а у меня почему-то с 2048. Победить эту печаль удалось запустив команду fdisk следующим образом:
Второй раз я решил не геройствовать и воспользовался 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 оказались нулевого размера.
Гуглю дальше. Согласно очередной инструкции попытался выполнить вот такой набор команд:
Перезагрузил ноутбук. Картина радикально поменялась - Windows перестала запускать даже Recovery Console, зато честно сообщила, чего ей не хватает:
Дальше уже дело техники - нашел живую машину с windows 7, сдернул с неё этот файл (он оказался размером 42560 байт), и с помощью всё той же загрузочной флэшки с Redo Backup and Recovery положил этот файл на место нулевого.
И - надо же - всё загрузилось 8-)
В общем, принесли мне неделю назад ноутбук с такой проблемой. При загрузке 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-)
Подписаться на:
Сообщения (Atom)