Is this the firmware you got from there: http://gopro.com/update/HERO3_plusTobi@s, btw, that's what happens when I try to open the firmware of GoPro Hero3+ (Plus) BE
The firmware here https://yadi.sk/d/WmNOqyJ3epkz5
generator serial numbers sushestvuet?a link to the original firmware can be obtained?
Will have a look at itGentlemen, I regained my DOD GSE550 and have a working firmware.
It has a file strings.bin, that's what happened.
Green noted that changing, changing their places, changed from 00 to FFno result.
Why is it so what is the reason ??
Error in AFT132.jar?
Can take a look here firmware.
https://yadi.sk/d/sRXawNnheqT2j
Thank.
type
PAbGzHeader = ^TAbGzHeader;
TAbGzHeader = packed record { SizeOf(TGzHeader) = 10}
ID1 : Byte; { ID Byte, should always be $1F}
ID2 : Byte; { ID Byte, should always be $8B}
CompMethod : Byte; { compression method used}
{ 0..7 reserved, 8 = deflate, others undefined as of this writing (4/27/2001)}
Flags : Byte; { misc flags}
{ Bit 0: FTEXT compressed file contains text, can be used for}
{ cross platform line termination translation}
{ Bit 1: FCONTINUATION file is a continuation of a multi-part gzip file}
{ RFC 1952 says this is the header CRC16 flag, but gzip}
{ reserves it and won't extract the file if this is set}
{ header data includes part number after header record}
{ Bit 2: FEXTRA header data contains Extra Data, starts after part}
{ number (if any)}
{ Bit 3: FNAME header data contains FileName, null terminated}
{ string starting immediately after Extra Data (if any)}
{ RFC 1952 says this is ISO 8859-1 encoded, but gzip}
{ always uses the system encoding}
{ Bit 4: FCOMMENT header data contains Comment, null terminated string}
{ starting immediately after FileName (if any)}
{ Bit 5: FENCRYPTED file is encrypted using zip-1.9 encryption }
{ header data contains a 12-byte encryption header }
{ starting immediately after Comment. Documented in}
{ "algorithm.doc", but unsupported in gzip}
{ Bits 6..7 are undefined and reserved as of this writing (8/25/2009)}
ModTime : LongInt; { File Modification (Creation) time,}
{ UNIX cdate format}
XtraFlags : Byte; { additional flags}
{ XtraFlags = 2 -- Deflate compressor used maximum compression algorithm}
{ XtraFlags = 4 -- Deflate compressor used fastest algorithm}
OS : Byte; { Operating system that created file,}
{ see GZOsToStr routine for values}
end;
const
{ Header Signature Values}
AB_GZ_HDR_ID1 = $1F;
AB_GZ_HDR_ID2 = $8B;
{ Test bits for TGzHeader.Flags field }
AB_GZ_FLAG_FTEXT = $01;
AB_GZ_FLAG_FCONTINUATION = $02;
AB_GZ_FLAG_FEXTRA = $04;
AB_GZ_FLAG_FNAME = $08;
AB_GZ_FLAG_FCOMMENT = $10;
AB_GZ_FLAG_FENCRYPTED = $20;
AB_GZ_UNSUPPORTED_FLAGS = $E2;
{ GZip OS source flags }
AB_GZ_OS_ID_FAT = 0;
AB_GZ_OS_ID_Amiga = 1;
AB_GZ_OS_ID_VMS = 2;
AB_GZ_OS_ID_Unix = 3;
AB_GZ_OS_ID_VM_CMS = 4;
AB_GZ_OS_ID_AtariTOS = 5;
AB_GZ_OS_ID_HPFS = 6;
AB_GZ_OS_ID_Macintosh = 7;
AB_GZ_OS_ID_Z_System = 8;
AB_GZ_OS_ID_CP_M = 9;
AB_GZ_OS_ID_TOPS20 = 10;
AB_GZ_OS_ID_NTFS = 11;
AB_GZ_OS_ID_QDOS = 12;
AB_GZ_OS_ID_AcornRISCOS = 13;
AB_GZ_OS_ID_VFAT = 14;
AB_GZ_OS_ID_MVS = 15;
AB_GZ_OS_ID_BEOS = 16;
AB_GZ_OS_ID_TANDEM = 17;
AB_GZ_OS_ID_THEOS = 18;
AB_GZ_OS_ID_unknown = 255;
function VerifyHeader(const Header : TAbGzHeader) : Boolean;
begin
{ check id fields and if deflated (only handle deflate anyway)}
Result := (Header.ID1 = AB_GZ_HDR_ID1) and
(Header.ID2 = AB_GZ_HDR_ID2) and
(Header.CompMethod = 8 {deflate});
end;
Thank you I will wait.Will have a look at it
Thanks..But Java already has a built in library for GZIPHi.
Header gzip, sorry Delphi...
* Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
package java.util.zip;
import java.io.SequenceInputStream;
import java.io.ByteArrayInputStream;
import java.io.FilterInputStream;
import java.io.InputStream;
import java.io.IOException;
import java.io.EOFException;
/**
* This class implements a stream filter for reading compressed data in
* the GZIP file format.
*
* @see InflaterInputStream
* @author David Connelly
*
*/
public
class GZIPInputStream extends InflaterInputStream {
/**
* CRC-32 for uncompressed data.
*/
protected CRC32 crc = new CRC32();
/**
* Indicates end of input stream.
*/
protected boolean eos;
private boolean closed = false;
/**
* Check to make sure that this stream has not been closed
*/
private void ensureOpen() throws IOException {
if (closed) {
throw new IOException("Stream closed");
}
}
/**
* Creates a new input stream with the specified buffer size.
* @param in the input stream
* @param size the input buffer size
*
* @exception ZipException if a GZIP format error has occurred or the
* compression method used is unsupported
* @exception IOException if an I/O error has occurred
* @exception IllegalArgumentException if {@code size <= 0}
*/
public GZIPInputStream(InputStream in, int size) throws IOException {
super(in, new Inflater(true), size);
usesDefaultInflater = true;
readHeader(in);
}
/**
* Creates a new input stream with a default buffer size.
* @param in the input stream
*
* @exception ZipException if a GZIP format error has occurred or the
* compression method used is unsupported
* @exception IOException if an I/O error has occurred
*/
public GZIPInputStream(InputStream in) throws IOException {
this(in, 512);
}
/**
* Reads uncompressed data into an array of bytes. If <code>len</code> is not
* zero, the method will block until some input can be decompressed; otherwise,
* no bytes are read and <code>0</code> is returned.
* @param buf the buffer into which the data is read
* @param off the start offset in the destination array <code>b</code>
* @param len the maximum number of bytes read
* @return the actual number of bytes read, or -1 if the end of the
* compressed input stream is reached
*
* @exception NullPointerException If <code>buf</code> is <code>null</code>.
* @exception IndexOutOfBoundsException If <code>off</code> is negative,
* <code>len</code> is negative, or <code>len</code> is greater than
* <code>buf.length - off</code>
* @exception ZipException if the compressed input data is corrupt.
* @exception IOException if an I/O error has occurred.
*
*/
public int read(byte[] buf, int off, int len) throws IOException {
ensureOpen();
if (eos) {
return -1;
}
int n = super.read(buf, off, len);
if (n == -1) {
if (readTrailer())
eos = true;
else
return this.read(buf, off, len);
} else {
crc.update(buf, off, n);
}
return n;
}
/**
* Closes this input stream and releases any system resources associated
* with the stream.
* @exception IOException if an I/O error has occurred
*/
public void close() throws IOException {
if (!closed) {
super.close();
eos = true;
closed = true;
}
}
/**
* GZIP header magic number.
*/
public final static int GZIP_MAGIC = 0x8b1f;
/*
* File header flags.
*/
private final static int FTEXT = 1; // Extra text
private final static int FHCRC = 2; // Header CRC
private final static int FEXTRA = 4; // Extra field
private final static int FNAME = 8; // File name
private final static int FCOMMENT = 16; // File comment
/*
* Reads GZIP member header and returns the total byte number
* of this member header.
*/
private int readHeader(InputStream this_in) throws IOException {
CheckedInputStream in = new CheckedInputStream(this_in, crc);
crc.reset();
// Check header magic
if (readUShort(in) != GZIP_MAGIC) {
throw new ZipException("Not in GZIP format");
}
// Check compression method
if (readUByte(in) != 8) {
throw new ZipException("Unsupported compression method");
}
// Read flags
int flg = readUByte(in);
// Skip MTIME, XFL, and OS fields
skipBytes(in, 6);
int n = 2 + 2 + 6;
// Skip optional extra field
if ((flg & FEXTRA) == FEXTRA) {
int m = readUShort(in);
skipBytes(in, m);
n += m + 2;
}
// Skip optional file name
if ((flg & FNAME) == FNAME) {
do {
n++;
} while (readUByte(in) != 0);
}
// Skip optional file comment
if ((flg & FCOMMENT) == FCOMMENT) {
do {
n++;
} while (readUByte(in) != 0);
}
// Check optional header CRC
if ((flg & FHCRC) == FHCRC) {
int v = (int)crc.getValue() & 0xffff;
if (readUShort(in) != v) {
throw new ZipException("Corrupt GZIP header");
}
n += 2;
}
crc.reset();
return n;
}
/*
* Reads GZIP member trailer and returns true if the eos
* reached, false if there are more (concatenated gzip
* data set)
*/
private boolean readTrailer() throws IOException {
InputStream in = this.in;
int n = inf.getRemaining();
if (n > 0) {
in = new SequenceInputStream(
new ByteArrayInputStream(buf, len - n, n),
new FilterInputStream(in) {
public void close() throws IOException {}
});
}
// Uses left-to-right evaluation order
if ((readUInt(in) != crc.getValue()) ||
// rfc1952; ISIZE is the input size modulo 2^32
(readUInt(in) != (inf.getBytesWritten() & 0xffffffffL)))
throw new ZipException("Corrupt GZIP trailer");
// If there are more bytes available in "in" or
// the leftover in the "inf" is > 26 bytes:
// this.trailer(8) + next.header.min(10) + next.trailer(8)
// try concatenated case
if (this.in.available() > 0 || n > 26) {
int m = 8; // this.trailer
try {
m += readHeader(in); // next.header
} catch (IOException ze) {
return true; // ignore any malformed, do nothing
}
inf.reset();
if (n > m)
inf.setInput(buf, len - n + m, n - m);
return false;
}
return true;
}
/*
* Reads unsigned integer in Intel byte order.
*/
private long readUInt(InputStream in) throws IOException {
long s = readUShort(in);
return ((long)readUShort(in) << 16) | s;
}
/*
* Reads unsigned short in Intel byte order.
*/
private int readUShort(InputStream in) throws IOException {
int b = readUByte(in);
return (readUByte(in) << 8) | b;
}
/*
* Reads unsigned byte.
*/
private int readUByte(InputStream in) throws IOException {
int b = in.read();
if (b == -1) {
throw new EOFException();
}
if (b < -1 || b > 255) {
// Report on this.in, not argument in; see read{Header, Trailer}.
throw new IOException(this.in.getClass().getName()
+ ".read() returned value out of range -1..255: " + b);
}
return b;
}
private byte[] tmpbuf = new byte[128];
/*
* Skips bytes of input data blocking until all bytes are skipped.
* Does not assume that the input stream is capable of seeking.
*/
private void skipBytes(InputStream in, int n) throws IOException {
while (n > 0) {
int len = in.read(tmpbuf, 0, n < tmpbuf.length ? n : tmpbuf.length);
if (len == -1) {
throw new EOFException();
}
n -= len;
}
}
}
Reporting . Today I tried to reassemble the firmware using that string.bin. Did everything according to instructions. Got a brick.
The firmware here: https://yadi.sk/d/cql1M-VEczt7N
TSecHeader = record // = 0x100
Crc32: DWORD; // crc32
Version: DWORD; // version
DateSec: DWORD; // date
LengthSec: DWORD; // length
MemAdress: DWORD; // memory adress
FlagSection: DWORD; // flag
MagicConst: DWORD; // CNS_MAGIC_CONSTANT = $A324EB90
ZeroBytes: array [1..57] of DWORD; // alignment bytes
end;
TSecHeader = record // = 0x100
Crc32: DWORD; // crc32
Version: DWORD; // version
DateSec: DWORD; // date
LengthSec: DWORD; // length
MemAdress: DWORD; // memory adress
FlagSection: DWORD; // flag
MagicConst: DWORD; // CNS_MAGIC_CONSTANT = $A324EB90
UnknownFlag: DWORD: // ..................????? = $00000001
ZeroBytes: array [1..56] of DWORD; // alignment bytes
end;
T0 plotter
Your unpacked section rom.
30 minutes of operation.
https://yadi.sk/d/vwvQ0yb0evMAK
Если это еще для Вас интересно ...
Good Luck.
I checked it, the difference is due to different strings.bin generation algorithms. Should work anyways.Thank you I will wait.
Does not want to.Should work anyways.