File indexing completed on 2024-06-23 03:58:18

 /*
     This file is part of the KDE project
     SPDX-FileCopyrightText: 2001 George Staikos <staikos@kde.org>
 
     Based heavily on SHA1 code from GPG 1.0.3:
     SPDX-FileCopyrightText: 1998 FSF
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "sha1.h"
 
 #include <config-kwalletbackend.h>
 
 // DO NOT INCLUDE THIS. IT BREAKS KWALLET.
 // We need to live with -Wundef until someone really figures out the problem.
 //#include <QtCore/qglobal.h> // for Q_BYTE_ORDER and friends
 // Workaround for -Wundef
 #define Q_BIG_ENDIAN 1
 #define Q_BYTE_ORDER Q_BIG_ENDIAN
 
 #include <sys/types.h>
 #if HAVE_SYS_BITYPES_H
 #include <sys/bitypes.h> /* For uintXX_t on Tru64 */
 #endif
 #if HAVE_STDINT_H
 #include <stdint.h>
 #endif
 
 #include <string.h>
 
 // clang-format off
 // FIXME: this can be optimized to one instruction on most cpus.
 #define rol(x,y) ((x << y) | (x >> (32-y)))
 
 #define K1 0x5a827999L
 #define K2 0x6ed9eba1L
 #define K3 0x8f1bbcdcL
 #define K4 0xca62c1d6L
 #define F1(x,y,z) ( z ^ ( x & ( y ^ z ) ) )
 #define F2(x,y,z) ( x ^ y ^ z )
 #define F3(x,y,z) ( ( x & y ) | ( z & ( x | y ) ) )
 #define F4(x,y,z) ( x ^ y ^ z )
 
 #define M(i) ( tm = x[i&0x0f] ^ x[(i-14)&0x0f]            \
                     ^ x[(i-8)&0x0f] ^ x[(i-3)&0x0f]         \
                     , (x[i&0x0f] = (tm << 1) | (tm >> 31)))
 
 #define R(a,b,c,d,e,f,k,m)   do { e += rol(a, 5)          \
                                            +  f(b, c, d)         \
                                            +  k                  \
                                            +  m;                 \
     b  = rol(b, 30);        \
 } while(0)
 // clang-format on
 
 SHA1::SHA1()
 {
     _hashlen = 160;
     _init = false;
     reset();
 }
 
 int SHA1::reset()
 {
     _h0 = 0x67452301;
     _h1 = 0xefcdab89;
     _h2 = 0x98badcfe;
     _h3 = 0x10325476;
     _h4 = 0xc3d2e1f0;
     _nblocks = 0;
     _count = 0;
     memset(_buf, 0, 56);      // clear the buffer
 
     _init = true;
     return 0;
 }
 
 int SHA1::size() const
 {
     return _hashlen;
 }
 
 SHA1::~SHA1()
 {
 
 }
 
 void SHA1::transform(void *data)
 {
     unsigned int a;
     unsigned int b;
     unsigned int c;
     unsigned int d;
     unsigned int e;
     unsigned int tm;
     unsigned int x[16];
     unsigned char *_data = (unsigned char *)data;
 
     a = _h0;
     b = _h1;
     c = _h2;
     d = _h3;
     e = _h4;
 
 #if Q_BYTE_ORDER == Q_BIG_ENDIAN
     memcpy(x, _data, 64);
 #else
     int i;
     unsigned char *p2;
     for (i = 0, p2 = (unsigned char *)x;
             i < 16; i++, p2 += 4) {
         p2[3] = *_data++;
         p2[2] = *_data++;
         p2[1] = *_data++;
         p2[0] = *_data++;
     }
 #endif
 
     R(a, b, c, d, e, F1, K1, x[ 0]);
     R(e, a, b, c, d, F1, K1, x[ 1]);
     R(d, e, a, b, c, F1, K1, x[ 2]);
     R(c, d, e, a, b, F1, K1, x[ 3]);
     R(b, c, d, e, a, F1, K1, x[ 4]);
     R(a, b, c, d, e, F1, K1, x[ 5]);
     R(e, a, b, c, d, F1, K1, x[ 6]);
     R(d, e, a, b, c, F1, K1, x[ 7]);
     R(c, d, e, a, b, F1, K1, x[ 8]);
     R(b, c, d, e, a, F1, K1, x[ 9]);
     R(a, b, c, d, e, F1, K1, x[10]);
     R(e, a, b, c, d, F1, K1, x[11]);
     R(d, e, a, b, c, F1, K1, x[12]);
     R(c, d, e, a, b, F1, K1, x[13]);
     R(b, c, d, e, a, F1, K1, x[14]);
     R(a, b, c, d, e, F1, K1, x[15]);
     R(e, a, b, c, d, F1, K1, M(16));
     R(d, e, a, b, c, F1, K1, M(17));
     R(c, d, e, a, b, F1, K1, M(18));
     R(b, c, d, e, a, F1, K1, M(19));
     R(a, b, c, d, e, F2, K2, M(20));
     R(e, a, b, c, d, F2, K2, M(21));
     R(d, e, a, b, c, F2, K2, M(22));
     R(c, d, e, a, b, F2, K2, M(23));
     R(b, c, d, e, a, F2, K2, M(24));
     R(a, b, c, d, e, F2, K2, M(25));
     R(e, a, b, c, d, F2, K2, M(26));
     R(d, e, a, b, c, F2, K2, M(27));
     R(c, d, e, a, b, F2, K2, M(28));
     R(b, c, d, e, a, F2, K2, M(29));
     R(a, b, c, d, e, F2, K2, M(30));
     R(e, a, b, c, d, F2, K2, M(31));
     R(d, e, a, b, c, F2, K2, M(32));
     R(c, d, e, a, b, F2, K2, M(33));
     R(b, c, d, e, a, F2, K2, M(34));
     R(a, b, c, d, e, F2, K2, M(35));
     R(e, a, b, c, d, F2, K2, M(36));
     R(d, e, a, b, c, F2, K2, M(37));
     R(c, d, e, a, b, F2, K2, M(38));
     R(b, c, d, e, a, F2, K2, M(39));
     R(a, b, c, d, e, F3, K3, M(40));
     R(e, a, b, c, d, F3, K3, M(41));
     R(d, e, a, b, c, F3, K3, M(42));
     R(c, d, e, a, b, F3, K3, M(43));
     R(b, c, d, e, a, F3, K3, M(44));
     R(a, b, c, d, e, F3, K3, M(45));
     R(e, a, b, c, d, F3, K3, M(46));
     R(d, e, a, b, c, F3, K3, M(47));
     R(c, d, e, a, b, F3, K3, M(48));
     R(b, c, d, e, a, F3, K3, M(49));
     R(a, b, c, d, e, F3, K3, M(50));
     R(e, a, b, c, d, F3, K3, M(51));
     R(d, e, a, b, c, F3, K3, M(52));
     R(c, d, e, a, b, F3, K3, M(53));
     R(b, c, d, e, a, F3, K3, M(54));
     R(a, b, c, d, e, F3, K3, M(55));
     R(e, a, b, c, d, F3, K3, M(56));
     R(d, e, a, b, c, F3, K3, M(57));
     R(c, d, e, a, b, F3, K3, M(58));
     R(b, c, d, e, a, F3, K3, M(59));
     R(a, b, c, d, e, F4, K4, M(60));
     R(e, a, b, c, d, F4, K4, M(61));
     R(d, e, a, b, c, F4, K4, M(62));
     R(c, d, e, a, b, F4, K4, M(63));
     R(b, c, d, e, a, F4, K4, M(64));
     R(a, b, c, d, e, F4, K4, M(65));
     R(e, a, b, c, d, F4, K4, M(66));
     R(d, e, a, b, c, F4, K4, M(67));
     R(c, d, e, a, b, F4, K4, M(68));
     R(b, c, d, e, a, F4, K4, M(69));
     R(a, b, c, d, e, F4, K4, M(70));
     R(e, a, b, c, d, F4, K4, M(71));
     R(d, e, a, b, c, F4, K4, M(72));
     R(c, d, e, a, b, F4, K4, M(73));
     R(b, c, d, e, a, F4, K4, M(74));
     R(a, b, c, d, e, F4, K4, M(75));
     R(e, a, b, c, d, F4, K4, M(76));
     R(d, e, a, b, c, F4, K4, M(77));
     R(c, d, e, a, b, F4, K4, M(78));
     R(b, c, d, e, a, F4, K4, M(79));
 
     _h0 += a;
     _h1 += b;
     _h2 += c;
     _h3 += d;
     _h4 += e;
 
 }
 
 bool SHA1::readyToGo() const
 {
     return _init;
 }
 
 int SHA1::process(const void *block, int len)
 {
     if (!_init) {
         return -1;
     }
 
     unsigned char *_block = (unsigned char *)block;
 
     int cnt = 0;
     // Flush the buffer before proceeding
     if (_count == 64) {
         transform(_buf);
         _count = 0;
         _nblocks++;
     }
 
     if (!_block) {
         return 0;
     }
 
     if (_count) {
         for (; len && _count < 64; --len, ++cnt) {
             _buf[_count++] = *_block++;
         }
         process(nullptr, 0);       // flush the buffer if necessary
         if (!len) {
             return cnt;
         }
     }
 
     while (len >= 64) {
         transform(_block);
         _count = 0;
         _nblocks++;
         len -= 64;
         cnt += 64;
         _block += 64;
     }
 
     for (; len && _count < 64; --len, ++cnt) {
         _buf[_count++] = *_block++;
     }
 
     return cnt;
 }
 
 const unsigned char *SHA1::hash()
 {
     unsigned int t;
     unsigned int msb;
     unsigned int lsb;
     unsigned char *p;
 
     if (!_init) {
         return (unsigned char *)_buf;
     }
 
     process(nullptr, 0);
 
     msb = 0;
     t = _nblocks;
 
     if ((lsb = t << 6) < t) {
         msb++;
     }
 
     msb += t >> 26;
     t = lsb;
 
     if ((lsb = t + _count) < t) {
         msb++;
     }
 
     t = lsb;
 
     if ((lsb = t << 3) < t) {
         msb++;
     }
 
     msb += t >> 29;
 
     _buf[_count++] = 0x80;
 
     if (_count < 56) {
         while (_count < 56) {
             _buf[_count++] = 0;
         }
     } else {
         while (_count < 64) {
             _buf[_count++] = 0;
         }
         process(nullptr, 0);
         memset(_buf, 0, 56);
     }
 
     _buf[56] = msb >> 24;
     _buf[57] = msb >> 16;
     _buf[58] = msb >>  8;
     _buf[59] = msb;
     _buf[60] = lsb >> 24;
     _buf[61] = lsb >> 16;
     _buf[62] = lsb >>  8;
     _buf[63] = lsb;
 
     transform(_buf);
 
     p = _buf;
 // clang-format off
 #if Q_BYTE_ORDER == Q_BIG_ENDIAN
 #define X(a) do { *(uint32_t *)p = _h##a; p += 4; } while (0)
 #else
 #define X(a) do { *p++ = _h##a >> 24;  *p++ = _h##a >> 16;             \
         *p++ = _h##a >>  8;  *p++ = _h##a;        } while (0)
 #endif
 // clang-format on
 
     X(0);
     X(1);
     X(2);
     X(3);
     X(4);
 
 #undef X
 
     _init = false;
 
     return (unsigned char *)_buf;
 }