/** * Efficient tar+bzip2 extractor for in-game use * Copyright (C) 2004 Andrew Reading * Copyright (C) 2007, 2008, 2014, 2018 Sylvain Beucler * This file is part of GNU FreeDink * GNU FreeDink is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 3 of the * License, or (at your option) any later version. * GNU FreeDink is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * You should have received a copy of the GNU General Public License * along with this program. If not, see * . */ #ifdef HAVE_CONFIG_H #include #else #define _(s) s #endif #include #include #include #include #include #include #include #include #include struct TarHeader { char Name[100+1]; // 100 char Mode[8+1]; // 108 char Uid[8+1]; // 116 char Gid[8+1]; // 124 char Size[12+1]; // 136 char Mtime[12+1]; // 148 char Chksum[8+1]; // 156 char Linkflag[1+1]; // 157 char Linkname[100+1]; // 257 char Magic[8+1]; // 265 char Uname[32+1]; // 297 char Gname[32+1]; // 329 char Devmajor[8+1]; // 337 char Devminor[8+1]; // 345 char Padding[167+1]; // 512 }; #define TAR_HEADER_SIZE 512 int mkdir_rec(char* path) { int ret; mode_t mode = 00755; ret = mkdir(path, mode); if (ret == 0 || errno == EEXIST) { return 0; } else { char* dir = strdup(path); dirname(dir); ret = mkdir_rec(dir); free(dir); if (ret < 0) { return ret; } if ((ret = mkdir(path, mode)) < 0) { perror("mkdir"); return ret; } return 0; } } int DirExists(char* path) { struct stat st; return (stat(path, &st) == 0 && S_ISDIR(st.st_mode)); } void print_bzerror(BZFILE* bzin, int bzerror) { printf("%s\n", BZ2_bzerror(bzin, &bzerror)); if (bzerror == BZ_OK || bzerror == BZ_STREAM_END) { // Success } else if (bzerror == BZ_PARAM_ERROR) { printf(_("Invalid .dmod file specified.")); } else if (bzerror == BZ_SEQUENCE_ERROR) { printf(_("Critical program function error: opened for write.")); } else if (bzerror == BZ_IO_ERROR) { printf(_("Could not read .dmod file.") ); } else if (bzerror == BZ_UNEXPECTED_EOF) { printf(_("Incomplete .dmod file. Please download it again.") ); } else if (bzerror == BZ_DATA_ERROR) { printf(_("The .dmod file is corrupted. Please download it again.")); } else if (bzerror == BZ_DATA_ERROR_MAGIC) { printf(_("The file is not a valid .dmod file.")); } else if (bzerror == BZ_MEM_ERROR) { printf(_("Out of memory error.")); } else { printf(_("An unhandled error occurred.")); } printf("\n"); } /** * Read all tar headers from a flux, so it can work if reading file * with BZip2 directly (only the 'read' operation is available). */ int TarFillHeaderFromStream(BZFILE* bzin, struct TarHeader* tarHeader) { memset(tarHeader, 0, sizeof(*tarHeader)); // Read the data. Don't load the whole header to a struct, you // never know what the memory alignment will be, especially in // these 32->64bits days int bzerror; BZ2_bzRead(&bzerror, bzin, tarHeader->Name, 100); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; } BZ2_bzRead(&bzerror, bzin, tarHeader->Mode, 8); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; } BZ2_bzRead(&bzerror, bzin, tarHeader->Uid, 8); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; } BZ2_bzRead(&bzerror, bzin, tarHeader->Gid, 8); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; } BZ2_bzRead(&bzerror, bzin, tarHeader->Size, 12); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; } BZ2_bzRead(&bzerror, bzin, tarHeader->Mtime, 12); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; } BZ2_bzRead(&bzerror, bzin, tarHeader->Chksum, 8); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; } BZ2_bzRead(&bzerror, bzin, tarHeader->Linkflag, 1); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; } BZ2_bzRead(&bzerror, bzin, tarHeader->Linkname, 100); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; } BZ2_bzRead(&bzerror, bzin, tarHeader->Magic, 8); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; } BZ2_bzRead(&bzerror, bzin, tarHeader->Uname, 32); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; } BZ2_bzRead(&bzerror, bzin, tarHeader->Gname, 32); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; } BZ2_bzRead(&bzerror, bzin, tarHeader->Devmajor, 8); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; } BZ2_bzRead(&bzerror, bzin, tarHeader->Devminor, 8); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; } BZ2_bzRead(&bzerror, bzin, tarHeader->Padding, 167); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; } return bzerror; } unsigned int TarComputeChecksum(struct TarHeader* tarHeader) { unsigned int sum = 0; char blankChecksum[8+1] = " "; for (int i = 0; i < 100; i++) { sum += tarHeader->Name[i]; } for (int i = 0; i < 8; i++) { sum += tarHeader->Mode[i]; } for (int i = 0; i < 8; i++) { sum += tarHeader->Uid[i]; } for (int i = 0; i < 8; i++) { sum += tarHeader->Gid[i]; } for (int i = 0; i < 12; i++) { sum += tarHeader->Size[i]; } for (int i = 0; i < 12; i++) { sum += tarHeader->Mtime[i]; } //for (int i = 0; i < 8; i++) { sum += tarHeader->Chksum[i]; } for (int i = 0; i < 8; i++) { sum += blankChecksum[i]; } for (int i = 0; i < 1; i++) { sum += tarHeader->Linkflag[i]; } for (int i = 0; i < 100; i++) { sum += tarHeader->Linkname[i]; } for (int i = 0; i < 8; i++) { sum += tarHeader->Magic[i]; } for (int i = 0; i < 32; i++) { sum += tarHeader->Uname[i]; } for (int i = 0; i < 32; i++) { sum += tarHeader->Gname[i]; } for (int i = 0; i < 8; i++) { sum += tarHeader->Devmajor[i]; } for (int i = 0; i < 8; i++) { sum += tarHeader->Devminor[i]; } for (int i = 0; i < 167; i++) { sum += tarHeader->Padding[i]; } return sum; } void GetFirstDir(const char* path, char* dmodDir) { char* firstDir = ""; char* previousDir = ""; char* checkPath = malloc(strlen(path)+strlen("dummy")+1); strcpy(checkPath, path); // tokenizer never returns empty strings + distinguish dir// and a/$ char last = path[strlen(path)-1]; if (last == '\\' || last == '/') strcat(checkPath, "dummy"); char *str, *curDir, *saveptr; for (str = checkPath; ; str = NULL) { curDir = strtok_r(str, "/\\", &saveptr); if (curDir == NULL) break; if (strcmp(curDir, ".") == 0) continue; if (strcmp(previousDir, "") != 0) { firstDir = previousDir; break; } previousDir = curDir; } strcpy(dmodDir, firstDir); free(checkPath); } int TarIsPathInsecure(char* path, char* prefix) { if (path[0] == '/' || path[0] == '\\') return 1; { char *str, *token, *saveptr; str = strdup(path); token = strtok_r(str, "/\\", &saveptr); if (strcmp(token, prefix) != 0) { free(str); return 1; } free(str); } { char *str, *token, *saveptr; for (str = path; ; str = NULL) { token = strtok_r(str, "/\\", &saveptr); if (token == NULL) break; if (strcmp(token, "..") == 0) return 1; } } return 0; } int DmodExtract(FILE* dmodFile, char* destDir, char** extractedDmodDir) { // Get the file size unsigned long dmodFileCompressedSize; if (fseek(dmodFile, 0, SEEK_END) < 0) perror("fseek"); dmodFileCompressedSize = ftell(dmodFile); if (fseek(dmodFile, 0, SEEK_SET) < 0) perror("fseek"); int bzerror = BZ_OK; BZFILE* bzin = BZ2_bzReadOpen(&bzerror, dmodFile, 0, 0, 0, 0); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); printf(_("Error: Invalid .dmod file selected!")); printf("\n"); return -1; } struct TarHeader tarHeader; unsigned int total_read = 0; int lastPercent = 0; char dmodDir[100+1] = {}; // Keep getting chunks of the file while (1) { unsigned char* buf; int nbReadUncompressed; int ret = TarFillHeaderFromStream(bzin, &tarHeader); total_read += 512; if (ret < 0) { break; } // Define dmodDir which needs to be consistent in all the archive if (strcmp(dmodDir, "") == 0) { GetFirstDir(tarHeader.Name, dmodDir); if (strcmp(dmodDir, "") == 0 || strcmp(dmodDir, "..") == 0) { printf(_("Error: empty D-Mod directory. Stopping.\n")); return 1; } char* dmodFullPath = malloc(strlen(destDir)+1+strlen(dmodDir)+1); sprintf(dmodFullPath, "%s/%s", destDir, dmodDir); if (DirExists(dmodFullPath)) { printf(_("Error: directory '%s' already exists. Stopping.\n"), dmodDir); free(dmodFullPath); return 1; } free(dmodFullPath); printf("D-Mod dir: %s\n", dmodDir); } // Bug fix for phantom files that aren't really files... // This is due to a bug in DFArc1.5 with empty files if (strcmp(tarHeader.Name, "\xFF") == 0) { continue; } // Tar files (except for a design bug in DFArc1.5) have a // multitude of NULL characters at the end to round up to the // 10K mark. If the header is blank, we don't have any more // data. if (strcmp(tarHeader.Name, "") == 0) { break; } // TODO: ISO-8869-1 -> UTF-8? // Size unsigned long fileSize = 0; sscanf((const char*)&tarHeader.Size, "%lo", &fileSize); // Extract char last = tarHeader.Name[strlen(tarHeader.Name)-1]; if (last == '\\' || last == '/') { // directory, skip and let mkdir_rec do its job } else { unsigned int checksum = 0; unsigned int expected = TarComputeChecksum(&tarHeader); sscanf((const char*)&tarHeader.Chksum, "%o", &checksum); if (checksum != expected) { printf("Incorrect checksum, but proceeding anyway: found 0%o, expected 0%o\n", checksum, expected); } char* checkName = strdup(tarHeader.Name); if (TarIsPathInsecure(checkName, dmodDir)) { printf("Insecure path, stopping: %s\n", tarHeader.Name); free(checkName); return 1; } free(checkName); char* destFullPath = malloc(strlen(destDir)+1+strlen(tarHeader.Name)+1); sprintf(destFullPath, "%s/%s", destDir, tarHeader.Name); //printf("* Extracting to: %s\n", destFullPath); char* dir = strdup(destFullPath); dirname(dir); int ret = mkdir_rec(dir); if (ret < 0) printf("Error creating directory %s\n", dir); free(dir); if (ret < 0) { free(destFullPath); break; } { // bzip2 -9 -> 900kiB blocks - randomly using 4MiB buf, we // might get better precision with low-level BZ2 API char buf[4*1024*1024]; FILE* out = fopen(destFullPath, "wb"); if (out == NULL) { perror("fopen"); break; } unsigned long nbRemaining = fileSize; while (nbRemaining > 0) { nbReadUncompressed = (nbRemaining > sizeof(buf)) ? sizeof(buf) : nbRemaining; nbReadUncompressed = BZ2_bzRead(&bzerror, bzin, buf, nbReadUncompressed); if (bzerror != BZ_OK && bzerror != BZ_STREAM_END) { print_bzerror(bzin, bzerror); return 1; }; fwrite(buf, nbReadUncompressed, 1, out); nbRemaining -= nbReadUncompressed; { unsigned long pos = ftell(dmodFile); double percent = 100.0 * pos / dmodFileCompressedSize; if ((int)percent != lastPercent) printf("progress: %lu %lu %.02f%%\n", pos, dmodFileCompressedSize, percent); lastPercent = (int)percent; } } if (bzerror == BZ_STREAM_END) { // old .mod without end-of-archive record nor padding, no error output break; } fclose(out); } free(destFullPath); total_read += fileSize; } // Move to the beginning of the next header char padding[512]; int padding_size = (512 - (total_read % 512)) % 512; BZ2_bzRead(&bzerror, bzin, padding, padding_size); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; } total_read += padding_size; } BZ2_bzReadClose(&bzerror, bzin); if (extractedDmodDir != NULL) { *extractedDmodDir = strdup(dmodDir); } return 0; } int emDmodExtract(char* filename, char* destdir, char** extractedDmodDir) { // printf("emDmodExtract(%s, %s)\n", filename, destdir); FILE* in = fopen(filename, "rb"); if (in == NULL) { perror("fopen"); printf("Cannot open %s\n", filename); return 1; } return DmodExtract(in, destdir, extractedDmodDir); } #ifdef TEST int main(int argc, char* argv[]) { { char buf[100+1]; assert((strcpy(buf, "../"), TarIsPathInsecure(buf, "..") == 1)); assert((strcpy(buf, "/../"), TarIsPathInsecure(buf, "") == 1)); assert((strcpy(buf, "/../"), TarIsPathInsecure(buf, "..") == 1)); assert((strcpy(buf, ".."), TarIsPathInsecure(buf, "..") == 1)); assert((strcpy(buf, "/.."), TarIsPathInsecure(buf, "") == 1)); assert((strcpy(buf, "/.."), TarIsPathInsecure(buf, "..") == 1)); assert((strcpy(buf, "path/.."), TarIsPathInsecure(buf, "path") == 1)); assert((strcpy(buf, "path/subpath/.."), TarIsPathInsecure(buf, "path") == 1)); assert((strcpy(buf, "path/../subpath"), TarIsPathInsecure(buf, "path") == 1)); assert((strcpy(buf, "../path/subpath"), TarIsPathInsecure(buf, "..") == 1)); assert((strcpy(buf, "../path/subpath"), TarIsPathInsecure(buf, "path") == 1)); assert((strcpy(buf, "/path/subpath"), TarIsPathInsecure(buf, "") == 1)); assert((strcpy(buf, "/path/subpath"), TarIsPathInsecure(buf, "path") == 1)); assert((strcpy(buf, "\\path/subpath"), TarIsPathInsecure(buf, "") == 1)); assert((strcpy(buf, "\\path/subpath"), TarIsPathInsecure(buf, "path") == 1)); assert((strcpy(buf, "path\\..\\subpath"), TarIsPathInsecure(buf, "path") == 1)); assert((strcpy(buf, "path"), TarIsPathInsecure(buf, "path") == 0)); assert((strcpy(buf, "path"), TarIsPathInsecure(buf, "path") == 0)); assert((strcpy(buf, "path/"), TarIsPathInsecure(buf, "path") == 0)); assert((strcpy(buf, "path\\"), TarIsPathInsecure(buf, "path") == 0)); assert((strcpy(buf, "path/subpath"), TarIsPathInsecure(buf, "path") == 0)); assert((strcpy(buf, "path\\subpath"), TarIsPathInsecure(buf, "path") == 0)); assert((strcpy(buf, "path2\\subpath"), TarIsPathInsecure(buf, "path") == 1)); assert((strcpy(buf, "dink.exe"), TarIsPathInsecure(buf, "path") == 1)); assert((strcpy(buf, "dink.exe"), TarIsPathInsecure(buf, "path") == 1)); } return emDmodExtract(argv[1], "/tmp/testdmod", NULL); } #endif