kmdcodec.h

/*
   Copyright (C) 2000-2001 Dawit Alemayehu <adawit@kde.org>
   Copyright (C) 2001 Rik Hemsley (rikkus) <rik@kde.org>
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License (LGPL)
   version 2 as published by the Free Software Foundation.
 
   This program 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 Library General Public
   License along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
   RFC 1321 "MD5 Message-Digest Algorithm" Copyright (C) 1991-1992.
   RSA Data Security, Inc. Created 1991. All rights reserved.
 
   The KMD5 class is based on a C++ implementation of
   "RSA Data Security, Inc. MD5 Message-Digest Algorithm" by
   Mordechai T. Abzug,  Copyright (c) 1995.  This implementation
   passes the test-suite as defined in RFC 1321.
 
   The encoding and decoding utilities in KCodecs with the exception of
   quoted-printable are based on the java implementation in HTTPClient
   package by Ronald Tschalär Copyright (C) 1996-1999.
 
   The quoted-printable codec as described in RFC 2045, section 6.7. is by
   Rik Hemsley (C) 2001.
*/
 
#ifndef _KMDBASE_H
#define _KMDBASE_H
 
#define KBase64 KCodecs
 
#include <tqglobal.h>
#include <tqstring.h>
#include <tqiodevice.h>
#include "tdelibs_export.h"
 
class TDECORE_EXPORT KCodecs
{
public:
 
  static TQCString quotedPrintableEncode(const TQByteArray & in,
                                        bool useCRLF = true);
 
  static TQCString quotedPrintableEncode(const TQCString & str,
                                        bool useCRLF = true);
 
  static void quotedPrintableEncode(const TQByteArray & in, TQByteArray& out,
                                    bool useCRLF);
 
  static TQCString quotedPrintableDecode(const TQByteArray & in);
 
  static TQCString quotedPrintableDecode(const TQCString & str);
 
  static void quotedPrintableDecode(const TQByteArray & in, TQByteArray& out);
 
 
  static TQCString uuencode( const TQByteArray& in );
 
  static TQCString uuencode( const TQCString& str );
 
  static void uuencode( const TQByteArray& in, TQByteArray& out );
 
  static TQCString uudecode( const TQByteArray& in );
 
  static TQCString uudecode( const TQCString& str );
 
  static void uudecode( const TQByteArray& in, TQByteArray& out );
 
 
  static TQCString base64Encode( const TQByteArray& in, bool insertLFs = false);
 
  static TQCString base64Encode( const TQCString& str, bool insertLFs = false );
 
  static void base64Encode( const TQByteArray& in, TQByteArray& out,
                            bool insertLFs = false );
 
  static TQCString base64Decode( const TQByteArray& in );
 
  static TQCString base64Decode( const TQCString& str );
 
  static void base64Decode( const TQByteArray& in, TQByteArray& out );
 
 
private:
  KCodecs();
 
private:
  static const char UUEncMap[64];
  static const char UUDecMap[128];
  static const char Base64EncMap[64];
  static const char Base64DecMap[128];
  static const char hexChars[16];
  static const unsigned int maxQPLineLength;
};
 
class KMD5Private;
class TDECORE_EXPORT KMD5
{
public:
 
  typedef unsigned char Digest[16];
 
  KMD5();
 
  KMD5(const char* in, int len = -1);
 
  KMD5(const TQByteArray& a );
 
  KMD5(const TQCString& a );
 
  void update(const char* in, int len = -1) { update(reinterpret_cast<const unsigned char*>(in), len); }
 
  void update(const unsigned char* in, int len = -1);
 
  void update(const TQByteArray& in );
 
  void update(const TQCString& in );
 
  bool update(TQIODevice& file);
 
  void reset();
 
  const Digest& rawDigest ();
 
  void rawDigest( KMD5::Digest& bin );
 
  TQCString hexDigest ();
 
  void hexDigest(TQCString&);
 
  TQCString base64Digest ();
 
  bool verify( const KMD5::Digest& digest);
 
  bool verify(const TQCString&);
 
protected:
  void transform( const unsigned char buffer[64] );
 
  void finalize();
 
private:
  KMD5(const KMD5& u);
  KMD5& operator=(const KMD5& md);
 
