Return to wipe.c CVS log

Up to [truecrypt] / truecrypt / common

Annotation of truecrypt/common/wipe.c, revision 1.1.1.6

1.1       root        1: /*
1.1.1.6 ! root        2:  Copyright (c) 2008-2009 TrueCrypt Developers Association. All rights reserved.
1.1       root        3: 
1.1.1.6 ! root        4:  Governed by the TrueCrypt License 2.8 the full text of which is contained in
        !             5:  the file License.txt included in TrueCrypt binary and source code distribution
        !             6:  packages.
1.1       root        7: */
                      8: 
                      9: #include "Tcdefs.h"
                     10: #include "Wipe.h"
                     11: 
                     12: 
1.1.1.3   root       13: static BOOL Wipe1PseudoRandom (int pass, byte *buffer, size_t size)
                     14: {
                     15:        return FALSE;
                     16: }
                     17: 
                     18: 
1.1       root       19: // Fill buffer with wipe patterns defined in "National Industrial Security Program Operating Manual", US DoD 5220.22-M.
                     20: // Return: FALSE = buffer must be filled with random data
                     21: 
                     22: static BOOL Wipe3Dod5220 (int pass, byte *buffer, size_t size)
                     23: {
                     24:        byte wipeChar;
                     25: 
                     26:        switch (pass)
                     27:        {
                     28:        case 1:
                     29:                wipeChar = 0;
                     30:                break;
                     31: 
                     32:        case 2:
                     33:                wipeChar = 0xff;
                     34:                break;
                     35: 
                     36:        default:
                     37:                return FALSE;
                     38:        }
                     39: 
                     40:        memset (buffer, wipeChar, size);
                     41:        return TRUE;
                     42: }
                     43: 
                     44: 
                     45: static BOOL Wipe7Dod5220 (int pass, byte randChars[TC_WIPE_RAND_CHAR_COUNT], byte *buffer, size_t size)
                     46: {
                     47:        byte wipeChar;
                     48: 
                     49:        switch (pass)
                     50:        {
                     51:        case 1:
                     52:                wipeChar = randChars[0];
                     53:                break;
                     54: 
                     55:        case 2:
                     56:                wipeChar = ~randChars[0];
                     57:                break;
                     58: 
                     59:        case 4:
                     60:                wipeChar = randChars[1];
                     61:                break;
                     62: 
                     63:        case 5:
                     64:                wipeChar = randChars[2];
                     65:                break;
                     66: 
                     67:        case 6:
                     68:                wipeChar = ~randChars[2];
                     69:                break;
                     70: 
                     71:        default:
                     72:                return FALSE;
                     73:        }
                     74: 
                     75:        memset (buffer, wipeChar, size);
                     76:        return TRUE;
                     77: }
                     78: 
                     79: 
                     80: // Fill the buffer with wipe patterns defined in the paper "Secure Deletion of Data from Magnetic and Solid-State Memory" by Peter Gutmann.
                     81: // Return: FALSE = buffer must be filled with random data
                     82: 
                     83: static BOOL Wipe35Gutmann (int pass, byte *buffer, size_t size)
                     84: {
                     85:        byte wipePat3[] = { 0x92, 0x49, 0x24 };
                     86:        int wipePat3Pos;
                     87:        size_t i;
                     88: 
                     89:        switch (pass)
                     90:        {
                     91:        case 5:
                     92:                memset (buffer, 0x55, size);
                     93:                break;
                     94: 
                     95:        case 6:
                     96:                memset (buffer, 0xaa, size);
                     97:                break;
                     98: 
                     99:        case 7:
                    100:        case 26:
                    101:        case 29:
                    102:                wipePat3Pos = 0;
                    103:                goto wipe3;
                    104: 
                    105:        case 8:
                    106:        case 27:
                    107:        case 30:
                    108:                wipePat3Pos = 1;
                    109:                goto wipe3;
                    110: 
                    111:        case 9:
                    112:        case 28:
                    113:        case 31:
                    114:                wipePat3Pos = 2;
                    115:                goto wipe3;
                    116: 
                    117: wipe3:
                    118:                if (pass >= 29)
                    119:                {
                    120:                        wipePat3[0] = ~wipePat3[0];
                    121:                        wipePat3[1] = ~wipePat3[1];
                    122:                        wipePat3[2] = ~wipePat3[2];
                    123:                }
                    124: 
                    125:                for (i = 0; i < size; ++i)
                    126:                {
                    127:                        buffer[i] = wipePat3[wipePat3Pos++ % 3];
                    128:                }
                    129:                break;
                    130: 
                    131:        default:
                    132:                if (pass >= 10 && pass <= 25)
                    133:                        memset (buffer, (pass - 10) * 0x11, size);
                    134:                else
                    135:                        return FALSE;
                    136:        }
                    137: 
                    138:        return TRUE;
                    139: }
                    140: 
                    141: 
1.1.1.5   root      142: int GetWipePassCount (WipeAlgorithmId algorithm)
1.1       root      143: {
                    144:        switch (algorithm)
                    145:        {
1.1.1.3   root      146:        case TC_WIPE_1_RAND:
                    147:                return 1;
                    148: 
1.1       root      149:        case TC_WIPE_3_DOD_5220:
                    150:                return 3;
                    151: 
                    152:        case TC_WIPE_7_DOD_5220:
                    153:                return 7;
                    154: 
                    155:        case TC_WIPE_35_GUTMANN:
                    156:                return 35;
                    157: 
                    158:        default:
                    159:                TC_THROW_FATAL_EXCEPTION;
                    160:        }
1.1.1.3   root      161: 
                    162:        return 0;       // Prevent compiler warnings
1.1       root      163: }
                    164: 
                    165: 
                    166: BOOL WipeBuffer (WipeAlgorithmId algorithm, byte randChars[TC_WIPE_RAND_CHAR_COUNT], int pass, byte *buffer, size_t size)
                    167: {
                    168:        switch (algorithm)
                    169:        {
1.1.1.3   root      170:        case TC_WIPE_1_RAND:
                    171:                return Wipe1PseudoRandom (pass, buffer, size);
                    172: 
1.1       root      173:        case TC_WIPE_3_DOD_5220:
                    174:                return Wipe3Dod5220 (pass, buffer, size);
                    175: 
                    176:        case TC_WIPE_7_DOD_5220:
                    177:                return Wipe7Dod5220 (pass, randChars, buffer, size);
                    178: 
                    179:        case TC_WIPE_35_GUTMANN:
                    180:                return Wipe35Gutmann (pass, buffer, size);
                    181: 
                    182:        default:
                    183:                TC_THROW_FATAL_EXCEPTION;
                    184:        }
1.1.1.3   root      185: 
                    186:        return FALSE;   // Prevent compiler warnings
1.1       root      187: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.