1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
|
/*
Copyright (C) 2000-2001 Dawit Alemayehu <[email protected]>
Copyright (C) 2001 Rik Hemsley (rikkus) <[email protected]>
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"
/**
* A wrapper class for the most commonly used encoding and
* decoding algorithms. Currently there is support for encoding
* and decoding input using base64, uu and the quoted-printable
* specifications.
*
* \b Usage:
*
* \code
* TQCString input = "Aladdin:open sesame";
* TQCString result = KCodecs::base64Encode(input);
* cout << "Result: " << result.data() << endl;
* \endcode
*
* <pre>
* Output should be
* Result: QWxhZGRpbjpvcGVuIHNlc2FtZQ==
* </pre>
*
* The above example makes use of the convenience functions
* (ones that accept/return null-terminated strings) to encode/decode
* a string. If what you need is to encode or decode binary data, then
* it is highly recommended that you use the functions that take an input
* and output TQByteArray as arguments. These functions are specifically
* tailored for encoding and decoding binary data.
*
* @short A collection of commonly used encoding and decoding algorithms.
* @author Dawit Alemayehu <[email protected]>
* @author Rik Hemsley <[email protected]>
*/
class TDECORE_EXPORT KCodecs
{
public:
/**
* Encodes the given data using the quoted-printable algorithm.
*
* @param in data to be encoded.
* @param useCRLF if true the input data is expected to have
* CRLF line breaks and the output will have CRLF line
* breaks, too.
* @return quoted-printable encoded string.
*/
static TQCString quotedPrintableEncode(const TQByteArray & in,
bool useCRLF = true);
/**
* @overload
*
* Same as above except it accepts a null terminated
* string instead an array.
*
* @param str string to be encoded.
* @param useCRLF if true the input data is expected to have
* CRLF line breaks and the output will have CRLF line
* breaks, too.
* @return quoted-printable encoded string.
*/
static TQCString quotedPrintableEncode(const TQCString & str,
bool useCRLF = true);
/**
* Encodes the given data using the quoted-printable algorithm.
*
* Use this function if you want the result of the encoding
* to be placed in another array which cuts down the number
* of copy operation that have to be performed in the process.
* This is also the preferred method for encoding binary data.
*
* NOTE: the output array is first reset and then resized
* appropriately before use, hence, all data stored in the
* output array will be lost.
*
* @param in data to be encoded.
* @param out encoded data.
* @param useCRLF if true the input data is expected to have
* CRLF line breaks and the output will have CRLF line
* breaks, too.
*/
static void quotedPrintableEncode(const TQByteArray & in, TQByteArray& out,
bool useCRLF);
/**
* Decodes a quoted-printable encoded data.
*
* Accepts data with CRLF or standard unix line breaks.
*
* @param in data to be decoded.
* @return decoded string.
*/
static TQCString quotedPrintableDecode(const TQByteArray & in);
/**
* @overload
*
* Same as above except it accepts a null terminated
* string instead an array.
*
* @param str string to be decoded.
* @return decoded string.
*/
static TQCString quotedPrintableDecode(const TQCString & str);
/**
* Decodes a quoted-printable encoded data.
*
* Accepts data with CRLF or standard unix line breaks.
* Use this function if you want the result of the decoding
* to be placed in another array which cuts down the number
* of copy operation that have to be performed in the process.
* This is also the preferred method for decoding an encoded
* binary data.
*
* NOTE: the output array is first reset and then resized
* appropriately before use, hence, all data stored in the
* output array will be lost.
*
* @param in data to be decoded.
* @param out decoded data.
*/
static void quotedPrintableDecode(const TQByteArray & in, TQByteArray& out);
/**
* Encodes the given data using the uuencode algorithm.
*
* The output is split into lines starting with the number of
* encoded octets in the line and ending with a newline. No
* line is longer than 45 octets (60 characters), excluding the
* line terminator.
*
* @param in data to be uuencoded
* @return uuencoded string.
*/
static TQCString uuencode( const TQByteArray& in );
/**
* @overload
*
* Same as the above functions except it accepts
* a null terminated string instead an array.
*
* @param str string to be uuencoded.
* @return encoded string.
*/
static TQCString uuencode( const TQCString& str );
/**
* Encodes the given data using the uuencode algorithm.
*
* Use this function if you want the result of the encoding
* to be placed in another array and cut down the number of
* copy operation that have to be performed in the process.
* This is the preffered method for encoding binary data.
*
* NOTE: the output array is first reset and then resized
* appropriately before use, hence, all data stored in the
* output array will be lost.
*
* @param in data to be uuencoded.
* @param out uudecoded data.
*/
static void uuencode( const TQByteArray& in, TQByteArray& out );
/**
* Decodes the given data using the uudecode algorithm.
*
* Any 'begin' and 'end' lines like those generated by
* the utilities in unix and unix-like OS will be
* automatically ignored.
*
* @param in data to be decoded.
* @return decoded string.
*/
static TQCString uudecode( const TQByteArray& in );
/**
* @overload
*
* Same as the above functions except it accepts
* a null terminated string instead an array.
*
* @param str string to be decoded.
* @return uudecoded string.
*/
static TQCString uudecode( const TQCString& str );
/**
* Decodes the given data using the uudecode algorithm.
*
* Use this function if you want the result of the decoding
* to be placed in another array which cuts down the number
* of copy operation that have to be performed in the process.
* This is the preferred method for decoding binary data.
*
* Any 'begin' and 'end' lines like those generated by
* the utilities in unix and unix-like OS will be
* automatically ignored.
*
* NOTE: the output array is first reset and then resized
* appropriately before use, hence, all data stored in the
* output array will be lost.
*
* @param in data to be decoded.
* @param out uudecoded data.
*/
static void uudecode( const TQByteArray& in, TQByteArray& out );
/**
* Encodes the given data using the base64 algorithm.
*
* The boolean argument determines if the encoded data is
* going to be restricted to 76 characters or less per line
* as specified by RFC 2045. If @p insertLFs is true, then
* there will be 76 characters or less per line.
*
* @param in data to be encoded.
* @param insertLFs limit the number of characters per line.
*
* @return base64 encoded string.
*/
static TQCString base64Encode( const TQByteArray& in, bool insertLFs = false);
/**
* @overload
*
* Same as the above functions except it accepts
* a null terminated string instead an array.
*
* @param str string to be encoded.
* @param insertLFs limit the number of characters per line.
* @return decoded string.
*/
static TQCString base64Encode( const TQCString& str, bool insertLFs = false );
/**
* Encodes the given data using the base64 algorithm.
*
* Use this function if you want the result of the encoding
* to be placed in another array which cuts down the number
* of copy operation that have to be performed in the process.
* This is also the preferred method for encoding binary data.
*
* The boolean argument determines if the encoded data is going
* to be restricted to 76 characters or less per line as specified
* by RFC 2045. If @p insertLFs is true, then there will be 76
* characters or less per line.
*
* NOTE: the output array is first reset and then resized
* appropriately before use, hence, all data stored in the
* output array will be lost.
*
* @param in data to be encoded.
* @param out encoded data.
* @param insertLFs limit the number of characters per line.
*/
static void base64Encode( const TQByteArray& in, TQByteArray& out,
bool insertLFs = false );
/**
* Decodes the given data that was encoded using the
* base64 algorithm.
*
* @param in data to be decoded.
* @return decoded string.
*/
static TQCString base64Decode( const TQByteArray& in );
/**
* @overload
*
* Same as the above functions except it accepts
* a null terminated string instead an array.
*
* @param str string to be decoded.
* @return decoded string.
*/
static TQCString base64Decode( const TQCString& str );
/**
* Decodes the given data that was encoded with the base64
* algorithm.
*
* Use this function if you want the result of the decoding
* to be placed in another array which cuts down the number
* of copy operation that have to be performed in the process.
* This is also the preferred method for decoding an encoded
* binary data.
*
* NOTE: the output array is first reset and then resized
* appropriately before use, hence, all data stored in the
* output array will be lost.
*
* @param in data to be decoded.
* @param out decoded data.
*/
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;
/**
* @short An adapted C++ implementation of RSA Data Securities MD5 algorithm.
*
* The default constructor is designed to provide much the same
* functionality as the most commonly used C-implementation, while
* the other three constructors are meant to further simplify the
* process of obtaining a digest by calculating the result in a
* single step.
*
* KMD5 is state-based, that means you can add new contents with
* update() as long as you didn't request the digest value yet.
* After the digest value was requested, the object is "finalized"
* and you have to call reset() to be able to do another calculation
* with it. The reason for this behavior is that upon requesting
* the message digest KMD5 has to pad the received contents up to a
* 64 byte boundary to calculate its value. After this operation it
* is not possible to resume consuming data.
*
* \b Usage:
*
* A common usage of this class:
*
* \code
* const char* test1;
* KMD5::Digest rawResult;
*
* test1 = "This is a simple test.";
* KMD5 context (test1);
* cout << "Hex Digest output: " << context.hexDigest().data() << endl;
* \endcode
*
* To cut down on the unnecessary overhead of creating multiple KMD5
* objects, you can simply invoke reset() to reuse the same object
* in making another calculation:
*
* \code
* context.reset ();
* context.update ("TWO");
* context.update ("THREE");
* cout << "Hex Digest output: " << context.hexDigest().data() << endl;
* \endcode
*
* @author Dirk Mueller <[email protected]>, Dawit Alemayehu <[email protected]>
*/
class TDECORE_EXPORT KMD5
{
public:
typedef unsigned char Digest[16];
KMD5();
/**
* Constructor that updates the digest for the given string.
*
* @param in C string or binary data
* @param len if negative, calculates the length by using
* strlen on the first parameter, otherwise
* it trusts the given length (does not stop on NUL byte).
*/
KMD5(const char* in, int len = -1);
/**
* @overload
*
* Same as above except it accepts a TQByteArray as its argument.
*/
KMD5(const TQByteArray& a );
/**
* @overload
*
* Same as above except it accepts a TQCString as its argument.
*/
KMD5(const TQCString& a );
/**
* Updates the message to be digested. Be sure to add all data
* before you read the digest. After reading the digest, you
* can <b>not</b> add more data!
*
* @param in message to be added to digest
* @param len the length of the given message.
*/
void update(const char* in, int len = -1) { update(reinterpret_cast<const unsigned char*>(in), len); }
/**
* @overload
*/
void update(const unsigned char* in, int len = -1);
/**
* @overload
*
* @param in message to be added to the digest (TQByteArray).
*/
void update(const TQByteArray& in );
/**
* @overload
*
* @param in message to be added to the digest (TQCString).
*/
void update(const TQCString& in );
/**
* @overload
*
* reads the data from an I/O device, i.e. from a file (TQFile).
*
* NOTE that the file must be open for reading.
*
* @param file a pointer to FILE as returned by calls like f{d,re}open
*
* @returns false if an error occurred during reading.
*/
bool update(TQIODevice& file);
/**
* Calling this function will reset the calculated message digest.
* Use this method to perform another message digest calculation
* without recreating the KMD5 object.
*/
void reset();
/**
* @return the raw representation of the digest
*/
const Digest& rawDigest ();
/**
* Fills the given array with the binary representation of the
* message digest.
*
* Use this method if you do not want to worry about making
* copy of the digest once you obtain it.
*
* @param bin an array of 16 characters ( char[16] )
*/
void rawDigest( KMD5::Digest& bin );
/**
* Returns the value of the calculated message digest in
* a hexadecimal representation.
*/
TQCString hexDigest ();
/**
* @overload
*/
void hexDigest(TQCString&);
/**
* Returns the value of the calculated message digest in
* a base64-encoded representation.
*/
TQCString base64Digest ();
/**
* returns true if the calculated digest for the given
* message matches the given one.
*/
bool verify( const KMD5::Digest& digest);
/**
* @overload
*/
bool verify(const TQCString&);
protected:
/**
* Performs the real update work. Note
* that length is implied to be 64.
*/
void transform( const unsigned char buffer[64] );
/**
* finalizes the digest
*/
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;
};
/**
* @short An adapted C++ implementation of the MD4 Message-Digest algorithm.
* @since 3.4
*
* The class usage is the same as KMD5.
*/
class TDECORE_EXPORT KMD4
{
public:
typedef unsigned char Digest[16];
KMD4();
/**
* Constructor that updates the digest for the given string.
*
* @param in C string or binary data
* @param len if negative, calculates the length by using
* strlen on the first parameter, otherwise
* it trusts the given length (does not stop on NUL byte).
*/
KMD4(const char* in, int len = -1);
/**
* @overload
*
* Same as above except it accepts a TQByteArray as its argument.
*/
KMD4(const TQByteArray& a );
/**
* @overload
*
* Same as above except it accepts a TQCString as its argument.
*/
KMD4(const TQCString& a );
/**
* Updates the message to be digested. Be sure to add all data
* before you read the digest. After reading the digest, you
* can <b>not</b> add more data!
*
* @param in message to be added to digest
* @param len the length of the given message.
*/
void update(const char* in, int len = -1) { update(reinterpret_cast<const unsigned char*>(in), len); }
/**
* @overload
*/
void update(const unsigned char* in, int len = -1);
/**
* @overload
*
* @param in message to be added to the digest (TQByteArray).
*/
void update(const TQByteArray& in );
/**
* @overload
*
* @param in message to be added to the digest (TQCString).
*/
void update(const TQCString& in );
/**
* @overload
*
* reads the data from an I/O device, i.e. from a file (TQFile).
*
* NOTE that the file must be open for reading.
*
* @param file a pointer to FILE as returned by calls like f{d,re}open
*
* @returns false if an error occurred during reading.
*/
bool update(TQIODevice& file);
/**
* Calling this function will reset the calculated message digest.
* Use this method to perform another message digest calculation
* without recreating the KMD4 object.
*/
void reset();
/**
* @return the raw representation of the digest
*/
const Digest& rawDigest ();
/**
* Fills the given array with the binary representation of the
* message digest.
*
* Use this method if you do not want to worry about making
* copy of the digest once you obtain it.
*
* @param bin an array of 16 characters ( char[16] )
*/
void rawDigest( KMD4::Digest& bin );
/**
* Returns the value of the calculated message digest in
* a hexadecimal representation.
*/
TQCString hexDigest ();
/**
* @overload
*/
void hexDigest(TQCString&);
/**
* Returns the value of the calculated message digest in
* a base64-encoded representation.
*/
TQCString base64Digest ();
/**
* returns true if the calculated digest for the given
* message matches the given one.
*/
bool verify( const KMD4::Digest& digest);
/**
* @overload
*/
bool verify(const TQCString&);
protected:
/**
* Performs the real update work. Note
* that length is implied to be 64.
*/
void transform( TQ_UINT32 buf[4], TQ_UINT32 const in[16] );
/**
* finalizes the digest
*/
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
|