IPAddress Scan

hallo welt;

ich will aus einem ip bereich ein scan durchführen. ich weiss im moment aber nicht welche schleife ich dazu verwenden kann um von 192.168.0.1 bis 192.168.1.255 ein scan durchführen zu können.

hat da einer einen tipp?

Hmm sonst wird nach Portscan gefragt!?

Aber gut hier habe ich mal ein Windwos-GUI mit einer Klasse IPCounter
dies ist quasi eine IP-Address die mit einer Methode Add hochzählt
und so von 0.0.0.0 bis 255.255.255.255 hochzählt wird dann nochmal Add aufgeruefen springts wieder auf 0.0.0.0

Die Klasse sieht so aus:

class IPCounter
	{
		private string IPstr;
		public string IP
		{
			get
			{
				return IPstr;
			}
			set
			{
				Regex IpPattern = new Regex(@"(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})");
				if(IpPattern.IsMatch(value) == true)
				{
					IPstr = value;
				}
			}
		}

		public IPCounter(IPCounter ipCounter)
		{
			IPstr = ipCounter.IPstr;
		}

		public IPCounter()
		{
			IP = "0.0.0.0";
		}

		public void Add()
		{
			string [] str = IP.Split('.');
			int [] iArray = new int[4];
			for(int idx = 0;idx < 4;idx++)
			{
				iArray[idx] = int.Parse(str[idx]);
			}

			if( (iArray[3] + 1) == 256)
			{
				iArray[3] = 0;
				if((iArray[2] + 1) == 256)
				{
					iArray[2] = 0;
					if((iArray[1] + 1) == 256)
					{
						iArray[1] = 0;
						if((iArray[0] + 1) == 256 )
						{
							iArray[0] = 0;
						}
						else
						{
							iArray[0]++;
						}
					}
					else
					{
						iArray[1]++;
					}
				}
				else
				{
					iArray[2]++;
				}
			}
			else
			{
				iArray[3]++; 
			}

			IP = iArray[0].ToString() + "." +
				iArray[1].ToString() + "." +
				iArray[2].ToString() + "." +
				iArray[3].ToString();
		}

Und das GUI zum testen so:

using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;

namespace IPCounterTest
{
	/// <summary>
	/// Zusammenfassung für Form1.
	/// </summary>
	public class Form1 : System.Windows.Forms.Form
	{
		private System.Windows.Forms.Timer timer1;
		private System.ComponentModel.IContainer components;
		private System.Windows.Forms.Label label1;

		private IPCounter ipCounter;
		public Form1()
		{
			//
			// Erforderlich für die Windows Form-Designerunterstützung
			//
			InitializeComponent();

			//
			// TODO: Fügen Sie den Konstruktorcode nach dem Aufruf von InitializeComponent hinzu
			//

			ipCounter = new IPCounter();
			ipCounter.IP = "0.0.255.255";
			label1.Text = ipCounter.IP;
		}

		/// <summary>
		/// Die verwendeten Ressourcen bereinigen.
		/// </summary>
		protected override void Dispose( bool disposing )
		{
			if( disposing )
			{
				if (components != null) 
				{
					components.Dispose();
				}
			}
			base.Dispose( disposing );
		}

		#region Vom Windows Form-Designer generierter Code
		/// <summary>
		/// Erforderliche Methode für die Designerunterstützung. 
		/// Der Inhalt der Methode darf nicht mit dem Code-Editor geändert werden.
		/// </summary>
		private void InitializeComponent()
		{
			this.components = new System.ComponentModel.Container();
			this.timer1 = new System.Windows.Forms.Timer(this.components);
			this.label1 = new System.Windows.Forms.Label();
			this.SuspendLayout();
			// 
			// timer1
			// 
			this.timer1.Interval = 350;
			this.timer1.Tick += new System.EventHandler(this.timer1_Tick);
			// 
			// label1
			// 
			this.label1.Location = new System.Drawing.Point(56, 112);
			this.label1.Name = "label1";
			this.label1.Size = new System.Drawing.Size(160, 24);
			this.label1.TabIndex = 0;
			// 
			// Form1
			// 
			this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
			this.ClientSize = new System.Drawing.Size(292, 266);
			this.Controls.Add(this.label1);
			this.Name = "Form1";
			this.Text = "Form1";
			this.Load += new System.EventHandler(this.Form1_Load);
			this.ResumeLayout(false);

		}
		#endregion

		/// <summary>
		/// Der Haupteinstiegspunkt für die Anwendung.
		/// </summary>
		[STAThread]
		static void Main() 
		{
			Application.Run(new Form1());
		}

		private void Form1_Load(object sender, System.EventArgs e)
		{
			timer1.Start();
		}

		private void timer1_Tick(object sender, System.EventArgs e)
		{
			ipCounter.Add();
			label1.Text = ipCounter.IP;
		}
	}

	class IPCounter
	{
		private string IPstr;
		public string IP
		{
			get
			{
				return IPstr;
			}
			set
			{
				Regex IpPattern = new Regex(@"(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})");
				if(IpPattern.IsMatch(value) == true)
				{
					IPstr = value;
				}
			}
		}

		public IPCounter(IPCounter ipCounter)
		{
			IPstr = ipCounter.IPstr;
		}

		public IPCounter()
		{
			IP = "0.0.0.0";
		}

		public void Add()
		{
			string [] str = IP.Split('.');
			int [] iArray = new int[4];
			for(int idx = 0;idx < 4;idx++)
			{
				iArray[idx] = int.Parse(str[idx]);
			}

			if( (iArray[3] + 1) == 256)
			{
				iArray[3] = 0;
				if((iArray[2] + 1) == 256)
				{
					iArray[2] = 0;
					if((iArray[1] + 1) == 256)
					{
						iArray[1] = 0;
						if((iArray[0] + 1) == 256 )
						{
							iArray[0] = 0;
						}
						else
						{
							iArray[0]++;
						}
					}
					else
					{
						iArray[1]++;
					}
				}
				else
				{
					iArray[2]++;
				}
			}
			else
			{
				iArray[3]++; 
			}

			IP = iArray[0].ToString() + "." +
				iArray[1].ToString() + "." +
				iArray[2].ToString() + "." +
				iArray[3].ToString();
		}
	}
}

einfach mal Copy&Paste machen

Gruss sclearscreen

P.S.: Vielleicht hätte ich die Klasse besser IPIncrement nennen sollen?
Naja aber das Beispiel soll ja nur die funktion verdeutlichen.

Müsstes Dir noch in der Klasse den == Operator reinbringen oder eine Equals-Methode damit Du 2 IP vergleichen kannst wolltest ja innerhalb eines bestimmten Bereiches hochzählen.

Damit Du im Bereich bleibst brauchst Du eine Vergleichsmöglichkeit, desahalb
musst Du eine Möglichkeit einbauen 2 IPCounter-Objekte miteinander vergleichen zu können.

eigentlich wollte ich wissen wie ich bei einer IP Adresse nochzählen kann.
z.b. wie bei Interget:
int++;

Na und das Ding zählt musst halt nurnoch konvertieren!
Wo ist das Problem?

An der Stelle konvertiere ich auch in meiner Klasse:

string [] str = IP.Split('.'); 
            int [] iArray = new int[4]; 
            for(int idx = 0;idx < 4;idx++) 
            { 
                iArray[idx] = int.Parse(str[idx]); 
            }

Was spricht also dagegen es in die andere Richtung zu konvertieren!?!
Du weisst Doch wie sowas geht vermute ich woher soll ich wissen das Du
int benutzt?

dann musst Dir halt von Deinem 32Bit-Int per Shift die 4 jeweiligen Byte rausholen Die jeweils hochzählen
und den Kram dan wieder zu einem 32Bit-Int zusammenbauen.

Ich habe einen String genommen weil die konkreten Objekt für Sockets
auch Überladungen haben wo ich die IP-Addresse als String übergeben kann.
Guck Dir doch die Dns-Klasse des .NET an.

Manche Objekte in dem Berich arbeiten auch mit einem Byte-Array aus 4 Byte.
Mit der Klasse bin ich zumindest bei diesen Variatonen flexibler als
wenn ich diese Address in meiner Geschäftslogik als int ausdrücke.

So ist es dann viel einfacher über TextBoxen zu arbeiten!

Molarie schrieb:

eigentlich wollte ich wissen wie ich bei einer IP Adresse nochzählen kann.
z.b. wie bei Interget:
int++;

Und meine Add-Methode zählt den Kram hoch. Also nurnoch konvertieren und fertig.

Nur die Klasse mit noch schönerer Funktionalität!

using System.Text.RegularExpressions;
using System.Net;
using System; 

namespace IPCounterTest
{
	class IPCounter
	{
		private string IPstr;
		public string IP
		{
			get
			{
				return IPstr;
			}
			set
			{
				Regex IpPattern = new Regex(@"(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})");
				if(IpPattern.IsMatch(value) == true)
				{
					IPstr = value;
				}
			}
		}

		public IPCounter(IPCounter ipCounter)
		{
			IPstr = ipCounter.IPstr;
		}

		public IPCounter()
		{
			IP = "0.0.0.0";
		}

		public void Add()
		{
			string [] str = IP.Split('.');
			int [] iArray = new int[4];
			for(int idx = 0;idx < 4;idx++)
			{
				iArray[idx] = int.Parse(str[idx]);
			}

			if( (iArray[3] + 1) == 256)
			{
				iArray[3] = 0;
				if((iArray[2] + 1) == 256)
				{
					iArray[2] = 0;
					if((iArray[1] + 1) == 256)
					{
						iArray[1] = 0;
						if((iArray[0] + 1) == 256 )
						{
							iArray[0] = 0;
						}
						else
						{
							iArray[0]++;
						}
					}
					else
					{
						iArray[1]++;
					}
				}
				else
				{
					iArray[2]++;
				}
			}
			else
			{
				iArray[3]++; 
			}

			IP = iArray[0].ToString() + "." +
				iArray[1].ToString() + "." +
				iArray[2].ToString() + "." +
				iArray[3].ToString();
		}

		public byte [] ToByteArray()
		{
			string [] str = IP.Split('.');
			byte [] bArray = new byte[4];

			for(int idx = 0;idx < 4;idx++)
			{
				bArray[idx] = Convert.ToByte(str[idx]);
			}

			return bArray;
		}

		public IPEndPoint ToIPEndPoint(int iPort)
		{
			IPAddress ipAddres = new IPAddress(ToByteArray());
			IPEndPoint ipEndPoint = new IPEndPoint(ipAddres, iPort);

			return ipEndPoint;
		}
	}
}

Die zwei letzten Methoden sollten ins Auge springen.

Aber wie gesagt Du kannst auch mit "bit shifting" über die Binären Operatoren für einen Integer arbeiten.

Dann kann man sich auch diese Byte (4 Stueck) rausshiften und die Hochzählen.

Und über die 4 einzelnen Byte einen Patchworkinteger wieder zusammenshiften.

Aber das erfordert dann auch wieder passend machen bei den ganzen IPzeugs des .NET weil manche Objekte eben eine String wollen und der wieder ein Byte-Array.
Wenn Du sagst der Shift ist schneller ja da stimme ich zu aber das hebt sich dann wieder auf wenn Du Deinen Integer in eine Byte-Array oder einen String umbauen musst bei einem Objekt des .NET-Framework.

mfg sclearscreen

using System.Text.RegularExpressions;
using System.Net;
using System; 

namespace IPCounterTest
{
	class IPCounter
	{
		private string IPstr;
		public string IP
		{
			get
			{
				return IPstr;
			}
			set
			{
				Regex IpPattern = new Regex(@"(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})");
				if(IpPattern.IsMatch(value) == true)
				{
					IPstr = value;
				}
			}
		}

		public IPCounter(IPCounter ipCounter)
		{
			IPstr = ipCounter.IPstr;
		}

		public IPCounter()
		{
			IP = "0.0.0.0";
		}

		public void Sub()
		{
			string [] str = IP.Split('.');
			int [] iArray = new int[4];
			for(int idx = 0;idx < 4;idx++)
			{
				iArray[idx] = int.Parse(str[idx]);
			}

			if( (iArray[3] - 1) == -1)
			{
				iArray[3] = 255;
				if((iArray[2] - 1) == -1)
				{
					iArray[2] = 255;
					if((iArray[1] - 1) == -1)
					{
						iArray[1] = 255;
						if((iArray[0] - 1) == -1)
						{
							iArray[0] = 255;
						}
						else
						{
							iArray[0]--;
						}
					}
					else
					{
						iArray[1]--;
					}
				}
				else
				{
					iArray[2]--;
				}
			}
			else
			{
				iArray[3]--; 
			}

			IP = iArray[0].ToString() + "." +
				iArray[1].ToString() + "." +
				iArray[2].ToString() + "." +
				iArray[3].ToString();
		}

		public void Add()
		{
			string [] str = IP.Split('.');
			int [] iArray = new int[4];
			for(int idx = 0;idx < 4;idx++)
			{
				iArray[idx] = int.Parse(str[idx]);
			}

			if( (iArray[3] + 1) == 256)
			{
				iArray[3] = 0;
				if((iArray[2] + 1) == 256)
				{
					iArray[2] = 0;
					if((iArray[1] + 1) == 256)
					{
						iArray[1] = 0;
						if((iArray[0] + 1) == 256 )
						{
							iArray[0] = 0;
						}
						else
						{
							iArray[0]++;
						}
					}
					else
					{
						iArray[1]++;
					}
				}
				else
				{
					iArray[2]++;
				}
			}
			else
			{
				iArray[3]++; 
			}

			IP = iArray[0].ToString() + "." +
				iArray[1].ToString() + "." +
				iArray[2].ToString() + "." +
				iArray[3].ToString();
		}

		public byte [] ToByteArray()
		{
			string [] str = IP.Split('.');
			byte [] bArray = new byte[4];

			for(int idx = 0;idx < 4;idx++)
			{
				bArray[idx] = Convert.ToByte(str[idx]);
			}

			return bArray;
		}

		public IPEndPoint ToIPEndPoint(int iPort)
		{
			IPAddress ipAddres = new IPAddress(ToByteArray());
			IPEndPoint ipEndPoint = new IPEndPoint(ipAddres, iPort);

			return ipEndPoint;
		}
	}
}

kann man ganz oben mit dem Gui testen
Sub/Add-Methode zählen immer um 1 Addresse zurück bzw. vor.
Das ganze ums pomböser zu machen mit der generierung eines richtigen
IPEndPoint-Objektes auf einen Port!

Gruss sclearscreen

P.S.: Andere Sonderwünsche bitte selbst reinbauen.
In Verbindung mit meine IP-TextBox bin ich damit über
Zeichenketten flexibler als mit einem Integer wo ich über
shifting die Byte manipulieren müsste.