MNDecrypt.h

Go to the documentation of this file.

/* Copyright (C) 2000 KOM/Darmstadt University of Technology
 *
 * You are allowed to use all other parts of the code under the following terms:
 *
 * For non-commercial use, code may be used in unmodified form provided
 * that this copyright notice and this permission notice appear in
 * supporting documentation.
 *
 * This software is provided "as is" and without any express or implied
 * warranties, including, without limitation, the implied warranty of
 * fitness for a particular purpose.
 *
 * The code may be subjected to the GNU General Public License, Version 2,
 * and re-distributed under the terms of this license.
 * As a special exception, permission is granted to link this code
 * with the Qt library and distribute executables, as long as you
 * follow the requirements of the GNU GPL in regard to all of the
 * software in the executable aside from Qt.
 *
 * Commercial use other than under the terms of the GNU General Public
 * License is allowed only after express negotiation of conditions
 * with the authors.
 */
#ifndef MNDECRYPT_H
#define MNDECRYPT_H

#include <sys/types.h>
#include <stdlib.h>
#include "MNMsg.h"
#include "rijndael.h"

class MNDecrypt {

  protected:
    typedef u_int64_t u_int64;
    typedef u_int32_t u_int32;

  public:

    MNDecrypt(const char* filename);
    ~MNDecrypt();

    //Die Methode write für die Daten <data> der Entschlüsselungsmethode zu
    //<pos> gibt die absolute Position der Daten in der Datei an, <len> die
    //Länge der Daten in Byte.
    //Bei jedem write werden evtl. alte vorhandene Daten gelöscht. Daher
    //sollte möglichst auf jedes write bald ein read folgen.
    void write(const unsigned char* data, u_int64 pos, u_int64 len);

    //Gibt in Bytes an wieviele Daten zum Lesen bereitstehen
    u_int64 bytesAvail() { return _dataLen; };
    //Liest die entschlüsselten Daten aus der Klasse
    const unsigned char* read() { return _data; };

    bool isInitialized() { return _initialized; };

  protected:

    unsigned char* _data;
    unsigned char* _decrypted;
    unsigned char _oddStuff[16];
    u_int64 _dataLen;
    bool _dataLocal;

    u_int32 _keyLen;
    u_int32 _buckets;
    u_int32 _bucketSize;

    //Offset des ersten Ciphertextblocks
    u_int32 _offset;
    //Länge des Plaintextbereiches
    u_int32 _plainLen;
    //Länge des Ciphertextbereiches für einen Schlüssel
    u_int32 _cipherLen;

    //Länge eines kompletten Cipherblocks für alle Schlüssel
    //_cipherBlockLen = _buckets * _bucketSize * _cipherLen
    u_int64 _cipherBlockLen;
    //Länge eines kompletten Blocks aus Plaintextbereich und Ciphertextbereich
    //_blockLen = _plainLen + _cipherBlockLen
    u_int64 _blockLen;

    //Benutzer-ID für die Entschlüsselung
    u_int32* _userID;

    //Die Rijndael-Objekte für die Entschlüsselung
    typedef Rijndael* rijndael_ptr;
    Rijndael** _decrypters;

    //Zeigt hinter die letzte beim letzten Durchlauf bearbeitete Position
    u_int64 _lastPos;
    
    bool _initialized;

    //Gibt das offset relativ zum letzten Block zurück
    u_int64 relBlockPos(const u_int64 pos) { return (pos - _offset) % _blockLen; };

    //Gibt zurück ob eine Dateiposition im Offset liegt
    bool isOffset(const u_int64 pos) { return (pos < _offset); };

    //Gibt zurück ob eine Dateiposition Plaintext ist (nur außerhalb des Offsets)
    bool isPlain(const u_int64 pos) { return ( relBlockPos(pos) >= _cipherBlockLen ); };

    //Gibt zurück ob eine Dateiposition Ciphertext ist (nur außerhalb des Offsets)
    bool isCipher(const u_int64 pos) { return !isPlain(pos); };

    //Speicher reservieren mit Fehlermeldung
    void* safemalloc(size_t size) {
      void* ret = malloc(size);
      if (ret == NULL) MN_FATAL("malloc() failed");
      return ret; };
    void* safecalloc(size_t nmemb, size_t size) {
      void* ret = calloc(nmemb, size);
      if (ret == NULL) MN_FATAL("calloc() failed");
      return ret; };
    void* saferealloc(void* ptr, size_t size) {
      void* ret = realloc(ptr, size);
      if ( (ret == NULL) && (size != 0) ) MN_FATAL("realloc() failed");
      return ret; };

};
 
#endif

---