Return to keyfile.cpp CVS log

Up to [truecrypt] / truecrypt / volume

Annotation of truecrypt/volume/keyfile.cpp, revision 1.1.1.1

1.1       root        1: /*
                      2:  Copyright (c) 2008 TrueCrypt Foundation. All rights reserved.
                      3: 
                      4:  Governed by the TrueCrypt License 2.4 the full text of which is contained
                      5:  in the file License.txt included in TrueCrypt binary and source code
                      6:  distribution packages.
                      7: */
                      8: 
                      9: #include "Platform/Serializer.h"
                     10: #include "Crc32.h"
                     11: #include "Keyfile.h"
                     12: 
                     13: namespace TrueCrypt
                     14: {
                     15:        void Keyfile::Apply (const BufferPtr &pool) const
                     16:        {
                     17:                if (Path.IsDirectory())
                     18:                        throw ParameterIncorrect (SRC_POS);
                     19: 
                     20:                File file;
                     21:                file.Open (Path, File::OpenRead, File::ShareRead, File::PreserveTimestamps);
                     22: 
                     23:                Crc32 crc32;
                     24:                size_t poolPos = 0;
                     25:                uint64 totalLength = 0;
                     26:                uint64 readLength;
                     27: 
                     28:                SecureBuffer keyfileBuf (File::GetOptimalReadSize());
                     29: 
                     30:                while ((readLength = file.Read (keyfileBuf)) > 0)
                     31:                {
                     32:                        for (size_t i = 0; i < readLength; i++)
                     33:                        {
                     34:                                uint32 crc = crc32.Process (keyfileBuf[i]);
                     35: 
                     36:                                pool[poolPos++] += (byte) (crc >> 24);
                     37:                                pool[poolPos++] += (byte) (crc >> 16);
                     38:                                pool[poolPos++] += (byte) (crc >> 8);
                     39:                                pool[poolPos++] += (byte) crc;
                     40: 
                     41:                                if (poolPos >= pool.Size())
                     42:                                        poolPos = 0;
                     43: 
                     44:                                if (++totalLength >= MaxProcessedLength)
                     45:                                        goto done;
                     46:                        }
                     47:                }
                     48: done:
                     49:                if (totalLength < MinProcessedLength)
                     50:                        throw InsufficientData (SRC_POS, Path);
                     51:        }
                     52: 
                     53:        shared_ptr <VolumePassword> Keyfile::ApplyListToPassword (shared_ptr <KeyfileList> keyfiles, shared_ptr <VolumePassword> password)
                     54:        {
                     55:                if (!password)
                     56:                        password.reset (new VolumePassword);
                     57: 
                     58:                if (!keyfiles || keyfiles->size() < 1)
                     59:                        return password;
                     60: 
                     61:                KeyfileList keyfilesExp;
                     62: 
                     63:                // Enumerate directories
                     64:                foreach (shared_ptr <Keyfile> keyfile, *keyfiles)
                     65:                {
                     66:                        if (FilesystemPath (*keyfile).GetType() == FilesystemPathType::Directory)
                     67:                        {
                     68:                                foreach_ref (const FilePath &path, Directory::GetFilePaths (*keyfile))
                     69:                                {
                     70:                                        keyfilesExp.push_back (make_shared <Keyfile> (path));
                     71:                                }
                     72:                        }
                     73:                        else
                     74:                        {
                     75:                                keyfilesExp.push_back (keyfile);
                     76:                        }
                     77:                }
                     78: 
                     79:                make_shared_auto (VolumePassword, newPassword);
                     80: 
                     81:                if (keyfilesExp.size() < 1)
                     82:                {
                     83:                        newPassword->Set (*password);
                     84:                }
                     85:                else
                     86:                {
                     87:                        SecureBuffer keyfilePool (VolumePassword::MaxSize);
                     88: 
                     89:                        // Pad password with zeros if shorter than max length
                     90:                        keyfilePool.Zero();
                     91:                        keyfilePool.CopyFrom (ConstBufferPtr (password->DataPtr(), password->Size()));
                     92: 
                     93:                        // Apply all keyfiles
                     94:                        foreach_ref (const Keyfile &k, keyfilesExp)
                     95:                        {
                     96:                                k.Apply (keyfilePool);
                     97:                        }
                     98: 
                     99:                        newPassword->Set (keyfilePool);
                    100:                }
                    101: 
                    102:                return newPassword;
                    103:        }
                    104: 
                    105:        shared_ptr <KeyfileList> Keyfile::DeserializeList (shared_ptr <Stream> stream, const string &name)
                    106:        {
                    107:                shared_ptr <KeyfileList> keyfiles;
                    108:                Serializer sr (stream);
                    109:                
                    110:                if (!sr.DeserializeBool (name + "Null"))
                    111:                {
                    112:                        keyfiles.reset (new KeyfileList);
                    113:                        foreach (const wstring &k, sr.DeserializeWStringList (name))
                    114:                                keyfiles->push_back (make_shared <Keyfile> (k));
                    115:                }
                    116:                return keyfiles;
                    117:        }
                    118: 
                    119:        void Keyfile::SerializeList (shared_ptr <Stream> stream, const string &name, shared_ptr <KeyfileList> keyfiles)
                    120:        {
                    121:                Serializer sr (stream);
                    122:                sr.Serialize (name + "Null", keyfiles == nullptr);
                    123:                if (keyfiles)
                    124:                {
                    125:                        list <wstring> sl;
                    126: 
                    127:                        foreach_ref (const Keyfile &k, *keyfiles)
                    128:                                sl.push_back (FilesystemPath (k));
                    129: 
                    130:                        sr.Serialize (name, sl);
                    131:                }
                    132:        }
                    133: }

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