+1 -1

utils/atj2137/atjboottool/Makefile

··· 10 10 %.o: %.c 11 11 $(CC) $(CFLAGS) -c -o $@ $< 12 12 13 13 - atjboottool: atjboottool.o fwu.o misc.o atj_tables.o 13 13 + atjboottool: atjboottool.o fwu.o fw.o afi.o misc.o atj_tables.o 14 14 $(LD) -o $@ $^ $(LDFLAGS) 15 15 16 16 clean:

+208

utils/atj2137/atjboottool/afi.c

··· 1 1 + /*************************************************************************** 2 2 + * __________ __ ___. 3 3 + * Open \______ \ ____ ____ | | _\_ |__ _______ ___ 4 4 + * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / 5 5 + * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < 6 6 + * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ 7 7 + * \/ \/ \/ \/ \/ 8 8 + * $Id$ 9 9 + * 10 10 + * Copyright (C) 2017 Amaury Pouly 11 11 + * 12 12 + * This program is free software; you can redistribute it and/or 13 13 + * modify it under the terms of the GNU General Public License 14 14 + * as published by the Free Software Foundation; either version 2 15 15 + * of the License, or (at your option) any later version. 16 16 + * 17 17 + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY 18 18 + * KIND, either express or implied. 19 19 + * 20 20 + ****************************************************************************/ 21 21 + #include <string.h> 22 22 + #include <stdlib.h> 23 23 + #include <ctype.h> 24 24 + #include "misc.h" 25 25 + #include "afi.h" 26 26 + 27 27 + /** part of this work comes from s1mp3/s1fwx */ 28 28 + 29 29 + #define AFI_ENTRIES 126 30 30 + #define AFI_SIG_SIZE 4 31 31 + 32 32 + struct afi_hdr_t 33 33 + { 34 34 + uint8_t sig[AFI_SIG_SIZE]; 35 35 + uint16_t vendor_id; 36 36 + uint16_t product_id; 37 37 + uint8_t ver_id[2]; 38 38 + uint8_t ext_ver_id[2]; 39 39 + uint8_t year[2]; 40 40 + uint8_t month; 41 41 + uint8_t day; 42 42 + uint32_t afi_size; 43 43 + uint32_t res[3]; 44 44 + } __attribute__((packed)); 45 45 + 46 46 + struct afi_entry_t 47 47 + { 48 48 + char name[8]; 49 49 + char ext[3]; 50 50 + char type; 51 51 + uint32_t addr; 52 52 + uint32_t offset; 53 53 + uint32_t size; 54 54 + char desc[4]; 55 55 + uint32_t checksum; 56 56 + } __attribute__((packed)); 57 57 + 58 58 + struct afi_post_hdr_t 59 59 + { 60 60 + uint8_t res[28]; 61 61 + uint32_t checksum; 62 62 + } __attribute__((packed)); 63 63 + 64 64 + struct afi_t 65 65 + { 66 66 + struct afi_hdr_t hdr; 67 67 + struct afi_entry_t entry[AFI_ENTRIES]; 68 68 + struct afi_post_hdr_t post; 69 69 + }; 70 70 + 71 71 + #define AFI_ENTRY_BREC 'B' 72 72 + #define AFI_ENTRY_FWSC 'F' 73 73 + #define AFI_ENTRY_ADFUS 'A' 74 74 + #define AFI_ENTRY_FW 'I' 75 75 + 76 76 + #define AFI_ENTRY_DLADR_BREC 0x00000006 // 'B' 77 77 + #define AFI_ENTRY_DLADR_FWSC 0x00020008 // 'F' 78 78 + #define AFI_ENTRY_DLADR_ADFUS 0x000C0008 // 'A' 79 79 + #define AFI_ENTRY_DLADR_ADFU 0x00000000 // 'U' 80 80 + #define AFI_ENTRY_DLADR_FW 0x00000011 // 'I' 81 81 + 82 82 + const uint8_t g_afi_signature[AFI_SIG_SIZE] = 83 83 + { 84 84 + 'A', 'F', 'I', 0 85 85 + }; 86 86 + 87 87 + uint32_t afi_checksum(void *ptr, size_t size) 88 88 + { 89 89 + uint32_t crc = 0; 90 90 + uint32_t *cp = ptr; 91 91 + for(; size >= 4; size -= 4) 92 92 + crc += *cp++; 93 93 + if(size == 1) 94 94 + crc += *(uint8_t *)cp; 95 95 + else if(size == 2) 96 96 + crc += *(uint16_t *)cp; 97 97 + else if(size == 3) 98 98 + crc += *(uint16_t *)cp + ((*(uint8_t *)(cp + 2)) << 16); 99 99 + return crc; 100 100 + } 101 101 + 102 102 + static void build_filename(char buf[16], struct afi_entry_t *ent) 103 103 + { 104 104 + int pos = 0; 105 105 + for(int i = 0; i < 8 && ent->name[i] != ' '; i++) 106 106 + buf[pos++] = ent->name[i]; 107 107 + buf[pos++] = '.'; 108 108 + for(int i = 0; i < 3 && ent->ext[i] != ' '; i++) 109 109 + buf[pos++] = ent->ext[i]; 110 110 + buf[pos] = 0; 111 111 + } 112 112 + 113 113 + int afi_unpack(uint8_t *buf, size_t size, afi_extract_callback_t unpack_cb) 114 114 + { 115 115 + struct afi_t *afi = (void *)buf; 116 116 + 117 117 + if(size < sizeof(struct afi_t)) 118 118 + { 119 119 + cprintf(GREY, "File too small\n"); 120 120 + return 1; 121 121 + } 122 122 + cprintf(BLUE, "Header\n"); 123 123 + cprintf(GREEN, " Signature:"); 124 124 + for(int i = 0; i < AFI_SIG_SIZE; i++) 125 125 + cprintf(YELLOW, " %02x", afi->hdr.sig[i]); 126 126 + if(memcmp(afi->hdr.sig, g_afi_signature, AFI_SIG_SIZE) == 0) 127 127 + cprintf(RED, " Ok\n"); 128 128 + else 129 129 + { 130 130 + cprintf(RED, " Mismatch\n"); 131 131 + return 1; 132 132 + } 133 133 + 134 134 + cprintf_field(" Vendor ID: ", "0x%x\n", afi->hdr.vendor_id); 135 135 + cprintf_field(" Product ID: ", "0x%x\n", afi->hdr.product_id); 136 136 + cprintf_field(" Version: ", "%x.%x\n", afi->hdr.ver_id[0], afi->hdr.ver_id[1]); 137 137 + cprintf_field(" Ext Version: ", "%x.%x\n", afi->hdr.ext_ver_id[0], 138 138 + afi->hdr.ext_ver_id[1]); 139 139 + cprintf_field(" Date: ", "%02x/%02x/%02x%02x\n", afi->hdr.day, afi->hdr.month, 140 140 + afi->hdr.year[0], afi->hdr.year[1]); 141 141 + 142 142 + cprintf_field(" AFI size: ", "%d ", afi->hdr.afi_size); 143 143 + if(afi->hdr.afi_size == size) 144 144 + cprintf(RED, " Ok\n"); 145 145 + else if(afi->hdr.afi_size < size) 146 146 + cprintf(RED, " Ok (file greater than archive)\n"); 147 147 + else 148 148 + { 149 149 + cprintf(RED, " Error (file too small)\n"); 150 150 + return 1; 151 151 + } 152 152 + 153 153 + cprintf_field(" Reserved: ", "%x %x %x\n", afi->hdr.res[0], 154 154 + afi->hdr.res[1], afi->hdr.res[2]); 155 155 + 156 156 + cprintf(BLUE, "Entries\n"); 157 157 + for(int i = 0; i < AFI_ENTRIES; i++) 158 158 + { 159 159 + if(afi->entry[i].name[0] == 0) 160 160 + continue; 161 161 + struct afi_entry_t *entry = &afi->entry[i]; 162 162 + char filename[16]; 163 163 + build_filename(filename, entry); 164 164 + cprintf(RED, " %s\n", filename); 165 165 + cprintf_field(" Type: ", "%02x", entry->type); 166 166 + if(isprint(entry->type)) 167 167 + cprintf(RED, " %c", entry->type); 168 168 + printf("\n"); 169 169 + cprintf_field(" Addr: ", "0x%x\n", entry->addr); 170 170 + cprintf_field(" Offset: ", "0x%x\n", entry->offset); 171 171 + cprintf_field(" Size: ", "0x%x\n", entry->size); 172 172 + cprintf_field(" Desc: ", "%.4s\n", entry->desc); 173 173 + cprintf_field(" Checksum: ", "0x%x ", entry->checksum); 174 174 + uint32_t chk = afi_checksum(buf + entry->offset, entry->size); 175 175 + if(chk != entry->checksum) 176 176 + { 177 177 + cprintf(RED, "Mismatch\n"); 178 178 + return 1; 179 179 + } 180 180 + else 181 181 + cprintf(RED, "Ok\n"); 182 182 + int ret = unpack_cb(filename, buf + entry->offset, entry->size); 183 183 + if(ret != 0) 184 184 + return ret; 185 185 + } 186 186 + 187 187 + cprintf(BLUE, "Post Header\n"); 188 188 + cprintf_field(" Checksum: ", "%x ", afi->post.checksum); 189 189 + uint32_t chk = afi_checksum(buf, sizeof(struct afi_t) - 4); 190 190 + if(chk != afi->post.checksum) 191 191 + { 192 192 + cprintf(RED, "Mismatch\n"); 193 193 + return 1; 194 194 + } 195 195 + else 196 196 + cprintf(RED, "Ok\n"); 197 197 + 198 198 + return 0; 199 199 + } 200 200 + 201 201 + bool afi_check(uint8_t *buf, size_t size) 202 202 + { 203 203 + struct afi_hdr_t *hdr = (void *)buf; 204 204 + 205 205 + if(size < sizeof(struct afi_hdr_t)) 206 206 + return false; 207 207 + return memcmp(hdr->sig, g_afi_signature, AFI_SIG_SIZE) == 0; 208 208 + }

+7 -1

utils/atj2137/atjboottool/afi.h

··· 23 23 24 24 #include <stdint.h> 25 25 26 26 - /* Check if a file looks like a FWU file */ 26 26 + uint32_t afi_checksum(void *ptr, size_t size); 27 27 + /* Unpack an AFI file: the callback function will be called once for each file in the archive with 28 28 + * its name and content. If the callback returns a nonzero value, the function will stop and return 29 29 + * that value. Returns 0 on success */ 30 30 + typedef int (*afi_extract_callback_t)(const char *name, uint8_t *buf, size_t size); 31 31 + int afi_unpack(uint8_t *buf, size_t size, afi_extract_callback_t cb); 32 32 + /* Check if a file looks like an AFI file */ 27 33 bool afi_check(uint8_t *buf, size_t size); 28 34 29 35 #endif /* __AFI_H__ */

+31 -385

utils/atj2137/atjboottool/atjboottool.c

··· 29 29 #include <sys/stat.h> 30 30 #include "misc.h" 31 31 #include "fwu.h" 32 32 + #include "afi.h" 33 33 + #include "fw.h" 32 34 33 35 bool g_debug = false; 34 36 char *g_out_prefix = NULL; ··· 89 91 } 90 92 } 91 93 92 92 - /** 93 93 - * AFI 94 94 - * 95 95 - * part of this work comes from s1mp3/s1fwx 96 96 - **/ 97 97 - 98 98 - #define AFI_ENTRIES 126 99 99 - #define AFI_SIG_SIZE 4 100 100 - 101 101 - struct afi_hdr_t 102 102 - { 103 103 - uint8_t sig[AFI_SIG_SIZE]; 104 104 - uint16_t vendor_id; 105 105 - uint16_t product_id; 106 106 - uint8_t ver_id[2]; 107 107 - uint8_t ext_ver_id[2]; 108 108 - uint8_t year[2]; 109 109 - uint8_t month; 110 110 - uint8_t day; 111 111 - uint32_t afi_size; 112 112 - uint32_t res[3]; 113 113 - } __attribute__((packed)); 114 114 - 115 115 - struct afi_entry_t 116 116 - { 117 117 - char name[8]; 118 118 - char ext[3]; 119 119 - char type; 120 120 - uint32_t addr; 121 121 - uint32_t offset; 122 122 - uint32_t size; 123 123 - char desc[4]; 124 124 - uint32_t checksum; 125 125 - } __attribute__((packed)); 126 126 - 127 127 - struct afi_post_hdr_t 128 128 - { 129 129 - uint8_t res[28]; 130 130 - uint32_t checksum; 131 131 - } __attribute__((packed)); 132 132 - 133 133 - struct afi_t 134 134 - { 135 135 - struct afi_hdr_t hdr; 136 136 - struct afi_entry_t entry[AFI_ENTRIES]; 137 137 - struct afi_post_hdr_t post; 138 138 - }; 139 139 - 140 140 - #define AFI_ENTRY_BREC 'B' 141 141 - #define AFI_ENTRY_FWSC 'F' 142 142 - #define AFI_ENTRY_ADFUS 'A' 143 143 - #define AFI_ENTRY_FW 'I' 144 144 - 145 145 - #define AFI_ENTRY_DLADR_BREC 0x00000006 // 'B' 146 146 - #define AFI_ENTRY_DLADR_FWSC 0x00020008 // 'F' 147 147 - #define AFI_ENTRY_DLADR_ADFUS 0x000C0008 // 'A' 148 148 - #define AFI_ENTRY_DLADR_ADFU 0x00000000 // 'U' 149 149 - #define AFI_ENTRY_DLADR_FW 0x00000011 // 'I' 150 150 - 151 151 - const uint8_t g_afi_signature[AFI_SIG_SIZE] = 152 152 - { 153 153 - 'A', 'F', 'I', 0 154 154 - }; 155 155 - 156 156 - static uint32_t afi_checksum(void *ptr, int size) 157 157 - { 158 158 - uint32_t crc = 0; 159 159 - uint32_t *cp = ptr; 160 160 - for(; size >= 4; size -= 4) 161 161 - crc += *cp++; 162 162 - if(size == 1) 163 163 - crc += *(uint8_t *)cp; 164 164 - else if(size == 2) 165 165 - crc += *(uint16_t *)cp; 166 166 - else if(size == 3) 167 167 - crc += *(uint16_t *)cp + ((*(uint8_t *)(cp + 2)) << 16); 168 168 - return crc; 169 169 - } 170 170 - 171 171 - static void build_filename(char buf[16], struct afi_entry_t *ent) 172 172 - { 173 173 - int pos = 0; 174 174 - for(int i = 0; i < 8 && ent->name[i] != ' '; i++) 175 175 - buf[pos++] = ent->name[i]; 176 176 - buf[pos++] = '.'; 177 177 - for(int i = 0; i < 3 && ent->ext[i] != ' '; i++) 178 178 - buf[pos++] = ent->ext[i]; 179 179 - buf[pos] = 0; 180 180 - } 181 181 - 182 182 - static int do_afi(uint8_t *buf, int size) 94 94 + static int unpack_afi_fw_cb(const char *filename, uint8_t *buf, size_t size) 183 95 { 184 184 - struct afi_t *afi = (void *)buf; 96 96 + char *name = malloc(strlen(g_out_prefix) + strlen(filename) + 16); 97 97 + sprintf(name, "%s%s", g_out_prefix, filename); 185 98 186 186 - if(size < (int)sizeof(struct afi_t)) 187 187 - { 188 188 - cprintf(GREY, "File too small\n"); 189 189 - return 1; 190 190 - } 191 191 - cprintf(BLUE, "Header\n"); 192 192 - cprintf(GREEN, " Signature:"); 193 193 - for(int i = 0; i < AFI_SIG_SIZE; i++) 194 194 - cprintf(YELLOW, " %02x", afi->hdr.sig[i]); 195 195 - if(memcmp(afi->hdr.sig, g_afi_signature, AFI_SIG_SIZE) == 0) 196 196 - cprintf(RED, " Ok\n"); 197 197 - else 99 99 + cprintf(GREY, "Unpacking to %s... ", name); 100 100 + FILE *f = fopen(name, "wb"); 101 101 + if(f) 198 102 { 199 199 - cprintf(RED, " Mismatch\n"); 200 200 - return 1; 103 103 + fwrite(buf, size, 1, f); 104 104 + fclose(f); 105 105 + cprintf(RED, "Ok\n"); 106 106 + return 0; 201 107 } 202 202 - 203 203 - cprintf_field(" Vendor ID: ", "0x%x\n", afi->hdr.vendor_id); 204 204 - cprintf_field(" Product ID: ", "0x%x\n", afi->hdr.product_id); 205 205 - cprintf_field(" Version: ", "%x.%x\n", afi->hdr.ver_id[0], afi->hdr.ver_id[1]); 206 206 - cprintf_field(" Ext Version: ", "%x.%x\n", afi->hdr.ext_ver_id[0], 207 207 - afi->hdr.ext_ver_id[1]); 208 208 - cprintf_field(" Date: ", "%02x/%02x/%02x%02x\n", afi->hdr.day, afi->hdr.month, 209 209 - afi->hdr.year[0], afi->hdr.year[1]); 210 210 - 211 211 - cprintf_field(" AFI size: ", "%d ", afi->hdr.afi_size); 212 212 - if((int)afi->hdr.afi_size == size) 213 213 - cprintf(RED, " Ok\n"); 214 214 - else if((int)afi->hdr.afi_size < size) 215 215 - cprintf(RED, " Ok (file greater than archive)\n"); 216 108 else 217 109 { 218 218 - cprintf(RED, " Error (file too small)\n"); 110 110 + color(RED); 111 111 + perror("Failed"); 219 112 return 1; 220 113 } 221 221 - 222 222 - cprintf_field(" Reserved: ", "%x %x %x\n", afi->hdr.res[0], 223 223 - afi->hdr.res[1], afi->hdr.res[2]); 224 224 - 225 225 - build_out_prefix(".fw", "", true); 226 226 - 227 227 - cprintf(BLUE, "Entries\n"); 228 228 - for(int i = 0; i < AFI_ENTRIES; i++) 229 229 - { 230 230 - if(afi->entry[i].name[0] == 0) 231 231 - continue; 232 232 - struct afi_entry_t *entry = &afi->entry[i]; 233 233 - char filename[16]; 234 234 - build_filename(filename, entry); 235 235 - cprintf(RED, " %s\n", filename); 236 236 - cprintf_field(" Type: ", "%02x", entry->type); 237 237 - if(isprint(entry->type)) 238 238 - cprintf(RED, " %c", entry->type); 239 239 - printf("\n"); 240 240 - cprintf_field(" Addr: ", "0x%x\n", entry->addr); 241 241 - cprintf_field(" Offset: ", "0x%x\n", entry->offset); 242 242 - cprintf_field(" Size: ", "0x%x\n", entry->size); 243 243 - cprintf_field(" Desc: ", "%.4s\n", entry->desc); 244 244 - cprintf_field(" Checksum: ", "0x%x ", entry->checksum); 245 245 - uint32_t chk = afi_checksum(buf + entry->offset, entry->size); 246 246 - cprintf(RED, "%s\n", chk == entry->checksum ? "Ok" : "Mismatch"); 247 247 - 248 248 - char *name = malloc(strlen(g_out_prefix) + strlen(filename) + 16); 249 249 - sprintf(name, "%s%s", g_out_prefix, filename); 250 250 - 251 251 - cprintf(GREY, "Unpacking to %s... ", name); 252 252 - FILE *f = fopen(name, "wb"); 253 253 - if(f) 254 254 - { 255 255 - fwrite(buf + entry->offset, entry->size, 1, f); 256 256 - fclose(f); 257 257 - cprintf(RED, "Ok\n"); 258 258 - } 259 259 - else 260 260 - cprintf(RED, "Failed: %m\n"); 261 261 - } 262 262 - 263 263 - cprintf(BLUE, "Post Header\n"); 264 264 - cprintf_field(" Checksum: ", "%x ", afi->post.checksum); 265 265 - uint32_t chk = afi_checksum(buf, sizeof(struct afi_t) - 4); 266 266 - cprintf(RED, "%s\n", chk == afi->post.checksum ? "Ok" : "Mismatch"); 267 267 - 268 268 - return 0; 269 114 } 270 115 271 271 - bool afi_check(uint8_t *buf, int size) 272 272 - { 273 273 - struct afi_hdr_t *hdr = (void *)buf; 274 274 - 275 275 - if(size < (int)sizeof(struct afi_hdr_t)) 276 276 - return false; 277 277 - return memcmp(hdr->sig, g_afi_signature, AFI_SIG_SIZE) == 0; 278 278 - } 279 279 - 280 280 - /** 281 281 - * FW 282 282 - **/ 283 283 - 284 284 - #define FW_SIG_SIZE 4 285 285 - 286 286 - #define FW_ENTRIES 240 287 287 - 288 288 - struct fw_entry_t 289 289 - { 290 290 - char name[8]; 291 291 - char ext[3]; 292 292 - uint8_t attr; 293 293 - uint8_t res[2]; 294 294 - uint16_t version; 295 295 - uint32_t block_offset; // offset shift by 9 296 296 - uint32_t size; 297 297 - uint32_t unk; 298 298 - uint32_t checksum; 299 299 - } __attribute__((packed)); 300 300 - 301 301 - struct fw_hdr_t 302 302 - { 303 303 - uint8_t sig[FW_SIG_SIZE]; 304 304 - uint32_t res[4]; 305 305 - uint8_t year[2]; 306 306 - uint8_t month; 307 307 - uint8_t day; 308 308 - uint16_t usb_vid; 309 309 - uint16_t usb_pid; 310 310 - uint32_t checksum; 311 311 - char productor[16]; 312 312 - char str2[16]; 313 313 - char str3[32]; 314 314 - char dev_name[32]; 315 315 - uint8_t res2[8 * 16]; 316 316 - char usb_name1[8]; 317 317 - char usb_name2[8]; 318 318 - char res3[4 * 16 + 1]; 319 319 - char mtp_name1[33]; 320 320 - char mtp_name2[33]; 321 321 - char mtp_ver[33]; 322 322 - uint16_t mtp_vid; 323 323 - uint16_t mtp_pid; 324 324 - char fw_ver[64]; 325 325 - uint32_t res4[2]; 326 326 - 327 327 - struct fw_entry_t entry[FW_ENTRIES]; 328 328 - } __attribute__((packed)); 329 329 - 330 330 - /* the s1fwx source code has a layout but it does not make any sense for firmwares 331 331 - * found in ATJ2127 for example. In doubt just don't do anything */ 332 332 - struct fw_hdr_f0_t 333 333 - { 334 334 - uint8_t sig[FW_SIG_SIZE]; 335 335 - uint8_t res[12]; 336 336 - uint32_t checksum; 337 337 - uint8_t res2[492]; 338 338 - 339 339 - struct fw_entry_t entry[FW_ENTRIES]; 340 340 - } __attribute__((packed)); 341 341 - 342 342 - const uint8_t g_fw_signature_f2[FW_SIG_SIZE] = 343 343 - { 344 344 - 0x55, 0xaa, 0xf2, 0x0f 345 345 - }; 346 346 - 347 347 - const uint8_t g_fw_signature_f0[FW_SIG_SIZE] = 116 116 + static int do_afi(uint8_t *buf, size_t size) 348 117 { 349 349 - 0x55, 0xaa, 0xf0, 0x0f 350 350 - }; 351 351 - 352 352 - static void build_filename_fw(char buf[16], struct fw_entry_t *ent) 353 353 - { 354 354 - int pos = 0; 355 355 - for(int i = 0; i < 8 && ent->name[i] != ' '; i++) 356 356 - buf[pos++] = ent->name[i]; 357 357 - buf[pos++] = '.'; 358 358 - for(int i = 0; i < 3 && ent->ext[i] != ' '; i++) 359 359 - buf[pos++] = ent->ext[i]; 360 360 - buf[pos] = 0; 118 118 + build_out_prefix(".fw", "", true); 119 119 + return afi_unpack(buf, size, &unpack_afi_fw_cb); 361 120 } 362 121 363 363 - static int do_fw(uint8_t *buf, int size) 122 122 + static int do_fw(uint8_t *buf, size_t size) 364 123 { 365 365 - struct fw_hdr_t *hdr = (void *)buf; 366 366 - 367 367 - if(size < (int)sizeof(struct fw_hdr_t)) 368 368 - { 369 369 - cprintf(GREY, "File too small\n"); 370 370 - return 1; 371 371 - } 372 372 - cprintf(BLUE, "Header\n"); 373 373 - cprintf(GREEN, " Signature:"); 374 374 - for(int i = 0; i < FW_SIG_SIZE; i++) 375 375 - cprintf(YELLOW, " %02x", hdr->sig[i]); 376 376 - int variant = 0; 377 377 - if(memcmp(hdr->sig, g_fw_signature_f2, FW_SIG_SIZE) == 0) 378 378 - { 379 379 - variant = 0xf2; 380 380 - cprintf(RED, " Ok (f2 variant)\n"); 381 381 - } 382 382 - else if(memcmp(hdr->sig, g_fw_signature_f0, FW_SIG_SIZE) == 0) 383 383 - { 384 384 - variant = 0xf0; 385 385 - cprintf(RED, " Ok (f0 variant)\n"); 386 386 - } 387 387 - else 388 388 - { 389 389 - cprintf(RED, " Mismatch\n"); 390 390 - return 1; 391 391 - } 392 392 - 393 393 - /* both variants have the same header size, only the fields differ */ 394 394 - if(variant == 0xf2) 395 395 - { 396 396 - cprintf_field(" USB VID: ", "0x%x\n", hdr->usb_vid); 397 397 - cprintf_field(" USB PID: ", "0x%x\n", hdr->usb_pid); 398 398 - cprintf_field(" Date: ", "%x/%x/%02x%02x\n", hdr->day, hdr->month, hdr->year[0], hdr->year[1]); 399 399 - cprintf_field(" Checksum: ", "%x\n", hdr->checksum); 400 400 - cprintf_field(" Productor: ", "%.16s\n", hdr->productor); 401 401 - cprintf_field(" String 2: ", "%.16s\n", hdr->str2); 402 402 - cprintf_field(" String 3: ", "%.32s\n", hdr->str3); 403 403 - cprintf_field(" Device Name: ", "%.32s\n", hdr->dev_name); 404 404 - cprintf(GREEN, " Unknown:\n"); 405 405 - for(int i = 0; i < 8; i++) 406 406 - { 407 407 - cprintf(YELLOW, " "); 408 408 - for(int j = 0; j < 16; j++) 409 409 - cprintf(YELLOW, "%02x ", hdr->res2[i * 16 + j]); 410 410 - cprintf(YELLOW, "\n"); 411 411 - } 412 412 - cprintf_field(" USB Name 1: ", "%.8s\n", hdr->usb_name1); 413 413 - cprintf_field(" USB Name 2: ", "%.8s\n", hdr->usb_name2); 414 414 - cprintf_field(" MTP Name 1: ", "%.32s\n", hdr->mtp_name1); 415 415 - cprintf_field(" MTP Name 2: ", "%.32s\n", hdr->mtp_name2); 416 416 - cprintf_field(" MTP Version: ", "%.32s\n", hdr->mtp_ver); 417 417 - 418 418 - cprintf_field(" MTP VID: ", "0x%x\n", hdr->mtp_vid); 419 419 - cprintf_field(" MTP PID: ", "0x%x\n", hdr->mtp_pid); 420 420 - cprintf_field(" FW Version: ", "%.64s\n", hdr->fw_ver); 421 421 - } 422 422 - else 423 423 - { 424 424 - /* struct fw_hdr_f0_t *hdr_f0 = (void *)hdr; */ 425 425 - cprintf(GREEN, " Header not dumped because format is unclear.\n"); 426 426 - } 427 427 - 428 124 build_out_prefix(".unpack", "", true); 429 429 - 430 430 - cprintf(BLUE, "Entries\n"); 431 431 - for(int i = 0; i < AFI_ENTRIES; i++) 432 432 - { 433 433 - if(hdr->entry[i].name[0] == 0) 434 434 - continue; 435 435 - struct fw_entry_t *entry = &hdr->entry[i]; 436 436 - char filename[16]; 437 437 - build_filename_fw(filename, entry); 438 438 - cprintf(RED, " %s\n", filename); 439 439 - cprintf_field(" Attr: ", "%02x\n", entry->attr); 440 440 - cprintf_field(" Offset: ", "0x%x\n", entry->block_offset << 9); 441 441 - cprintf_field(" Size: ", "0x%x\n", entry->size); 442 442 - cprintf_field(" Unknown: ", "%x\n", entry->unk); 443 443 - cprintf_field(" Checksum: ", "0x%x ", entry->checksum); 444 444 - uint32_t chk = afi_checksum(buf + (entry->block_offset << 9), entry->size); 445 445 - cprintf(RED, "%s\n", chk == entry->checksum ? "Ok" : "Mismatch"); 446 446 - if(g_out_prefix) 447 447 - { 448 448 - char *name = malloc(strlen(g_out_prefix) + strlen(filename) + 16); 449 449 - sprintf(name, "%s%s", g_out_prefix, filename); 450 450 - 451 451 - cprintf(GREY, "Unpacking to %s... ", name); 452 452 - FILE *f = fopen(name, "wb"); 453 453 - if(f) 454 454 - { 455 455 - fwrite(buf + (entry->block_offset << 9), entry->size, 1, f); 456 456 - fclose(f); 457 457 - cprintf(RED, "Ok\n"); 458 458 - } 459 459 - else 460 460 - cprintf(RED, "Failed: %m\n"); 461 461 - } 462 462 - } 463 463 - 464 464 - return 0; 465 465 - } 466 466 - 467 467 - static bool check_fw(uint8_t *buf, int size) 468 468 - { 469 469 - struct fw_hdr_t *hdr = (void *)buf; 470 470 - 471 471 - if(size < (int)sizeof(struct fw_hdr_t)) 472 472 - return false; 473 473 - if(memcmp(hdr->sig, g_fw_signature_f2, FW_SIG_SIZE) == 0) 474 474 - return true; 475 475 - if(memcmp(hdr->sig, g_fw_signature_f0, FW_SIG_SIZE) == 0) 476 476 - return true; 477 477 - return false; 125 125 + return fw_unpack(buf, size, &unpack_afi_fw_cb); 478 126 } 479 479 - 480 127 static void usage(void) 481 128 { 482 129 printf("Usage: atjboottool [options] firmware\n"); 483 130 printf("Options:\n"); 484 484 - printf(" -o <prefix>\tSet output prefix\n"); 485 485 - printf(" -f/--force\tForce to continue on errors\n"); 486 486 - printf(" -?/--help\tDisplay this message\n"); 487 487 - printf(" -d/--debug\tDisplay debug messages\n"); 488 488 - printf(" -c/--no-color\tDisable color output\n"); 489 489 - printf(" --fwu\tUnpack a FWU firmware file\n"); 490 490 - printf(" --afi\tUnpack a AFI archive file\n"); 491 491 - printf(" --fw\tUnpack a FW archive file\n"); 492 492 - printf(" --atj2127\tForce ATJ2127 decryption mode\n"); 131 131 + printf(" -o <path> Set output file or output prefix\n"); 132 132 + printf(" -h/--help Display this message\n"); 133 133 + printf(" -d/--debug Display debug messages\n"); 134 134 + printf(" -c/--no-color Disable color output\n"); 135 135 + printf(" --fwu Unpack a FWU firmware file\n"); 136 136 + printf(" --afi Unpack a AFI archive file\n"); 137 137 + printf(" --fw Unpack a FW archive file\n"); 138 138 + printf(" --atj2127 Force ATJ2127 decryption mode\n"); 493 139 printf("The default is to try to guess the format.\n"); 494 140 printf("If several formats are specified, all are tried.\n"); 495 141 printf("If no output prefix is specified, a default one is picked.\n"); ··· 507 153 { 508 154 static struct option long_options[] = 509 155 { 510 510 - {"help", no_argument, 0, '?'}, 156 156 + {"help", no_argument, 0, 'h'}, 511 157 {"debug", no_argument, 0, 'd'}, 512 158 {"no-color", no_argument, 0, 'c'}, 513 159 {"fwu", no_argument, 0, 'u'}, ··· 517 163 {0, 0, 0, 0} 518 164 }; 519 165 520 520 - int c = getopt_long(argc, argv, "?dcfo:a1", long_options, NULL); 166 166 + int c = getopt_long(argc, argv, "hdco:a2", long_options, NULL); 521 167 if(c == -1) 522 168 break; 523 169 switch(c) ··· 531 177 g_debug = true; 532 178 break; 533 179 break; 534 534 - case '?': 180 180 + case 'h': 535 181 usage(); 536 182 break; 537 183 case 'o': ··· 591 237 ret = do_fwu(buf, size, fwu_mode); 592 238 else if(try_afi || afi_check(buf, size)) 593 239 ret = do_afi(buf, size); 594 594 - else if(try_fw || check_fw(buf, size)) 240 240 + else if(try_fw || fw_check(buf, size)) 595 241 ret = do_fw(buf, size); 596 242 else 597 243 {

