package/system/fwtool/src/fwtool.c

   1 /*
   2  * Copyright (C) 2016 Felix Fietkau <nbd@nbd.name>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2
   6  * as published by the Free Software Foundation
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  */
  13 #include <sys/types.h>
  14 #include <stdio.h>
  15 #include <getopt.h>
  16 #include <stdbool.h>
  17 #include <stdlib.h>
  18 #include <string.h>
  19 #include <unistd.h>
  20
  21 #include "fwimage.h"
  22 #include "utils.h"
  23 #include "crc32.h"
  24
  25 #define METADATA_MAXLEN         30 * 1024
  26 #define SIGNATURE_MAXLEN        1 * 1024
  27
  28 #define BUFLEN                  (METADATA_MAXLEN + SIGNATURE_MAXLEN + 1024)
  29
  30 enum {
  31         MODE_DEFAULT = -1,
  32         MODE_EXTRACT = 0,
  33         MODE_APPEND = 1,
  34 };
  35
  36 struct data_buf {
  37         char *cur;
  38         char *prev;
  39         int cur_len;
  40         int file_len;
  41 };
  42
  43 static FILE *signature_file, *metadata_file, *firmware_file;
  44 static int file_mode = MODE_DEFAULT;
  45 static bool truncate_file;
  46 static bool quiet = false;
  47
  48 static uint32_t crc_table[256];
  49
  50 #define msg(...)                                        \
  51         do {                                            \
  52                 if (!quiet)                             \
  53                         fprintf(stderr, __VA_ARGS__);   \
  54         } while (0)
  55
  56 static int
  57 usage(const char *progname)
  58 {
  59         fprintf(stderr, "Usage: %s <options> <firmware>\n"
  60                 "\n"
  61                 "Options:\n"
  62                 "  -S <file>:           Append signature file to firmware image\n"
  63                 "  -I <file>:           Append metadata file to firmware image\n"
  64                 "  -s <file>:           Extract signature file from firmware image\n"
  65                 "  -i <file>:           Extract metadata file from firmware image\n"
  66                 "  -t:                  Remove extracted chunks from firmare image (using -s, -i)\n"
  67                 "  -q:                  Quiet (suppress error messages)\n"
  68                 "\n", progname);
  69         return 1;
  70 }
  71
  72 static FILE *
  73 open_file(const char *name, bool write)
  74 {
  75         FILE *ret;
  76
  77         if (!strcmp(name, "-"))
  78                 return write ? stdout : stdin;
  79
  80         ret = fopen(name, write ? "w" : "r+");
  81         if (!ret && !write)
  82                 ret = fopen(name, "r");
  83
  84         return ret;
  85 }
  86
  87 static int
  88 set_file(FILE **file, const char *name, int mode)
  89 {
  90         if (file_mode < 0)
  91                 file_mode = mode;
  92         else if (file_mode != mode) {
  93                 msg("Error: mixing appending and extracting data is not supported\n");
  94                 return 1;
  95         }
  96
  97         if (*file) {
  98                 msg("Error: the same append/extract option cannot be used multiple times\n");
  99                 return 1;
 100         }
 101
 102         *file = open_file(name, mode == MODE_EXTRACT);
 103         return !*file;
 104 }
 105
 106 static void
 107 trailer_update_crc(struct fwimage_trailer *tr, void *buf, int len)
 108 {
 109         tr->crc32 = cpu_to_be32(crc32_block(be32_to_cpu(tr->crc32), buf, len, crc_table));
 110 }
 111
 112 static int
 113 append_data(FILE *in, FILE *out, struct fwimage_trailer *tr, int maxlen)
 114 {
 115         while (1) {
 116                 char buf[512];
 117                 int len;
 118
 119                 len = fread(buf, 1, sizeof(buf), in);
 120                 if (!len)
 121                         break;
 122
 123                 maxlen -= len;
 124                 if (maxlen < 0)
 125                         return 1;
 126
 127                 tr->size += len;
 128                 trailer_update_crc(tr, buf, len);
 129                 fwrite(buf, len, 1, out);
 130         }
 131
 132         return 0;
 133 }
 134
 135 static void
 136 append_trailer(FILE *out, struct fwimage_trailer *tr)
 137 {
 138         tr->size = cpu_to_be32(tr->size);
 139         fwrite(tr, sizeof(*tr), 1, out);
 140         trailer_update_crc(tr, tr, sizeof(*tr));
 141 }
 142
 143 static int
 144 add_metadata(struct fwimage_trailer *tr)
 145 {
 146         struct fwimage_header hdr = {};
 147
 148         tr->type = FWIMAGE_INFO;
 149         tr->size = sizeof(hdr) + sizeof(*tr);
 150
 151         trailer_update_crc(tr, &hdr, sizeof(hdr));
 152         fwrite(&hdr, sizeof(hdr), 1, firmware_file);
 153
 154         if (append_data(metadata_file, firmware_file, tr, METADATA_MAXLEN))
 155                 return 1;
 156
 157         append_trailer(firmware_file, tr);
 158
 159         return 0;
 160 }
 161
 162 static int
 163 add_signature(struct fwimage_trailer *tr)
 164 {
 165         if (!signature_file)
 166                 return 0;
 167
 168         tr->type = FWIMAGE_SIGNATURE;
 169         tr->size = sizeof(*tr);
 170
 171         if (append_data(signature_file, firmware_file, tr, SIGNATURE_MAXLEN))
 172                 return 1;
 173
 174         append_trailer(firmware_file, tr);
 175
 176         return 0;
 177 }
 178
 179 static int
 180 add_data(const char *name)
 181 {
 182         struct fwimage_trailer tr = {
 183                 .magic = cpu_to_be32(FWIMAGE_MAGIC),
 184                 .crc32 = ~0,
 185         };
 186         int file_len = 0;
 187         int ret = 0;
 188
 189         firmware_file = fopen(name, "r+");
 190         if (!firmware_file) {
 191                 msg("Failed to open firmware file\n");
 192                 return 1;
 193         }
 194
 195         while (1) {
 196                 char buf[512];
 197                 int len;
 198
 199                 len = fread(buf, 1, sizeof(buf), firmware_file);
 200                 if (!len)
 201                         break;
 202
 203                 file_len += len;
 204                 trailer_update_crc(&tr, buf, len);
 205         }
 206
 207         if (metadata_file)
 208                 ret = add_metadata(&tr);
 209         else if (signature_file)
 210                 ret = add_signature(&tr);
 211
 212         if (ret) {
 213                 fflush(firmware_file);
 214                 ftruncate(fileno(firmware_file), file_len);
 215         }
 216
 217         return ret;
 218 }
 219
 220 static void
 221 remove_tail(struct data_buf *dbuf, int len)
 222 {
 223         dbuf->cur_len -= len;
 224         dbuf->file_len -= len;
 225
 226         if (dbuf->cur_len)
 227                 return;
 228
 229         free(dbuf->cur);
 230         dbuf->cur = dbuf->prev;
 231         dbuf->prev = NULL;
 232         dbuf->cur_len = BUFLEN;
 233 }
 234
 235 static int
 236 extract_tail(struct data_buf *dbuf, void *dest, int len)
 237 {
 238         int cur_len = dbuf->cur_len;
 239
 240         if (!dbuf->cur)
 241                 return 1;
 242
 243         if (cur_len >= len)
 244                 cur_len = len;
 245
 246         memcpy(dest + (len - cur_len), dbuf->cur + dbuf->cur_len - cur_len, cur_len);
 247         remove_tail(dbuf, cur_len);
 248
 249         cur_len = len - cur_len;
 250         if (cur_len && !dbuf->cur)
 251                 return 1;
 252
 253         memcpy(dest, dbuf->cur + dbuf->cur_len - cur_len, cur_len);
 254         remove_tail(dbuf, cur_len);
 255
 256         return 0;
 257 }
 258
 259 static uint32_t
 260 tail_crc32(struct data_buf *dbuf, uint32_t crc32)
 261 {
 262         if (dbuf->prev)
 263                 crc32 = crc32_block(crc32, dbuf->prev, BUFLEN, crc_table);
 264
 265         return crc32_block(crc32, dbuf->cur, dbuf->cur_len, crc_table);
 266 }
 267
 268 static int
 269 validate_metadata(struct fwimage_header *hdr, int data_len)
 270 {
 271          if (hdr->version != 0)
 272                  return 1;
 273          return 0;
 274 }
 275
 276 static int
 277 extract_data(const char *name)
 278 {
 279         struct fwimage_header *hdr;
 280         struct fwimage_trailer tr;
 281         struct data_buf dbuf = {};
 282         uint32_t crc32 = ~0;
 283         int ret = 1;
 284         void *buf;
 285
 286         firmware_file = open_file(name, false);
 287         if (!firmware_file) {
 288                 msg("Failed to open firmware file\n");
 289                 return 1;
 290         }
 291
 292         if (truncate_file && firmware_file == stdin) {
 293                 msg("Cannot truncate file when reading from stdin\n");
 294                 return 1;
 295         }
 296
 297         buf = malloc(BUFLEN);
 298         if (!buf)
 299                 return 1;
 300
 301         do {
 302                 char *tmp = dbuf.cur;
 303
 304                 dbuf.cur = dbuf.prev;
 305                 dbuf.prev = tmp;
 306
 307                 if (dbuf.cur)
 308                         crc32 = crc32_block(crc32, dbuf.cur, BUFLEN, crc_table);
 309                 else
 310                         dbuf.cur = malloc(BUFLEN);
 311
 312                 if (!dbuf.cur)
 313                         goto out;
 314
 315                 dbuf.cur_len = fread(dbuf.cur, 1, BUFLEN, firmware_file);
 316                 dbuf.file_len += dbuf.cur_len;
 317         } while (dbuf.cur_len == BUFLEN);
 318
 319         while (1) {
 320                 int data_len;
 321
 322                 if (extract_tail(&dbuf, &tr, sizeof(tr)))
 323                         break;
 324
 325                 data_len = be32_to_cpu(tr.size) - sizeof(tr);
 326                 if (tr.magic != cpu_to_be32(FWIMAGE_MAGIC)) {
 327                         msg("Data not found\n");
 328                         break;
 329                 }
 330
 331                 if (be32_to_cpu(tr.crc32) != tail_crc32(&dbuf, crc32)) {
 332                         msg("CRC error\n");
 333                         break;
 334                 }
 335
 336                 if (data_len > BUFLEN) {
 337                         msg("Size error\n");
 338                         break;
 339                 }
 340
 341                 extract_tail(&dbuf, buf, data_len);
 342
 343                 if (tr.type == FWIMAGE_SIGNATURE) {
 344                         if (!signature_file)
 345                                 continue;
 346                         fwrite(buf, data_len, 1, signature_file);
 347                         ret = 0;
 348                         break;
 349                 } else if (tr.type == FWIMAGE_INFO) {
 350                         if (!metadata_file) {
 351                                 dbuf.file_len += data_len + sizeof(tr);
 352                                 break;
 353                         }
 354
 355                         hdr = buf;
 356                         data_len -= sizeof(*hdr);
 357                         if (validate_metadata(hdr, data_len))
 358                                 continue;
 359
 360                         fwrite(hdr + 1, data_len, 1, metadata_file);
 361                         ret = 0;
 362                         break;
 363                 } else {
 364                         continue;
 365                 }
 366         }
 367
 368         if (!ret && truncate_file)
 369                 ftruncate(fileno(firmware_file), dbuf.file_len);
 370
 371 out:
 372         free(buf);
 373         free(dbuf.cur);
 374         free(dbuf.prev);
 375         return ret;
 376 }
 377
 378 static void cleanup(void)
 379 {
 380         if (signature_file)
 381                 fclose(signature_file);
 382         if (metadata_file)
 383                 fclose(metadata_file);
 384         if (firmware_file)
 385                 fclose(firmware_file);
 386 }
 387
 388 int main(int argc, char **argv)
 389 {
 390         const char *progname = argv[0];
 391         int ret, ch;
 392
 393         crc32_filltable(crc_table);
 394
 395         while ((ch = getopt(argc, argv, "i:I:qs:S:t")) != -1) {
 396                 ret = 0;
 397                 switch(ch) {
 398                 case 'S':
 399                         ret = set_file(&signature_file, optarg, MODE_APPEND);
 400                         break;
 401                 case 'I':
 402                         ret = set_file(&metadata_file, optarg, MODE_APPEND);
 403                         break;
 404                 case 's':
 405                         ret = set_file(&signature_file, optarg, MODE_EXTRACT);
 406                         break;
 407                 case 'i':
 408                         ret = set_file(&metadata_file, optarg, MODE_EXTRACT);
 409                         break;
 410                 case 't':
 411                         truncate_file = true;
 412                         break;
 413                 case 'q':
 414                         quiet = true;
 415                         break;
 416                 }
 417
 418                 if (ret)
 419                         goto out;
 420         }
 421
 422         if (optind >= argc) {
 423                 ret = usage(progname);
 424                 goto out;
 425         }
 426
 427         if (file_mode == MODE_DEFAULT) {
 428                 ret = usage(progname);
 429                 goto out;
 430         }
 431
 432         if (signature_file && metadata_file) {
 433                 msg("Cannot append/extract metadata and signature in one run\n");
 434                 return 1;
 435         }
 436
 437         if (file_mode)
 438                 ret = add_data(argv[optind]);
 439         else
 440                 ret = extract_data(argv[optind]);
 441
 442 out:
 443         cleanup();
 444         return ret;
 445 }