![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to volumes.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [truecrypt] / truecrypt / common|
Return to volumes.c CVS log | Up to [truecrypt] / truecrypt / common |
1.1.1.3 root 1: /* The source code contained in this file has been derived from the source code
2: of Encryption for the Masses 2.02a by Paul Le Roux. Modifications and
3: additions to that source code contained in this file are Copyright (c) 2004
1.1.1.4 ! root 4: TrueCrypt Foundation and Copyright (c) 2004 TrueCrypt Team. Unmodified
1.1.1.3 root 5: parts are Copyright (c) 1998-99 Paul Le Roux. This is a TrueCrypt Foundation
6: release. Please see the file license.txt for full license details. */
1.1 root 7:
8: #include "TCdefs.h"
9:
10: #include <fcntl.h>
11: #include <sys/types.h>
12: #include <sys/stat.h>
13: #include <io.h>
14: #include <time.h>
15:
16: #include "crypto.h"
17: #include "random.h"
18: #include "endian.h"
19: #include "fat.h"
20: #include "volumes.h"
21:
1.1.1.4 ! root 22: #include "Aes.h"
1.1 root 23: #include "pkcs5.h"
24: #include "crc.h"
25:
26:
1.1.1.4 ! root 27: /* When FALSE, hidden volumes will not be attempted to mount. This variable could be used in future.
! 28: Should a large number of new ciphers be implemented, setting this to FALSE (via program prefs) might
! 29: speed mounting up. */
! 30: BOOL mountingHiddenVolumesAllowed = TRUE;
1.1 root 31:
32:
33: // Volume header structure:
34: //
35: // Offset Length Description
36: // ------------------------------------------
37: // Unencrypted:
38: // 0 64 Key salt
39: // Encrypted:
1.1.1.4 ! root 40: // 64 4 ASCII string 'TRUE'
1.1 root 41: // 68 2 Header version
42: // 70 2 Required program version
43: // 72 4 CRC32 of disk IV and key
44: // 76 8 Volume creation time
45: // 84 8 Header creation time
1.1.1.4 ! root 46: // 92 8 Size of hidden volume in bytes (0 = normal volume)
! 47: // 100 156 Unused
1.1 root 48: // 256 32 Disk IV
49: // 288 224 Disk key
50:
51: int
1.1.1.4 ! root 52: VolumeReadHeader (char *encryptedHeader, char *encryptedHeaderHiddenVol, char *lpszPassword, PCRYPTO_INFO *retInfo)
1.1 root 53: {
54: char header[SECTOR_SIZE];
55: unsigned char *input = (unsigned char *) header;
56: KEY_INFO keyInfo;
1.1.1.4 ! root 57: KEY_INFO keyInfoHiddenVol;
1.1 root 58: PCRYPTO_INFO cryptoInfo;
59: int nStatus = 0, nKeyLen;
60: char dk[DISKKEY_SIZE];
1.1.1.4 ! root 61: char dkHiddenVol[DISKKEY_SIZE];
1.1 root 62: int pkcs5;
63: int headerVersion, requiredVersion;
1.1.1.4 ! root 64: int volType, lastVolType = NORMAL_VOLUME;
1.1 root 65:
66: cryptoInfo = *retInfo = crypto_open ();
67: if (cryptoInfo == NULL)
68: return ERR_OUTOFMEMORY;
69:
70: crypto_loadkey (&keyInfo, lpszPassword, strlen (lpszPassword));
71:
72: // PKCS5 is used to derive header key and IV from user password
73: memcpy (keyInfo.key_salt, encryptedHeader + HEADER_USERKEY_SALT, USERKEY_SALT_SIZE);
1.1.1.4 ! root 74:
! 75: if (mountingHiddenVolumesAllowed && encryptedHeaderHiddenVol != 0)
! 76: {
! 77: // Salt for a possible hidden volume
! 78: memcpy (keyInfoHiddenVol.key_salt, encryptedHeaderHiddenVol + HEADER_USERKEY_SALT, USERKEY_SALT_SIZE);
! 79: lastVolType = HIDDEN_VOLUME;
! 80: }
! 81:
1.1 root 82: keyInfo.noIterations = USERKEY_ITERATIONS;
83:
1.1.1.3 root 84: // Test all available PKCS5 PRFs
85: for (pkcs5 = 1; pkcs5 <= LAST_PRF_ID; pkcs5++)
1.1 root 86: {
1.1.1.3 root 87: if (pkcs5 == SHA1)
88: {
89: derive_sha_key (keyInfo.userKey, keyInfo.keyLength, keyInfo.key_salt,
1.1.1.4 ! root 90: USERKEY_SALT_SIZE, keyInfo.noIterations, dk, DISK_IV_SIZE + EAGetLargestKey());
! 91: if (mountingHiddenVolumesAllowed)
! 92: {
! 93: // Derive header for a possible hidden volume (HMAC-SHA-1)
! 94: derive_sha_key (keyInfo.userKey, keyInfo.keyLength, keyInfoHiddenVol.key_salt,
! 95: USERKEY_SALT_SIZE, keyInfo.noIterations, dkHiddenVol, DISK_IV_SIZE + EAGetLargestKey());
! 96: }
! 97: }
! 98: else if (pkcs5 == RIPEMD160)
1.1.1.3 root 99: {
100: derive_rmd160_key (keyInfo.userKey, keyInfo.keyLength, keyInfo.key_salt,
1.1.1.4 ! root 101: USERKEY_SALT_SIZE, keyInfo.noIterations, dk, DISK_IV_SIZE + EAGetLargestKey());
! 102: if (mountingHiddenVolumesAllowed)
! 103: {
! 104: // Derive header for a possible hidden volume (HMAC-RIPEMD-160)
! 105: derive_rmd160_key (keyInfo.userKey, keyInfo.keyLength, keyInfoHiddenVol.key_salt,
! 106: USERKEY_SALT_SIZE, keyInfo.noIterations, dkHiddenVol, DISK_IV_SIZE + EAGetLargestKey());
! 107: }
1.1.1.3 root 108: }
1.1 root 109:
1.1.1.4 ! root 110: // Test all available encryption algorithms
! 111: for (cryptoInfo->ea = EAGetFirst (); cryptoInfo->ea != 0; cryptoInfo->ea = EAGetNext (cryptoInfo->ea))
1.1.1.3 root 112: {
1.1.1.4 ! root 113: // Test all volume types
! 114: for (volType = NORMAL_VOLUME; volType <= lastVolType; volType++)
1.1.1.3 root 115: {
1.1.1.4 ! root 116: // Copy header for decryption and init an encryption algorithm
! 117: if (volType == NORMAL_VOLUME)
! 118: {
! 119: memcpy (header, encryptedHeader, SECTOR_SIZE);
! 120: memcpy (cryptoInfo->iv, dk, DISK_IV_SIZE);
! 121: EAInit (cryptoInfo->ea, dk + DISK_IV_SIZE, cryptoInfo->ks);
! 122: }
! 123: else if (volType == HIDDEN_VOLUME)
! 124: {
! 125: memcpy (header, encryptedHeaderHiddenVol, SECTOR_SIZE);
! 126: memcpy (cryptoInfo->iv, dkHiddenVol, DISK_IV_SIZE);
! 127: EAInit (cryptoInfo->ea, dkHiddenVol + DISK_IV_SIZE, cryptoInfo->ks);
! 128: }
! 129:
! 130: input = header;
! 131:
! 132: // Try to decrypt header
! 133:
! 134: DecryptBuffer ((unsigned long *) (header + HEADER_ENCRYPTEDDATA), HEADER_ENCRYPTEDDATASIZE,
! 135: cryptoInfo->ks, cryptoInfo->iv, &cryptoInfo->iv[8], cryptoInfo->ea);
! 136:
! 137: input += HEADER_ENCRYPTEDDATA;
! 138:
! 139: // Magic
! 140: if (mgetLong (input) != 'TRUE')
! 141: continue;
! 142:
! 143: // Header version
! 144: headerVersion = mgetWord (input);
! 145:
! 146: // Required program version
! 147: requiredVersion = mgetWord (input);
! 148:
! 149: // Check CRC of disk IV and key
! 150: if (mgetLong (input) != crc32 (header + HEADER_DISKKEY, DISKKEY_SIZE))
! 151: continue;
! 152:
! 153: // Now we have the correct password, cipher, hash algorithm, and volume type
! 154:
! 155: // Check the version required to handle this volume
! 156: if (requiredVersion > VERSION_NUM)
! 157: return ERR_NEW_VERSION_REQUIRED;
! 158:
! 159: // Volume creation time
! 160: cryptoInfo->volume_creation_time = mgetInt64 (input);
! 161:
! 162: // Header creation time
! 163: cryptoInfo->header_creation_time = mgetInt64 (input);
! 164:
! 165: // Hidden volume
! 166: cryptoInfo->hiddenVolumeSize = mgetInt64 (input);
! 167:
! 168: if (volType == HIDDEN_VOLUME) // If mounted as a hidden volume
! 169: {
! 170: cryptoInfo->hiddenVolume = TRUE;
! 171: }
! 172: else
! 173: {
! 174: cryptoInfo->hiddenVolume = FALSE;
! 175: cryptoInfo->hiddenVolumeSize = 0;
! 176: }
! 177:
! 178: // Disk key
! 179: nKeyLen = DISKKEY_SIZE;
! 180: memcpy (keyInfo.key, header + HEADER_DISKKEY, nKeyLen);
! 181:
! 182: memcpy (cryptoInfo->master_decrypted_key, keyInfo.key, nKeyLen);
! 183: memcpy (cryptoInfo->key_salt, keyInfo.key_salt, USERKEY_SALT_SIZE);
! 184: cryptoInfo->pkcs5 = pkcs5;
! 185: cryptoInfo->noIterations = keyInfo.noIterations;
! 186:
! 187: // Init the encryption algorithm with the decrypted master key
! 188: EAInit (cryptoInfo->ea, keyInfo.key + DISK_IV_SIZE, cryptoInfo->ks);
! 189:
! 190: // Disk IV
! 191: memcpy (cryptoInfo->iv, keyInfo.key, DISK_IV_SIZE);
! 192:
! 193: // Clear out the temp. key buffers
! 194: burn (dk, sizeof(dk));
! 195: burn (dkHiddenVol, sizeof(dkHiddenVol));
1.1.1.3 root 196:
1.1.1.4 ! root 197: return 0;
! 198: }
1.1.1.2 root 199: }
1.1 root 200: }
201:
202: crypto_close(cryptoInfo);
203: burn (&keyInfo, sizeof (keyInfo));
1.1.1.4 ! root 204: burn (&keyInfoHiddenVol, sizeof (keyInfoHiddenVol));
1.1 root 205: return ERR_PASSWORD_WRONG;
206: }
207:
208: #ifndef DEVICE_DRIVER
209:
210: #ifdef VOLFORMAT
1.1.1.3 root 211: extern BOOL showKeys;
1.1 root 212: extern HWND hDiskKey;
1.1.1.3 root 213: extern HWND hHeaderKey;
1.1 root 214: #endif
215:
216: // VolumeWriteHeader:
217: // Creates volume header in memory
218: int
1.1.1.4 ! root 219: VolumeWriteHeader (char *header, int ea, char *lpszPassword,
! 220: int pkcs5, char *masterKey, unsigned __int64 volumeCreationTime, PCRYPTO_INFO * retInfo,
! 221: unsigned __int64 hiddenVolumeSize)
1.1 root 222: {
223: unsigned char *p = (unsigned char *) header;
224: KEY_INFO keyInfo;
225:
226: int nUserKeyLen = strlen(lpszPassword);
227: PCRYPTO_INFO cryptoInfo = crypto_open ();
228: char dk[DISKKEY_SIZE];
229: int x;
230:
231: if (cryptoInfo == NULL)
232: return ERR_OUTOFMEMORY;
233:
234: memset (header, 0, SECTOR_SIZE);
1.1.1.2 root 235: VirtualLock (&keyInfo, sizeof (keyInfo));
1.1 root 236:
237: //// Encryption setup
238:
1.1.1.2 root 239: // Generate disk key and IV
240: if(masterKey == 0)
241: RandgetBytes (keyInfo.key, DISKKEY_SIZE, TRUE);
242: else
243: memcpy (keyInfo.key, masterKey, DISKKEY_SIZE);
244:
1.1 root 245: // User key
246: memcpy (keyInfo.userKey, lpszPassword, nUserKeyLen);
247: keyInfo.keyLength = nUserKeyLen;
248: keyInfo.noIterations = USERKEY_ITERATIONS;
249:
250: // User selected encryption algorithm
1.1.1.4 ! root 251: cryptoInfo->ea = ea;
1.1 root 252:
253: // Salt for header key derivation
1.1.1.2 root 254: RandgetBytes (keyInfo.key_salt, USERKEY_SALT_SIZE, TRUE);
1.1 root 255:
1.1.1.4 ! root 256: // PKCS5 is used to derive the header key and IV from the password
1.1 root 257: if (pkcs5 == SHA1)
258: {
259: derive_sha_key (keyInfo.userKey, keyInfo.keyLength, keyInfo.key_salt,
1.1.1.4 ! root 260: USERKEY_SALT_SIZE, keyInfo.noIterations, dk, DISK_IV_SIZE + EAGetLargestKey() );
1.1 root 261: }
1.1.1.3 root 262: else if (pkcs5 == RIPEMD160)
263: {
264: derive_rmd160_key (keyInfo.userKey, keyInfo.keyLength, keyInfo.key_salt,
1.1.1.4 ! root 265: USERKEY_SALT_SIZE, keyInfo.noIterations, dk, DISK_IV_SIZE + EAGetLargestKey() );
1.1.1.3 root 266: }
1.1 root 267:
268:
269: //// Header setup
270:
271: // Salt
272: mputBytes (p, keyInfo.key_salt, USERKEY_SALT_SIZE);
273:
274: // Magic
275: mputLong (p, 'TRUE');
276:
277: // Header version
1.1.1.4 ! root 278: mputWord (p, VOLUME_HEADER_VERSION);
1.1 root 279:
280: // Required program version to handle this volume
1.1.1.4 ! root 281: mputWord (p, VOL_REQ_PROG_VERSION);
1.1 root 282:
283: // CRC of disk key
284: x = crc32(keyInfo.key, DISKKEY_SIZE);
285: mputLong (p, x);
286:
287: // Time
288: {
289: SYSTEMTIME st;
290: FILETIME ft;
291:
292: // Volume creation time
293: if (volumeCreationTime == 0)
294: {
295: GetLocalTime (&st);
296: SystemTimeToFileTime (&st, &ft);
297: }
298: else
299: {
300: ft.dwHighDateTime = (DWORD)(volumeCreationTime >> 32);
301: ft.dwLowDateTime = (DWORD)volumeCreationTime;
302: }
303: mputLong (p, ft.dwHighDateTime);
304: mputLong (p, ft.dwLowDateTime);
305:
306: // Password change time
307: GetLocalTime (&st);
308: SystemTimeToFileTime (&st, &ft);
309: mputLong (p, ft.dwHighDateTime);
310: mputLong (p, ft.dwLowDateTime);
311: }
312:
1.1.1.4 ! root 313: // Hidden volume size
! 314: cryptoInfo->hiddenVolumeSize = hiddenVolumeSize;
! 315: mputInt64 (p, cryptoInfo->hiddenVolumeSize);
! 316:
1.1 root 317: // Disk key and IV
318: memcpy (header + HEADER_DISKKEY, keyInfo.key, DISKKEY_SIZE);
319:
320:
321: //// Header encryption
322:
323: memcpy (cryptoInfo->iv, dk, DISK_IV_SIZE);
1.1.1.4 ! root 324: EAInit (cryptoInfo->ea, dk + DISK_IV_SIZE, cryptoInfo->ks);
1.1 root 325:
1.1.1.4 ! root 326: EncryptBuffer ((unsigned long *) (header + HEADER_ENCRYPTEDDATA), HEADER_ENCRYPTEDDATASIZE,
! 327: cryptoInfo->ks, cryptoInfo->iv, &cryptoInfo->iv[8], cryptoInfo->ea);
1.1 root 328:
329:
330: //// cryptoInfo setup for further use (disk format)
331:
332: // Init with master disk key for sector decryption
1.1.1.4 ! root 333: EAInit (cryptoInfo->ea, keyInfo.key + DISK_IV_SIZE, cryptoInfo->ks);
1.1 root 334:
335: // Disk IV
336: memcpy (cryptoInfo->iv, keyInfo.key, DISK_IV_SIZE);
337:
1.1.1.2 root 338:
1.1 root 339: #ifdef VOLFORMAT
1.1.1.3 root 340: if (showKeys)
1.1 root 341: {
342: char tmp[64];
343: BOOL dots3 = FALSE;
344: int i, j;
345:
1.1.1.4 ! root 346: j = EAGetKeySize (ea);
1.1 root 347:
1.1.1.3 root 348: if (j > 14)
1.1 root 349: {
350: dots3 = TRUE;
1.1.1.3 root 351: j = 14;
1.1 root 352: }
353:
354: tmp[0] = 0;
355: for (i = 0; i < j; i++)
356: {
357: char tmp2[8] =
358: {0};
359: sprintf (tmp2, "%02X", (int) (unsigned char) keyInfo.key[i + DISK_IV_SIZE]);
360: strcat (tmp, tmp2);
361: }
362:
363: if (dots3 == TRUE)
364: {
365: strcat (tmp, "...");
366: }
367:
368:
369: SetWindowText (hDiskKey, tmp);
370:
371: tmp[0] = 0;
1.1.1.3 root 372: for (i = 0; i < 14; i++)
1.1 root 373: {
374: char tmp2[8];
1.1.1.3 root 375: sprintf (tmp2, "%02X", (int) (unsigned char) dk[DISK_IV_SIZE + i]);
1.1 root 376: strcat (tmp, tmp2);
377: }
378:
1.1.1.3 root 379: if (dots3 == TRUE)
380: {
381: strcat (tmp, "...");
382: }
383:
384: SetWindowText (hHeaderKey, tmp);
1.1 root 385: }
386: #endif
387:
1.1.1.3 root 388: burn (dk, sizeof(dk));
1.1 root 389: burn (&keyInfo, sizeof (keyInfo));
1.1.1.2 root 390: VirtualUnlock (&keyInfo, sizeof (keyInfo));
1.1 root 391:
392: *retInfo = cryptoInfo;
393: return 0;
394: }
395:
396: #endif /* !NT4_DRIVER */
1.1.1.4 ! root 397:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.