374 lines
10 KiB
C++
374 lines
10 KiB
C++
// Copyright (c) 2006, Google Inc.
|
|
// All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions are
|
|
// met:
|
|
//
|
|
// * Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
// * Redistributions in binary form must reproduce the above
|
|
// copyright notice, this list of conditions and the following disclaimer
|
|
// in the documentation and/or other materials provided with the
|
|
// distribution.
|
|
// * Neither the name of Google Inc. nor the names of its
|
|
// contributors may be used to endorse or promote products derived from
|
|
// this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
// macho_id.cc: Functions to gather identifying information from a macho file
|
|
//
|
|
// See macho_id.h for documentation
|
|
//
|
|
// Author: Dan Waylonis
|
|
|
|
extern "C" { // necessary for Leopard
|
|
#include <fcntl.h>
|
|
#include <mach-o/loader.h>
|
|
#include <mach-o/swap.h>
|
|
#include <openssl/md5.h>
|
|
#include <openssl/sha.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/time.h>
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
}
|
|
|
|
#include "common/mac/macho_id.h"
|
|
#include "common/mac/macho_walker.h"
|
|
#include "common/mac/macho_utilities.h"
|
|
|
|
namespace MacFileUtilities {
|
|
|
|
MachoID::MachoID(const char *path)
|
|
: file_(0),
|
|
crc_(0),
|
|
md5_context_(),
|
|
sha1_context_(),
|
|
update_function_(NULL) {
|
|
strlcpy(path_, path, sizeof(path_));
|
|
file_ = open(path, O_RDONLY);
|
|
}
|
|
|
|
MachoID::~MachoID() {
|
|
if (file_ != -1)
|
|
close(file_);
|
|
}
|
|
|
|
// The CRC info is from http://en.wikipedia.org/wiki/Adler-32
|
|
// With optimizations from http://www.zlib.net/
|
|
|
|
// The largest prime smaller than 65536
|
|
#define MOD_ADLER 65521
|
|
// MAX_BLOCK is the largest n such that 255n(n+1)/2 + (n+1)(MAX_BLOCK-1) <= 2^32-1
|
|
#define MAX_BLOCK 5552
|
|
|
|
void MachoID::UpdateCRC(unsigned char *bytes, size_t size) {
|
|
// Unrolled loops for summing
|
|
#define DO1(buf,i) {sum1 += (buf)[i]; sum2 += sum1;}
|
|
#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1);
|
|
#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2);
|
|
#define DO8(buf,i) DO4(buf,i); DO4(buf,i+4);
|
|
#define DO16(buf) DO8(buf,0); DO8(buf,8);
|
|
// Split up the crc
|
|
uint32_t sum1 = crc_ & 0xFFFF;
|
|
uint32_t sum2 = (crc_ >> 16) & 0xFFFF;
|
|
|
|
// Do large blocks
|
|
while (size >= MAX_BLOCK) {
|
|
size -= MAX_BLOCK;
|
|
int block_count = MAX_BLOCK / 16;
|
|
do {
|
|
DO16(bytes);
|
|
bytes += 16;
|
|
} while (--block_count);
|
|
sum1 %= MOD_ADLER;
|
|
sum2 %= MOD_ADLER;
|
|
}
|
|
|
|
// Do remaining bytes
|
|
if (size) {
|
|
while (size >= 16) {
|
|
size -= 16;
|
|
DO16(bytes);
|
|
bytes += 16;
|
|
}
|
|
while (size--) {
|
|
sum1 += *bytes++;
|
|
sum2 += sum1;
|
|
}
|
|
sum1 %= MOD_ADLER;
|
|
sum2 %= MOD_ADLER;
|
|
crc_ = (sum2 << 16) | sum1;
|
|
}
|
|
}
|
|
|
|
void MachoID::UpdateMD5(unsigned char *bytes, size_t size) {
|
|
MD5_Update(&md5_context_, bytes, size);
|
|
}
|
|
|
|
void MachoID::UpdateSHA1(unsigned char *bytes, size_t size) {
|
|
SHA_Update(&sha1_context_, bytes, size);
|
|
}
|
|
|
|
void MachoID::Update(MachoWalker *walker, off_t offset, size_t size) {
|
|
if (!update_function_ || !size)
|
|
return;
|
|
|
|
// Read up to 4k bytes at a time
|
|
unsigned char buffer[4096];
|
|
size_t buffer_size;
|
|
off_t file_offset = offset;
|
|
while (size > 0) {
|
|
if (size > sizeof(buffer)) {
|
|
buffer_size = sizeof(buffer);
|
|
size -= buffer_size;
|
|
} else {
|
|
buffer_size = size;
|
|
size = 0;
|
|
}
|
|
|
|
if (!walker->ReadBytes(buffer, buffer_size, file_offset))
|
|
return;
|
|
|
|
(this->*update_function_)(buffer, buffer_size);
|
|
file_offset += buffer_size;
|
|
}
|
|
}
|
|
|
|
bool MachoID::UUIDCommand(int cpu_type, unsigned char bytes[16]) {
|
|
struct breakpad_uuid_command uuid_cmd;
|
|
MachoWalker walker(path_, UUIDWalkerCB, &uuid_cmd);
|
|
|
|
uuid_cmd.cmd = 0;
|
|
if (!walker.WalkHeader(cpu_type))
|
|
return false;
|
|
|
|
// If we found the command, we'll have initialized the uuid_command
|
|
// structure
|
|
if (uuid_cmd.cmd == LC_UUID) {
|
|
memcpy(bytes, uuid_cmd.uuid, sizeof(uuid_cmd.uuid));
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool MachoID::IDCommand(int cpu_type, unsigned char identifier[16]) {
|
|
struct dylib_command dylib_cmd;
|
|
MachoWalker walker(path_, IDWalkerCB, &dylib_cmd);
|
|
|
|
dylib_cmd.cmd = 0;
|
|
if (!walker.WalkHeader(cpu_type))
|
|
return false;
|
|
|
|
// If we found the command, we'll have initialized the dylib_command
|
|
// structure
|
|
if (dylib_cmd.cmd == LC_ID_DYLIB) {
|
|
// Take the hashed filename, version, and compatability version bytes
|
|
// to form the first 12 bytes, pad the rest with zeros
|
|
|
|
// create a crude hash of the filename to generate the first 4 bytes
|
|
identifier[0] = 0;
|
|
identifier[1] = 0;
|
|
identifier[2] = 0;
|
|
identifier[3] = 0;
|
|
|
|
for (int j = 0, i = (int)strlen(path_)-1; i>=0 && path_[i]!='/'; ++j, --i) {
|
|
identifier[j%4] += path_[i];
|
|
}
|
|
|
|
identifier[4] = (dylib_cmd.dylib.current_version >> 24) & 0xFF;
|
|
identifier[5] = (dylib_cmd.dylib.current_version >> 16) & 0xFF;
|
|
identifier[6] = (dylib_cmd.dylib.current_version >> 8) & 0xFF;
|
|
identifier[7] = dylib_cmd.dylib.current_version & 0xFF;
|
|
identifier[8] = (dylib_cmd.dylib.compatibility_version >> 24) & 0xFF;
|
|
identifier[9] = (dylib_cmd.dylib.compatibility_version >> 16) & 0xFF;
|
|
identifier[10] = (dylib_cmd.dylib.compatibility_version >> 8) & 0xFF;
|
|
identifier[11] = dylib_cmd.dylib.compatibility_version & 0xFF;
|
|
identifier[12] = (cpu_type >> 24) & 0xFF;
|
|
identifier[13] = (cpu_type >> 16) & 0xFF;
|
|
identifier[14] = (cpu_type >> 8) & 0xFF;
|
|
identifier[15] = cpu_type & 0xFF;
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
uint32_t MachoID::Adler32(int cpu_type) {
|
|
MachoWalker walker(path_, WalkerCB, this);
|
|
update_function_ = &MachoID::UpdateCRC;
|
|
crc_ = 0;
|
|
|
|
if (!walker.WalkHeader(cpu_type))
|
|
return 0;
|
|
|
|
return crc_;
|
|
}
|
|
|
|
bool MachoID::MD5(int cpu_type, unsigned char identifier[16]) {
|
|
MachoWalker walker(path_, WalkerCB, this);
|
|
update_function_ = &MachoID::UpdateMD5;
|
|
|
|
if (MD5_Init(&md5_context_)) {
|
|
if (!walker.WalkHeader(cpu_type))
|
|
return false;
|
|
|
|
MD5_Final(identifier, &md5_context_);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool MachoID::SHA1(int cpu_type, unsigned char identifier[16]) {
|
|
MachoWalker walker(path_, WalkerCB, this);
|
|
update_function_ = &MachoID::UpdateSHA1;
|
|
|
|
if (SHA_Init(&sha1_context_)) {
|
|
if (!walker.WalkHeader(cpu_type))
|
|
return false;
|
|
|
|
SHA_Final(identifier, &sha1_context_);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// static
|
|
bool MachoID::WalkerCB(MachoWalker *walker, load_command *cmd, off_t offset,
|
|
bool swap, void *context) {
|
|
MachoID *macho_id = (MachoID *)context;
|
|
|
|
if (cmd->cmd == LC_SEGMENT) {
|
|
struct segment_command seg;
|
|
|
|
if (!walker->ReadBytes(&seg, sizeof(seg), offset))
|
|
return false;
|
|
|
|
if (swap)
|
|
swap_segment_command(&seg, NXHostByteOrder());
|
|
|
|
struct mach_header_64 header;
|
|
off_t header_offset;
|
|
|
|
if (!walker->CurrentHeader(&header, &header_offset))
|
|
return false;
|
|
|
|
// Process segments that have sections:
|
|
// (e.g., __TEXT, __DATA, __IMPORT, __OBJC)
|
|
offset += sizeof(struct segment_command);
|
|
struct section sec;
|
|
for (unsigned long i = 0; i < seg.nsects; ++i) {
|
|
if (!walker->ReadBytes(&sec, sizeof(sec), offset))
|
|
return false;
|
|
|
|
if (swap)
|
|
swap_section(&sec, 1, NXHostByteOrder());
|
|
|
|
// sections of type S_ZEROFILL are "virtual" and contain no data
|
|
// in the file itself
|
|
if ((sec.flags & SECTION_TYPE) != S_ZEROFILL && sec.offset != 0)
|
|
macho_id->Update(walker, header_offset + sec.offset, sec.size);
|
|
|
|
offset += sizeof(struct section);
|
|
}
|
|
} else if (cmd->cmd == LC_SEGMENT_64) {
|
|
struct segment_command_64 seg64;
|
|
|
|
if (!walker->ReadBytes(&seg64, sizeof(seg64), offset))
|
|
return false;
|
|
|
|
if (swap)
|
|
breakpad_swap_segment_command_64(&seg64, NXHostByteOrder());
|
|
|
|
struct mach_header_64 header;
|
|
off_t header_offset;
|
|
|
|
if (!walker->CurrentHeader(&header, &header_offset))
|
|
return false;
|
|
|
|
// Process segments that have sections:
|
|
// (e.g., __TEXT, __DATA, __IMPORT, __OBJC)
|
|
offset += sizeof(struct segment_command_64);
|
|
struct section_64 sec64;
|
|
for (unsigned long i = 0; i < seg64.nsects; ++i) {
|
|
if (!walker->ReadBytes(&sec64, sizeof(sec64), offset))
|
|
return false;
|
|
|
|
if (swap)
|
|
breakpad_swap_section_64(&sec64, 1, NXHostByteOrder());
|
|
|
|
// sections of type S_ZEROFILL are "virtual" and contain no data
|
|
// in the file itself
|
|
if ((sec64.flags & SECTION_TYPE) != S_ZEROFILL && sec64.offset != 0)
|
|
macho_id->Update(walker,
|
|
header_offset + sec64.offset,
|
|
(size_t)sec64.size);
|
|
|
|
offset += sizeof(struct section_64);
|
|
}
|
|
}
|
|
|
|
// Continue processing
|
|
return true;
|
|
}
|
|
|
|
// static
|
|
bool MachoID::UUIDWalkerCB(MachoWalker *walker, load_command *cmd, off_t offset,
|
|
bool swap, void *context) {
|
|
if (cmd->cmd == LC_UUID) {
|
|
struct breakpad_uuid_command *uuid_cmd =
|
|
(struct breakpad_uuid_command *)context;
|
|
|
|
if (!walker->ReadBytes(uuid_cmd, sizeof(struct breakpad_uuid_command),
|
|
offset))
|
|
return false;
|
|
|
|
if (swap)
|
|
breakpad_swap_uuid_command(uuid_cmd, NXHostByteOrder());
|
|
|
|
return false;
|
|
}
|
|
|
|
// Continue processing
|
|
return true;
|
|
}
|
|
|
|
// static
|
|
bool MachoID::IDWalkerCB(MachoWalker *walker, load_command *cmd, off_t offset,
|
|
bool swap, void *context) {
|
|
if (cmd->cmd == LC_ID_DYLIB) {
|
|
struct dylib_command *dylib_cmd = (struct dylib_command *)context;
|
|
|
|
if (!walker->ReadBytes(dylib_cmd, sizeof(struct dylib_command), offset))
|
|
return false;
|
|
|
|
if (swap)
|
|
swap_dylib_command(dylib_cmd, NXHostByteOrder());
|
|
|
|
return false;
|
|
}
|
|
|
|
// Continue processing
|
|
return true;
|
|
}
|
|
|
|
} // namespace MacFileUtilities
|