WebSVN – QNX 8.QNX8 IFS tool – Diff – /ifstool.c

 #include <time.h>
 #ifdef _MSC_VER
 #include <io.h>
+#define __ORDER_BIG_ENDIAN__    4321
 #define __ORDER_LITTLE_ENDIAN__ 1234
 #define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__
 #define __attribute__(x)
+#define __builtin_bswap32(x) _byteswap_ulong ((unsigned long) (x))
 #define __builtin_bswap64(x) _byteswap_uint64 ((unsigned long long) (x))
 #define S_IFIFO 0x1000
 #define S_IFLNK 0xa000
 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
 #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
 static void SHA512_Init (SHA512_CTX *context);
 static void SHA512_Update (SHA512_CTX *context, void *data, size_t len);
 static void SHA512_Final (uint8_t digest[SHA512_DIGEST_LENGTH], SHA512_CTX *context);
 static uint8_t *SHA512 (void *data, size_t data_len, uint8_t *digest); // computes a SHA-512 in one pass (shortcut for SHA512_Init(), SHA512_Update() N times and SHA512_Final())
 static int32_t update_checksum32 (const int32_t start_value, const void *data, const size_t len); // update the sum of an array of 32-bit signed integers
+static int32_t update_image_checksum (const int32_t start_value, const void *data, const size_t data_len, const bool is_foreign_endianness); // compute an IFS image checksum to store in the image trailer
 static long long read_integer (const char *str); // reads an integer number for a string that may be specified in either hex, octal or decimal base, and may have an optional unit suffix (k, m, g, t)
 static void hex_fprintf (FILE *fp, const uint8_t *data, size_t data_size, int howmany_columns, const char *fmt, ...); // hexdump-style formatted output to a file stream (which may be stdout/stderr)
 static char *binary (const uint8_t x, char char_for_zero, char char_for_one); // returns the binary representation of byte 'x' as a string
 static char *describe_uint8 (const uint8_t x, const char *bitwise_stringdescs[8]); // returns the ORed description of byte 'x' according to the description strings for each bit
 static int fwrite_filecontents (const char *pathname, FILE *fp); // dumps the contents of pathname into fp
       sprintf (&digest_as_string[2 * byte_index], "%02x", digest_or_NULL[byte_index]);
    return (digest_as_string);
+}
-static int32_t update_checksum32 (const int32_t start_value, const void *data, const size_t len)
+static int32_t update_checksum32_NOT (const int32_t start_value, const void *data, const size_t len)
+{
    // compute the sum of an array of 32-bit signed integers
    const int32_t *values_array = data;
    int32_t sum = start_value;
    for (size_t value_index = 0; value_index < len / sizeof (int32_t); value_index++)
       sum += values_array[value_index];
    return (sum);
+}
+static int32_t update_checksum32 (const int32_t start_value, const void *data, const size_t data_len)
+{
+   uint8_t hold_cksum_4[4] = { 0, 0, 0, 0 };
+   int32_t image_cksum = start_value;
+   int hold_index; // ST2C_4@4
+   uint64_t i; // [sp+30h] [bp-10h]@3
+   char *current_char_ptr; // [sp+38h] [bp-8h]@3
+   char *data_start; // [sp+50h] [bp+10h]@1
+   uint64_t _data_len; // [sp+58h] [bp+18h]@1
+   data_start = data;
+   _data_len = data_len;
+   current_char_ptr = data_start;
+   for (i = 0; i < data_len; ++i)
+   {
+      hold_index = i & 3;
+      hold_cksum_4[hold_index] = *current_char_ptr;
+      if (hold_index == 3)
+      {
+         if (false) // endianness
+            image_cksum += (hold_cksum_4[3] << 0)
+            + (hold_cksum_4[2] << 8)
+            + (hold_cksum_4[1] << 16)
+            + (hold_cksum_4[0] << 24);
+         else
+            image_cksum += (hold_cksum_4[0] << 0)
+            + (hold_cksum_4[1] << 8)
+            + (hold_cksum_4[2] << 16)
+            + (hold_cksum_4[3] << 24);
+      }
+      current_char_ptr++;
+   }
+   return (-image_cksum);
+}
+static int32_t update_image_checksum (const int32_t start_value, const void *data, const size_t data_len, const bool is_foreign_endianness)
+{
+   // computes the checksum of an IFS image section, i.e. from the start of the image header to the end of the image trailer minus the last 4 bytes where the checksum is stored
+   uint8_t accumulator[4] = { 0, 0, 0, 0 };
+   int32_t image_cksum = start_value;
+   char *current_char_ptr = data;
+   size_t i;
+   for (i = 0; i < data_len; i++)
+   {
+      accumulator[i % 4] = *current_char_ptr;
+      if (i % 4 == 3)
+         if (is_foreign_endianness)
+            image_cksum += (accumulator[3] <<  0) + (accumulator[2] <<  8) + (accumulator[1] << 16) + (accumulator[0] << 24);
+         else
+            image_cksum += (accumulator[0] <<  0) + (accumulator[1] <<  8) + (accumulator[2] << 16) + (accumulator[3] << 24);
+      current_char_ptr++;
+   }
+   return (is_foreign_endianness ? __builtin_bswap32 (-image_cksum) : -image_cksum);
+}
 static long long read_integer (const char *str)