+213

utils/atj2137/atjboottool/fw.c

··· 1 1 + /*************************************************************************** 2 2 + * __________ __ ___. 3 3 + * Open \______ \ ____ ____ | | _\_ |__ _______ ___ 4 4 + * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / 5 5 + * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < 6 6 + * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ 7 7 + * \/ \/ \/ \/ \/ 8 8 + * $Id$ 9 9 + * 10 10 + * Copyright (C) 2017 Amaury Pouly 11 11 + * 12 12 + * This program is free software; you can redistribute it and/or 13 13 + * modify it under the terms of the GNU General Public License 14 14 + * as published by the Free Software Foundation; either version 2 15 15 + * of the License, or (at your option) any later version. 16 16 + * 17 17 + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY 18 18 + * KIND, either express or implied. 19 19 + * 20 20 + ****************************************************************************/ 21 21 + #include <string.h> 22 22 + #include <stdlib.h> 23 23 + #include <ctype.h> 24 24 + #include "misc.h" 25 25 + #include "fw.h" 26 26 + #include "afi.h" 27 27 + 28 28 + #define FW_SIG_SIZE 4 29 29 + 30 30 + #define FW_ENTRIES 240 31 31 + 32 32 + struct fw_entry_t 33 33 + { 34 34 + char name[8]; 35 35 + char ext[3]; 36 36 + uint8_t attr; 37 37 + uint8_t res[2]; 38 38 + uint16_t version; 39 39 + uint32_t block_offset; // offset shift by 9 40 40 + uint32_t size; 41 41 + uint32_t unk; 42 42 + uint32_t checksum; 43 43 + } __attribute__((packed)); 44 44 + 45 45 + struct fw_hdr_t 46 46 + { 47 47 + uint8_t sig[FW_SIG_SIZE]; 48 48 + uint32_t res[4]; 49 49 + uint8_t year[2]; 50 50 + uint8_t month; 51 51 + uint8_t day; 52 52 + uint16_t usb_vid; 53 53 + uint16_t usb_pid; 54 54 + uint32_t checksum; 55 55 + char productor[16]; 56 56 + char str2[16]; 57 57 + char str3[32]; 58 58 + char dev_name[32]; 59 59 + uint8_t res2[8 * 16]; 60 60 + char usb_name1[8]; 61 61 + char usb_name2[8]; 62 62 + char res3[4 * 16 + 1]; 63 63 + char mtp_name1[33]; 64 64 + char mtp_name2[33]; 65 65 + char mtp_ver[33]; 66 66 + uint16_t mtp_vid; 67 67 + uint16_t mtp_pid; 68 68 + char fw_ver[64]; 69 69 + uint32_t res4[2]; 70 70 + 71 71 + struct fw_entry_t entry[FW_ENTRIES]; 72 72 + } __attribute__((packed)); 73 73 + 74 74 + /* the s1fwx source code has a layout but it does not make any sense for firmwares 75 75 + * found in ATJ2127 for example. In doubt just don't do anything */ 76 76 + struct fw_hdr_f0_t 77 77 + { 78 78 + uint8_t sig[FW_SIG_SIZE]; 79 79 + uint8_t res[12]; 80 80 + uint32_t checksum; 81 81 + uint8_t res2[492]; 82 82 + 83 83 + struct fw_entry_t entry[FW_ENTRIES]; 84 84 + } __attribute__((packed)); 85 85 + 86 86 + const uint8_t g_fw_signature_f2[FW_SIG_SIZE] = 87 87 + { 88 88 + 0x55, 0xaa, 0xf2, 0x0f 89 89 + }; 90 90 + 91 91 + const uint8_t g_fw_signature_f0[FW_SIG_SIZE] = 92 92 + { 93 93 + 0x55, 0xaa, 0xf0, 0x0f 94 94 + }; 95 95 + 96 96 + static void build_filename_fw(char buf[16], struct fw_entry_t *ent) 97 97 + { 98 98 + int pos = 0; 99 99 + for(int i = 0; i < 8 && ent->name[i] != ' '; i++) 100 100 + buf[pos++] = ent->name[i]; 101 101 + buf[pos++] = '.'; 102 102 + for(int i = 0; i < 3 && ent->ext[i] != ' '; i++) 103 103 + buf[pos++] = ent->ext[i]; 104 104 + buf[pos] = 0; 105 105 + } 106 106 + 107 107 + int fw_unpack(uint8_t *buf, size_t size, fw_extract_callback_t unpack_cb) 108 108 + { 109 109 + struct fw_hdr_t *hdr = (void *)buf; 110 110 + 111 111 + if(size < sizeof(struct fw_hdr_t)) 112 112 + { 113 113 + cprintf(GREY, "File too small\n"); 114 114 + return 1; 115 115 + } 116 116 + cprintf(BLUE, "Header\n"); 117 117 + cprintf(GREEN, " Signature:"); 118 118 + for(int i = 0; i < FW_SIG_SIZE; i++) 119 119 + cprintf(YELLOW, " %02x", hdr->sig[i]); 120 120 + int variant = 0; 121 121 + if(memcmp(hdr->sig, g_fw_signature_f2, FW_SIG_SIZE) == 0) 122 122 + { 123 123 + variant = 0xf2; 124 124 + cprintf(RED, " Ok (f2 variant)\n"); 125 125 + } 126 126 + else if(memcmp(hdr->sig, g_fw_signature_f0, FW_SIG_SIZE) == 0) 127 127 + { 128 128 + variant = 0xf0; 129 129 + cprintf(RED, " Ok (f0 variant)\n"); 130 130 + } 131 131 + else 132 132 + { 133 133 + cprintf(RED, " Mismatch\n"); 134 134 + return 1; 135 135 + } 136 136 + 137 137 + /* both variants have the same header size, only the fields differ */ 138 138 + if(variant == 0xf2) 139 139 + { 140 140 + cprintf_field(" USB VID: ", "0x%x\n", hdr->usb_vid); 141 141 + cprintf_field(" USB PID: ", "0x%x\n", hdr->usb_pid); 142 142 + cprintf_field(" Date: ", "%x/%x/%02x%02x\n", hdr->day, hdr->month, hdr->year[0], hdr->year[1]); 143 143 + cprintf_field(" Checksum: ", "%x\n", hdr->checksum); 144 144 + cprintf_field(" Productor: ", "%.16s\n", hdr->productor); 145 145 + cprintf_field(" String 2: ", "%.16s\n", hdr->str2); 146 146 + cprintf_field(" String 3: ", "%.32s\n", hdr->str3); 147 147 + cprintf_field(" Device Name: ", "%.32s\n", hdr->dev_name); 148 148 + cprintf(GREEN, " Unknown:\n"); 149 149 + for(int i = 0; i < 8; i++) 150 150 + { 151 151 + cprintf(YELLOW, " "); 152 152 + for(int j = 0; j < 16; j++) 153 153 + cprintf(YELLOW, "%02x ", hdr->res2[i * 16 + j]); 154 154 + cprintf(YELLOW, "\n"); 155 155 + } 156 156 + cprintf_field(" USB Name 1: ", "%.8s\n", hdr->usb_name1); 157 157 + cprintf_field(" USB Name 2: ", "%.8s\n", hdr->usb_name2); 158 158 + cprintf_field(" MTP Name 1: ", "%.32s\n", hdr->mtp_name1); 159 159 + cprintf_field(" MTP Name 2: ", "%.32s\n", hdr->mtp_name2); 160 160 + cprintf_field(" MTP Version: ", "%.32s\n", hdr->mtp_ver); 161 161 + 162 162 + cprintf_field(" MTP VID: ", "0x%x\n", hdr->mtp_vid); 163 163 + cprintf_field(" MTP PID: ", "0x%x\n", hdr->mtp_pid); 164 164 + cprintf_field(" FW Version: ", "%.64s\n", hdr->fw_ver); 165 165 + } 166 166 + else 167 167 + { 168 168 + /* struct fw_hdr_f0_t *hdr_f0 = (void *)hdr; */ 169 169 + cprintf(GREEN, " Header not dumped because format is unclear.\n"); 170 170 + } 171 171 + 172 172 + cprintf(BLUE, "Entries\n"); 173 173 + for(int i = 0; i < FW_ENTRIES; i++) 174 174 + { 175 175 + if(hdr->entry[i].name[0] == 0) 176 176 + continue; 177 177 + struct fw_entry_t *entry = &hdr->entry[i]; 178 178 + char filename[16]; 179 179 + build_filename_fw(filename, entry); 180 180 + cprintf(RED, " %s\n", filename); 181 181 + cprintf_field(" Attr: ", "%02x\n", entry->attr); 182 182 + cprintf_field(" Offset: ", "0x%x\n", entry->block_offset << 9); 183 183 + cprintf_field(" Size: ", "0x%x\n", entry->size); 184 184 + cprintf_field(" Unknown: ", "%x\n", entry->unk); 185 185 + cprintf_field(" Checksum: ", "0x%x ", entry->checksum); 186 186 + uint32_t chk = afi_checksum(buf + (entry->block_offset << 9), entry->size); 187 187 + if(chk != entry->checksum) 188 188 + { 189 189 + cprintf(RED, "Mismatch\n"); 190 190 + return 1; 191 191 + } 192 192 + else 193 193 + cprintf(RED, "Ok\n"); 194 194 + int ret = unpack_cb(filename, buf + (entry->block_offset << 9), entry->size); 195 195 + if(ret != 0) 196 196 + return ret; 197 197 + } 198 198 + 199 199 + return 0; 200 200 + } 201 201 + 202 202 + bool fw_check(uint8_t *buf, size_t size) 203 203 + { 204 204 + struct fw_hdr_t *hdr = (void *)buf; 205 205 + 206 206 + if(size < sizeof(struct fw_hdr_t)) 207 207 + return false; 208 208 + if(memcmp(hdr->sig, g_fw_signature_f2, FW_SIG_SIZE) == 0) 209 209 + return true; 210 210 + if(memcmp(hdr->sig, g_fw_signature_f0, FW_SIG_SIZE) == 0) 211 211 + return true; 212 212 + return false; 213 213 + }

