crypt/file.cc

Go to the documentation of this file.

// $Id: file.cc 3351 2010-09-17 21:55:30Z java $
//
// Copyright (C) 2008-2010  Rafael Ostertag
//
// This file is part of YAPET.
//
// YAPET is free software: you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the Free Software
// Foundation, either version 3 of the License, or (at your option) any later
// version.
//
// YAPET is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
// details.
//
// You should have received a copy of the GNU General Public License along with
// YAPET.  If not, see <http://www.gnu.org/licenses/>.
//
// Additional permission under GNU GPL version 3 section 7
//
// If you modify this program, or any covered work, by linking or combining it
// with the OpenSSL project's OpenSSL library (or a modified version of that
// library), containing parts covered by the terms of the OpenSSL or SSLeay
// licenses, Rafael Ostertag grants you additional permission to convey the
// resulting work.  Corresponding Source for a non-source form of such a
// combination shall include the source code for the parts of OpenSSL used as
// well as that of the covered work.
//

#include "../intl.h"
#include "crypt.h"
#include "record.h"
#include "structs.h"
#include "file.h"

#ifdef TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# ifdef HAVE_SYS_TIME_H
#  include <sys/time.h>
# else
#  include <time.h>
# endif
#endif // TIME_WITH_SYS_TIME

#ifdef HAVE_INTTYPES_H
# include <inttypes.h>
#endif

#ifdef HAVE_SYS_TYPES_H
# include <sys/types.h>
#endif

#ifdef HAVE_SYS_STAT_H
# include <sys/stat.h>
#endif

#ifdef HAVE_FCNTL_H
# include <fcntl.h>
#endif

#ifdef HAVE_STRING_H
# include <string.h>
#endif

#ifdef HAVE_ERRNO_H
# include <errno.h>
#endif

#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif

#ifdef HAVE_ALLOCA_H
# include <alloca.h>
#endif

using namespace YAPET;

const char CONTROL_STR[] = "ABCDEFGHIJKLMNOPQRSTUVW";

const char RECOG_STR[] = "YAPET1.0";

void
File::checkFileSecurity() throw (YAPETException) {
#if defined(HAVE_FSTAT) && defined(HAVE_GETUID)
    struct stat buf;
    int err = fstat (fd, &buf);

    if (err == -1)
        throw YAPETException (strerror (errno) );

    uid_t uid = getuid();

    if (buf.st_uid != uid) {
        std::string tmp (_ ("You are not the owner of ") );
        throw YAPETRetryException (tmp + filename);
    }

    if (buf.st_mode != (S_IFREG | S_IRUSR | S_IWUSR) ) {
        std::string tmp1 (_ ("Permissions of ") );
        std::string tmp2 (_ (" not secure.") );
        throw YAPETRetryException (tmp1 + filename + tmp2);
    }

#endif
}

void
File::setFileSecurity() throw (YAPETException) {
#if defined(HAVE_FCHOWN) && defined(HAVE_FCHMOD) && defined(HAVE_FSTAT)
    struct stat buf;
    int err = fstat (fd, &buf);

    if (err == -1)
        throw YAPETException (strerror (errno) );

    err = fchown (fd, getuid(), buf.st_gid);

    if (err == -1) {
        std::string tmp (_ ("Cannot set the owner of ") );
        throw YAPETRetryException (tmp + filename);
    }

    err = fchmod (fd, S_IRUSR | S_IWUSR);

    if (err == -1) {
        std::string tmp (_ ("Cannot set file permissions on ") );
        throw YAPETRetryException (tmp + filename);
    }

#endif
}


void
File::openCreate() throw (YAPETException) {
    fd = ::open (filename.c_str(),
                 O_RDWR | O_CREAT | O_TRUNC | O_APPEND,
                 (usefsecurity ? S_IRUSR | S_IWUSR :
                  S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH ) );

    if (fd == -1)
        throw YAPETException (strerror (errno) );

    if (usefsecurity)
        checkFileSecurity();
}

void
File::openNoCreate() throw (YAPETException) {
    fd = ::open (filename.c_str(), O_RDWR | O_APPEND);

    if (fd == -1)
        throw YAPETException (strerror (errno) );

    if (usefsecurity)
        checkFileSecurity();
}

int64_t
File::lastModified() const throw (YAPETException) {
    struct stat st_buf;
    int retval = fstat (fd, &st_buf);

    if (retval == -1)
        throw YAPETException (strerror (errno) );

    return st_buf.st_mtime;
}

void
File::seekCurr (off_t offset) const throw (YAPETException) {
    off_t pos = lseek (fd, offset, SEEK_CUR);

    if ( ( (off_t) - 1) == pos)
        throw YAPETException (strerror (errno) );
}

void
File::seekAbs (off_t offset) const throw (YAPETException) {
    off_t pos = lseek (fd, offset, SEEK_SET);

    if ( ( (off_t) - 1) == pos)
        throw YAPETException (strerror (errno) );

    if (pos != offset)
        throw YAPETException (_ ("Error seeking within file: ") + filename);
}

void
File::preparePWSave() throw (YAPETException) {
    BDBuffer* curr_header = readHeader();
    ::close (fd);

    try {
        openCreate();
    } catch (YAPETException& ex) {
        if (curr_header != NULL)
            delete curr_header;

        throw;
    }

    mtime = lastModified();
    writeHeader (*curr_header);
    delete curr_header;
}

void
File::seekDataSection() const throw (YAPETException) {
    seekAbs (strlen (RECOG_STR) );
    uint32_t len;
    int retval = ::read (fd, &len, sizeof (uint32_t) );

    if (retval == -1)
        throw YAPETException (strerror (errno) );

    if ( ( (size_t) retval) != sizeof (uint32_t) )
        throw YAPETException (_ ("Unable to seek to data section") );

    len = int_from_disk<uint32_t> (len);
    seekCurr (len);
}

BDBuffer*
File::read() const throw (YAPETException) {
    uint32_t len;
    int retval = ::read (fd, &len, sizeof (uint32_t) );

    if (retval == -1)
        throw YAPETException (strerror (errno) );

    if (retval == 0)
        return NULL;

    if ( ( (size_t) retval) < sizeof (uint32_t) )
        throw YAPETException (_ ("Short read on file: ") + filename);

    // Convert len to the endianess of the architecture
    len = int_from_disk<uint32_t> (len);
    BDBuffer* buf = new BDBuffer (len);
    retval = ::read (fd, *buf, len);

    if (retval == -1)
        throw YAPETException (strerror (errno) );

    if (retval == 0) {
        delete buf;
        return NULL;
    }

    if ( ( (uint32_t) retval) < len) {
        delete buf;
        throw YAPETException (_ ("Short read on file: ") + filename);
    }

    return buf;
}

void
File::write (const BDBuffer& buff, bool forceappend, bool forcewrite)
throw (YAPETException, YAPETRetryException) {
    if ( (mtime != lastModified() ) && !forcewrite)
        throw YAPETRetryException (_ ("File has been modified") );

    if (forceappend) {
        off_t pos = lseek (fd, 0, SEEK_END);

        if ( ( (off_t) - 1) == pos)
            throw YAPETException (strerror (errno) );
    }

    uint32_t s = buff.size();
    // Convert s to the on-disk structure
    s = int_to_disk<uint32_t> (s);
    int retval = ::write (fd, &s, sizeof (uint32_t) );

    if (retval == -1)
        throw YAPETException (strerror (errno) );

    if (retval != sizeof (uint32_t) )
        throw YAPETException (_ ("Short write on file: ") + filename);

    retval = ::write (fd, buff, buff.size() );

    if (retval == -1)
        throw YAPETException (strerror (errno) );

    if ( ( (size_t) retval) < buff.size() )
        throw YAPETException (_ ("Short write on file: ") + filename);

    mtime = lastModified();
}

bool
File::isempty() const throw (YAPETException) {
    struct stat st_buf;
    int retval = fstat (fd, &st_buf);

    if (retval == -1)
        throw YAPETException (strerror (errno) );

    if (st_buf.st_size == 0)
        return true;

    return false;
}

void
File::initFile (const Key& key) throw (YAPETException) {
    Crypt crypt (key);
    Record<FileHeader_64> header;
    FileHeader_64* ptr = header;
    ptr->version = VERSION_2;
    memcpy (ptr->control, CONTROL_STR, HEADER_CONTROL_SIZE);
    ptr->pwset = int_to_disk<int64_t> (time (NULL) );
    mtime = lastModified();
    writeHeader (header, key);
    // Sanity checks
    BDBuffer* buff = readHeader();

    if (buff == NULL)
        throw YAPETException (_ ("EOF encountered while reading header") );

    Record<FileHeader_64>* dec_hdr = crypt.decrypt<FileHeader_64> (*buff);
    FileHeader_64* ptr_dec_hdr = *dec_hdr;
    int retval = memcmp (ptr_dec_hdr->control, ptr->control, HEADER_CONTROL_SIZE);

    if (retval != 0)
        throw YAPETException (_ ("Sanity check for control field failed") );

    delete buff;
    delete dec_hdr;
}

void
File::writeHeader (const Record<FileHeader_64>& header, const Key& key)
throw (YAPETException) {
    Crypt crypt (key);
    BDBuffer* buff = NULL;

    try {
        buff = crypt.encrypt (header);
        writeHeader (*buff);
    } catch (YAPETException& ex) {
        if (buff != NULL)
            delete buff;

        throw;
    } catch (...) {
        if (buff != NULL)
            delete buff;

        throw YAPETException (_ ("Unknown exception catched") );
    }

    delete buff;
}

void
File::writeHeader (const BDBuffer& enc_header) throw (YAPETException) {
    seekAbs (0);
    // Write the recognition string
    ssize_t retval = ::write (fd, RECOG_STR, strlen (RECOG_STR) );

    if (retval == -1)
        throw YAPETException (strerror (errno) );

    if ( ( (size_t) retval) != strlen (RECOG_STR) )
        throw YAPETException (_ ("Short write on file: ") + filename);

    mtime = lastModified();
    write (enc_header);
}

BDBuffer*
File::readHeader() const throw (YAPETException) {
    seekAbs (0);
    char* buff = (char*) alloca (strlen (RECOG_STR) );

    if (buff == NULL)
        throw YAPETException (_ ("Memory exhausted") );

    int retval = ::read (fd, buff, strlen (RECOG_STR) );

    if (retval == -1)
        throw YAPETException (strerror (errno) );

    if ( ( (size_t) retval) != strlen (RECOG_STR) )
        throw YAPETException (_ ("File type not recognized") );

    retval = memcmp (RECOG_STR, buff, strlen (RECOG_STR) );

    if (retval != 0)
        throw YAPETException (_ ("File type not recognized") );

    return read();
}

void
File::readHeader(const Key& key, Record<FileHeader_32>** ptr32, Record<FileHeader_64>** ptr64) const throw(YAPETException) {
    assert(ptr32 != NULL && ptr64 != NULL);
    if (ptr32 == NULL)
    throw YAPETException(_("Null pointer passed in ptr32"), NULLPOINTER);
    if (ptr64 == NULL)
    throw YAPETException(_("Null pointer passed in ptr64"), NULLPOINTER);

    Crypt crypt (key);
    BDBuffer* enc_header = NULL;

    try {
        enc_header = readHeader();
    // First try to read a 32bit header
    try {
        *ptr32 = crypt.decrypt<FileHeader_32> (*enc_header);
    } catch (YAPETException& ex) {

        if (*ptr32 != NULL) {
        delete *ptr32;
        *ptr32 = NULL;
        }

        try {
        *ptr64 = crypt.decrypt<FileHeader_64> (*enc_header);
        } catch (YAPETEncryptionException& ex) { // Catch invalid password
        if (enc_header != NULL) {
            delete enc_header;
            enc_header = NULL;
        }
        
        if (*ptr32 != NULL) {
            delete *ptr32;
            *ptr32 = NULL;
        }
        if (*ptr64 != NULL) {
            delete *ptr64;
            *ptr64 = NULL;
        }
        
        throw YAPETInvalidPasswordException();
        } catch (YAPETException &ex) {
        // Ok, we got another problem
        if (*ptr64 != NULL) {
            delete *ptr64;
            *ptr64 = NULL;
        }
        throw;
        }
    }
    } catch (YAPETEncryptionException& ex) { // Catch invalid password
        if (enc_header != NULL) delete enc_header;

        if (*ptr32 != NULL) {
        delete *ptr32;
        *ptr32 = NULL;
    }
    if (*ptr64 != NULL) {
        delete *ptr64;
        *ptr64 = NULL;
    }

        throw YAPETInvalidPasswordException();
    } catch (YAPETException& ex) {
        if (enc_header != NULL) delete enc_header;

        if (*ptr32 != NULL) {
        delete *ptr32;
        *ptr32 = NULL;
    }
    if (*ptr64 != NULL) {
        delete *ptr64;
        *ptr64 = NULL;
    }

        throw;
    }

    delete enc_header;
}

void
File::validateKey (const Key& key)
throw (YAPETException, YAPETInvalidPasswordException) {
    // Expect either a 32bit or 64bit header
    Record<FileHeader_32>* dec_header_32 = NULL;
    Record<FileHeader_64>* dec_header_64 = NULL;

    readHeader(key, &dec_header_32, &dec_header_64);
    assert(dec_header_32 != NULL || dec_header_64 != NULL);

    FileHeader_32* ptr_dec_header_32 = 
    (dec_header_32 != NULL) ? static_cast<FileHeader_32*>(*dec_header_32) : NULL;
    FileHeader_64* ptr_dec_header_64 = 
    (dec_header_64 != NULL) ? static_cast<FileHeader_64*>(*dec_header_64) : NULL;

    int retval;
    if (ptr_dec_header_32 != NULL) {
    retval = memcmp (ptr_dec_header_32->control,
                         CONTROL_STR,
                         HEADER_CONTROL_SIZE);
    } else {
    assert(ptr_dec_header_64 != NULL);
    retval = memcmp (ptr_dec_header_64->control,
                         CONTROL_STR,
                         HEADER_CONTROL_SIZE);
    }
    if (dec_header_32 != NULL)
    delete dec_header_32;
    if (dec_header_64 != NULL)
    delete dec_header_64;

    if (retval != 0)
        throw YAPETInvalidPasswordException();
}

File::File (const std::string& fn, const Key& key, bool create, bool secure)
throw (YAPETException) : filename (fn), usefsecurity (secure) {
    if (create)
        openCreate();
    else
        openNoCreate();

    if (isempty() ) {
        initFile (key);
    } else {
        validateKey (key);
    }
}

File::File (const File& f) throw (YAPETException) {
    fd = dup (f.fd);

    if (fd == -1)
        throw YAPETException (strerror (errno) );

    filename = f.filename;
    mtime = f.mtime;
    usefsecurity = f.usefsecurity;
}

File::~File() {
    close (fd);
}

void
File::save (std::list<PartDec>& records) throw (YAPETException) {
    if (usefsecurity)
        setFileSecurity();

    preparePWSave();
    std::list<PartDec>::iterator it = records.begin();

    while (it != records.end() ) {
        write ( it->getEncRecord() );
        it++;
    }
}

std::list<PartDec>
File::read (const Key& key) const throw (YAPETException) {
    seekDataSection();
    BDBuffer* buff = NULL;
    std::list<PartDec> retval;

    try {
        buff = read();

        while (buff != NULL) {
            retval.push_back (PartDec (*buff, key) );
            delete buff;
            buff = read();
        }
    } catch (YAPETException& ex) {
        if (buff != NULL)
            delete buff;

        throw;
    }

    return retval;
}

