sprout42 /
StarStruct
| @@ 86-149 (lines=64) @@ | ||
| 83 | assert new.salted == b'random_salter' |
|
| 84 | # print(new._asdict()) |
|
| 85 | ||
| 86 | def test_single_element_2(self): |
|
| 87 | def pseudo_salted_md5(salt, original): |
|
| 88 | temp_md5 = md5(original) |
|
| 89 | ||
| 90 | if salt is None: |
|
| 91 | salt = b'' |
|
| 92 | ||
| 93 | return md5(salt + temp_md5.digest()).digest() |
|
| 94 | ||
| 95 | def do_nothing(data): |
|
| 96 | return data |
|
| 97 | ||
| 98 | TestStruct = Message('TestStruct', [ |
|
| 99 | ('length_in_objects', 'H', 'vardata'), |
|
| 100 | ('vardata', self.VarTest, 'length_in_objects'), |
|
| 101 | ]) |
|
| 102 | ||
| 103 | CRCedMessage = Message('CRCedMessage', [ |
|
| 104 | ('data', TestStruct), |
|
| 105 | ('salted', None), |
|
| 106 | ('function_data', '16B', { |
|
| 107 | 'make': (pseudo_salted_md5, 'salted', b'data'), |
|
| 108 | 'pack': (pseudo_salted_md5, 'salted', b'data'), |
|
| 109 | 'unpack': (do_nothing, 'function_data'), |
|
| 110 | }, False), |
|
| 111 | ]) |
|
| 112 | ||
| 113 | test_data = { |
|
| 114 | 'data': { |
|
| 115 | 'length_in_objects': 2, |
|
| 116 | 'vardata': [ |
|
| 117 | {'x': 1, 'y': 2}, |
|
| 118 | {'x': 3, 'y': 4}, |
|
| 119 | ], |
|
| 120 | }, |
|
| 121 | 'salted': b'random_salter', |
|
| 122 | } |
|
| 123 | ||
| 124 | made = CRCedMessage.make(test_data) |
|
| 125 | assert len(made.data.vardata) == 2 |
|
| 126 | assert made.data.vardata[0].x == 1 |
|
| 127 | assert made.data.vardata[0].y == 2 |
|
| 128 | ||
| 129 | no_data = made.pack() |
|
| 130 | regular = CRCedMessage.pack(**test_data) |
|
| 131 | assert regular == no_data |
|
| 132 | ||
| 133 | # Show that there's no room to have the random salter be packed |
|
| 134 | len_data = len(no_data) - 16 |
|
| 135 | assert no_data[0:len_data] == struct.pack('HBBBB', 2, 1, 2, 3, 4) |
|
| 136 | assert md5( |
|
| 137 | b'random_salter' + |
|
| 138 | md5(no_data[0:len_data]).digest() |
|
| 139 | ).digest() == no_data[len_data:] |
|
| 140 | ||
| 141 | unpacked = CRCedMessage.unpack(no_data) |
|
| 142 | ||
| 143 | assert unpacked.salted is None |
|
| 144 | # This is non symmetric for this test, so we can't just check based on the made item |
|
| 145 | assert unpacked.function_data == (157, 38, 247, 245, 5, 71, 43, 227, 80, 44, 10, 243, 48, 248, 163, 207) |
|
| 146 | ||
| 147 | # TEMP |
|
| 148 | new = unpacked._replace(**{'salted': b'random_salter'}) |
|
| 149 | assert new.salted == b'random_salter' |
|
| 150 | # print(new._asdict()) |
|
| 151 | ||
| 152 | def test_single_element_3(self): |
|
| @@ 213-273 (lines=61) @@ | ||
| 210 | # This is non symmetric for this test, so we can't just check based on the made item |
|
| 211 | assert unpacked.function_data == [314, 76, 494, 490, 10, 142, 86, 454, 160, 88, 20, 486, 96, 496, 326, 414] |
|
| 212 | ||
| 213 | def test_single_element_4(self): |
|
| 214 | def pseudo_salted_md5(salt, original): |
|
| 215 | temp_md5 = md5(original) |
|
| 216 | ||
| 217 | if salt is None: |
|
| 218 | salt = b'' |
|
| 219 | ||
| 220 | return md5(salt + temp_md5.digest()).digest() |
|
| 221 | ||
| 222 | def double(data): |
|
| 223 | return [item * 2 for item in data] |
|
| 224 | ||
| 225 | TestStruct = Message('TestStruct', [ |
|
| 226 | ('length_in_objects', 'H', 'vardata'), |
|
| 227 | ('vardata', self.VarTest, 'length_in_objects'), |
|
| 228 | ]) |
|
| 229 | ||
| 230 | # This one has nothing to do with the original packed message |
|
| 231 | CRCedMessage = Message('CRCedMessage', [ |
|
| 232 | ('data', TestStruct), |
|
| 233 | ('salted', None), |
|
| 234 | ('function_data', '16B', { |
|
| 235 | 'make': (pseudo_salted_md5, 'salted', b'data'), |
|
| 236 | 'pack': (pseudo_salted_md5, 'salted', b'data'), |
|
| 237 | 'unpack': (double, b'data'), |
|
| 238 | }, False), |
|
| 239 | ]) |
|
| 240 | ||
| 241 | test_data = { |
|
| 242 | 'data': { |
|
| 243 | 'length_in_objects': 2, |
|
| 244 | 'vardata': [ |
|
| 245 | {'x': 1, 'y': 2}, |
|
| 246 | {'x': 3, 'y': 4}, |
|
| 247 | ], |
|
| 248 | }, |
|
| 249 | 'salted': b'random_salter', |
|
| 250 | } |
|
| 251 | ||
| 252 | made = CRCedMessage.make(test_data) |
|
| 253 | assert len(made.data.vardata) == 2 |
|
| 254 | assert made.data.vardata[0].x == 1 |
|
| 255 | assert made.data.vardata[0].y == 2 |
|
| 256 | ||
| 257 | no_data = made.pack() |
|
| 258 | regular = CRCedMessage.pack(**test_data) |
|
| 259 | assert regular == no_data |
|
| 260 | ||
| 261 | # Show that there's no room to have the random salter be packed |
|
| 262 | len_data = len(no_data) - 16 |
|
| 263 | assert no_data[0:len_data] == struct.pack('HBBBB', 2, 1, 2, 3, 4) |
|
| 264 | assert md5( |
|
| 265 | b'random_salter' + |
|
| 266 | md5(no_data[0:len_data]).digest() |
|
| 267 | ).digest() == no_data[len_data:] |
|
| 268 | ||
| 269 | unpacked = CRCedMessage.unpack(no_data) |
|
| 270 | ||
| 271 | assert unpacked.salted is None |
|
| 272 | # This is non symmetric for this test, so we can't just check based on the made item |
|
| 273 | assert unpacked.function_data == [4, 0, 2, 4, 6, 8] |
|
| 274 | ||
| 275 | def test_nounpack_function(self): |
|
| 276 | def pseudo_salted_md5(salt, original): |
|
| @@ 152-211 (lines=60) @@ | ||
| 149 | assert new.salted == b'random_salter' |
|
| 150 | # print(new._asdict()) |
|
| 151 | ||
| 152 | def test_single_element_3(self): |
|
| 153 | def pseudo_salted_md5(salt, original): |
|
| 154 | temp_md5 = md5(original) |
|
| 155 | ||
| 156 | if salt is None: |
|
| 157 | salt = b'' |
|
| 158 | ||
| 159 | return md5(salt + temp_md5.digest()).digest() |
|
| 160 | ||
| 161 | def double(data): |
|
| 162 | return [item * 2 for item in data] |
|
| 163 | ||
| 164 | TestStruct = Message('TestStruct', [ |
|
| 165 | ('length_in_objects', 'H', 'vardata'), |
|
| 166 | ('vardata', self.VarTest, 'length_in_objects'), |
|
| 167 | ]) |
|
| 168 | ||
| 169 | CRCedMessage = Message('CRCedMessage', [ |
|
| 170 | ('data', TestStruct), |
|
| 171 | ('salted', None), |
|
| 172 | ('function_data', '16B', { |
|
| 173 | 'make': (pseudo_salted_md5, 'salted', b'data'), |
|
| 174 | 'pack': (pseudo_salted_md5, 'salted', b'data'), |
|
| 175 | 'unpack': (double, 'function_data'), |
|
| 176 | }, False), |
|
| 177 | ]) |
|
| 178 | ||
| 179 | test_data = { |
|
| 180 | 'data': { |
|
| 181 | 'length_in_objects': 2, |
|
| 182 | 'vardata': [ |
|
| 183 | {'x': 1, 'y': 2}, |
|
| 184 | {'x': 3, 'y': 4}, |
|
| 185 | ], |
|
| 186 | }, |
|
| 187 | 'salted': b'random_salter', |
|
| 188 | } |
|
| 189 | ||
| 190 | made = CRCedMessage.make(test_data) |
|
| 191 | assert len(made.data.vardata) == 2 |
|
| 192 | assert made.data.vardata[0].x == 1 |
|
| 193 | assert made.data.vardata[0].y == 2 |
|
| 194 | ||
| 195 | no_data = made.pack() |
|
| 196 | regular = CRCedMessage.pack(**test_data) |
|
| 197 | assert regular == no_data |
|
| 198 | ||
| 199 | # Show that there's no room to have the random salter be packed |
|
| 200 | len_data = len(no_data) - 16 |
|
| 201 | assert no_data[0:len_data] == struct.pack('HBBBB', 2, 1, 2, 3, 4) |
|
| 202 | assert md5( |
|
| 203 | b'random_salter' + |
|
| 204 | md5(no_data[0:len_data]).digest() |
|
| 205 | ).digest() == no_data[len_data:] |
|
| 206 | ||
| 207 | unpacked = CRCedMessage.unpack(no_data) |
|
| 208 | ||
| 209 | assert unpacked.salted is None |
|
| 210 | # This is non symmetric for this test, so we can't just check based on the made item |
|
| 211 | assert unpacked.function_data == [314, 76, 494, 490, 10, 142, 86, 454, 160, 88, 20, 486, 96, 496, 326, 414] |
|
| 212 | ||
| 213 | def test_single_element_4(self): |
|
| 214 | def pseudo_salted_md5(salt, original): |
|
