407 lines
15 KiB
C#
407 lines
15 KiB
C#
using System;
|
|
using System.Collections.Concurrent;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Net.Sockets;
|
|
using System.Security.Cryptography;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace VideoReader
|
|
{
|
|
internal class InOutSocket
|
|
{
|
|
public int bitrateout = 0;
|
|
public int bitratein = 0;
|
|
|
|
private static byte[] keyByte = MD5("73!2#qweaSdzxc4r");
|
|
private static byte[] ivByte = MD5("0_=op[l:',./vf73");
|
|
|
|
private bool open;
|
|
private ServerConfig config;
|
|
private ConcurrentQueue<byte[]> outbuffer = new ConcurrentQueue<byte[]>();
|
|
private BinaryWriter bw;
|
|
private ConcurrentQueue<byte[]> output = new ConcurrentQueue<byte[]>();
|
|
private bool noblock = true;
|
|
|
|
// Новые поля для детального логгирования
|
|
private TcpClient tcpClient;
|
|
private NetworkStream networkStream;
|
|
private Thread receiveThread;
|
|
private Thread sendThread;
|
|
private bool isRunning = false;
|
|
private long packetCounter = 0;
|
|
private DateTime connectionStartTime;
|
|
|
|
public bool opened
|
|
{
|
|
get { return open; }
|
|
set { open = value; }
|
|
}
|
|
|
|
public InOutSocket()
|
|
{
|
|
config = ServerConfig.LoadConfig();
|
|
DetailedLogger.LogConnection($"InOutSocket initialized with server: {config.ServerAddress}:{config.Port}");
|
|
DetailedLogger.LogDebug($"Encryption keys initialized - Key: {BitConverter.ToString(keyByte)}, IV: {BitConverter.ToString(ivByte)}");
|
|
}
|
|
|
|
private static byte[] MD5(string input)
|
|
{
|
|
using (var md5 = System.Security.Cryptography.MD5.Create())
|
|
{
|
|
return md5.ComputeHash(Encoding.UTF8.GetBytes(input));
|
|
}
|
|
}
|
|
|
|
public void Connect()
|
|
{
|
|
try
|
|
{
|
|
connectionStartTime = DateTime.Now;
|
|
DetailedLogger.LogConnection($"Starting connection to {config.ServerAddress}:{config.Port}...");
|
|
|
|
// DNS Resolution
|
|
DetailedLogger.LogDebug($"Resolving DNS for {config.ServerAddress}...");
|
|
var addresses = Dns.GetHostAddresses(config.ServerAddress);
|
|
DetailedLogger.LogDebug($"DNS resolved to {addresses.Length} addresses: {string.Join(", ", addresses.Select(a => a.ToString()))}");
|
|
|
|
// TCP Connection
|
|
tcpClient = new TcpClient();
|
|
tcpClient.ReceiveTimeout = 30000; // 30 seconds
|
|
tcpClient.SendTimeout = 30000;
|
|
|
|
var connectTask = tcpClient.ConnectAsync(config.ServerAddress, config.Port);
|
|
var sw = Stopwatch.StartNew();
|
|
|
|
DetailedLogger.LogConnection($"Attempting TCP connection to {config.ServerAddress}:{config.Port}...");
|
|
connectTask.Wait(10000); // 10 second timeout
|
|
|
|
if (!tcpClient.Connected)
|
|
{
|
|
throw new Exception($"Failed to connect within timeout");
|
|
}
|
|
|
|
sw.Stop();
|
|
DetailedLogger.LogConnection($"TCP connection established in {sw.ElapsedMilliseconds}ms");
|
|
|
|
networkStream = tcpClient.GetStream();
|
|
DetailedLogger.LogDebug($"Network stream obtained, available: {networkStream.DataAvailable}");
|
|
|
|
// Start monitoring threads
|
|
isRunning = true;
|
|
receiveThread = new Thread(ReceiveLoop) { IsBackground = true, Name = "ReceiveThread" };
|
|
sendThread = new Thread(SendLoop) { IsBackground = true, Name = "SendThread" };
|
|
|
|
receiveThread.Start();
|
|
sendThread.Start();
|
|
|
|
DetailedLogger.LogConnection("Monitoring threads started");
|
|
|
|
// Send initial handshake
|
|
SendInitialHandshake();
|
|
|
|
opened = true;
|
|
DetailedLogger.LogConnection("Connection established successfully");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
DetailedLogger.LogError($"Connection failed: {ex.Message}", ex);
|
|
opened = false;
|
|
Cleanup();
|
|
throw;
|
|
}
|
|
}
|
|
|
|
public void Disconnect()
|
|
{
|
|
DetailedLogger.LogConnection("Starting disconnect procedure...");
|
|
|
|
isRunning = false;
|
|
opened = false;
|
|
|
|
try
|
|
{
|
|
// Send disconnect packet if possible
|
|
if (networkStream != null && tcpClient != null && tcpClient.Connected)
|
|
{
|
|
var disconnectPacket = Encoding.UTF8.GetBytes("DISCONNECT");
|
|
SendPacket(disconnectPacket, "Disconnect command");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
DetailedLogger.LogError($"Error sending disconnect packet: {ex.Message}");
|
|
}
|
|
|
|
Cleanup();
|
|
|
|
var totalTime = DateTime.Now - connectionStartTime;
|
|
DetailedLogger.LogConnection($"Disconnected from server (session duration: {totalTime.TotalSeconds:F1}s, packets processed: {packetCounter})");
|
|
}
|
|
|
|
private void Cleanup()
|
|
{
|
|
try
|
|
{
|
|
networkStream?.Close();
|
|
networkStream?.Dispose();
|
|
tcpClient?.Close();
|
|
tcpClient?.Dispose();
|
|
|
|
// Wait for threads to finish
|
|
receiveThread?.Join(2000);
|
|
sendThread?.Join(2000);
|
|
|
|
DetailedLogger.LogDebug("Connection cleanup completed");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
DetailedLogger.LogError($"Error during cleanup: {ex.Message}");
|
|
}
|
|
}
|
|
|
|
private void SendInitialHandshake()
|
|
{
|
|
try
|
|
{
|
|
DetailedLogger.LogConnection("Sending initial handshake...");
|
|
|
|
// Создаем пакет авторизации
|
|
var handshakeData = new byte[64];
|
|
var channelBytes = BitConverter.GetBytes(config.Channel);
|
|
var serverTypeBytes = Encoding.UTF8.GetBytes(config.ServerType.PadRight(16).Substring(0, 16));
|
|
|
|
Array.Copy(channelBytes, 0, handshakeData, 0, 4);
|
|
Array.Copy(serverTypeBytes, 0, handshakeData, 4, 16);
|
|
|
|
// Добавляем timestamp
|
|
var timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
|
|
var timestampBytes = BitConverter.GetBytes(timestamp);
|
|
Array.Copy(timestampBytes, 0, handshakeData, 20, 8);
|
|
|
|
SendPacket(handshakeData, "Initial handshake");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
DetailedLogger.LogError($"Failed to send handshake: {ex.Message}", ex);
|
|
}
|
|
}
|
|
|
|
private void SendPacket(byte[] data, string description)
|
|
{
|
|
try
|
|
{
|
|
var encryptedData = EncryptData(data);
|
|
DetailedLogger.LogPacket("OUTGOING", encryptedData, description);
|
|
|
|
networkStream.Write(encryptedData, 0, encryptedData.Length);
|
|
networkStream.Flush();
|
|
|
|
Interlocked.Add(ref bitrateout, encryptedData.Length);
|
|
Interlocked.Increment(ref packetCounter);
|
|
|
|
DetailedLogger.LogDebug($"Packet sent successfully ({encryptedData.Length} bytes)");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
DetailedLogger.LogError($"Failed to send packet: {ex.Message}", ex);
|
|
}
|
|
}
|
|
|
|
private void ReceiveLoop()
|
|
{
|
|
DetailedLogger.LogDebug("Receive thread started");
|
|
var buffer = new byte[8192];
|
|
|
|
while (isRunning && tcpClient?.Connected == true)
|
|
{
|
|
try
|
|
{
|
|
if (networkStream.DataAvailable)
|
|
{
|
|
var bytesRead = networkStream.Read(buffer, 0, buffer.Length);
|
|
if (bytesRead > 0)
|
|
{
|
|
var receivedData = new byte[bytesRead];
|
|
Array.Copy(buffer, receivedData, bytesRead);
|
|
|
|
ProcessReceivedPacket(receivedData);
|
|
Interlocked.Add(ref bitratein, bytesRead);
|
|
Interlocked.Increment(ref packetCounter);
|
|
}
|
|
}
|
|
|
|
Thread.Sleep(10); // Небольшая задержка чтобы не грузить CPU
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (isRunning) // Только логгируем если не идет остановка
|
|
{
|
|
DetailedLogger.LogError($"Error in receive loop: {ex.Message}");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
DetailedLogger.LogDebug("Receive thread stopped");
|
|
}
|
|
|
|
private void SendLoop()
|
|
{
|
|
DetailedLogger.LogDebug("Send thread started");
|
|
|
|
while (isRunning && tcpClient?.Connected == true)
|
|
{
|
|
try
|
|
{
|
|
if (outbuffer.TryDequeue(out byte[] dataToSend))
|
|
{
|
|
SendPacket(dataToSend, "Queued data");
|
|
}
|
|
|
|
Thread.Sleep(10);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (isRunning)
|
|
{
|
|
DetailedLogger.LogError($"Error in send loop: {ex.Message}");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
DetailedLogger.LogDebug("Send thread stopped");
|
|
}
|
|
|
|
private void ProcessReceivedPacket(byte[] rawData)
|
|
{
|
|
try
|
|
{
|
|
DetailedLogger.LogPacket("INCOMING", rawData, "Raw received data");
|
|
|
|
// Пытаемся расшифровать данные
|
|
var decryptedData = DecryptData(rawData);
|
|
if (decryptedData != null)
|
|
{
|
|
DetailedLogger.LogPacket("DECRYPTED", decryptedData, "Decrypted data");
|
|
AnalyzePacketContent(decryptedData);
|
|
}
|
|
else
|
|
{
|
|
DetailedLogger.LogDebug("Failed to decrypt packet, analyzing as plain data");
|
|
AnalyzePacketContent(rawData);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
DetailedLogger.LogError($"Error processing received packet: {ex.Message}", ex);
|
|
}
|
|
}
|
|
|
|
private void AnalyzePacketContent(byte[] data)
|
|
{
|
|
try
|
|
{
|
|
var dataStr = Encoding.UTF8.GetString(data);
|
|
|
|
// Проверяем на подключение телефона
|
|
if (dataStr.Contains("PHONE") || dataStr.Contains("DEVICE") || dataStr.Contains("CONNECT"))
|
|
{
|
|
DetailedLogger.LogPhoneConnection(dataStr, "Phone connection detected in packet");
|
|
}
|
|
|
|
// Проверяем другие типы пакетов
|
|
if (dataStr.Contains("VIDEO"))
|
|
{
|
|
DetailedLogger.LogDebug("Video data packet detected");
|
|
}
|
|
else if (dataStr.Contains("AUDIO"))
|
|
{
|
|
DetailedLogger.LogDebug("Audio data packet detected");
|
|
}
|
|
else if (dataStr.Contains("HEARTBEAT") || dataStr.Contains("PING"))
|
|
{
|
|
DetailedLogger.LogDebug("Heartbeat/ping packet detected");
|
|
}
|
|
else if (dataStr.Contains("AUTH") || dataStr.Contains("LOGIN"))
|
|
{
|
|
DetailedLogger.LogConnection("Authentication packet detected");
|
|
}
|
|
|
|
// Логгируем содержимое пакета
|
|
DetailedLogger.LogDebug($"Packet content analysis: {dataStr.Substring(0, Math.Min(100, dataStr.Length))}...");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
DetailedLogger.LogDebug($"Could not analyze packet as text: {ex.Message}");
|
|
}
|
|
}
|
|
|
|
private byte[] EncryptData(byte[] data)
|
|
{
|
|
try
|
|
{
|
|
using (var aes = Aes.Create())
|
|
{
|
|
aes.Key = keyByte;
|
|
aes.IV = ivByte;
|
|
aes.Mode = CipherMode.CBC;
|
|
aes.Padding = PaddingMode.PKCS7;
|
|
|
|
using (var encryptor = aes.CreateEncryptor())
|
|
using (var ms = new MemoryStream())
|
|
using (var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
|
|
{
|
|
cs.Write(data, 0, data.Length);
|
|
cs.FlushFinalBlock();
|
|
return ms.ToArray();
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
DetailedLogger.LogError($"Encryption failed: {ex.Message}");
|
|
return data; // Возвращаем оригинальные данные если шифрование не удалось
|
|
}
|
|
}
|
|
|
|
private byte[] DecryptData(byte[] data)
|
|
{
|
|
try
|
|
{
|
|
using (var aes = Aes.Create())
|
|
{
|
|
aes.Key = keyByte;
|
|
aes.IV = ivByte;
|
|
aes.Mode = CipherMode.CBC;
|
|
aes.Padding = PaddingMode.PKCS7;
|
|
|
|
using (var decryptor = aes.CreateDecryptor())
|
|
using (var ms = new MemoryStream(data))
|
|
using (var cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
|
|
using (var result = new MemoryStream())
|
|
{
|
|
cs.CopyTo(result);
|
|
return result.ToArray();
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
DetailedLogger.LogDebug($"Decryption failed (data might not be encrypted): {ex.Message}");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public void QueueDataForSending(byte[] data)
|
|
{
|
|
outbuffer.Enqueue(data);
|
|
DetailedLogger.LogDebug($"Data queued for sending ({data.Length} bytes)");
|
|
}
|
|
}
|
|
} |