void
File::setNewKey (const Key& oldkey,
                 const Key& newkey) throw (YAPETException) {
    close (fd);
    std::string backupfilename (filename + ".bak");
    int retval = rename (filename.c_str(), backupfilename.c_str() );

    if (retval == -1) {
        // Reopen the old file
        openNoCreate();
        throw YAPETException (strerror (errno) );
    }

    File* oldfile = NULL;

    try {
        // Reopen the old (backup) file
        oldfile = new File (backupfilename, oldkey, false, false);
        // Initialize the (this) file with the new key
        openCreate();
        initFile (newkey);
        // Retrieve the records encrypted with the old key
        std::list<PartDec> entries = oldfile->read (oldkey);
        std::list<PartDec>::iterator it = entries.begin();
        Crypt oldcrypt (oldkey);
        Crypt newcrypt (newkey);

        while (it != entries.end() ) {
            Record<PasswordRecord>* dec_rec_ptr = NULL;
            BDBuffer* new_enc_rec = NULL;

            try {
                // Decrypt with the old key
                const BDBuffer old_enc_rec = (*it).getEncRecord();
                dec_rec_ptr =
                    oldcrypt.decrypt<PasswordRecord> (old_enc_rec);
                new_enc_rec =
                    newcrypt.encrypt (*dec_rec_ptr);
                write (*new_enc_rec);
                delete dec_rec_ptr;
                delete new_enc_rec;
            } catch (YAPETException& ex) {
                if (dec_rec_ptr != NULL)
                    delete dec_rec_ptr;

                if (new_enc_rec != NULL)
                    delete new_enc_rec;

                throw;
            }

            it++;
        }
    } catch (YAPETException& ex) {
        if (oldfile != NULL)
            delete oldfile;

        throw;
    }

    delete oldfile;
}

int64_t
File::getMasterPWSet (const Key& key) const
throw (YAPETException, YAPETInvalidPasswordException) {
    // Expect either a 32bit or 64bit header
    Record<FileHeader_32>* dec_header_32 = NULL;
    Record<FileHeader_64>* dec_header_64 = NULL;

    readHeader(key, &dec_header_32, &dec_header_64);
    assert(dec_header_32 != NULL || dec_header_64 != NULL);

    FileHeader_32* ptr_dec_header_32 = 
    (dec_header_32 != NULL) ? static_cast<FileHeader_32*>(*dec_header_32) : NULL;
    FileHeader_64* ptr_dec_header_64 = 
    (dec_header_64 != NULL) ? static_cast<FileHeader_64*>(*dec_header_64) : NULL;

    int64_t t;
    if (ptr_dec_header_32 != NULL) {
    t = int_from_disk<int32_t> (ptr_dec_header_32->pwset);
    } else {
    assert(ptr_dec_header_64 != NULL);
    t = int_from_disk<int64_t> (ptr_dec_header_64->pwset);
    }

    if (dec_header_32 != NULL)
    delete dec_header_32;
    if (dec_header_64 != NULL)
    delete dec_header_64;

    return t;
}

FILE_VERSION
File::getFileVersion(const Key& key) const throw (YAPETException, YAPETInvalidPasswordException) {
    // Expect either a 32bit or 64bit header
    Record<FileHeader_32>* dec_header_32 = NULL;
    Record<FileHeader_64>* dec_header_64 = NULL;

    readHeader(key, &dec_header_32, &dec_header_64);
    assert(dec_header_32 != NULL || dec_header_64 != NULL);

    FileHeader_32* ptr_dec_header_32 = 
    (dec_header_32 != NULL) ? static_cast<FileHeader_32*>(*dec_header_32) : NULL;
    FileHeader_64* ptr_dec_header_64 = 
    (dec_header_64 != NULL) ? static_cast<FileHeader_64*>(*dec_header_64) : NULL;

    FILE_VERSION v;
    if (ptr_dec_header_32 != NULL) {
    v = static_cast<FILE_VERSION>(ptr_dec_header_32->version);
    } else {
    assert(ptr_dec_header_64 != NULL);
    v = static_cast<FILE_VERSION>(ptr_dec_header_64->version);
    }

    if (dec_header_32 != NULL)
    delete dec_header_32;
    if (dec_header_64 != NULL)
    delete dec_header_64;

    return v;
}

const File&
File::operator= (const File & f) throw (YAPETException) {
    if (this == &f) return *this;

    close (fd);
    fd = dup (f.fd);

    if (fd == -1)
        throw YAPETException (strerror (errno) );

    filename = f.filename;
    return *this;
}