  void init();
  void encode( unsigned char* output, TQ_UINT32 *in, TQ_UINT32 len );
  void decode( TQ_UINT32 *output, const unsigned char* in, TQ_UINT32 len );
 
  TQ_UINT32 rotate_left( TQ_UINT32 x, TQ_UINT32 n );
  TQ_UINT32 F( TQ_UINT32 x, TQ_UINT32 y, TQ_UINT32 z );
  TQ_UINT32 G( TQ_UINT32 x, TQ_UINT32 y, TQ_UINT32 z );
  TQ_UINT32 H( TQ_UINT32 x, TQ_UINT32 y, TQ_UINT32 z );
  TQ_UINT32 I( TQ_UINT32 x, TQ_UINT32 y, TQ_UINT32 z );
  void FF( TQ_UINT32& a, TQ_UINT32 b, TQ_UINT32 c, TQ_UINT32 d, TQ_UINT32 x,
               TQ_UINT32  s, TQ_UINT32 ac );
  void GG( TQ_UINT32& a, TQ_UINT32 b, TQ_UINT32 c, TQ_UINT32 d, TQ_UINT32 x,
                TQ_UINT32 s, TQ_UINT32 ac );
  void HH( TQ_UINT32& a, TQ_UINT32 b, TQ_UINT32 c, TQ_UINT32 d, TQ_UINT32 x,
                TQ_UINT32 s, TQ_UINT32 ac );
  void II( TQ_UINT32& a, TQ_UINT32 b, TQ_UINT32 c, TQ_UINT32 d, TQ_UINT32 x,
             TQ_UINT32 s, TQ_UINT32 ac );
 
private:
  TQ_UINT32 m_state[4];
  TQ_UINT32 m_count[2];
  TQ_UINT8 m_buffer[64];
  Digest m_digest;
  bool m_finalized;
 
  KMD5Private* d;
};
 
class TDECORE_EXPORT KMD4
{
public:
 
  typedef unsigned char Digest[16];
 
  KMD4();
 
  KMD4(const char* in, int len = -1);
 
  KMD4(const TQByteArray& a );
 
  KMD4(const TQCString& a );
 
  void update(const char* in, int len = -1) { update(reinterpret_cast<const unsigned char*>(in), len); }
 
  void update(const unsigned char* in, int len = -1);
 
  void update(const TQByteArray& in );
 
  void update(const TQCString& in );
 
  bool update(TQIODevice& file);
 
  void reset();
 
  const Digest& rawDigest ();
 
  void rawDigest( KMD4::Digest& bin );
 
  TQCString hexDigest ();
 
  void hexDigest(TQCString&);
 
  TQCString base64Digest ();
 
  bool verify( const KMD4::Digest& digest);
 
  bool verify(const TQCString&);
 
protected:
  void transform( TQ_UINT32 buf[4], TQ_UINT32 const in[16] );
 
  void finalize();
 
private:
  KMD4(const KMD4& u);
  KMD4& operator=(const KMD4& md);
 
  void init();
 
  void byteReverse( unsigned char *buf, TQ_UINT32 len );
 
  TQ_UINT32 rotate_left( TQ_UINT32 x, TQ_UINT32 n );
  TQ_UINT32 F( TQ_UINT32 x, TQ_UINT32 y, TQ_UINT32 z );
  TQ_UINT32 G( TQ_UINT32 x, TQ_UINT32 y, TQ_UINT32 z );
  TQ_UINT32 H( TQ_UINT32 x, TQ_UINT32 y, TQ_UINT32 z );
  void FF( TQ_UINT32& a, TQ_UINT32 b, TQ_UINT32 c, TQ_UINT32 d, TQ_UINT32 x,
               TQ_UINT32  s );
  void GG( TQ_UINT32& a, TQ_UINT32 b, TQ_UINT32 c, TQ_UINT32 d, TQ_UINT32 x,
                TQ_UINT32 s );
  void HH( TQ_UINT32& a, TQ_UINT32 b, TQ_UINT32 c, TQ_UINT32 d, TQ_UINT32 x,
                TQ_UINT32 s );
 
private:
  TQ_UINT32 m_state[4];
  TQ_UINT32 m_count[2];
  TQ_UINT8 m_buffer[64];
  Digest m_digest;
  bool m_finalized;
 
  class KMD4Private;
  KMD4Private* d;
};
 
 
#endif