public void ProcessPacketQueue()
{
if (_packetQueue.Count <= 0)
{
return;
}
if (_collectAndWaitFor)
{
if (_collectAndWaitPacket != null && _collectAndWaitFunc())
{
foreach (var packet in _waitingPacketQueue.ToArray())
{
_packetQueue.Enqueue(packet);
}
_collectAndWaitPacket = null;
_collectAndWaitFor = false;
}
else
{
return;
}
}
do
{
var packet = _packetQueue.Dequeue();
PacketType packetType = packet.Item1;
PacketReceivedEventArgs args = packet.Item2;
if (_packetHandlers.ContainsKey(packetType))
{
foreach (var handler in _packetHandlers[packetType])
{
if (Settings.DisplayNetworkMessages)
{
Console.WriteLine("Handling packet {0} by {1}", packetType.ToString(), handler.Method.ToString());
}
// Reset the read position.
args.Message.Position = 0;
handler.Invoke(args);
}
}
this.EventOccured?.Invoke(this, new SubjectEventArgs("packetRec" + packetType.ToString(), new object[] { args.Message }));
} while (_packetQueue.Count > 0);
}
public void DeCrypt(ref byte[] raw, int lenght, int offset, PacketType type)
{
Logincrypt crypt;
if (type == PacketType.ClientToLoginserver)
{
crypt = this.clientCrypt;
}
else if (type == PacketType.LoginserverToClient)
{
crypt = this.serverCrypt;
}
else
{
throw new Exception("Wrong PacketType "
+ type.ToString() + " for " + this.ToString());
}
if (this.staticCrypt)
{
crypt.staticDecrypt(ref raw, offset, lenght);
this.staticCrypt = false;
if (raw[0 + offset] == 0x00)
{
Console.WriteLine("Got Initpacket");
handleInit(new Bytebuffer(raw));
}
}
else
{
crypt.decrypt(ref raw, offset, lenght);
}
}
public static T Create <T>(PacketType type) where T : Packet
{
T packet = (T)Activator.CreateInstance(typeof(T));
packet.Id = GameData.GameData.Packets.ByName(type.ToString()).ID;
return(packet);
}
public static T Create <T>(PacketType type)
{
Packet packet = (Packet)Activator.CreateInstance(typeof(T));
packet.Id = Constants.GameData.Packets.ByName(type.ToString()).ID;
return((T)Convert.ChangeType(packet, typeof(T)));
}
public void RandomValidPacketStressTest()
{
const int k_iterations = 500;
Client client = clientManager.GetClientFromEmailAddress("TestUser1");
var receiver = MessageReceiver.GetInstance();
Array packetTypes = Enum.GetValues(typeof(PacketType));
Random r = new Random();
for (int i = 0; i < k_iterations; i++)
{
var index = r.Next(0, packetTypes.Length - 1);
PacketType selectedPacketType = (PacketType)packetTypes.GetValue(index);
Debug.WriteLine(String.Format("Sending a packet of type {0}", selectedPacketType.ToString()));
var messageBuffer = CreateMessage(selectedPacketType, "sender=TestUser1&message=validtestmessage");
receiver.HandleMessage(ref client, messageBuffer);
}
}
public void RunModuleCache()
{
try
{
int count = ModuleHandler.InvokeGetModuleAddonCount();
int i = 0;
for (; i < count; i++)
{
object[] obj_temp = ModuleHandler.InvokeGetModuleAddon(i, true);
string key = (string)obj_temp[0];
string[] split_key = key.Split(new char[1] {
'_'
}, StringSplitOptions.RemoveEmptyEntries);
if (split_key[0] == _ptype.ToString())
{
obj_temp = ModuleHandler.InvokeGetModuleAddon(i, false);
key = (string)obj_temp[0];
ModuleAddonCallback mac = (ModuleAddonCallback)obj_temp[1];
if (ModuleAddons.ContainsKey(key))
{
ModuleAddons.Remove(key);
}
ModuleAddons.Add(key, mac);
}
else
{
}
}
}
catch (Exception e)
{
Console.WriteLine("ERROR: " + e.Message);
}
}
public void DeCrypt(ref byte[] raw, int lenght, int offset, PacketType type)
{
Logincrypt crypt;
if (type == PacketType.ClientToLoginserver)
{
crypt = this.clientCrypt;
}
else if (type == PacketType.LoginserverToClient)
{
crypt = this.serverCrypt;
}
else
{
throw new Exception("Wrong PacketType "
+ type.ToString() + " for " + this.ToString());
}
if (this.staticCrypt)
{
crypt.staticDecrypt(ref raw, offset, lenght);
this.staticCrypt = false;
if (raw[0 + offset] == 0x00)
{
Console.WriteLine("Got Initpacket");
handleInit(new Bytebuffer(raw));
}
}
else
{
crypt.decrypt(ref raw, offset, lenght);
}
}
public void EnCrypt(ref byte[] raw, int lenght, int offset, PacketType type)
{
Logincrypt crypt;
if (type == PacketType.ClientToLoginserver)
{
crypt = this.clientCrypt;
}
else if (type == PacketType.LoginserverToClient)
{
crypt = this.serverCrypt;
}
else
{
throw new Exception("Wrong PacketType "
+ type.ToString() + " for " + this.ToString());
}
if (this.staticCrypt)
{
crypt.staticEncrypt(ref raw, offset, lenght, (uint)new Random().Next());
enableCrypt();
}
else
{
crypt.encrypt(ref raw, offset, lenght);
}
}
public void EnCrypt(ref byte[] raw, int lenght, int offset, PacketType type)
{
Logincrypt crypt;
if (type == PacketType.ClientToLoginserver)
{
crypt = this.clientCrypt;
}
else if (type == PacketType.LoginserverToClient)
{
crypt = this.serverCrypt;
}
else
{
throw new Exception("Wrong PacketType "
+ type.ToString() + " for " + this.ToString());
}
if (this.staticCrypt)
{
crypt.staticEncrypt(ref raw, offset, lenght, (uint)new Random().Next());
enableCrypt();
}
else
{
crypt.encrypt(ref raw, offset, lenght);
}
}
public override void OnReceive(IPacket packet)
{
PacketType packetType = packet.GetPacketType();
if (packetHandler.ContainsKey(packetType) == false)
{
Console.Error.WriteLine($"Not Found Packet Handler (packetType: {packetType.ToString()})");
return;
}
#if DEBUG
Console.WriteLine($"received {packetType.ToString()}");
#endif
packetHandler[packetType]?.Invoke(packet);
}
public Packet AcceptedPacket(PacketType type, User user)
{
return(new Packet
{
Type = type.ToString(),
Username = user.Username
});
}
public override string ToString()
{
if (!IsValid)
{
return("Invalid packet");
}
return(" IsValid:" + IsValid + " Type:" + Type.ToString() + " Unk:" + Unk.ToString("X") + " IsEncrypted:" + IsEncrypted + " ID:" + ID.ToString("X") + " BodySize:" + BodySize.ToString("X") + " Body:" + Helpers.ByteArrayToString(Body));
}
public static Packet Create(PacketType type)
{
PacketStructure st = Constants.GameData.Packets.ByName(type.ToString());
Packet packet = (Packet)Activator.CreateInstance(st.Type);
packet.Id = st.ID;
return(packet);
}
public Packet DisconnectPacket(PacketType type, User user)
{
return(new Packet
{
Type = type.ToString(),
Username = user.Username
});
}
public static _0001 CreatePacketFromType <_0001>(PacketType type)
{
Packet obj = (Packet)Activator.CreateInstance(typeof(_0001));
obj.ID = ResourceDownloader._PP85pw5fC3jVm7LDMzFra717hdB
.ByName(type.ToString())._QjKHGXZ7ohXwrDQImauPaSixsVg;
return((_0001)Convert.ChangeType(obj, typeof(_0001)));
}
public Packet ConnectPacket(PacketType type, User user)
{
return(new Packet
{
Type = type.ToString(),
Username = user.Username,
Password = user.Password
});
}
internal void TraceReceptionEvent(PacketType pt, string message, params object[] args)
{
ISSHEventTracer t = _param.EventTracer;
if (t != null)
{
t.OnReception(pt.ToString(), String.Format(message, args));
}
}
public static BasePacket CreatePacket(PacketType type)
{
if (listOfConstructors.ContainsKey(type) == false)
{
Console.WriteLine("Missing create packet dictionary lookup {0}", type.ToString());
throw new Exception("Missing create packet dictionary lookup");
}
return(listOfConstructors[type].Invoke());
}
public static Packet CreatePacketFromType(PacketType type)
{
PacketStructure packetStructure =
ResourceDownloader._PP85pw5fC3jVm7LDMzFra717hdB.ByName(type.ToString());
Packet obj = (Packet)Activator.CreateInstance(packetStructure._bjQd3Vpt6RdoySpzKxn7K2gQGoM);
obj.ID = packetStructure._QjKHGXZ7ohXwrDQImauPaSixsVg;
return(obj);
}
public void DeCrypt(ref byte[] raw, int lenght, int offset, PacketType type)
{
Gamecrypt crypt;
if (type == PacketType.ClientToGameserver)
{
crypt = this.clientCrypt;
}
else if (type == PacketType.GameserverToClient)
{
crypt = this.serverCrypt;
}
else
{
throw new Exception("Wrong PacketType "
+ type.ToString() + " for " + this.ToString());
}
crypt.decrypt(ref raw, offset, lenght);
if (this.state == ConnectionState.Connected)
{
if (raw[0 + offset] == 0x2e)
{
Bytebuffer bb = new Bytebuffer(raw);
bb.Position = offset;
this.onKeyPacket(bb);
}
else if (raw[0 + offset] == 0x09)
{
// CharSelectionInfo
this.state = ConnectionState.Authed;
}
}
else if (this.state == ConnectionState.Authed)
{
if (raw[0 + offset] == 0x73)
{
this.state = ConnectionState.InGame;
}
}
else if (this.state == ConnectionState.InGame)
{
if (raw[0 + offset] == 0x0b)
{
//CharSelected
Bytebuffer bb = new Bytebuffer(raw);
bb.Position = offset;
this.onCharSelected(new Bytebuffer(raw));
}
}
}
public static long CalculateOperator(List <long> data, PacketType type)
{
return(type switch
{
PacketType.Sum => data.Sum(),
PacketType.Product => data.Aggregate(1L, (acc, next) => acc * next),
PacketType.Minimum => data.Min(),
PacketType.Maximum => data.Max(),
PacketType.GreaterThan => data[0] > data[1] ? 1 : 0,
PacketType.LessThan => data[0] < data[1] ? 1 : 0,
PacketType.Equals => data[0] == data[1] ? 1 : 0,
_ => throw new ArgumentException("unknown argument" + type.ToString(), nameof(type))
});
public void DeCrypt(ref byte[] raw, int lenght, int offset, PacketType type)
{
Gamecrypt crypt;
if (type == PacketType.ClientToGameserver)
{
crypt = this.clientCrypt;
}
else if (type == PacketType.GameserverToClient)
{
crypt = this.serverCrypt;
}
else
{
throw new Exception("Wrong PacketType "
+ type.ToString() + " for " + this.ToString());
}
crypt.decrypt(ref raw, offset, lenght);
if (this.state == ConnectionState.Connected)
{
if (raw[0 + offset] == 0x2e)
{
Bytebuffer bb = new Bytebuffer(raw);
bb.Position = offset;
this.onKeyPacket(bb);
}
else if (raw[0 + offset] == 0x09)
{
// CharSelectionInfo
this.state = ConnectionState.Authed;
}
}
else if (this.state == ConnectionState.Authed)
{
if (raw[0 + offset] == 0x73)
{
this.state = ConnectionState.InGame;
}
}
else if (this.state == ConnectionState.InGame)
{
if (raw[0 + offset] == 0x0b)
{
//CharSelected
Bytebuffer bb = new Bytebuffer(raw);
bb.Position = offset;
this.onCharSelected(new Bytebuffer(raw));
}
}
}
/// <summary>
/// Convenience debug method to display the contents of a packet.
/// </summary>
public void Dump()
{
Console.WriteLine("Dumping {0} packet with {1} bytes of data in the body:", type.ToString("g"), this.size);
try {
int count = 0;
int idata;
byte[] line = new byte[16];
ASCIIEncoding encoding = new ASCIIEncoding( );
if (rawdata == null)
{
rawdata = this.ToByteArray();
}
if (rawdata != null)
{
while (count < this.size)
{
idata = rawdata[count];
if ((((count % 16) == 0) && count != 0) || (count == rawdata.Length - 1))
{
string output = "";
string text = encoding.GetString(line);
string result = Regex.Replace(text, @"[^0-9a-zA-Z]", ".");
for (int i = 0; i < rawdata.Length && i < 16; i += 2)
{
output += String.Format("{0:x2}{1:x2} ", line[i], line[i + 1]);
}
Console.WriteLine("0x{0:x4}: {1} {2}", count - 16, output, result);
line = new byte[16];
}
line[count % 16] = Convert.ToByte(idata);
count++;
}
}
Console.WriteLine("");
} catch (Exception e) {
Console.WriteLine("Exception writing data: {0} ", e.ToString());
}
}
private void WirteDiagnosticBefore(TransportMessage message, string address, string traceId, PacketType packetType)
{
if (!AppConfig.ServerOptions.DisableDiagnostic)
{
var remoteInvokeMessage = message.GetContent <RemoteInvokeMessage>();
_diagnosticListener.WriteTransportBefore(TransportType.Mqtt, new TransportEventData(new DiagnosticMessage
{
Content = message.Content,
ContentType = message.ContentType,
Id = message.Id,
MessageName = remoteInvokeMessage.ServiceId
}, packetType.ToString(),
traceId, address));
}
}
public void SendPacketData(byte[] data, int dataLength, PacketType type, bool doZerocode)
{
UDPPacketBuffer buffer = new UDPPacketBuffer(remoteEndPoint, Packet.MTU);
// Zerocode if needed
if (doZerocode)
{
try { dataLength = Helpers.ZeroEncode(data, dataLength, buffer.Data); }
catch (IndexOutOfRangeException)
{
// The packet grew larger than Packet.MTU bytes while zerocoding.
// Remove the MSG_ZEROCODED flag and send the unencoded data
// instead
data[0] = (byte)(data[0] & ~Helpers.MSG_ZEROCODED);
Buffer.BlockCopy(data, 0, buffer.Data, 0, dataLength);
}
}
else
{
Buffer.BlockCopy(data, 0, buffer.Data, 0, dataLength);
}
buffer.DataLength = dataLength;
#region Queue or Send
NetworkManager.OutgoingPacket outgoingPacket = new NetworkManager.OutgoingPacket(this, buffer);
// Send ACK and logout packets directly, everything else goes through the queue
if (Client.Settings.THROTTLE_OUTGOING_PACKETS == false ||
type == PacketType.PacketAck ||
type == PacketType.LogoutRequest)
{
SendPacketFinal(outgoingPacket);
}
else
{
Network.PacketOutbox.Enqueue(outgoingPacket);
}
#endregion Queue or Send
#region Stats Tracking
if (Client.Settings.TRACK_UTILIZATION)
{
Client.Stats.Update(type.ToString(), OpenMetaverse.Stats.Type.Packet, dataLength, 0);
}
#endregion
}
private Packet ReceivePacket(PacketType type)
{
byte[] packetBuffer = ReceiveCompletely(Packet.SIZE);
Packet received = Packet.BytesToPacket(packetBuffer);
if (received.Type == type)
{
return(received);
}
else
{
throw new InvalidOperationException($"예상한 패킷이 도달하지 않았습니다. 예상 : {type.ToString()}");
}
}
public override void Run(IPacket packet)
{
PacketType type = (PacketType)packet.GetPacketType();
switch (type)
{
case PacketType.E_S_ANS_CHAT:
Contents.ReceiveChat(packet);
return;
}
if (base.DefaultRun(packet) == false)
{
#if DEBUG
MessageBox.Show("잘못된 패킷이 수신되었습니다: " + type.ToString(), "error", MessageBoxButtons.OK);
Application.Exit();
#endif
}
}
static void BuildForAndroid()
{
GetBuildParams();
string param = "";//LOCAL
string identitfyStr = "";
string productNameExt = "";
BuildOptions opt = new BuildOptions();
opt |= BuildOptions.None;
if (Mode == PacketType.DEBUG)
{
param += ";ISDEBUG";
opt |= BuildOptions.Development;
}
if (netType == NetType.OFFLINE)
{
param += ";OFFLINE";
identitfyStr = "_offline";
productNameExt = "(单机)";
}
else if (netType == NetType.INTERNAL)
{
param += ";INTERNAL";
identitfyStr = "_internal";
productNameExt = "(内网)";
}
else if (netType == NetType.OUTER)
{
param += ";OUTER";
}
PlayerSettings.SetScriptingDefineSymbolsForGroup(BuildTargetGroup.Android, param);
PlayerSettings.bundleVersion = version;
PlayerSettings.Android.bundleVersionCode = 1;
PlayerSettings.applicationIdentifier = buildIdentify + identitfyStr;
PlayerSettings.productName = productName + productNameExt;
PlayerSettings.defaultInterfaceOrientation = UIOrientation.LandscapeLeft;
string timeStr = "_" + Convert.ToInt32(netType) + "_" + (DateTime.Now.Year % 100) + DateTime.Now.Month + DateTime.Now.Day + DateTime.Now.Hour + DateTime.Now.Minute + DateTime.Now.Second;
Util.Log("GameName:" + productName + " Identify:" + buildIdentify + identitfyStr + " Version:" + version + " Net:" + netType.ToString() + timeStr);
string apkName = "XY_" + Mode.ToString().ToLower() + timeStr + ".apk";
BuildPipeline.BuildPlayer(GetBuildScenes(), "PacketTool/android/bin/" + apkName, BuildTarget.Android, opt);
}
public object[] ToStrings()
{
var result = new object[3];
result[0] = _packetType.ToString();
if (_packetType == PacketType.Extension21 || _buttons == WiiMoteButtons.None)
{
result[1] = "";
}
else
{
result[1] = _buttons.ToString();
}
result[2] = _data.ToHexString();
return(result);
}
public override void run(PacketInterface packet)
{
PacketType type = (PacketType)packet.type();
switch (type)
{
case PacketType.E_S_ANS_CHATTING:
contents_.recvChatting(packet);
return;
}
if (base.defaultRun(packet) == false)
{
#if DEBUG
MessageBox.Show("잘못된 패킷이 수신되었습니다 : " + type.ToString(), "error", MessageBoxButtons.OK);
Application.Exit();
#endif
}
}
public void EnCrypt(ref byte[] raw, int lenght, int offset, PacketType type)
{
Gamecrypt crypt;
if (type == PacketType.ClientToGameserver)
{
crypt = this.clientCrypt;
}
else if (type == PacketType.GameserverToClient)
{
crypt = this.serverCrypt;
}
else
{
throw new Exception("Wrong PacketType "
+ type.ToString() + " for " + this.ToString());
}
crypt.encrypt(ref raw, offset, lenght);
}
//protected override void receive_unconnected(System.Net.IPEndPoint remoteEndPoint, NetPacketReader reader, UnconnectedMessageType messageType) { }
protected override void receive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
PacketType packetType = (PacketType)reader.GetByte();
switch (packetType)
{
case PacketType.InputUpdate:
var packet = read_packet <InputUpdate>(reader); //MessagePackSerializer.Deserialize<InputUpdate>(reader.GetRemainingBytes());
input_update_event(peer, packet);
break;
case PacketType.CharacterSelection:
//Just in case
break;
default:
Log.LogWarning($"Unknown Packet Type received by Game Server <{packetType.ToString()}>");
break;
}
}
/// <summary>
/// Registers a callback for the specified packet type.
/// </summary>
/// <param name="type">Type of packet to be hooked</param>
/// <param name="callback">Callback to be registered</param>
public void HookPacket(PacketType type, PacketHandler callback)
{
if (GameData.GameData.Packets.ByName(type.ToString()).ID == 255)
{
throw new InvalidOperationException("[Plugin Error] A plugin attempted to register callback " +
callback.GetMethodInfo().ReflectedType + "." + callback.Method.Name +
" for packet type " + type + " that doesn't have a structure defined.");
}
else if (_packetHooks.ContainsKey(callback))
{
_packetHooks[callback].Add(type);
}
else
{
_packetHooks.Add(callback, new List <PacketType>()
{
type
});
}
}
private void TraceReceptionNegotiation(PacketType pt, string msg) {
_connection.TraceReceptionEvent(pt.ToString(), msg);
}
private void OpenShell(ISSHChannelEventReceiver receiver, PacketType pt, SSH2DataReader reader)
{
if(_negotiationStatus==3) {
if(pt!=PacketType.SSH_MSG_CHANNEL_OPEN_CONFIRMATION) {
if(pt!=PacketType.SSH_MSG_CHANNEL_OPEN_FAILURE)
receiver.OnChannelError(null, "opening channel failed; packet type="+pt);
else {
int errcode = reader.ReadInt32();
string msg = Encoding.ASCII.GetString(reader.ReadString());
receiver.OnChannelError(null, msg);
}
Close();
}
else {
_remoteID = reader.ReadInt32();
_serverMaxPacketSize = reader.ReadInt32();
//open pty
SSH2DataWriter wr = new SSH2DataWriter();
wr.WritePacketType(PacketType.SSH_MSG_CHANNEL_REQUEST);
wr.Write(_remoteID);
wr.Write("pty-req");
wr.Write(true);
wr.Write(_connection.Param.TerminalName);
wr.Write(_connection.Param.TerminalWidth);
wr.Write(_connection.Param.TerminalHeight);
wr.Write(_connection.Param.TerminalPixelWidth);
wr.Write(_connection.Param.TerminalPixelHeight);
wr.WriteAsString(new byte[0]);
TransmitPacket(wr.ToByteArray());
_negotiationStatus = 2;
}
}
else if(_negotiationStatus==2) {
if(pt!=PacketType.SSH_MSG_CHANNEL_SUCCESS) {
receiver.OnChannelError(null, "opening pty failed");
Close();
}
else {
//open shell
SSH2DataWriter wr = new SSH2DataWriter();
wr.Write((byte)PacketType.SSH_MSG_CHANNEL_REQUEST);
wr.Write(_remoteID);
wr.Write("shell");
wr.Write(true);
TransmitPacket(wr.ToByteArray());
_negotiationStatus = 1;
}
}
else if(_negotiationStatus==1) {
if(pt!=PacketType.SSH_MSG_CHANNEL_SUCCESS) {
receiver.OnChannelError(null, "Opening shell failed: packet type="+pt.ToString());
Close();
}
else {
receiver.OnChannelReady();
_negotiationStatus = 0; //goal!
}
}
else
Debug.Assert(false);
}
public void EnCrypt(ref byte[] raw, int lenght, int offset, PacketType type)
{
Gamecrypt crypt;
if (type == PacketType.ClientToGameserver)
{
crypt = this.clientCrypt;
}
else if (type == PacketType.GameserverToClient)
{
crypt = this.serverCrypt;
}
else
{
throw new Exception("Wrong PacketType "
+ type.ToString() + " for " + this.ToString());
}
crypt.encrypt(ref raw, offset, lenght);
}
//constructor, reads in the args
public Param(string[] args)
{
for (int i = 0; i < args.Length; i++)
{
string curStr = args[i];
try
{
if (String.Compare(curStr, "-adapter", true) == 0)
{
string nextStr = args[++i];
adapter = nextStr;
Console.WriteLine("Read in adapter as: " + adapter);
}
else if (String.Compare(curStr, "-v6EH", true) == 0)
{
string nextStr = args[++i];
string[] tempEHArray = nextStr.Split(',');
//ExtentionHeader =
int[] tempInt = Array.ConvertAll(tempEHArray, int.Parse);
foreach (int curInt in tempInt)
{
ExtentionHeader.Add((IPProtocolType)curInt);
}
packetType = PacketType.IP;
IPProtocol = IPProtocolType.IPV6;
Console.WriteLine("Read in -v6EH as: " + string.Join(",", tempEHArray));
Console.WriteLine("Setting packetType as: " + packetType.ToString());
Console.WriteLine("Setting IPProtocol as: " + IPProtocol.ToString());
}
else if (String.Compare(curStr, "-dMAC", true) == 0)
{
string nextStr = args[++i];
nextStr = nextStr.Replace(':', '-').ToUpper();
dMAC = PhysicalAddress.Parse(nextStr);
Console.WriteLine("Read in dMAC as: " + dMAC.ToString());
}
else if (String.Compare(curStr, "-sMAC", true) == 0)
{
string nextStr = args[++i];
nextStr = nextStr.Replace(':', '-').ToUpper();
sMAC = PhysicalAddress.Parse(nextStr);
Console.WriteLine("Read in sMAC as: " + sMAC.ToString());
}
else if (String.Compare(curStr, "-dIP", true) == 0)
{
string nextStr = args[++i];
dIP = IPAddress.Parse(nextStr);
Console.WriteLine("Read in dIP as: " + dIP.ToString());
}
else if (String.Compare(curStr, "-sIP", true) == 0)
{
string nextStr = args[++i];
sIP = IPAddress.Parse(nextStr);
Console.WriteLine("Read in sIP as: " + sIP.ToString());
}
else if (String.Compare(curStr, "-IP", true) == 0)
{
string nextStr = args[++i];
packetType = PacketType.IP;
if (nextStr.StartsWith("0x"))
{
IPProtocol = (IPProtocolType)Convert.ToInt32(nextStr, 16);
}
else
{
IPProtocol = (IPProtocolType)Convert.ToInt32(nextStr);
}
Console.WriteLine("Read in IP as: " + IPProtocol.ToString());
}
else if (String.Compare(curStr, "-EtherType", true) == 0)
{
string nextStr = args[++i];
packetType = PacketType.EtherType;
if (nextStr.StartsWith("0x"))
{
EtherTypeProtocol = (EthernetPacketType)Convert.ToInt32(nextStr, 16);
}
else
{
EtherTypeProtocol = (EthernetPacketType)Convert.ToInt32(nextStr);
}
Console.WriteLine("Read in EtherType as: " + EtherTypeProtocol.ToString());
}
else if (String.Compare(curStr, "-sPort", true) == 0)
{
string nextStr = args[++i];
sPort = (ushort)Int16.Parse(nextStr);
Console.WriteLine("Read in sPort as: " + sPort.ToString());
}
else if (String.Compare(curStr, "-dPort", true) == 0)
{
string nextStr = args[++i];
dPort = (ushort)Int16.Parse(nextStr);
Console.WriteLine("Read in dPort as: " + dPort.ToString());
}
else if (String.Compare(curStr, "-type", true) == 0)
{
string nextStr = args[++i];
type = (ushort)Int16.Parse(nextStr);
Console.WriteLine("Read in type as: " + type.ToString());
}
else if (String.Compare(curStr, "-tcpFlag", true) == 0)
{
string nextStr = args[++i];
tcpFlag = (byte)Byte.Parse(nextStr);
Console.WriteLine("Read in tcpFlag as: " + tcpFlag.ToString());
}
else if (String.Compare(curStr, "-code", true) == 0)
{
string nextStr = args[++i];
code = (ushort)Int16.Parse(nextStr);
Console.WriteLine("Read in code as: " + code.ToString());
}
else if (String.Compare(curStr, "-payload", true) == 0)
{
string nextStr = args[++i];
if (nextStr.StartsWith("0x"))
{
payload = Utility.ParseHex(nextStr);
Console.WriteLine("Read in -payload as: 0x" + BitConverter.ToString(payload));
}
else
{
payload = Encoding.ASCII.GetBytes(nextStr);
Console.WriteLine("Read in -payload as: " + System.Text.Encoding.Default.GetString(payload));
}
}
else if (String.Compare(curStr, "-adapter", true) == 0)
{
string nextStr = args[++i];
adapter = nextStr;
Console.WriteLine("Read in -adapter as: " + adapter);
}
else if (String.Compare(curStr, "-IPv4Frag", true) == 0)
{
IPv4Frag = true;
Console.WriteLine("Read in -ipv4frag as: " + IPv4Frag);
}
else if (String.Compare(curStr, "-ICMP", true) == 0)
{
packetType = PacketType.ICMP;
}
else if (String.Compare(curStr, "-tcp", true) == 0)
{
packetType = PacketType.TCP;
}
else if (String.Compare(curStr, "-udp", true) == 0)
{
packetType = PacketType.UDP;
}
else if (String.Compare(curStr, "-ICMPv6", true) == 0)
{
packetType = PacketType.ICMPv6;
}
else if (String.Compare(curStr, "-h", true) == 0)
{
Utility.PrintHelp();
Environment.Exit(0);
}
else
{
Console.WriteLine("Unrecognized param: " + curStr);
Utility.PrintHelp();
Environment.Exit(1);
}
}
catch (IndexOutOfRangeException)
{
Console.WriteLine("Another arg was expected after " + curStr);
Environment.Exit(1);
}
catch (FormatException)
{
Console.WriteLine("The address specified for " + curStr + " was not in the correct format.");
Environment.Exit(1);
}
catch (DllNotFoundException e)
{
Console.WriteLine("A required DLL was not found, is WinPcap and .NET framework installed?");
Console.WriteLine("Exception Message: " + e.Message);
Console.WriteLine("StackTrace: " + e.StackTrace);
Environment.Exit(1);
}
catch (Exception e)
{
Console.WriteLine("Exception caught while handling commandline.");
Console.WriteLine("Exception Message: " + e.Message);
Console.WriteLine("StackTrace: " + e.StackTrace);
Environment.Exit(1);
}
}
// do some checks to make sure this param combination is valid
if (dIP == null && dMAC == null)
{
Console.WriteLine("-dIP or -dMAC has to be set to send a packet.");
Environment.Exit(1);
}
if (dIP == null &&
(packetType == PacketType.ICMP ||
packetType == PacketType.ICMPv6 ||
packetType == PacketType.IP ||
packetType == PacketType.TCP ||
packetType == PacketType.UDP))
{
Console.WriteLine("dIP needs to be defined for IP based packets.");
Environment.Exit(1);
}
if (packetType == PacketType.ICMPv6 && (dIP == null || !dIP.ToString().Contains(":")))
{
Console.WriteLine("dIP needs to be IPv6 for ICMPv6 packets.");
Environment.Exit(1);
}
else if ((packetType == PacketType.ICMP && (dIP == null || !dIP.ToString().Contains("."))))
{
Console.WriteLine("dIP needs to be IPv4 for ICMP packets.");
Environment.Exit(1);
}
if (ExtentionHeader.Count != 0 && (dIP == null || !dIP.ToString().Contains(":")))
{
Console.WriteLine("dIP needs to be IPv6 for ExtensionHeader packets.");
Environment.Exit(1);
}
if (ExtentionHeader.Count == 1)
{
Console.WriteLine("There needs to be at least 2 extension headers.");
Environment.Exit(1);
}
if (dMAC == null && packetType == PacketType.EtherType)
{
Console.WriteLine("dMAC needs to be defined for EtherType based packets.");
Environment.Exit(1);
}
}
private static object checkPacketType(PacketType p)
{
return p.ToString();
}
public static Packet Read(PacketType type, BigEndianStream stream)
{
try
{
Type ptype;
if(PacketMap.Map.TryGetValue(type, out ptype))
{
Packet packet = (Packet)ptype.GetConstructor(new Type[0]).Invoke(new object[0]);
packet.Read(stream);
return packet;
}
else
{
Console.WriteLine("Error processing packet of type {0}", type);
return null;
}
}
catch (Exception ex)
{
Console.WriteLine("Error processing packet of type {0}: {1}", type.ToString(), ex);
return null;
}
}
/// <summary>
///
/// </summary>
/// <param name="type"></param>
/// <param name="callback"></param>
public void UnregisterCallback(PacketType type, PacketCallback callback)
{
if (!Callbacks.ContainsKey(type))
{
Client.Log("Trying to unregister a callback for packet " + type.ToString() +
" when no callbacks are setup for that packet", Helpers.LogLevel.Info);
return;
}
List<PacketCallback> callbackArray = Callbacks[type];
if (callbackArray.Contains(callback))
{
callbackArray.Remove(callback);
}
else
{
Client.Log("Trying to unregister a non-existant callback for packet " + type.ToString(),
Helpers.LogLevel.Info);
}
}
private void OpenShellOrSubsystem(ISSHChannelEventReceiver receiver, PacketType pt, SSH2DataReader reader, string scheme) {
if(_negotiationStatus==NegotiationStatus.WaitingChannelConfirmation) {
if(pt!=PacketType.SSH_MSG_CHANNEL_OPEN_CONFIRMATION) {
if(pt!=PacketType.SSH_MSG_CHANNEL_OPEN_FAILURE)
receiver.OnChannelError(new SSHException("opening channel failed; packet type="+pt));
else {
int errcode = reader.ReadInt32();
string msg = Encoding.ASCII.GetString(reader.ReadString());
receiver.OnChannelError(new SSHException(msg));
}
Close();
}
else {
_remoteID = reader.ReadInt32();
_allowedDataSize = reader.ReadInt32();
_serverMaxPacketSize = reader.ReadInt32();
//open pty
SSH2DataWriter wr = new SSH2DataWriter();
SSHConnectionParameter param = _connection.Param;
wr.WritePacketType(PacketType.SSH_MSG_CHANNEL_REQUEST);
wr.Write(_remoteID);
wr.Write("pty-req");
wr.Write(true);
wr.Write(param.TerminalName);
wr.Write(param.TerminalWidth);
wr.Write(param.TerminalHeight);
wr.Write(param.TerminalPixelWidth);
wr.Write(param.TerminalPixelHeight);
wr.WriteAsString(new byte[0]);
if(_connection.IsEventTracerAvailable)
_connection.TraceTransmissionEvent(PacketType.SSH_MSG_CHANNEL_REQUEST, "pty-req", "terminal={0} width={1} height={2}", param.TerminalName, param.TerminalWidth, param.TerminalHeight);
TransmitPayload(wr.ToByteArray());
_negotiationStatus = NegotiationStatus.WaitingPtyReqConfirmation;
}
}
else if(_negotiationStatus==NegotiationStatus.WaitingPtyReqConfirmation) {
if(pt!=PacketType.SSH_MSG_CHANNEL_SUCCESS) {
receiver.OnChannelError(new SSHException("opening pty failed"));
Close();
}
else {
//agent request (optional)
if(_connection.Param.AgentForward!=null) {
SSH2DataWriter wr = new SSH2DataWriter();
wr.WritePacketType(PacketType.SSH_MSG_CHANNEL_REQUEST);
wr.Write(_remoteID);
wr.Write("*****@*****.**");
wr.Write(true);
_connection.TraceTransmissionEvent(PacketType.SSH_MSG_CHANNEL_REQUEST, "auth-agent-req", "");
TransmitPayload(wr.ToByteArray());
_negotiationStatus = NegotiationStatus.WaitingAuthAgentReqConfirmation;
}
else {
OpenScheme(scheme);
_negotiationStatus = NegotiationStatus.WaitingShellConfirmation;
}
}
}
else if(_negotiationStatus==NegotiationStatus.WaitingAuthAgentReqConfirmation) {
if(pt!=PacketType.SSH_MSG_CHANNEL_SUCCESS && pt!=PacketType.SSH_MSG_CHANNEL_FAILURE) {
receiver.OnChannelError(new SSHException("auth-agent-req error"));
Close();
}
else { //auth-agent-req is optional
_connection.SetAgentForwardConfirmed(pt==PacketType.SSH_MSG_CHANNEL_SUCCESS);
_connection.TraceReceptionEvent(pt, "auth-agent-req");
OpenScheme(scheme);
_negotiationStatus = NegotiationStatus.WaitingShellConfirmation;
}
}
else if(_negotiationStatus==NegotiationStatus.WaitingShellConfirmation) {
if(pt!=PacketType.SSH_MSG_CHANNEL_SUCCESS) {
receiver.OnChannelError(new SSHException("Opening shell failed: packet type="+pt.ToString()));
Close();
}
else {
receiver.OnChannelReady();
_negotiationStatus = NegotiationStatus.Ready; //goal!
}
}
}
internal void TraceReceptionEvent(PacketType pt, byte[] msg) {
TraceReceptionEvent(pt.ToString(), Encoding.ASCII.GetString(msg));
}
public static Packet Get(PacketType id, bool log = false)
{
Type type;
if (!IdTypes.TryGetValue(id, out type))
{
Uberminer.Log("Unknown packet: 0x" + id.ToString("x"));
return null;
}
var packet = Activator.CreateInstance(type) as Packet;
if (log)
{
packetHistory.Add(packet);
}
return packet;
}
public static Packet Read(PacketType type, BigEndianStream stream)
{
try
{
if (!PacketMap.Map.ContainsKey(type))
{
Console.WriteLine("ERROR Unknown packet type: {0}", type);
return null;
}
Type ptype = PacketMap.Map[type];
Packet packet = (Packet)ptype.GetConstructor(new Type[0]).Invoke(new object[0]);
packet.Read(stream);
return packet;
}
catch (Exception ex)
{
Console.WriteLine("Error processing packet of type {0}: {1}", type.ToString(), ex);
return null;
}
}
public static void InvokeAddModuleAddon(PacketType p, ModuleAddonCallback m)
{
Assembly _Assemblies = Assembly.GetAssembly(ModuleHandler.ModuleAddons.GetType());
Type _Type = ModuleHandler.ModuleAddons.GetType();
// Get the desired method we want from the target type.
MethodInfo _MethodInfo = null;
try
{
_MethodInfo = _Type.GetMethod("Add");
}
catch (Exception ex)
{
return;
}
_MethodInfo.Invoke(ModuleHandler.ModuleAddons, new object[2] { (p.ToString() + "_" + count_i), (object)m });
count_i++;
}
public void Read(PacketReader reader)
{
Type = (PacketType)reader.ReadByte();
Logger.LogToConsole( Type.ToString() );
}
public void SendPacketData(byte[] data, int dataLength, PacketType type, bool doZerocode)
{
UDPPacketBuffer buffer = new UDPPacketBuffer(remoteEndPoint, Packet.MTU);
// Zerocode if needed
if (doZerocode)
{
try { dataLength = Helpers.ZeroEncode(data, dataLength, buffer.Data); }
catch (IndexOutOfRangeException)
{
// The packet grew larger than Packet.MTU bytes while zerocoding.
// Remove the MSG_ZEROCODED flag and send the unencoded data
// instead
data[0] = (byte)(data[0] & ~Helpers.MSG_ZEROCODED);
Buffer.BlockCopy(data, 0, buffer.Data, 0, dataLength);
}
}
else
{
Buffer.BlockCopy(data, 0, buffer.Data, 0, dataLength);
}
buffer.DataLength = dataLength;
#region Queue or Send
NetworkManager.OutgoingPacket outgoingPacket = new NetworkManager.OutgoingPacket(this, buffer);
// Send ACK and logout packets directly, everything else goes through the queue
if (Client.Settings.THROTTLE_OUTGOING_PACKETS == false ||
type == PacketType.PacketAck ||
type == PacketType.LogoutRequest)
{
SendPacketFinal(outgoingPacket);
}
else
{
Network.PacketOutbox.Enqueue(outgoingPacket);
}
#endregion Queue or Send
#region Stats Tracking
if (Client.Settings.TRACK_UTILIZATION)
{
Client.Stats.Update(type.ToString(), OpenMetaverse.Stats.Type.Packet, dataLength, 0);
}
#endregion
}
internal void TraceReceptionEvent(PacketType pt, string message, params object[] args) {
ISSHEventTracer t = _param.EventTracer;
if(t!=null) t.OnReception(pt.ToString(), String.Format(message, args));
}
