kcodecs.h

Go to the documentation of this file.

/*
   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 Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser 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.             // krazy:exclude=copyright
   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                // krazy:exclude=copyright
   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.                          // krazy:exclude=copyright

   The quoted-printable codec as described in RFC 2045, section 6.7. is by
   Rik Hemsley (C) 2001.
*/

#ifndef KCODECS_H
#define KCODECS_H

#define KBase64 KCodecs

#include <kdecore_export.h>

class QByteArray;
class QIODevice;

namespace KCodecs
{
  KDECORE_EXPORT QByteArray quotedPrintableEncode(const QByteArray & in,
                                        bool useCRLF = true);

  KDECORE_EXPORT void quotedPrintableEncode(const QByteArray & in, QByteArray& out,
                                    bool useCRLF);

  KDECORE_EXPORT QByteArray quotedPrintableDecode(const QByteArray & in);

  KDECORE_EXPORT void quotedPrintableDecode(const QByteArray & in, QByteArray& out);


  KDECORE_EXPORT QByteArray uuencode( const QByteArray& in );

  KDECORE_EXPORT void uuencode( const QByteArray& in, QByteArray& out );

  KDECORE_EXPORT QByteArray uudecode( const QByteArray& in );

  KDECORE_EXPORT void uudecode( const QByteArray& in, QByteArray& out );


  KDECORE_EXPORT QByteArray base64Encode( const QByteArray& in, bool insertLFs = false);

  KDECORE_EXPORT void base64Encode( const QByteArray& in, QByteArray& out,
                            bool insertLFs = false );

  KDECORE_EXPORT QByteArray base64Decode( const QByteArray& in );

  KDECORE_EXPORT void base64Decode( const QByteArray& in, QByteArray& out );


  KDECORE_EXPORT QString decodeRFC2047String(const QString &text);


}

class KMD5Private;
class KDECORE_EXPORT KMD5
{
public:

  typedef unsigned char Digest[16];

  KMD5();
  ~KMD5();

  explicit KMD5(const char* in, int len = -1);

  explicit KMD5(const QByteArray& a );

  void update(const char* in, int len = -1);

  void update(const unsigned char* in, int len = -1);

  void update(const QByteArray& in );

  bool update(QIODevice& file);

  void reset();

  const Digest& rawDigest (); //krazy:exclude=constref (simple array)

  void rawDigest( KMD5::Digest& bin );

  QByteArray hexDigest ();

  void hexDigest(QByteArray&);

  QByteArray base64Digest ();

  bool verify( const KMD5::Digest& digest);

  bool verify(const QByteArray&);

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, quint32 *in, quint32 len );
  void decode( quint32 *output, const unsigned char* in, quint32 len );

  quint32 rotate_left( quint32 x, quint32 n );
  quint32 F( quint32 x, quint32 y, quint32 z );
  quint32 G( quint32 x, quint32 y, quint32 z );
  quint32 H( quint32 x, quint32 y, quint32 z );
  quint32 I( quint32 x, quint32 y, quint32 z );
  void FF( quint32& a, quint32 b, quint32 c, quint32 d, quint32 x,
               quint32  s, quint32 ac );
  void GG( quint32& a, quint32 b, quint32 c, quint32 d, quint32 x,
                quint32 s, quint32 ac );
  void HH( quint32& a, quint32 b, quint32 c, quint32 d, quint32 x,
                quint32 s, quint32 ac );
  void II( quint32& a, quint32 b, quint32 c, quint32 d, quint32 x,
             quint32 s, quint32 ac );

private:
  quint32 m_state[4];
  quint32 m_count[2];
  quint8 m_buffer[64];
  Digest m_digest;
  bool m_finalized;

  KMD5Private* d;
};


#endif // KCODECS_H