/// <summary> /// Parses an array of bytes containing every attributes of a message and /// add them to managed and unmanaged attributes lists /// </summary> /// <param name="attributes">The array of byte which contains every attributes of a message</param> private void ImportAttributes(byte[] attributes) { Int32 offset = 0; Int32 attributesLength = attributes.Length; while (offset < attributesLength) { // We retrieve length and add it attribute header length (4 bytes) UInt16 valueLength = BitConverter.ToUInt16(StunUtilities.SubArray(attributes, offset + 2, 2), 0); UInt16 attributeLength = (UInt16)(StunUtilities.ReverseBytes(valueLength) + 4); // Adjust original length to a padded 32bit length if (attributeLength % 4 != 0) { attributeLength = (UInt16)(attributeLength + (4 - attributeLength % 4)); } StunAttribute attr = StunUtilities.SubArray(attributes, offset, attributeLength); // When doing auto conversion of a byte array, according to STUN RFC 5389 // only the first attribute of a given type must be taken into account this.SetAttribute(attr, false); offset += attributeLength; } }
/// <summary> /// Computes a HMAC SHA1 based on this StunMessage attributes /// </summary> /// <param name="hmacSha1Key">The key of HMAC SHA1 computation algorithm</param> /// <returns>The HMAC computed value of this StunMessage</returns> private byte[] ComputeHMAC(byte[] hmacSha1Key) { byte[] hashed; using (HMACSHA1 hmacSha1 = new HMACSHA1(hmacSha1Key)) { StunMessage thisCopy = new StunMessage(this.MethodType, this.MethodClass, this.TransactionID); foreach (var item in this.attributesList) { if (item.Key == StunAttributeType.MessageIntegrity) { break; } thisCopy.SetAttribute(item.Value); } if (this.Stun.FingerPrint != null) { thisCopy.SetAttribute(this.Stun.FingerPrint); } byte[] thisCopyBytes = thisCopy; // Insert a fake message length for HMAC computation as described in [RFC5489#15.4] UInt16 dummyLength = StunUtilities.ReverseBytes((UInt16)(thisCopy.MessageLength + 24)); // 20 hmac + 4 header BitConverter.GetBytes(dummyLength).CopyTo(thisCopyBytes, 2); hashed = hmacSha1.ComputeHash(thisCopyBytes); } return(hashed); }
/// <summary> /// Convert a network-byte ordered array of bytes to a StunAttributeType /// </summary> /// <param name="bytes">An array of 2 bytes (16bits) representing an attribute type</param> /// <returns> /// The StunAttributeType matching the array of bytes /// Returns StunAttributeType.Unmanaged if the byte array doesn't match any StunAttributeType StunValue's /// </returns> public static StunAttributeType BytesToAttributeType(byte[] bytes) { UInt16 type = StunUtilities.ReverseBytes(BitConverter.ToUInt16(bytes, 0)); foreach (FieldInfo field in typeof(StunAttributeType).GetFields()) { Object[] fieldAttributes = field.GetCustomAttributes(typeof(StunValueAttribute), false); if (fieldAttributes.Length == 1) { StunValueAttribute stunValueAttribute = fieldAttributes.GetValue(0) as StunValueAttribute; if (stunValueAttribute != null && stunValueAttribute.Value == type) { return((StunAttributeType)Enum.Parse(typeof(StunAttributeType), field.Name)); } } } return(StunAttributeType.Unmanaged); }
/// <summary> /// TODO: Documentation RefreshAllocation /// </summary> /// <param name="allocation"></param> /// <param name="lifeTime"></param> public void RefreshAllocation(TurnAllocation allocation, UInt32 lifeTime) { StunMessage msg = new StunMessage(StunMethodType.Refresh, StunMethodClass.Request, StunUtilities.NewTransactionId); msg.Stun.Username = new UTF8Attribute(StunAttributeType.Username, allocation.Username); msg.Stun.Realm = new UTF8Attribute(StunAttributeType.Realm, allocation.Realm); msg.Stun.Nonce = new UTF8Attribute(StunAttributeType.Nonce, allocation.Nonce); msg.Turn.LifeTime = new StunAttribute(StunAttributeType.LifeTime, BitConverter.GetBytes(StunUtilities.ReverseBytes(lifeTime))); msg.AddMessageIntegrity(allocation.Password, true); this.StunClient.BeginSendMessage(msg, null); }
/// <summary> /// TODO: Documentation StunClient_OnReceivedSuccessResponse /// </summary> /// <param name="sender"></param> /// <param name="receivedMsg"></param> /// <param name="sentMsg"></param> /// <param name="transactionObject"></param> private void StunClient_OnReceivedSuccessResponse(object sender, StunMessage receivedMsg, StunMessage sentMsg, object transactionObject) { switch (receivedMsg.MethodType) { case StunMethodType.Allocate: TurnAllocation allocation = new TurnAllocation() { Username = sentMsg.Stun.Username.ValueString, Password = transactionObject as String, Realm = sentMsg.Stun.Realm.ValueString, Nonce = sentMsg.Stun.Nonce.ValueString, RelayedMappedAddress = receivedMsg.Turn.XorRelayedAddress, MappedAddress = receivedMsg.Stun.XorMappedAddress, StartTime = DateTime.Now, LifeTime = StunUtilities.ReverseBytes(BitConverter.ToUInt32(receivedMsg.Turn.LifeTime.Value, 0)) }; if (this.Allocations.ContainsKey(receivedMsg.Turn.XorRelayedAddress)) { this.Allocations[receivedMsg.Turn.XorRelayedAddress] = allocation; } else { this.Allocations.Add(receivedMsg.Turn.XorRelayedAddress, allocation); if (this.OnAllocateSucceed != null) { this.OnAllocateSucceed(this, allocation, sentMsg, receivedMsg); } } break; case StunMethodType.CreatePermission: TurnPermission permission = new TurnPermission() { PeerAddress = sentMsg.Turn.XorPeerAddress, StartTime = DateTime.Now, LifeTime = 300 }; TurnAllocation permAllocation = transactionObject as TurnAllocation; if (permAllocation.Permissions.ContainsKey(sentMsg.Turn.XorPeerAddress)) { permAllocation.Permissions[sentMsg.Turn.XorPeerAddress] = permission; } else { permAllocation.Permissions.Add(sentMsg.Turn.XorPeerAddress, permission); if (this.OnCreatePermissionSucceed != null) { this.OnCreatePermissionSucceed(this, permAllocation, permission, sentMsg, receivedMsg); } } break; case StunMethodType.ChannelBind: TurnChannel channel = new TurnChannel() { Channel = sentMsg.Turn.ChannelNumber, PeerAddress = sentMsg.Turn.XorPeerAddress, StartTime = DateTime.Now, LifeTime = 600 }; TurnAllocation channelAllocation = transactionObject as TurnAllocation; if (channelAllocation.Channels.ContainsKey(sentMsg.Turn.ChannelNumber)) { channelAllocation.Channels[sentMsg.Turn.ChannelNumber] = channel; } else { channelAllocation.Channels.Add(sentMsg.Turn.ChannelNumber, channel); if (this.OnChannelBindSucceed != null) { this.OnChannelBindSucceed(this, transactionObject as TurnAllocation, channel, sentMsg, receivedMsg); } } break; case StunMethodType.ConnectionBind: if (this.OnConnectionBindSucceed != null) { this.OnConnectionBindSucceed(this, transactionObject as Socket, receivedMsg); } break; } }