installshield_main.c

   1 /*
   2   InstallShield Z file format
   3   Copyright 2015 <hacker@iam.tj>
   4   Licenced on the terms of then GNU General Public Licence version 3
   5
   6   Read and extract InstallShield .Z archive files
   7  */
   8
   9 #include <stdio.h>
  10 #include <sys/types.h>
  11 #include <sys/stat.h>
  12 #include <inttypes.h>
  13 #include <fcntl.h>
  14 #include <stdlib.h>
  15 #include <unistd.h>
  16 #include <errno.h>
  17 #include <string.h>
  18
  19 #include "implode.h"
  20 #include "installshield_z.h"
  21
  22 static const size_t BUFFER_SIZE = 0x4000;
  23 static bool debug = 0;
  24 static bool extract = 0;
  25
  26 void
  27 usage(const char *name)
  28 {
  29         printf("usage: %s %s\n\n", name,
  30                 " FILENAME\n"
  31                 " [-x|--extract]"
  32         );
  33 }
  34
  35 int
  36 headers_decode(int z_fd)
  37 {
  38         int result = -1;
  39         struct archive_header *header = NULL;
  40         off_t offset = 0;
  41         ssize_t qty = 0;
  42
  43         if (z_fd != -1 && (header = calloc(BUFFER_SIZE, 1))) {
  44                 offset = lseek(z_fd, offset, SEEK_SET);
  45                 if ((qty = read(z_fd, header, Z_FILE_HEADER_BYTES))< Z_FILE_HEADER_BYTES)
  46                         fprintf(stderr, "Warning: Tried to read %ld header bytes but only got %ld. Will do my best\n", Z_FILE_HEADER_BYTES, qty);
  47                 printf("Magic               %08x\n", header->magic);
  48                 printf("CRC32               %08x\n", header->__crc32);
  49                 printf("File size           %08x\n", header->file_bytes);
  50                 printf("Payload size        %08x\n", header->payload_bytes);
  51                 printf("Directories offset  %08x\n", header->directories_offset);
  52                 printf("Directories size    %08x\n", header->directories_bytes);
  53                 printf("Directories entries     %04x\n", header->directories_entries);
  54                 printf("Files offset        %08x\n", header->files_offset);
  55                 printf("Files size          %08x\n", header->files_bytes);
  56                 printf("Files entries           %04x\n", header->files_entries);
  57
  58                 offset = lseek(z_fd, header->directories_offset, SEEK_SET);
  59                 struct dirent_prefix *dirent, *p;
  60
  61                 if (offset == header->directories_offset && ((dirent = p = calloc(header->directories_bytes, 1)))) {
  62
  63                         if ((qty = read(z_fd, dirent, header->directories_bytes)) != header->directories_bytes)
  64                                 fprintf(stderr, "Warning: Tried to read %d directory bytes but only got %ld. Will do my best\n", header->directories_bytes, qty);
  65
  66                         printf("Directory entries: %d ( %08x bytes @ 0x%08x)\n", header->directories_entries, header->directories_bytes, header->directories_offset);
  67
  68                         struct dirent dirents[header->directories_entries];
  69                         for (int i = 0; i < header->directories_entries; ++i) {
  70                                 printf(" Entry %4d Size %x @ %08x    \"%s\"\n", i, p->entry_bytes, header->directories_offset + (uint32_t)((void *)p - (void *)dirent), p->name);
  71                                 dirents[i].entry = p;
  72                                 p = (void *)p + p->entry_bytes;
  73                         }
  74
  75                         offset = lseek(z_fd, header->files_offset, SEEK_SET);
  76                         struct fileent_prefix *fileent, *q;
  77                         if (offset == header->files_offset && ((fileent = q = calloc(header->files_bytes, 1)))) {
  78                                 if ((qty = read(z_fd, fileent, header->files_bytes)) != header->files_bytes)
  79                                         fprintf(stderr, "Warning: Tried to read %d file entry bytes but only got %ld. Will do my best\n", header->files_bytes, qty);
  80
  81                                 printf("File entries: %d ( %08x bytes @ 0x%08x)\n", header->files_entries, header->files_bytes, header->files_offset);
  82
  83                                 for (int i = 0; i < header->files_entries; ++i) {
  84                                         printf(" Entry %4d uses %06x bytes @ %08x. file-size %08x (payload %08x @ %08x)", i, q->entry_bytes, header->files_offset +(uint32_t)((void *)q - (void *)fileent), q->file_bytes, q->payload_bytes, q->payload_offset);
  85
  86                                         if (debug) {
  87                                                 printf(" next @ %08x", q->payload_offset + q->payload_bytes);
  88                                                 for (int r = 0; r < 0x1E; ++r)
  89                                                 printf(" %02x", *(unsigned char *)(r + (void *)q));
  90                                         }
  91
  92                                         printf(" \"%s\\%s\"\n", dirents[q->dir_index].entry->name, q->name);
  93
  94                                         char *dir_name = strdup(dirents[q->dir_index].entry->name);
  95                                         for (char *p = dir_name; *p; ++p)
  96                                                 if (*p == '\\') *p = '/';
  97                                          if (debug) printf("Parsing '%s' (%ld bytes)\n", dir_name, strlen(dir_name));
  98
  99                                         int dir_fd = AT_FDCWD;
 100                                         int dir_fd_last = dir_fd;
 101                                         if (extract) {
 102                                                 if (!dirents[q->dir_index].created) {
 103                                                         char *component = dir_name;
 104                                                         bool last_component = false;
 105                                                         for (char *sep = dir_name;; ++sep) {
 106                                                                 if (*sep == '/' || *sep == 0) {
 107                                                                         if (*sep == 0)
 108                                                                                 last_component = true;
 109                                                                         char temp = *sep;
 110                                                                         *sep = 0;
 111                                                                         if (strlen(component) > 0) {
 112                                                                                 if (debug) printf("Component: '%s' %ld bytes @ %p\n", component, strlen(component), component);
 113                                                                                 int ret = mkdirat(dir_fd, component, 0755);
 114                                                                                 if (ret == 0 || (ret == -1 && errno == EEXIST)) {
 115                                                                                         if (debug)
 116                                                                                                 printf("Directory '%s' %s\n", component, ret == 0 ? "created" : "already exists");
 117                                                                                         dir_fd_last = dir_fd;
 118                                                                                         dir_fd = openat(dir_fd_last, component, O_DIRECTORY);
 119                                                                                         close(dir_fd_last);
 120                                                                                         if (dir_fd == -1) {
 121                                                                                                 fprintf(stderr, "Error %d: cannot open directory '%s': ", errno, component);
 122                                                                                                 perror(NULL);
 123                                                                                                 *sep = temp;
 124                                                                                                 break; // cannot continue if unable to open a path component
 125                                                                                         } else if (last_component == true) {
 126                                                                                                 dirents[q->dir_index].created = true;
 127                                                                                         }
 128                                                                                 } else {
 129                                                                                         fprintf(stderr, "Error %d: cannot create directory '%s': ", errno, component);
 130                                                                                         perror(NULL);
 131                                                                                         *sep = temp;
 132                                                                                         break; // leave the for() loop immediately
 133                                                                                 }
 134                                                                         } // strlen()
 135                                                                         *sep = temp;
 136                                                                         component = sep + 1;
 137                                                                         if (last_component) break;
 138                                                                 } // separator
 139                                                         } // for()
 140                                                         if (dir_fd < 0)
 141                                                                 dir_fd = AT_FDCWD;
 142                                                 } // .created == false
 143                                         }
 144                                         if ((dir_fd = openat(AT_FDCWD, dir_name, O_DIRECTORY)) != -1) {
 145
 146                                                 unsigned int z_filename_len = strlen(q->name) + 4;
 147                                                 char z_filename[z_filename_len];
 148                                                 strncpy(z_filename, q->name, z_filename_len);
 149                                                 strncat(z_filename, ".z", 2);
 150
 151                                                 if (debug)
 152                                                         printf(" Creating payload file '%s/%s'\n", dir_name,  z_filename);
 153
 154                                                 if ((offset = lseek(z_fd, q->payload_offset, SEEK_SET)) == q->payload_offset) {
 155                                                         void *buffer;
 156                                                         if ((buffer = calloc(q->payload_bytes, 1)) != 0) {
 157                                                                 int pay_fd;
 158                                                                 if ((pay_fd = openat(dir_fd, z_filename, O_WRONLY | O_CREAT | O_TRUNC, 0644))) {
 159                                                                         ssize_t z_qty, pay_qty;
 160                                                                         if ((z_qty = read(z_fd, buffer, q->payload_bytes)) == q->payload_bytes) {
 161                                                                                 if (debug) {
 162                                                                                         unsigned int checksum = 0x0;
 163                                                                                         for (int i = 0; i < q->payload_bytes / sizeof(unsigned int); ++i) {
 164                                                                                                 checksum ^= ((unsigned int *)buffer)[i];
 165                                                                                         }
 166                                                                                         printf("Checksum: %08x\n", checksum);
 167                                                                                 }
 168                                                                                 if ((pay_qty = write(pay_fd, buffer, q->payload_bytes)) != q->payload_bytes)
 169                                                                                         fprintf(stderr, "Error: whilst writing payload expected %d bytes but wrote %ld\n", q->payload_bytes, pay_qty);
 170                                                                         } else
 171                                                                                 fprintf(stderr, "Error: whilst reading payload expected %d bytes but read %ld\n", q->payload_bytes, z_qty);
 172                                                                         close(pay_fd);
 173                                                                 }
 174                                                                 if (q->payload_bytes >= 4) {
 175                                                                         uint8_t comp_type = *(uint8_t *)buffer;
 176                                                                         uint8_t dict_size = *(uint8_t *)(buffer + 1);
 177                                                                         if (comp_type >= IMPLODE_BINARY && comp_type <= IMPLODE_ASCII && dict_size >= IMPLODE_DICT_1K && dict_size <= IMPLODE_DICT_4K) {
 178                                                                                 void * buffer_decomp;
 179                                                                                 if ((buffer_decomp = calloc(q->file_bytes, 1)) != 0) {
 180                                                                                         uint32_t decomp_bytes = q->file_bytes;
 181                                                                                         if (explode(buffer, q->payload_bytes, buffer_decomp, &decomp_bytes)) {
 182                                                                                                 if (decomp_bytes > q->file_bytes) {
 183                                                                                                         fprintf(stderr, "Expected %d uncompressed bytes but got %d\n", q->file_bytes, decomp_bytes);
 184                                                                                                 }
 185                                                                                                 int decomp_fd;
 186                                                                                                 if ((decomp_fd = openat(dir_fd, q->name, O_WRONLY | O_CREAT | O_TRUNC, 0644))) {
 187                                                                                                         ssize_t decomp_qty;
 188                                                                                                         if (debug)
 189                                                                                                                 printf("Creating uncompressed file '%s/%s'\n",dir_name,  q->name);
 190                                                                                                         if ((decomp_qty = write(decomp_fd, buffer_decomp, q->file_bytes)) != q->file_bytes)
 191                                                                                                                 fprintf(stderr, "Error: whilst writing decompressed data expected %d bytes but wrote %ld\n", q->file_bytes, decomp_qty);
 192                                                                                                         close(decomp_fd);
 193                                                                                                 }
 194                                                                                         } else {
 195                                                                                                 fprintf(stderr, "Error: failed to decompress '%s', payload: %d decompressed: %d\n", q->name, q->payload_bytes, decomp_bytes);
 196                                                                                         }
 197                                                                                         free(buffer_decomp);
 198                                                                                 } else {
 199                                                                                         fprintf(stderr, "Error: unable to allocate %d bytes for decompression buffer\n", q->file_bytes);
 200                                                                                 }
 201                                                                         } else {
 202                                                                                 fprintf(stderr, "Does not look like TTComp compressed data. header: %04x\n", *(uint16_t *)buffer);
 203                                                                         }
 204                                                                 } else {
 205                                                                         fprintf(stderr, "Error: payload %d bytes smaller than minimum allowed TTComp of 4\n", q->payload_bytes);
 206                                                                 }
 207                                                                 free(buffer);
 208                                                         }
 209                                                 } else {
 210                                                         fprintf(stderr, "Error %d: failed to create %s\n", errno, z_filename);
 211                                                 }
 212                                                 close(dir_fd);
 213                                         } else {
 214                                                 fprintf(stderr, "Error %d: cannot open directory at (%d) '%s': ", errno, dir_fd, dir_name);
 215                                                 perror(NULL);
 216                                         }
 217                                         free(dir_name);
 218                                         q = (void *)q + q->entry_bytes;
 219                                 }
 220                                 free(fileent);
 221                         }
 222                         free(dirent);
 223                 } else
 224                         fprintf(stderr, "Error: %s\n", "failed to seek or couldn't allocate memory for directories");
 225
 226                 free(header);
 227                 result = 0;
 228         }
 229         return result;
 230 }
 231
 232 int
 233 main(int argc, char **argv, char **env)
 234 {
 235         int result = -1;
 236         int fd = 0;
 237
 238         if (argc < 2 ) {
 239                 usage(argv[0]);
 240                 return 0;
 241         }
 242
 243         for (char **e = env; *e; ++e) {
 244                 if (strncmp("DEBUG", *e, 5) == 0)
 245                         debug = true;
 246         }
 247         for (char **a = argv; *a; ++a) {
 248                 if (debug) printf("Arg: %s\n", *a);
 249                 if (strncmp("-x", *a, 2) == 0 || strncmp("--extract", *a, 9) == 0)
 250                         extract = true;
 251         }
 252
 253         if ((fd = open(argv[1], O_RDONLY)) != -1) {
 254                 result = headers_decode(fd);
 255                 close(fd);
 256         } else {
 257                 fprintf(stderr, "Error: could not open %s\n", argv[0]);
 258                 return errno;
 259         }
 260
 261
 262         return result;
 263 }
 264