public void Extract(ref Dictionary <string, FileStream> streamCache, string destinationFolder, bool extractAsRaw) { string destinationFile = Path.Combine(Path.Combine(destinationFolder, this.ParentDirectoryName), this.FileName); byte[] magicBytes; if (!streamCache.ContainsKey(this.SourceFilePath)) { streamCache[this.SourceFilePath] = File.OpenRead(this.SourceFilePath); } // check for CRILAYLA signature since file size is not always reliable, // this will be a little slower, but hopefully the stream caching will minimize // the impact magicBytes = ParseFile.ParseSimpleOffset(streamCache[this.SourceFilePath], (long)this.Offset, CriCpkArchive.CRILAYLA_SIGNATURE.Length); if (ParseFile.CompareSegment(magicBytes, 0, CriCpkArchive.CRILAYLA_SIGNATURE)) { CriCpkArchive.Uncompress(streamCache[this.SourceFilePath], (long)this.Offset, this.Size, destinationFile); } else { ParseFile.ExtractChunkToFile64(streamCache[this.SourceFilePath], (ulong)this.Offset, (ulong)this.Size, destinationFile, false, false); } }
private void ValidateIvfcContainer(FileStream fs, long offset) // thanks to neimod's ctrtool { StringBuilder hashFailures = new StringBuilder(); ulong blockCount; byte[] blockToHash; byte[] calculatedHash; byte[] testHash; HashAlgorithm cryptoHash = SHA256.Create(); uint badHashCount = 0, goodHashCount = 0; // only check level 1 and 2 hash on load, level 3 takes too long and can be performed on extraction for (ulong i = 0; i < 3; i++) { // verify hash block to data size blockCount = this.IvfcLevels[i].DataSize / this.IvfcLevels[i].HashBlockSize; if ((blockCount * this.IvfcLevels[i].HashBlockSize) != this.IvfcLevels[i].DataSize) { throw new Exception("Error, IVFC block mismatch."); } // calculate hash and compare for (ulong j = 0; j < blockCount; j++) { testHash = ParseFile.ParseSimpleOffset(fs, offset + (long)this.IvfcLevels[i].HashOffset + (long)(0x20 * j), 0x20); blockToHash = ParseFile.ParseSimpleOffset(fs, offset + (long)this.IvfcLevels[i].DataOffset + ((long)this.IvfcLevels[i].HashBlockSize * (long)j), (int)this.IvfcLevels[i].HashBlockSize); calculatedHash = cryptoHash.ComputeHash(blockToHash); if (!ParseFile.CompareSegment(calculatedHash, 0, testHash)) { badHashCount++; } else { goodHashCount++; } } if (badHashCount > 0) { hashFailures.AppendFormat("IVFC hash failure(s) in Level {0}. Good Blocks: {1} Bad Blocks: {2}{3}", i + 1, goodHashCount.ToString(), badHashCount.ToString(), Environment.NewLine); } else { hashFailures.AppendFormat("No IVFC hash failures found in Level {0} check.{1}", i + 1, Environment.NewLine); } } // for (ulong i = 0;... // display warning about hash failures if (hashFailures.Length > 0) { //hashFailures.Insert(0, String.Format("Hash Failures when Validating .3DS file. This file is corrupted.{0}{0}", Environment.NewLine)); //MessageBox.Show(hashFailures.ToString(), "Warning: Hash Failures in .3DS file."); MessageBox.Show(hashFailures.ToString(), "Hash Validation Results"); } }
public static bool IsSonyAdpcmRow(Stream inputStream, long offset, ref Dictionary <long, bool> rowCheckHash) { bool ret = true; if (rowCheckHash.ContainsKey(offset)) { ret = rowCheckHash[offset]; } else { byte[] potentialAdpcm = new byte[SONY_ADPCM_ROW_SIZE]; int bytesRead; inputStream.Position = offset; bytesRead = inputStream.Read(potentialAdpcm, 0, SONY_ADPCM_ROW_SIZE); if ((bytesRead != SONY_ADPCM_ROW_SIZE) || (potentialAdpcm[1] > 7) || (potentialAdpcm[0] > 0x4C) || ((potentialAdpcm[0] == 0) && (potentialAdpcm[1] != 2) && (GetCountOfZeroBytes(potentialAdpcm) > 14)) || (ParseFile.CompareSegment(potentialAdpcm, 0, VB_START_BYTES)) ) { ret = false; } // update hash table rowCheckHash[offset] = ret; } return(ret); }
public static DateTime GetIsoDateTime(byte[] isoDateArray) { DateTime dateValue = new DateTime(); string dateString; if (ParseFile.CompareSegment(isoDateArray, 0, EMPTY_DATETIME)) { dateValue = DateTime.MinValue; } // Easy CD Creator v4.2 (310), and maybe others, // doesn't set the Grenwich Mean Time offset to zero as it should else if (ParseFile.CompareSegmentUsingSourceOffset(isoDateArray, 0, EMPTY_DATETIME_HACK.Length, EMPTY_DATETIME_HACK)) { dateValue = DateTime.MinValue; } else { dateString = ByteConversion.GetAsciiText(isoDateArray); dateValue = new DateTime(Int32.Parse(dateString.Substring(0, 4).Replace("0000", "2000")), Int16.Parse(dateString.Substring(4, 2)), Int16.Parse(dateString.Substring(6, 2)), Int16.Parse(dateString.Substring(8, 2)), Int16.Parse(dateString.Substring(10, 2)), Int16.Parse(dateString.Substring(12, 2)), Int16.Parse(dateString.Substring(14, 2))); } return(dateValue); }
protected override string GetAudioFileExtension(Stream readStream, long currentOffset) { string fileExtension; byte[] checkBytes, checkBytesAc3; int headerSize = this.GetAudioPacketHeaderSize(readStream, currentOffset); checkBytes = ParseFile.ParseSimpleOffset(readStream, (currentOffset + 6 + headerSize), 4); if (ParseFile.CompareSegment(checkBytes, 0, AixSignatureBytes)) { fileExtension = AixAudioExtension; } else if (checkBytes[0] == 0x80) { fileExtension = AdxAudioExtension; } else { checkBytesAc3 = ParseFile.ParseSimpleOffset(readStream, (currentOffset + 6 + headerSize), 2); if (ParseFile.CompareSegment(checkBytesAc3, 0, Ac3SignatureBytes)) { fileExtension = Ac3AudioExtension; } else { fileExtension = ".bin"; } } return(fileExtension); }
protected bool IsThisAnAudioBlock(byte[] blockToCheck) { return(ParseFile.CompareSegment(blockToCheck, 0, ElectronicArtsVp6Stream.SCxx_BYTES) || ParseFile.CompareSegment(blockToCheck, 0, ElectronicArtsVp6Stream.SHEN_BYTES) || ParseFile.CompareSegment(blockToCheck, 0, ElectronicArtsVp6Stream.SCEN_BYTES) || ParseFile.CompareSegment(blockToCheck, 0, ElectronicArtsVp6Stream.SDEN_BYTES) || ParseFile.CompareSegment(blockToCheck, 0, ElectronicArtsVp6Stream.SEEN_BYTES)); }
private void parseBankChunk() { foreach (ChunkStruct c in chunks) { if (ParseFile.CompareSegment(c.chunkIdentifier, 0, BANK_SIGNATURE)) { this.bankSwitchInit = c.chunkData; } } }
private void parseDataChunk() { foreach (ChunkStruct c in chunks) { if (ParseFile.CompareSegment(c.chunkIdentifier, 0, DATA_SIGNATURE)) { this.data = c.chunkData; } } }
public static bool IsUtfTable(FileStream fs, long offset, bool useIncomingKeys = false, Dictionary <string, byte> incomingLcgEncryptionKeys = null) { bool ret = false; CriUtfTable utf = new CriUtfTable(); utf.SourceFile = fs.Name; utf.BaseOffset = offset; try { utf.MagicBytes = ParseFile.ParseSimpleOffset(fs, utf.BaseOffset, 4); // check if file is decrypted and get decryption keys if needed utf.checkEncryption(fs, useIncomingKeys, incomingLcgEncryptionKeys); if (utf.IsEncrypted) { // write (decrypted) utf header to file utf.UtfTableFile = utf.WriteTableToTempFile(fs, offset, 4); using (FileStream checkFs = File.Open(utf.UtfTableFile, FileMode.Open, FileAccess.Read, FileShare.Read)) { utf.MagicBytes = ParseFile.ParseSimpleOffset(checkFs, utf.BaseOffset, 4); } //utf.IsEncrypted = false; // since we've decrypted to a temp file // utf.UtfReader.IsEncrypted = false; } if (ParseFile.CompareSegment(utf.MagicBytes, 0, SIGNATURE_BYTES)) { ret = true; } else { ret = false; } } catch (Exception ex) { throw ex; } finally { if (!String.IsNullOrEmpty(utf.UtfTableFile)) { File.Delete(utf.UtfTableFile); } } return(ret); }
public void Initialize(Stream pStream, string pFilePath) { this.filePath = pFilePath; this.asciiSignature = this.getAsciiSignature(pStream); this.dummy26 = this.getDummy26(pStream); this.headerHasId666 = this.getHeaderHasId666(pStream); this.versionMinor = this.getVersionMinor(pStream); this.registerPc = this.getRegisterPc(pStream); this.registerA = this.getRegisterA(pStream); this.registerX = this.getRegisterX(pStream); this.registerY = this.getRegisterY(pStream); this.registerPSW = this.getRegisterPSW(pStream); this.registerSP = this.getRegisterSP(pStream); this.reserved = this.getReserved(pStream); // ID666 if (ParseFile.CompareSegment(this.headerHasId666, 0, ID666_IN_HEADER_VAL)) { this.id666 = this.getId666(pStream); this.id_songTitle = this.getIdSongTitle(this.id666); this.id_gameTitle = this.getIdGameTitle(this.id666); this.id_nameOfDumper = this.getIdNameOfDumper(this.id666); this.id_comments = this.getIdComments(this.id666); this.id_dumpDate = this.getIdDumpDate(this.id666); this.id_numSecondsToPlay = this.getIdNumSecondsToPlay(this.id666); this.id_lengthOfFade = this.getIdLengthOfFade(this.id666); this.id_songArtist = this.getIdSongArtist(this.id666); this.id_defaultChanDisab = this.getIdDefaultChanDisab(this.id666); this.id_emulatorUsed = this.getIdEmulatorUsed(this.id666); this.id_reserved = this.getIdReserved(this.id666); } this.ram64k = this.getRam64k(pStream); this.dspRegisters = this.getDspRegisters(pStream); this.unused = this.getUnused(pStream); this.extraRam = this.getExtraRam(pStream); this.extendedInfo = this.getExtendedInfo(pStream); this.initializeTagHash(); this.initializeExId666Hash(); // Extended ID666 if (this.extendedInfo.Length > 0 && ParseFile.CompareSegment(this.extendedInfo, 0, EXTENDED_ID666_SIGNATURE)) { exidHeaderChunkSize = this.getExidHeaderChunkSize(this.extendedInfo); if (BitConverter.ToInt32(exidHeaderChunkSize, 0) > 0) { exidFullChunk = ParseFile.ParseSimpleOffset(this.extendedInfo, EX_ID666_CHUNK_DATA_OFFSET, BitConverter.ToInt32(exidHeaderChunkSize, 0)); } this.parseExtendedChunk(exidFullChunk); } }
public void Initialize(FileStream fs, long offset) { this.SourceFile = fs.Name; this.BaseOffset = offset; try { this.MagicBytes = ParseFile.ParseSimpleOffset(fs, this.BaseOffset, 4); // check if file is decrypted and get decryption keys if needed this.checkEncryption(fs); // write (decrypted) utf header to file this.UtfTableFile = this.WriteTableToTempFile(fs, offset); this.IsEncrypted = false; // since we've decrypted to a temp file this.UtfReader.IsEncrypted = false; if (ParseFile.CompareSegment(this.MagicBytes, 0, SIGNATURE_BYTES)) { using (FileStream utfTableStream = File.Open(this.UtfTableFile, FileMode.Open, FileAccess.Read, FileShare.Read)) { // read header this.initializeUtfHeader(utfTableStream); // initialize rows this.Rows = new Dictionary <string, CriField> [this.NumberOfRows]; // read schema if (this.TableSize > 0) { this.initializeUtfSchema(fs, utfTableStream, 0x20); } } } else { //Dictionary<string, byte> foo = GetKeysForEncryptedUtfTable(this.MagicBytes); throw new FormatException(String.Format("@UTF signature not found at offset <0x{0}>.", offset.ToString("X8"))); } } catch (Exception ex) { throw ex; } finally { if (!String.IsNullOrEmpty(this.UtfTableFile)) { File.Delete(this.UtfTableFile); } } }
public static bool IsCriAfs2Archive(FileStream fs, long offset) { var ret = false; var checkBytes = ParseFile.ParseSimpleOffset(fs, offset, SIGNATURE.Length); if (ParseFile.CompareSegment(checkBytes, 0, SIGNATURE)) { ret = true; } return(ret); }
} // for use by ACB extraction public static bool IsCriCpkArchive(FileStream fs, long offset) { var ret = false; var checkBytes = ParseFile.ParseSimpleOffset(fs, offset, STANDARD_IDENTIFIER.Length); if (ParseFile.CompareSegment(checkBytes, 0, STANDARD_IDENTIFIER)) { ret = true; } return(ret); }
protected override void DoTaskForFile(string pPath, IVgmtWorkerStruct pExtractStruct, DoWorkEventArgs e) { ExtractCriAcbAwbStruct extractStruct = (ExtractCriAcbAwbStruct)pExtractStruct; byte[] magicBytes; long awbOffset = 0; using (FileStream fs = File.Open(pPath, FileMode.Open, FileAccess.Read, FileShare.Read)) { magicBytes = ParseFile.ParseSimpleOffset(fs, 0, 4); this.progressStruct.Clear(); // ACB if (ParseFile.CompareSegment(magicBytes, 0, CriAcbFile.SIGNATURE_BYTES)) { this.progressStruct.GenericMessage = String.Format("Processing ACB file: '{0}'.{1}", Path.GetFileName(pPath), Environment.NewLine); ReportProgress(Constants.ProgressMessageOnly, this.progressStruct); CriAcbFile acb = new CriAcbFile(fs, 0, extractStruct.IncludeCueIdInFileName); acb.ExtractAll(); } else if (ParseFile.CompareSegment(magicBytes, 0, CriAfs2Archive.SIGNATURE)) { this.progressStruct.GenericMessage = String.Format("Processing AWB file: '{0}'.{1}", Path.GetFileName(pPath), Environment.NewLine); ReportProgress(Constants.ProgressMessageOnly, this.progressStruct); CriAfs2Archive afs2 = new CriAfs2Archive(fs, 0); afs2.ExtractAll(); } else { this.progressStruct.GenericMessage = String.Format("ACB/AWB signature not found at offset 0...scanning for AWB signature: '{0}'.{1}", Path.GetFileName(pPath), Environment.NewLine); ReportProgress(Constants.ProgressMessageOnly, this.progressStruct); awbOffset = ParseFile.GetNextOffset(fs, 0, CriAfs2Archive.SIGNATURE); if (awbOffset > 0) { CriAfs2Archive afs2 = new CriAfs2Archive(fs, awbOffset); afs2.ExtractAll(); } else { this.progressStruct.GenericMessage = String.Format("File is not an ACB or AWB...skipping: '{0}'.{1}", Path.GetFileName(pPath), Environment.NewLine); ReportProgress(Constants.ProgressMessageOnly, this.progressStruct); } } } }
private void parsePlaylistChunk() { foreach (ChunkStruct c in chunks) { if (ParseFile.CompareSegment(c.chunkIdentifier, 0, PLST_SIGNATURE)) { for (int i = 0; i < c.chunkData.Length; i++) { this.playlist += c.chunkData[i].ToString() + ", "; } this.playlist = this.playlist.Substring(0, this.playlist.Length - 2); } } }
private void parseAuthChunk() { foreach (ChunkStruct c in chunks) { if (ParseFile.CompareSegment(c.chunkIdentifier, 0, AUTH_SIGNATURE)) { System.Text.Encoding enc = System.Text.Encoding.ASCII; byte[] authBlock; int offset = 0; int labelLength; if (offset < c.chunkData.Length) { labelLength = ParseFile.GetSegmentLength(c.chunkData, offset, NULL_TERMINATOR); authBlock = ParseFile.ParseSimpleOffset(c.chunkData, offset, labelLength); songName = enc.GetString(authBlock); songNameBytes = authBlock; offset += labelLength + 1; } if (offset < c.chunkData.Length) { labelLength = ParseFile.GetSegmentLength(c.chunkData, offset, NULL_TERMINATOR); authBlock = ParseFile.ParseSimpleOffset(c.chunkData, offset, labelLength); songArtist = enc.GetString(authBlock); songArtistBytes = authBlock; offset += labelLength + 1; } if (offset < c.chunkData.Length) { labelLength = ParseFile.GetSegmentLength(c.chunkData, offset, NULL_TERMINATOR); authBlock = ParseFile.ParseSimpleOffset(c.chunkData, offset, labelLength); songCopyright = enc.GetString(authBlock); songCopyrightBytes = authBlock; offset += labelLength + 1; } if (offset < c.chunkData.Length) { labelLength = ParseFile.GetSegmentLength(c.chunkData, offset, NULL_TERMINATOR); authBlock = ParseFile.ParseSimpleOffset(c.chunkData, offset, labelLength); nsfRipper = enc.GetString(authBlock); nsfRipperBytes = authBlock; offset += labelLength + 1; } } } }
private void parseInfoChunk() { foreach (ChunkStruct c in chunks) { if (ParseFile.CompareSegment(c.chunkIdentifier, 0, INFO_SIGNATURE)) { this.loadAddress = ParseFile.ParseSimpleOffset(c.chunkData, LOAD_ADDRESS_OFFSET, LOAD_ADDRESS_LENGTH); this.initAddress = ParseFile.ParseSimpleOffset(c.chunkData, INIT_ADDRESS_OFFSET, INIT_ADDRESS_LENGTH); this.playAddress = ParseFile.ParseSimpleOffset(c.chunkData, PLAY_ADDRESS_OFFSET, PLAY_ADDRESS_LENGTH); this.palNtscBits = ParseFile.ParseSimpleOffset(c.chunkData, PAL_NTSC_BITS_OFFSET, PAL_NTSC_BITS_LENGTH); this.extraChipsBits = ParseFile.ParseSimpleOffset(c.chunkData, EXTRA_SOUND_BITS_OFFSET, EXTRA_SOUND_BITS_LENGTH); this.totalSongs = ParseFile.ParseSimpleOffset(c.chunkData, TOTAL_SONGS_OFFSET, TOTAL_SONGS_LENGTH); this.startingSong = ParseFile.ParseSimpleOffset(c.chunkData, STARTING_SONG_OFFSET, STARTING_SONG_LENGTH); } } }
public static bool IsGzipFile(Stream pFileStream) { bool ret = false; long currentOffset = pFileStream.Position; byte[] signatureBytes = ParseFile.ParseSimpleOffset(pFileStream, HEADER_OFFSET, GZIP_SIGNATURE.Length); if (ParseFile.CompareSegment(signatureBytes, HEADER_OFFSET, GZIP_SIGNATURE)) { ret = true; } pFileStream.Position = currentOffset; return(ret); }
private void parseFadesChunk() { foreach (ChunkStruct c in chunks) { if (ParseFile.CompareSegment(c.chunkIdentifier, 0, FADE_SIGNATURE)) { this.fades = new Int32[c.chunkData.Length / 4]; int j = 0; for (int i = 0; i < c.chunkData.Length; i += 4) { byte[] tempTime = ParseFile.ParseSimpleOffset(c.chunkData, i, 4); this.fades[j] = BitConverter.ToInt32(tempTime, 0); j++; } } } }
/// <summary> /// Checks for WAD file Magic Bytes. /// </summary> /// <param name="sourceFile">Full path to file to check.</param> /// <returns>Boolean value indicating if input file has WAD magic bytes.</returns> public static bool IsWadFile(string sourceFile) { bool isWad = false; byte[] magicBytes = new byte[NintendoWad.STANDARD_IDENTIFIER.Length]; using (FileStream fs = File.OpenRead(sourceFile)) { magicBytes = ParseFile.ParseSimpleOffset(fs, NintendoWad.IDENTIFIER_OFFSET, NintendoWad.STANDARD_IDENTIFIER.Length); if (ParseFile.CompareSegment(magicBytes, 0, NintendoWad.STANDARD_IDENTIFIER)) { isWad = true; } } return(isWad); }
public static bool IsGzipFile(string pFilePath) { bool ret = false; byte[] signatureBytes = null; using (FileStream fs = File.OpenRead(pFilePath)) { signatureBytes = ParseFile.ParseSimpleOffset(fs, HEADER_OFFSET, GZIP_SIGNATURE.Length); } if ((signatureBytes != null) && (ParseFile.CompareSegment(signatureBytes, HEADER_OFFSET, GZIP_SIGNATURE))) { ret = true; } return(ret); }
public static bool IsSeqTypeSequence(string fileName) { bool ret = false; int numBytesRead; byte[] checkBytes = new byte[PsxSequence.ASCII_SIGNATURE_SEQ.Length]; using (FileStream fs = File.OpenRead(fileName)) { numBytesRead = fs.Read(checkBytes, 0, PsxSequence.ASCII_SIGNATURE_SEQ.Length); if (numBytesRead == PsxSequence.ASCII_SIGNATURE_SEQ.Length) { ret = ParseFile.CompareSegment(checkBytes, 0, PsxSequence.ASCII_SIGNATURE_SEQ); } } return(ret); }
public static bool IsSonyAdpcmRow(byte[] potentialAdpcm, bool doAdditionalChecks) { bool ret = true; if ((potentialAdpcm.Length != SONY_ADPCM_ROW_SIZE) || (potentialAdpcm[1] > 7) || (potentialAdpcm[0] > 0x4C) || (ParseFile.CompareSegment(potentialAdpcm, 0, VB_START_BYTES)) ) { ret = false; } else if (doAdditionalChecks && ((potentialAdpcm[0] == 0) && (potentialAdpcm[1] != 2) && (GetCountOfZeroBytes(potentialAdpcm) > 14))) { ret = false; } return(ret); }
protected override string GetVideoFileExtension(Stream readStream, long currentOffset) { string fileExtension; byte[] checkBytes; int videoHeaderSize = this.GetVideoPacketHeaderSize(readStream, currentOffset); checkBytes = ParseFile.ParseSimpleOffset(readStream, (currentOffset + videoHeaderSize + 6), 4); if (ParseFile.CompareSegment(checkBytes, 0, AvcBytes)) { fileExtension = AvcVideoExtension; } else { fileExtension = ".bin"; } return(fileExtension); }
public static MovieType GetMobiclipStreamType(string path) { MovieType streamType = MovieType.Unknown; using (FileStream fs = File.OpenRead(path)) { byte[] typeBytes = ParseFile.ParseSimpleOffset(fs, 2, 2); if (ParseFile.CompareSegment(typeBytes, 0, MobiclipNdsStream.StreamTypeBytes)) { streamType = MovieType.NintendoDs; } else if (ParseFile.CompareSegment(typeBytes, 0, MobiclipWiiStream.StreamTypeBytes)) { streamType = MovieType.Wii; } } return(streamType); }
private void parseTrackLabelsChunk() { foreach (ChunkStruct c in chunks) { if (ParseFile.CompareSegment(c.chunkIdentifier, 0, TRACK_LABELS_SIGNATURE)) { System.Text.Encoding enc = System.Text.Encoding.ASCII; int offset = 0; while (offset < c.chunkData.Length) { int labelLength = ParseFile.GetSegmentLength(c.chunkData, offset, NULL_TERMINATOR); byte[] trackLabel = ParseFile.ParseSimpleOffset(c.chunkData, offset, labelLength); this.trackLabels.Add(enc.GetString(trackLabel)); offset += labelLength + 1; } } } }
private void checkEncryption(FileStream fs, bool useIncomingKeys = false, Dictionary <string, byte> incomingLcgEncryptionKeys = null) { if (ParseFile.CompareSegment(MagicBytes, 0, SIGNATURE_BYTES) || useIncomingKeys && incomingLcgEncryptionKeys == null ) { IsEncrypted = false; UtfReader = new CriUtfReader(); } else { IsEncrypted = true; if (useIncomingKeys) // use incoming keys if available { if (incomingLcgEncryptionKeys != null) { LcgEncryptionKeys = incomingLcgEncryptionKeys; } } else if (LcgEncryptionKeys == null) // use keys found earlier, assume same keys for entire file { LcgEncryptionKeys = GetKeysForEncryptedUtfTable(MagicBytes); } if (LcgEncryptionKeys.Count != 2) { throw new FormatException(string.Format("Unable to decrypt UTF table at offset: 0x{0}", BaseOffset.ToString("X8"))); } else { UtfReader = new CriUtfReader(LcgEncryptionKeys[LCG_SEED_KEY], LcgEncryptionKeys[LCG_INCREMENT_KEY], IsEncrypted); } MagicBytes = UtfReader.GetBytes(fs, BaseOffset, 4, 0); } }
public static bool IsSonyAdpcmRow(Stream inputStream, long offset) { bool ret = true; byte[] potentialAdpcm = new byte[SONY_ADPCM_ROW_SIZE]; int bytesRead; inputStream.Position = offset; bytesRead = inputStream.Read(potentialAdpcm, 0, SONY_ADPCM_ROW_SIZE); if ((bytesRead != SONY_ADPCM_ROW_SIZE) || (potentialAdpcm[1] > 7) || (potentialAdpcm[0] > 0x4C) || ((potentialAdpcm[0] == 0) && (potentialAdpcm[1] != 2) && (GetCountOfZeroBytes(potentialAdpcm) > 14)) || (ParseFile.CompareSegment(potentialAdpcm, 0, VB_START_BYTES)) ) { ret = false; } return(ret); }
public void Extract(ref Dictionary <string, FileStream> streamCache, string destinationFolder, bool extractAsRaw) { string destinationFile = Path.Combine(Path.Combine(destinationFolder, this.ParentDirectoryName), this.FileName); if (!streamCache.ContainsKey(this.SourceFilePath)) { streamCache[this.SourceFilePath] = File.OpenRead(this.SourceFilePath); } //----------------------------------------------------------- // ExeFS //----------------------------------------------------------- if (this.FileSystem == Nintendo3dsCtr.FileSystemType.ExeFS) { // write file while calculating hash HashAlgorithm cryptoHash = SHA256.Create(); byte[] outputHash = ParseFile.ExtractChunkToFile64ReturningHash(streamCache[this.SourceFilePath], (ulong)this.Offset, (ulong)this.Size, destinationFile, cryptoHash, false, false); if (!ParseFile.CompareSegment(outputHash, 0, this.Sha256Hash)) { // @TODO: only show error once per file //if (!sha1ErrorDisplayed) { MessageBox.Show(String.Format("Warning: '{0},' failed SHA256 verification in ExeFS at offset 0x{1} during extraction.{2}", Path.GetFileName(destinationFile), this.Offset, Environment.NewLine), "Warning - SHA256 Failure"); } } } //--------------- // RomFS //--------------- else { // @TODO: Modify to verify on extraction ParseFile.ExtractChunkToFile64(streamCache[this.SourceFilePath], (ulong)this.Offset, (ulong)this.Size, destinationFile, false, false); } }
private void ReadHeader(FileStream thpStream, long currentOffset) { byte[] magicBytes = ParseFile.ParseSimpleOffset(thpStream, currentOffset, MAGIC_BYTES.Length); byte[] tempChunk; if (ParseFile.CompareSegment(magicBytes, 0, MAGIC_BYTES)) { tempChunk = ParseFile.ParseSimpleOffset(thpStream, currentOffset + 4, 4); if (ParseFile.CompareSegment(tempChunk, 0, VERSON_10)) { this.Version = ThpVersion.Version10; } else { this.Version = ThpVersion.Version11; } this.MaxBufferSize = ByteConversion.GetUInt32BigEndian(ParseFile.ParseSimpleOffset(thpStream, currentOffset + 8, 4)); this.MaxAudioSamples = ByteConversion.GetUInt32BigEndian(ParseFile.ParseSimpleOffset(thpStream, currentOffset + 0xC, 4)); this.ContainsAudio = (this.MaxAudioSamples > 0); // public float Fps { set; get; } this.NumberOfFrames = ByteConversion.GetUInt32BigEndian(ParseFile.ParseSimpleOffset(thpStream, currentOffset + 0x14, 4)); this.FirstFrameSize = ByteConversion.GetUInt32BigEndian(ParseFile.ParseSimpleOffset(thpStream, currentOffset + 0x18, 4)); this.DataSize = ByteConversion.GetUInt32BigEndian(ParseFile.ParseSimpleOffset(thpStream, currentOffset + 0x1C, 4)); this.ComponentDataOffset = ByteConversion.GetUInt32BigEndian(ParseFile.ParseSimpleOffset(thpStream, currentOffset + 0x20, 4)); this.ComponentTypes = ParseFile.ParseSimpleOffset(thpStream, currentOffset + 0x24, 16); this.FirstFrameOffset = ByteConversion.GetUInt32BigEndian(ParseFile.ParseSimpleOffset(thpStream, currentOffset + 0x28, 4)); this.LastFrameOffset = ByteConversion.GetUInt32BigEndian(ParseFile.ParseSimpleOffset(thpStream, currentOffset + 0x2C, 4)); } else { throw new FormatException("Magic bytes 'THP\\0' not found."); } }