|
public static ReverseEndian ( |
||
| val | ||
| Résultat | ||
public STUNv2Attribute(STUNv2AttributeTypesEnum attributeType, int value)
{
AttributeType = attributeType;
if (BitConverter.IsLittleEndian)
{
Value = BitConverter.GetBytes(Utility.ReverseEndian(Convert.ToUInt32(value)));
}
else
{
Value = BitConverter.GetBytes(value);
}
}
public STUNv2AddressAttribute(byte[] attributeValue)
: base(STUNv2AttributeTypesEnum.MappedAddress, attributeValue)
{
if (BitConverter.IsLittleEndian)
{
Port = Utility.ReverseEndian(BitConverter.ToUInt16(attributeValue, 2));
}
else
{
Port = BitConverter.ToUInt16(attributeValue, 2);
}
Address = new IPAddress(new byte[] { attributeValue[4], attributeValue[5], attributeValue[6], attributeValue[7] });
}
public STUNv2XORAddressAttribute(STUNv2AttributeTypesEnum attributeType, byte[] attributeValue)
: base(attributeType, attributeValue)
{
if (BitConverter.IsLittleEndian)
{
Port = Utility.ReverseEndian(BitConverter.ToUInt16(attributeValue, 2)) ^ (UInt16)(STUNv2Header.MAGIC_COOKIE >> 16);
UInt32 address = Utility.ReverseEndian(BitConverter.ToUInt32(attributeValue, 4)) ^ STUNv2Header.MAGIC_COOKIE;
Address = new IPAddress(Utility.ReverseEndian(address));
}
else
{
Port = BitConverter.ToUInt16(attributeValue, 2) ^ (UInt16)(STUNv2Header.MAGIC_COOKIE >> 16);
UInt32 address = BitConverter.ToUInt32(attributeValue, 4) ^ STUNv2Header.MAGIC_COOKIE;
Address = new IPAddress(address);
}
}
public virtual int ToByteBuffer(byte[] buffer, int startIndex)
{
if (BitConverter.IsLittleEndian)
{
Buffer.BlockCopy(BitConverter.GetBytes(Utility.ReverseEndian((ushort)AttributeType)), 0, buffer, startIndex, 2);
if (Value != null && Value.Length > 0)
{
Buffer.BlockCopy(BitConverter.GetBytes(Utility.ReverseEndian(Convert.ToUInt16(Value.Length))), 0, buffer, startIndex + 2, 2);
}
else
{
buffer[startIndex + 2] = 0x00;
buffer[startIndex + 3] = 0x00;
}
}
else
{
Buffer.BlockCopy(BitConverter.GetBytes((ushort)AttributeType), 0, buffer, startIndex, 2);
if (Value != null && Value.Length > 0)
{
Buffer.BlockCopy(BitConverter.GetBytes(Convert.ToUInt16(Value.Length)), 0, buffer, startIndex + 2, 2);
}
else
{
buffer[startIndex + 2] = 0x00;
buffer[startIndex + 3] = 0x00;
}
}
if (Value != null && Value.Length > 0)
{
Buffer.BlockCopy(Value, 0, buffer, startIndex + 4, Value.Length);
}
return(STUNv2Attribute.STUNATTRIBUTE_HEADER_LENGTH + PaddedLength);
}
public virtual int ToByteBuffer(byte[] buffer, int startIndex)
{
if (BitConverter.IsLittleEndian)
{
Buffer.BlockCopy(BitConverter.GetBytes(Utility.ReverseEndian((ushort)AttributeType)), 0, buffer, startIndex, 2);
Buffer.BlockCopy(BitConverter.GetBytes(Utility.ReverseEndian(Length)), 0, buffer, startIndex + 2, 2);
}
else
{
Buffer.BlockCopy(BitConverter.GetBytes((ushort)AttributeType), 0, buffer, startIndex, 2);
Buffer.BlockCopy(BitConverter.GetBytes(Length), 0, buffer, startIndex + 2, 2);
}
if (BitConverter.IsLittleEndian)
{
Buffer.BlockCopy(Value, 0, buffer, startIndex + 4, Length);
}
else
{
Buffer.BlockCopy(Value, 0, buffer, startIndex + 4, Length);
}
return(STUNAttribute.STUNATTRIBUTE_HEADER_LENGTH + Length);
}
public byte[] ToByteBuffer(byte[] messageIntegrityKey, bool addFingerprint)
{
UInt16 attributesLength = 0;
foreach (STUNv2Attribute attribute in Attributes)
{
attributesLength += Convert.ToUInt16(STUNv2Attribute.STUNATTRIBUTE_HEADER_LENGTH + attribute.PaddedLength);
}
if (messageIntegrityKey != null)
{
attributesLength += STUNv2Attribute.STUNATTRIBUTE_HEADER_LENGTH + MESSAGE_INTEGRITY_ATTRIBUTE_HMAC_LENGTH;
}
int messageLength = STUNv2Header.STUN_HEADER_LENGTH + attributesLength;
byte[] buffer = new byte[messageLength];
if (BitConverter.IsLittleEndian)
{
Buffer.BlockCopy(BitConverter.GetBytes(Utility.ReverseEndian((UInt16)Header.MessageType)), 0, buffer, 0, 2);
Buffer.BlockCopy(BitConverter.GetBytes(Utility.ReverseEndian(attributesLength)), 0, buffer, 2, 2);
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(STUNv2Header.MAGIC_COOKIE)), 0, buffer, 4, 4);
}
else
{
Buffer.BlockCopy(BitConverter.GetBytes((UInt16)Header.MessageType), 0, buffer, 0, 2);
Buffer.BlockCopy(BitConverter.GetBytes(attributesLength), 0, buffer, 2, 2);
Buffer.BlockCopy(BitConverter.GetBytes(STUNv2Header.MAGIC_COOKIE), 0, buffer, 4, 4);
}
Buffer.BlockCopy(Header.TransactionId, 0, buffer, 8, STUNv2Header.TRANSACTION_ID_LENGTH);
int attributeIndex = 20;
foreach (STUNv2Attribute attr in Attributes)
{
attributeIndex += attr.ToByteBuffer(buffer, attributeIndex);
}
//logger.LogDebug($"Pre HMAC STUN message: {ByteBufferInfo.HexStr(buffer, attributeIndex)}");
if (messageIntegrityKey != null)
{
var integrityAttibtue = new STUNv2Attribute(STUNv2AttributeTypesEnum.MessageIntegrity, new byte[MESSAGE_INTEGRITY_ATTRIBUTE_HMAC_LENGTH]);
HMACSHA1 hmacSHA = new HMACSHA1(messageIntegrityKey, true);
byte[] hmac = hmacSHA.ComputeHash(buffer, 0, attributeIndex);
integrityAttibtue.Value = hmac;
attributeIndex += integrityAttibtue.ToByteBuffer(buffer, attributeIndex);
}
if (addFingerprint)
{
// The fingerprint attribute length has not been included in the length in the STUN header so adjust it now.
attributesLength += STUNv2Attribute.STUNATTRIBUTE_HEADER_LENGTH + FINGERPRINT_ATTRIBUTE_CRC32_LENGTH;
messageLength += STUNv2Attribute.STUNATTRIBUTE_HEADER_LENGTH + FINGERPRINT_ATTRIBUTE_CRC32_LENGTH;
if (BitConverter.IsLittleEndian)
{
Buffer.BlockCopy(BitConverter.GetBytes(Utility.ReverseEndian(attributesLength)), 0, buffer, 2, 2);
}
else
{
Buffer.BlockCopy(BitConverter.GetBytes(attributesLength), 0, buffer, 2, 2);
}
var fingerprintAttribute = new STUNv2Attribute(STUNv2AttributeTypesEnum.FingerPrint, new byte[FINGERPRINT_ATTRIBUTE_CRC32_LENGTH]);
uint crc = Crc32.Compute(buffer) ^ FINGERPRINT_XOR;
byte[] fingerPrint = (BitConverter.IsLittleEndian) ? BitConverter.GetBytes(NetConvert.DoReverseEndian(crc)) : BitConverter.GetBytes(crc);
fingerprintAttribute.Value = fingerPrint;
Array.Resize(ref buffer, messageLength);
fingerprintAttribute.ToByteBuffer(buffer, attributeIndex);
}
return(buffer);
}
public static List <STUNv2Attribute> ParseMessageAttributes(byte[] buffer, int startIndex, int endIndex)
{
if (buffer != null && buffer.Length > startIndex && buffer.Length >= endIndex)
{
List <STUNv2Attribute> attributes = new List <STUNv2Attribute>();
int startAttIndex = startIndex;
while (startAttIndex < endIndex)
{
UInt16 stunAttributeType = BitConverter.ToUInt16(buffer, startAttIndex);
UInt16 stunAttributeLength = BitConverter.ToUInt16(buffer, startAttIndex + 2);
byte[] stunAttributeValue = null;
if (BitConverter.IsLittleEndian)
{
stunAttributeType = Utility.ReverseEndian(stunAttributeType);
stunAttributeLength = Utility.ReverseEndian(stunAttributeLength);
}
if (stunAttributeLength > 0)
{
if (stunAttributeLength + startIndex + 4 > endIndex)
{
logger.LogWarning("The attribute length on a STUN parameter was greater than the available number of bytes.");
}
else
{
stunAttributeValue = new byte[stunAttributeLength];
Buffer.BlockCopy(buffer, startAttIndex + 4, stunAttributeValue, 0, stunAttributeLength);
}
}
STUNv2AttributeTypesEnum attributeType = STUNv2AttributeTypes.GetSTUNAttributeTypeForId(stunAttributeType);
STUNv2Attribute attribute = null;
if (attributeType == STUNv2AttributeTypesEnum.ChangeRequest)
{
attribute = new STUNv2ChangeRequestAttribute(stunAttributeValue);
}
else if (attributeType == STUNv2AttributeTypesEnum.MappedAddress)
{
attribute = new STUNv2AddressAttribute(stunAttributeValue);
}
else if (attributeType == STUNv2AttributeTypesEnum.ErrorCode)
{
attribute = new STUNv2ErrorCodeAttribute(stunAttributeValue);
}
else if (attributeType == STUNv2AttributeTypesEnum.XORMappedAddress || attributeType == STUNv2AttributeTypesEnum.XORPeerAddress || attributeType == STUNv2AttributeTypesEnum.XORRelayedAddress)
{
attribute = new STUNv2XORAddressAttribute(attributeType, stunAttributeValue);
}
else
{
attribute = new STUNv2Attribute(attributeType, stunAttributeValue);
}
attributes.Add(attribute);
// Attributes start on 32 bit word boundaries so where an attribute length is not a multiple of 4 it gets padded.
int padding = (stunAttributeLength % 4 != 0) ? 4 - (stunAttributeLength % 4) : 0;
startAttIndex = startAttIndex + 4 + stunAttributeLength + padding;
}
return(attributes);
}
else
{
return(null);
}
}
public static List <STUNAttribute> ParseMessageAttributes(byte[] buffer, int startIndex, int endIndex)
{
if (buffer != null && buffer.Length > startIndex && buffer.Length >= endIndex)
{
List <STUNAttribute> attributes = new List <STUNAttribute>();
int startAttIndex = startIndex;
while (startAttIndex < endIndex)
{
UInt16 stunAttributeType = BitConverter.ToUInt16(buffer, startAttIndex);
UInt16 stunAttributeLength = BitConverter.ToUInt16(buffer, startAttIndex + 2);
byte[] stunAttributeValue = null;
if (BitConverter.IsLittleEndian)
{
stunAttributeType = Utility.ReverseEndian(stunAttributeType);
stunAttributeLength = Utility.ReverseEndian(stunAttributeLength);
}
if (stunAttributeLength > 0)
{
if (stunAttributeType == (int)STUNAttributeTypesEnum.Username && stunAttributeLength > buffer.Length - startIndex - 4)
{
// Received some STUN messages where the username is shorter than the claimed length.
int realLength = buffer.Length - startIndex - 4;
stunAttributeValue = new byte[realLength];
Buffer.BlockCopy(buffer, startIndex + 4, stunAttributeValue, 0, realLength);
}
else
{
stunAttributeValue = new byte[stunAttributeLength];
Buffer.BlockCopy(buffer, startIndex + 4, stunAttributeValue, 0, stunAttributeLength);
}
}
STUNAttributeTypesEnum attributeType = STUNAttributeTypes.GetSTUNAttributeTypeForId(stunAttributeType);
STUNAttribute attribute = null;
if (attributeType == STUNAttributeTypesEnum.ChangeRequest)
{
attribute = new STUNChangeRequestAttribute(stunAttributeValue);
}
else if (attributeType == STUNAttributeTypesEnum.MappedAddress)
{
attribute = new STUNAddressAttribute(stunAttributeValue);
}
else
{
attribute = new STUNAttribute(attributeType, stunAttributeLength, stunAttributeValue);
}
attributes.Add(attribute);
startAttIndex = startAttIndex + 4 + stunAttributeLength;
}
return(attributes);
}
else
{
return(null);
}
}
