private void CalculateHash(ByteData sourceData, long offset, int size) { if (this.m_sink.QueryStatus().IsFilled) { throw new InvalidOperationException(); } this.m_sink.PushData(sourceData, offset); }
public ByteData PullData(long offset, int size) { ByteData srcData = this.m_source.PullData(offset, size); long dstOffset = (long)this.HashSize * offset / (long)this.m_blockSize; this.CalculateAndStoreHash(srcData, dstOffset, this.m_hashLayerCount - 1); return(srcData); }
public ByteData PullData(long offset, int size) { ByteData byteData = this.m_source.PullData(offset, size); if (byteData.Buffer.Count % this.BlockSize != 0) { throw new InvalidOperationException(); } if (offset % (long)this.BlockSize != 0L) { throw new InvalidOperationException(); } if (byteData.Buffer.Count == 0) { return(new ByteData(new ArraySegment <byte>())); } byte[] numArray = new byte[byteData.Buffer.Count]; int num1 = 0; ArraySegment <byte> buffer; while (true) { int num2 = num1; buffer = byteData.Buffer; int count = buffer.Count; if (num2 < count) { IXtsModeEncryptor crypto = this.m_crypto; byte[] initialTweak = this.GetInitialTweak(offset + (long)num1); buffer = byteData.Buffer; byte[] array = buffer.Array; buffer = byteData.Buffer; int srcOffset = buffer.Offset + num1; int blockSize = this.BlockSize; byte[] dst = numArray; int dstOffset = num1; crypto.EncryptBlock(initialTweak, array, srcOffset, blockSize, dst, dstOffset); num1 += this.BlockSize; } else { break; } } byte[] array1 = numArray; int offset1 = 0; buffer = byteData.Buffer; int count1 = buffer.Count; return(new ByteData(new ArraySegment <byte>(array1, offset1, count1))); }
public int PushData(ByteData data, long offset) { int writableSize = SinkUtil.GetWritableSize(this.Size, offset, data.Buffer.Count); if (writableSize == 0) { return(0); } Buffer.BlockCopy((Array)data.Buffer.Array, data.Buffer.Offset, (Array)this.m_buffer, (int)offset, writableSize); this.m_status.FilledRangeList.MergingAdd(new Range(offset, (long)writableSize)); this.m_status.IsFilled = SinkUtil.CheckIsFilled(this.m_status.FilledRangeList, this.Size); return(writableSize); }
public int PushData(ByteData data, long offset) { int writableSize = SinkUtil.GetWritableSize(this.Size, offset, data.Buffer.Count); if (writableSize == 0) { return(0); } this.m_storage.Write(offset, data.Buffer.Array); this.m_storage.Commit(); this.m_status.FilledRangeList.MergingAdd(new Range(offset, (long)writableSize)); this.m_status.IsFilled = SinkUtil.CheckIsFilled(this.m_status.FilledRangeList, this.Size); return(writableSize); }
public int PushData(ByteData data, long offset) { int count = data.Buffer.Count; if (offset + (long)count > this.Size) { int num = (int)(this.Size - offset); count = num > 0 ? num : 0; } int num1 = this.m_sink.PushData(new ByteData(new ArraySegment <byte>(data.Buffer.Array, data.Buffer.Offset, count)), this.m_offset + offset); this.m_status.FilledRangeList.MergingAdd(new Range(offset, (long)num1)); this.m_status.IsFilled = SinkUtil.CheckIsFilled(this.m_status.FilledRangeList, this.Size); return(num1); }
public ByteData PullData(long offset, int size) { this.CheckAlignment(offset); int size1 = size; if (offset + (long)size1 < this.Size && (size1 & this.AlignmentSize - 1) != 0) { size1 = size1 / this.AlignmentSize * this.AlignmentSize; } ByteData byteData = this.m_source.PullData(offset, size1); if (offset + (long)byteData.Buffer.Count < this.Size) { this.CheckAlignment((long)byteData.Buffer.Count); } return(byteData); }
public override int Read(byte[] buffer, int offset, int count) { ByteData byteData = this.m_source.PullData(this.m_offset, count); if (byteData.Buffer.Count == 0) { return(0); } Buffer.BlockCopy((Array)byteData.Buffer.Array, byteData.Buffer.Offset, (Array)buffer, offset, byteData.Buffer.Count); long offset1 = this.m_offset; ArraySegment <byte> buffer1 = byteData.Buffer; long count1 = (long)buffer1.Count; this.m_offset = offset1 + count1; buffer1 = byteData.Buffer; return(buffer1.Count); }
public ByteData PullData(long offset, int size) { ByteData byteData = this.m_source.PullData(offset, size); if (byteData.Buffer.Count == 0) { return(new ByteData(new ArraySegment <byte>())); } ulong num = (ulong)(this.BaseOffset + offset) / (ulong)this.BlockSize; byte[] numArray1 = new byte[this.m_crypto.KeySize]; for (int index = 0; index < 4; ++index) { numArray1[7 - index] = (byte)(this.Generation >> index * 8 & (int)byte.MaxValue); } for (int index = 0; index < 8; ++index) { numArray1[15 - index] = (byte)(num >> index * 8 & (ulong)byte.MaxValue); } byte[] numArray2 = new byte[byteData.Buffer.Count]; ICtrModeEncryptor crypto = this.m_crypto; byte[] iv = numArray1; ArraySegment <byte> buffer = byteData.Buffer; byte[] array1 = buffer.Array; buffer = byteData.Buffer; int offset1 = buffer.Offset; buffer = byteData.Buffer; int count1 = buffer.Count; byte[] dst = numArray2; int dstOffset = 0; crypto.EncryptBlock(iv, array1, offset1, count1, dst, dstOffset); byte[] array2 = numArray2; int offset2 = 0; buffer = byteData.Buffer; int count2 = buffer.Count; return(new ByteData(new ArraySegment <byte>(array2, offset2, count2))); }
public ByteData PullData(long offset, int size) { if (this.m_buffer == null) { for (int index = 0; index < this.m_hashSources.Count; ++index) { if (!(this.m_hashSources[index].Extension != ".nca") || !(this.m_hashSources[index].Extension != ".cnmt.nca") || (!(this.m_hashSources[index].Extension != ".cnmt.xml") || !(this.m_hashSources[index].Extension != ".jpg")) || (!(this.m_hashSources[index].Extension != ".cnmt") || !(this.m_hashSources[index].Extension != ".nacp.xml") || !(this.m_hashSources[index].Extension != ".programinfo.xml"))) { if (this.m_hashSources[index].Source == null || this.m_hashSources[index].Source.Size != 32L) { throw new InvalidOperationException(); } ByteData byteData = this.m_hashSources[index].Source.PullData(0L, 16); ArraySegment <byte> buffer = byteData.Buffer; if (buffer.Count != 16) { throw new InvalidOperationException(); } buffer = byteData.Buffer; byte[] numArray1 = new byte[buffer.Count]; buffer = byteData.Buffer; byte[] array = buffer.Array; buffer = byteData.Buffer; int offset1 = buffer.Offset; byte[] numArray2 = numArray1; int dstOffset = 0; buffer = byteData.Buffer; int count = buffer.Count; Buffer.BlockCopy((Array)array, offset1, (Array)numArray2, dstOffset, count); PartitionFileSystemInfo.EntryInfo entry = this.m_partFsInfo.entries[index]; entry.name = Regex.Replace(entry.name, "^.{32}", BitConverter.ToString(numArray1).Replace("-", string.Empty).ToLower()); this.m_partFsInfo.entries[index] = entry; } } this.m_buffer = Activator.CreateInstance <T>().Create(this.m_partFsInfo); if (this.Size != (long)this.m_buffer.Length) { throw new InvalidOperationException(); } } return(new MemorySource(this.m_buffer, 0, this.m_buffer.Length).PullData(offset, size)); }
public ByteData PullData(long offset, int size) { ISource source = this.m_contentMetaBase.GetSource(); NintendoContentMetaReader contentMetaReader = new NintendoContentMetaReader(source.PullData(0L, (int)source.Size).Buffer.Array); List <NintendoContentInfo> contentInfoList = contentMetaReader.GetContentInfoList(); for (int index = 0; index < contentInfoList.Count; ++index) { NintendoContentInfo nintendoContentInfo = contentInfoList[index]; this.m_model.ContentList[index].SetIdBytes(nintendoContentInfo.Id); this.m_model.ContentList[index].SetHashBytes(nintendoContentInfo.Hash); } this.m_model.SetDigestBytes(contentMetaReader.GetDigest()); ByteData byteData = this.m_MetaHashSource.PullData(0L, NintendoContentMeta.GetContentInfoHashSize()); this.m_MetaModel.SetIdBytes(byteData.Buffer.Array); this.m_MetaModel.SetHashBytes(byteData.Buffer.Array); byte[] bytes = this.GetBytes(); return(new MemorySource(bytes, 0, bytes.Length).PullData(offset, size)); }
private void CalculateAndStoreHash(ByteData srcData, long dstOffset, int hashLayerCount) { if (this.m_hierarchicalHashValueSinkList[hashLayerCount].QueryStatus().IsFilled) { throw new InvalidOperationException(); } int num1 = 0; int num2 = 0; while (true) { int num3 = num2; ArraySegment <byte> buffer = srcData.Buffer; int count1 = buffer.Count; if (num3 < count1) { buffer = srcData.Buffer; int num4 = Math.Min(buffer.Count - num2, this.m_blockSize); SHA256CryptoServiceProvider hashCalculator = this.m_hashCalculator; buffer = srcData.Buffer; byte[] array = buffer.Array; buffer = srcData.Buffer; int offset = buffer.Offset + num2; int count2 = num4; byte[] hash = hashCalculator.ComputeHash(array, offset, count2); num1 += this.m_hierarchicalHashValueSinkList[hashLayerCount].PushData(new ByteData(new ArraySegment <byte>(hash, 0, hash.Length)), dstOffset + (long)num1); num2 += this.m_blockSize; } else { break; } } if (!this.m_hierarchicalHashValueSinkList[hashLayerCount].QueryStatus().IsFilled || hashLayerCount == 0) { return; } ISource source = this.m_hierarchicalHashValueSinkList[hashLayerCount].ToSource(); this.CalculateAndStoreHash(source.PullData(0L, (int)source.Size), 0L, hashLayerCount - 1); }
public ByteData PullData(long offset, int size) { int count1 = 0; byte[] array1 = new byte[size]; long offset1 = offset; while (count1 != size) { ConcatenatedSource.Element element = this.GetElement(offset1); ByteData byteData = element.Source.PullData(offset1 - element.Offset, size - count1); ArraySegment <byte> buffer = byteData.Buffer; if (buffer.Count != 0) { buffer = byteData.Buffer; byte[] array2 = buffer.Array; buffer = byteData.Buffer; int offset2 = buffer.Offset; byte[] numArray = array1; int dstOffset = count1; buffer = byteData.Buffer; int count2 = buffer.Count; Buffer.BlockCopy((Array)array2, offset2, (Array)numArray, dstOffset, count2); int num1 = count1; buffer = byteData.Buffer; int count3 = buffer.Count; count1 = num1 + count3; long num2 = offset1; buffer = byteData.Buffer; long count4 = (long)buffer.Count; offset1 = num2 + count4; } else { break; } } return(new ByteData(new ArraySegment <byte>(array1, 0, count1))); }
public int PushData(ByteData data, long offset) { int writableSize = SinkUtil.GetWritableSize(this.Size, offset, data.Buffer.Count); if (writableSize == 0) { return(0); } using (Stream stream1 = (Stream) new SubStream((Stream) new FileStream(this.m_filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.None, 4096, FileOptions.RandomAccess), this.m_offset, this.Size)) { stream1.Seek(offset, SeekOrigin.Begin); Stream stream2 = stream1; ArraySegment <byte> buffer = data.Buffer; byte[] array = buffer.Array; buffer = data.Buffer; int offset1 = buffer.Offset; int count = writableSize; stream2.Write(array, offset1, count); } this.m_status.FilledRangeList.MergingAdd(new Range(offset, (long)writableSize)); this.m_status.IsFilled = SinkUtil.CheckIsFilled(this.m_status.FilledRangeList, this.Size); return(writableSize); }
public ByteData PullData(long offset, int size) { if (size % 2 != 0) { throw new ArgumentException(); } ByteData byteData = this.m_source.PullData(offset, size / 2); byte[] numArray1 = new byte[byteData.Buffer.Count]; byte[] array = byteData.Buffer.Array; ArraySegment <byte> buffer = byteData.Buffer; int offset1 = buffer.Offset; byte[] numArray2 = numArray1; int dstOffset = 0; buffer = byteData.Buffer; int count = buffer.Count; Buffer.BlockCopy((Array)array, offset1, (Array)numArray2, dstOffset, count); byte[] bytes = Encoding.ASCII.GetBytes(BitConverter.ToString(numArray1).Replace("-", string.Empty)); return(new ByteData(new ArraySegment <byte>(bytes, 0, bytes.Length))); }
public ByteData PullData(long offset, int size) { ByteData byteData = this.m_rootPartitionFsHeaderHashSource.PullData(0L, 32); this.m_xciInfo.partitionFsHeaderHash = new byte[32]; ArraySegment <byte> buffer = byteData.Buffer; byte[] array1 = buffer.Array; buffer = byteData.Buffer; int offset1 = buffer.Offset; byte[] partitionFsHeaderHash = this.m_xciInfo.partitionFsHeaderHash; int dstOffset = 0; buffer = byteData.Buffer; int count = buffer.Count; Buffer.BlockCopy((Array)array1, offset1, (Array)partitionFsHeaderHash, dstOffset, count); byte[] header = this.m_xciMeta.CreateHeader(this.m_xciInfo); this.m_headerEncryptor.EncryptBlock(this.m_xciInfo.iv, header, XciMeta.GetEncryptionTargetOffset(), XciMeta.GetEncryptionTargetSize(), header, XciMeta.GetEncryptionTargetOffset()); byte[] array2 = ((IEnumerable <byte>) this.m_headerSigner.SignBlock(header, 0, header.Length)).Concat <byte>((IEnumerable <byte>)header).ToArray <byte>(); return(new ByteData(new ArraySegment <byte>(array2, 0, array2.Length))); }
public ByteData PullData(long offset, int size) { ByteData byteData1 = this.m_baseSource.PullData(offset, size); foreach (Tuple <ISource, long, long> adaptSourceInfo in this.m_adaptSourceInfos) { ISource source = adaptSourceInfo.Item1; long num1 = adaptSourceInfo.Item2; long num2 = adaptSourceInfo.Item3; if (offset < num1 + num2) { long num3 = offset; ArraySegment <byte> buffer = byteData1.Buffer; long count1 = (long)buffer.Count; if (num3 + count1 > num1) { ByteData byteData2 = source.PullData(0L, (int)num2); buffer = byteData2.Buffer; if (buffer.Count == 0) { buffer = new ArraySegment <byte>(); return(new ByteData(buffer)); } buffer = byteData2.Buffer; if ((long)buffer.Count != num2) { throw new InvalidOperationException(); } long num4 = num1 + num2; long num5 = offset; buffer = byteData1.Buffer; long count2 = (long)buffer.Count; long num6 = num5 + count2; bool flag1 = num4 <= num6; bool flag2 = num1 >= offset; int num7 = 0; int num8 = 0; int num9 = 0; if (flag2 & flag1) { num7 = (int)(num1 - offset); num8 = 0; num9 = (int)num2; } else if (flag2 && !flag1) { num7 = (int)(num1 - offset); num8 = 0; long num10 = offset; buffer = byteData1.Buffer; long count3 = (long)buffer.Count; num9 = (int)(num10 + count3 - num1); } else if (!flag2 & flag1) { num7 = 0; num8 = (int)(offset - num1); num9 = (int)(num2 - (long)num8); } else if (!flag2 && !flag1) { num7 = 0; num8 = (int)(offset - num1); buffer = byteData1.Buffer; num9 = buffer.Count; } buffer = byteData2.Buffer; byte[] array1 = buffer.Array; buffer = byteData2.Buffer; int srcOffset = buffer.Offset + num8; buffer = byteData1.Buffer; byte[] array2 = buffer.Array; buffer = byteData1.Buffer; int dstOffset = buffer.Offset + num7; int count4 = num9; Buffer.BlockCopy((Array)array1, srcOffset, (Array)array2, dstOffset, count4); } } } return(byteData1); }
public void Run() { SourceStatus sourceStatus = new SourceStatus(); bool flag1 = false; while (!flag1) { bool flag2 = false; foreach (Connection connection in this.m_connectionList) { foreach (Range duplicatedDeleted in (List <Range>)connection.Source.QueryStatus().AvailableRangeList.GetDuplicatedDeletedList(connection.Sink.QueryStatus().FilledRangeList)) { long num1 = 0; int length = 8388608; byte[] array1 = new byte[length]; long num2 = 0; while (num1 < duplicatedDeleted.Size) { int size = (int)Math.Min(duplicatedDeleted.Size - num1 - num2, (long)length); ByteData data1 = connection.Source.PullData(duplicatedDeleted.Offset + num1 + num2, size); ArraySegment <byte> buffer; if (num2 + (long)data1.Buffer.Count <= (long)length) { buffer = data1.Buffer; if (buffer.Count != 0 || num2 == 0L) { goto label_9; } } num1 += (long)connection.Sink.PushData(new ByteData(new ArraySegment <byte>(array1, 0, (int)num2)), duplicatedDeleted.Offset + num1); num2 = 0L; buffer = data1.Buffer; if (buffer.Count == 0) { continue; } label_9: buffer = data1.Buffer; if (buffer.Count == size) { if (0L < num2) { buffer = data1.Buffer; byte[] array2 = buffer.Array; int srcOffset = 0; byte[] numArray = array1; int dstOffset = (int)num2; buffer = data1.Buffer; int count1 = buffer.Count; Buffer.BlockCopy((Array)array2, srcOffset, (Array)numArray, dstOffset, count1); long num3 = num1; ISink sink = connection.Sink; byte[] array3 = array1; int offset1 = 0; int num4 = (int)num2; buffer = data1.Buffer; int count2 = buffer.Count; int count3 = num4 + count2; ByteData data2 = new ByteData(new ArraySegment <byte>(array3, offset1, count3)); long offset2 = duplicatedDeleted.Offset + num1; long num5 = (long)sink.PushData(data2, offset2); num1 = num3 + num5; num2 = 0L; } else { num1 += (long)connection.Sink.PushData(data1, duplicatedDeleted.Offset + num1); } } else { buffer = data1.Buffer; byte[] array2 = buffer.Array; int srcOffset = 0; byte[] numArray = array1; int dstOffset = (int)num2; buffer = data1.Buffer; int count1 = buffer.Count; Buffer.BlockCopy((Array)array2, srcOffset, (Array)numArray, dstOffset, count1); long num3 = num2; buffer = data1.Buffer; long count2 = (long)buffer.Count; num2 = num3 + count2; } } if (num1 > 0L) { flag2 = true; } } } flag1 = true; foreach (Connection connection in this.m_connectionList) { if (!connection.Sink.QueryStatus().IsFilled) { flag1 = false; break; } } if (!flag1 && !flag2) { throw new ApplicationException("Failed to resolve dependencies for archiving. Please contact to NintendoSDK support."); } } }
internal static NintendoSubmissionPackageFileSystemInfo GetReplacedNspInfo(NintendoSubmissionPackageReader nspReader, ISource inSource, string targetEntryPath, string descFilePath, KeyConfiguration keyConfig) { bool isReplaced = false; ArchiveReconstructionUtils.GetContentInfoDelegate getContentInfoImpl = (ArchiveReconstructionUtils.GetContentInfoDelegate)(contentInfo => { NintendoSubmissionPackageFileSystemInfo.ContentInfo contentInfo1 = new NintendoSubmissionPackageFileSystemInfo.ContentInfo(); string fileName = contentInfo.Id + ".nca"; NintendoContentArchiveReader ncaReader = nspReader.OpenNintendoContentArchiveReader(fileName, keyConfig.GetKeyAreaEncryptionKeys()); if (targetEntryPath.StartsWith(fileName)) { contentInfo1.FsInfo = (Nintendo.Authoring.FileSystemMetaLibrary.FileSystemInfo)ArchiveReconstructionUtils.GetReplacedNcaInfo(ncaReader, descFilePath, new EntryReplaceRule() { Source = inSource, Path = targetEntryPath.Substring(fileName.Length + 1) }); isReplaced = true; } else { contentInfo1.Source = (ISource) new FileSystemArchvieFileSource((IFileSystemArchiveReader)nspReader, fileName); } contentInfo1.ContentType = contentInfo.Type; return(contentInfo1); }); ArchiveReconstructionUtils.GetContentMetaInfoDelegate getContentMetaInfoImpl = (ArchiveReconstructionUtils.GetContentMetaInfoDelegate)((ref NintendoSubmissionPackageFileSystemInfo.EntryInfo entry, string contentMetaFileName, ContentMetaModel model) => { ArchiveReconstructionUtils.GetCommonContentMetaInfo(ref entry, contentMetaFileName, model, nspReader, keyConfig); if (!targetEntryPath.StartsWith(contentMetaFileName) || !targetEntryPath.EndsWith(".cnmt")) { return; } NintendoContentMetaReader contentMetaReader1 = new NintendoContentMetaReader(entry.ContentMetaInfo.Data); ulong id1 = contentMetaReader1.GetId(); uint version1 = contentMetaReader1.GetVersion(); if (inSource.Size != (long)entry.ContentMetaInfo.Data.Length) { throw new Exception(".cnmt file specified to be replaced is invalid."); } ByteData byteData = inSource.PullData(0L, (int)inSource.Size); ArraySegment <byte> buffer = byteData.Buffer; byte[] array = buffer.Array; buffer = byteData.Buffer; int offset = buffer.Offset; byte[] data = entry.ContentMetaInfo.Data; int dstOffset = 0; int count = byteData.Buffer.Count; Buffer.BlockCopy((Array)array, offset, (Array)data, dstOffset, count); NintendoContentMetaReader contentMetaReader2 = new NintendoContentMetaReader(entry.ContentMetaInfo.Data); ulong id2 = contentMetaReader2.GetId(); if ((long)id1 != (long)id2) { throw new ArgumentException(string.Format("Ids of content meta are different. (oldId = {0:x16}, newID = {0:x16})", (object)id1, (object)id2)); } uint version2 = contentMetaReader2.GetVersion(); Log.Info(string.Format("content meta (ID = {0:x16}) will be replaced : version {1} -> {2}", (object)id1, (object)version1, (object)version2)); isReplaced = true; }); NintendoSubmissionPackageFileSystemInfo nspInfo = ArchiveReconstructionUtils.GetNspInfo(nspReader, keyConfig, getContentInfoImpl, getContentMetaInfoImpl); if (isReplaced) { return(nspInfo); } throw new Exception("nothing was replaced."); }
public int PushData(ByteData data, long offset) { return(data.Buffer.Count); }