tools/kwbimage.c

   1 /*
   2  * Image manipulator for Marvell SoCs
   3  *  supports Kirkwood, Dove, Armada 370, Armada XP, and Armada 38x
   4  *
   5  * (C) Copyright 2013 Thomas Petazzoni
   6  * <thomas.petazzoni@free-electrons.com>
   7  *
   8  * SPDX-License-Identifier:     GPL-2.0+
   9  *
  10  * Not implemented: support for the register headers in v1 images
  11  */
  12
  13 #include "imagetool.h"
  14 #include <limits.h>
  15 #include <image.h>
  16 #include <stdarg.h>
  17 #include <stdint.h>
  18 #include "kwbimage.h"
  19
  20 #ifdef CONFIG_KWB_SECURE
  21 #include <openssl/bn.h>
  22 #include <openssl/rsa.h>
  23 #include <openssl/pem.h>
  24 #include <openssl/err.h>
  25 #include <openssl/evp.h>
  26
  27 #if OPENSSL_VERSION_NUMBER < 0x10100000L || \
  28     (defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER < 0x2070000fL)
  29 static void RSA_get0_key(const RSA *r,
  30                  const BIGNUM **n, const BIGNUM **e, const BIGNUM **d)
  31 {
  32    if (n != NULL)
  33        *n = r->n;
  34    if (e != NULL)
  35        *e = r->e;
  36    if (d != NULL)
  37        *d = r->d;
  38 }
  39
  40 #elif !defined(LIBRESSL_VERSION_NUMBER)
  41 void EVP_MD_CTX_cleanup(EVP_MD_CTX *ctx)
  42 {
  43         EVP_MD_CTX_reset(ctx);
  44 }
  45 #endif
  46 #endif
  47
  48 static struct image_cfg_element *image_cfg;
  49 static int cfgn;
  50 #ifdef CONFIG_KWB_SECURE
  51 static int verbose_mode;
  52 #endif
  53
  54 struct boot_mode {
  55         unsigned int id;
  56         const char *name;
  57 };
  58
  59 /*
  60  * SHA2-256 hash
  61  */
  62 struct hash_v1 {
  63         uint8_t hash[32];
  64 };
  65
  66 struct boot_mode boot_modes[] = {
  67         { 0x4D, "i2c"  },
  68         { 0x5A, "spi"  },
  69         { 0x8B, "nand" },
  70         { 0x78, "sata" },
  71         { 0x9C, "pex"  },
  72         { 0x69, "uart" },
  73         { 0xAE, "sdio" },
  74         {},
  75 };
  76
  77 struct nand_ecc_mode {
  78         unsigned int id;
  79         const char *name;
  80 };
  81
  82 struct nand_ecc_mode nand_ecc_modes[] = {
  83         { 0x00, "default" },
  84         { 0x01, "hamming" },
  85         { 0x02, "rs" },
  86         { 0x03, "disabled" },
  87         {},
  88 };
  89
  90 /* Used to identify an undefined execution or destination address */
  91 #define ADDR_INVALID ((uint32_t)-1)
  92
  93 #define BINARY_MAX_ARGS 8
  94
  95 /* In-memory representation of a line of the configuration file */
  96
  97 enum image_cfg_type {
  98         IMAGE_CFG_VERSION = 0x1,
  99         IMAGE_CFG_BOOT_FROM,
 100         IMAGE_CFG_DEST_ADDR,
 101         IMAGE_CFG_EXEC_ADDR,
 102         IMAGE_CFG_NAND_BLKSZ,
 103         IMAGE_CFG_NAND_BADBLK_LOCATION,
 104         IMAGE_CFG_NAND_ECC_MODE,
 105         IMAGE_CFG_NAND_PAGESZ,
 106         IMAGE_CFG_BINARY,
 107         IMAGE_CFG_PAYLOAD,
 108         IMAGE_CFG_DATA,
 109         IMAGE_CFG_BAUDRATE,
 110         IMAGE_CFG_DEBUG,
 111         IMAGE_CFG_KAK,
 112         IMAGE_CFG_CSK,
 113         IMAGE_CFG_CSK_INDEX,
 114         IMAGE_CFG_JTAG_DELAY,
 115         IMAGE_CFG_BOX_ID,
 116         IMAGE_CFG_FLASH_ID,
 117         IMAGE_CFG_SEC_COMMON_IMG,
 118         IMAGE_CFG_SEC_SPECIALIZED_IMG,
 119         IMAGE_CFG_SEC_BOOT_DEV,
 120         IMAGE_CFG_SEC_FUSE_DUMP,
 121
 122         IMAGE_CFG_COUNT
 123 } type;
 124
 125 static const char * const id_strs[] = {
 126         [IMAGE_CFG_VERSION] = "VERSION",
 127         [IMAGE_CFG_BOOT_FROM] = "BOOT_FROM",
 128         [IMAGE_CFG_DEST_ADDR] = "DEST_ADDR",
 129         [IMAGE_CFG_EXEC_ADDR] = "EXEC_ADDR",
 130         [IMAGE_CFG_NAND_BLKSZ] = "NAND_BLKSZ",
 131         [IMAGE_CFG_NAND_BADBLK_LOCATION] = "NAND_BADBLK_LOCATION",
 132         [IMAGE_CFG_NAND_ECC_MODE] = "NAND_ECC_MODE",
 133         [IMAGE_CFG_NAND_PAGESZ] = "NAND_PAGE_SIZE",
 134         [IMAGE_CFG_BINARY] = "BINARY",
 135         [IMAGE_CFG_PAYLOAD] = "PAYLOAD",
 136         [IMAGE_CFG_DATA] = "DATA",
 137         [IMAGE_CFG_BAUDRATE] = "BAUDRATE",
 138         [IMAGE_CFG_DEBUG] = "DEBUG",
 139         [IMAGE_CFG_KAK] = "KAK",
 140         [IMAGE_CFG_CSK] = "CSK",
 141         [IMAGE_CFG_CSK_INDEX] = "CSK_INDEX",
 142         [IMAGE_CFG_JTAG_DELAY] = "JTAG_DELAY",
 143         [IMAGE_CFG_BOX_ID] = "BOX_ID",
 144         [IMAGE_CFG_FLASH_ID] = "FLASH_ID",
 145         [IMAGE_CFG_SEC_COMMON_IMG] = "SEC_COMMON_IMG",
 146         [IMAGE_CFG_SEC_SPECIALIZED_IMG] = "SEC_SPECIALIZED_IMG",
 147         [IMAGE_CFG_SEC_BOOT_DEV] = "SEC_BOOT_DEV",
 148         [IMAGE_CFG_SEC_FUSE_DUMP] = "SEC_FUSE_DUMP"
 149 };
 150
 151 struct image_cfg_element {
 152         enum image_cfg_type type;
 153         union {
 154                 unsigned int version;
 155                 unsigned int bootfrom;
 156                 struct {
 157                         const char *file;
 158                         unsigned int args[BINARY_MAX_ARGS];
 159                         unsigned int nargs;
 160                 } binary;
 161                 const char *payload;
 162                 unsigned int dstaddr;
 163                 unsigned int execaddr;
 164                 unsigned int nandblksz;
 165                 unsigned int nandbadblklocation;
 166                 unsigned int nandeccmode;
 167                 unsigned int nandpagesz;
 168                 struct ext_hdr_v0_reg regdata;
 169                 unsigned int baudrate;
 170                 unsigned int debug;
 171                 const char *key_name;
 172                 int csk_idx;
 173                 uint8_t jtag_delay;
 174                 uint32_t boxid;
 175                 uint32_t flashid;
 176                 bool sec_specialized_img;
 177                 unsigned int sec_boot_dev;
 178                 const char *name;
 179         };
 180 };
 181
 182 #define IMAGE_CFG_ELEMENT_MAX 256
 183
 184 /*
 185  * Utility functions to manipulate boot mode and ecc modes (convert
 186  * them back and forth between description strings and the
 187  * corresponding numerical identifiers).
 188  */
 189
 190 static const char *image_boot_mode_name(unsigned int id)
 191 {
 192         int i;
 193
 194         for (i = 0; boot_modes[i].name; i++)
 195                 if (boot_modes[i].id == id)
 196                         return boot_modes[i].name;
 197         return NULL;
 198 }
 199
 200 int image_boot_mode_id(const char *boot_mode_name)
 201 {
 202         int i;
 203
 204         for (i = 0; boot_modes[i].name; i++)
 205                 if (!strcmp(boot_modes[i].name, boot_mode_name))
 206                         return boot_modes[i].id;
 207
 208         return -1;
 209 }
 210
 211 int image_nand_ecc_mode_id(const char *nand_ecc_mode_name)
 212 {
 213         int i;
 214
 215         for (i = 0; nand_ecc_modes[i].name; i++)
 216                 if (!strcmp(nand_ecc_modes[i].name, nand_ecc_mode_name))
 217                         return nand_ecc_modes[i].id;
 218         return -1;
 219 }
 220
 221 static struct image_cfg_element *
 222 image_find_option(unsigned int optiontype)
 223 {
 224         int i;
 225
 226         for (i = 0; i < cfgn; i++) {
 227                 if (image_cfg[i].type == optiontype)
 228                         return &image_cfg[i];
 229         }
 230
 231         return NULL;
 232 }
 233
 234 static unsigned int
 235 image_count_options(unsigned int optiontype)
 236 {
 237         int i;
 238         unsigned int count = 0;
 239
 240         for (i = 0; i < cfgn; i++)
 241                 if (image_cfg[i].type == optiontype)
 242                         count++;
 243
 244         return count;
 245 }
 246
 247 #if defined(CONFIG_KWB_SECURE)
 248
 249 static int image_get_csk_index(void)
 250 {
 251         struct image_cfg_element *e;
 252
 253         e = image_find_option(IMAGE_CFG_CSK_INDEX);
 254         if (!e)
 255                 return -1;
 256
 257         return e->csk_idx;
 258 }
 259
 260 static bool image_get_spezialized_img(void)
 261 {
 262         struct image_cfg_element *e;
 263
 264         e = image_find_option(IMAGE_CFG_SEC_SPECIALIZED_IMG);
 265         if (!e)
 266                 return false;
 267
 268         return e->sec_specialized_img;
 269 }
 270
 271 #endif
 272
 273 /*
 274  * Compute a 8-bit checksum of a memory area. This algorithm follows
 275  * the requirements of the Marvell SoC BootROM specifications.
 276  */
 277 static uint8_t image_checksum8(void *start, uint32_t len)
 278 {
 279         uint8_t csum = 0;
 280         uint8_t *p = start;
 281
 282         /* check len and return zero checksum if invalid */
 283         if (!len)
 284                 return 0;
 285
 286         do {
 287                 csum += *p;
 288                 p++;
 289         } while (--len);
 290
 291         return csum;
 292 }
 293
 294 size_t kwbimage_header_size(unsigned char *ptr)
 295 {
 296         if (image_version((void *)ptr) == 0)
 297                 return sizeof(struct main_hdr_v0);
 298         else
 299                 return KWBHEADER_V1_SIZE((struct main_hdr_v1 *)ptr);
 300 }
 301
 302 /*
 303  * Verify checksum over a complete header that includes the checksum field.
 304  * Return 1 when OK, otherwise 0.
 305  */
 306 static int main_hdr_checksum_ok(void *hdr)
 307 {
 308         /* Offsets of checksum in v0 and v1 headers are the same */
 309         struct main_hdr_v0 *main_hdr = (struct main_hdr_v0 *)hdr;
 310         uint8_t checksum;
 311
 312         checksum = image_checksum8(hdr, kwbimage_header_size(hdr));
 313         /* Calculated checksum includes the header checksum field. Compensate
 314          * for that.
 315          */
 316         checksum -= main_hdr->checksum;
 317
 318         return checksum == main_hdr->checksum;
 319 }
 320
 321 static uint32_t image_checksum32(void *start, uint32_t len)
 322 {
 323         uint32_t csum = 0;
 324         uint32_t *p = start;
 325
 326         /* check len and return zero checksum if invalid */
 327         if (!len)
 328                 return 0;
 329
 330         if (len % sizeof(uint32_t)) {
 331                 fprintf(stderr, "Length %d is not in multiple of %zu\n",
 332                         len, sizeof(uint32_t));
 333                 return 0;
 334         }
 335
 336         do {
 337                 csum += *p;
 338                 p++;
 339                 len -= sizeof(uint32_t);
 340         } while (len > 0);
 341
 342         return csum;
 343 }
 344
 345 static uint8_t baudrate_to_option(unsigned int baudrate)
 346 {
 347         switch (baudrate) {
 348         case 2400:
 349                 return MAIN_HDR_V1_OPT_BAUD_2400;
 350         case 4800:
 351                 return MAIN_HDR_V1_OPT_BAUD_4800;
 352         case 9600:
 353                 return MAIN_HDR_V1_OPT_BAUD_9600;
 354         case 19200:
 355                 return MAIN_HDR_V1_OPT_BAUD_19200;
 356         case 38400:
 357                 return MAIN_HDR_V1_OPT_BAUD_38400;
 358         case 57600:
 359                 return MAIN_HDR_V1_OPT_BAUD_57600;
 360         case 115200:
 361                 return MAIN_HDR_V1_OPT_BAUD_115200;
 362         default:
 363                 return MAIN_HDR_V1_OPT_BAUD_DEFAULT;
 364         }
 365 }
 366
 367 #if defined(CONFIG_KWB_SECURE)
 368 static void kwb_msg(const char *fmt, ...)
 369 {
 370         if (verbose_mode) {
 371                 va_list ap;
 372
 373                 va_start(ap, fmt);
 374                 vfprintf(stdout, fmt, ap);
 375                 va_end(ap);
 376         }
 377 }
 378
 379 static int openssl_err(const char *msg)
 380 {
 381         unsigned long ssl_err = ERR_get_error();
 382
 383         fprintf(stderr, "%s", msg);
 384         fprintf(stderr, ": %s\n",
 385                 ERR_error_string(ssl_err, 0));
 386
 387         return -1;
 388 }
 389
 390 static int kwb_load_rsa_key(const char *keydir, const char *name, RSA **p_rsa)
 391 {
 392         char path[PATH_MAX];
 393         RSA *rsa;
 394         FILE *f;
 395
 396         if (!keydir)
 397                 keydir = ".";
 398
 399         snprintf(path, sizeof(path), "%s/%s.key", keydir, name);
 400         f = fopen(path, "r");
 401         if (!f) {
 402                 fprintf(stderr, "Couldn't open RSA private key: '%s': %s\n",
 403                         path, strerror(errno));
 404                 return -ENOENT;
 405         }
 406
 407         rsa = PEM_read_RSAPrivateKey(f, 0, NULL, "");
 408         if (!rsa) {
 409                 openssl_err("Failure reading private key");
 410                 fclose(f);
 411                 return -EPROTO;
 412         }
 413         fclose(f);
 414         *p_rsa = rsa;
 415
 416         return 0;
 417 }
 418
 419 static int kwb_load_cfg_key(struct image_tool_params *params,
 420                             unsigned int cfg_option, const char *key_name,
 421                             RSA **p_key)
 422 {
 423         struct image_cfg_element *e_key;
 424         RSA *key;
 425         int res;
 426
 427         *p_key = NULL;
 428
 429         e_key = image_find_option(cfg_option);
 430         if (!e_key) {
 431                 fprintf(stderr, "%s not configured\n", key_name);
 432                 return -ENOENT;
 433         }
 434
 435         res = kwb_load_rsa_key(params->keydir, e_key->key_name, &key);
 436         if (res < 0) {
 437                 fprintf(stderr, "Failed to load %s\n", key_name);
 438                 return -ENOENT;
 439         }
 440
 441         *p_key = key;
 442
 443         return 0;
 444 }
 445
 446 static int kwb_load_kak(struct image_tool_params *params, RSA **p_kak)
 447 {
 448         return kwb_load_cfg_key(params, IMAGE_CFG_KAK, "KAK", p_kak);
 449 }
 450
 451 static int kwb_load_csk(struct image_tool_params *params, RSA **p_csk)
 452 {
 453         return kwb_load_cfg_key(params, IMAGE_CFG_CSK, "CSK", p_csk);
 454 }
 455
 456 static int kwb_compute_pubkey_hash(struct pubkey_der_v1 *pk,
 457                                    struct hash_v1 *hash)
 458 {
 459         EVP_MD_CTX *ctx;
 460         unsigned int key_size;
 461         unsigned int hash_size;
 462         int ret = 0;
 463
 464         if (!pk || !hash || pk->key[0] != 0x30 || pk->key[1] != 0x82)
 465                 return -EINVAL;
 466
 467         key_size = (pk->key[2] << 8) + pk->key[3] + 4;
 468
 469         ctx = EVP_MD_CTX_create();
 470         if (!ctx)
 471                 return openssl_err("EVP context creation failed");
 472
 473         EVP_MD_CTX_init(ctx);
 474         if (!EVP_DigestInit(ctx, EVP_sha256())) {
 475                 ret = openssl_err("Digest setup failed");
 476                 goto hash_err_ctx;
 477         }
 478
 479         if (!EVP_DigestUpdate(ctx, pk->key, key_size)) {
 480                 ret = openssl_err("Hashing data failed");
 481                 goto hash_err_ctx;
 482         }
 483
 484         if (!EVP_DigestFinal(ctx, hash->hash, &hash_size)) {
 485                 ret = openssl_err("Could not obtain hash");
 486                 goto hash_err_ctx;
 487         }
 488
 489         EVP_MD_CTX_cleanup(ctx);
 490
 491 hash_err_ctx:
 492         EVP_MD_CTX_destroy(ctx);
 493         return ret;
 494 }
 495
 496 static int kwb_import_pubkey(RSA **key, struct pubkey_der_v1 *src, char *keyname)
 497 {
 498         RSA *rsa;
 499         const unsigned char *ptr;
 500
 501         if (!key || !src)
 502                 goto fail;
 503
 504         ptr = src->key;
 505         rsa = d2i_RSAPublicKey(key, &ptr, sizeof(src->key));
 506         if (!rsa) {
 507                 openssl_err("error decoding public key");
 508                 goto fail;
 509         }
 510
 511         return 0;
 512 fail:
 513         fprintf(stderr, "Failed to decode %s pubkey\n", keyname);
 514         return -EINVAL;
 515 }
 516
 517 static int kwb_export_pubkey(RSA *key, struct pubkey_der_v1 *dst, FILE *hashf,
 518                              char *keyname)
 519 {
 520         int size_exp, size_mod, size_seq;
 521         const BIGNUM *key_e, *key_n;
 522         uint8_t *cur;
 523         char *errmsg = "Failed to encode %s\n";
 524
 525         RSA_get0_key(key, NULL, &key_e, NULL);
 526         RSA_get0_key(key, &key_n, NULL, NULL);
 527
 528         if (!key || !key_e || !key_n || !dst) {
 529                 fprintf(stderr, "export pk failed: (%p, %p, %p, %p)",
 530                         key, key_e, key_n, dst);
 531                 fprintf(stderr, errmsg, keyname);
 532                 return -EINVAL;
 533         }
 534
 535         /*
 536          * According to the specs, the key should be PKCS#1 DER encoded.
 537          * But unfortunately the really required encoding seems to be different;
 538          * it violates DER...! (But it still conformes to BER.)
 539          * (Length always in long form w/ 2 byte length code; no leading zero
 540          * when MSB of first byte is set...)
 541          * So we cannot use the encoding func provided by OpenSSL and have to
 542          * do the encoding manually.
 543          */
 544
 545         size_exp = BN_num_bytes(key_e);
 546         size_mod = BN_num_bytes(key_n);
 547         size_seq = 4 + size_mod + 4 + size_exp;
 548
 549         if (size_mod > 256) {
 550                 fprintf(stderr, "export pk failed: wrong mod size: %d\n",
 551                         size_mod);
 552                 fprintf(stderr, errmsg, keyname);
 553                 return -EINVAL;
 554         }
 555
 556         if (4 + size_seq > sizeof(dst->key)) {
 557                 fprintf(stderr, "export pk failed: seq too large (%d, %lu)\n",
 558                         4 + size_seq, sizeof(dst->key));
 559                 fprintf(stderr, errmsg, keyname);
 560                 return -ENOBUFS;
 561         }
 562
 563         cur = dst->key;
 564
 565         /* PKCS#1 (RFC3447) RSAPublicKey structure */
 566         *cur++ = 0x30;          /* SEQUENCE */
 567         *cur++ = 0x82;
 568         *cur++ = (size_seq >> 8) & 0xFF;
 569         *cur++ = size_seq & 0xFF;
 570         /* Modulus */
 571         *cur++ = 0x02;          /* INTEGER */
 572         *cur++ = 0x82;
 573         *cur++ = (size_mod >> 8) & 0xFF;
 574         *cur++ = size_mod & 0xFF;
 575         BN_bn2bin(key_n, cur);
 576         cur += size_mod;
 577         /* Exponent */
 578         *cur++ = 0x02;          /* INTEGER */
 579         *cur++ = 0x82;
 580         *cur++ = (size_exp >> 8) & 0xFF;
 581         *cur++ = size_exp & 0xFF;
 582         BN_bn2bin(key_e, cur);
 583
 584         if (hashf) {
 585                 struct hash_v1 pk_hash;
 586                 int i;
 587                 int ret = 0;
 588
 589                 ret = kwb_compute_pubkey_hash(dst, &pk_hash);
 590                 if (ret < 0) {
 591                         fprintf(stderr, errmsg, keyname);
 592                         return ret;
 593                 }
 594
 595                 fprintf(hashf, "SHA256 = ");
 596                 for (i = 0 ; i < sizeof(pk_hash.hash); ++i)
 597                         fprintf(hashf, "%02X", pk_hash.hash[i]);
 598                 fprintf(hashf, "\n");
 599         }
 600
 601         return 0;
 602 }
 603
 604 int kwb_sign(RSA *key, void *data, int datasz, struct sig_v1 *sig, char *signame)
 605 {
 606         EVP_PKEY *evp_key;
 607         EVP_MD_CTX *ctx;
 608         unsigned int sig_size;
 609         int size;
 610         int ret = 0;
 611
 612         evp_key = EVP_PKEY_new();
 613         if (!evp_key)
 614                 return openssl_err("EVP_PKEY object creation failed");
 615
 616         if (!EVP_PKEY_set1_RSA(evp_key, key)) {
 617                 ret = openssl_err("EVP key setup failed");
 618                 goto err_key;
 619         }
 620
 621         size = EVP_PKEY_size(evp_key);
 622         if (size > sizeof(sig->sig)) {
 623                 fprintf(stderr, "Buffer to small for signature (%d bytes)\n",
 624                         size);
 625                 ret = -ENOBUFS;
 626                 goto err_key;
 627         }
 628
 629         ctx = EVP_MD_CTX_create();
 630         if (!ctx) {
 631                 ret = openssl_err("EVP context creation failed");
 632                 goto err_key;
 633         }
 634         EVP_MD_CTX_init(ctx);
 635         if (!EVP_SignInit(ctx, EVP_sha256())) {
 636                 ret = openssl_err("Signer setup failed");
 637                 goto err_ctx;
 638         }
 639
 640         if (!EVP_SignUpdate(ctx, data, datasz)) {
 641                 ret = openssl_err("Signing data failed");
 642                 goto err_ctx;
 643         }
 644
 645         if (!EVP_SignFinal(ctx, sig->sig, &sig_size, evp_key)) {
 646                 ret = openssl_err("Could not obtain signature");
 647                 goto err_ctx;
 648         }
 649
 650         EVP_MD_CTX_cleanup(ctx);
 651         EVP_MD_CTX_destroy(ctx);
 652         EVP_PKEY_free(evp_key);
 653
 654         return 0;
 655
 656 err_ctx:
 657         EVP_MD_CTX_destroy(ctx);
 658 err_key:
 659         EVP_PKEY_free(evp_key);
 660         fprintf(stderr, "Failed to create %s signature\n", signame);
 661         return ret;
 662 }
 663
 664 int kwb_verify(RSA *key, void *data, int datasz, struct sig_v1 *sig,
 665                char *signame)
 666 {
 667         EVP_PKEY *evp_key;
 668         EVP_MD_CTX *ctx;
 669         int size;
 670         int ret = 0;
 671
 672         evp_key = EVP_PKEY_new();
 673         if (!evp_key)
 674                 return openssl_err("EVP_PKEY object creation failed");
 675
 676         if (!EVP_PKEY_set1_RSA(evp_key, key)) {
 677                 ret = openssl_err("EVP key setup failed");
 678                 goto err_key;
 679         }
 680
 681         size = EVP_PKEY_size(evp_key);
 682         if (size > sizeof(sig->sig)) {
 683                 fprintf(stderr, "Invalid signature size (%d bytes)\n",
 684                         size);
 685                 ret = -EINVAL;
 686                 goto err_key;
 687         }
 688
 689         ctx = EVP_MD_CTX_create();
 690         if (!ctx) {
 691                 ret = openssl_err("EVP context creation failed");
 692                 goto err_key;
 693         }
 694         EVP_MD_CTX_init(ctx);
 695         if (!EVP_VerifyInit(ctx, EVP_sha256())) {
 696                 ret = openssl_err("Verifier setup failed");
 697                 goto err_ctx;
 698         }
 699
 700         if (!EVP_VerifyUpdate(ctx, data, datasz)) {
 701                 ret = openssl_err("Hashing data failed");
 702                 goto err_ctx;
 703         }
 704
 705         if (!EVP_VerifyFinal(ctx, sig->sig, sizeof(sig->sig), evp_key)) {
 706                 ret = openssl_err("Could not verify signature");
 707                 goto err_ctx;
 708         }
 709
 710         EVP_MD_CTX_cleanup(ctx);
 711         EVP_MD_CTX_destroy(ctx);
 712         EVP_PKEY_free(evp_key);
 713
 714         return 0;
 715
 716 err_ctx:
 717         EVP_MD_CTX_destroy(ctx);
 718 err_key:
 719         EVP_PKEY_free(evp_key);
 720         fprintf(stderr, "Failed to verify %s signature\n", signame);
 721         return ret;
 722 }
 723
 724 int kwb_sign_and_verify(RSA *key, void *data, int datasz, struct sig_v1 *sig,
 725                         char *signame)
 726 {
 727         if (kwb_sign(key, data, datasz, sig, signame) < 0)
 728                 return -1;
 729
 730         if (kwb_verify(key, data, datasz, sig, signame) < 0)
 731                 return -1;
 732
 733         return 0;
 734 }
 735
 736
 737 int kwb_dump_fuse_cmds_38x(FILE *out, struct secure_hdr_v1 *sec_hdr)
 738 {
 739         struct hash_v1 kak_pub_hash;
 740         struct image_cfg_element *e;
 741         unsigned int fuse_line;
 742         int i, idx;
 743         uint8_t *ptr;
 744         uint32_t val;
 745         int ret = 0;
 746
 747         if (!out || !sec_hdr)
 748                 return -EINVAL;
 749
 750         ret = kwb_compute_pubkey_hash(&sec_hdr->kak, &kak_pub_hash);
 751         if (ret < 0)
 752                 goto done;
 753
 754         fprintf(out, "# burn KAK pub key hash\n");
 755         ptr = kak_pub_hash.hash;
 756         for (fuse_line = 26; fuse_line <= 30; ++fuse_line) {
 757                 fprintf(out, "fuse prog -y %u 0 ", fuse_line);
 758
 759                 for (i = 4; i-- > 0;)
 760                         fprintf(out, "%02hx", (ushort)ptr[i]);
 761                 ptr += 4;
 762                 fprintf(out, " 00");
 763
 764                 if (fuse_line < 30) {
 765                         for (i = 3; i-- > 0;)
 766                                 fprintf(out, "%02hx", (ushort)ptr[i]);
 767                         ptr += 3;
 768                 } else {
 769                         fprintf(out, "000000");
 770                 }
 771
 772                 fprintf(out, " 1\n");
 773         }
 774
 775         fprintf(out, "# burn CSK selection\n");
 776
 777         idx = image_get_csk_index();
 778         if (idx < 0 || idx > 15) {
 779                 ret = -EINVAL;
 780                 goto done;
 781         }
 782         if (idx > 0) {
 783                 for (fuse_line = 31; fuse_line < 31 + idx; ++fuse_line)
 784                         fprintf(out, "fuse prog -y %u 0 00000001 00000000 1\n",
 785                                 fuse_line);
 786         } else {
 787                 fprintf(out, "# CSK index is 0; no mods needed\n");
 788         }
 789
 790         e = image_find_option(IMAGE_CFG_BOX_ID);
 791         if (e) {
 792                 fprintf(out, "# set box ID\n");
 793                 fprintf(out, "fuse prog -y 48 0 %08x 00000000 1\n", e->boxid);
 794         }
 795
 796         e = image_find_option(IMAGE_CFG_FLASH_ID);
 797         if (e) {
 798                 fprintf(out, "# set flash ID\n");
 799                 fprintf(out, "fuse prog -y 47 0 %08x 00000000 1\n", e->flashid);
 800         }
 801
 802         fprintf(out, "# enable secure mode ");
 803         fprintf(out, "(must be the last fuse line written)\n");
 804
 805         val = 1;
 806         e = image_find_option(IMAGE_CFG_SEC_BOOT_DEV);
 807         if (!e) {
 808                 fprintf(stderr, "ERROR: secured mode boot device not given\n");
 809                 ret = -EINVAL;
 810                 goto done;
 811         }
 812
 813         if (e->sec_boot_dev > 0xff) {
 814                 fprintf(stderr, "ERROR: secured mode boot device invalid\n");
 815                 ret = -EINVAL;
 816                 goto done;
 817         }
 818
 819         val |= (e->sec_boot_dev << 8);
 820
 821         fprintf(out, "fuse prog -y 24 0 %08x 0103e0a9 1\n", val);
 822
 823         fprintf(out, "# lock (unused) fuse lines (0-23)s\n");
 824         for (fuse_line = 0; fuse_line < 24; ++fuse_line)
 825                 fprintf(out, "fuse prog -y %u 2 1\n", fuse_line);
 826
 827         fprintf(out, "# OK, that's all :-)\n");
 828
 829 done:
 830         return ret;
 831 }
 832
 833 static int kwb_dump_fuse_cmds(struct secure_hdr_v1 *sec_hdr)
 834 {
 835         int ret = 0;
 836         struct image_cfg_element *e;
 837
 838         e = image_find_option(IMAGE_CFG_SEC_FUSE_DUMP);
 839         if (!e)
 840                 return 0;
 841
 842         if (!strcmp(e->name, "a38x")) {
 843                 FILE *out = fopen("kwb_fuses_a38x.txt", "w+");
 844
 845                 kwb_dump_fuse_cmds_38x(out, sec_hdr);
 846                 fclose(out);
 847                 goto done;
 848         }
 849
 850         ret = -ENOSYS;
 851
 852 done:
 853         return ret;
 854 }
 855
 856 #endif
 857
 858 static void *image_create_v0(size_t *imagesz, struct image_tool_params *params,
 859                              int payloadsz)
 860 {
 861         struct image_cfg_element *e;
 862         size_t headersz;
 863         struct main_hdr_v0 *main_hdr;
 864         uint8_t *image;
 865         int has_ext = 0;
 866
 867         /*
 868          * Calculate the size of the header and the size of the
 869          * payload
 870          */
 871         headersz  = sizeof(struct main_hdr_v0);
 872
 873         if (image_count_options(IMAGE_CFG_DATA) > 0) {
 874                 has_ext = 1;
 875                 headersz += sizeof(struct ext_hdr_v0);
 876         }
 877
 878         if (image_count_options(IMAGE_CFG_PAYLOAD) > 1) {
 879                 fprintf(stderr, "More than one payload, not possible\n");
 880                 return NULL;
 881         }
 882
 883         image = malloc(headersz);
 884         if (!image) {
 885                 fprintf(stderr, "Cannot allocate memory for image\n");
 886                 return NULL;
 887         }
 888
 889         memset(image, 0, headersz);
 890
 891         main_hdr = (struct main_hdr_v0 *)image;
 892
 893         /* Fill in the main header */
 894         main_hdr->blocksize =
 895                 cpu_to_le32(payloadsz + sizeof(uint32_t) - headersz);
 896         main_hdr->srcaddr   = cpu_to_le32(headersz);
 897         main_hdr->ext       = has_ext;
 898         main_hdr->destaddr  = cpu_to_le32(params->addr);
 899         main_hdr->execaddr  = cpu_to_le32(params->ep);
 900
 901         e = image_find_option(IMAGE_CFG_BOOT_FROM);
 902         if (e)
 903                 main_hdr->blockid = e->bootfrom;
 904         e = image_find_option(IMAGE_CFG_NAND_ECC_MODE);
 905         if (e)
 906                 main_hdr->nandeccmode = e->nandeccmode;
 907         e = image_find_option(IMAGE_CFG_NAND_PAGESZ);
 908         if (e)
 909                 main_hdr->nandpagesize = cpu_to_le16(e->nandpagesz);
 910         main_hdr->checksum = image_checksum8(image,
 911                                              sizeof(struct main_hdr_v0));
 912
 913         /* Generate the ext header */
 914         if (has_ext) {
 915                 struct ext_hdr_v0 *ext_hdr;
 916                 int cfgi, datai;
 917
 918                 ext_hdr = (struct ext_hdr_v0 *)
 919                                 (image + sizeof(struct main_hdr_v0));
 920                 ext_hdr->offset = cpu_to_le32(0x40);
 921
 922                 for (cfgi = 0, datai = 0; cfgi < cfgn; cfgi++) {
 923                         e = &image_cfg[cfgi];
 924                         if (e->type != IMAGE_CFG_DATA)
 925                                 continue;
 926
 927                         ext_hdr->rcfg[datai].raddr =
 928                                 cpu_to_le32(e->regdata.raddr);
 929                         ext_hdr->rcfg[datai].rdata =
 930                                 cpu_to_le32(e->regdata.rdata);
 931                         datai++;
 932                 }
 933
 934                 ext_hdr->checksum = image_checksum8(ext_hdr,
 935                                                     sizeof(struct ext_hdr_v0));
 936         }
 937
 938         *imagesz = headersz;
 939         return image;
 940 }
 941
 942 static size_t image_headersz_v1(int *hasext)
 943 {
 944         struct image_cfg_element *binarye;
 945         size_t headersz;
 946
 947         /*
 948          * Calculate the size of the header and the size of the
 949          * payload
 950          */
 951         headersz = sizeof(struct main_hdr_v1);
 952
 953         if (image_count_options(IMAGE_CFG_BINARY) > 1) {
 954                 fprintf(stderr, "More than one binary blob, not supported\n");
 955                 return 0;
 956         }
 957
 958         if (image_count_options(IMAGE_CFG_PAYLOAD) > 1) {
 959                 fprintf(stderr, "More than one payload, not possible\n");
 960                 return 0;
 961         }
 962
 963         binarye = image_find_option(IMAGE_CFG_BINARY);
 964         if (binarye) {
 965                 int ret;
 966                 struct stat s;
 967
 968                 ret = stat(binarye->binary.file, &s);
 969                 if (ret < 0) {
 970                         char cwd[PATH_MAX];
 971                         char *dir = cwd;
 972
 973                         memset(cwd, 0, sizeof(cwd));
 974                         if (!getcwd(cwd, sizeof(cwd))) {
 975                                 dir = "current working directory";
 976                                 perror("getcwd() failed");
 977                         }
 978
 979                         fprintf(stderr,
 980                                 "Didn't find the file '%s' in '%s' which is mandatory to generate the image\n"
 981                                 "This file generally contains the DDR3 training code, and should be extracted from an existing bootable\n"
 982                                 "image for your board. See 'kwbimage -x' to extract it from an existing image.\n",
 983                                 binarye->binary.file, dir);
 984                         return 0;
 985                 }
 986
 987                 headersz += sizeof(struct opt_hdr_v1) +
 988                         s.st_size +
 989                         (binarye->binary.nargs + 2) * sizeof(uint32_t);
 990                 if (hasext)
 991                         *hasext = 1;
 992         }
 993
 994 #if defined(CONFIG_KWB_SECURE)
 995         if (image_get_csk_index() >= 0) {
 996                 headersz += sizeof(struct secure_hdr_v1);
 997                 if (hasext)
 998                         *hasext = 1;
 999         }
1000 #endif
1001
1002 #if defined(CONFIG_SYS_U_BOOT_OFFS)
1003         if (headersz > CONFIG_SYS_U_BOOT_OFFS) {
1004                 fprintf(stderr,
1005                         "Error: Image header (incl. SPL image) too big!\n");
1006                 fprintf(stderr, "header=0x%x CONFIG_SYS_U_BOOT_OFFS=0x%x!\n",
1007                         (int)headersz, CONFIG_SYS_U_BOOT_OFFS);
1008                 fprintf(stderr, "Increase CONFIG_SYS_U_BOOT_OFFS!\n");
1009                 return 0;
1010         }
1011
1012         headersz = CONFIG_SYS_U_BOOT_OFFS;
1013 #endif
1014
1015         /*
1016          * The payload should be aligned on some reasonable
1017          * boundary
1018          */
1019         return ALIGN_SUP(headersz, 4096);
1020 }
1021
1022 int add_binary_header_v1(uint8_t *cur)
1023 {
1024         struct image_cfg_element *binarye;
1025         struct opt_hdr_v1 *hdr = (struct opt_hdr_v1 *)cur;
1026         uint32_t *args;
1027         size_t binhdrsz;
1028         struct stat s;
1029         int argi;
1030         FILE *bin;
1031         int ret;
1032
1033         binarye = image_find_option(IMAGE_CFG_BINARY);
1034
1035         if (!binarye)
1036                 return 0;
1037
1038         hdr->headertype = OPT_HDR_V1_BINARY_TYPE;
1039
1040         bin = fopen(binarye->binary.file, "r");
1041         if (!bin) {
1042                 fprintf(stderr, "Cannot open binary file %s\n",
1043                         binarye->binary.file);
1044                 return -1;
1045         }
1046
1047         if (fstat(fileno(bin), &s)) {
1048                 fprintf(stderr, "Cannot stat binary file %s\n",
1049                         binarye->binary.file);
1050                 goto err_close;
1051         }
1052
1053         binhdrsz = sizeof(struct opt_hdr_v1) +
1054                 (binarye->binary.nargs + 2) * sizeof(uint32_t) +
1055                 s.st_size;
1056
1057         /*
1058          * The size includes the binary image size, rounded
1059          * up to a 4-byte boundary. Plus 4 bytes for the
1060          * next-header byte and 3-byte alignment at the end.
1061          */
1062         binhdrsz = ALIGN_SUP(binhdrsz, 4) + 4;
1063         hdr->headersz_lsb = cpu_to_le16(binhdrsz & 0xFFFF);
1064         hdr->headersz_msb = (binhdrsz & 0xFFFF0000) >> 16;
1065
1066         cur += sizeof(struct opt_hdr_v1);
1067
1068         args = (uint32_t *)cur;
1069         *args = cpu_to_le32(binarye->binary.nargs);
1070         args++;
1071         for (argi = 0; argi < binarye->binary.nargs; argi++)
1072                 args[argi] = cpu_to_le32(binarye->binary.args[argi]);
1073
1074         cur += (binarye->binary.nargs + 1) * sizeof(uint32_t);
1075
1076         ret = fread(cur, s.st_size, 1, bin);
1077         if (ret != 1) {
1078                 fprintf(stderr,
1079                         "Could not read binary image %s\n",
1080                         binarye->binary.file);
1081                 goto err_close;
1082         }
1083
1084         fclose(bin);
1085
1086         cur += ALIGN_SUP(s.st_size, 4);
1087
1088         /*
1089          * For now, we don't support more than one binary
1090          * header, and no other header types are
1091          * supported. So, the binary header is necessarily the
1092          * last one
1093          */
1094         *((uint32_t *)cur) = 0x00000000;
1095
1096         cur += sizeof(uint32_t);
1097
1098         return 0;
1099
1100 err_close:
1101         fclose(bin);
1102
1103         return -1;
1104 }
1105
1106 #if defined(CONFIG_KWB_SECURE)
1107
1108 int export_pub_kak_hash(RSA *kak, struct secure_hdr_v1 *secure_hdr)
1109 {
1110         FILE *hashf;
1111         int res;
1112
1113         hashf = fopen("pub_kak_hash.txt", "w");
1114
1115         res = kwb_export_pubkey(kak, &secure_hdr->kak, hashf, "KAK");
1116
1117         fclose(hashf);
1118
1119         return res < 0 ? 1 : 0;
1120 }
1121
1122 int kwb_sign_csk_with_kak(struct image_tool_params *params,
1123                           struct secure_hdr_v1 *secure_hdr, RSA *csk)
1124 {
1125         RSA *kak = NULL;
1126         RSA *kak_pub = NULL;
1127         int csk_idx = image_get_csk_index();
1128         struct sig_v1 tmp_sig;
1129
1130         if (csk_idx >= 16) {
1131                 fprintf(stderr, "Invalid CSK index %d\n", csk_idx);
1132                 return 1;
1133         }
1134
1135         if (kwb_load_kak(params, &kak) < 0)
1136                 return 1;
1137
1138         if (export_pub_kak_hash(kak, secure_hdr))
1139                 return 1;
1140
1141         if (kwb_import_pubkey(&kak_pub, &secure_hdr->kak, "KAK") < 0)
1142                 return 1;
1143
1144         if (kwb_export_pubkey(csk, &secure_hdr->csk[csk_idx], NULL, "CSK") < 0)
1145                 return 1;
1146
1147         if (kwb_sign_and_verify(kak, &secure_hdr->csk,
1148                                 sizeof(secure_hdr->csk) +
1149                                 sizeof(secure_hdr->csksig),
1150                                 &tmp_sig, "CSK") < 0)
1151                 return 1;
1152
1153         if (kwb_verify(kak_pub, &secure_hdr->csk,
1154                        sizeof(secure_hdr->csk) +
1155                        sizeof(secure_hdr->csksig),
1156                        &tmp_sig, "CSK (2)") < 0)
1157                 return 1;
1158
1159         secure_hdr->csksig = tmp_sig;
1160
1161         return 0;
1162 }
1163
1164 int add_secure_header_v1(struct image_tool_params *params, uint8_t *ptr,
1165                          int payloadsz, size_t headersz, uint8_t *image,
1166                          struct secure_hdr_v1 *secure_hdr)
1167 {
1168         struct image_cfg_element *e_jtagdelay;
1169         struct image_cfg_element *e_boxid;
1170         struct image_cfg_element *e_flashid;
1171         RSA *csk = NULL;
1172         unsigned char *image_ptr;
1173         size_t image_size;
1174         struct sig_v1 tmp_sig;
1175         bool specialized_img = image_get_spezialized_img();
1176
1177         kwb_msg("Create secure header content\n");
1178
1179         e_jtagdelay = image_find_option(IMAGE_CFG_JTAG_DELAY);
1180         e_boxid = image_find_option(IMAGE_CFG_BOX_ID);
1181         e_flashid = image_find_option(IMAGE_CFG_FLASH_ID);
1182
1183         if (kwb_load_csk(params, &csk) < 0)
1184                 return 1;
1185
1186         secure_hdr->headertype = OPT_HDR_V1_SECURE_TYPE;
1187         secure_hdr->headersz_msb = 0;
1188         secure_hdr->headersz_lsb = cpu_to_le16(sizeof(struct secure_hdr_v1));
1189         if (e_jtagdelay)
1190                 secure_hdr->jtag_delay = e_jtagdelay->jtag_delay;
1191         if (e_boxid && specialized_img)
1192                 secure_hdr->boxid = cpu_to_le32(e_boxid->boxid);
1193         if (e_flashid && specialized_img)
1194                 secure_hdr->flashid = cpu_to_le32(e_flashid->flashid);
1195
1196         if (kwb_sign_csk_with_kak(params, secure_hdr, csk))
1197                 return 1;
1198
1199         image_ptr = ptr + headersz;
1200         image_size = payloadsz - headersz;
1201
1202         if (kwb_sign_and_verify(csk, image_ptr, image_size,
1203                                 &secure_hdr->imgsig, "image") < 0)
1204                 return 1;
1205
1206         if (kwb_sign_and_verify(csk, image, headersz, &tmp_sig, "header") < 0)
1207                 return 1;
1208
1209         secure_hdr->hdrsig = tmp_sig;
1210
1211         kwb_dump_fuse_cmds(secure_hdr);
1212
1213         return 0;
1214 }
1215 #endif
1216
1217 static void *image_create_v1(size_t *imagesz, struct image_tool_params *params,
1218                              uint8_t *ptr, int payloadsz)
1219 {
1220         struct image_cfg_element *e;
1221         struct main_hdr_v1 *main_hdr;
1222 #if defined(CONFIG_KWB_SECURE)
1223         struct secure_hdr_v1 *secure_hdr = NULL;
1224 #endif
1225         size_t headersz;
1226         uint8_t *image, *cur;
1227         int hasext = 0;
1228         uint8_t *next_ext = NULL;
1229
1230         /*
1231          * Calculate the size of the header and the size of the
1232          * payload
1233          */
1234         headersz = image_headersz_v1(&hasext);
1235         if (headersz == 0)
1236                 return NULL;
1237
1238         image = malloc(headersz);
1239         if (!image) {
1240                 fprintf(stderr, "Cannot allocate memory for image\n");
1241                 return NULL;
1242         }
1243
1244         memset(image, 0, headersz);
1245
1246         main_hdr = (struct main_hdr_v1 *)image;
1247         cur = image;
1248         cur += sizeof(struct main_hdr_v1);
1249         next_ext = &main_hdr->ext;
1250
1251         /* Fill the main header */
1252         main_hdr->blocksize    =
1253                 cpu_to_le32(payloadsz - headersz + sizeof(uint32_t));
1254         main_hdr->headersz_lsb = cpu_to_le16(headersz & 0xFFFF);
1255         main_hdr->headersz_msb = (headersz & 0xFFFF0000) >> 16;
1256         main_hdr->destaddr     = cpu_to_le32(params->addr)
1257                                  - sizeof(image_header_t);
1258         main_hdr->execaddr     = cpu_to_le32(params->ep);
1259         main_hdr->srcaddr      = cpu_to_le32(headersz);
1260         main_hdr->ext          = hasext;
1261         main_hdr->version      = 1;
1262         e = image_find_option(IMAGE_CFG_BOOT_FROM);
1263         if (e)
1264                 main_hdr->blockid = e->bootfrom;
1265         e = image_find_option(IMAGE_CFG_NAND_BLKSZ);
1266         if (e)
1267                 main_hdr->nandblocksize = e->nandblksz / (64 * 1024);
1268         e = image_find_option(IMAGE_CFG_NAND_BADBLK_LOCATION);
1269         if (e)
1270                 main_hdr->nandbadblklocation = e->nandbadblklocation;
1271         e = image_find_option(IMAGE_CFG_BAUDRATE);
1272         if (e)
1273                 main_hdr->options = baudrate_to_option(e->baudrate);
1274         e = image_find_option(IMAGE_CFG_DEBUG);
1275         if (e)
1276                 main_hdr->flags = e->debug ? 0x1 : 0;
1277
1278 #if defined(CONFIG_KWB_SECURE)
1279         if (image_get_csk_index() >= 0) {
1280                 /*
1281                  * only reserve the space here; we fill the header later since
1282                  * we need the header to be complete to compute the signatures
1283                  */
1284                 secure_hdr = (struct secure_hdr_v1 *)cur;
1285                 cur += sizeof(struct secure_hdr_v1);
1286                 next_ext = &secure_hdr->next;
1287         }
1288 #endif
1289         *next_ext = 1;
1290
1291         if (add_binary_header_v1(cur))
1292                 return NULL;
1293
1294 #if defined(CONFIG_KWB_SECURE)
1295         if (secure_hdr && add_secure_header_v1(params, ptr, payloadsz,
1296                                                headersz, image, secure_hdr))
1297                 return NULL;
1298 #endif
1299
1300         /* Calculate and set the header checksum */
1301         main_hdr->checksum = image_checksum8(main_hdr, headersz);
1302
1303         *imagesz = headersz;
1304         return image;
1305 }
1306
1307 int recognize_keyword(char *keyword)
1308 {
1309         int kw_id;
1310
1311         for (kw_id = 1; kw_id < IMAGE_CFG_COUNT; ++kw_id)
1312                 if (!strcmp(keyword, id_strs[kw_id]))
1313                         return kw_id;
1314
1315         return 0;
1316 }
1317
1318 static int image_create_config_parse_oneline(char *line,
1319                                              struct image_cfg_element *el)
1320 {
1321         char *keyword, *saveptr, *value1, *value2;
1322         char delimiters[] = " \t";
1323         int keyword_id, ret, argi;
1324         char *unknown_msg = "Ignoring unknown line '%s'\n";
1325
1326         keyword = strtok_r(line, delimiters, &saveptr);
1327         keyword_id = recognize_keyword(keyword);
1328
1329         if (!keyword_id) {
1330                 fprintf(stderr, unknown_msg, line);
1331                 return 0;
1332         }
1333
1334         el->type = keyword_id;
1335
1336         value1 = strtok_r(NULL, delimiters, &saveptr);
1337
1338         if (!value1) {
1339                 fprintf(stderr, "Parameter missing in line '%s'\n", line);
1340                 return -1;
1341         }
1342
1343         switch (keyword_id) {
1344         case IMAGE_CFG_VERSION:
1345                 el->version = atoi(value1);
1346                 break;
1347         case IMAGE_CFG_BOOT_FROM:
1348                 ret = image_boot_mode_id(value1);
1349
1350                 if (ret < 0) {
1351                         fprintf(stderr, "Invalid boot media '%s'\n", value1);
1352                         return -1;
1353                 }
1354                 el->bootfrom = ret;
1355                 break;
1356         case IMAGE_CFG_NAND_BLKSZ:
1357                 el->nandblksz = strtoul(value1, NULL, 16);
1358                 break;
1359         case IMAGE_CFG_NAND_BADBLK_LOCATION:
1360                 el->nandbadblklocation = strtoul(value1, NULL, 16);
1361                 break;
1362         case IMAGE_CFG_NAND_ECC_MODE:
1363                 ret = image_nand_ecc_mode_id(value1);
1364
1365                 if (ret < 0) {
1366                         fprintf(stderr, "Invalid NAND ECC mode '%s'\n", value1);
1367                         return -1;
1368                 }
1369                 el->nandeccmode = ret;
1370                 break;
1371         case IMAGE_CFG_NAND_PAGESZ:
1372                 el->nandpagesz = strtoul(value1, NULL, 16);
1373                 break;
1374         case IMAGE_CFG_BINARY:
1375                 argi = 0;
1376
1377                 el->binary.file = strdup(value1);
1378                 while (1) {
1379                         char *value = strtok_r(NULL, delimiters, &saveptr);
1380
1381                         if (!value)
1382                                 break;
1383                         el->binary.args[argi] = strtoul(value, NULL, 16);
1384                         argi++;
1385                         if (argi >= BINARY_MAX_ARGS) {
1386                                 fprintf(stderr,
1387                                         "Too many arguments for BINARY\n");
1388                                 return -1;
1389                         }
1390                 }
1391                 el->binary.nargs = argi;
1392                 break;
1393         case IMAGE_CFG_DATA:
1394                 value2 = strtok_r(NULL, delimiters, &saveptr);
1395
1396                 if (!value1 || !value2) {
1397                         fprintf(stderr,
1398                                 "Invalid number of arguments for DATA\n");
1399                         return -1;
1400                 }
1401
1402                 el->regdata.raddr = strtoul(value1, NULL, 16);
1403                 el->regdata.rdata = strtoul(value2, NULL, 16);
1404                 break;
1405         case IMAGE_CFG_BAUDRATE:
1406                 el->baudrate = strtoul(value1, NULL, 10);
1407                 break;
1408         case IMAGE_CFG_DEBUG:
1409                 el->debug = strtoul(value1, NULL, 10);
1410                 break;
1411         case IMAGE_CFG_KAK:
1412                 el->key_name = strdup(value1);
1413                 break;
1414         case IMAGE_CFG_CSK:
1415                 el->key_name = strdup(value1);
1416                 break;
1417         case IMAGE_CFG_CSK_INDEX:
1418                 el->csk_idx = strtol(value1, NULL, 0);
1419                 break;
1420         case IMAGE_CFG_JTAG_DELAY:
1421                 el->jtag_delay = strtoul(value1, NULL, 0);
1422                 break;
1423         case IMAGE_CFG_BOX_ID:
1424                 el->boxid = strtoul(value1, NULL, 0);
1425                 break;
1426         case IMAGE_CFG_FLASH_ID:
1427                 el->flashid = strtoul(value1, NULL, 0);
1428                 break;
1429         case IMAGE_CFG_SEC_SPECIALIZED_IMG:
1430                 el->sec_specialized_img = true;
1431                 break;
1432         case IMAGE_CFG_SEC_COMMON_IMG:
1433                 el->sec_specialized_img = false;
1434                 break;
1435         case IMAGE_CFG_SEC_BOOT_DEV:
1436                 el->sec_boot_dev = strtoul(value1, NULL, 0);
1437                 break;
1438         case IMAGE_CFG_SEC_FUSE_DUMP:
1439                 el->name = strdup(value1);
1440                 break;
1441         default:
1442                 fprintf(stderr, unknown_msg, line);
1443         }
1444
1445         return 0;
1446 }
1447
1448 /*
1449  * Parse the configuration file 'fcfg' into the array of configuration
1450  * elements 'image_cfg', and return the number of configuration
1451  * elements in 'cfgn'.
1452  */
1453 static int image_create_config_parse(FILE *fcfg)
1454 {
1455         int ret;
1456         int cfgi = 0;
1457
1458         /* Parse the configuration file */
1459         while (!feof(fcfg)) {
1460                 char *line;
1461                 char buf[256];
1462
1463                 /* Read the current line */
1464                 memset(buf, 0, sizeof(buf));
1465                 line = fgets(buf, sizeof(buf), fcfg);
1466                 if (!line)
1467                         break;
1468
1469                 /* Ignore useless lines */
1470                 if (line[0] == '\n' || line[0] == '#')
1471                         continue;
1472
1473                 /* Strip final newline */
1474                 if (line[strlen(line) - 1] == '\n')
1475                         line[strlen(line) - 1] = 0;
1476
1477                 /* Parse the current line */
1478                 ret = image_create_config_parse_oneline(line,
1479                                                         &image_cfg[cfgi]);
1480                 if (ret)
1481                         return ret;
1482
1483                 cfgi++;
1484
1485                 if (cfgi >= IMAGE_CFG_ELEMENT_MAX) {
1486                         fprintf(stderr,
1487                                 "Too many configuration elements in .cfg file\n");
1488                         return -1;
1489                 }
1490         }
1491
1492         cfgn = cfgi;
1493         return 0;
1494 }
1495
1496 static int image_get_version(void)
1497 {
1498         struct image_cfg_element *e;
1499
1500         e = image_find_option(IMAGE_CFG_VERSION);
1501         if (!e)
1502                 return -1;
1503
1504         return e->version;
1505 }
1506
1507 static void kwbimage_set_header(void *ptr, struct stat *sbuf, int ifd,
1508                                 struct image_tool_params *params)
1509 {
1510         FILE *fcfg;
1511         void *image = NULL;
1512         int version;
1513         size_t headersz = 0;
1514         uint32_t checksum;
1515         int ret;
1516         int size;
1517
1518         fcfg = fopen(params->imagename, "r");
1519         if (!fcfg) {
1520                 fprintf(stderr, "Could not open input file %s\n",
1521                         params->imagename);
1522                 exit(EXIT_FAILURE);
1523         }
1524
1525         image_cfg = malloc(IMAGE_CFG_ELEMENT_MAX *
1526                            sizeof(struct image_cfg_element));
1527         if (!image_cfg) {
1528                 fprintf(stderr, "Cannot allocate memory\n");
1529                 fclose(fcfg);
1530                 exit(EXIT_FAILURE);
1531         }
1532
1533         memset(image_cfg, 0,
1534                IMAGE_CFG_ELEMENT_MAX * sizeof(struct image_cfg_element));
1535         rewind(fcfg);
1536
1537         ret = image_create_config_parse(fcfg);
1538         fclose(fcfg);
1539         if (ret) {
1540                 free(image_cfg);
1541                 exit(EXIT_FAILURE);
1542         }
1543
1544         /* The MVEBU BootROM does not allow non word aligned payloads */
1545         sbuf->st_size = ALIGN_SUP(sbuf->st_size, 4);
1546
1547         version = image_get_version();
1548         switch (version) {
1549                 /*
1550                  * Fallback to version 0 if no version is provided in the
1551                  * cfg file
1552                  */
1553         case -1:
1554         case 0:
1555                 image = image_create_v0(&headersz, params, sbuf->st_size);
1556                 break;
1557
1558         case 1:
1559                 image = image_create_v1(&headersz, params, ptr, sbuf->st_size);
1560                 break;
1561
1562         default:
1563                 fprintf(stderr, "Unsupported version %d\n", version);
1564                 free(image_cfg);
1565                 exit(EXIT_FAILURE);
1566         }
1567
1568         if (!image) {
1569                 fprintf(stderr, "Could not create image\n");
1570                 free(image_cfg);
1571                 exit(EXIT_FAILURE);
1572         }
1573
1574         free(image_cfg);
1575
1576         /* Build and add image checksum header */
1577         checksum =
1578                 cpu_to_le32(image_checksum32((uint32_t *)ptr, sbuf->st_size));
1579         size = write(ifd, &checksum, sizeof(uint32_t));
1580         if (size != sizeof(uint32_t)) {
1581                 fprintf(stderr, "Error:%s - Checksum write %d bytes %s\n",
1582                         params->cmdname, size, params->imagefile);
1583                 exit(EXIT_FAILURE);
1584         }
1585
1586         sbuf->st_size += sizeof(uint32_t);
1587
1588         /* Finally copy the header into the image area */
1589         memcpy(ptr, image, headersz);
1590
1591         free(image);
1592 }
1593
1594 static void kwbimage_print_header(const void *ptr)
1595 {
1596         struct main_hdr_v0 *mhdr = (struct main_hdr_v0 *)ptr;
1597
1598         printf("Image Type:   MVEBU Boot from %s Image\n",
1599                image_boot_mode_name(mhdr->blockid));
1600         printf("Image version:%d\n", image_version((void *)ptr));
1601         printf("Data Size:    ");
1602         genimg_print_size(mhdr->blocksize - sizeof(uint32_t));
1603         printf("Load Address: %08x\n", mhdr->destaddr);
1604         printf("Entry Point:  %08x\n", mhdr->execaddr);
1605 }
1606
1607 static int kwbimage_check_image_types(uint8_t type)
1608 {
1609         if (type == IH_TYPE_KWBIMAGE)
1610                 return EXIT_SUCCESS;
1611
1612         return EXIT_FAILURE;
1613 }
1614
1615 static int kwbimage_verify_header(unsigned char *ptr, int image_size,
1616                                   struct image_tool_params *params)
1617 {
1618         uint8_t checksum;
1619
1620         if (!main_hdr_checksum_ok(ptr))
1621                 return -FDT_ERR_BADSTRUCTURE;
1622
1623         /* Only version 0 extended header has checksum */
1624         if (image_version((void *)ptr) == 0) {
1625                 struct ext_hdr_v0 *ext_hdr;
1626
1627                 ext_hdr = (struct ext_hdr_v0 *)
1628                                 (ptr + sizeof(struct main_hdr_v0));
1629                 checksum = image_checksum8(ext_hdr,
1630                                            sizeof(struct ext_hdr_v0)
1631                                            - sizeof(uint8_t));
1632                 if (checksum != ext_hdr->checksum)
1633                         return -FDT_ERR_BADSTRUCTURE;
1634         }
1635
1636         return 0;
1637 }
1638
1639 static int kwbimage_generate(struct image_tool_params *params,
1640                              struct image_type_params *tparams)
1641 {
1642         FILE *fcfg;
1643         int alloc_len;
1644         int version;
1645         void *hdr;
1646         int ret;
1647
1648         fcfg = fopen(params->imagename, "r");
1649         if (!fcfg) {
1650                 fprintf(stderr, "Could not open input file %s\n",
1651                         params->imagename);
1652                 exit(EXIT_FAILURE);
1653         }
1654
1655         image_cfg = malloc(IMAGE_CFG_ELEMENT_MAX *
1656                            sizeof(struct image_cfg_element));
1657         if (!image_cfg) {
1658                 fprintf(stderr, "Cannot allocate memory\n");
1659                 fclose(fcfg);
1660                 exit(EXIT_FAILURE);
1661         }
1662
1663         memset(image_cfg, 0,
1664                IMAGE_CFG_ELEMENT_MAX * sizeof(struct image_cfg_element));
1665         rewind(fcfg);
1666
1667         ret = image_create_config_parse(fcfg);
1668         fclose(fcfg);
1669         if (ret) {
1670                 free(image_cfg);
1671                 exit(EXIT_FAILURE);
1672         }
1673
1674         version = image_get_version();
1675         switch (version) {
1676                 /*
1677                  * Fallback to version 0 if no version is provided in the
1678                  * cfg file
1679                  */
1680         case -1:
1681         case 0:
1682                 alloc_len = sizeof(struct main_hdr_v0) +
1683                         sizeof(struct ext_hdr_v0);
1684                 break;
1685
1686         case 1:
1687                 alloc_len = image_headersz_v1(NULL);
1688                 break;
1689
1690         default:
1691                 fprintf(stderr, "Unsupported version %d\n", version);
1692                 free(image_cfg);
1693                 exit(EXIT_FAILURE);
1694         }
1695
1696         free(image_cfg);
1697
1698         hdr = malloc(alloc_len);
1699         if (!hdr) {
1700                 fprintf(stderr, "%s: malloc return failure: %s\n",
1701                         params->cmdname, strerror(errno));
1702                 exit(EXIT_FAILURE);
1703         }
1704
1705         memset(hdr, 0, alloc_len);
1706         tparams->header_size = alloc_len;
1707         tparams->hdr = hdr;
1708
1709         /*
1710          * The resulting image needs to be 4-byte aligned. At least
1711          * the Marvell hdrparser tool complains if its unaligned.
1712          * By returning 1 here in this function, called via
1713          * tparams->vrec_header() in mkimage.c, mkimage will
1714          * automatically pad the the resulting image to a 4-byte
1715          * size if necessary.
1716          */
1717         return 1;
1718 }
1719
1720 /*
1721  * Report Error if xflag is set in addition to default
1722  */
1723 static int kwbimage_check_params(struct image_tool_params *params)
1724 {
1725         if (!strlen(params->imagename)) {
1726                 char *msg = "Configuration file for kwbimage creation omitted";
1727
1728                 fprintf(stderr, "Error:%s - %s\n", params->cmdname, msg);
1729                 return CFG_INVALID;
1730         }
1731
1732         return (params->dflag && (params->fflag || params->lflag)) ||
1733                 (params->fflag && (params->dflag || params->lflag)) ||
1734                 (params->lflag && (params->dflag || params->fflag)) ||
1735                 (params->xflag) || !(strlen(params->imagename));
1736 }
1737
1738 /*
1739  * kwbimage type parameters definition
1740  */
1741 U_BOOT_IMAGE_TYPE(
1742         kwbimage,
1743         "Marvell MVEBU Boot Image support",
1744         0,
1745         NULL,
1746         kwbimage_check_params,
1747         kwbimage_verify_header,
1748         kwbimage_print_header,
1749         kwbimage_set_header,
1750         NULL,
1751         kwbimage_check_image_types,
1752         NULL,
1753         kwbimage_generate
1754 );