ported to golang
This commit is contained in:
Rifat Azad
parent
6e4ace56aa
commit
5283178483
4 changed files with 310 additions and 279 deletions
4
.gitignore
vendored
4
.gitignore
vendored
|
|
@ -1,2 +1,4 @@
|
|||
*.vscode
|
||||
*pacextractor
|
||||
*pacextractor
|
||||
*.tar.gz
|
||||
*ports
|
||||
47
Makefile
47
Makefile
|
|
@ -1,16 +1,41 @@
|
|||
# Define compiler and flags
|
||||
CC = gcc
|
||||
# Variables
|
||||
BINARY_NAME = pacextractor
|
||||
SRC_FILES = pacextractor.go
|
||||
|
||||
# Target executable
|
||||
TARGET = pacextractor
|
||||
# Default target
|
||||
all: build
|
||||
|
||||
# Source files
|
||||
SRC = pacextractor.c
|
||||
# Build the binary
|
||||
build:
|
||||
go build -o $(BINARY_NAME) $(SRC_FILES)
|
||||
|
||||
# Rule to build the target
|
||||
$(TARGET): $(SRC)
|
||||
$(CC) $(SRC) -o $(TARGET)
|
||||
# Format the code
|
||||
fmt:
|
||||
go fmt $(SRC_FILES)
|
||||
|
||||
# Clean up build artifacts
|
||||
# Run go vet for static analysis
|
||||
vet:
|
||||
go vet $(SRC_FILES)
|
||||
|
||||
# Run the program with default arguments (modify as needed)
|
||||
run: build
|
||||
./$(BINARY_NAME) firmware.pac output_directory
|
||||
|
||||
# Clean the build
|
||||
clean:
|
||||
rm -f $(TARGET)
|
||||
rm -f $(BINARY_NAME)
|
||||
|
||||
# Help message
|
||||
help:
|
||||
@echo "Makefile for building and managing the Go project"
|
||||
@echo ""
|
||||
@echo "Usage:"
|
||||
@echo " make - Build the project"
|
||||
@echo " make build - Build the binary"
|
||||
@echo " make fmt - Format the source files"
|
||||
@echo " make vet - Run go vet for static analysis"
|
||||
@echo " make run - Run the program with default arguments"
|
||||
@echo " make clean - Remove the binary"
|
||||
@echo " make help - Show this help message"
|
||||
|
||||
.PHONY: all build fmt vet run clean help
|
||||
|
|
|
|||
267
pacextractor.c
267
pacextractor.c
|
|
@ -1,267 +0,0 @@
|
|||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <sys/types.h>
|
||||
#include <unistd.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/stat.h>
|
||||
|
||||
#define VERSION "1.0.0"
|
||||
|
||||
typedef struct {
|
||||
int16_t someField[24];
|
||||
int32_t someInt;
|
||||
int16_t productName[256];
|
||||
int16_t firmwareName[256];
|
||||
int32_t partitionCount;
|
||||
int32_t partitionsListStart;
|
||||
int32_t someIntFields1[5];
|
||||
int16_t productName2[50];
|
||||
int16_t someIntFields2[6];
|
||||
int16_t someIntFields3[2];
|
||||
} PacHeader;
|
||||
|
||||
typedef struct {
|
||||
uint32_t length;
|
||||
int16_t partitionName[256];
|
||||
int16_t fileName[512];
|
||||
uint32_t partitionSize;
|
||||
int32_t someFields1[2];
|
||||
uint32_t partitionAddrInPac;
|
||||
int32_t someFields2[3];
|
||||
int32_t dataArray[];
|
||||
} PartitionHeader;
|
||||
|
||||
static void getString(const int16_t* baseString, char* resString) {
|
||||
if (baseString == NULL || resString == NULL) {
|
||||
*resString = '\0';
|
||||
return;
|
||||
}
|
||||
|
||||
while (*baseString) {
|
||||
*resString++ = (char)(*baseString & 0xFF);
|
||||
baseString++;
|
||||
if (resString - resString > 255) { // Prevent buffer overflow
|
||||
break;
|
||||
}
|
||||
}
|
||||
*resString = '\0'; // Null-terminate the result string
|
||||
}
|
||||
|
||||
static void printUsage(void) {
|
||||
printf("Usage: pacextractor <firmware name>.pac <output path>\n");
|
||||
printf("Options:\n");
|
||||
printf(" -h Show this help message and exit\n");
|
||||
printf(" -v Show version information and exit\n");
|
||||
}
|
||||
|
||||
static void printUsageAndExit(void) {
|
||||
printUsage();
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
static void handleOpenFileError(const char* fileName) {
|
||||
perror(fileName);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
static int openFirmwareFile(const char* filePath) {
|
||||
int fd = open(filePath, O_RDONLY);
|
||||
if (fd == -1) {
|
||||
handleOpenFileError(filePath);
|
||||
}
|
||||
return fd;
|
||||
}
|
||||
|
||||
static void createOutputDirectory(const char* path) {
|
||||
if (access(path, F_OK) == -1) {
|
||||
if (mkdir(path, 0777) == -1) {
|
||||
perror("Failed to create output directory");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
printf("Created output directory: %s\n", path);
|
||||
}
|
||||
}
|
||||
|
||||
static PacHeader readPacHeader(int fd) {
|
||||
PacHeader header;
|
||||
if (read(fd, &header, sizeof(PacHeader)) != sizeof(PacHeader)) {
|
||||
perror("Error while reading PAC header");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
return header;
|
||||
}
|
||||
|
||||
static PartitionHeader* readPartitionHeader(int fd, uint32_t* curPos) {
|
||||
lseek(fd, *curPos, SEEK_SET);
|
||||
uint32_t length;
|
||||
if (read(fd, &length, sizeof(length)) != sizeof(length)) {
|
||||
perror("Error while reading partition header length");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
PartitionHeader* header = malloc(length);
|
||||
if (header == NULL) {
|
||||
perror("Memory allocation failed");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
lseek(fd, *curPos, SEEK_SET);
|
||||
if (read(fd, header, length) != length) {
|
||||
perror("Error while reading partition header");
|
||||
free(header);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
*curPos += length;
|
||||
return header;
|
||||
}
|
||||
|
||||
static void printProgressBar(uint32_t completed, uint32_t total) {
|
||||
const int barWidth = 50;
|
||||
float progress = (float)completed / total;
|
||||
int pos = barWidth * progress;
|
||||
|
||||
printf("\r[");
|
||||
for (int i = 0; i < barWidth; ++i) {
|
||||
if (i < pos) printf("=");
|
||||
else if (i == pos) printf(">");
|
||||
else printf(" ");
|
||||
}
|
||||
printf("] %.2f%%", progress * 100.0);
|
||||
fflush(stdout);
|
||||
}
|
||||
|
||||
static void extractPartition(int fd, const PartitionHeader* partHeader, const char* outputPath) {
|
||||
if (partHeader->partitionSize == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
lseek(fd, partHeader->partitionAddrInPac, SEEK_SET);
|
||||
|
||||
// Increase buffer size for faster I/O operations
|
||||
const size_t BUFFER_SIZE = 256 * 1024; // 256 KB
|
||||
char* buffer = malloc(BUFFER_SIZE);
|
||||
if (buffer == NULL) {
|
||||
perror("Memory allocation failed");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
char outputFilePath[768];
|
||||
char fileName[512];
|
||||
getString(partHeader->fileName, fileName);
|
||||
snprintf(outputFilePath, sizeof(outputFilePath), "%s/%s", outputPath, fileName);
|
||||
|
||||
if (remove(outputFilePath) == -1 && errno != ENOENT) {
|
||||
perror("Error removing existing output file");
|
||||
free(buffer);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
int fd_new = open(outputFilePath, O_WRONLY | O_CREAT | O_TRUNC, 0666);
|
||||
if (fd_new == -1) {
|
||||
perror("Error creating output file");
|
||||
free(buffer);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
printf("Extracting to %s\n", outputFilePath);
|
||||
|
||||
uint32_t dataSizeLeft = partHeader->partitionSize;
|
||||
uint32_t dataSizeRead = 0;
|
||||
|
||||
while (dataSizeLeft > 0) {
|
||||
uint32_t copyLength = (dataSizeLeft > BUFFER_SIZE) ? BUFFER_SIZE : dataSizeLeft;
|
||||
ssize_t rb = read(fd, buffer, copyLength);
|
||||
if (rb != copyLength) {
|
||||
perror("Error while reading partition data");
|
||||
close(fd_new);
|
||||
free(buffer);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
ssize_t wb = write(fd_new, buffer, copyLength);
|
||||
if (wb != copyLength) {
|
||||
perror("Error while writing partition data");
|
||||
close(fd_new);
|
||||
free(buffer);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
dataSizeLeft -= copyLength;
|
||||
dataSizeRead += copyLength;
|
||||
printProgressBar(dataSizeRead, partHeader->partitionSize);
|
||||
}
|
||||
printf("\n");
|
||||
close(fd_new);
|
||||
free(buffer);
|
||||
}
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
if (argc < 2) {
|
||||
printUsageAndExit();
|
||||
}
|
||||
|
||||
if (strcmp(argv[1], "-h") == 0) {
|
||||
printUsage();
|
||||
exit(EXIT_SUCCESS);
|
||||
} else if (strcmp(argv[1], "-v") == 0) {
|
||||
printf("pacextractor version %s\n", VERSION);
|
||||
exit(EXIT_SUCCESS);
|
||||
}
|
||||
|
||||
if (argc < 3) {
|
||||
printUsageAndExit();
|
||||
}
|
||||
|
||||
int fd = openFirmwareFile(argv[1]);
|
||||
|
||||
struct stat st;
|
||||
if (fstat(fd, &st) == -1) {
|
||||
perror("Error getting file stats");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
int firmwareSize = st.st_size;
|
||||
if (firmwareSize < sizeof(PacHeader)) {
|
||||
fprintf(stderr, "file %s is not a valid firmware\n", argv[1]);
|
||||
close(fd);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
char* outputPath = argv[2];
|
||||
createOutputDirectory(outputPath);
|
||||
|
||||
PacHeader pacHeader = readPacHeader(fd);
|
||||
|
||||
char firmwareName[256];
|
||||
getString(pacHeader.firmwareName, firmwareName);
|
||||
printf("Firmware name: %s\n", firmwareName);
|
||||
|
||||
uint32_t curPos = pacHeader.partitionsListStart;
|
||||
PartitionHeader** partHeaders = malloc(pacHeader.partitionCount * sizeof(PartitionHeader*));
|
||||
if (partHeaders == NULL) {
|
||||
perror("Memory allocation failed for partition headers");
|
||||
close(fd);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
for (int i = 0; i < pacHeader.partitionCount; i++) {
|
||||
partHeaders[i] = readPartitionHeader(fd, &curPos);
|
||||
|
||||
char partitionName[256];
|
||||
char fileName[512];
|
||||
getString(partHeaders[i]->partitionName, partitionName);
|
||||
getString(partHeaders[i]->fileName, fileName);
|
||||
printf("Partition name: %s\n\twith file name: %s\n\twith size %u\n",
|
||||
partitionName, fileName, partHeaders[i]->partitionSize);
|
||||
}
|
||||
|
||||
for (int i = 0; i < pacHeader.partitionCount; i++) {
|
||||
extractPartition(fd, partHeaders[i], outputPath);
|
||||
free(partHeaders[i]);
|
||||
}
|
||||
free(partHeaders);
|
||||
close(fd);
|
||||
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
271
pacextractor.go
Normal file
271
pacextractor.go
Normal file
|
|
@ -0,0 +1,271 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"flag"
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"path/filepath"
|
||||
)
|
||||
|
||||
// Version of the extractor
|
||||
const Version = "1.0.0"
|
||||
|
||||
// PacHeader is the structure for the PAC file header
|
||||
type PacHeader struct {
|
||||
SomeField [24]int16
|
||||
SomeInt int32
|
||||
ProductName [256]int16
|
||||
FirmwareName [256]int16
|
||||
PartitionCount int32
|
||||
PartitionsListStart int32
|
||||
SomeIntFields1 [5]int32
|
||||
ProductName2 [50]int16
|
||||
SomeIntFields2 [6]int16
|
||||
SomeIntFields3 [2]int16
|
||||
}
|
||||
|
||||
// PartitionHeader is the structure for each partition in the PAC file
|
||||
type PartitionHeader struct {
|
||||
Length uint32
|
||||
PartitionName [256]int16
|
||||
FileName [512]int16
|
||||
PartitionSize uint32
|
||||
SomeFields1 [2]int32
|
||||
PartitionAddrInPac uint32
|
||||
SomeFields2 [3]int32
|
||||
}
|
||||
|
||||
// getString converts an int16 array to a UTF-8 string
|
||||
func getString(baseString []int16) string {
|
||||
var resString string
|
||||
for _, ch := range baseString {
|
||||
if ch == 0 {
|
||||
break
|
||||
}
|
||||
resString += string(rune(ch))
|
||||
}
|
||||
return resString
|
||||
}
|
||||
|
||||
// printUsage prints the usage information
|
||||
func printUsage() {
|
||||
fmt.Println("Usage: pacextractor <firmware name>.pac <output path>")
|
||||
fmt.Println("Options:")
|
||||
fmt.Println(" -h Show this help message and exit")
|
||||
fmt.Println(" -v Show version information and exit")
|
||||
}
|
||||
|
||||
// openFirmwareFile opens the firmware file
|
||||
func openFirmwareFile(filePath string) (*os.File, error) {
|
||||
fd, err := os.Open(filePath)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("Error opening file %s: %w", filePath, err)
|
||||
}
|
||||
return fd, nil
|
||||
}
|
||||
|
||||
// createOutputDirectory creates the output directory if it doesn't exist
|
||||
func createOutputDirectory(path string) error {
|
||||
if _, err := os.Stat(path); os.IsNotExist(err) {
|
||||
err = os.MkdirAll(path, 0777)
|
||||
if err != nil {
|
||||
return fmt.Errorf("Failed to create output directory: %w", err)
|
||||
}
|
||||
fmt.Printf("Created output directory: %s\n", path)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// readPacHeader reads the PAC file header
|
||||
func readPacHeader(fd *os.File) (PacHeader, error) {
|
||||
var header PacHeader
|
||||
err := binary.Read(fd, binary.LittleEndian, &header)
|
||||
if err != nil {
|
||||
return header, fmt.Errorf("Error while reading PAC header: %w", err)
|
||||
}
|
||||
return header, nil
|
||||
}
|
||||
|
||||
// readPartitionHeader reads the partition header at the current file offset
|
||||
func readPartitionHeader(fd *os.File) (PartitionHeader, error) {
|
||||
var header PartitionHeader
|
||||
err := binary.Read(fd, binary.LittleEndian, &header)
|
||||
if err != nil {
|
||||
return header, fmt.Errorf("Error while reading partition header: %w", err)
|
||||
}
|
||||
return header, nil
|
||||
}
|
||||
|
||||
// printProgressBar prints a progress bar
|
||||
func printProgressBar(completed, total uint32) {
|
||||
const barWidth = 50
|
||||
progress := float64(completed) / float64(total)
|
||||
pos := int(barWidth * progress)
|
||||
|
||||
fmt.Print("\r[")
|
||||
for i := 0; i < barWidth; i++ {
|
||||
if i < pos {
|
||||
fmt.Print("=")
|
||||
} else if i == pos {
|
||||
fmt.Print(">")
|
||||
} else {
|
||||
fmt.Print(" ")
|
||||
}
|
||||
}
|
||||
fmt.Printf("] %.2f%%", progress*100)
|
||||
}
|
||||
|
||||
// extractPartition extracts a partition to a file
|
||||
func extractPartition(fd *os.File, partHeader PartitionHeader, outputPath string) error {
|
||||
if partHeader.PartitionSize == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
_, err := fd.Seek(int64(partHeader.PartitionAddrInPac), io.SeekStart)
|
||||
if err != nil {
|
||||
return fmt.Errorf("Error seeking partition data: %w", err)
|
||||
}
|
||||
|
||||
// Increase buffer size for faster I/O operations
|
||||
const bufferSize = 256 * 1024 // 256 KB
|
||||
buffer := make([]byte, bufferSize)
|
||||
|
||||
fileName := getString(partHeader.FileName[:])
|
||||
outputFilePath := filepath.Join(outputPath, fileName)
|
||||
|
||||
// Remove existing file if it exists
|
||||
err = os.Remove(outputFilePath)
|
||||
if err != nil && !os.IsNotExist(err) {
|
||||
return fmt.Errorf("Error removing existing output file: %w", err)
|
||||
}
|
||||
|
||||
fdNew, err := os.OpenFile(outputFilePath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
|
||||
if err != nil {
|
||||
return fmt.Errorf("Error creating output file: %w", err)
|
||||
}
|
||||
defer fdNew.Close()
|
||||
|
||||
fmt.Printf("Extracting to %s\n", outputFilePath)
|
||||
|
||||
dataSizeLeft := partHeader.PartitionSize
|
||||
var dataSizeRead uint32
|
||||
|
||||
for dataSizeLeft > 0 {
|
||||
copyLength := bufferSize
|
||||
if int(dataSizeLeft) < bufferSize {
|
||||
copyLength = int(dataSizeLeft)
|
||||
}
|
||||
|
||||
n, err := io.ReadFull(fd, buffer[:copyLength])
|
||||
if err != nil {
|
||||
return fmt.Errorf("Error while reading partition data: %w", err)
|
||||
}
|
||||
|
||||
_, err = fdNew.Write(buffer[:n])
|
||||
if err != nil {
|
||||
return fmt.Errorf("Error while writing partition data: %w", err)
|
||||
}
|
||||
|
||||
dataSizeLeft -= uint32(n)
|
||||
dataSizeRead += uint32(n)
|
||||
printProgressBar(dataSizeRead, partHeader.PartitionSize)
|
||||
}
|
||||
|
||||
fmt.Println()
|
||||
return nil
|
||||
}
|
||||
|
||||
func main() {
|
||||
flag.Usage = printUsage
|
||||
flagVersion := flag.Bool("v", false, "Show version information and exit")
|
||||
flagHelp := flag.Bool("h", false, "Show help message and exit")
|
||||
flag.Parse()
|
||||
|
||||
if *flagHelp {
|
||||
printUsage()
|
||||
os.Exit(0)
|
||||
}
|
||||
|
||||
if *flagVersion {
|
||||
fmt.Printf("pacextractor version %s\n", Version)
|
||||
os.Exit(0)
|
||||
}
|
||||
|
||||
args := flag.Args()
|
||||
if len(args) < 2 {
|
||||
printUsage()
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
firmwarePath := args[0]
|
||||
outputPath := args[1]
|
||||
|
||||
fd, err := openFirmwareFile(firmwarePath)
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
os.Exit(1)
|
||||
}
|
||||
defer fd.Close()
|
||||
|
||||
fileInfo, err := fd.Stat()
|
||||
if err != nil {
|
||||
fmt.Printf("Error getting file stats: %v\n", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
firmwareSize := fileInfo.Size()
|
||||
if firmwareSize < int64(binary.Size(PacHeader{})) {
|
||||
fmt.Printf("file %s is not a valid firmware\n", firmwarePath)
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
err = createOutputDirectory(outputPath)
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
pacHeader, err := readPacHeader(fd)
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
firmwareName := getString(pacHeader.FirmwareName[:])
|
||||
fmt.Printf("Firmware name: %s\n", firmwareName)
|
||||
|
||||
curPos := int64(pacHeader.PartitionsListStart)
|
||||
partHeaders := make([]PartitionHeader, pacHeader.PartitionCount)
|
||||
|
||||
for i := 0; i < int(pacHeader.PartitionCount); i++ {
|
||||
_, err := fd.Seek(curPos, io.SeekStart)
|
||||
if err != nil {
|
||||
fmt.Printf("Error seeking to partition %d: %v\n", i, err)
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
partHeader, err := readPartitionHeader(fd)
|
||||
if err != nil {
|
||||
fmt.Printf("Error reading partition %d: %v\n", i, err)
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
partHeaders[i] = partHeader
|
||||
|
||||
partitionName := getString(partHeader.PartitionName[:])
|
||||
fileName := getString(partHeader.FileName[:])
|
||||
fmt.Printf("Partition name: %s\n\twith file name: %s\n\twith size %d\n", partitionName, fileName, partHeader.PartitionSize)
|
||||
|
||||
curPos += int64(partHeader.Length)
|
||||
}
|
||||
|
||||
for i := 0; i < int(pacHeader.PartitionCount); i++ {
|
||||
err = extractPartition(fd, partHeaders[i], outputPath)
|
||||
if err != nil {
|
||||
fmt.Printf("Error extracting partition %d: %v\n", i, err)
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue