From 14c7f45cdae826f88dc539c8c38dd95caf305731 Mon Sep 17 00:00:00 2001 From: Maurus Cuelenaere Date: Fri, 11 Jul 2008 15:50:46 +0000 Subject: Add zook's ZenUtils to SVN git-svn-id: svn://svn.rockbox.org/rockbox/trunk@18010 a1c6a512-1295-4272-9138-f99709370657 --- utils/zenutils/source/shared/CMakeLists.txt | 16 ++ utils/zenutils/source/shared/cenc.cpp | 333 ++++++++++++++++++++++++ utils/zenutils/source/shared/cenc.h | 29 +++ utils/zenutils/source/shared/crypt.cpp | 91 +++++++ utils/zenutils/source/shared/crypt.h | 30 +++ utils/zenutils/source/shared/file.cpp | 106 ++++++++ utils/zenutils/source/shared/file.h | 36 +++ utils/zenutils/source/shared/firmware.cpp | 387 ++++++++++++++++++++++++++++ utils/zenutils/source/shared/firmware.h | 92 +++++++ utils/zenutils/source/shared/pe.cpp | 128 +++++++++ utils/zenutils/source/shared/pe.h | 142 ++++++++++ utils/zenutils/source/shared/shared.cpp | 0 utils/zenutils/source/shared/updater.cpp | 151 +++++++++++ utils/zenutils/source/shared/updater.h | 32 +++ utils/zenutils/source/shared/utils.cpp | 211 +++++++++++++++ utils/zenutils/source/shared/utils.h | 68 +++++ 16 files changed, 1852 insertions(+) create mode 100755 utils/zenutils/source/shared/CMakeLists.txt create mode 100755 utils/zenutils/source/shared/cenc.cpp create mode 100755 utils/zenutils/source/shared/cenc.h create mode 100755 utils/zenutils/source/shared/crypt.cpp create mode 100755 utils/zenutils/source/shared/crypt.h create mode 100755 utils/zenutils/source/shared/file.cpp create mode 100755 utils/zenutils/source/shared/file.h create mode 100755 utils/zenutils/source/shared/firmware.cpp create mode 100755 utils/zenutils/source/shared/firmware.h create mode 100755 utils/zenutils/source/shared/pe.cpp create mode 100755 utils/zenutils/source/shared/pe.h create mode 100755 utils/zenutils/source/shared/shared.cpp create mode 100755 utils/zenutils/source/shared/updater.cpp create mode 100755 utils/zenutils/source/shared/updater.h create mode 100755 utils/zenutils/source/shared/utils.cpp create mode 100755 utils/zenutils/source/shared/utils.h (limited to 'utils/zenutils/source/shared') diff --git a/utils/zenutils/source/shared/CMakeLists.txt b/utils/zenutils/source/shared/CMakeLists.txt new file mode 100755 index 0000000000..2e42dbbe74 --- /dev/null +++ b/utils/zenutils/source/shared/CMakeLists.txt @@ -0,0 +1,16 @@ +PROJECT(shared) + +# source files for shared +SET(shared_srcs + cenc.cpp + crypt.cpp + file.cpp + firmware.cpp + pe.cpp + updater.cpp + utils.cpp +) + +ADD_LIBRARY(shared ${shared_srcs}) +TARGET_LINK_LIBRARIES(shared pelib) +TARGET_LINK_LIBRARIES(shared zlib) diff --git a/utils/zenutils/source/shared/cenc.cpp b/utils/zenutils/source/shared/cenc.cpp new file mode 100755 index 0000000000..932bee4625 --- /dev/null +++ b/utils/zenutils/source/shared/cenc.cpp @@ -0,0 +1,333 @@ +/* zenutils - Utilities for working with creative firmwares. + * Copyright 2007 (c) Rasmus Ry + * + * This program 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 2 of the License, or + * (at your option) any later version. + * + * This program 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "cenc.h" +#include +#include + + +namespace { +const byte CODE_MASK = 0xC0; +const byte ARGS_MASK = 0x3F; + +const byte REPEAT_CODE = 0x00; +const byte BLOCK_CODE = 0x40; +const byte LONG_RUN_CODE = 0x80; +const byte SHORT_RUN_CODE = 0xC0; + +const byte BLOCK_ARGS = 0x1F; +const byte BLOCK_MODE = 0x20; + + +void decode_run(byte* dst, word len, byte val, + int& dstidx) +{ + memset(dst + dstidx, val, len); + dstidx += len; +} + +void decode_pattern(byte* src, byte* dst, + word len, int& srcidx, int& dstidx, + bool bdecode, int npasses) +{ + for (int i = 0; i < npasses; i++) + { + if (bdecode) + { + for (int j = 0; j < len; j++) + { + word c, d; + c = src[srcidx + j]; + d = (c >> 5) & 7; + c = (c << 3) & 0xF8; + src[srcidx + j] = static_cast(c | d); + } + bdecode = false; + } + memcpy(dst + dstidx, src + srcidx, len); + dstidx += len; + } + srcidx += len; +} +}; //namespace + +int zen::cenc_decode(byte* src, int srclen, byte* dst, int dstlen) +{ + if (!src || !srclen || !dst || !dstlen) + { + throw std::invalid_argument("Invalid argument(s)."); + } + + int i = 0, j = 0; + do + { + word c, d, e; + c = src[i++]; + switch (c & CODE_MASK) + { + case REPEAT_CODE: // 2 bytes + d = src[i++]; + d = d + 2; + + e = (c & ARGS_MASK) + 2; + + decode_pattern(src, dst, e, i, j, false, d); + break; + + case BLOCK_CODE: // 1/2/3 bytes + d = c & BLOCK_ARGS; + if (!(c & BLOCK_MODE)) + { + e = src[i++]; + e = (d << 8) + (e + 0x21); + + d = static_cast(i ^ j); + } + else + { + e = d + 1; + + d = static_cast(i ^ j); + } + if (d & 1) + { + i++; + } + + decode_pattern(src, dst, e, i, j, true, 1); + break; + + case LONG_RUN_CODE: // 3 bytes + d = src[i++]; + e = ((c & ARGS_MASK) << 8) + (d + 0x42); + + d = src[i++]; + d = ((d & 7) << 5) | ((d >> 3) & 0x1F); + + decode_run(dst, e, static_cast(d), j); + break; + + case SHORT_RUN_CODE: // 2 bytes + d = src[i++]; + d = ((d & 3) << 6) | ((d >> 2) & 0x3F); + + e = (c & ARGS_MASK) + 2; + + decode_run(dst, e, static_cast(d), j); + break; + }; + } while (i < srclen && j < dstlen); + + return j; +} + +namespace { +int encode_run(byte* dst, int& dstidx, byte val, int len, int dstlen) +{ + if (len < 2) + throw std::invalid_argument("Length is too small."); + + int ret = 0; + if (len <= 0x41) + { + if ((dstidx + 2) > dstlen) + throw std::runtime_error("Not enough space to store run."); + + dst[dstidx++] = SHORT_RUN_CODE | (((len - 2) & ARGS_MASK)); + dst[dstidx++] = ((val >> 6) & 3) | ((val & 0x3F) << 2); + + ret = 2; + } + else if (len <= 0x4041) + { + if ((dstidx + 3) > dstlen) + throw std::runtime_error("Not enough space to store run."); + + byte b1 = (len - 0x42) >> 8; + byte b2 = (len - 0x42) & 0xFF; + + dst[dstidx++] = LONG_RUN_CODE | ((b1 & ARGS_MASK)); + dst[dstidx++] = b2; + dst[dstidx++] = ((val >> 5) & 7) | ((val & 0x1F) << 3); + + ret = 3; + } + else + { + int long_count = len / 0x4041; + int short_len = len % 0x4041; + bool toosmall = short_len == 1; + + int run_len = 0x4041; + for (int i = 0; i < long_count; i++) + { + if (toosmall && (i == (long_count-1))) + { + run_len--; + toosmall = false; + } + int tmp = encode_run(dst, dstidx, val, run_len, dstlen); + if (!tmp) return 0; + ret += tmp; + len -= run_len; + } + + if (len) + { + int short_count = len / 0x41; + int short_rest = short_count ? (len % 0x41) : 0; + toosmall = short_rest == 1; + + run_len = 0x41; + for (int i = 0; i < short_count; i++) + { + if (toosmall && (i == (short_count-1))) + { + run_len--; + toosmall = false; + } + int tmp = encode_run(dst, dstidx, val, run_len, dstlen); + if (!tmp) return 0; + ret += tmp; + len -= run_len; + } + int tmp = encode_run(dst, dstidx, val, len, dstlen); + if (!tmp) return 0; + ret += tmp; + len -= len; + } + } + + return ret; +} + +int encode_block(byte* dst, int& dstidx, byte* src, int& srcidx, int len, + int dstlen) +{ + if (len < 1) + throw std::invalid_argument("Length is too small."); + + int startidx = dstidx; + if (len < 0x21) + { + if ((dstidx + 2 + len) > dstlen) + throw std::runtime_error("Not enough space to store block."); + + dst[dstidx++] = BLOCK_CODE | BLOCK_MODE | ((len - 1) & BLOCK_ARGS); + if ((dstidx ^ srcidx) & 1) + dst[dstidx++] = 0; + + for (int i = 0; i < len; i++) + { + byte c = src[srcidx++]; + byte d = (c & 7) << 5; + c = (c & 0xF8) >> 3; + dst[dstidx++] = c | d; + } + } + else if (len < 0x2021) + { + if ((dstidx + 3 + len) > dstlen) + throw std::runtime_error("Not enough space to store block."); + + dst[dstidx++] = BLOCK_CODE | (((len - 0x21) >> 8) & BLOCK_ARGS); + dst[dstidx++] = (len - 0x21) & 0xFF; + if ((dstidx ^ srcidx) & 1) + dst[dstidx++] = 0; + + for (int i = 0; i < len; i++) + { + byte c = src[srcidx++]; + byte d = (c & 7) << 5; + c = (c & 0xF8) >> 3; + dst[dstidx++] = c | d; + } + } + else + { + int longblocks = len / 0x2020; + int rest = len % 0x2020; + for (int i = 0; i < longblocks; i++) + { + int tmp = encode_block(dst, dstidx, src, srcidx, 0x2020, dstlen); + if (!tmp) return 0; + } + if (rest) + { + int shortblocks = rest / 0x20; + for (int i = 0; i < shortblocks; i++) + { + int tmp = encode_block(dst, dstidx, src, srcidx, 0x20, dstlen); + if (!tmp) return 0; + } + rest = rest % 0x20; + int tmp = encode_block(dst, dstidx, src, srcidx, rest, dstlen); + if (!tmp) return 0; + } + } + + return (dstidx - startidx); +} +}; //namespace + +int zen::cenc_encode(byte* src, int srclen, byte* dst, int dstlen) +{ + if (!src || !srclen || !dst || !dstlen) + { + throw std::invalid_argument("Invalid argument(s)."); + } + + int i = 0, j = 0, k = 0; + word c, d, e; + int runlen = 0; + while (i < srclen && j < dstlen) + { + k = i; + c = src[i++]; + runlen = 1; + while (i < srclen && src[i] == c) + { + runlen++; + i++; + } + if (runlen >= 2) + { + if (!encode_run(dst, j, c, runlen, dstlen)) + return 0; + } + else + { + runlen = 0; + i = k; + while (i < (srclen - 1) && (src[i] != src[i + 1])) + { + runlen++; + i++; + } + if (i == (srclen - 1)) + { + runlen++; + i++; + } + if (!encode_block(dst, j, src, k, runlen, dstlen)) + return 0; + } + } + + return j; +} diff --git a/utils/zenutils/source/shared/cenc.h b/utils/zenutils/source/shared/cenc.h new file mode 100755 index 0000000000..12a7c92516 --- /dev/null +++ b/utils/zenutils/source/shared/cenc.h @@ -0,0 +1,29 @@ +/* zenutils - Utilities for working with creative firmwares. + * Copyright 2007 (c) Rasmus Ry + * + * This program 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 2 of the License, or + * (at your option) any later version. + * + * This program 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef ZEN_CENC_H_INCLUDED +#define ZEN_CENC_H_INCLUDED + +#include + +namespace zen { + int cenc_decode(byte* src, int srclen, byte* dst, int dstlen); + int cenc_encode(byte* src, int srclen, byte* dst, int dstlen); +}; //namespace zen + +#endif //CENC_H_INCLUDED diff --git a/utils/zenutils/source/shared/crypt.cpp b/utils/zenutils/source/shared/crypt.cpp new file mode 100755 index 0000000000..9c2d33870c --- /dev/null +++ b/utils/zenutils/source/shared/crypt.cpp @@ -0,0 +1,91 @@ +/* zenutils - Utilities for working with creative firmwares. + * Copyright 2007 (c) Rasmus Ry + * + * This program 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 2 of the License, or + * (at your option) any later version. + * + * This program 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "crypt.h" +#include +#include +#include +#include + + +bool zen::hmac_sha1_calc(const byte* key, size_t keylen, const byte* data, + size_t datalen, byte* sig, size_t* siglen) +{ + hmacsha1Param param; + if (hmacsha1Setup(¶m, key, keylen * 8)) + return false; + if (hmacsha1Update(¶m, data, datalen)) + return false; + if (hmacsha1Digest(¶m, sig)) + return false; + return true; +} + +bool zen::bf_cbc_encrypt(const byte* key, size_t keylen, byte* data, + size_t datalen, const byte* iv) +{ + if (datalen % blowfish.blocksize) + throw std::invalid_argument( + "The length must be aligned on a 8 byte boundary."); + + blowfishParam param; + if (blowfishSetup(¶m, key, keylen * 8, ENCRYPT)) + return false; + if (blowfishSetIV(¶m, iv)) + return false; + + byte* plain = new byte[datalen]; + memcpy(plain, data, datalen); + + unsigned int nblocks = datalen / blowfish.blocksize; + if (blockEncryptCBC(&blowfish, ¶m, (uint32_t*)data, (uint32_t*)plain, + nblocks)) + { + delete [] plain; + return false; + } + + return true; +} + +bool zen::bf_cbc_decrypt(const byte* key, size_t keylen, byte* data, + size_t datalen, const byte* iv) +{ + if (datalen % blowfish.blocksize) + throw std::invalid_argument( + "The length must be aligned on a 8 byte boundary."); + + blowfishParam param; + if (blowfishSetup(¶m, key, keylen * 8, ENCRYPT)) + return false; + if (blowfishSetIV(¶m, iv)) + return false; + + byte* cipher = new byte[datalen]; + memcpy(cipher, data, datalen); + + unsigned int nblocks = datalen / blowfish.blocksize; + if (blockDecryptCBC(&blowfish, ¶m, (uint32_t*)data, (uint32_t*)cipher, + nblocks)) + { + delete [] cipher; + return false; + } + + return true; +} diff --git a/utils/zenutils/source/shared/crypt.h b/utils/zenutils/source/shared/crypt.h new file mode 100755 index 0000000000..a057055b70 --- /dev/null +++ b/utils/zenutils/source/shared/crypt.h @@ -0,0 +1,30 @@ +/* zenutils - Utilities for working with creative firmwares. + * Copyright 2007 (c) Rasmus Ry + * + * This program 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 2 of the License, or + * (at your option) any later version. + * + * This program 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef ZEN_CRYPT_H_INCLUDED +#define ZEN_CRYPT_H_INCLUDED + +#include + +namespace zen { + bool hmac_sha1_calc(const byte* key, size_t keylen, const byte* data, size_t datalen, byte* sig, size_t* siglen); + bool bf_cbc_encrypt(const byte* key, size_t keylen, byte* data, size_t datalen, const byte* iv); + bool bf_cbc_decrypt(const byte* key, size_t keylen, byte* data, size_t datalen, const byte* iv); +}; //namespace zen + +#endif //ZEN_CRYPT_H_INCLUDED diff --git a/utils/zenutils/source/shared/file.cpp b/utils/zenutils/source/shared/file.cpp new file mode 100755 index 0000000000..2c31498972 --- /dev/null +++ b/utils/zenutils/source/shared/file.cpp @@ -0,0 +1,106 @@ +/* zenutils - Utilities for working with creative firmwares. + * Copyright 2007 (c) Rasmus Ry + * + * This program 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 2 of the License, or + * (at your option) any later version. + * + * This program 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "file.h" +#include + + +bool shared::read_file(const std::string& filename, bytes& buffer, + std::streampos offset, std::streamsize count) +{ + std::ifstream ifs; + ifs.open(filename.c_str(), std::ios::binary); + if (!ifs) + { + return false; + } + + std::ifstream::pos_type startpos = offset; + ifs.seekg(offset, std::ios::beg); + if (count == -1) + ifs.seekg(0, std::ios::end); + else + ifs.seekg(count, std::ios::cur); + std::ifstream::pos_type endpos = ifs.tellg(); + + buffer.resize(endpos-startpos); + ifs.seekg(offset, std::ios::beg); + + ifs.read((char*)&buffer[0], endpos-startpos); + + ifs.close(); + return ifs.good(); +} + + +bool shared::write_file(const std::string& filename, bytes& buffer, + bool truncate, std::streampos offset, + std::streamsize count) +{ + std::ios::openmode mode = std::ios::in|std::ios::out|std::ios::binary; + if (truncate) + mode |= std::ios::trunc; + + std::fstream ofs; + ofs.open(filename.c_str(), mode); + if (!ofs) + { + return false; + } + + if (count == -1) + count = buffer.size(); + else if (count > buffer.size()) + return false; + + ofs.seekg(offset, std::ios::beg); + + ofs.write((char*)&buffer[0], count); + + ofs.close(); + return ofs.good(); +} + +bool shared::file_exists(const std::string& filename) +{ + std::ifstream ifs; + ifs.open(filename.c_str(), std::ios::in); + if (ifs.is_open()) + { + ifs.close(); + return true; + } + return false; +} + +bool shared::copy_file(const std::string& srcname, const std::string& dstname) +{ + bytes buffer; + if (!read_file(srcname, buffer)) + return false; + return write_file(dstname, buffer, true); +} + +bool shared::backup_file(const std::string& filename, bool force) +{ + std::string backupname = filename + ".bak"; + if (!force) + if (file_exists(backupname)) + return true; + return copy_file(filename, backupname); +} diff --git a/utils/zenutils/source/shared/file.h b/utils/zenutils/source/shared/file.h new file mode 100755 index 0000000000..8fa533c981 --- /dev/null +++ b/utils/zenutils/source/shared/file.h @@ -0,0 +1,36 @@ +/* zenutils - Utilities for working with creative firmwares. + * Copyright 2007 (c) Rasmus Ry + * + * This program 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 2 of the License, or + * (at your option) any later version. + * + * This program 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef SHARED_FILE_H_INCLUDED +#define SHARED_FILE_H_INCLUDED + +#include +#include +#include "utils.h" + +namespace shared { + bool read_file(const std::string& filename, bytes& buffer, + std::streampos offset = 0, std::streamsize count = -1); + bool write_file(const std::string& filename, bytes& buffer, bool truncate, + std::streampos offset = 0, std::streamsize count = -1); + bool file_exists(const std::string& filename); + bool copy_file(const std::string& srcname, const std::string& dstname); + bool backup_file(const std::string& filename, bool force = false); +}; //namespace shared + +#endif //SHARED_FILE_H_INCLUDED diff --git a/utils/zenutils/source/shared/firmware.cpp b/utils/zenutils/source/shared/firmware.cpp new file mode 100755 index 0000000000..7767b55d8f --- /dev/null +++ b/utils/zenutils/source/shared/firmware.cpp @@ -0,0 +1,387 @@ +/* zenutils - Utilities for working with creative firmwares. + * Copyright 2007 (c) Rasmus Ry + * + * This program 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 2 of the License, or + * (at your option) any later version. + * + * This program 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "firmware.h" +#include +#include + + +zen::firmware_entry::firmware_entry(bool big_endian) + : _big_endian(big_endian) +{ +} + +zen::firmware_entry::firmware_entry(const firmware_entry& copy) +{ + assign(copy); +} + +zen::firmware_entry& zen::firmware_entry::operator=(const firmware_entry& right) +{ + assign(right); + return *this; +} + + +bool zen::firmware_entry::read(std::istream& is) +{ + // Read the header. + is.read((char*)&_header, sizeof(firmware_header_t)); + if (!is.good()) + return false; + + // If the firmware is big-endian, swap the header values to little-endian. + if (_big_endian) + { + _header.tag = shared::swap(_header.tag); + if (_header.tag != 'NULL') + { + _header.size = shared::swap(_header.size); + } + } + + // Resize the bytes buffer to the size specified in the header. + _bytes.resize(_header.size); + + // Read the entry contents. + is.read(reinterpret_cast(&_bytes[0]), + _header.size); + + return is.good(); +} + +bool zen::firmware_entry::write(std::ostream& os) const +{ + // Form a header using the current size of the bytes buffer. + firmware_header_t header = { + _header.tag, + static_cast(_bytes.size()) + }; + + // If the firmware is big-endian, swap the header values back into big-endian. + if (_big_endian) + { + if (header.tag != 'NULL') + { + header.size = shared::swap(header.size); + } + header.tag = shared::swap(header.tag); + } + + // Write the header. + os.write((const char*)&header, sizeof(firmware_header_t)); + if (!os.good()) + return false; + + // Write the entry contents. + os.write(reinterpret_cast(&_bytes[0]), + static_cast(_bytes.size())); + + return os.good(); +} + + +bool zen::firmware_entry::is_big_endian() const +{ + return _big_endian; +} + +const zen::firmware_header_t& zen::firmware_entry::get_header() const +{ + return _header; +} +zen::firmware_header_t& zen::firmware_entry::get_header() +{ + return _header; +} + +const shared::bytes& zen::firmware_entry::get_bytes() const +{ + return _bytes; +} +shared::bytes& zen::firmware_entry::get_bytes() +{ + return _bytes; +} + + +std::string zen::firmware_entry::get_name() const +{ + char name[5]; + *(dword*)name = shared::swap(_header.tag); + name[4] = '\0'; + + // Determine if all characters in the tag are printable. + bool isprintable = true; + for (int i = 0; i < 4; i++) + { + if (!isprint((byte)name[i])) + { + isprintable = false; + break; + } + } + + // If they are, simply return the tag as a string. + if (isprintable) + { + return std::string(name); + } + + // Otherwise, encode the tag into a hexadecimal string. + char buffer[11]; + sprintf(buffer, "0x%08x", _header.tag); + return std::string(buffer); +} + +std::string zen::firmware_entry::get_content_name() const +{ + std::string name = get_name(); + if (name == "DATA") + { + name = ""; + int nameoff = is_big_endian() ? 1 : 0; + for (int i = 0; i < 16; i++) + { + char c = get_bytes()[i * 2 + nameoff]; + if (!c) + break; + name += c; + } + } + else if (name == "EXT0") + { + name = ""; + int nameoff = is_big_endian() ? 1 : 0; + for (int i = 0; i < 12; i++) + { + char c = get_bytes()[i * 2 + nameoff]; + if (!c) + break; + name += c; + } + } + return name; +} + +size_t zen::firmware_entry::get_content_offset() const +{ + std::string name = get_name(); + if (name == "DATA") + { + return 32; + } + else if (name == "EXT0") + { + return 24; + } + return 0; +} + +size_t zen::firmware_entry::calc_size() const +{ + return _bytes.size() + sizeof(firmware_header_t); +} + + +void zen::firmware_entry::assign(const firmware_entry& copy) +{ + _big_endian = copy._big_endian; + _header.tag = copy._header.tag; + _header.size = copy._header.size; + _bytes.assign(copy._bytes.begin(), copy._bytes.end()); +} + + + +zen::firmware_archive::firmware_archive(bool big_endian) + : _big_endian(big_endian) +{ +} + +zen::firmware_archive::firmware_archive(const firmware_archive& copy) +{ + assign(copy); +} + +zen::firmware_archive& zen::firmware_archive::operator=(const firmware_archive& right) +{ + assign(right); + return *this; +} + + +bool zen::firmware_archive::read(std::istream& is) +{ + // Read the root entry's header. + firmware_header_t root; + is.read((char*)&root, sizeof(firmware_header_t)); + if (!is.good()) + return false; + + if ((root.tag != 'CIFF') && (root.tag != 'FFIC')) + { + throw std::runtime_error("Invalid firmware archive format!"); + } + + _big_endian = root.tag == 'FFIC' ? true : false; + if (_big_endian) + { + root.tag = shared::swap(root.tag); + root.size = shared::swap(root.size); + } + + // Save the current stream position. + std::istream::pos_type endpos = is.tellg(); + std::istream::pos_type curpos = endpos; + endpos += std::istream::pos_type(root.size); + + // Read untill the end of the root entry contents. + while (curpos < endpos) + { + firmware_entry entry(_big_endian); + if (!entry.read(is)) + return false; + + _children.push_back(entry); + curpos = is.tellg(); + } + + curpos = is.tellg(); + is.seekg(0, std::ios::end); + endpos = is.tellg(); + is.seekg(curpos); + + // Read untill the end of the file. + while (((size_t)curpos + sizeof(firmware_header_t)) < endpos) + { + firmware_entry entry(_big_endian); + if (!entry.read(is)) + return false; + + _neighbours.push_back(entry); + curpos = is.tellg(); + } + + return true; +} + +bool zen::firmware_archive::write(std::ostream& os) const +{ + // Read the root entry's header. + firmware_header_t root = {'CIFF', 0}; + + // Calculate the total size of all the children entries. + for (firmware_entries::const_iterator i = _children.begin(); + i != _children.end(); ++i) + { + root.size += i->calc_size(); + } + + // If the firmware is big-endian, swap the header values back into big-endian. + if (_big_endian) + { + root.tag = shared::swap(root.tag); + root.size = shared::swap(root.size); + } + + // Write the header. + os.write((const char*)&root, sizeof(firmware_header_t)); + if (!os.good()) + return false; + + // Write all the child entries. + for (firmware_entries::const_iterator i = _children.begin(); + i != _children.end(); ++i) + { + if (!i->write(os)) + return false; + } + + // Write all the neighbour entries. + for (firmware_entries::const_iterator i = _neighbours.begin(); + i != _neighbours.end(); ++i) + { + if (!i->write(os)) + return false; + } + + return true; +} + + +bool zen::firmware_archive::is_big_endian() const +{ + return _big_endian; +} + +const zen::firmware_entries& zen::firmware_archive::get_children() const +{ + return _children; +} +zen::firmware_entries& zen::firmware_archive::get_children() +{ + return _children; +} + +const zen::firmware_entries& zen::firmware_archive::get_neighbours() const +{ + return _neighbours; +} +zen::firmware_entries& zen::firmware_archive::get_neighbours() +{ + return _neighbours; +} + +bool zen::firmware_archive::is_signed() const +{ + for (firmware_entries::const_iterator i = _neighbours.begin(); + i != _neighbours.end(); i++) + { + if (i->get_name() == "NULL") + return true; + } + return false; +} + +size_t zen::firmware_archive::calc_size() const +{ + size_t size = sizeof(firmware_header_t); + + for (firmware_entries::const_iterator i = _children.begin(); + i != _children.end(); i++) + { + size += i->calc_size(); + } + + for (firmware_entries::const_iterator i = _neighbours.begin(); + i != _neighbours.end(); i++) + { + size += i->calc_size(); + } + + return size; +} + + +void zen::firmware_archive::assign(const firmware_archive& copy) +{ + _big_endian = copy._big_endian; + _children.assign(copy._children.begin(), copy._children.end()); + _neighbours.assign(copy._neighbours.begin(), copy._neighbours.end()); +} diff --git a/utils/zenutils/source/shared/firmware.h b/utils/zenutils/source/shared/firmware.h new file mode 100755 index 0000000000..3542186590 --- /dev/null +++ b/utils/zenutils/source/shared/firmware.h @@ -0,0 +1,92 @@ +/* zenutils - Utilities for working with creative firmwares. + * Copyright 2007 (c) Rasmus Ry + * + * This program 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 2 of the License, or + * (at your option) any later version. + * + * This program 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef ZEN_FIRMWARE_H_INCLUDED +#define ZEN_FIRMWARE_H_INCLUDED + +#include +#include + +namespace zen { + struct firmware_header_t + { + dword tag; + dword size; + }; //struct firmware_header_t + + class firmware_entry + { + public: + firmware_entry(bool big_endian); + firmware_entry(const firmware_entry& copy); + firmware_entry& operator=(const firmware_entry& right); + + bool read(std::istream& is); + bool write(std::ostream& os) const; + + bool is_big_endian() const; + const firmware_header_t& get_header() const; + firmware_header_t& get_header(); + const shared::bytes& get_bytes() const; + shared::bytes& get_bytes(); + + std::string get_name() const; + std::string get_content_name() const; + size_t get_content_offset() const; + size_t calc_size() const; + + protected: + void assign(const firmware_entry& copy); + + private: + bool _big_endian; + firmware_header_t _header; + shared::bytes _bytes; + }; //class firmware_entry + + typedef std::list firmware_entries; + + class firmware_archive + { + public: + firmware_archive(bool big_endian); + firmware_archive(const firmware_archive& copy); + firmware_archive& operator=(const firmware_archive& right); + + bool read(std::istream& is); + bool write(std::ostream& os) const; + + bool is_big_endian() const; + const firmware_entries& get_children() const; + firmware_entries& get_children(); + const firmware_entries& get_neighbours() const; + firmware_entries& get_neighbours(); + bool is_signed() const; + size_t calc_size() const; + + protected: + void assign(const firmware_archive& copy); + + private: + firmware_entries _children; + firmware_entries _neighbours; + bool _big_endian; + }; //class firmware_archive +}; //namespace zen + +#endif //ZEN_FIRMWARE_ARCHIVE_H_INCLUDED diff --git a/utils/zenutils/source/shared/pe.cpp b/utils/zenutils/source/shared/pe.cpp new file mode 100755 index 0000000000..c86ec6c8cc --- /dev/null +++ b/utils/zenutils/source/shared/pe.cpp @@ -0,0 +1,128 @@ +/* zenutils - Utilities for working with creative firmwares. + * Copyright 2007 (c) Rasmus Ry + * + * This program 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 2 of the License, or + * (at your option) any later version. + * + * This program 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "pe.h" + + +shared::pe_file::pe_file(PeLib::PeFile* pef) : _pef(pef) +{ +} +shared::pe_file::~pe_file() +{ + if (_pef != NULL) + delete _pef; +} + +bool shared::pe_file::is_valid() const +{ + if (_pef->getBits() == 32) + { + PeLib::PeHeader32& pef32 = static_cast(_pef)->peHeader(); + if (!pef32.isValid()) + return false; + return true; + } + else if (_pef->getBits() == 64) + { + PeLib::PeHeader64& pef64 = static_cast(_pef)->peHeader(); + if (!pef64.isValid()) + return false; + return true; + } + return false; +} + +bool shared::pe_file::read(const std::string& filename) +{ + if (_pef != NULL) + { + delete _pef; + _pef = NULL; + } + + _pef = PeLib::openPeFile(filename); + if (!_pef) + { + return false; + } + if (_pef->readMzHeader()) + { + delete _pef; + return false; + } + if (!_pef->mzHeader().isValid()) + { + delete _pef; + return false; + } + if (_pef->readPeHeader()) + { + delete _pef; + return false; + } + if (!is_valid()) + { + delete _pef; + return false; + } + return true; +} + +bool shared::pe_file::find_section(const std::string& name, section_info& info) const +{ + if (_pef->getBits() == 32) + return find_section(static_cast(_pef), + name, info); + else if (_pef->getBits() == 64) + return find_section(static_cast(_pef), + name, info); + return false; +} + +bool shared::pe_file::add_section(const std::string& name, + const bytes& buffer, section_info& info) +{ + if (_pef->getBits() == 32) + { + return add_section(static_cast(_pef), + name, buffer, info); + } + else if (_pef->getBits() == 64) + { + return add_section(static_cast(_pef), + name, buffer, info); + } + return false; +} + +dword shared::pe_file::get_image_base() const +{ + if (_pef->getBits() == 32) + return static_cast(_pef)->peHeader().getImageBase(); + else + return static_cast(_pef)->peHeader().getImageBase(); + return 0; +} +dword shared::pe_file::pa_to_va(dword pa) const +{ + if (_pef->getBits() == 32) + return static_cast(_pef)->peHeader().offsetToVa(pa); + else + return static_cast(_pef)->peHeader().offsetToVa(pa); + return 0; +} diff --git a/utils/zenutils/source/shared/pe.h b/utils/zenutils/source/shared/pe.h new file mode 100755 index 0000000000..92a272d3c7 --- /dev/null +++ b/utils/zenutils/source/shared/pe.h @@ -0,0 +1,142 @@ +/* zenutils - Utilities for working with creative firmwares. + * Copyright 2007 (c) Rasmus Ry + * + * This program 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 2 of the License, or + * (at your option) any later version. + * + * This program 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef SHARED_PE_H_INCLUDED +#define SHARED_PE_H_INCLUDED + +#include +#include +#include + +namespace shared { + struct section_info + { + word index; + dword virtual_address; + dword virtual_size; + dword raw_address; + dword raw_size; + dword characteristics; + }; //struct section_info + + class pe_file + { + public: + pe_file(PeLib::PeFile* pef = NULL); + ~pe_file(); + + bool is_valid() const; + bool read(const std::string& filename); + bool find_section(const std::string& name, section_info& info) const; + bool add_section(const std::string& name, const bytes& buffer, section_info& info); + dword get_image_base() const; + dword pa_to_va(PeLib::dword pa) const; + + protected: + template + static bool find_section(const PeLib::PeFileT<_Bits>* pef, + const std::string& name, section_info& info); + template + static bool add_section(PeLib::PeFileT<_Bits>* pef, + const std::string& name, const bytes& buffer, + section_info& info); + + private: + PeLib::PeFile* _pef; + }; //class pe_file + + + template + bool pe_file::find_section(const PeLib::PeFileT<_Bits>* pef, + const std::string& name, section_info& info) + { + for (PeLib::word i = 0; i < pef->peHeader().getNumberOfSections(); i++) + { + if (pef->peHeader().getSectionName(i) == name) + { + info.index = i; + info.virtual_address = pef->peHeader().getVirtualAddress(i); + info.virtual_size = pef->peHeader().getVirtualSize(i); + info.raw_address = pef->peHeader().getPointerToRawData(i); + info.raw_size = pef->peHeader().getSizeOfRawData(i); + info.characteristics = pef->peHeader().getCharacteristics(i); + return true; + } + } + return false; + } + + template + bool pe_file::add_section(PeLib::PeFileT<_Bits>* pef, + const std::string& name, const bytes& buffer, + section_info& info) + { + using namespace PeLib; + + // Check if the last section has the same name as the one being added. + PeLib::word secnum = pef->peHeader().getNumberOfSections(); + if (pef->peHeader().getSectionName(secnum-1) == name) + { + // If it is, we change the attributes of the existing section. + secnum = secnum - 1; + pef->peHeader().setSizeOfRawData(secnum, + alignOffset(buffer.size(), + pef->peHeader().getFileAlignment())); + pef->peHeader().setVirtualSize(secnum, + alignOffset(buffer.size(), + pef->peHeader().getSectionAlignment())); + PeLib::dword chars = pef->peHeader().getCharacteristics(secnum-1); + pef->peHeader().setCharacteristics(secnum, + chars | PELIB_IMAGE_SCN_MEM_WRITE | PELIB_IMAGE_SCN_MEM_READ); + } + else + { + // Otherwise we add a new section. + if (pef->peHeader().addSection(name, buffer.size()) != NO_ERROR) + { + return false; + } + pef->peHeader().makeValid(pef->mzHeader().getAddressOfPeHeader()); + pef->peHeader().write(pef->getFileName(), pef->mzHeader().getAddressOfPeHeader()); + } + + // Save the section headers to the file. + if (pef->peHeader().writeSections(pef->getFileName()) != NO_ERROR) + { + return false; + } + + // Save the section data to the file. + if (pef->peHeader().writeSectionData(pef->getFileName(), secnum, buffer) != NO_ERROR) + { + return false; + } + + // Fill out the section information. + info.index = secnum; + info.virtual_address = pef->peHeader().getVirtualAddress(secnum); + info.virtual_size = pef->peHeader().getVirtualSize(secnum); + info.raw_address = pef->peHeader().getPointerToRawData(secnum); + info.raw_size = pef->peHeader().getSizeOfRawData(secnum); + info.characteristics = pef->peHeader().getCharacteristics(secnum); + + return true; + } +}; //namespace shared + +#endif //SHARED_PE_H_INCLUDED diff --git a/utils/zenutils/source/shared/shared.cpp b/utils/zenutils/source/shared/shared.cpp new file mode 100755 index 0000000000..e69de29bb2 diff --git a/utils/zenutils/source/shared/updater.cpp b/utils/zenutils/source/shared/updater.cpp new file mode 100755 index 0000000000..77d3f2876c --- /dev/null +++ b/utils/zenutils/source/shared/updater.cpp @@ -0,0 +1,151 @@ +/* zenutils - Utilities for working with creative firmwares. + * Copyright 2007 (c) Rasmus Ry + * + * This program 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 2 of the License, or + * (at your option) any later version. + * + * This program 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "updater.h" +#include +#include +#include + + +const char* zen::find_firmware_key(const byte* buffer, size_t len) +{ + char szkey1[] = "34d1"; + size_t cchkey1 = strlen(szkey1); + char szkey2[] = "TbnCboEbn"; + size_t cchkey2 = strlen(szkey2); + for (int i = 0; i < static_cast(len); i++) + { + if (len >= cchkey1) + { + if (!strncmp((char*)&buffer[i], szkey1, cchkey1)) + { + return (const char*)&buffer[i]; + } + } + if (len >= cchkey2) + { + if (!strncmp((char*)&buffer[i], szkey2, cchkey2)) + { + return (const char*)&buffer[i]; + } + } + } + return NULL; +} + +dword zen::find_firmware_offset(byte* buffer, size_t len) +{ + for (dword i = 0; i < static_cast(len); i += 0x10) + { + dword size = *(dword*)&buffer[i]; + if (size < (i + len) && size > (len >> 1)) + { + if (buffer[i + sizeof(dword)] != 0 + && buffer[i + sizeof(dword) + 1] != 0 + && buffer[i + sizeof(dword) + 2] != 0 + && buffer[i + sizeof(dword) + 3] != 0) + { + return i; + } + } + } + return 0; +} + +bool zen::find_firmware_archive(const std::string& filename, dword& va, dword& pa) +{ + shared::pe_file pef; + if (!pef.read(filename)) + { + return false; + } + shared::section_info data_section; + if (!pef.find_section(".data", data_section)) + { + return false; + } + shared::bytes buffer; + if (!shared::read_file(filename, buffer, data_section.raw_address, + data_section.raw_size)) + { + return false; + } + dword offset = find_firmware_offset(&buffer[0], buffer.size()); + if (!offset) + { + return false; + } + va = data_section.virtual_address + offset; + pa = data_section.raw_address + offset; + + return true; +} + + +bool zen::crypt_firmware(const char* key, byte* buffer, size_t len) +{ + // Determine if the key length is dword aligned. + int keylen = strlen(key); + int keylen_rem = keylen % sizeof(dword); + + // Determine how many times the key must be repeated to be dword aligned. + int keycycle = keylen_rem ? (sizeof(dword) / keylen_rem) : 1; + int keyscount = (keylen * keycycle) / sizeof(dword); + + // Allocate a buffer to hold the key as an array of dwords. + dword* keys = new dword[keyscount]; + + // Copy the key into the key array, whilst mutating it. + for (int i = 0; i < keyscount; i++) + { + dword val; + int keyoffset = (i * sizeof(dword)) % keylen; + if ((keyoffset+sizeof(dword)) < keylen) + { + val = *(dword*)&key[keyoffset]; + } + else + { + val = key[keyoffset] + | (key[(keyoffset + 1) % keylen] << 8) + | (key[(keyoffset + 2) % keylen] << 16) + | (key[(keyoffset + 3) % keylen] << 24); + } + keys[i] = (val - 0x01010101) | 0x80808080; + } + + // Determine the number of dwords in the buffer. + int len_div = len / sizeof(dword); + + // Decrypt all dwords of the buffer. + for (int i = 0; i < len_div; i++) + { + ((dword*)buffer)[i] ^= keys[i % keyscount]; + } + + // Determine the remaining number of bytes in the buffer. + int len_rem = len % sizeof(dword); + + // Decrypt the remaining number of bytes in the buffer. + for (int i = len_div * sizeof(dword); i < len; i++) + { + buffer[i] ^= ((key[i % keylen] - 0x01) | 0x80); + } + + return true; +} diff --git a/utils/zenutils/source/shared/updater.h b/utils/zenutils/source/shared/updater.h new file mode 100755 index 0000000000..57f9979c30 --- /dev/null +++ b/utils/zenutils/source/shared/updater.h @@ -0,0 +1,32 @@ +/* zenutils - Utilities for working with creative firmwares. + * Copyright 2007 (c) Rasmus Ry + * + * This program 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 2 of the License, or + * (at your option) any later version. + * + * This program 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef ZEN_UPDATER_H_INCLUDED +#define ZEN_UPDATER_H_INCLUDED + +#include +#include + +namespace zen { + const char* find_firmware_key(const byte* buffer, size_t len); + dword find_firmware_offset(byte* buffer, size_t len); + bool find_firmware_archive(const std::string& filename, dword& va, dword& pa); + bool crypt_firmware(const char* key, byte* buffer, size_t len); +}; //namespace zen + +#endif //ZEN_UPDATER_H_INCLUDED diff --git a/utils/zenutils/source/shared/utils.cpp b/utils/zenutils/source/shared/utils.cpp new file mode 100755 index 0000000000..8f45de5d3f --- /dev/null +++ b/utils/zenutils/source/shared/utils.cpp @@ -0,0 +1,211 @@ +/* zenutils - Utilities for working with creative firmwares. + * Copyright 2007 (c) Rasmus Ry + * + * This program 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 2 of the License, or + * (at your option) any later version. + * + * This program 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "utils.h" +#include +#include + + +std::string shared::replace_extension(const std::string& filename, const std::string& extension) +{ + std::string newname; + const char* name = filename.c_str(); + const char* ext = strrchr(name, '.'); + if (ext) + { + // If an extension was found, replace it. + newname.assign(name, ext-name); + newname += extension; + } + else + { + // If an extension was not found, append it. + newname = name; + newname += extension; + } + return newname; +} + +std::string shared::remove_extension(const std::string& filename) +{ + std::string newname; + const char* name = filename.c_str(); + const char* ext = strrchr(name, '.'); + if (ext) + { + newname.assign(name, ext-name); + } + else + { + newname = name; + } + return newname; +} + +std::string shared::double_quote(const std::string& str) +{ + std::string out; + for (int i = 0, j = str.length(); i < j; i++) + { + if (str[i] == '\\') + out += "\\\\"; + else + out += str[i]; + } + return out; +} + +bool shared::inflate_to_file(const bytes& buffer, const char* filename) +{ + // Open output file. + std::ofstream ofs; + ofs.open(filename, std::ios::binary); + if (!ofs) + { + return false; + } + + // Initialize zlib. + z_stream d_stream; // decompression stream + + d_stream.zalloc = Z_NULL; + d_stream.zfree = Z_NULL; + d_stream.opaque = Z_NULL; + + d_stream.next_in = const_cast(&buffer[0]); + d_stream.avail_in = static_cast(buffer.size()); + + int ret = inflateInit(&d_stream); + if (ret != Z_OK) + return false; + + // Allocate buffer to hold the inflated data. + const size_t BUFSIZE = 1048576; + Bytef* infbuf = new Bytef[BUFSIZE]; + if (!infbuf) + return false; + + // Decompress untill the end of the input buffer. + uLong totalout = 0; + bool bLoop = true; + while (bLoop) + { + d_stream.next_out = infbuf; + d_stream.avail_out = BUFSIZE; + + ret = inflate(&d_stream, Z_NO_FLUSH); + if (ret == Z_STREAM_END) + { + bLoop = false; + } + else if (ret != Z_OK) + { + inflateEnd(&d_stream); + delete [] infbuf; + return false; + } + + // Write the inflated data to the output file. + if (!ofs.write((const char*)infbuf, d_stream.total_out-totalout)) + { + inflateEnd(&d_stream); + delete [] infbuf; + return false; + } + totalout = d_stream.total_out; + } + + // Cleanup and return. + inflateEnd(&d_stream); + delete [] infbuf; + + return true; +} + +bool shared::deflate_to_file(const bytes& buffer, const char* filename) +{ + // Open output file. + std::ofstream ofs; + ofs.open(filename, std::ios::binary); + if (!ofs) + { + return false; + } + + // Initialize zlib. + z_stream c_stream; // compression stream. + + c_stream.zalloc = Z_NULL; + c_stream.zfree = Z_NULL; + c_stream.opaque = Z_NULL; + + int ret = deflateInit(&c_stream, Z_BEST_COMPRESSION); + if (ret != Z_OK) + return false; + + // Allocate buffer to hold the deflated data. + const size_t BUFSIZE = 1048576; + Bytef* defbuf = new Bytef[BUFSIZE]; + if (!defbuf) + return false; + + c_stream.avail_in = static_cast(buffer.size()); + c_stream.next_in = const_cast(&buffer[0]); + + // Compress until end of the buffer. + uLong totalout = 0; + bool bLoop = true; + while (bLoop) + { + c_stream.avail_out = BUFSIZE; + c_stream.next_out = defbuf; + + ret = deflate(&c_stream, Z_NO_FLUSH); // no bad return value + if (ret == Z_STREAM_END) + { + bLoop = false; + } + else if (ret == Z_BUF_ERROR && !c_stream.avail_in) + { + ret = deflate(&c_stream, Z_FINISH); // no bad return value + bLoop = false; + } + else if (ret != Z_OK) + { + deflateEnd(&c_stream); + delete [] defbuf; + return false; + } + + // Write the inflated data to the output file. + if (!ofs.write((const char*)defbuf, c_stream.total_out-totalout)) + { + deflateEnd(&c_stream); + delete [] defbuf; + return false; + } + + totalout = c_stream.total_out; + } + + // Clean up and return. + deflateEnd(&c_stream); + delete [] defbuf; + + return true; +} diff --git a/utils/zenutils/source/shared/utils.h b/utils/zenutils/source/shared/utils.h new file mode 100755 index 0000000000..ca9e291514 --- /dev/null +++ b/utils/zenutils/source/shared/utils.h @@ -0,0 +1,68 @@ +/* zenutils - Utilities for working with creative firmwares. + * Copyright 2007 (c) Rasmus Ry + * + * This program 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 2 of the License, or + * (at your option) any later version. + * + * This program 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, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef SHARED_UTILS_H_INCLUDED +#define SHARED_UTILS_H_INCLUDED + +#include +#include + +#ifndef byte +typedef PeLib::byte byte; +#endif +#ifndef word +typedef PeLib::word word; +#endif +#ifndef dword +typedef PeLib::dword dword; +#endif + +namespace shared { + typedef std::vector bytes; + + inline dword swap(dword val) + { + return ((val & 0xFF) << 24) + | ((val & 0xFF00) << 8) + | ((val & 0xFF0000) >> 8) + | ((val & 0xFF000000) >> 24); + } + + template + inline void reverse(_Type* start, _Type* end) + { + while (start < end) + { + *start ^= *end; + *end ^= *start; + *start ^= *end; + start++; + end--; + } + } + + std::string replace_extension(const std::string& filename, const std::string& extension); + std::string remove_extension(const std::string& filename); + std::string get_path(const std::string& filename); + std::string double_quote(const std::string& str); + + bool inflate_to_file(const bytes& buffer, const char* filename); + bool deflate_to_file(const bytes& buffer, const char* filename); +}; //namespace shared + +#endif //SHARED_UTILS_H_INCLUDED -- cgit v1.2.3