/// <summary>
/// Recalculate the checksum
/// </summary>
public override void UpdateCalculatedValues()
{
if (skipUpdating)
{
return;
}
// prevent us from entering this routine twice
// by setting this flag, the act of retrieving the Bytes
// property will cause this routine to be called which will
// retrieve Bytes recursively and overflow the stack
skipUpdating = true;
// start with this packet with a zeroed out checksum field
Checksum = 0;
var originalBytes = Bytes;
var ipv6Parent = ParentPacket as IPv6Packet;
var bytesToChecksum = ipv6Parent.AttachPseudoIPHeader(originalBytes);
// calculate the one's complement sum of the tcp header
Checksum = (ushort)ChecksumUtils.OnesComplementSum(bytesToChecksum);
// clear the skip variable
skipUpdating = false;
}
/// <summary>
/// Calculates the transport layer checksum, either for the
/// tcp or udp packet
/// </summary>
/// <param name="option">
/// <see cref="TransportChecksumOption" />
/// </param>
/// <returns>
/// A <see cref="int" />
/// </returns>
internal int CalculateChecksum(TransportChecksumOption option)
{
// save the checksum field value so it can be restored, altering the checksum is not
// an intended side effect of this method
var originalChecksum = Checksum;
// reset the checksum field (checksum is calculated when this field is
// zeroed)
Checksum = 0;
// copy the tcp section with data
var dataToChecksum = ((IPPacket)ParentPacket).PayloadPacket.BytesSegment;
var bytes = option == TransportChecksumOption.IncludePseudoIPHeader
? ((IPPacket)ParentPacket).GetPseudoIPHeader(dataToChecksum.Length)
: new byte[0];
// calculate the one's complement sum of the tcp header
var cs = ChecksumUtils.OnesComplementSum(dataToChecksum, bytes);
// restore the checksum field value
Checksum = originalChecksum;
return(cs);
}
/// <summary>
/// Determine if the transport layer checksum is valid
/// </summary>
/// <param name="option">
/// A <see cref="TransportChecksumOption" />
/// </param>
/// <returns>
/// A <see cref="bool" />
/// </returns>
public virtual bool IsValidChecksum(TransportChecksumOption option)
{
var dataToChecksum = ((IPPacket)ParentPacket).PayloadPacket.BytesSegment;
if (dataToChecksum.Offset + dataToChecksum.Length > dataToChecksum.BytesLength)
{
return(false);
}
var bytes = option == TransportChecksumOption.IncludePseudoIPHeader
? ((IPPacket)ParentPacket).GetPseudoIPHeader(dataToChecksum.Length)
: new byte[0];
var onesSum = ChecksumUtils.OnesSum(dataToChecksum, bytes);
Log.DebugFormat("option: {0}, byteArrayCombination.Length {1}",
option,
bytes.Length);
const int expectedOnesSum = 0xFFFF;
Log.DebugFormat("onesSum {0} expected {1}",
onesSum,
expectedOnesSum);
return(onesSum == expectedOnesSum);
}
private static byte[] CalculateCrc(byte[] buffer)
{
var crc = ChecksumUtils.CalculateCrc(buffer, 1, 10);
var crcBytes = BitConverter.GetBytes(crc);
return(crcBytes);
}
[DataRow(true, CoreChecksumAlgorithm.SHA256, "x-amz-checksum-crc32", "x-amz-checksum-crc32")] // Checksum specified but another was set, still calculate it anyway.
public void TestRequestChecksumSelection(bool fallbackToMD5, CoreChecksumAlgorithm checksumAlgorithm, string originalHeaderKey, string expectedHeaderKey)
{
var mock = new Mock <IRequest>();
var headers = new Dictionary <string, string>();
var request = mock.Object;
mock.SetupGet(x => x.Headers).Returns(headers);
mock.SetupGet(x => x.Content).Returns(Encoding.ASCII.GetBytes("foo"));
if (!string.IsNullOrEmpty(originalHeaderKey))
{
headers.Add(originalHeaderKey, "foo");
}
ChecksumUtils.SetRequestChecksum(request, checksumAlgorithm.ToString(), fallbackToMD5);
if (!string.IsNullOrEmpty(expectedHeaderKey))
{
Assert.IsTrue(request.Headers.ContainsKey(expectedHeaderKey));
Assert.IsFalse(string.IsNullOrEmpty(request.Headers[expectedHeaderKey]));
}
else
{
Assert.AreEqual(0, request.Headers.Count);
}
}
protected void SetupFlexibleChecksumStream(IWebResponseData responseData, Stream responseStream, long contentLength, IRequestContext requestContext)
{
var algorithm = ChecksumUtils.SelectChecksumForResponseValidation(requestContext?.OriginalRequest?.ChecksumResponseAlgorithms, responseData);
if (algorithm == CoreChecksumAlgorithm.NONE)
{
return;
}
ChecksumAlgorithm = algorithm;
ExpectedFlexibleChecksumResult = responseData.GetHeaderValue(ChecksumUtils.GetChecksumHeaderKey(algorithm));
var checksum = Convert.FromBase64String(ExpectedFlexibleChecksumResult);
switch (algorithm)
{
case CoreChecksumAlgorithm.CRC32C:
FlexibleChecksumStream = new HashStream <HashingWrapperCRC32C>(responseStream, checksum, contentLength);
break;
case CoreChecksumAlgorithm.CRC32:
FlexibleChecksumStream = new HashStream <HashingWrapperCRC32>(responseStream, checksum, contentLength);
break;
case CoreChecksumAlgorithm.SHA256:
FlexibleChecksumStream = new HashStream <HashingWrapperSHA256>(responseStream, checksum, contentLength);
break;
case CoreChecksumAlgorithm.SHA1:
FlexibleChecksumStream = new HashStream <HashingWrapperSHA1>(responseStream, checksum, contentLength);
break;
default:
throw new AmazonClientException($"Unsupported checksum algorithm {algorithm}");
}
}
public IRequest Marshall(RestoreObjectRequest restoreObjectRequest)
{
IRequest request = new DefaultRequest(restoreObjectRequest, "AmazonS3");
request.HttpMethod = "POST";
if (restoreObjectRequest.IsSetRequestPayer())
{
request.Headers.Add(S3Constants.AmzHeaderRequestPayer, S3Transforms.ToStringValue(restoreObjectRequest.RequestPayer.ToString()));
}
if (restoreObjectRequest.IsSetExpectedBucketOwner())
{
request.Headers.Add(S3Constants.AmzHeaderExpectedBucketOwner, S3Transforms.ToStringValue(restoreObjectRequest.ExpectedBucketOwner));
}
if (string.IsNullOrEmpty(restoreObjectRequest.BucketName))
{
throw new System.ArgumentException("BucketName is a required property and must be set before making this call.", "RestoreObjectRequest.BucketName");
}
if (string.IsNullOrEmpty(restoreObjectRequest.Key))
{
throw new System.ArgumentException("Key is a required property and must be set before making this call.", "RestoreObjectRequest.Key");
}
request.ResourcePath = string.Format(CultureInfo.InvariantCulture, "/{0}/{1}",
S3Transforms.ToStringValue(restoreObjectRequest.BucketName),
S3Transforms.ToStringValue(restoreObjectRequest.Key));
request.AddSubResource("restore");
if (restoreObjectRequest.IsSetVersionId())
{
request.AddSubResource("versionId", S3Transforms.ToStringValue(restoreObjectRequest.VersionId));
}
var stringWriter = new XMLEncodedStringWriter(System.Globalization.CultureInfo.InvariantCulture);
using (var xmlWriter = XmlWriter.Create(stringWriter, new XmlWriterSettings()
{
Encoding = Encoding.UTF8, OmitXmlDeclaration = true, NewLineHandling = NewLineHandling.Entitize
}))
{
restoreObjectRequest.Marshall("RestoreRequest", xmlWriter);
}
try
{
var content = stringWriter.ToString();
request.Content = Encoding.UTF8.GetBytes(content);
request.Headers[HeaderKeys.ContentTypeHeader] = "application/xml";
ChecksumUtils.SetRequestChecksum(request, restoreObjectRequest.ChecksumAlgorithm, fallbackToMD5: false);
}
catch (EncoderFallbackException e)
{
throw new AmazonServiceException("Unable to marshall request to XML", e);
}
return(request);
}
/// <summary>
/// Calculates the transport layer checksum, either for the
/// tcp or udp packet
/// </summary>
/// <param name="option"><see cref="TransportPacket.TransportChecksumOption"/></param>
/// <returns>
/// A <see cref="System.Int32"/>
/// </returns>
internal int CalculateChecksum(TransportChecksumOption option)
{
// save the checksum field value so it can be restored, altering the checksum is not
// an intended side effect of this method
var originalChecksum = Checksum;
// reset the checksum field (checksum is calculated when this field is
// zeroed)
Checksum = 0;
// copy the tcp section with data
byte[] dataToChecksum = ((IpPacket)ParentPacket).PayloadPacket.Bytes;
if (option == TransportChecksumOption.AttachPseudoIPHeader)
{
dataToChecksum = ((IpPacket)ParentPacket).AttachPseudoIPHeader(dataToChecksum);
}
// calculate the one's complement sum of the tcp header
int cs = ChecksumUtils.OnesComplementSum(dataToChecksum);
// restore the checksum field value
Checksum = originalChecksum;
return(cs);
}
public IRequest Marshall(PutBucketRequestPaymentRequest putBucketRequestPaymentRequest)
{
IRequest request = new DefaultRequest(putBucketRequestPaymentRequest, "AmazonS3");
request.HttpMethod = "PUT";
if (putBucketRequestPaymentRequest.IsSetChecksumAlgorithm())
{
request.Headers.Add(S3Constants.AmzHeaderSdkChecksumAlgorithm, S3Transforms.ToStringValue(putBucketRequestPaymentRequest.ChecksumAlgorithm));
}
if (putBucketRequestPaymentRequest.IsSetExpectedBucketOwner())
{
request.Headers.Add(S3Constants.AmzHeaderExpectedBucketOwner, S3Transforms.ToStringValue(putBucketRequestPaymentRequest.ExpectedBucketOwner));
}
if (string.IsNullOrEmpty(putBucketRequestPaymentRequest.BucketName))
{
throw new System.ArgumentException("BucketName is a required property and must be set before making this call.", "PutBucketRequestPaymentRequest.BucketName");
}
request.ResourcePath = string.Concat("/", S3Transforms.ToStringValue(putBucketRequestPaymentRequest.BucketName));
request.AddSubResource("requestPayment");
var stringWriter = new XMLEncodedStringWriter(System.Globalization.CultureInfo.InvariantCulture);
using (var xmlWriter = XmlWriter.Create(stringWriter, new XmlWriterSettings()
{
Encoding = Encoding.UTF8, OmitXmlDeclaration = true, NewLineHandling = NewLineHandling.Entitize
}))
{
var requestPaymentConfigurationRequestPaymentConfiguration = putBucketRequestPaymentRequest.RequestPaymentConfiguration;
if (requestPaymentConfigurationRequestPaymentConfiguration != null)
{
xmlWriter.WriteStartElement("RequestPaymentConfiguration", "");
if (requestPaymentConfigurationRequestPaymentConfiguration.IsSetPayer())
{
xmlWriter.WriteElementString("Payer", "", S3Transforms.ToXmlStringValue(requestPaymentConfigurationRequestPaymentConfiguration.Payer));
}
xmlWriter.WriteEndElement();
}
}
try
{
var content = stringWriter.ToString();
request.Content = Encoding.UTF8.GetBytes(content);
request.Headers[HeaderKeys.ContentTypeHeader] = "application/xml";
ChecksumUtils.SetRequestChecksum(request, putBucketRequestPaymentRequest.ChecksumAlgorithm);
}
catch (EncoderFallbackException e)
{
throw new AmazonServiceException("Unable to marshall request to XML", e);
}
return(request);
}
public virtual bool IsValidChecksum(TransportChecksumOption option)
{
byte[] bytes = ((IpPacket)this.ParentPacket).PayloadPacket.Bytes;
if (option == TransportChecksumOption.AttachPseudoIPHeader)
{
bytes = ((IpPacket)this.ParentPacket).AttachPseudoIPHeader(bytes);
}
return(ChecksumUtils.OnesSum(bytes) == 0xffff);
}
internal int CalculateChecksum(TransportChecksumOption option)
{
this.Checksum = 0;
byte[] bytes = ((IpPacket)this.ParentPacket).PayloadPacket.Bytes;
if (option == TransportChecksumOption.AttachPseudoIPHeader)
{
bytes = ((IpPacket)this.ParentPacket).AttachPseudoIPHeader(bytes);
}
return(ChecksumUtils.OnesComplementSum(bytes));
}
public int CalculateIPChecksum()
{
byte[] header = this.Header;
byte[] destinationArray = new byte[header.Length];
Array.Copy(header, destinationArray, header.Length);
ushort num = 0;
EndianBitConverter.Big.CopyBytes(num, destinationArray, IPv4Fields.ChecksumPosition);
return(ChecksumUtils.OnesComplementSum(destinationArray, 0, destinationArray.Length));
}
public void CalculateFletcherSumForSampleMessage()
{
byte[] message = new byte[] { 0x07, 0x84, 0x09, 0x7E, 0x10, 0x58, 0x01, 0x00 };
byte[] expectedChecksum = new byte[] { 0x7C, 0xD1 };
byte[] fletcherSum = ChecksumUtils.CalculateFletcher16Checksum(message);
CollectionAssert.AreEqual(expectedChecksum, fletcherSum);
}
public void CalculateFletcherSumForTwoByteMessage()
{
byte[] message = new byte[] { 0x01, 0x02 };
byte[] expectedChecksum = new byte[] { 0x03, 0x04 };
byte[] fletcherSum = ChecksumUtils.CalculateFletcher16Checksum(message);
CollectionAssert.AreEqual(expectedChecksum, fletcherSum);
}
public void CanCalculateHash(string key, uint expected)
{
// Arrange
// Act
var actual = ChecksumUtils.JenkinsLookup3(key);
// Assert
Assert.Equal(expected, actual);
}
public void CrcUtilReturnProperValue()
{
var payload = new byte[] { 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
Assert.Equal(12, payload.Length);
ushort crc = ChecksumUtils.CalculateCrc(payload);
Assert.Equal(65120, crc);
}
public void CalculateFletcherSumForTwoByteMessageWithOverflow()
{
byte[] message = new byte[] { 0xF1, 0xF2 };
byte[] expectedChecksum = new byte[] { 0xE4, 0xD6 };
byte[] fletcherSum = ChecksumUtils.CalculateFletcher16Checksum(message);
CollectionAssert.AreEqual(expectedChecksum, fletcherSum);
}
public virtual bool IsValidTransportLayerChecksum(bool pseudoIPHeader)
{
byte[] upperLayer = IPData;
if (pseudoIPHeader)
{
upperLayer = AttachPseudoIPHeader(upperLayer);
}
int onesSum = ChecksumUtils.OnesSum(upperLayer);
return(onesSum == 0xFFFF);
}
/// <summary>
/// Marshall PutObjectTaggingRequest into an http request.
/// </summary>
public IRequest Marshall(PutObjectTaggingRequest putObjectTaggingRequest)
{
IRequest request = new DefaultRequest(putObjectTaggingRequest, "AmazonS3");
request.HttpMethod = "PUT";
if (putObjectTaggingRequest.IsSetChecksumAlgorithm())
{
request.Headers.Add(S3Constants.AmzHeaderSdkChecksumAlgorithm, S3Transforms.ToStringValue(putObjectTaggingRequest.ChecksumAlgorithm));
}
if (putObjectTaggingRequest.IsSetExpectedBucketOwner())
{
request.Headers.Add(S3Constants.AmzHeaderExpectedBucketOwner, S3Transforms.ToStringValue(putObjectTaggingRequest.ExpectedBucketOwner));
}
if (putObjectTaggingRequest.IsSetRequestPayer())
{
request.Headers.Add(S3Constants.AmzHeaderRequestPayer, S3Transforms.ToStringValue(putObjectTaggingRequest.RequestPayer));
}
if (string.IsNullOrEmpty(putObjectTaggingRequest.BucketName))
{
throw new System.ArgumentException("BucketName is a required property and must be set before making this call.", "PutObjectTaggingRequest.BucketName");
}
if (string.IsNullOrEmpty(putObjectTaggingRequest.Key))
{
throw new System.ArgumentException("Key is a required property and must be set before making this call.", "PutObjectTaggingRequest.Key");
}
request.ResourcePath = string.Format(CultureInfo.InvariantCulture, "/{0}/{1}",
S3Transforms.ToStringValue(putObjectTaggingRequest.BucketName),
S3Transforms.ToStringValue(putObjectTaggingRequest.Key));
request.AddSubResource("tagging");
if (putObjectTaggingRequest.IsSetVersionId())
{
request.AddSubResource("versionId", putObjectTaggingRequest.VersionId);
}
try
{
var content = AmazonS3Util.SerializeTaggingToXml(putObjectTaggingRequest.Tagging);
request.Content = Encoding.UTF8.GetBytes(content);
request.Headers[HeaderKeys.ContentTypeHeader] = "application/xml";
ChecksumUtils.SetRequestChecksum(request, putObjectTaggingRequest.ChecksumAlgorithm);
}
catch (EncoderFallbackException e)
{
throw new AmazonServiceException("Unable to marhsall request to XML", e);
}
return(request);
}
public void ResponseChecksumSelection_NoChecksumsReturned()
{
var operationSupportedChecksums = new List <CoreChecksumAlgorithm>
{
CoreChecksumAlgorithm.CRC32,
CoreChecksumAlgorithm.CRC32C
};
var responseData = new WebResponseData();
// No checksum headers on the response, so we cannot choose one to validate
Assert.AreEqual(CoreChecksumAlgorithm.NONE,
ChecksumUtils.SelectChecksumForResponseValidation(operationSupportedChecksums, responseData));
}
/// <summary>
/// Determine if the transport layer checksum is valid
/// </summary>
/// <param name="option">
/// A <see cref="TransportChecksumOption"/>
/// </param>
/// <returns>
/// A <see cref="System.Boolean"/>
/// </returns>
public virtual bool IsValidChecksum(TransportChecksumOption option)
{
var upperLayer = ((IpPacket)ParentPacket).PayloadPacket.Bytes;
if (option == TransportChecksumOption.AttachPseudoIPHeader)
{
upperLayer = ((IpPacket)ParentPacket).AttachPseudoIPHeader(upperLayer);
}
var onesSum = ChecksumUtils.OnesSum(upperLayer);
const int expectedOnesSum = 0xffff;
return(onesSum == expectedOnesSum);
}
/// <summary> Computes the IP checksum, optionally updating the IP checksum header.
///
/// </summary>
/// <param name="update">Specifies whether or not to update the IP checksum
/// header after computing the checksum. A value of true indicates
/// the header should be updated, a value of false indicates it
/// should not be updated.
/// </param>
/// <returns> The computed IP checksum.
/// </returns>
public int ComputeIPChecksum(bool update)
{
//copy the ip header
byte[] ip = ArrayHelper.copy(Bytes, _ethPayloadOffset, IPHeaderLength);
//reset the checksum field (checksum is calculated when this field is zeroed)
ArrayHelper.insertLong(ip, 0, IPv4Fields_Fields.IP_CSUM_POS, 2);
//compute the one's complement sum of the ip header
int cs = ChecksumUtils.OnesComplementSum(ip, 0, ip.Length);
if (update)
{
IPChecksum = cs;
}
return(cs);
}
private void ScanFiles()
{
// If no includes were specified, add all files and subdirectories
// from the fileset's base directory to the fileset.
if ((FileSet.Includes.Count == 0) && (FileSet.AsIs.Count == 0))
{
FileSet.Includes.Add("**/*.dll");
// Make sure to rescan the fileset
FileSet.Scan();
}
AgentProjectInfo projectInfo = new AgentProjectInfo();
if (String.IsNullOrEmpty(ProjectToken))
{
projectInfo.Coordinates = new Coordinates(null, Project.ProjectName, null);
}
else
{
projectInfo.ProjectToken = ProjectToken;
}
// scan files and calculate SHA-1 values
List <DependencyInfo> dependencies = projectInfo.Dependencies;
foreach (String pathname in FileSet.FileNames)
{
FileInfo srcInfo = new FileInfo(pathname);
if (srcInfo.Exists)
{
String sha1 = ChecksumUtils.GetSha1Hash(pathname);
String filename = srcInfo.Name;
Log(Level.Debug, "SHA-1 for " + filename + " is: " + sha1);
DependencyInfo dependency = new DependencyInfo();
dependency.Sha1 = sha1;
dependency.ArtifactId = filename;
dependency.SystemPath = pathname;
dependencies.Add(dependency);
}
}
Log(Level.Info, "Found " + dependencies.Count + " direct dependencies");
projects.Add(projectInfo);
}
/// <summary>
/// Determine if the transport layer checksum is valid
/// </summary>
/// <param name="option">
/// A <see cref="TransportChecksumOption" />
/// </param>
/// <returns>
/// A <see cref="System.Boolean" />
/// </returns>
public virtual bool IsValidChecksum(TransportChecksumOption option)
{
var upperLayer = ((IpPacket)this.ParentPacket).PayloadPacket.Bytes;
log.DebugFormat("option: {0}, upperLayer.Length {1}", option, upperLayer.Length);
if (option == TransportChecksumOption.AttachPseudoIPHeader)
{
upperLayer = ((IpPacket)this.ParentPacket).AttachPseudoIPHeader(upperLayer);
}
var onesSum = ChecksumUtils.OnesSum(upperLayer);
const int expectedOnesSum = 0xffff;
log.DebugFormat("onesSum {0} expected {1}", onesSum, expectedOnesSum);
return(onesSum == expectedOnesSum);
}
public void ResponseChecksumSelection_SingleChecksum()
{
var operationSupportedChecksums = new List <CoreChecksumAlgorithm>
{
CoreChecksumAlgorithm.SHA256,
CoreChecksumAlgorithm.CRC32
};
var responseData = new WebResponseData();
responseData.Headers = new Dictionary <string, string>
{
{ "x-amz-checksum-sha256", "checksum" }
};
// Even though CRC32 is supported and comes first in priority order, only SHA256 is returned from service
Assert.AreEqual(CoreChecksumAlgorithm.SHA256,
ChecksumUtils.SelectChecksumForResponseValidation(operationSupportedChecksums, responseData));
}
public void TestResponseChecksumSelection_UnsupportedChecksum()
{
var operationSupportedChecksums = new List <CoreChecksumAlgorithm>
{
CoreChecksumAlgorithm.SHA256,
CoreChecksumAlgorithm.CRC32
};
var responseData = new WebResponseData();
responseData.Headers = new Dictionary <string, string>
{
{ "x-amz-checksum-crc64", "checksum" }
};
// CRC64 is not currently supported by the SDK
Assert.AreEqual(CoreChecksumAlgorithm.NONE,
ChecksumUtils.SelectChecksumForResponseValidation(operationSupportedChecksums, responseData));
}
public void CrcUtilOverloadedMethodsReturnEqualValues()
{
var frame = new byte[] { 0x03, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x61, 0x3E };
Assert.Equal(16, frame.Length);
var payload = new byte[12];
Buffer.BlockCopy(frame, 1, payload, 0, 12);
var crc = ChecksumUtils.CalculateCrc(payload);
Assert.Equal(65120, crc);
var crc2 = ChecksumUtils.CalculateCrc(frame, 1, 12);
Assert.Equal(crc, crc2);
}
/// <summary>
/// Calculates the IP checksum, optionally updating the IP checksum header.
/// </summary>
/// <returns>
/// The calculated IP checksum.
/// </returns>
public ushort CalculateIPChecksum()
{
//copy the ip header
var theHeader = this.Header;
var ip = new byte[theHeader.Length];
Array.Copy(theHeader, ip, theHeader.Length);
//reset the checksum field (checksum is calculated when this field is zeroed)
var theValue = (UInt16)0;
EndianBitConverter.Big.CopyBytes(theValue, ip, IPv4Fields.ChecksumPosition);
//calculate the one's complement sum of the ip header
var cs = ChecksumUtils.OnesComplementSum(ip, 0, ip.Length);
return((ushort)cs);
}
public void TestResponseChecksumSelection_Priority()
{
var operationSupportedChecksums = new List <CoreChecksumAlgorithm>
{
CoreChecksumAlgorithm.SHA256,
CoreChecksumAlgorithm.CRC32
};
var responseData = new WebResponseData();
responseData.Headers = new Dictionary <string, string>
{
{ "x-amz-checksum-sha256", "checksum" },
{ "x-amz-checksum-crc32", "checksum" }
};
// CRC32 should take priority over SHA256 when both are returned
Assert.AreEqual(CoreChecksumAlgorithm.CRC32,
ChecksumUtils.SelectChecksumForResponseValidation(operationSupportedChecksums, responseData));
}
private void updateIPChecksums(ref byte[] data)
{
int header_len = (data[IP_HEADER_IHL_OFFSET] & 0x0F) * 4;
//reset the checksum field (checksum is calculated when this field is zeroed)
data[IP_HEADER_CHECKSUM_OFFSET] = 0;
data[IP_HEADER_CHECKSUM_OFFSET + 1] = 0;
//calculate the one's complement sum of the ip header
var val = (UInt16)ChecksumUtils.OnesComplementSum(data, IP_HEADER_IHL_OFFSET, header_len);
EndianBitConverter.Big.CopyBytes(val, data, IP_HEADER_CHECKSUM_OFFSET);
// disable UDP checksum
if (data[IP_HEADER_PROTOCOL_OFFSET] == (byte)IPProtocolType.UDP)
{
data[IP_HEADER_IHL_OFFSET + header_len + UDP_HEADER_CHECKSUM_OFFSET] = 0;
data[IP_HEADER_IHL_OFFSET + header_len + UDP_HEADER_CHECKSUM_OFFSET + 1] = 0;
}
}
