File indexing completed on 2024-06-16 03:53:04

0001 /*
0002     This file is part of the KDE project
0003     SPDX-FileCopyrightText: 2001 George Staikos <staikos@kde.org>
0004 
0005     Based heavily on SHA1 code from GPG 1.0.3:
0006     SPDX-FileCopyrightText: 1998 FSF
0007 
0008     SPDX-License-Identifier: LGPL-2.0-or-later
0009 */
0010 
0011 #include "sha1.h"
0012 
0013 #include <config-kwalletbackend.h>
0014 
0015 // DO NOT INCLUDE THIS. IT BREAKS KWALLET.
0016 // We need to live with -Wundef until someone really figures out the problem.
0017 //#include <QtCore/qglobal.h> // for Q_BYTE_ORDER and friends
0018 // Workaround for -Wundef
0019 #define Q_BIG_ENDIAN 1
0020 #define Q_BYTE_ORDER Q_BIG_ENDIAN
0021 
0022 #include <sys/types.h>
0023 #if HAVE_SYS_BITYPES_H
0024 #include <sys/bitypes.h> /* For uintXX_t on Tru64 */
0025 #endif
0026 #if HAVE_STDINT_H
0027 #include <stdint.h>
0028 #endif
0029 
0030 #include <string.h>
0031 
0032 // clang-format off
0033 // FIXME: this can be optimized to one instruction on most cpus.
0034 #define rol(x,y) ((x << y) | (x >> (32-y)))
0035 
0036 #define K1 0x5a827999L
0037 #define K2 0x6ed9eba1L
0038 #define K3 0x8f1bbcdcL
0039 #define K4 0xca62c1d6L
0040 #define F1(x,y,z) ( z ^ ( x & ( y ^ z ) ) )
0041 #define F2(x,y,z) ( x ^ y ^ z )
0042 #define F3(x,y,z) ( ( x & y ) | ( z & ( x | y ) ) )
0043 #define F4(x,y,z) ( x ^ y ^ z )
0044 
0045 #define M(i) ( tm = x[i&0x0f] ^ x[(i-14)&0x0f]            \
0046                     ^ x[(i-8)&0x0f] ^ x[(i-3)&0x0f]         \
0047                     , (x[i&0x0f] = (tm << 1) | (tm >> 31)))
0048 
0049 #define R(a,b,c,d,e,f,k,m)   do { e += rol(a, 5)          \
0050                                            +  f(b, c, d)         \
0051                                            +  k                  \
0052                                            +  m;                 \
0053     b  = rol(b, 30);        \
0054 } while(0)
0055 // clang-format on
0056 
0057 SHA1::SHA1()
0058 {
0059     _hashlen = 160;
0060     _init = false;
0061     reset();
0062 }
0063 
0064 int SHA1::reset()
0065 {
0066     _h0 = 0x67452301;
0067     _h1 = 0xefcdab89;
0068     _h2 = 0x98badcfe;
0069     _h3 = 0x10325476;
0070     _h4 = 0xc3d2e1f0;
0071     _nblocks = 0;
0072     _count = 0;
0073     memset(_buf, 0, 56);      // clear the buffer
0074 
0075     _init = true;
0076     return 0;
0077 }
0078 
0079 int SHA1::size() const
0080 {
0081     return _hashlen;
0082 }
0083 
0084 SHA1::~SHA1()
0085 {
0086 
0087 }
0088 
0089 void SHA1::transform(void *data)
0090 {
0091     unsigned int a;
0092     unsigned int b;
0093     unsigned int c;
0094     unsigned int d;
0095     unsigned int e;
0096     unsigned int tm;
0097     unsigned int x[16];
0098     unsigned char *_data = (unsigned char *)data;
0099 
0100     a = _h0;
0101     b = _h1;
0102     c = _h2;
0103     d = _h3;
0104     e = _h4;
0105 
0106 #if Q_BYTE_ORDER == Q_BIG_ENDIAN
0107     memcpy(x, _data, 64);
0108 #else
0109     int i;
0110     unsigned char *p2;
0111     for (i = 0, p2 = (unsigned char *)x;
0112             i < 16; i++, p2 += 4) {
0113         p2[3] = *_data++;
0114         p2[2] = *_data++;
0115         p2[1] = *_data++;
0116         p2[0] = *_data++;
0117     }
0118 #endif
0119 
0120     R(a, b, c, d, e, F1, K1, x[ 0]);
0121     R(e, a, b, c, d, F1, K1, x[ 1]);
0122     R(d, e, a, b, c, F1, K1, x[ 2]);
0123     R(c, d, e, a, b, F1, K1, x[ 3]);
0124     R(b, c, d, e, a, F1, K1, x[ 4]);
0125     R(a, b, c, d, e, F1, K1, x[ 5]);
0126     R(e, a, b, c, d, F1, K1, x[ 6]);
0127     R(d, e, a, b, c, F1, K1, x[ 7]);
0128     R(c, d, e, a, b, F1, K1, x[ 8]);
0129     R(b, c, d, e, a, F1, K1, x[ 9]);
0130     R(a, b, c, d, e, F1, K1, x[10]);
0131     R(e, a, b, c, d, F1, K1, x[11]);
0132     R(d, e, a, b, c, F1, K1, x[12]);
0133     R(c, d, e, a, b, F1, K1, x[13]);
0134     R(b, c, d, e, a, F1, K1, x[14]);
0135     R(a, b, c, d, e, F1, K1, x[15]);
0136     R(e, a, b, c, d, F1, K1, M(16));
0137     R(d, e, a, b, c, F1, K1, M(17));
0138     R(c, d, e, a, b, F1, K1, M(18));
0139     R(b, c, d, e, a, F1, K1, M(19));
0140     R(a, b, c, d, e, F2, K2, M(20));
0141     R(e, a, b, c, d, F2, K2, M(21));
0142     R(d, e, a, b, c, F2, K2, M(22));
0143     R(c, d, e, a, b, F2, K2, M(23));
0144     R(b, c, d, e, a, F2, K2, M(24));
0145     R(a, b, c, d, e, F2, K2, M(25));
0146     R(e, a, b, c, d, F2, K2, M(26));
0147     R(d, e, a, b, c, F2, K2, M(27));
0148     R(c, d, e, a, b, F2, K2, M(28));
0149     R(b, c, d, e, a, F2, K2, M(29));
0150     R(a, b, c, d, e, F2, K2, M(30));
0151     R(e, a, b, c, d, F2, K2, M(31));
0152     R(d, e, a, b, c, F2, K2, M(32));
0153     R(c, d, e, a, b, F2, K2, M(33));
0154     R(b, c, d, e, a, F2, K2, M(34));
0155     R(a, b, c, d, e, F2, K2, M(35));
0156     R(e, a, b, c, d, F2, K2, M(36));
0157     R(d, e, a, b, c, F2, K2, M(37));
0158     R(c, d, e, a, b, F2, K2, M(38));
0159     R(b, c, d, e, a, F2, K2, M(39));
0160     R(a, b, c, d, e, F3, K3, M(40));
0161     R(e, a, b, c, d, F3, K3, M(41));
0162     R(d, e, a, b, c, F3, K3, M(42));
0163     R(c, d, e, a, b, F3, K3, M(43));
0164     R(b, c, d, e, a, F3, K3, M(44));
0165     R(a, b, c, d, e, F3, K3, M(45));
0166     R(e, a, b, c, d, F3, K3, M(46));
0167     R(d, e, a, b, c, F3, K3, M(47));
0168     R(c, d, e, a, b, F3, K3, M(48));
0169     R(b, c, d, e, a, F3, K3, M(49));
0170     R(a, b, c, d, e, F3, K3, M(50));
0171     R(e, a, b, c, d, F3, K3, M(51));
0172     R(d, e, a, b, c, F3, K3, M(52));
0173     R(c, d, e, a, b, F3, K3, M(53));
0174     R(b, c, d, e, a, F3, K3, M(54));
0175     R(a, b, c, d, e, F3, K3, M(55));
0176     R(e, a, b, c, d, F3, K3, M(56));
0177     R(d, e, a, b, c, F3, K3, M(57));
0178     R(c, d, e, a, b, F3, K3, M(58));
0179     R(b, c, d, e, a, F3, K3, M(59));
0180     R(a, b, c, d, e, F4, K4, M(60));
0181     R(e, a, b, c, d, F4, K4, M(61));
0182     R(d, e, a, b, c, F4, K4, M(62));
0183     R(c, d, e, a, b, F4, K4, M(63));
0184     R(b, c, d, e, a, F4, K4, M(64));
0185     R(a, b, c, d, e, F4, K4, M(65));
0186     R(e, a, b, c, d, F4, K4, M(66));
0187     R(d, e, a, b, c, F4, K4, M(67));
0188     R(c, d, e, a, b, F4, K4, M(68));
0189     R(b, c, d, e, a, F4, K4, M(69));
0190     R(a, b, c, d, e, F4, K4, M(70));
0191     R(e, a, b, c, d, F4, K4, M(71));
0192     R(d, e, a, b, c, F4, K4, M(72));
0193     R(c, d, e, a, b, F4, K4, M(73));
0194     R(b, c, d, e, a, F4, K4, M(74));
0195     R(a, b, c, d, e, F4, K4, M(75));
0196     R(e, a, b, c, d, F4, K4, M(76));
0197     R(d, e, a, b, c, F4, K4, M(77));
0198     R(c, d, e, a, b, F4, K4, M(78));
0199     R(b, c, d, e, a, F4, K4, M(79));
0200 
0201     _h0 += a;
0202     _h1 += b;
0203     _h2 += c;
0204     _h3 += d;
0205     _h4 += e;
0206 
0207 }
0208 
0209 bool SHA1::readyToGo() const
0210 {
0211     return _init;
0212 }
0213 
0214 int SHA1::process(const void *block, int len)
0215 {
0216     if (!_init) {
0217         return -1;
0218     }
0219 
0220     unsigned char *_block = (unsigned char *)block;
0221 
0222     int cnt = 0;
0223     // Flush the buffer before proceeding
0224     if (_count == 64) {
0225         transform(_buf);
0226         _count = 0;
0227         _nblocks++;
0228     }
0229 
0230     if (!_block) {
0231         return 0;
0232     }
0233 
0234     if (_count) {
0235         for (; len && _count < 64; --len, ++cnt) {
0236             _buf[_count++] = *_block++;
0237         }
0238         process(nullptr, 0);       // flush the buffer if necessary
0239         if (!len) {
0240             return cnt;
0241         }
0242     }
0243 
0244     while (len >= 64) {
0245         transform(_block);
0246         _count = 0;
0247         _nblocks++;
0248         len -= 64;
0249         cnt += 64;
0250         _block += 64;
0251     }
0252 
0253     for (; len && _count < 64; --len, ++cnt) {
0254         _buf[_count++] = *_block++;
0255     }
0256 
0257     return cnt;
0258 }
0259 
0260 const unsigned char *SHA1::hash()
0261 {
0262     unsigned int t;
0263     unsigned int msb;
0264     unsigned int lsb;
0265     unsigned char *p;
0266 
0267     if (!_init) {
0268         return (unsigned char *)_buf;
0269     }
0270 
0271     process(nullptr, 0);
0272 
0273     msb = 0;
0274     t = _nblocks;
0275 
0276     if ((lsb = t << 6) < t) {
0277         msb++;
0278     }
0279 
0280     msb += t >> 26;
0281     t = lsb;
0282 
0283     if ((lsb = t + _count) < t) {
0284         msb++;
0285     }
0286 
0287     t = lsb;
0288 
0289     if ((lsb = t << 3) < t) {
0290         msb++;
0291     }
0292 
0293     msb += t >> 29;
0294 
0295     _buf[_count++] = 0x80;
0296 
0297     if (_count < 56) {
0298         while (_count < 56) {
0299             _buf[_count++] = 0;
0300         }
0301     } else {
0302         while (_count < 64) {
0303             _buf[_count++] = 0;
0304         }
0305         process(nullptr, 0);
0306         memset(_buf, 0, 56);
0307     }
0308 
0309     _buf[56] = msb >> 24;
0310     _buf[57] = msb >> 16;
0311     _buf[58] = msb >>  8;
0312     _buf[59] = msb;
0313     _buf[60] = lsb >> 24;
0314     _buf[61] = lsb >> 16;
0315     _buf[62] = lsb >>  8;
0316     _buf[63] = lsb;
0317 
0318     transform(_buf);
0319 
0320     p = _buf;
0321 // clang-format off
0322 #if Q_BYTE_ORDER == Q_BIG_ENDIAN
0323 #define X(a) do { *(uint32_t *)p = _h##a; p += 4; } while (0)
0324 #else
0325 #define X(a) do { *p++ = _h##a >> 24;  *p++ = _h##a >> 16;             \
0326         *p++ = _h##a >>  8;  *p++ = _h##a;        } while (0)
0327 #endif
0328 // clang-format on
0329 
0330     X(0);
0331     X(1);
0332     X(2);
0333     X(3);
0334     X(4);
0335 
0336 #undef X
0337 
0338     _init = false;
0339 
0340     return (unsigned char *)_buf;
0341 }