+34

utils/atj2137/atjboottool/fw.h

··· 1 1 + /*************************************************************************** 2 2 + * __________ __ ___. 3 3 + * Open \______ \ ____ ____ | | _\_ |__ _______ ___ 4 4 + * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / 5 5 + * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < 6 6 + * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ 7 7 + * \/ \/ \/ \/ \/ 8 8 + * $Id$ 9 9 + * 10 10 + * Copyright (C) 2017 Amaury Pouly 11 11 + * 12 12 + * This program is free software; you can redistribute it and/or 13 13 + * modify it under the terms of the GNU General Public License 14 14 + * as published by the Free Software Foundation; either version 2 15 15 + * of the License, or (at your option) any later version. 16 16 + * 17 17 + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY 18 18 + * KIND, either express or implied. 19 19 + * 20 20 + ****************************************************************************/ 21 21 + #ifndef __FW_H__ 22 22 + #define __FW_H__ 23 23 + 24 24 + #include <stdint.h> 25 25 + 26 26 + /* Unpack an AFI file: the callback function will be called once for each file in the archive with 27 27 + * its name and content. If the callback returns a nonzero value, the function will stop and return 28 28 + * that value. Returns 0 on success */ 29 29 + typedef int (*fw_extract_callback_t)(const char *name, uint8_t *buf, size_t size); 30 30 + int fw_unpack(uint8_t *buf, size_t size, fw_extract_callback_t cb); 31 31 + /* Check if a file looks like an AFI file */ 32 32 + bool fw_check(uint8_t *buf, size_t size); 33 33 + 34 34 + #endif /* __FW_H__ */

