64 const char KCodecs::Base64EncMap[64] =
66 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
67 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50,
68 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
69 0x59, 0x5A, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
70 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E,
71 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
72 0x77, 0x78, 0x79, 0x7A, 0x30, 0x31, 0x32, 0x33,
73 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2B, 0x2F
76 const char KCodecs::Base64DecMap[128] =
78 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
79 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
80 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
81 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
82 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
83 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x3F,
84 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B,
85 0x3C, 0x3D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
86 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
87 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
88 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
89 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
90 0x00, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20,
91 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
92 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30,
93 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00
96 const char KCodecs::UUEncMap[64] =
98 0x60, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
99 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
100 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
101 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
102 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
103 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
104 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
105 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F
108 const char KCodecs::UUDecMap[128] =
110 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
111 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
112 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
113 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
114 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
115 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
116 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
117 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
118 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
119 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
120 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
121 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
122 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
123 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
124 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
125 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
128 const char KCodecs::hexChars[16] =
130 '0',
'1',
'2',
'3',
'4',
'5',
'6',
'7',
131 '8',
'9',
'A',
'B',
'C',
'D',
'E',
'F'
134 const unsigned int KCodecs::maxQPLineLength = 70;
139 static int rikFindChar(
register const char * _s,
const char c)
141 register const char * s = _s;
145 if ((0 == *s) || (c == *s))
break; ++s;
146 if ((0 == *s) || (c == *s))
break; ++s;
147 if ((0 == *s) || (c == *s))
break; ++s;
148 if ((0 == *s) || (c == *s))
break; ++s;
158 return TQCString (out.data(), out.size()+1);
166 TQByteArray in (str.length());
167 memcpy (in.data(), str.data(), str.length());
179 unsigned int lineLength;
182 const unsigned int length = in.size();
183 const unsigned int end = length - 1;
190 out.resize ((length*12)/10);
196 for (
unsigned int i = 0; i < length; i++)
198 unsigned char c (data[i]);
202 pos = cursor-out.data();
203 if (out.size()-pos < 16) {
204 out.resize(out.size()+4096);
205 cursor = out.data()+pos;
210 if ((c >= 33) && (c <= 126) && (
'=' != c))
224 ((i < end) && ((useCRLF && (
'\r' == data[i + 1]) && (
'\n' == data[i + 2]))
226 (!useCRLF && (
'\n' == data[i + 1]))))
242 else if ((useCRLF && (
'\r' == c) && (i < end) && (
'\n' == data[i + 1])) ||
243 (!useCRLF && (
'\n' == c)))
261 *cursor++ = hexChars[c / 16];
262 *cursor++ = hexChars[c % 16];
269 if ((lineLength > maxQPLineLength) && (i < end))
284 out.truncate(cursor - out.data());
291 return TQCString (out.data(), out.size()+1);
299 TQByteArray in (str.length());
300 memcpy (in.data(), str.data(), str.length());
313 const unsigned int length = in.size();
319 for (
unsigned int i = 0; i < length; i++)
330 if ((
'\n' == c1) || (
'\r' == c1 &&
'\n' == c2))
342 int hexChar0 = rikFindChar(hexChars, c1);
343 int hexChar1 = rikFindChar(hexChars, c2);
345 if (hexChar0 < 16 && hexChar1 < 16)
347 *cursor++ = char((hexChar0 * 16) | hexChar1);
359 out.truncate(cursor - out.data());
367 TQByteArray in (str.length());
368 memcpy( in.data(), str.data(), str.length() );
376 return TQCString( out.data(), out.size()+1 );
387 unsigned int sidx = 0;
388 unsigned int didx = 0;
389 const char* data = in.data();
390 const unsigned int len = in.size();
392 unsigned int out_len = ((len+2)/3)*4;
397 insertLFs = (insertLFs && out_len > 76);
399 out_len += ((out_len-1)/76);
402 out.resize( out_len );
411 if ( count && (count%76) == 0 )
415 out[didx++] = Base64EncMap[(data[sidx] >> 2) & 077];
416 out[didx++] = Base64EncMap[(data[sidx+1] >> 4) & 017 |
417 (data[sidx] << 4) & 077];
418 out[didx++] = Base64EncMap[(data[sidx+2] >> 6) & 003 |
419 (data[sidx+1] << 2) & 077];
420 out[didx++] = Base64EncMap[data[sidx+2] & 077];
427 if ( insertLFs && (count > 0) && (count%76) == 0 )
430 out[didx++] = Base64EncMap[(data[sidx] >> 2) & 077];
433 out[didx++] = Base64EncMap[(data[sidx+1] >> 4) & 017 |
434 (data[sidx] << 4) & 077];
435 out[didx++] = Base64EncMap[(data[sidx+1] << 2) & 077];
439 out[didx++] = Base64EncMap[(data[sidx] << 4) & 077];
444 while (didx < out.size())
456 TQByteArray in( str.length() );
457 memcpy( in.data(), str.data(), str.length() );
465 return TQCString( out.data(), out.size()+1 );
474 unsigned int count = 0;
475 unsigned int len = in.size(), tail = len;
476 const char* data = in.data();
479 while ( count < len && (data[count] ==
'\n' || data[count] ==
'\r' ||
480 data[count] ==
'\t' || data[count] ==
' ') )
486 if ( strncasecmp(data+count,
"begin", 5) == 0 )
489 while ( count < len && data[count] !=
'\n' && data[count] !=
'\r' )
492 while ( count < len && (data[count] ==
'\n' || data[count] ==
'\r') )
496 tail = (len -= count);
502 && ( data[tail-1] ==
'=' || data[tail-1] ==
'\n' || data[tail-1] ==
'\r' ) )
503 if ( data[--tail] !=
'=' ) len = tail;
505 unsigned int outIdx = 0;
506 out.resize( (count=len) );
507 for (
unsigned int idx = 0; idx < count; idx++)
511 unsigned char ch = data[idx];
512 if ((ch > 47 && ch < 58) || (ch > 64 && ch < 91) ||
513 (ch > 96 && ch < 123) || ch ==
'+' || ch ==
'/' || ch ==
'=')
515 out[outIdx++] = Base64DecMap[ch];
527 len = (tail>(len/4)) ? tail-(len/4) : 0;
528 unsigned int sidx = 0, didx = 0;
533 out[didx] = (((out[sidx] << 2) & 255) | ((out[sidx+1] >> 4) & 003));
534 out[didx+1] = (((out[sidx+1] << 4) & 255) | ((out[sidx+2] >> 2) & 017));
535 out[didx+2] = (((out[sidx+2] << 6) & 255) | (out[sidx+3] & 077));
542 out[didx] = (((out[sidx] << 2) & 255) | ((out[sidx+1] >> 4) & 003));
545 out[didx] = (((out[sidx+1] << 4) & 255) | ((out[sidx+2] >> 2) & 017));
548 if ( len == 0 || len < out.size() )
558 in.resize( str.length() );
559 memcpy( in.data(), str.data(), str.length() );
567 return TQCString( out.data(), out.size()+1 );
576 unsigned int sidx = 0;
577 unsigned int didx = 0;
578 unsigned int line_len = 45;
580 const char nl[] =
"\n";
581 const char* data = in.data();
582 const unsigned int nl_len = strlen(nl);
583 const unsigned int len = in.size();
585 out.resize( (len+2)/3*4 + ((len+line_len-1)/line_len)*(nl_len+1) );
587 while (sidx+line_len < len)
590 out[didx++] = UUEncMap[line_len];
593 for (
unsigned int end = sidx+line_len; sidx < end; sidx += 3)
595 out[didx++] = UUEncMap[(data[sidx] >> 2) & 077];
596 out[didx++] = UUEncMap[(data[sidx+1] >> 4) & 017 |
597 (data[sidx] << 4) & 077];
598 out[didx++] = UUEncMap[(data[sidx+2] >> 6) & 003 |
599 (data[sidx+1] << 2) & 077];
600 out[didx++] = UUEncMap[data[sidx+2] & 077];
606 memcpy(out.data()+didx, nl, nl_len);
611 out[didx++] = UUEncMap[len-sidx];
615 out[didx++] = UUEncMap[(data[sidx] >> 2) & 077];
616 out[didx++] = UUEncMap[(data[sidx+1] >> 4) & 017 |
617 (data[sidx] << 4) & 077];
618 out[didx++] = UUEncMap[(data[sidx+2] >> 6) & 003 |
619 (data[sidx+1] << 2) & 077];
620 out[didx++] = UUEncMap[data[sidx+2] & 077];
626 out[didx++] = UUEncMap[(data[sidx] >> 2) & 077];
627 out[didx++] = UUEncMap[(data[sidx+1] >> 4) & 017 |
628 (data[sidx] << 4) & 077];
629 out[didx++] = UUEncMap[(data[sidx+1] << 2) & 077];
630 out[didx++] = UUEncMap[0];
634 out[didx++] = UUEncMap[(data[sidx] >> 2) & 077];
635 out[didx++] = UUEncMap[(data[sidx] << 4) & 077];
636 out[didx++] = UUEncMap[0];
637 out[didx++] = UUEncMap[0];
641 memcpy(out.data()+didx, nl, nl_len);
645 if ( didx != out.size() )
655 in.resize( str.length() );
656 memcpy( in.data(), str.data(), str.length() );
664 return TQCString( out.data(), out.size()+1 );
673 unsigned int sidx = 0;
674 unsigned int didx = 0;
675 unsigned int len = in.size();
676 unsigned int line_len, end;
677 const char* data = in.data();
680 unsigned int count = 0;
681 while ( count < len && (data[count] ==
'\n' || data[count] ==
'\r' ||
682 data[count] ==
'\t' || data[count] ==
' ') )
686 if ( strncasecmp( data+count,
"begin", 5) == 0 )
689 while ( count < len && data[count] !=
'\n' && data[count] !=
'\r' )
692 while ( count < len && (data[count] ==
'\n' || data[count] ==
'\r') )
700 out.resize( len/4*3 );
704 line_len = UUDecMap[ (
unsigned char) data[sidx++]];
711 A = UUDecMap[(
unsigned char) data[sidx]];
712 B = UUDecMap[(
unsigned char) data[sidx+1]];
713 C = UUDecMap[(
unsigned char) data[sidx+2]];
714 D = UUDecMap[(
unsigned char) data[sidx+3]];
715 out[didx++] = ( ((A << 2) & 255) | ((B >> 4) & 003) );
716 out[didx++] = ( ((B << 4) & 255) | ((C >> 2) & 017) );
717 out[didx++] = ( ((C << 6) & 255) | (D & 077) );
724 A = UUDecMap[(
unsigned char) data[sidx]];
725 B = UUDecMap[(
unsigned char) data[sidx+1]];
726 out[didx++] = ( ((A << 2) & 255) | ((B >> 4) & 003) );
731 B = UUDecMap[(
unsigned char) data[sidx+1]];
732 C = UUDecMap[(
unsigned char) data[sidx+2]];
733 out[didx++] = ( ((B << 4) & 255) | ((C >> 2) & 017) );
737 while (sidx < len && data[sidx] !=
'\n' && data[sidx] !=
'\r')
741 while (sidx < len && (data[sidx] ==
'\n' || data[sidx] ==
'\r'))
745 if ( hasLF && strncasecmp( data+sidx,
"end", 3) == 0 )
749 if ( didx < out.size() )
759 KMD5::KMD5(
const char *in,
int len)
765 KMD5::KMD5(
const TQByteArray& in)
771 KMD5::KMD5(
const TQCString& in)
779 update(in.data(), int(in.size()));
784 update(in.data(), int(in.length()));
790 len = tqstrlen(reinterpret_cast<const char*>(in));
796 kdWarning() <<
"KMD5::update called after state was finalized!" <<
endl;
801 TQ_UINT32 buffer_index;
802 TQ_UINT32 buffer_space;
803 TQ_UINT32 in_length =
static_cast<TQ_UINT32
>( len );
805 buffer_index =
static_cast<TQ_UINT32
>((m_count[0] >> 3) & 0x3F);
807 if ( (m_count[0] += (in_length << 3))<(in_length << 3) )
810 m_count[1] += (in_length >> 29);
811 buffer_space = 64 - buffer_index;
813 if (in_length >= buffer_space)
815 memcpy (m_buffer + buffer_index, in, buffer_space);
818 for (in_index = buffer_space; in_index + 63 < in_length;
820 transform (reinterpret_cast<const unsigned char*>(in+in_index));
827 memcpy(m_buffer+buffer_index, in+in_index, in_length-in_index);
835 while ((len=file.readBlock(reinterpret_cast<char*>(buffer),
sizeof(buffer))) > 0)
843 if (m_finalized)
return;
846 TQ_UINT32 index, padLen;
847 static const unsigned char PADDING[64]=
849 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
850 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
851 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
852 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
855 encode (bits, m_count, 8);
859 index =
static_cast<TQ_UINT32
>((m_count[0] >> 3) & 0x3f);
860 padLen = (index < 56) ? (56 - index) : (120 - index);
861 update (reinterpret_cast<const char*>(PADDING), padLen);
864 update (reinterpret_cast<const char*>(bits), 8);
867 encode (m_digest, m_state, 16);
871 memset ( (
void *)m_buffer, 0,
sizeof(*m_buffer));
880 return (0 == memcmp(
rawDigest(), digest,
sizeof(KMD5::Digest)));
886 return (0 == strcmp(
hexDigest().data(), hexdigest));
898 memcpy( bin, m_digest, 16 );
907 sprintf(s.data(),
"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
908 m_digest[0], m_digest[1], m_digest[2], m_digest[3], m_digest[4], m_digest[5],
909 m_digest[6], m_digest[7], m_digest[8], m_digest[9], m_digest[10], m_digest[11],
910 m_digest[12], m_digest[13], m_digest[14], m_digest[15]);
919 sprintf(s.data(),
"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
920 m_digest[0], m_digest[1], m_digest[2], m_digest[3], m_digest[4], m_digest[5],
921 m_digest[6], m_digest[7], m_digest[8], m_digest[9], m_digest[10], m_digest[11],
922 m_digest[12], m_digest[13], m_digest[14], m_digest[15]);
930 memcpy(ba.data(), m_digest, 16);
948 m_state[0] = 0x67452301;
949 m_state[1] = 0xefcdab89;
950 m_state[2] = 0x98badcfe;
951 m_state[3] = 0x10325476;
953 memset ( m_buffer, 0,
sizeof(*m_buffer));
954 memset ( m_digest, 0,
sizeof(*m_digest));
960 TQ_UINT32 a = m_state[0], b = m_state[1], c = m_state[2], d = m_state[3], x[16];
962 decode (x, block, 64);
965 Q_ASSERT(!m_finalized);
968 FF (a, b, c, d, x[ 0], KMD5_S11, 0xd76aa478);
969 FF (d, a, b, c, x[ 1], KMD5_S12, 0xe8c7b756);
970 FF (c, d, a, b, x[ 2], KMD5_S13, 0x242070db);
971 FF (b, c, d, a, x[ 3], KMD5_S14, 0xc1bdceee);
972 FF (a, b, c, d, x[ 4], KMD5_S11, 0xf57c0faf);
973 FF (d, a, b, c, x[ 5], KMD5_S12, 0x4787c62a);
974 FF (c, d, a, b, x[ 6], KMD5_S13, 0xa8304613);
975 FF (b, c, d, a, x[ 7], KMD5_S14, 0xfd469501);
976 FF (a, b, c, d, x[ 8], KMD5_S11, 0x698098d8);
977 FF (d, a, b, c, x[ 9], KMD5_S12, 0x8b44f7af);
978 FF (c, d, a, b, x[10], KMD5_S13, 0xffff5bb1);
979 FF (b, c, d, a, x[11], KMD5_S14, 0x895cd7be);
980 FF (a, b, c, d, x[12], KMD5_S11, 0x6b901122);
981 FF (d, a, b, c, x[13], KMD5_S12, 0xfd987193);
982 FF (c, d, a, b, x[14], KMD5_S13, 0xa679438e);
983 FF (b, c, d, a, x[15], KMD5_S14, 0x49b40821);
986 GG (a, b, c, d, x[ 1], KMD5_S21, 0xf61e2562);
987 GG (d, a, b, c, x[ 6], KMD5_S22, 0xc040b340);
988 GG (c, d, a, b, x[11], KMD5_S23, 0x265e5a51);
989 GG (b, c, d, a, x[ 0], KMD5_S24, 0xe9b6c7aa);
990 GG (a, b, c, d, x[ 5], KMD5_S21, 0xd62f105d);
991 GG (d, a, b, c, x[10], KMD5_S22, 0x2441453);
992 GG (c, d, a, b, x[15], KMD5_S23, 0xd8a1e681);
993 GG (b, c, d, a, x[ 4], KMD5_S24, 0xe7d3fbc8);
994 GG (a, b, c, d, x[ 9], KMD5_S21, 0x21e1cde6);
995 GG (d, a, b, c, x[14], KMD5_S22, 0xc33707d6);
996 GG (c, d, a, b, x[ 3], KMD5_S23, 0xf4d50d87);
997 GG (b, c, d, a, x[ 8], KMD5_S24, 0x455a14ed);
998 GG (a, b, c, d, x[13], KMD5_S21, 0xa9e3e905);
999 GG (d, a, b, c, x[ 2], KMD5_S22, 0xfcefa3f8);
1000 GG (c, d, a, b, x[ 7], KMD5_S23, 0x676f02d9);
1001 GG (b, c, d, a, x[12], KMD5_S24, 0x8d2a4c8a);
1004 HH (a, b, c, d, x[ 5], KMD5_S31, 0xfffa3942);
1005 HH (d, a, b, c, x[ 8], KMD5_S32, 0x8771f681);
1006 HH (c, d, a, b, x[11], KMD5_S33, 0x6d9d6122);
1007 HH (b, c, d, a, x[14], KMD5_S34, 0xfde5380c);
1008 HH (a, b, c, d, x[ 1], KMD5_S31, 0xa4beea44);
1009 HH (d, a, b, c, x[ 4], KMD5_S32, 0x4bdecfa9);
1010 HH (c, d, a, b, x[ 7], KMD5_S33, 0xf6bb4b60);
1011 HH (b, c, d, a, x[10], KMD5_S34, 0xbebfbc70);
1012 HH (a, b, c, d, x[13], KMD5_S31, 0x289b7ec6);
1013 HH (d, a, b, c, x[ 0], KMD5_S32, 0xeaa127fa);
1014 HH (c, d, a, b, x[ 3], KMD5_S33, 0xd4ef3085);
1015 HH (b, c, d, a, x[ 6], KMD5_S34, 0x4881d05);
1016 HH (a, b, c, d, x[ 9], KMD5_S31, 0xd9d4d039);
1017 HH (d, a, b, c, x[12], KMD5_S32, 0xe6db99e5);
1018 HH (c, d, a, b, x[15], KMD5_S33, 0x1fa27cf8);
1019 HH (b, c, d, a, x[ 2], KMD5_S34, 0xc4ac5665);
1022 II (a, b, c, d, x[ 0], KMD5_S41, 0xf4292244);
1023 II (d, a, b, c, x[ 7], KMD5_S42, 0x432aff97);
1024 II (c, d, a, b, x[14], KMD5_S43, 0xab9423a7);
1025 II (b, c, d, a, x[ 5], KMD5_S44, 0xfc93a039);
1026 II (a, b, c, d, x[12], KMD5_S41, 0x655b59c3);
1027 II (d, a, b, c, x[ 3], KMD5_S42, 0x8f0ccc92);
1028 II (c, d, a, b, x[10], KMD5_S43, 0xffeff47d);
1029 II (b, c, d, a, x[ 1], KMD5_S44, 0x85845dd1);
1030 II (a, b, c, d, x[ 8], KMD5_S41, 0x6fa87e4f);
1031 II (d, a, b, c, x[15], KMD5_S42, 0xfe2ce6e0);
1032 II (c, d, a, b, x[ 6], KMD5_S43, 0xa3014314);
1033 II (b, c, d, a, x[13], KMD5_S44, 0x4e0811a1);
1034 II (a, b, c, d, x[ 4], KMD5_S41, 0xf7537e82);
1035 II (d, a, b, c, x[11], KMD5_S42, 0xbd3af235);
1036 II (c, d, a, b, x[ 2], KMD5_S43, 0x2ad7d2bb);
1037 II (b, c, d, a, x[ 9], KMD5_S44, 0xeb86d391);
1044 memset ( static_cast<void *>(x), 0,
sizeof(x) );
1047 inline TQ_UINT32 KMD5::rotate_left (TQ_UINT32 x, TQ_UINT32 n)
1049 return (x << n) | (x >> (32-n)) ;
1052 inline TQ_UINT32 KMD5::F (TQ_UINT32 x, TQ_UINT32 y, TQ_UINT32 z)
1054 return (x & y) | (~x & z);
1057 inline TQ_UINT32 KMD5::G (TQ_UINT32 x, TQ_UINT32 y, TQ_UINT32 z)
1059 return (x & z) | (y & ~z);
1062 inline TQ_UINT32 KMD5::H (TQ_UINT32 x, TQ_UINT32 y, TQ_UINT32 z)
1067 inline TQ_UINT32 KMD5::I (TQ_UINT32 x, TQ_UINT32 y, TQ_UINT32 z)
1069 return y ^ (x | ~z);
1072 void KMD5::FF ( TQ_UINT32& a, TQ_UINT32 b, TQ_UINT32 c, TQ_UINT32 d,
1073 TQ_UINT32 x, TQ_UINT32 s, TQ_UINT32 ac )
1075 a += F(b, c, d) + x + ac;
1076 a = rotate_left (a, s) +b;
1079 void KMD5::GG ( TQ_UINT32& a, TQ_UINT32 b, TQ_UINT32 c, TQ_UINT32 d,
1080 TQ_UINT32 x, TQ_UINT32 s, TQ_UINT32 ac)
1082 a += G(b, c, d) + x + ac;
1083 a = rotate_left (a, s) +b;
1086 void KMD5::HH ( TQ_UINT32& a, TQ_UINT32 b, TQ_UINT32 c, TQ_UINT32 d,
1087 TQ_UINT32 x, TQ_UINT32 s, TQ_UINT32 ac )
1089 a += H(b, c, d) + x + ac;
1090 a = rotate_left (a, s) +b;
1093 void KMD5::II ( TQ_UINT32& a, TQ_UINT32 b, TQ_UINT32 c, TQ_UINT32 d,
1094 TQ_UINT32 x, TQ_UINT32 s, TQ_UINT32 ac )
1096 a += I(b, c, d) + x + ac;
1097 a = rotate_left (a, s) +b;
1101 void KMD5::encode (
unsigned char* output, TQ_UINT32 *in, TQ_UINT32 len )
1103 #if !defined(WORDS_BIGENDIAN)
1104 memcpy(output, in, len);
1108 for (i = 0, j = 0; j < len; i++, j += 4)
1110 output[j] =
static_cast<TQ_UINT8
>((in[i] & 0xff));
1111 output[j+1] =
static_cast<TQ_UINT8
>(((in[i] >> 8) & 0xff));
1112 output[j+2] =
static_cast<TQ_UINT8
>(((in[i] >> 16) & 0xff));
1113 output[j+3] =
static_cast<TQ_UINT8
>(((in[i] >> 24) & 0xff));
1120 void KMD5::decode (TQ_UINT32 *output,
const unsigned char* in, TQ_UINT32 len)
1122 #if !defined(WORDS_BIGENDIAN)
1123 memcpy(output, in, len);
1127 for (i = 0, j = 0; j < len; i++, j += 4)
1128 output[i] = static_cast<TQ_UINT32>(in[j]) |
1129 (
static_cast<TQ_UINT32
>(in[j+1]) << 8) |
1130 (
static_cast<TQ_UINT32
>(in[j+2]) << 16) |
1131 (
static_cast<TQ_UINT32
>(in[j+3]) << 24);
1148 KMD4::KMD4(
const char *in,
int len)
1154 KMD4::KMD4(
const TQByteArray& in)
1160 KMD4::KMD4(
const TQCString& in)
1168 update(in.data(), int(in.size()));
1173 update(in.data(), int(in.length()));
1183 len = tqstrlen(reinterpret_cast<const char*>(in));
1189 kdWarning() <<
"KMD4::update called after state was finalized!" <<
endl;
1198 if ((m_count[0] = t + ((TQ_UINT32) len << 3)) < t)
1200 m_count[1] += len >> 29;
1202 t = (t >> 3) & 0x3f;
1208 TQ_UINT8 *p = &m_buffer[ t ];
1211 if ((TQ_UINT32)len < t)
1213 memcpy (p, in, len);
1217 byteReverse (m_buffer, 16);
1218 transform (m_state, (TQ_UINT32*) m_buffer);
1226 memcpy (m_buffer, in, 64);
1227 byteReverse (m_buffer, 16);
1228 transform (m_state, (TQ_UINT32 *) m_buffer);
1235 memcpy (m_buffer, in, len);
1243 while ((len=file.readBlock(reinterpret_cast<char*>(buffer),
sizeof(buffer))) > 0)
1246 return file.atEnd();
1259 count = (m_count[0] >> 3) & 0x3F;
1263 p = m_buffer + count;
1267 count = 64 - 1 - count;
1273 memset (p, 0, count);
1274 byteReverse (m_buffer, 16);
1275 transform (m_state, (TQ_UINT32*) m_buffer);
1278 memset (m_buffer, 0, 56);
1283 memset (p, 0, count - 8);
1285 byteReverse (m_buffer, 14);
1288 ((TQ_UINT32 *) m_buffer)[14] = m_count[0];
1289 ((TQ_UINT32 *) m_buffer)[15] = m_count[1];
1291 transform (m_state, (TQ_UINT32 *) m_buffer);
1292 byteReverse ((
unsigned char *) m_state, 4);
1294 memcpy (m_digest, m_state, 16);
1295 memset ( (
void *)m_buffer, 0,
sizeof(*m_buffer));
1303 return (0 == memcmp(
rawDigest(), digest,
sizeof(KMD4::Digest)));
1309 return (0 == strcmp(
hexDigest().data(), hexdigest));
1321 memcpy( bin, m_digest, 16 );
1329 sprintf(s.data(),
"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
1330 m_digest[0], m_digest[1], m_digest[2], m_digest[3], m_digest[4], m_digest[5],
1331 m_digest[6], m_digest[7], m_digest[8], m_digest[9], m_digest[10], m_digest[11],
1332 m_digest[12], m_digest[13], m_digest[14], m_digest[15]);
1341 sprintf(s.data(),
"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
1342 m_digest[0], m_digest[1], m_digest[2], m_digest[3], m_digest[4], m_digest[5],
1343 m_digest[6], m_digest[7], m_digest[8], m_digest[9], m_digest[10], m_digest[11],
1344 m_digest[12], m_digest[13], m_digest[14], m_digest[15]);
1352 memcpy(ba.data(), m_digest, 16);
1369 m_finalized =
false;
1371 m_state[0] = 0x67452301;
1372 m_state[1] = 0xefcdab89;
1373 m_state[2] = 0x98badcfe;
1374 m_state[3] = 0x10325476;
1379 memset ( m_buffer, 0,
sizeof(*m_buffer));
1380 memset ( m_digest, 0,
sizeof(*m_digest));
1385 inline TQ_UINT32 KMD4::rotate_left (TQ_UINT32 x, TQ_UINT32 n)
1387 return (x << n) | (x >> (32-n)) ;
1390 inline TQ_UINT32 KMD4::F (TQ_UINT32 x, TQ_UINT32 y, TQ_UINT32 z)
1392 return (x & y) | (~x & z);
1395 inline TQ_UINT32 KMD4::G (TQ_UINT32 x, TQ_UINT32 y, TQ_UINT32 z)
1397 return ((x) & (y)) | ((x) & (z)) | ((y) & (z));
1400 inline TQ_UINT32 KMD4::H (TQ_UINT32 x, TQ_UINT32 y, TQ_UINT32 z)
1405 inline void KMD4::FF ( TQ_UINT32& a, TQ_UINT32 b, TQ_UINT32 c, TQ_UINT32 d,
1406 TQ_UINT32 x, TQ_UINT32 s )
1408 a += F(b, c, d) + x;
1409 a = rotate_left (a, s);
1412 inline void KMD4::GG ( TQ_UINT32& a, TQ_UINT32 b, TQ_UINT32 c, TQ_UINT32 d,
1413 TQ_UINT32 x, TQ_UINT32 s)
1415 a += G(b, c, d) + x + (TQ_UINT32)0x5a827999;
1416 a = rotate_left (a, s);
1419 inline void KMD4::HH ( TQ_UINT32& a, TQ_UINT32 b, TQ_UINT32 c, TQ_UINT32 d,
1420 TQ_UINT32 x, TQ_UINT32 s )
1422 a += H(b, c, d) + x + (TQ_UINT32)0x6ed9eba1;
1423 a = rotate_left (a, s);
1426 void KMD4::byteReverse(
unsigned char *buf, TQ_UINT32 len )
1428 #ifdef WORDS_BIGENDIAN
1429 TQ_UINT32 *b = (TQ_UINT32*) buf;
1431 *b = ((((*b) & 0xff000000) >> 24) | (((*b) & 0x00ff0000) >> 8) |
1432 (((*b) & 0x0000ff00) << 8) | (((*b) & 0x000000ff) << 24));
1447 TQ_UINT32 a, b, c, d;
1454 FF (a, b, c, d, in[0], 3);
1455 FF (d, a, b, c, in[1], 7);
1456 FF (c, d, a, b, in[2], 11);
1457 FF (b, c, d, a, in[3], 19);
1458 FF (a, b, c, d, in[4], 3);
1459 FF (d, a, b, c, in[5], 7);
1460 FF (c, d, a, b, in[6], 11);
1461 FF (b, c, d, a, in[7], 19);
1462 FF (a, b, c, d, in[8], 3);
1463 FF (d, a, b, c, in[9], 7);
1464 FF (c, d, a, b, in[10], 11);
1465 FF (b, c, d, a, in[11], 19);
1466 FF (a, b, c, d, in[12], 3);
1467 FF (d, a, b, c, in[13], 7);
1468 FF (c, d, a, b, in[14], 11);
1469 FF (b, c, d, a, in[15], 19);
1471 GG (a, b, c, d, in[0], 3);
1472 GG (d, a, b, c, in[4], 5);
1473 GG (c, d, a, b, in[8], 9);
1474 GG (b, c, d, a, in[12], 13);
1475 GG (a, b, c, d, in[1], 3);
1476 GG (d, a, b, c, in[5], 5);
1477 GG (c, d, a, b, in[9], 9);
1478 GG (b, c, d, a, in[13], 13);
1479 GG (a, b, c, d, in[2], 3);
1480 GG (d, a, b, c, in[6], 5);
1481 GG (c, d, a, b, in[10], 9);
1482 GG (b, c, d, a, in[14], 13);
1483 GG (a, b, c, d, in[3], 3);
1484 GG (d, a, b, c, in[7], 5);
1485 GG (c, d, a, b, in[11], 9);
1486 GG (b, c, d, a, in[15], 13);
1488 HH (a, b, c, d, in[0], 3);
1489 HH (d, a, b, c, in[8], 9);
1490 HH (c, d, a, b, in[4], 11);
1491 HH (b, c, d, a, in[12], 15);
1492 HH (a, b, c, d, in[2], 3);
1493 HH (d, a, b, c, in[10], 9);
1494 HH (c, d, a, b, in[6], 11);
1495 HH (b, c, d, a, in[14], 15);
1496 HH (a, b, c, d, in[1], 3);
1497 HH (d, a, b, c, in[9], 9);
1498 HH (c, d, a, b, in[5], 11);
1499 HH (b, c, d, a, in[13], 15);
1500 HH (a, b, c, d, in[3], 3);
1501 HH (d, a, b, c, in[11], 9);
1502 HH (c, d, a, b, in[7], 11);
1503 HH (b, c, d, a, in[15], 15);