+{
    int arg_index;
    bool is_quoted_context = false;
    bool is_escaped_char = false;
    bool want_info = false;
    bool want_help = false;
+   bool is_foreign_endianness;
    int string_len;
    int read_char;
    FILE *buildfile_fp;
    FILE *fp;
       exit (1);
+   }
    fseek (fp, imgheader_offset, SEEK_SET);
    fread (blob_data, 1, blob_datasize, fp);
    SHA512 (blob_data, blob_datasize, image_trailer.sha512); // compute SHA512 checksum
+   if (   ( (image_header.flags & IMAGE_FLAGS_BIGENDIAN) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
+       || (!(image_header.flags & IMAGE_FLAGS_BIGENDIAN) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)))
+      is_foreign_endianness = true; // if the header is big endian and we're on a little endian machine, or the other way around, it's a foreign endianness
+   else
+      is_foreign_endianness = false; // else this header is for the same endianness as us
    image_trailer.cksum = 0; // compute old checksum
-   image_trailer.cksum = update_checksum32 (image_trailer.cksum, (const uint32_t *) blob_data, blob_datasize);
+   image_trailer.cksum = update_image_checksum (image_trailer.cksum, (const uint32_t *) blob_data, blob_datasize, is_foreign_endianness);
-   image_trailer.cksum = update_checksum32 (image_trailer.cksum, (const uint32_t *) image_trailer.sha512, sizeof (image_trailer.sha512));
+   image_trailer.cksum = update_image_checksum (image_trailer.cksum, (const uint32_t *) image_trailer.sha512, sizeof (image_trailer.sha512), is_foreign_endianness);
    free (blob_data);
    // rewrite image trailer with final checksum values
    fseek (fp, imgtrailer_offset, SEEK_SET);
    fwrite (&image_trailer, sizeof (image_trailer), 1, fp); // write image trailer
    fsentry_t *current_fsentry = NULL;
    char recorded_sha512[2 * SHA512_DIGEST_LENGTH + 1] = "";
    char computed_sha512[2 * SHA512_DIGEST_LENGTH + 1] = "";
    size_t startupfile_blobsize = 0;
    void *reallocated_ptr;
+   bool is_foreign_endianness;
    size_t bootfile_blobsize = 0;
    size_t current_offset;
    size_t fsentry_index;
    size_t nearest_distance;
    size_t nearest_index;
          if (current_offset + startup_header->startup_size > filesize)
+         {
             fprintf (stderr, "WARNING: this IFS file is too short (startup trailer would be past end of file)\n");
             break;
+         }
+         // check if this endianness is ours
+         if (   ( (startup_header->flags1 & STARTUP_HDR_FLAGS1_BIGENDIAN) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
+             || (!(startup_header->flags1 & STARTUP_HDR_FLAGS1_BIGENDIAN) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)))
+            is_foreign_endianness = true; // if the header is big endian and we're on a little endian machine, or the other way around, it's a foreign endianness
+         else
+            is_foreign_endianness = false; // else this header is for the same endianness as us
          // locate the right startup trailer at the right offset
          if (startup_header->flags1 & STARTUP_HDR_FLAGS1_TRAILER_V2)
+         {
             startup_trailer_v2 = (startup_trailer_v2_t *) &filedata[current_offset + startup_header->startup_size - sizeof (startup_trailer_v2_t)];
          current_offset += sizeof (startup_header_t); // jump over the startup header and reach the startup blob
          printf ("\n");
          printf ("Startup blob at offset 0x%zx (%zd):\n", current_offset, current_offset);
          printf ("   size 0x%zx (%zd) bytes\n", startupfile_blobsize, startupfile_blobsize);
-         printf ("   checksum %d\n", update_checksum32 (0, (uint32_t *) &filedata[current_offset], startupfile_blobsize));
+         printf ("   checksum %d\n", update_checksum32 (0, &filedata[current_offset], startupfile_blobsize));
          current_offset += startupfile_blobsize; // jump over the startup blob and reach the startup trailer
          printf ("\n");
          printf ("Startup trailer at offset 0x%zx (%zd) - version %d:\n", current_offset, current_offset, (startup_header->flags1 & STARTUP_HDR_FLAGS1_TRAILER_V2 ? 2 : 1));
          if (startup_header->flags1 & STARTUP_HDR_FLAGS1_TRAILER_V2)
+         {
             for (byte_index = 0; byte_index < SHA512_DIGEST_LENGTH; byte_index++)
                sprintf (&recorded_sha512[2 * byte_index], "%02x", startup_trailer_v2->sha512[byte_index]);
             strcpy (computed_sha512, SHA512 (startup_header, (size_t) ((uint8_t *) startup_trailer_v2 - (uint8_t *) startup_header), NULL));
             recorded_checksum = startup_trailer_v2->cksum;
-            computed_checksum = update_checksum32 (0, (uint32_t *) startup_header, sizeof (startup_header) + startupfile_blobsize + SHA512_DIGEST_LENGTH);
+            computed_checksum = update_checksum32 (0, startup_header, sizeof (startup_header) + startupfile_blobsize + SHA512_DIGEST_LENGTH);
             printf ("    sha512 = %s - %s\n", recorded_sha512, (strcasecmp (computed_sha512, recorded_sha512) == 0 ? "GOOD" : "BAD"));
             printf ("    cksum = 0x%08x (%d) - %s\n", recorded_checksum, recorded_checksum, (computed_checksum == recorded_checksum ? "GOOD" : "BAD"));
             if (strcasecmp (computed_sha512, recorded_sha512) != 0)
                printf ("Computed SHA-512: %s\n", computed_sha512);
             if (computed_checksum != recorded_checksum)
                printf ("Computed cksum: 0x%08x (%d)\n", computed_checksum, computed_checksum);
+         }
          else // old v1 trailer
+         {
             recorded_checksum = startup_trailer_v1->cksum;
-            computed_checksum = update_checksum32 (0, (uint32_t *) startup_header, sizeof (startup_header) + startupfile_blobsize);
+            computed_checksum = update_checksum32 (0, startup_header, sizeof (startup_header) + startupfile_blobsize);
             printf ("    cksum = 0x%08x (%d) - %s\n", recorded_checksum, recorded_checksum, (computed_checksum == recorded_checksum ? "GOOD" : "BAD"));
             if (computed_checksum != recorded_checksum)
                printf ("Computed cksum: 0x%08x (%d)\n", computed_checksum, computed_checksum);
+         }
          if (current_offset + image_header->image_size > filesize)
+         {
             fprintf (stderr, "WARNING: this IFS file is too short (image trailer would be past end of file)\n");
             break;
+         }
+         // check if this endianness is ours
+         if (   ( (image_header->flags & IMAGE_FLAGS_BIGENDIAN) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
+             || (!(image_header->flags & IMAGE_FLAGS_BIGENDIAN) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)))
+            is_foreign_endianness = true; // if the header is big endian and we're on a little endian machine, or the other way around, it's a foreign endianness
+         else
+            is_foreign_endianness = false; // else this header is for the same endianness as us
          // locate the image trailer at the right offset
          if (image_header->flags & IMAGE_FLAGS_TRAILER_V2)
+         {
             imagetrailer_offset = current_offset + image_header->image_size - sizeof (image_trailer_v2_t);
                printf ("   corresponding dirent index: %zd/%zd\n", fsentry_index, fsentry_count);
                printf ("   corresponding inode 0x%08x (%d) - %s%s%s%s\n", current_fsentry->header.ino, current_fsentry->header.ino, (current_fsentry->header.ino & 0xE0000000 ? "is" : "nothing special"), (current_fsentry->header.ino & IFS_INO_PROCESSED_ELF ? " PROCESSED_ELF" : ""), (current_fsentry->header.ino & IFS_INO_RUNONCE_ELF ? " RUNONCE_ELF" : ""), (current_fsentry->header.ino & IFS_INO_BOOTSTRAP_EXE ? " BOOTSTRAP_EXE" : ""));
                printf ("   corresponding path: \"%s\"\n", (char *) &current_fsentry->u.file.path); // convert from pointer to char array
                printf ("   size 0x%zx (%zd) bytes\n", (size_t) current_fsentry->u.file.size, (size_t) current_fsentry->u.file.size);
                printf ("   first 4 bytes: %02x%02x%02x%02x [%c%c%c%c] (%s)\n", (uint8_t) filedata[current_offset + 0], (uint8_t) filedata[current_offset + 1], (uint8_t) filedata[current_offset + 2], (uint8_t) filedata[current_offset + 3], (isprint (filedata[current_offset + 0]) ? filedata[current_offset + 0] : '.'), (isprint (filedata[current_offset + 1]) ? filedata[current_offset + 1] : '.'), (isprint (filedata[current_offset + 2]) ? filedata[current_offset + 2] : '.'), (isprint (filedata[current_offset + 3]) ? filedata[current_offset + 3] : '.'), (memcmp (&filedata[current_offset], "\x7f" "ELF", 4) == 0 ? "ELF binary" : (memcmp (&filedata[current_offset], "#!", 2) == 0 ? "shell script" : "???")));
-               printf ("   checksum %d\n", update_checksum32 (0, (uint32_t *) &filedata[current_offset], current_fsentry->u.file.size));
+               printf ("   checksum %d\n", update_image_checksum (0, &filedata[current_offset], current_fsentry->u.file.size, is_foreign_endianness));
                current_offset += current_fsentry->u.file.size; // now jump over this file's data
+            }
+         }
+         {
             for (byte_index = 0; byte_index < SHA512_DIGEST_LENGTH; byte_index++)
                sprintf (&recorded_sha512[2 * byte_index], "%02x", image_trailer_v2->sha512[byte_index]);
             strcpy (computed_sha512, SHA512 (image_header, (size_t) ((uint8_t *) image_trailer_v2 - (uint8_t *) image_header), NULL));
             recorded_checksum = image_trailer_v2->cksum;
-            computed_checksum = update_checksum32 (0, (uint32_t *) image_header, sizeof (image_header) + image_header->image_size - sizeof (image_trailer_v2_t) + SHA512_DIGEST_LENGTH);
+            computed_checksum = update_image_checksum (0, image_header, /*sizeof (image_header) +*/ image_header->image_size - sizeof (image_trailer_v2_t) + SHA512_DIGEST_LENGTH, is_foreign_endianness);
             printf ("    sha512 = %s - %s\n", recorded_sha512, (strcasecmp (computed_sha512, recorded_sha512) == 0 ? "GOOD" : "BAD"));
             printf ("    cksum = 0x%08x (%d) - %s\n", recorded_checksum, recorded_checksum, (computed_checksum == recorded_checksum ? "GOOD" : "BAD"));
             if (strcasecmp (computed_sha512, recorded_sha512) != 0)
                printf ("Computed SHA-512: %s\n", computed_sha512);
             if (computed_checksum != recorded_checksum)
                printf ("Computed cksum: 0x%08x (%d)\n", computed_checksum, computed_checksum);
+         }
          else // old v1 trailer
