summaryrefslogtreecommitdiff
path: root/rbutil/rbutilqt/irivertools/irivertools.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'rbutil/rbutilqt/irivertools/irivertools.cpp')
-rw-r--r--rbutil/rbutilqt/irivertools/irivertools.cpp527
1 files changed, 0 insertions, 527 deletions
diff --git a/rbutil/rbutilqt/irivertools/irivertools.cpp b/rbutil/rbutilqt/irivertools/irivertools.cpp
deleted file mode 100644
index 2bcd9ffb80..0000000000
--- a/rbutil/rbutilqt/irivertools/irivertools.cpp
+++ /dev/null
@@ -1,527 +0,0 @@
1/***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * Module: rbutil
9 * File: irivertools.cpp
10 *
11 * Copyright (C) 2007 Dominik Wenger
12 *
13 * All files in this archive are subject to the GNU General Public License.
14 * See the file COPYING in the source tree root for full license agreement.
15 *
16 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
17 * KIND, either express or implied.
18 *
19 ****************************************************************************/
20
21#include <QtCore>
22#include "irivertools.h"
23
24const unsigned char munge[] = {
25 0x7a, 0x36, 0xc4, 0x43, 0x49, 0x6b, 0x35, 0x4e, 0xa3, 0x46, 0x25, 0x84,
26 0x4d, 0x73, 0x74, 0x61
27};
28
29const unsigned char header_modify[] = "* IHPFIRM-DECODED ";
30
31const char * const models[] = { "iHP-100", "iHP-120/iHP-140", "H300 series",
32 NULL };
33
34/* aligns with models array; expected min firmware size */
35const unsigned int firmware_minsize[] = { 0x100000, 0x100000, 0x200000 };
36/* aligns with models array; expected max firmware size */
37const unsigned int firmware_maxsize[] = { 0x200000, 0x200000, 0x400000 };
38
39const unsigned char header[][16] = {
40 { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },
41 { 0x20, 0x03, 0x08, 0x27, 0x24, 0x00, 0x02, 0x30, 0x19, 0x17, 0x65, 0x73,
42 0x85, 0x32, 0x83, 0x22 },
43 { 0x20, 0x04, 0x03, 0x27, 0x20, 0x50, 0x01, 0x70, 0x80, 0x30, 0x80, 0x06,
44 0x30, 0x19, 0x17, 0x65 }
45};
46
47/* begin mkboot.c excerpt */
48unsigned char image[0x400000 + 0x220 + 0x400000/0x200];
49
50int mkboot(QString infile, QString outfile, QString bootloader, int origin)
51{
52 int i;
53 int len,bllen;
54 int actual_length, total_length, binary_length, num_chksums;
55
56 memset(image, 0xff, sizeof(image));
57
58 /* First, read the iriver original firmware into the image */
59 QFile f(infile);
60 if(!f.open(QIODevice::ReadOnly))
61 {
62 // can't open input file
63 return -1;
64 }
65 i = f.read((char*)image,16);
66 if(i < 16) {
67 // reading header failed
68 return -2;
69 }
70
71 /* This is the length of the binary image without the scrambling
72 overhead (but including the ESTFBINR header) */
73 binary_length = image[4] + (image[5] << 8) +
74 (image[6] << 16) + (image[7] << 24);
75
76 /* Read the rest of the binary data, but not the checksum block */
77 len = binary_length+0x200-16;
78 i = f.read((char*)image+16, len);
79 if(i < len) {
80 // reading firmware failed
81 return -3;
82 }
83
84 f.close();
85 /* Now, read the boot loader into the image */
86 f.setFileName(bootloader);
87 if(!f.open(QIODevice::ReadOnly))
88 {
89 // can't open bootloader file
90 return -4;
91 }
92
93 bllen = f.size();
94
95 i = f.read((char*)image+0x220 + origin, bllen);
96 if(i < bllen) {
97 // reading bootloader file failed
98 return -5;
99 }
100
101 f.close();
102 f.setFileName(outfile);
103 if(!f.open(QIODevice::WriteOnly))
104 {
105 // can't open output file
106 return -6;
107 }
108
109 /* Patch the reset vector to start the boot loader */
110 image[0x220 + 4] = image[origin + 0x220 + 4];
111 image[0x220 + 5] = image[origin + 0x220 + 5];
112 image[0x220 + 6] = image[origin + 0x220 + 6];
113 image[0x220 + 7] = image[origin + 0x220 + 7];
114
115 /* This is the actual length of the binary, excluding all headers */
116 actual_length = origin + bllen;
117
118 /* Patch the ESTFBINR header */
119 image[0x20c] = (actual_length >> 24) & 0xff;
120 image[0x20d] = (actual_length >> 16) & 0xff;
121 image[0x20e] = (actual_length >> 8) & 0xff;
122 image[0x20f] = actual_length & 0xff;
123
124 image[0x21c] = (actual_length >> 24) & 0xff;
125 image[0x21d] = (actual_length >> 16) & 0xff;
126 image[0x21e] = (actual_length >> 8) & 0xff;
127 image[0x21f] = actual_length & 0xff;
128
129 /* This is the length of the binary, including the ESTFBINR header and
130 rounded up to the nearest 0x200 boundary */
131 binary_length = (actual_length + 0x20 + 0x1ff) & 0xfffffe00;
132
133 /* The number of checksums, i.e number of 0x200 byte blocks */
134 num_chksums = binary_length / 0x200;
135
136 /* The total file length, including all headers and checksums */
137 total_length = binary_length + num_chksums + 0x200;
138
139 /* Patch the scrambler header with the new length info */
140 image[0] = total_length & 0xff;
141 image[1] = (total_length >> 8) & 0xff;
142 image[2] = (total_length >> 16) & 0xff;
143 image[3] = (total_length >> 24) & 0xff;
144
145 image[4] = binary_length & 0xff;
146 image[5] = (binary_length >> 8) & 0xff;
147 image[6] = (binary_length >> 16) & 0xff;
148 image[7] = (binary_length >> 24) & 0xff;
149
150 image[8] = num_chksums & 0xff;
151 image[9] = (num_chksums >> 8) & 0xff;
152 image[10] = (num_chksums >> 16) & 0xff;
153 image[11] = (num_chksums >> 24) & 0xff;
154
155 i = f.write((char*)image,total_length);
156 if(i < total_length) {
157 // writing bootloader file failed
158 return -7;
159 }
160
161 f.close();
162
163 return 0;
164}
165
166/* end mkboot.c excerpt */
167
168
169int intable(char *md5, struct sumpairs *table, int len)
170{
171 int i;
172 for (i = 0; i < len; i++) {
173 if (strncmp(md5, table[i].unpatched, 32) == 0) {
174 return i;
175 }
176 }
177 return -1;
178}
179
180
181
182
183static int testheader( const unsigned char * const data )
184{
185 const unsigned char * const d = data+16;
186 const char * const * m = models;
187 int index = 0;
188 while( *m )
189 {
190 if( memcmp( header[ index ], d, 16 ) == 0 )
191 return index;
192 index++;
193 m++;
194 };
195 return -1;
196};
197
198static void modifyheader( unsigned char * data )
199{
200 const unsigned char * h = header_modify;
201 int i;
202 for( i=0; i<512; i++ )
203 {
204 if( *h == '\0' )
205 h = header_modify;
206 *data++ ^= *h++;
207 };
208};
209
210int iriver_decode(QString infile_name, QString outfile_name, unsigned int modify,
211 enum striptype stripmode)
212{
213 QFile infile(infile_name);
214 QFile outfile(outfile_name);
215 int i = -1;
216 unsigned char headerdata[512];
217 unsigned long dwLength1, dwLength2, dwLength3, fp = 0;
218 unsigned char blockdata[16+16];
219 unsigned char out[16];
220 unsigned char newmunge;
221 signed long lenread;
222 int s = 0;
223 unsigned char * pChecksums, * ppChecksums = 0;
224 unsigned char ck;
225
226
227 if(!infile.open(QIODevice::ReadOnly))
228 {
229 // can't open input file
230 return -1;
231 }
232 if(!outfile.open(QIODevice::WriteOnly))
233 {
234 // can't open output file
235 return -2;
236 }
237 lenread = infile.read( (char*)headerdata, 512);
238 if( lenread != 512 )
239 {
240 // header length doesn't match
241 infile.close();
242 outfile.close();
243 return -3;
244 };
245
246 i = testheader( headerdata );
247 if( i == -1 )
248 {
249 // header unknown
250 infile.close();
251 outfile.close();
252 return -4;
253 };
254 fprintf( stderr, "Model %s\n", models[ i ] );
255
256 dwLength1 = headerdata[0] | (headerdata[1]<<8) |
257 (headerdata[2]<<16) | (headerdata[3]<<24);
258 dwLength2 = headerdata[4] | (headerdata[5]<<8) |
259 (headerdata[6]<<16) | (headerdata[7]<<24);
260 dwLength3 = headerdata[8] | (headerdata[9]<<8) |
261 (headerdata[10]<<16) | (headerdata[11]<<24);
262
263 if( dwLength1 < firmware_minsize[ i ] ||
264 dwLength1 > firmware_maxsize[ i ] ||
265 dwLength2 < firmware_minsize[ i ] ||
266 dwLength2 > dwLength1 ||
267 dwLength3 > dwLength1 ||
268 dwLength2>>9 != dwLength3 ||
269 dwLength2+dwLength3+512 != dwLength1 )
270 {
271 // file 'length' data is wrong
272 infile.close();
273 outfile.close();
274 return -5;
275 };
276
277 pChecksums = ppChecksums = (unsigned char *)( malloc( dwLength3 ) );
278
279 if( modify )
280 {
281 modifyheader( headerdata );
282 };
283
284 if( stripmode == STRIP_NONE )
285 outfile.write( (char*)headerdata, 512);
286
287 memset( blockdata, 0, 16 );
288
289 ck = 0;
290 while( ( fp < dwLength2 ) &&
291 ( lenread = infile.read( (char*)blockdata+16, 16) == 16) )
292 {
293 fp += 16;
294
295 for( i=0; i<16; ++i )
296 {
297 newmunge = blockdata[16+i] ^ munge[i];
298 out[i] = newmunge ^ blockdata[i];
299 blockdata[i] = newmunge;
300 ck += out[i];
301 }
302
303 if( fp > ESTF_SIZE || stripmode != STRIP_HEADER_CHECKSUM_ESTF )
304 {
305 outfile.write( (char*)out+4, 12);
306 outfile.write( (char*)out, 4);
307 }
308 else
309 {
310 if( ESTF_SIZE - fp < 16 )
311 {
312 memcpy( out+4, blockdata+16, 12 );
313 memcpy( out, blockdata+28, 4 );
314 outfile.write((char*) blockdata+16+ESTF_SIZE-fp, ESTF_SIZE-fp);
315 }
316 }
317
318
319 if( s == 496 )
320 {
321 s = 0;
322 memset( blockdata, 0, 16 );
323 *ppChecksums++ = ck;
324 ck = 0;
325 }
326 else
327 s+=16;
328 };
329
330 if( fp != dwLength2 )
331 {
332 // 'length2' field mismatch
333 infile.close();
334 outfile.close();
335 return -6;
336 };
337
338 fp = 0;
339 ppChecksums = pChecksums;
340 while( ( fp < dwLength3 ) &&
341 ( lenread = infile.read((char*) blockdata, 32 ) ) > 0 )
342 {
343 fp += lenread;
344 if( stripmode == STRIP_NONE )
345 outfile.write((char*) blockdata, lenread );
346 if( memcmp( ppChecksums, blockdata, lenread ) != 0 )
347 {
348 // file checksum wrong
349 infile.close();
350 outfile.close();
351 return -7;
352 };
353 ppChecksums += lenread;
354 };
355
356 if( fp != dwLength3 )
357 {
358 // 'length3' field mismatch
359 infile.close();
360 outfile.close();
361 return -8;
362 };
363
364
365 fprintf( stderr, "File decoded correctly and all checksums matched!\n" );
366 switch( stripmode )
367 {
368 default:
369 case STRIP_NONE:
370 fprintf(stderr, "Output file contains all headers and "
371 "checksums\n");
372 break;
373 case STRIP_HEADER_CHECKSUM:
374 fprintf( stderr, "NB: output file contains only ESTFBINR header"
375 " and decoded firmware code\n" );
376 break;
377 case STRIP_HEADER_CHECKSUM_ESTF:
378 fprintf( stderr, "NB: output file contains only raw decoded "
379 "firmware code\n" );
380 break;
381 };
382
383 infile.close();
384 outfile.close();
385 return 0;
386
387};
388
389int iriver_encode(QString infile_name, QString outfile_name, unsigned int modify)
390{
391 QFile infile(infile_name);
392 QFile outfile(outfile_name);
393 int i = -1;
394 unsigned char headerdata[512];
395 unsigned long dwLength1, dwLength2, dwLength3, fp = 0;
396 unsigned char blockdata[16+16];
397 unsigned char out[16];
398 unsigned char newmunge;
399 signed long lenread;
400 int s = 0;
401 unsigned char * pChecksums, * ppChecksums;
402 unsigned char ck;
403
404 if(!infile.open(QIODevice::ReadOnly))
405 {
406 // can't open input file
407 return -1;
408 }
409 if(!outfile.open(QIODevice::WriteOnly))
410 {
411 // can't open output file
412 infile.close();
413 return -2;
414 }
415
416 lenread = infile.read((char*) headerdata, 512 );
417 if( lenread != 512 )
418 {
419 // header length error
420 infile.close();
421 outfile.close();
422 return -3;
423 };
424
425 if( modify )
426 {
427 modifyheader( headerdata ); /* reversible */
428 };
429
430 i = testheader( headerdata );
431 if( i == -1 )
432 {
433 // header verification error
434 infile.close();
435 outfile.close();
436 return -4;
437 };
438 fprintf( stderr, "Model %s\n", models[ i ] );
439
440 dwLength1 = headerdata[0] | (headerdata[1]<<8) |
441 (headerdata[2]<<16) | (headerdata[3]<<24);
442 dwLength2 = headerdata[4] | (headerdata[5]<<8) |
443 (headerdata[6]<<16) | (headerdata[7]<<24);
444 dwLength3 = headerdata[8] | (headerdata[9]<<8) |
445 (headerdata[10]<<16) | (headerdata[11]<<24);
446
447 if( dwLength1 < firmware_minsize[i] ||
448 dwLength1 > firmware_maxsize[i] ||
449 dwLength2 < firmware_minsize[i] ||
450 dwLength2 > dwLength1 ||
451 dwLength3 > dwLength1 ||
452 dwLength2+dwLength3+512 != dwLength1 )
453 {
454 // file 'length' error
455 infile.close();
456 outfile.close();
457 return -5;
458 };
459
460 pChecksums = ppChecksums = (unsigned char *)( malloc( dwLength3 ) );
461
462 outfile.write( (char*)headerdata, 512);
463
464 memset( blockdata, 0, 16 );
465 ck = 0;
466 while( ( fp < dwLength2 ) &&
467 ( lenread = infile.read((char*) blockdata+16, 16) ) == 16 )
468 {
469 fp += 16;
470 for( i=0; i<16; ++i )
471 {
472 newmunge = blockdata[16+((12+i)&0xf)] ^ blockdata[i];
473 out[i] = newmunge ^ munge[i];
474 ck += blockdata[16+i];
475 blockdata[i] = newmunge;
476 };
477 outfile.write( (char*)out, 16);
478
479 if( s == 496 )
480 {
481 s = 0;
482 memset( blockdata, 0, 16 );
483 *ppChecksums++ = ck;
484 ck = 0;
485 }
486 else
487 s+=16;
488 };
489
490 if( fp != dwLength2 )
491 {
492 // file 'length1' mismatch
493 infile.close();
494 outfile.close();
495 return -6;
496 };
497
498 /* write out remainder w/out applying descrambler */
499 fp = 0;
500 lenread = dwLength3;
501 ppChecksums = pChecksums;
502 while( ( fp < dwLength3) &&
503 ( lenread = outfile.write((char*) ppChecksums, lenread) ) > 0 )
504 {
505 fp += lenread;
506 ppChecksums += lenread;
507 lenread = dwLength3 - fp;
508 };
509
510 if( fp != dwLength3 )
511 {
512 // 'length2' field mismatch
513 infile.close();
514 outfile.close();
515 return -8;
516 };
517
518 fprintf( stderr, "File encoded successfully and checksum table built!\n" );
519
520 infile.close();
521 outfile.close();
522 return 0;
523
524};
525
526
527
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-17 23:28:26 +0000