/// <summary> /// Get the signature for single chunk. /// </summary> /// <param name="header">The data of file header.</param> /// <param name="dataFile">The data of data file.</param> /// <returns>An instance of SignatureObject.</returns> private SignatureObject GetSingleChunkSignature(byte[] header, byte[] dataFile) { SHA1 sha = new SHA1CryptoServiceProvider(); byte[] headerSignature = sha.ComputeHash(header); sha.Dispose(); byte[] singleSignature = null; if (SharedContext.Current.CellStorageVersionType.MinorVersion >= 2) { singleSignature = new byte[dataFile.Length]; for (int i = 0; i < headerSignature.Length; i++) { singleSignature[i] = (byte)(headerSignature[i] ^ dataFile[i]); } } else { List <byte> tmp = new List <byte>(); tmp.AddRange(headerSignature); tmp.AddRange(dataFile); singleSignature = tmp.ToArray(); } SignatureObject signature = new SignatureObject(); signature.SignatureData = new BinaryItem(singleSignature); return(signature); }
/// <summary> /// Get the signature for data file. /// </summary> /// <param name="array">The input data.</param> /// <returns>An instance of SignatureObject.</returns> private SignatureObject GetDataFileSignature(byte[] array) { SignatureObject signature = new SignatureObject(); signature.SignatureData = new BinaryItem(array); return(signature); }
/// <summary> /// Get signature with SHA1 algorithm. /// </summary> /// <param name="array">The input data.</param> /// <returns>An instance of SignatureObject.</returns> private SignatureObject GetSHA1Signature(byte[] array) { SHA1 sha = new SHA1CryptoServiceProvider(); byte[] temp = sha.ComputeHash(array); sha.Dispose(); SignatureObject signature = new SignatureObject(); signature.SignatureData = new BinaryItem(temp); return(signature); }
/// <summary> /// This method is used to verify the signature object related requirements. /// </summary> /// <param name="instance">Specify the signature object instance.</param> /// <param name="site">Specify the ITestSite instance.</param> public void VerifySignatureObject(SignatureObject instance, ITestSite site) { // If the instance is not null and there are no parsing errors, then the SignatureObject related adapter requirements can be directly captured. if (null == instance) { site.Assert.Fail("The instance of type SignatureObject is null due to parsing error or type casting error."); } // Verify the stream object header related requirements. this.ExpectStreamObjectHeaderStart(instance.StreamObjectHeaderStart, instance.GetType(), site); this.ExpectSingleObject(instance.StreamObjectHeaderStart, site); }
/// <summary> /// This method is used to build intermediate node object from a byte array with a signature. /// </summary> /// <param name="array">Specify the byte array.</param> /// <param name="signature">Specify the signature.</param> /// <returns>Return the intermediate node object.</returns> public LeafNodeObject Build(byte[] array, SignatureObject signature) { LeafNodeObject nodeObject = new LeafNodeObject(); nodeObject.DataSize = new DataSizeObject(); nodeObject.DataSize.DataSize = (ulong)array.Length; nodeObject.Signature = signature; nodeObject.ExGuid = new ExGuid(SequenceNumberGenerator.GetCurrentSerialNumber(), Guid.NewGuid()); nodeObject.DataNodeObjectData = new DataNodeObjectData(array, 0, array.Length); nodeObject.IntermediateNodeObjectList = null; // Now in the current implementation, one intermediate node only contain one single data object node. return(nodeObject); }
/// <summary> /// Get signature for the chunk. /// </summary> /// <param name="array">The data of the chunk.</param> /// <returns>The signature instance.</returns> private SignatureObject GetSignature(byte[] array) { if (this.FileContent.Length <= 250 * 1024 * 1024) { SHA1 sha = new SHA1CryptoServiceProvider(); byte[] temp = sha.ComputeHash(array); sha.Dispose(); SignatureObject signature = new SignatureObject(); signature.SignatureData = new BinaryItem(temp); return(signature); } else { throw new NotImplementedException("When the file size is larger than 250MB, the signature method is not implemented."); } }
/// <summary> /// This method is used to analyze the chunk for simple chunk. /// </summary> /// <param name="rootNode">Specify the root node object which is needed to be analyzed.</param> /// <param name="site">Specify the ITestSite instance.</param> public override void AnalyzeChunking(IntermediateNodeObject rootNode, ITestSite site) { if (rootNode.DataSize.DataSize <= 1024 * 1024) { // These would be something ignored for MOSS2010, when the file size is less than 1MB. // In this case the server will response data without signature, but to be consistent with the behavior, // The Simple chunk still will be used, but empty signature check will be ignored. return; } else if (rootNode.DataSize.DataSize <= 250 * 1024 * 1024) { foreach (LeafNodeObject interNode in rootNode.IntermediateNodeObjectList) { SignatureObject expect = this.GetSignature(interNode.DataNodeObjectData.ObjectData); SignatureObject realValue = interNode.Signature; if (!expect.Equals(interNode.Signature)) { site.Assert.Fail("Expect the signature value {0}, but actual value is {1}", expect.ToString(), realValue.ToString()); } site.Assert.IsTrue(interNode.DataSize.DataSize <= 1024 * 1024, "The size of each chunk should be equal or less than 1MB for simple chunk."); site.Assert.AreEqual <ulong>( (ulong)interNode.GetContent().Count, interNode.DataSize.DataSize, "Expect the data size value equal the number represented by the chunk."); site.Assert.IsNotNull( interNode.DataNodeObjectData, "The Object References array of the Intermediate Node Object associated with this Data Node Object MUST have a single entry which MUST be the Object ID of the Data Node Object."); } site.Log.Add(LogEntryKind.Debug, "All the intermediate signature value matches."); if (SharedContext.Current.IsMsFsshttpRequirementsCaptured) { MsfsshttpdCapture.VerifySimpleChunk(SharedContext.Current.Site); } } else { throw new NotImplementedException("When the file size is larger than 250MB, because the signature method is not implemented, the analysis method is also not implemented."); } }
/// <summary> /// Get a chunk with the input bytes. /// </summary> /// <param name="chunkStart">The start index of the chunk.</param> /// <param name="chunkEnd">The end index of the chunk.</param> /// <returns>An IntermediateNodeObject which contains a chunk.</returns> private IntermediateNodeObject GetChunk(uint chunkStart, uint chunkEnd) { if (chunkEnd <= chunkStart || (chunkEnd - chunkStart > this.maxChunkSize) || chunkStart > uint.MaxValue) { throw new ArgumentOutOfRangeException("chunkStart"); } byte[] temp = AdapterHelper.GetBytes(this.FileContent, (int)chunkStart, (int)(chunkEnd - chunkStart)); byte[] signatureBytes = null; using (RDCSignatureGenerator generator = new RDCSignatureGenerator()) { signatureBytes = generator.ComputeHash(temp); } SignatureObject signature = new SignatureObject(); signature.SignatureData = new BinaryItem(signatureBytes); return(new IntermediateNodeObject.IntermediateNodeObjectBuilder().Build(temp, signature)); }
/// <summary> /// Override the equals method. /// </summary> /// <param name="obj">Specify the compared instance.</param> /// <returns>If equals return true, otherwise return false.</returns> public override bool Equals(object obj) { SignatureObject so = obj as SignatureObject; if (so == null) { return(false); } if (so.SignatureData != null && this.SignatureData != null) { return(so.SignatureData.Equals(this.SignatureData)); } else if (so.SignatureData == null && this.SignatureData == null) { return(true); } else { return(false); } }
/// <summary> /// Get the signature for single chunk. /// </summary> /// <param name="header">The data of file header.</param> /// <param name="dataFile">The data of data file.</param> /// <returns>An instance of SignatureObject.</returns> private SignatureObject GetSingleChunkSignature(byte[] header, byte[] dataFile) { SHA1 sha = new SHA1CryptoServiceProvider(); byte[] headerSignature = sha.ComputeHash(header); sha.Dispose(); byte[] singleSignature = null; if (SharedContext.Current.CellStorageVersionType.MinorVersion >= 2) { singleSignature = new byte[dataFile.Length]; for (int i = 0; i < headerSignature.Length; i++) { singleSignature[i] = (byte)(headerSignature[i] ^ dataFile[i]); } } else { List<byte> tmp = new List<byte>(); tmp.AddRange(headerSignature); tmp.AddRange(dataFile); singleSignature = tmp.ToArray(); } SignatureObject signature = new SignatureObject(); signature.SignatureData = new BinaryItem(singleSignature); return signature; }
/// <summary> /// Get signature for the chunk. /// </summary> /// <param name="array">The data of the chunk.</param> /// <returns>The signature instance.</returns> private SignatureObject GetSignature(byte[] array) { if (this.FileContent.Length <= 250 * 1024 * 1024) { SHA1 sha = new SHA1CryptoServiceProvider(); byte[] temp = sha.ComputeHash(array); sha.Dispose(); SignatureObject signature = new SignatureObject(); signature.SignatureData = new BinaryItem(temp); return signature; } else { throw new NotImplementedException("When the file size is larger than 250MB, the signature method is not implemented."); } }
/// <summary> /// This method is used to analyze the chunk. /// </summary> /// <param name="rootNode">Specify the root node object which will be analyzed.</param> /// <param name="site">Specify the ITestSite instance.</param> public override void AnalyzeChunking(IntermediateNodeObject rootNode, ITestSite site) { List <LeafNodeObject> cloneList = new List <LeafNodeObject>(rootNode.IntermediateNodeObjectList); while (cloneList.Count != 0) { LeafNodeObject nodeObject = cloneList.First(); byte[] content = nodeObject.DataNodeObjectData.ObjectData; if (cloneList.Count == 1) { if (content.Length > 1048576) { throw new NotImplementedException("If the final chunk is larger than 1MB, the signature method is not implemented."); } // Only final chunk left SignatureObject expect = this.GetSHA1Signature(content); if (!expect.Equals(nodeObject.Signature)) { site.Assert.Fail("For the Zip file, final part chunk expect the signature {0}, actual signature {1}", expect.ToString(), nodeObject.Signature.ToString()); } // Verify the less than 1MB final part related requirements if (SharedContext.Current.IsMsFsshttpRequirementsCaptured) { MsfsshttpdCapture.VerifySmallFinalChunk(SharedContext.Current.Site); } } else { if (ZipHeader.IsFileHeader(content, 0)) { byte[] dataFileSignatureBytes; byte[] header = this.AnalyzeFileHeader(content, 0, out dataFileSignatureBytes); int headerLength = header.Length; int compressedSize = (int)this.GetCompressedSize(dataFileSignatureBytes); if (headerLength + compressedSize <= 4096) { if (Common.GetConfigurationPropertyValue("SutVersion", SharedContext.Current.Site) != "SharePointFoundation2010" && Common.GetConfigurationPropertyValue("SutVersion", SharedContext.Current.Site) != "SharePointServer2010") { LeafNodeObject expectNode = new LeafNodeObject.IntermediateNodeObjectBuilder().Build(content, this.GetSingleChunkSignature(header, dataFileSignatureBytes)); if (!expectNode.Signature.Equals(nodeObject.Signature)) { site.Assert.Fail("For the Zip file, when zip file is less than 4096, expect the signature {0}, actual signature {1}", expectNode.Signature.ToString(), nodeObject.Signature.ToString()); } } // Verify the zip file less than 4096 bytes MsfsshttpdCapture.VerifyZipFileLessThan4096Bytes(SharedContext.Current.Site); } else { SignatureObject expectHeader = this.GetSHA1Signature(header); if (!expectHeader.Equals(nodeObject.Signature)) { site.Assert.Fail("For the Zip file header, expect the signature {0}, actual signature {1}", expectHeader.ToString(), nodeObject.Signature.ToString()); } // Remove the header node cloneList.RemoveAt(0); // Then expect the next is file content node nodeObject = cloneList.First(); // Here having something need to be distinguished between the MOSS2010 and MOSS2013 if (nodeObject.DataNodeObjectData == null && nodeObject.IntermediateNodeObjectList != null) { if (Common.IsRequirementEnabled("MS-FSSHTTP-FSSHTTPB", 8213, SharedContext.Current.Site)) { bool isR8213Verified = false; if (compressedSize > 1024 * 1024 && nodeObject.IntermediateNodeObjectList.Count > 1) { isR8213Verified = true; } site.CaptureRequirementIfIsTrue( isR8213Verified, "MS-FSSHTTPD", 8213, @"[In Appendix A: Product Behavior] For implementation, if the number of .ZIP file bytes represented by a chunk is greater than 1 megabyte, a list of subchunks is generated. <4> Section 2.4.1: For SharePoint Server 2010, if the number of .ZIP file bytes represented by a chunk is greater than 1 megabyte, a list of subchunks is generated."); } if (Common.IsRequirementEnabled("MS-FSSHTTP-FSSHTTPB", 8207, SharedContext.Current.Site)) { bool isR8207Verified = false; if (compressedSize > 3 * 1024 * 1024 && nodeObject.IntermediateNodeObjectList.Count > 1) { isR8207Verified = true; } site.CaptureRequirementIfIsTrue( isR8207Verified, "MS-FSSHTTPD", 8207, @"[In Appendix A: Product Behavior] For implementation, if the number of .ZIP file bytes represented by a chunk is greater than 3 megabytes, a list of subchunks is generated. (Microsoft Office 2013/Microsoft SharePoint Foundation 2013/Microsoft SharePoint Server 2013/Microsoft SharePoint Workspace 2010/Microsft Office 2016/Microsft SharePoint Server 2016 follow this behavior.)"); } if (Common.IsRequirementEnabled("MS-FSSHTTP-FSSHTTPB", 8208, SharedContext.Current.Site) && Common.IsRequirementEnabled("MS-FSSHTTP-FSSHTTPB", 8210, SharedContext.Current.Site)) { bool isR8208Verified = true; bool isR8210Verified = true; if (nodeObject.IntermediateNodeObjectList[nodeObject.IntermediateNodeObjectList.Count - 1].DataSize.DataSize > 1024 * 1024) { isR8208Verified = false; } for (int i = 0; i < nodeObject.IntermediateNodeObjectList.Count - 1; i++) { if (nodeObject.IntermediateNodeObjectList[i].DataSize.DataSize != 1024 * 1024) { isR8210Verified = false; } } site.CaptureRequirementIfIsTrue( isR8208Verified, "MS-FSSHTTPD", 8208, @"[In Appendix A: Product Behavior] The size of each subchunk is at most 1 megabyte. (Microsoft SharePoint Server 2010 follows this behavior.)"); site.CaptureRequirementIfIsTrue( isR8210Verified, "MS-FSSHTTPD", 8210, @"[In Appendix A: Product Behavior] All but the last subchunk MUST be 1 megabyte in size. (Microsfot SharePoint Server 2010 follows this behavior.)"); } if (Common.IsRequirementEnabled("MS-FSSHTTP-FSSHTTPB", 8209, SharedContext.Current.Site) && Common.IsRequirementEnabled("MS-FSSHTTP-FSSHTTPB", 8211, SharedContext.Current.Site)) { bool isR8209Verified = true; bool isR8211Verified = true; if (nodeObject.IntermediateNodeObjectList[nodeObject.IntermediateNodeObjectList.Count - 1].DataSize.DataSize > 3 * 1024 * 1024) { isR8209Verified = false; } for (int i = 0; i < nodeObject.IntermediateNodeObjectList.Count - 1; i++) { if (nodeObject.IntermediateNodeObjectList[i].DataSize.DataSize != 3 * 1024 * 1024) { isR8211Verified = false; } } site.CaptureRequirementIfIsTrue( isR8209Verified, "MS-FSSHTTPD", 8209, @"[In Appendix A: Product Behavior] The size of each subchunk is at most 3 megabytes. (Microsoft Office 2013/Microsoft SharePoint Foundation 2013/Microsoft SharePoint Server 2013/Microsoft SharePoint Workspace 2010/Microsft Office 2016/Microsft SharePoint Server 2016 follow this behavior.)"); site.CaptureRequirementIfIsTrue( isR8211Verified, "MS-FSSHTTPD", 8211, @"[In Appendix A: Product Behavior] All but the last subchunk MUST be 3 megabyte in size. (Microsoft Office 2013/Microsoft SharePoint Foundation 2013/Microsoft SharePoint Server 2013/Microsoft SharePoint Workspace 2010/Microsft Office 2016/Microsft SharePoint Server 2016 follow this behavior.)"); } } else if (nodeObject.DataNodeObjectData != null) { site.Assert.AreEqual <ulong>( (ulong)compressedSize, nodeObject.DataSize.DataSize, "The Data Size of the Intermediate Node Object MUST be the total number of bytes represented by the chunk."); if (Common.GetConfigurationPropertyValue("SutVersion", SharedContext.Current.Site) != "SharePointFoundation2010" && Common.GetConfigurationPropertyValue("SutVersion", SharedContext.Current.Site) != "SharePointServer2010") { SignatureObject contentSignature = new SignatureObject(); contentSignature.SignatureData = new BinaryItem(dataFileSignatureBytes); if (!contentSignature.Equals(nodeObject.Signature)) { site.Assert.Fail("For the Zip file content, expect the signature {0}, actual signature {1}", contentSignature.ToString(), nodeObject.Signature.ToString()); } } // Verify the zip file larger than 4096 bytes and less than 1MB. if (SharedContext.Current.IsMsFsshttpRequirementsCaptured) { MsfsshttpdCapture.VerifyZipFileHeaderAndContentSignature(SharedContext.Current.Site); MsfsshttpdCapture.VerifyIntermediateNodeForZipFileChunk(SharedContext.Current.Site); } } else { throw new InvalidOperationException("The DataNodeObjectData and IntermediateNodeObjectList cannot be null at the same time."); } } } } cloneList.RemoveAt(0); } }
/// <summary> /// Get the signature for data file. /// </summary> /// <param name="array">The input data.</param> /// <returns>An instance of SignatureObject.</returns> private SignatureObject GetDataFileSignature(byte[] array) { SignatureObject signature = new SignatureObject(); signature.SignatureData = new BinaryItem(array); return signature; }
/// <summary> /// This method is used to analyze the chunk. /// </summary> /// <param name="rootNode">Specify the root node object which will be analyzed.</param> /// <param name="site">Specify the ITestSite instance.</param> public override void AnalyzeChunking(RootNodeObject rootNode, ITestSite site) { List<IntermediateNodeObject> cloneList = new List<IntermediateNodeObject>(rootNode.IntermediateNodeObjectList); while (cloneList.Count != 0) { IntermediateNodeObject nodeObject = cloneList.First(); byte[] content = nodeObject.DataNodeObjectData.ObjectData; if (cloneList.Count == 1) { if (content.Length > 1048576) { throw new NotImplementedException("If the final chunk is larger than 1MB, the signature method is not implemented."); } // Only final chunk left SignatureObject expect = this.GetSHA1Signature(content); if (!expect.Equals(nodeObject.Signature)) { site.Assert.Fail("For the Zip file, final part chunk expect the signature {0}, actual signature {1}", expect.ToString(), nodeObject.Signature.ToString()); } // Verify the less than 1MB final part related requirements if (SharedContext.Current.IsMsFsshttpRequirementsCaptured) { MsfsshttpdCapture.VerifySmallFinalChunk(SharedContext.Current.Site); } } else { if (ZipHeader.IsFileHeader(content, 0)) { byte[] dataFileSignatureBytes; byte[] header = this.AnalyzeFileHeader(content, 0, out dataFileSignatureBytes); int headerLength = header.Length; int compressedSize = (int)this.GetCompressedSize(dataFileSignatureBytes); if (headerLength + compressedSize <= 4096) { IntermediateNodeObject expectNode = new IntermediateNodeObject.IntermediateNodeObjectBuilder().Build(content, this.GetSingleChunkSignature(header, dataFileSignatureBytes)); if (!expectNode.Signature.Equals(nodeObject.Signature)) { site.Assert.Fail("For the Zip file, when zip file is less than 4096, expect the signature {0}, actual signature {1}", expectNode.Signature.ToString(), nodeObject.Signature.ToString()); } // Verify the zip file less than 4096 bytes MsfsshttpdCapture.VerifyZipFileLessThan4096Bytes(SharedContext.Current.Site); } else { SignatureObject expectHeader = this.GetSHA1Signature(header); if (!expectHeader.Equals(nodeObject.Signature)) { site.Assert.Fail("For the Zip file header, expect the signature {0}, actual signature {1}", expectHeader.ToString(), nodeObject.Signature.ToString()); } // Remove the header node cloneList.RemoveAt(0); // Then expect the next is file content node nodeObject = cloneList.First(); // Here having something need to be distinguished between the MOSS2010 and MOSS2013 if (nodeObject.DataNodeObjectData == null && nodeObject.IntermediateNodeObjectList != null) { // This situation could most happens for MOSS2010, we fake intermediate node instead of the root node when the zip file size is larger than 1M. // In the current stage, this kind of signature algorithm is not mentioned in the open specification, so leave this verify blank. } else if (nodeObject.DataNodeObjectData != null) { site.Assert.AreEqual<ulong>( (ulong)compressedSize, nodeObject.DataSize.DataSize, "The Data Size of the Intermediate Node Object MUST be the total number of bytes represented by the chunk."); SignatureObject contentSignature = new SignatureObject(); contentSignature.SignatureData = new BinaryItem(dataFileSignatureBytes); if (!contentSignature.Equals(nodeObject.Signature)) { site.Assert.Fail("For the Zip file content, expect the signature {0}, actual signature {1}", contentSignature.ToString(), nodeObject.Signature.ToString()); } // Verify the zip file larger than 4096 bytes and less than 1MB. if (SharedContext.Current.IsMsFsshttpRequirementsCaptured) { MsfsshttpdCapture.VerifyZipFileHeaderAndContentSignature(SharedContext.Current.Site); MsfsshttpdCapture.VerifyIntermediateNodeForZipFileChunk(SharedContext.Current.Site); } } else { throw new InvalidOperationException("The DataNodeObjectData and IntermediateNodeObjectList cannot be null at the same time."); } } } } cloneList.RemoveAt(0); } }
/// <summary> /// This method is used to analyze the chunk. /// </summary> /// <param name="rootNode">Specify the root node object which will be analyzed.</param> /// <param name="site">Specify the ITestSite instance.</param> public override void AnalyzeChunking(RootNodeObject rootNode, ITestSite site) { List <IntermediateNodeObject> cloneList = new List <IntermediateNodeObject>(rootNode.IntermediateNodeObjectList); while (cloneList.Count != 0) { IntermediateNodeObject nodeObject = cloneList.First(); byte[] content = nodeObject.DataNodeObjectData.ObjectData; if (cloneList.Count == 1) { if (content.Length > 1048576) { throw new NotImplementedException("If the final chunk is larger than 1MB, the signature method is not implemented."); } // Only final chunk left SignatureObject expect = this.GetSHA1Signature(content); if (!expect.Equals(nodeObject.Signature)) { site.Assert.Fail("For the Zip file, final part chunk expect the signature {0}, actual signature {1}", expect.ToString(), nodeObject.Signature.ToString()); } // Verify the less than 1MB final part related requirements if (SharedContext.Current.IsMsFsshttpRequirementsCaptured) { MsfsshttpdCapture.VerifySmallFinalChunk(SharedContext.Current.Site); } } else { if (ZipHeader.IsFileHeader(content, 0)) { byte[] dataFileSignatureBytes; byte[] header = this.AnalyzeFileHeader(content, 0, out dataFileSignatureBytes); int headerLength = header.Length; int compressedSize = (int)this.GetCompressedSize(dataFileSignatureBytes); if (headerLength + compressedSize <= 4096) { IntermediateNodeObject expectNode = new IntermediateNodeObject.IntermediateNodeObjectBuilder().Build(content, this.GetSingleChunkSignature(header, dataFileSignatureBytes)); if (!expectNode.Signature.Equals(nodeObject.Signature)) { site.Assert.Fail("For the Zip file, when zip file is less than 4096, expect the signature {0}, actual signature {1}", expectNode.Signature.ToString(), nodeObject.Signature.ToString()); } // Verify the zip file less than 4096 bytes MsfsshttpdCapture.VerifyZipFileLessThan4096Bytes(SharedContext.Current.Site); } else { SignatureObject expectHeader = this.GetSHA1Signature(header); if (!expectHeader.Equals(nodeObject.Signature)) { site.Assert.Fail("For the Zip file header, expect the signature {0}, actual signature {1}", expectHeader.ToString(), nodeObject.Signature.ToString()); } // Remove the header node cloneList.RemoveAt(0); // Then expect the next is file content node nodeObject = cloneList.First(); // Here having something need to be distinguished between the MOSS2010 and MOSS2013 if (nodeObject.DataNodeObjectData == null && nodeObject.IntermediateNodeObjectList != null) { // This situation could most happens for MOSS2010, we fake intermediate node instead of the root node when the zip file size is larger than 1M. // In the current stage, this kind of signature algorithm is not mentioned in the open specification, so leave this verify blank. } else if (nodeObject.DataNodeObjectData != null) { site.Assert.AreEqual <ulong>( (ulong)compressedSize, nodeObject.DataSize.DataSize, "The Data Size of the Intermediate Node Object MUST be the total number of bytes represented by the chunk."); SignatureObject contentSignature = new SignatureObject(); contentSignature.SignatureData = new BinaryItem(dataFileSignatureBytes); if (!contentSignature.Equals(nodeObject.Signature)) { site.Assert.Fail("For the Zip file content, expect the signature {0}, actual signature {1}", contentSignature.ToString(), nodeObject.Signature.ToString()); } // Verify the zip file larger than 4096 bytes and less than 1MB. if (SharedContext.Current.IsMsFsshttpRequirementsCaptured) { MsfsshttpdCapture.VerifyZipFileHeaderAndContentSignature(SharedContext.Current.Site); MsfsshttpdCapture.VerifyIntermediateNodeForZipFileChunk(SharedContext.Current.Site); } } else { throw new InvalidOperationException("The DataNodeObjectData and IntermediateNodeObjectList cannot be null at the same time."); } } } } cloneList.RemoveAt(0); } }
/// <summary> /// Get signature with SHA1 algorithm. /// </summary> /// <param name="array">The input data.</param> /// <returns>An instance of SignatureObject.</returns> private SignatureObject GetSHA1Signature(byte[] array) { SHA1 sha = new SHA1CryptoServiceProvider(); byte[] temp = sha.ComputeHash(array); sha.Dispose(); SignatureObject signature = new SignatureObject(); signature.SignatureData = new BinaryItem(temp); return signature; }
/// <summary> /// Get a chunk with the input bytes. /// </summary> /// <param name="chunkStart">The start index of the chunk.</param> /// <param name="chunkEnd">The end index of the chunk.</param> /// <returns>An IntermediateNodeObject which contains a chunk.</returns> private IntermediateNodeObject GetChunk(uint chunkStart, uint chunkEnd) { if (chunkEnd <= chunkStart || (chunkEnd - chunkStart > this.maxChunkSize) || chunkStart > uint.MaxValue) { throw new ArgumentOutOfRangeException("chunkStart"); } byte[] temp = AdapterHelper.GetBytes(this.FileContent, (int)chunkStart, (int)(chunkEnd - chunkStart)); byte[] signatureBytes = null; using (RDCSignatureGenerator generator = new RDCSignatureGenerator()) { signatureBytes = generator.ComputeHash(temp); } SignatureObject signature = new SignatureObject(); signature.SignatureData = new BinaryItem(signatureBytes); return new IntermediateNodeObject.IntermediateNodeObjectBuilder().Build(temp, signature); }
/// <summary> /// This method is used to build intermediate node object from a byte array with a signature. /// </summary> /// <param name="array">Specify the byte array.</param> /// <param name="signature">Specify the signature.</param> /// <returns>Return the intermediate node object.</returns> public IntermediateNodeObject Build(byte[] array, SignatureObject signature) { IntermediateNodeObject nodeObject = new IntermediateNodeObject(); nodeObject.DataSize = new DataSizeObject(); nodeObject.DataSize.DataSize = (ulong)array.Length; nodeObject.Signature = signature; nodeObject.ExGuid = new ExGuid(SequenceNumberGenerator.GetCurrentSerialNumber(), Guid.NewGuid()); nodeObject.DataNodeObjectData = new DataNodeObjectData(array, 0, array.Length); nodeObject.IntermediateNodeObjectList = null; // Now in the current implementation, one intermediate node only contain one single data object node. return nodeObject; }