+5 -5

utils/atj2137/atjboottool/fwu.c

··· 149 149 } 150 150 for(int i = 20; i < 32; i++) 151 151 key[i] = key[i - 20]; 152 152 - 152 152 + 153 153 for(int i = 0; i < 992; i++) 154 154 block[i] ^= key[i % 32] ^ g_check_block_A_table[i]; 155 155 - 155 155 + 156 156 return check_block(block - 1, block + 1000, 1001); 157 157 } 158 158 ··· 277 277 g_crypto_info_byte = block[offset - 1]; 278 278 g_decode_buffer = malloc(g_decode_A_info.size); 279 279 g_decode_buffer2 = malloc(g_decode_A_info.size); 280 280 - 280 280 + 281 281 memset(g_decode_buffer, 0, g_decode_A_info.size); 282 282 memset(g_decode_buffer2, 0, g_decode_A_info.size); 283 283 ··· 288 288 289 289 cprintf_field(" Word: ", "%d ", *(uint16_t *)&g_subblock_A[286]); 290 290 check_field(*(uint16_t *)&g_subblock_A[286], 1, "Ok\n", "Mismatch\n"); 291 291 - 291 291 + 292 292 return 0; 293 293 } 294 294 ··· 625 625 static int crypto4(uint8_t *a1, ptr_bundle_t *ptrs, uint32_t *a3) 626 626 { 627 627 ptr_bundle_t ptrs_others; 628 628 - 628 628 + 629 629 ptrs_others.ptrA = malloc(g_decode_A_info.size); 630 630 ptrs_others.ptrB = malloc(g_decode_A_info.size); 631 631 clear_memory(ptrs_others.ptrA, g_decode_A_info.nr_dwords);