![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bootmain.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [truecrypt] / truecrypt / boot / windows|
Return to bootmain.cpp CVS log | Up to [truecrypt] / truecrypt / boot / windows |
1.1 root 1: /*
1.1.1.8 root 2: Copyright (c) 2008-2009 TrueCrypt Foundation. All rights reserved.
1.1 root 3:
1.1.1.9 ! root 4: Governed by the TrueCrypt License 2.7 the full text of which is contained
1.1 root 5: in the file License.txt included in TrueCrypt binary and source code
6: distribution packages.
7: */
8:
9: #include "Crc.h"
10: #include "Crypto.h"
11: #include "Password.h"
12: #include "Volumes.h"
13:
14: #include "Platform.h"
15: #include "Bios.h"
16: #include "BootConfig.h"
17: #include "BootMain.h"
18: #include "BootDefs.h"
19: #include "BootCommon.h"
20: #include "BootConsoleIo.h"
21: #include "BootDebug.h"
22: #include "BootDiskIo.h"
23: #include "BootEncryptedIo.h"
1.1.1.2 root 24: #include "BootMemory.h"
1.1.1.6 root 25: #include "BootStrings.h"
1.1 root 26: #include "IntFilter.h"
27:
28:
29: static void InitScreen ()
30: {
31: ClearScreen();
32:
1.1.1.8 root 33: const char *title =
1.1.1.5 root 34: #ifndef TC_WINDOWS_BOOT_RESCUE_DISK_MODE
35: " TrueCrypt Boot Loader "
36: #else
37: " TrueCrypt Rescue Disk "
38: #endif
1.1.1.8 root 39: VERSION_STRING;
40:
41: Print (title);
42: PrintRepeatedChar (' ', title[26] ? 8 : 9);
43: Print ("Copyright (C) 2008-2009 TrueCrypt Foundation\r\n");
1.1 root 44:
1.1.1.5 root 45: PrintRepeatedChar ('\xDC', TC_BIOS_MAX_CHARS_PER_LINE);
1.1.1.6 root 46:
47: #ifndef TC_WINDOWS_BOOT_RESCUE_DISK_MODE
48: if (CustomUserMessage[0])
49: {
50: PrintEndl();
51: Print (CustomUserMessage);
52: }
53: #endif
54:
1.1 root 55: PrintEndl (2);
56: }
57:
58:
59: static void PrintMainMenu ()
60: {
1.1.1.6 root 61: if (PreventBootMenu)
62: return;
63:
1.1 root 64: Print (" Keyboard Controls:\r\n");
1.1.1.5 root 65: Print (" [Esc] ");
66:
67: #ifndef TC_WINDOWS_BOOT_RESCUE_DISK_MODE
68:
1.1.1.6 root 69: Print ((BootSectorFlags & TC_BOOT_CFG_MASK_HIDDEN_OS_CREATION_PHASE) != TC_HIDDEN_OS_CREATION_PHASE_NONE
70: ? "Boot Non-Hidden System (Boot Manager)"
1.1.1.5 root 71: : "Skip Authentication (Boot Manager)");
72:
73: #else // TC_WINDOWS_BOOT_RESCUE_DISK_MODE
74:
75: Print ("Skip Authentication (Boot Manager)");
76: Print ("\r\n [F8] "); Print ("Repair Options");
77:
78: #endif // TC_WINDOWS_BOOT_RESCUE_DISK_MODE
1.1 root 79:
80: PrintEndl (3);
81: }
82:
83:
84: static bool IsMenuKey (byte scanCode)
85: {
1.1.1.5 root 86: #ifdef TC_WINDOWS_BOOT_RESCUE_DISK_MODE
1.1 root 87: return scanCode == TC_MENU_KEY_REPAIR;
1.1.1.5 root 88: #else
89: return false;
90: #endif
1.1 root 91: }
92:
93:
94: static bool AskYesNo (const char *message)
95: {
96: Print (message);
97: Print ("? (y/n): ");
98: while (true)
99: {
100: switch (GetKeyboardChar())
101: {
102: case 'y':
103: case 'Y':
1.1.1.3 root 104: case 'z':
1.1.1.6 root 105: case 'Z':
106: Print ("y\r\n");
1.1 root 107: return true;
108:
109: case 'n':
110: case 'N':
1.1.1.6 root 111: Print ("n\r\n");
1.1 root 112: return false;
113:
114: default:
115: Beep();
116: }
117: }
118: }
119:
120:
121: static int AskSelection (const char *options[], size_t optionCount)
122: {
123: for (int i = 0; i < optionCount; ++i)
124: {
125: Print ("["); Print (i + 1); Print ("] ");
126: Print (options[i]);
127: PrintEndl();
128: }
129: Print ("[Esc] Cancel\r\n\r\n");
130:
131: Print ("To select, press 1-9: ");
132:
133: char str;
134:
135: while (true)
136: {
137: if (GetString (&str, 1) == 0)
138: return 0;
139:
140: if (str >= '1' && str <= optionCount + '0')
141: return str - '0';
142:
143: Beep();
144: PrintBackspace();
145: }
146: }
147:
148:
1.1.1.6 root 149: static byte AskPassword (Password &password)
1.1 root 150: {
151: size_t pos = 0;
152: byte scanCode;
153: byte asciiCode;
154:
1.1.1.5 root 155: Print ("Enter password");
1.1.1.6 root 156: Print (PreventNormalSystemBoot ? " for hidden system:\r\n" : ": ");
1.1 root 157:
158: while (true)
159: {
160: asciiCode = GetKeyboardChar (&scanCode);
161:
162: switch (scanCode)
163: {
164: case TC_BIOS_KEY_ENTER:
1.1.1.2 root 165: ClearBiosKeystrokeBuffer();
1.1 root 166: PrintEndl();
1.1.1.2 root 167:
168: password.Length = pos;
169: return scanCode;
1.1 root 170:
171: case TC_BIOS_KEY_BACKSPACE:
172: if (pos > 0)
173: {
174: if (pos < MAX_PASSWORD)
175: PrintBackspace();
176: else
1.1.1.6 root 177: PrintCharAtCursor (' ');
1.1 root 178:
179: --pos;
180: }
181: continue;
182:
183: default:
184: if (scanCode == TC_BIOS_KEY_ESC || IsMenuKey (scanCode))
185: {
186: burn (password.Text, sizeof (password.Text));
1.1.1.2 root 187: ClearBiosKeystrokeBuffer();
188:
1.1 root 189: PrintEndl();
190: return scanCode;
191: }
192: }
193:
194: if (!IsPrintable (asciiCode) || pos == MAX_PASSWORD)
195: {
196: Beep();
197: continue;
198: }
199:
200: password.Text[pos++] = asciiCode;
201: if (pos < MAX_PASSWORD)
202: PrintChar ('*');
203: else
1.1.1.6 root 204: PrintCharAtCursor ('*');
1.1 root 205: }
206: }
207:
208:
209: static void ExecuteBootSector (byte drive, byte *sectorBuffer)
210: {
211: Print ("Booting...\r\n");
212: CopyMemory (sectorBuffer, 0x0000, 0x7c00, TC_LB_SIZE);
1.1.1.3 root 213:
1.1.1.6 root 214: BootStarted = true;
215:
1.1.1.3 root 216: uint32 addr = 0x7c00;
217: __asm
218: {
219: cli
1.1.1.8 root 220: mov dl, drive // Boot drive
221: mov dh, 0
1.1.1.3 root 222: xor ax, ax
1.1.1.8 root 223: mov si, ax
1.1.1.3 root 224: mov ds, ax
225: mov es, ax
226: mov ss, ax
1.1.1.8 root 227: mov sp, 0x7c00
1.1.1.3 root 228: sti
1.1.1.8 root 229:
1.1.1.3 root 230: jmp cs:addr
231: }
1.1 root 232: }
233:
234:
1.1.1.6 root 235: static bool OpenVolume (byte drive, Password &password, CRYPTO_INFO **cryptoInfo, uint32 *headerSaltCrc32, bool skipNormal, bool skipHidden)
1.1 root 236: {
1.1.1.6 root 237: int volumeType;
238: bool hiddenVolume;
1.1 root 239: uint64 headerSec;
1.1.1.5 root 240:
1.1.1.3 root 241: AcquireSectorBuffer();
1.1 root 242:
1.1.1.6 root 243: for (volumeType = 1; volumeType <= 2; ++volumeType)
1.1 root 244: {
1.1.1.6 root 245: hiddenVolume = (volumeType == 2);
1.1.1.5 root 246:
1.1.1.6 root 247: if (hiddenVolume)
248: {
249: if (skipHidden || PartitionFollowingActive.Drive != drive || PartitionFollowingActive.SectorCount <= ActivePartition.SectorCount)
250: continue;
1.1.1.5 root 251:
1.1.1.6 root 252: headerSec = PartitionFollowingActive.StartSector + TC_HIDDEN_VOLUME_HEADER_OFFSET / TC_LB_SIZE;
253: }
254: else
1.1.1.5 root 255: {
1.1.1.6 root 256: if (skipNormal)
257: continue;
258:
259: headerSec.HighPart = 0;
260: headerSec.LowPart = TC_BOOT_VOLUME_HEADER_SECTOR;
1.1.1.5 root 261: }
262:
1.1.1.6 root 263: if (ReadSectors (SectorBuffer, drive, headerSec, 1) != BiosResultSuccess)
264: continue;
265:
266: if (ReadVolumeHeader (!hiddenVolume, (char *) SectorBuffer, &password, cryptoInfo, nullptr) == ERR_SUCCESS)
1.1.1.5 root 267: {
1.1.1.6 root 268: // Prevent opening a non-system hidden volume
269: if (hiddenVolume && !((*cryptoInfo)->HeaderFlags & TC_HEADER_FLAG_ENCRYPTED_SYSTEM))
270: {
271: crypto_close (*cryptoInfo);
272: continue;
273: }
274:
275: if (headerSaltCrc32)
276: *headerSaltCrc32 = GetCrc32 (SectorBuffer, PKCS5_SALT_SIZE);
1.1.1.5 root 277:
1.1.1.6 root 278: break;
279: }
1.1 root 280: }
281:
1.1.1.3 root 282: ReleaseSectorBuffer();
1.1.1.6 root 283: return volumeType != 3;
1.1 root 284: }
285:
286:
1.1.1.2 root 287: static bool CheckMemoryRequirements ()
288: {
289: uint16 codeSeg;
290: __asm mov codeSeg, cs
291: if (codeSeg == TC_BOOT_LOADER_LOWMEM_SEGMENT)
292: {
1.1.1.6 root 293: PrintError ("BIOS reserved too much memory: ", true, false);
1.1.1.2 root 294:
295: uint16 memFree;
296: __asm
297: {
298: push es
299: xor ax, ax
300: mov es, ax
301: mov ax, es:[0x413]
302: mov memFree, ax
303: pop es
304: }
305:
1.1.1.6 root 306: Print (memFree);
1.1.1.8 root 307: PrintEndl();
1.1.1.6 root 308: Print (TC_BOOT_STR_UPGRADE_BIOS);
1.1.1.5 root 309:
1.1.1.2 root 310: return false;
311: }
312:
313: return true;
314: }
315:
316:
1.1.1.5 root 317: static bool MountVolume (byte drive, byte &exitKey, bool skipNormal, bool skipHidden)
1.1 root 318: {
319: BootArguments *bootArguments = (BootArguments *) TC_BOOT_LOADER_ARGS_OFFSET;
1.1.1.3 root 320: int incorrectPasswordCount = 0;
1.1 root 321:
1.1.1.5 root 322: EraseMemory (bootArguments, sizeof (*bootArguments));
323:
1.1 root 324: // Open volume header
325: while (true)
326: {
1.1.1.6 root 327: exitKey = AskPassword (bootArguments->BootPassword);
1.1 root 328:
329: if (exitKey != TC_BIOS_KEY_ENTER)
330: return false;
331:
1.1.1.5 root 332: if (OpenVolume (BootDrive, bootArguments->BootPassword, &BootCryptoInfo, &bootArguments->HeaderSaltCrc32, skipNormal, skipHidden))
1.1 root 333: break;
334:
1.1.1.5 root 335: if (GetShiftFlags() & TC_BIOS_SHIFTMASK_CAPSLOCK)
336: Print ("Warning: Caps Lock is on.\r\n");
337:
1.1.1.4 root 338: Print ("Incorrect password.\r\n\r\n");
1.1.1.3 root 339:
1.1.1.6 root 340: if (++incorrectPasswordCount == 4)
1.1.1.3 root 341: {
1.1.1.6 root 342: #ifdef TC_WINDOWS_BOOT_RESCUE_DISK_MODE
343: Print ("The key data may be damaged. Use 'Repair Options' > 'Restore key data'.\r\n\r\n");
344: #else
1.1.1.3 root 345: Print ("If you are sure the password is correct, the key data may be damaged. Boot your\r\n"
346: "TrueCrypt Rescue Disk and select 'Repair Options' > 'Restore key data'.\r\n\r\n");
1.1.1.6 root 347: #endif
1.1.1.3 root 348: }
1.1 root 349: }
350:
351: // Setup boot arguments
1.1.1.5 root 352: bootArguments->BootLoaderVersion = VERSION_NUM;
1.1 root 353: bootArguments->CryptoInfoOffset = (uint16) BootCryptoInfo;
354: bootArguments->CryptoInfoLength = sizeof (*BootCryptoInfo);
1.1.1.5 root 355:
356: if (BootCryptoInfo->hiddenVolume)
357: bootArguments->HiddenSystemPartitionStart = PartitionFollowingActive.StartSector << TC_LB_SIZE_BIT_SHIFT_DIVISOR;
358:
1.1 root 359: TC_SET_BOOT_ARGUMENTS_SIGNATURE (bootArguments->Signature);
360:
1.1.1.5 root 361: // Setup virtual encrypted partition
1.1 root 362: if (BootCryptoInfo->EncryptedAreaLength.HighPart != 0 || BootCryptoInfo->EncryptedAreaLength.LowPart != 0)
363: {
364: EncryptedVirtualPartition.Drive = BootDrive;
365:
1.1.1.5 root 366: EncryptedVirtualPartition.StartSector = BootCryptoInfo->EncryptedAreaStart >> TC_LB_SIZE_BIT_SHIFT_DIVISOR;
367:
368: HiddenVolumeStartUnitNo = EncryptedVirtualPartition.StartSector;
369: HiddenVolumeStartSector = PartitionFollowingActive.StartSector;
370: HiddenVolumeStartSector += EncryptedVirtualPartition.StartSector;
371:
372: EncryptedVirtualPartition.SectorCount = BootCryptoInfo->EncryptedAreaLength >> TC_LB_SIZE_BIT_SHIFT_DIVISOR;
373:
374: EncryptedVirtualPartition.EndSector = EncryptedVirtualPartition.SectorCount - 1;
375: EncryptedVirtualPartition.EndSector += EncryptedVirtualPartition.StartSector;
1.1 root 376: }
377: else
378: {
379: // Drive not encrypted
1.1.1.5 root 380: EncryptedVirtualPartition.Drive = TC_INVALID_BIOS_DRIVE;
1.1 root 381: }
382:
383: return true;
384: }
385:
386:
387: static byte BootEncryptedDrive ()
388: {
1.1.1.5 root 389: BootArguments *bootArguments = (BootArguments *) TC_BOOT_LOADER_ARGS_OFFSET;
1.1.1.6 root 390: byte exitKey;
391: BootCryptoInfo = NULL;
1.1 root 392:
1.1.1.5 root 393: if (!GetActiveAndFollowingPartition (BootDrive))
1.1 root 394: goto err;
395:
1.1.1.6 root 396: if (!MountVolume (BootDrive, exitKey, PreventNormalSystemBoot, false))
1.1 root 397: return exitKey;
398:
1.1.1.2 root 399: if (!CheckMemoryRequirements ())
400: goto err;
1.1.1.5 root 401:
402: if (BootCryptoInfo->hiddenVolume)
403: {
404: EncryptedVirtualPartition = ActivePartition;
405: bootArguments->DecoySystemPartitionStart = ActivePartition.StartSector << TC_LB_SIZE_BIT_SHIFT_DIVISOR;
1.1.1.2 root 406: }
407:
408: if (!InstallInterruptFilters())
409: goto err;
1.1 root 410:
1.1.1.5 root 411: bootArguments->BootArgumentsCrc32 = GetCrc32 ((byte *) bootArguments, (byte *) &bootArguments->BootArgumentsCrc32 - (byte *) bootArguments);
412:
1.1.1.3 root 413: while (true)
1.1 root 414: {
1.1.1.3 root 415: // Execute boot sector of the active partition
1.1.1.5 root 416: if (ReadSectors (SectorBuffer, ActivePartition.Drive, ActivePartition.StartSector, 1) == BiosResultSuccess)
1.1.1.3 root 417: {
1.1.1.6 root 418: if (*(uint16 *) (SectorBuffer + 510) != 0xaa55)
419: {
420: PrintError (TC_BOOT_STR_NO_BOOT_PARTITION);
421: GetKeyboardChar();
422: }
423:
1.1.1.5 root 424: ExecuteBootSector (ActivePartition.Drive, SectorBuffer);
1.1.1.3 root 425: }
426:
427: GetKeyboardChar();
1.1 root 428: }
429:
430: err:
1.1.1.3 root 431: if (BootCryptoInfo)
432: {
433: crypto_close (BootCryptoInfo);
434: BootCryptoInfo = NULL;
435: }
436:
1.1.1.5 root 437: EncryptedVirtualPartition.Drive = TC_INVALID_BIOS_DRIVE;
438: EraseMemory ((void *) TC_BOOT_LOADER_ARGS_OFFSET, sizeof (BootArguments));
1.1.1.2 root 439:
1.1 root 440: byte scanCode;
441: GetKeyboardChar (&scanCode);
442: return scanCode;
443: }
444:
445:
446: static void BootMenu ()
447: {
448: BiosResult result;
449: Partition partitions[16];
450: Partition bootablePartitions[9];
451: size_t partitionCount;
452: size_t bootablePartitionCount = 0;
453:
454: for (byte drive = TC_FIRST_BIOS_DRIVE; drive <= TC_LAST_BIOS_DRIVE; ++drive)
455: {
1.1.1.5 root 456: if (GetDrivePartitions (drive, partitions, array_capacity (partitions), partitionCount, false, nullptr, true) == BiosResultSuccess)
1.1 root 457: {
458: for (size_t i = 0; i < partitionCount; ++i)
459: {
460: const Partition &partition = partitions[i];
1.1.1.3 root 461: result = ReadSectors (SectorBuffer, drive, partition.StartSector, 1);
1.1 root 462:
1.1.1.3 root 463: if (result == BiosResultSuccess && *(uint16 *) (SectorBuffer + TC_LB_SIZE - 2) == 0xaa55)
1.1 root 464: {
465: // Windows writes boot loader on all NTFS/FAT filesytems it creates and, therefore,
466: // NTFS/FAT partitions must have the boot indicator set to be considered bootable.
467: if (!partition.Active
1.1.1.3 root 468: && (*(uint32 *) (SectorBuffer + 3) == 0x5346544e // 'NTFS'
1.1.1.8 root 469: || *(uint32 *) (SectorBuffer + 3) == 0x41465845 && SectorBuffer[7] == 'T' // 'exFAT'
1.1.1.3 root 470: || *(uint16 *) (SectorBuffer + 54) == 0x4146 && SectorBuffer[56] == 'T' // 'FAT'
471: || *(uint16 *) (SectorBuffer + 82) == 0x4146 && SectorBuffer[84] == 'T'))
1.1 root 472: {
473: continue;
474: }
475:
476: // Bootable sector found
477: if (bootablePartitionCount < array_capacity (bootablePartitions))
478: bootablePartitions[bootablePartitionCount++] = partition;
479: }
480: }
481: }
482: }
483:
484: if (bootablePartitionCount < 1)
485: {
1.1.1.6 root 486: PrintError (TC_BOOT_STR_NO_BOOT_PARTITION);
1.1 root 487: GetKeyboardChar();
488: return;
489: }
490:
491: char partChar;
492: while (true)
493: {
494: InitScreen();
495: Print ("Bootable Partitions:\r\n");
496: PrintRepeatedChar ('\xC4', 20);
497: Print ("\r\n");
498:
499: for (size_t i = 0; i < bootablePartitionCount; ++i)
500: {
501: const Partition &partition = bootablePartitions[i];
502: Print ("["); Print (i + 1); Print ("] ");
503: Print ("Drive: "); Print (partition.Drive - TC_FIRST_BIOS_DRIVE);
504: Print (", Partition: "); Print (partition.Number + 1);
1.1.1.5 root 505: Print (", Size: "); PrintSectorCountInMB (partition.SectorCount); PrintEndl();
1.1 root 506: }
507:
508: if (bootablePartitionCount == 1)
509: {
510: // There's only one bootable partition so we'll boot it directly instead of showing boot manager
511: partChar = '1';
512: }
513: else
514: {
515: Print ("[Esc] Cancel\r\n\r\n");
516: Print ("Press 1-9 to select partition: ");
517:
518: if (GetString (&partChar, 1) == 0)
519: return;
520:
521: PrintEndl();
522:
523: if (partChar < '1' || partChar > '0' + bootablePartitionCount)
524: {
525: Beep();
526: continue;
527: }
528: }
529:
530: const Partition &partition = bootablePartitions[partChar - '0' - 1];
531:
1.1.1.3 root 532: if (ReadSectors (SectorBuffer, partition.Drive, partition.StartSector, 1) == BiosResultSuccess)
1.1 root 533: {
1.1.1.3 root 534: ExecuteBootSector (partition.Drive, SectorBuffer);
1.1 root 535: }
536: }
537: }
538:
539:
1.1.1.5 root 540: #ifndef TC_WINDOWS_BOOT_RESCUE_DISK_MODE
541:
542: static bool CopyActivePartitionToHiddenVolume (byte drive, byte &exitKey)
543: {
544: bool status = false;
545:
546: uint64 sectorsRemaining;
547: uint64 sectorOffset;
548: sectorOffset.LowPart = 0;
549: sectorOffset.HighPart = 0;
550:
551: int fragmentSectorCount = 0x7f; // Maximum safe value supported by BIOS
552: int statCount;
553:
554: if (!CheckMemoryRequirements ())
555: goto err;
556:
557: if (!GetActiveAndFollowingPartition (drive))
558: goto err;
559:
560: if (PartitionFollowingActive.Drive == TC_INVALID_BIOS_DRIVE)
1.1.1.6 root 561: TC_THROW_FATAL_EXCEPTION;
562:
563: // Check if BIOS can read the last sector of the hidden system
564: AcquireSectorBuffer();
565:
566: if (ReadSectors (SectorBuffer, PartitionFollowingActive.Drive, PartitionFollowingActive.EndSector - (TC_VOLUME_HEADER_GROUP_SIZE / TC_LB_SIZE - 2), 1) != BiosResultSuccess
1.1.1.8 root 567: || GetCrc32 (SectorBuffer, sizeof (SectorBuffer)) != OuterVolumeBackupHeaderCrc)
1.1.1.5 root 568: {
1.1.1.8 root 569: if (!IsLbaSupported (PartitionFollowingActive.Drive))
570: Print ("BIOS: LBA N/A\r\n");
571:
1.1.1.6 root 572: PrintError ("Your BIOS does not support large drives");
573: Print (TC_BOOT_STR_UPGRADE_BIOS);
574:
575: ReleaseSectorBuffer();
1.1.1.5 root 576: goto err;
577: }
578:
1.1.1.6 root 579: ReleaseSectorBuffer();
580:
1.1.1.5 root 581: if (!MountVolume (drive, exitKey, true, false))
582: return false;
583:
584: sectorsRemaining = EncryptedVirtualPartition.SectorCount;
585:
586: if (!(sectorsRemaining == ActivePartition.SectorCount))
1.1.1.7 root 587: TC_THROW_FATAL_EXCEPTION;
1.1.1.5 root 588:
589: InitScreen();
590: Print ("\r\nCopying system to hidden volume. To abort, press Esc.\r\n\r\n");
591:
592: while (sectorsRemaining.HighPart != 0 || sectorsRemaining.LowPart != 0)
593: {
594: if (EscKeyPressed())
595: {
596: Print ("\rIf aborted, copying will have to start from the beginning (if attempted again).\r\n");
597: if (AskYesNo ("Abort"))
598: break;
599: }
600:
601: if (sectorsRemaining.HighPart == 0 && sectorsRemaining.LowPart < fragmentSectorCount)
602: fragmentSectorCount = sectorsRemaining.LowPart;
603:
604: if (ReadWriteSectors (false, TC_BOOT_LOADER_BUFFER_SEGMENT, 0, drive, ActivePartition.StartSector + sectorOffset, fragmentSectorCount, false) != BiosResultSuccess)
1.1.1.7 root 605: {
606: Print ("To fix bad sectors: 1) Terminate 2) Encrypt and decrypt sys partition 3) Retry\r\n");
607: crypto_close (BootCryptoInfo);
608: goto err;
609: }
1.1.1.5 root 610:
611: AcquireSectorBuffer();
612:
613: for (int i = 0; i < fragmentSectorCount; ++i)
614: {
615: CopyMemory (TC_BOOT_LOADER_BUFFER_SEGMENT, i * TC_LB_SIZE, SectorBuffer, TC_LB_SIZE);
616:
617: uint64 s = HiddenVolumeStartUnitNo + sectorOffset + i;
618: EncryptDataUnits (SectorBuffer, &s, 1, BootCryptoInfo);
619:
620: CopyMemory (SectorBuffer, TC_BOOT_LOADER_BUFFER_SEGMENT, i * TC_LB_SIZE, TC_LB_SIZE);
621: }
622:
623: ReleaseSectorBuffer();
624:
625: if (ReadWriteSectors (true, TC_BOOT_LOADER_BUFFER_SEGMENT, 0, drive, HiddenVolumeStartSector + sectorOffset, fragmentSectorCount, false) != BiosResultSuccess)
1.1.1.7 root 626: {
627: crypto_close (BootCryptoInfo);
628: goto err;
629: }
1.1.1.5 root 630:
631: sectorsRemaining = sectorsRemaining - fragmentSectorCount;
632: sectorOffset = sectorOffset + fragmentSectorCount;
633:
634: if (!(statCount++ & 0xf))
635: {
636: Print ("\rRemaining: ");
637: PrintSectorCountInMB (sectorsRemaining);
638: }
639: }
640:
641: crypto_close (BootCryptoInfo);
642:
643: if (sectorsRemaining.HighPart == 0 && sectorsRemaining.LowPart == 0)
644: {
645: status = true;
646: Print ("\rCopying completed.");
647: }
648:
649: PrintEndl (2);
650: goto ret;
651:
652: err:
653: exitKey = TC_BIOS_KEY_ESC;
654: GetKeyboardChar();
655:
656: ret:
657: EraseMemory ((void *) TC_BOOT_LOADER_ARGS_OFFSET, sizeof (BootArguments));
658: return status;
659: }
660:
661:
662: #else // TC_WINDOWS_BOOT_RESCUE_DISK_MODE
663:
664:
1.1 root 665: static void DecryptDrive (byte drive)
666: {
667: byte exitKey;
1.1.1.5 root 668: if (!MountVolume (drive, exitKey, false, true))
1.1 root 669: return;
670:
1.1.1.5 root 671: BootArguments *bootArguments = (BootArguments *) TC_BOOT_LOADER_ARGS_OFFSET;
1.1 root 672:
673: bool headerUpdateRequired = false;
674: uint64 sectorsRemaining = EncryptedVirtualPartition.EndSector + 1 - EncryptedVirtualPartition.StartSector;
675: uint64 sector = EncryptedVirtualPartition.EndSector + 1;
676:
1.1.1.5 root 677: int fragmentSectorCount = 0x7f; // Maximum safe value supported by BIOS
1.1 root 678: int statCount;
679:
1.1.1.5 root 680: bool skipBadSectors = false;
681:
1.1.1.6 root 682: Print ("\r\nUse only if Windows cannot start. Decryption under Windows is much faster\r\n"
683: "(in TrueCrypt, select 'System' > 'Permanently Decrypt').\r\n\r\n");
1.1.1.5 root 684:
685: if (!AskYesNo ("Decrypt now"))
686: {
687: crypto_close (BootCryptoInfo);
688: goto ret;
689: }
690:
691: if (EncryptedVirtualPartition.Drive == TC_INVALID_BIOS_DRIVE)
1.1 root 692: {
1.1.1.3 root 693: // Drive already decrypted
1.1 root 694: sectorsRemaining.HighPart = 0;
695: sectorsRemaining.LowPart = 0;
696: }
697: else
698: {
1.1.1.3 root 699: Print ("\r\nTo safely interrupt and defer decryption, press Esc.\r\n"
700: "WARNING: You can turn off power only after you press Esc.\r\n\r\n");
1.1 root 701: }
702:
703: while (sectorsRemaining.HighPart != 0 || sectorsRemaining.LowPart != 0)
704: {
1.1.1.5 root 705: if (EscKeyPressed())
706: break;
1.1 root 707:
708: if (sectorsRemaining.HighPart == 0 && sectorsRemaining.LowPart < fragmentSectorCount)
709: fragmentSectorCount = sectorsRemaining.LowPart;
710:
711: sector = sector - fragmentSectorCount;
712:
713: if (!(statCount++ & 0xf))
714: {
715: Print ("\rRemaining: ");
1.1.1.5 root 716: PrintSectorCountInMB (sectorsRemaining);
1.1 root 717: }
718:
1.1.1.5 root 719: if (ReadWriteSectors (false, TC_BOOT_LOADER_BUFFER_SEGMENT, 0, drive, sector, fragmentSectorCount, skipBadSectors) == BiosResultSuccess)
1.1 root 720: {
1.1.1.5 root 721: AcquireSectorBuffer();
1.1 root 722:
1.1.1.5 root 723: for (int i = 0; i < fragmentSectorCount; ++i)
724: {
725: CopyMemory (TC_BOOT_LOADER_BUFFER_SEGMENT, i * TC_LB_SIZE, SectorBuffer, TC_LB_SIZE);
1.1 root 726:
1.1.1.5 root 727: uint64 s = sector + i;
728: DecryptDataUnits (SectorBuffer, &s, 1, BootCryptoInfo);
1.1 root 729:
1.1.1.5 root 730: CopyMemory (SectorBuffer, TC_BOOT_LOADER_BUFFER_SEGMENT, i * TC_LB_SIZE, TC_LB_SIZE);
731: }
1.1.1.3 root 732:
1.1.1.5 root 733: ReleaseSectorBuffer();
734:
735: if (ReadWriteSectors (true, TC_BOOT_LOADER_BUFFER_SEGMENT, 0, drive, sector, fragmentSectorCount, skipBadSectors) != BiosResultSuccess && !skipBadSectors)
736: goto askBadSectorSkip;
737: }
738: else if (!skipBadSectors)
739: goto askBadSectorSkip;
1.1 root 740:
741: sectorsRemaining = sectorsRemaining - fragmentSectorCount;
742: headerUpdateRequired = true;
1.1.1.5 root 743: continue;
744:
745: askBadSectorSkip:
746: if (!AskYesNo ("Skip all bad sectors"))
747: break;
748:
749: skipBadSectors = true;
750: sector = sector + fragmentSectorCount;
751: fragmentSectorCount = 1;
1.1 root 752: }
753:
754: crypto_close (BootCryptoInfo);
755:
756: if (headerUpdateRequired)
757: {
1.1.1.3 root 758: AcquireSectorBuffer();
1.1 root 759: uint64 headerSector;
760: headerSector.HighPart = 0;
761: headerSector.LowPart = TC_BOOT_VOLUME_HEADER_SECTOR;
762:
1.1.1.3 root 763: // Update encrypted area size in volume header
1.1 root 764:
1.1.1.3 root 765: CRYPTO_INFO *headerCryptoInfo = crypto_open();
1.1.1.5 root 766: while (ReadSectors (SectorBuffer, drive, headerSector, 1) != BiosResultSuccess);
1.1 root 767:
1.1.1.6 root 768: if (ReadVolumeHeader (TRUE, (char *) SectorBuffer, &bootArguments->BootPassword, NULL, headerCryptoInfo) == 0)
1.1.1.3 root 769: {
770: DecryptBuffer (SectorBuffer + HEADER_ENCRYPTED_DATA_OFFSET, HEADER_ENCRYPTED_DATA_SIZE, headerCryptoInfo);
1.1 root 771:
1.1.1.3 root 772: uint64 encryptedAreaLength = sectorsRemaining << TC_LB_SIZE_BIT_SHIFT_DIVISOR;
1.1 root 773:
1.1.1.3 root 774: for (int i = 7; i >= 0; --i)
775: {
1.1.1.5 root 776: SectorBuffer[TC_HEADER_OFFSET_ENCRYPTED_AREA_LENGTH + i] = (byte) encryptedAreaLength.LowPart;
1.1.1.3 root 777: encryptedAreaLength = encryptedAreaLength >> 8;
1.1 root 778: }
779:
1.1.1.5 root 780: uint32 headerCrc32 = GetCrc32 (SectorBuffer + TC_HEADER_OFFSET_MAGIC, TC_HEADER_OFFSET_HEADER_CRC - TC_HEADER_OFFSET_MAGIC);
781:
782: for (i = 3; i >= 0; --i)
783: {
784: SectorBuffer[TC_HEADER_OFFSET_HEADER_CRC + i] = (byte) headerCrc32;
785: headerCrc32 >>= 8;
786: }
787:
1.1.1.3 root 788: EncryptBuffer (SectorBuffer + HEADER_ENCRYPTED_DATA_OFFSET, HEADER_ENCRYPTED_DATA_SIZE, headerCryptoInfo);
1.1 root 789: }
790:
1.1.1.3 root 791: crypto_close (headerCryptoInfo);
792:
1.1.1.5 root 793: while (WriteSectors (SectorBuffer, drive, headerSector, 1) != BiosResultSuccess);
1.1.1.3 root 794: ReleaseSectorBuffer();
1.1 root 795: }
796:
1.1.1.3 root 797: if (sectorsRemaining.HighPart == 0 && sectorsRemaining.LowPart == 0)
798: Print ("\rDrive decrypted.\r\n");
799: else
800: Print ("\r\nDecryption deferred.\r\n");
801:
1.1 root 802: GetKeyboardChar();
1.1.1.5 root 803: ret:
804: EraseMemory (bootArguments, sizeof (*bootArguments));
1.1 root 805: }
806:
807:
808: static void RepairMenu ()
809: {
810: DriveGeometry bootLoaderDriveGeometry;
1.1.1.6 root 811:
812: if (GetDriveGeometry (BootLoaderDrive, bootLoaderDriveGeometry, true) != BiosResultSuccess)
1.1 root 813: {
1.1.1.6 root 814: // Some BIOSes may fail to get the geometry of an emulated floppy drive
815: bootLoaderDriveGeometry.Cylinders = 80;
816: bootLoaderDriveGeometry.Heads = 2;
817: bootLoaderDriveGeometry.Sectors = 18;
1.1 root 818: }
819:
820: while (true)
821: {
822: InitScreen();
823: Print ("Available "); Print ("Repair Options"); Print (":\r\n");
824: PrintRepeatedChar ('\xC4', 25);
1.1.1.5 root 825: PrintEndl();
1.1 root 826:
827: enum
828: {
829: RestoreNone = 0,
830: DecryptVolume,
831: RestoreTrueCryptLoader,
832: RestoreVolumeHeader,
833: RestoreOriginalSystemLoader
834: };
835:
836: static const char *options[] = { "Permanently decrypt system partition/drive", "Restore TrueCrypt Boot Loader", "Restore key data (volume header)", "Restore original system loader" };
837:
1.1.1.5 root 838: int selection = AskSelection (options,
839: (BootSectorFlags & TC_BOOT_CFG_FLAG_RESCUE_DISK_ORIG_SYS_LOADER) ? array_capacity (options) : array_capacity (options) - 1);
1.1 root 840:
841: PrintEndl();
842:
1.1.1.2 root 843: switch (selection)
1.1 root 844: {
1.1.1.2 root 845: case RestoreNone:
846: return;
847:
848: case DecryptVolume:
1.1.1.5 root 849: DecryptDrive (BootDrive);
1.1.1.2 root 850: continue;
851:
852: case RestoreOriginalSystemLoader:
1.1.1.6 root 853: if (!AskYesNo ("Is the system partition/drive decrypted"))
1.1.1.3 root 854: {
855: Print ("Please decrypt it first.\r\n");
856: GetKeyboardChar();
1.1.1.2 root 857: continue;
1.1.1.3 root 858: }
1.1.1.4 root 859: break;
1.1 root 860: }
861:
862: bool writeConfirmed = false;
863: BiosResult result;
864:
865: uint64 sector;
866: sector.HighPart = 0;
867: ChsAddress chs;
868:
1.1.1.3 root 869: byte mbrPartTable[TC_LB_SIZE - TC_MAX_MBR_BOOT_CODE_SIZE];
870: AcquireSectorBuffer();
871:
1.1 root 872: for (int i = (selection == RestoreVolumeHeader ? TC_BOOT_VOLUME_HEADER_SECTOR : TC_MBR_SECTOR);
873: i < TC_BOOT_LOADER_AREA_SECTOR_COUNT; ++i)
874: {
1.1.1.5 root 875: sector.LowPart = i;
876:
877: if (selection == RestoreOriginalSystemLoader)
878: sector.LowPart += TC_ORIG_BOOT_LOADER_BACKUP_SECTOR;
879: else if (selection == RestoreTrueCryptLoader)
880: sector.LowPart += TC_BOOT_LOADER_BACKUP_RESCUE_DISK_SECTOR;
1.1 root 881:
882: // The backup medium may be a floppy-emulated bootable CD. The emulation may fail if LBA addressing is used.
883: // Therefore, only CHS addressing can be used.
884: LbaToChs (bootLoaderDriveGeometry, sector, chs);
885: sector.LowPart = i;
886:
887: if (i == TC_MBR_SECTOR)
888: {
1.1.1.3 root 889: // Read current partition table
890: result = ReadSectors (SectorBuffer, TC_FIRST_BIOS_DRIVE, sector, 1);
1.1 root 891: if (result != BiosResultSuccess)
892: goto err;
893:
1.1.1.3 root 894: memcpy (mbrPartTable, SectorBuffer + TC_MAX_MBR_BOOT_CODE_SIZE, sizeof (mbrPartTable));
895: }
896:
897: result = ReadSectors (SectorBuffer, BootLoaderDrive, chs, 1);
898: if (result != BiosResultSuccess)
899: goto err;
900:
901: if (i == TC_MBR_SECTOR)
902: {
903: // Preserve current partition table
904: memcpy (SectorBuffer + TC_MAX_MBR_BOOT_CODE_SIZE, mbrPartTable, sizeof (mbrPartTable));
1.1 root 905: }
906:
907: // Volume header
908: if (i == TC_BOOT_VOLUME_HEADER_SECTOR)
909: {
910: if (selection == RestoreTrueCryptLoader)
911: continue;
912:
913: if (selection == RestoreVolumeHeader)
914: {
915: while (true)
916: {
917: Password password;
918: byte exitKey = AskPassword (password);
919:
920: if (exitKey != TC_BIOS_KEY_ENTER)
921: goto abort;
922:
923: CRYPTO_INFO *cryptoInfo;
924:
1.1.1.3 root 925: CopyMemory (SectorBuffer, TC_BOOT_LOADER_BUFFER_SEGMENT, 0, TC_LB_SIZE);
926: ReleaseSectorBuffer();
927:
1.1 root 928: // Restore volume header only if the current one cannot be used
1.1.1.5 root 929: if (OpenVolume (TC_FIRST_BIOS_DRIVE, password, &cryptoInfo, nullptr, false, true))
1.1 root 930: {
931: Print ("Original header preserved.\r\n");
932: crypto_close (cryptoInfo);
933: goto err;
934: }
935:
1.1.1.3 root 936: AcquireSectorBuffer();
937: CopyMemory (TC_BOOT_LOADER_BUFFER_SEGMENT, 0, SectorBuffer, TC_LB_SIZE);
938:
1.1.1.6 root 939: if (ReadVolumeHeader (TRUE, (char *) SectorBuffer, &password, &cryptoInfo, nullptr) == 0)
1.1 root 940: {
941: crypto_close (cryptoInfo);
942: break;
943: }
944:
1.1.1.4 root 945: Print ("Incorrect password.\r\n\r\n");
1.1 root 946: }
947: }
948: }
949:
1.1.1.3 root 950: if (!writeConfirmed && !AskYesNo ("Modify drive 0"))
1.1 root 951: goto abort;
952: writeConfirmed = true;
953:
1.1.1.3 root 954: if (WriteSectors (SectorBuffer, TC_FIRST_BIOS_DRIVE, sector, 1) != BiosResultSuccess)
1.1 root 955: goto err;
956: }
957: done:
958: switch (selection)
959: {
960: case RestoreTrueCryptLoader:
961: Print ("TrueCrypt Boot Loader");
962: break;
963:
964: case RestoreVolumeHeader:
965: Print ("Header");
966: break;
967:
968: case RestoreOriginalSystemLoader:
969: Print ("System loader");
970: break;
971: }
972: Print (" restored.\r\n");
973:
974: err: GetKeyboardChar();
1.1.1.3 root 975: abort: ReleaseSectorBuffer();
1.1 root 976: }
977: }
978:
1.1.1.5 root 979: #endif // TC_WINDOWS_BOOT_RESCUE_DISK_MODE
980:
1.1 root 981:
982: #ifndef DEBUG
983: extern "C" void _acrtused () { } // Required by linker
984: #endif
985:
986:
987: void main ()
988: {
989: __asm mov BootLoaderDrive, dl
990: __asm mov BootSectorFlags, dh
991:
1.1.1.3 root 992: #ifdef TC_BOOT_TRACING_ENABLED
1.1 root 993: InitDebugPort();
994: #endif
995:
1.1.1.3 root 996: #ifdef TC_BOOT_STACK_CHECKING_ENABLED
997: InitStackChecker();
998: #endif
999:
1.1.1.6 root 1000: #ifndef TC_WINDOWS_BOOT_RESCUE_DISK_MODE
1001: ReadBootSectorUserConfiguration();
1002: #endif
1003:
1.1.1.5 root 1004: InitVideoMode();
1005: InitScreen();
1006:
1007: // Determine boot drive
1.1 root 1008: BootDrive = BootLoaderDrive;
1009: if (BootDrive < TC_FIRST_BIOS_DRIVE)
1010: BootDrive = TC_FIRST_BIOS_DRIVE;
1011:
1.1.1.5 root 1012: // Query boot drive geometry
1.1 root 1013: if (GetDriveGeometry (BootDrive, BootDriveGeometry, true) != BiosResultSuccess)
1014: {
1015: BootDrive = TC_FIRST_BIOS_DRIVE;
1016: if (GetDriveGeometry (BootDrive, BootDriveGeometry) == BiosResultSuccess)
1017: BootDriveGeometryValid = TRUE;
1018: }
1019: else
1020: BootDriveGeometryValid = TRUE;
1021:
1.1.1.5 root 1022:
1023: #ifdef TC_WINDOWS_BOOT_RESCUE_DISK_MODE
1024:
1025: // Check whether the user is not using the Rescue Disk to create a hidden system
1026:
1027: if (ReadWriteMBR (false, BootDrive, true) == BiosResultSuccess
1028: && *(uint32 *) (SectorBuffer + 6) == 0x65757254
1029: && *(uint32 *) (SectorBuffer + 10) == 0x70797243
1030: && (SectorBuffer[TC_BOOT_SECTOR_CONFIG_OFFSET] & TC_BOOT_CFG_MASK_HIDDEN_OS_CREATION_PHASE) != TC_HIDDEN_OS_CREATION_PHASE_NONE)
1031: {
1032: PrintError ("It appears you are creating a hidden OS.");
1033: if (AskYesNo ("Is this correct"))
1034: {
1035: Print ("Please remove the Rescue Disk from the drive and restart.");
1036: while (true);
1037: }
1038: }
1039:
1040: #endif // TC_WINDOWS_BOOT_RESCUE_DISK_MODE
1041:
1042:
1043: // Main menu
1044:
1.1 root 1045: while (true)
1046: {
1.1.1.5 root 1047: byte exitKey;
1.1 root 1048: InitScreen();
1049:
1.1.1.5 root 1050: #ifndef TC_WINDOWS_BOOT_RESCUE_DISK_MODE
1051:
1052: // Hidden system setup
1053: byte hiddenSystemCreationPhase = BootSectorFlags & TC_BOOT_CFG_MASK_HIDDEN_OS_CREATION_PHASE;
1054:
1055: if (hiddenSystemCreationPhase != TC_HIDDEN_OS_CREATION_PHASE_NONE)
1056: {
1.1.1.6 root 1057: PreventNormalSystemBoot = true;
1.1.1.5 root 1058: PrintMainMenu();
1059:
1060: if (hiddenSystemCreationPhase == TC_HIDDEN_OS_CREATION_PHASE_CLONING)
1061: {
1062: if (CopyActivePartitionToHiddenVolume (BootDrive, exitKey))
1063: {
1.1.1.6 root 1064: BootSectorFlags = (BootSectorFlags & ~TC_BOOT_CFG_MASK_HIDDEN_OS_CREATION_PHASE) | TC_HIDDEN_OS_CREATION_PHASE_WIPING;
1.1.1.5 root 1065: UpdateBootSectorConfiguration (BootLoaderDrive);
1066: }
1067: else if (exitKey == TC_BIOS_KEY_ESC)
1068: goto bootMenu;
1069: else
1070: continue;
1071: }
1072: }
1073: else
1074: PrintMainMenu();
1075:
1076: exitKey = BootEncryptedDrive();
1077:
1078: #else // TC_WINDOWS_BOOT_RESCUE_DISK_MODE
1.1 root 1079:
1.1.1.5 root 1080: PrintMainMenu();
1081: exitKey = BootEncryptedDrive();
1082:
1.1 root 1083: if (exitKey == TC_MENU_KEY_REPAIR)
1084: {
1085: RepairMenu();
1086: continue;
1087: }
1088:
1.1.1.5 root 1089: #endif // TC_WINDOWS_BOOT_RESCUE_DISK_MODE
1090:
1091: bootMenu:
1.1.1.6 root 1092: if (!PreventBootMenu)
1093: BootMenu();
1.1 root 1094: }
1095: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.