+         {
             recorded_checksum = image_trailer_v1->cksum;
-            computed_checksum = update_checksum32 (0, (uint32_t *) image_header, sizeof (image_header) + image_header->image_size - sizeof (image_trailer_v1_t));
+            computed_checksum = update_image_checksum (0, image_header, /*sizeof (image_header) +*/ image_header->image_size - sizeof (image_trailer_v1_t), is_foreign_endianness);
             printf ("    cksum = 0x%08x (%d) - %s\n", recorded_checksum, recorded_checksum, (computed_checksum == recorded_checksum ? "GOOD" : "BAD"));
             if (computed_checksum != recorded_checksum)
                printf ("Computed cksum: 0x%08x (%d)\n", computed_checksum, computed_checksum);
+         }
             break; // if not found, stop scanning
          bootfile_blobsize = byte_index - current_offset;
          printf ("Boot blob at offset 0x%zx (%zd):\n", current_offset, current_offset);
          printf ("   size 0x%zx (%zd) bytes\n", bootfile_blobsize, bootfile_blobsize);
-         printf ("   checksum %d\n", update_checksum32 (0, (uint32_t *) &filedata[current_offset], bootfile_blobsize));
+         printf ("   checksum 0x%08x\n", update_checksum32 (0, &filedata[current_offset], bootfile_blobsize));
          current_offset = byte_index; // now reach the next segment
+      }
+   }

Subversion Repositories QNX 8.QNX8 IFS tool

QNX 8.QNX8 IFS tool/ifstool.c – Rev 4 → 5