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 }