libxcks  0.1.0.1
All Classes Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
md2.cpp
Go to the documentation of this file.
1 /*
2  * libxcks
3  * Copyright (C) 2022 Julien Couot
4  *
5  * This program is free software: you can redistribute it and/or modify it
6  * under the terms of the GNU Lesser General Public License as published by
7  * the Free Software Foundation, either version 3 of the License, or (at your
8  * option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
12  * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
13  * License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public License
16  * along with this program. If not, see <https://www.gnu.org/licenses/>.
17  */
18 
24 //---------------------------------------------------------------------------
25 #include <cstring>
26 
27 #include "md2.hpp"
28 //---------------------------------------------------------------------------
29 
31 using namespace std;
32 //---------------------------------------------------------------------------
33 
34 
35 namespace libxcks
36 {
37 /*
38  * Default constructor.
39  */
40 MD2::MD2()
41 {
42  reset();
43 }
44 //---------------------------------------------------------------------------
45 
46 
47 /*
48  * Resets the MD2 hash to initial value.
49  */
50 void MD2::reset()
51 {
52  memset(X, 0, 48);
53  memset(C, 0, 16);
54  count = 0;
55 }
56 //---------------------------------------------------------------------------
57 
58 
59 /*
60  * Process the remaining bytes in the internal buffer and the usual
61  * prolog according to the standard.
62  */
63 void MD2::finish()
64 {
65  uint8_t padding[16];
66  uint32_t padlen;
67 
68  padlen = 16 - count;
69  for(uint32_t i = 0; i < padlen; i++)
70  padding[i] = static_cast<uint8_t>(padlen);
71 
72  update(padding, padlen);
73  update(C, 16);
74 }
75 //---------------------------------------------------------------------------
76 
77 
78 /*
79  * Updates the MD2 hash with specified array of bytes.
80  */
81 void MD2::update(const uint8_t* buf, size_t len)
82 {
83  static const uint8_t S[256] =
84  {
85  41, 46, 67, 201, 162, 216, 124, 1, 61, 54, 84, 161, 236, 240, 6,
86  19, 98, 167, 5, 243, 192, 199, 115, 140, 152, 147, 43, 217, 188,
87  76, 130, 202, 30, 155, 87, 60, 253, 212, 224, 22, 103, 66, 111, 24,
88  138, 23, 229, 18, 190, 78, 196, 214, 218, 158, 222, 73, 160, 251,
89  245, 142, 187, 47, 238, 122, 169, 104, 121, 145, 21, 178, 7, 63,
90  148, 194, 16, 137, 11, 34, 95, 33, 128, 127, 93, 154, 90, 144, 50,
91  39, 53, 62, 204, 231, 191, 247, 151, 3, 255, 25, 48, 179, 72, 165,
92  181, 209, 215, 94, 146, 42, 172, 86, 170, 198, 79, 184, 56, 210,
93  150, 164, 125, 182, 118, 252, 107, 226, 156, 116, 4, 241, 69, 157,
94  112, 89, 100, 113, 135, 32, 134, 91, 207, 101, 230, 45, 168, 2, 27,
95  96, 37, 173, 174, 176, 185, 246, 28, 70, 97, 105, 52, 64, 126, 15,
96  85, 71, 163, 35, 221, 81, 175, 58, 195, 92, 249, 206, 186, 197,
97  234, 38, 44, 83, 13, 110, 133, 40, 132, 9, 211, 223, 205, 244, 65,
98  129, 77, 82, 106, 220, 55, 200, 108, 193, 171, 250, 36, 225, 123,
99  8, 12, 189, 177, 74, 120, 136, 149, 139, 227, 99, 232, 109, 233,
100  203, 213, 254, 59, 0, 29, 57, 242, 239, 183, 14, 102, 88, 208, 228,
101  166, 119, 114, 248, 235, 117, 75, 10, 49, 68, 80, 180, 143, 237,
102  31, 26, 219, 153, 141, 51, 159, 17, 131, 20
103  };
104 
105  uint32_t L;
106  while (len > 0)
107  {
108  L = (16U - count) < len ? (16U - count) : len;
109  memcpy(ibuffer + count, buf, L);
110  count += L;
111  buf += L;
112  len -= L;
113  if (count == 16)
114  {
115  uint8_t t;
116  int i, j;
117 
118  count = 0;
119  memcpy(X + 16, ibuffer, 16);
120  t = C[15];
121  for (i = 0; i < 16; i++)
122  {
123  X[32 + i] = X[16 + i] ^ X[i];
124  t = C[i] ^= S[ibuffer[i] ^ t];
125  }
126 
127  t=0;
128  for (i = 0; i < 18; i++)
129  {
130  for (j = 0; j < 48; j++)
131  t = X[j] ^= S[t];
132  t = (t + i) & 0xFF;
133  }
134  }
135  }
136 }
137 //---------------------------------------------------------------------------
138 
139 
140 /*
141  * Returns the MD2 hash value in the first 20 bytes of the given address.
142  */
143 uint8_t* MD2::getValue(uint8_t* buffer) const
144 {
145  MD2 md2(*this);
146  md2.finish();
147 
148  memcpy(buffer, md2.X, getSize());
149 
150  return buffer;
151 }
152 //---------------------------------------------------------------------------
153 } // namespace libxcks
154 //---------------------------------------------------------------------------
Computes the MD2 hash from a byte stream.
Definition: md2.hpp:57
uint8_t X[48]
Buffer used for computing md2 hash.
Definition: md2.hpp:61
void finish()
Process the remaining bytes in the internal buffer and the usual prolog according to the standard.
Definition: md2.cpp:63
Compute md2 hash.
#define X(a)
Helper function for MD4's computing.