static void EncodeSharedObject(RtmpContext context, ISharedObjectMessage so, ByteBuffer output) { RtmpWriter writer = new RtmpWriter(output); //Set legacy collection flag from context writer.UseLegacyCollection = context.UseLegacyCollection; writer.UseLegacyThrowable = context.UseLegacyThrowable; writer.WriteUTF(so.Name); // SO version writer.WriteInt32(so.Version); // Encoding (this always seems to be 2 for persistent shared objects) writer.WriteInt32(so.IsPersistent ? 2 : 0); // unknown field writer.WriteInt32(0); int mark, len = 0; foreach (ISharedObjectEvent sharedObjectEvent in so.Events) { byte type = SharedObjectTypeMapping.ToByte(sharedObjectEvent.Type); switch (sharedObjectEvent.Type) { case SharedObjectEventType.SERVER_CONNECT: case SharedObjectEventType.CLIENT_INITIAL_DATA: case SharedObjectEventType.CLIENT_CLEAR_DATA: writer.WriteByte(type); writer.WriteInt32(0); break; case SharedObjectEventType.SERVER_DELETE_ATTRIBUTE: case SharedObjectEventType.CLIENT_DELETE_DATA: case SharedObjectEventType.CLIENT_UPDATE_ATTRIBUTE: writer.WriteByte(type); mark = (int)output.Position; output.Skip(4); // we will be back writer.WriteUTF(sharedObjectEvent.Key); len = (int)output.Position - mark - 4; output.PutInt(mark, len); break; case SharedObjectEventType.SERVER_SET_ATTRIBUTE: case SharedObjectEventType.CLIENT_UPDATE_DATA: if (sharedObjectEvent.Key == null) { // Update multiple attributes in one request IDictionary initialData = sharedObjectEvent.Value as IDictionary; foreach (DictionaryEntry entry in initialData) { writer.WriteByte(type); mark = (int)output.Position; output.Skip(4); // we will be back string key = entry.Key as string; object value = entry.Value; writer.WriteUTF(key); writer.WriteData(context.ObjectEncoding, value); len = (int)output.Position - mark - 4; output.PutInt(mark, len); } } else { writer.WriteByte(type); mark = (int)output.Position; output.Skip(4); // we will be back writer.WriteUTF(sharedObjectEvent.Key); writer.WriteData(context.ObjectEncoding, sharedObjectEvent.Value); //writer.WriteData(sharedObjectEvent.Value); len = (int)output.Position - mark - 4; output.PutInt(mark, len); } break; case SharedObjectEventType.CLIENT_SEND_MESSAGE: case SharedObjectEventType.SERVER_SEND_MESSAGE: // Send method name and value writer.WriteByte(type); mark = (int)output.Position; output.Skip(4); // we will be back // Serialize name of the handler to call writer.WriteData(context.ObjectEncoding, sharedObjectEvent.Key); //writer.WriteUTF(sharedObjectEvent.Key); // Serialize the arguments foreach (object arg in sharedObjectEvent.Value as IList) { writer.WriteData(context.ObjectEncoding, arg); } //writer.WriteData(sharedObjectEvent.Value as IList); len = (int)output.Position - mark - 4; //output.PutInt(mark, len); output.PutInt(mark, len); break; case SharedObjectEventType.CLIENT_STATUS: writer.WriteByte(type); mark = (int)output.Position; output.Skip(4); // we will be back writer.WriteUTF(sharedObjectEvent.Key); writer.WriteUTF(sharedObjectEvent.Value as string); len = (int)output.Position - mark - 4; output.PutInt(mark, len); break; case SharedObjectEventType.SERVER_DISCONNECT: writer.WriteByte(type); output.PutInt((int)output.Position, 0); break; default: #if !SILVERLIGHT _log.Error("Unknown event " + sharedObjectEvent.Type.ToString()); #endif writer.WriteByte(type); mark = (int)output.Position; output.Skip(4); // we will be back if (sharedObjectEvent.Key != null) { writer.WriteUTF(sharedObjectEvent.Key); writer.WriteData(context.ObjectEncoding, sharedObjectEvent.Value); } len = (int)output.Position - mark - 4; output.PutInt(mark, len); break; } } }
/// <summary> /// Decodes handshake message. /// </summary> /// <param name="context">RTMP protocol state.</param> /// <param name="stream">Buffer to be decoded.</param> /// <returns>Buffer with handshake response.</returns> public static object DecodeHandshake(RtmpContext context, ByteBuffer stream) { long remaining = stream.Remaining; if (context.Mode == RtmpMode.Server) { if (context.State == RtmpState.Connect) { if (remaining < HandshakeSize + 1) { #if !SILVERLIGHT if (log.IsDebugEnabled) log.Debug(__Res.GetString(__Res.Rtmp_HSInitBuffering, remaining)); #endif context.SetBufferDecoding(HandshakeSize + 1); return null; } else { #if !SILVERLIGHT if (log.IsDebugEnabled) log.Debug("Handshake 1st phase"); #endif stream.Get();// skip the header byte byte[] handshake = RtmpHandshake.GetHandshakeResponse(stream); context.SetHandshake(handshake); context.State = RtmpState.Handshake; return handshake; } } if (context.State == RtmpState.Handshake) { //if (log.IsDebugEnabled) // log.Debug("Handshake reply"); if (remaining < HandshakeSize) { #if !SILVERLIGHT if (log.IsDebugEnabled) log.Debug(__Res.GetString(__Res.Rtmp_HSReplyBuffering, remaining)); #endif context.SetBufferDecoding(HandshakeSize); return null; } else { // Skip first 8 bytes when comparing the handshake, they seem to be changed when connecting from a Mac client. if (!context.ValidateHandshakeReply(stream, 8, HandshakeSize - 8)) { #if !SILVERLIGHT if (log.IsDebugEnabled) log.Debug("Handshake reply validation failed, disconnecting client."); #endif stream.Skip(HandshakeSize); context.State = RtmpState.Error; throw new HandshakeFailedException("Handshake validation failed"); } stream.Skip(HandshakeSize); context.State = RtmpState.Connected; context.ContinueDecoding(); return null; } } } else { //Client mode if (context.State == RtmpState.Connect) { int size = (2 * HandshakeSize) + 1; if (remaining < size) { #if !SILVERLIGHT if (log.IsDebugEnabled) log.Debug(__Res.GetString(__Res.Rtmp_HSInitBuffering, remaining)); #endif context.SetBufferDecoding(size); return null; } else { ByteBuffer hs = ByteBuffer.Allocate(size); ByteBuffer.Put(hs, stream, size); hs.Flip(); context.State = RtmpState.Handshake; return hs; } } } return null; }
static ISharedObjectMessage DecodeFlexSharedObject(ByteBuffer stream) { // Unknown byte, always 0? stream.Skip(1); RtmpReader reader = new RtmpReader(stream); string name = reader.ReadString(); // Read version of SO to modify int version = reader.ReadInt32(); // Read persistence informations bool persistent = reader.ReadInt32() == 2; // Skip unknown bytes reader.ReadInt32(); SharedObjectMessage so = new FlexSharedObjectMessage(null, name, version, persistent); DecodeSharedObject(so, stream, reader); return so; }
public static byte[] GetHandshakeResponse(ByteBuffer input) { int position = (int)input.Position; if (input[position + 4] == 0) { //Using old style handshake byte[] output = new byte[2 * RtmpProtocolDecoder.HandshakeSize + 1]; output[0] = 0x03; int tick = System.Environment.TickCount; output[1] = (byte)((tick >> 24) & 0xff); output[2] = (byte)((tick >> 16) & 0xff); output[3] = (byte)((tick >> 8) & 0xff); output[4] = (byte)(tick & 0xff); HandshakePadBytes.CopyTo(output, 5); input.Read(output, RtmpProtocolDecoder.HandshakeSize + 1, RtmpProtocolDecoder.HandshakeSize); return output; } else { //This method is broken by FP 10.0.32.18 //int index = (input[8] + input[9] + input[10] + input[11]) % 728 + 12; int index = 0; if (input[position + 5] == 0 && input[position + 6] == 3 && input[position + 7] == 2) index = ((input[position + 772] & 0x0ff) + (input[position + 773] & 0x0ff) + (input[position + 774] & 0x0ff) + (input[position + 775] & 0x0ff)) % 728 + 776; else index = ((input[position + 8] & 0x0ff) + (input[position + 9] & 0x0ff) + (input[position + 10] & 0x0ff) + (input[position + 11] & 0x0ff)) % 728 + 12; byte[] part = new byte[32]; for (int i = 0; i < 32; ++i) { part[i] = input[position + index + i]; } HMACSHA256 hmacsha256 = new HMACSHA256(); hmacsha256.Key = SecretKey; byte[] newKey = hmacsha256.ComputeHash(part); byte[] randBytes = new byte[RtmpProtocolDecoder.HandshakeSize - 32]; Random random = new Random(); random.NextBytes(randBytes); hmacsha256.Key = newKey; byte[] hashedBytes = hmacsha256.ComputeHash(randBytes); byte[] output = new byte[2 * RtmpProtocolDecoder.HandshakeSize + 1]; output[0] = 0x03; HandshakeServerBytes.CopyTo(output, 1); //randBytes.CopyTo(output, RtmpProtocolDecoder.HandshakeSize + 1); randBytes.CopyTo(output, 1 + HandshakeServerBytes.Length); //hashedBytes.CopyTo(output, RtmpProtocolDecoder.HandshakeSize + 1 + randBytes.Length); hashedBytes.CopyTo(output, 1 + HandshakeServerBytes.Length + randBytes.Length); input.Skip(RtmpProtocolDecoder.HandshakeSize); return output; } }