public static string GetNetworkAddressAsString(IPAddress address, IPAddress mask) { string netIP = ""; // Network address as string int networkLength = 0; if (null != mask) { for (int i = 0; i < 4; i++) { byte ba = address.GetAddressBytes()[i]; byte bm = mask.GetAddressBytes()[i]; netIP += ba & bm; if (i < 3) netIP += "."; networkLength += 8 - (int)System.Math.Truncate(System.Math.Log(256 - bm, 2)); } netIP += "/" + networkLength; } else { netIP = address.ToString() + "/32"; } return netIP; }
public sockaddr_in6(IPAddress address) { if (address.AddressFamily == AddressFamily.InterNetworkV6) { this.sin6_addr = address.GetAddressBytes(); this.sin6_scope_id = (uint) address.ScopeId; } else { byte[] addressBytes = address.GetAddressBytes(); this.sin6_addr = new byte[0x10]; for (int i = 0; i < 10; i++) { this.sin6_addr[i] = 0; } this.sin6_addr[10] = 0xff; this.sin6_addr[11] = 0xff; for (int j = 12; j < 0x10; j++) { this.sin6_addr[j] = addressBytes[j - 12]; } this.sin6_scope_id = 0; } this.sin6_family = 0x17; this.sin6_port = 0; this.sin6_flowinfo = 0; }
public SocketAddress(IPAddress ipAddress) : this(ipAddress.AddressFamily, ipAddress.AddressFamily == AddressFamily.InterNetwork ? 16 : 28) { this.m_buffer[2] = (byte)0; this.m_buffer[3] = (byte)0; if (ipAddress.AddressFamily == AddressFamily.InterNetworkV6) { this.m_buffer[4] = (byte)0; this.m_buffer[5] = (byte)0; this.m_buffer[6] = (byte)0; this.m_buffer[7] = (byte)0; long scopeId = ipAddress.ScopeId; this.m_buffer[24] = (byte)scopeId; this.m_buffer[25] = (byte)(scopeId >> 8); this.m_buffer[26] = (byte)(scopeId >> 16); this.m_buffer[27] = (byte)(scopeId >> 24); byte[] addressBytes = ipAddress.GetAddressBytes(); for (int index = 0; index < addressBytes.Length; ++index) this.m_buffer[8 + index] = addressBytes[index]; } else { System.Buffer.BlockCopy(ipAddress.GetAddressBytes(), 0, m_buffer, 4, 4); } }
public WhoisTask(IPAddress ip) { StringBuilder host = new StringBuilder(); switch (ip.AddressFamily) { // Turn the address into its in-addr.arpa form. case System.Net.Sockets.AddressFamily.InterNetwork: foreach (byte octet in ip.GetAddressBytes().Reverse()) { host.Append(octet.ToString() + "."); } host.Append("in-addr.arpa"); break; // Turn the address into its ip6.arpa form. case System.Net.Sockets.AddressFamily.InterNetworkV6: foreach (byte octet in ip.GetAddressBytes().Reverse()) { string hex = string.Format("{0:x2}", octet); host.Append(string.Format("{0}.{1}.", hex[1], hex[0])); } host.Append("ip6.arpa"); break; } Host = host.ToString(); }
public unsafe void BlockSource(IPAddress groupAdress, IPAddress sourceAdress, uint interfaceIndex = 0) { if (groupAdress.AddressFamily != sourceAdress.AddressFamily) throw new ArgumentException("Address family must be the same"); var adress = groupAdress.GetAddressBytes(); var sourceadress = groupAdress.GetAddressBytes(); if (groupAdress.AddressFamily == AddressFamily.InterNetwork) { ip_mreq_source value = new ip_mreq_source(); value.imr_interface.s_b4 = (byte)interfaceIndex; fixed (byte* a = adress) Unsafe.CopyBlock(value.imr_multiaddr.Address, a, (uint)adress.Length); fixed (byte* a = sourceadress) Unsafe.CopyBlock(value.imr_multiaddr.Address, a, (uint)sourceadress.Length); if (SetSocketOption(IPPROTO_IP_SocketOptions.IP_BLOCK_SOURCE, (void*)&value, Marshal.SizeOf<ip_mreq_source>()) != 0) WinSock.ThrowLastWSAError(); } else if (groupAdress.AddressFamily == AddressFamily.InterNetworkV6) { //ipv6_mreq value = new ipv6_mreq(); //value.ipv6mr_interface = interfaceIndex; //fixed (byte* a = adress) // Unsafe.CopyBlock(value.ipv6mr_multiaddr.Address, a, (uint)adress.Length); //if (SetSocketOption(IPPROTO_IPV6_SocketOptions., (void*)&value, Marshal.SizeOf<ipv6_mreq>()) != 0) // WinSock.ThrowLastWSAError(); } }
public static string FormatIp(IPAddress ipa) { string ipData = string.Empty; if (ipa.AddressFamily == AddressFamily.InterNetwork) { ipData = "IPv4"; foreach (byte b in ipa.GetAddressBytes()) { if (ipData[ipData.Length - 1] != ' ') ipData += "."; ipData += string.Format("{0}", b); } } else { ipData = "IPv6"; byte[] bytes = ipa.GetAddressBytes(); for (int i = 0; i < bytes.Length; i = i + 2) { if (ipData[ipData.Length - 1] != ' ') ipData += ":"; byte b = bytes[i]; ipData += string.Format("{0:X2}", b); b = bytes[i + 1]; ipData += string.Format("{0:X2}", b); } } return ipData; }
public static IPAddress CloneAddress(IPAddress source, bool maskScopeId) { if (maskScopeId || V4Address(source)) { return new IPAddress(source.GetAddressBytes()); } return new IPAddress(source.GetAddressBytes(), source.ScopeId); }
private static long IPToLong(IPAddress address) { MemoryStream ms = new MemoryStream(); ms.Write(address.GetAddressBytes(), 0, address.GetAddressBytes().Length); while (ms.Length < 8) ms.WriteByte(0); return System.BitConverter.ToInt64(ms.ToArray(), 0); }
public InternetAddress(IPAddress address) { if (address == null || address.GetAddressBytes().Length != 4) { _address = null; } _address = address.GetAddressBytes(); }
public NetAddr(Services services, IPAddress address, UInt16 port) { this.services = services; this.address = address; this.port = port; if (address.GetAddressBytes().Length != 16) this.address = new IPAddress((new Byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF }) .Concat(address.GetAddressBytes()).ToArray()); }
public IPNetwork(IPAddress prefix, int prefixLength) { Prefix = prefix; PrefixLength = prefixLength; PrefixBytes = Prefix.GetAddressBytes(); Mask = CreateMask(); }
public bool IsInRange(IPAddress address) { if (address.AddressFamily != addressFamily) { return false; } var addressBytes = address.GetAddressBytes(); bool lowerBoundary = true, upperBoundary = true; for (var i = 0; i < lowerBytes.Length && (lowerBoundary || upperBoundary); i++) { if ((lowerBoundary && addressBytes[i] < lowerBytes[i]) || (upperBoundary && addressBytes[i] > upperBytes[i])) { return false; } lowerBoundary &= (addressBytes[i] == lowerBytes[i]); upperBoundary &= (addressBytes[i] == upperBytes[i]); } return true; }
public static bool IsInRange(this IPAddress address, IPAddress start, IPAddress end) { AddressFamily addressFamily = start.AddressFamily; byte[] lowerBytes = start.GetAddressBytes(); byte[] upperBytes = end.GetAddressBytes(); if (address.AddressFamily != addressFamily) { return false; } byte[] addressBytes = address.GetAddressBytes(); bool lowerBoundary = true, upperBoundary = true; for (int i = 0; i < lowerBytes.Length && (lowerBoundary || upperBoundary); i++) { if ((lowerBoundary && addressBytes[i] < lowerBytes[i]) || (upperBoundary && addressBytes[i] > upperBytes[i])) { return false; } lowerBoundary &= (addressBytes[i] == lowerBytes[i]); upperBoundary &= (addressBytes[i] == upperBytes[i]); } return true; }
public static IPAddress UintToIP(uint ipaddr, bool reverse = false, bool IsLittleEndian = true) { //fix endianess from network if (IsLittleEndian) { ipaddr = ( (ipaddr << 24) & 0xFF000000) + ((ipaddr << 8) & 0x00FF0000) + ((ipaddr >> 8) & 0x0000FF00) + ((ipaddr >> 24) & 0x000000FF ); } else { ipaddr = ( ((ipaddr >> 24) & 0x000000FF + ((ipaddr >> 8) & 0x0000FF00) + ((ipaddr << 8) & 0x00FF0000) + (ipaddr << 24) & 0xFF000000) ); } var result = new System.Net.IPAddress(ipaddr); if (reverse) { result = new IPAddress(result.GetAddressBytes().Reverse().ToArray()); } return(result); }
private int ProcessSHandshake(Protocol _p) { Handshake.SHandshake p = (Handshake.SHandshake)_p; if (DHContext.TryGetValue(p.Sender.SessionId, out var dhRandom)) { Array.Reverse(p.Argument.dh_data); byte[] material = Handshake.Helper.computeDHKey( Config.HandshakeOptions.DhGroup, new BigInteger(p.Argument.dh_data), dhRandom).ToByteArray(); Array.Reverse(material); System.Net.IPAddress ipaddress = ((IPEndPoint)p.Sender.Socket.RemoteEndPoint).Address; if (ipaddress.IsIPv4MappedToIPv6) { ipaddress = ipaddress.MapToIPv4(); } byte[] key = ipaddress.GetAddressBytes(); logger.Debug("{0} remoteip={1}", p.Sender.SessionId, BitConverter.ToString(key)); int half = material.Length / 2; byte[] hmacMd5 = Digest.HmacMd5(key, material, 0, half); p.Sender.SetOutputSecurityCodec(hmacMd5, p.Argument.c2sneedcompress); hmacMd5 = Digest.HmacMd5(key, material, half, material.Length - half); p.Sender.SetInputSecurityCodec(hmacMd5, p.Argument.s2cneedcompress); DHContext.TryRemove(p.Sender.SessionId, out var _); new Handshake.CHandshakeDone().Send(p.Sender); OnHandshakeDone(p.Sender); return(0); } throw new Exception("handshake lost context."); }
public static uint ReToNumIP(string ip) { if (ip == null || ip.Length < 1) { return(0); } uint IP = 0; byte[] addbyte = new byte[128]; try { System.Net.IPAddress ipaddr = System.Net.IPAddress.Parse(ip); addbyte = ipaddr.GetAddressBytes(); byte[] IPByte = new byte[4]; IPByte[0] = addbyte[3]; IPByte[1] = addbyte[2]; IPByte[2] = addbyte[1]; IPByte[3] = addbyte[0]; IP = System.BitConverter.ToUInt32(IPByte, 0); } catch (System.Exception e1) { Tools.WriteLog("ICS AdminPortal", e1.ToString(), System.Diagnostics.EventLogEntryType.Error); return(0); } return(IP); }
public void Initial(System.Net.IPAddress startIP, System.Net.IPAddress endIP) { if (Helper.Compare(startIP, endIP) == 1) { var tempIp = endIP; endIP = startIP; startIP = tempIp; } ltbxIPAddressesRange.DataSource = null; var IPAddressesRange = new List <System.Net.IPAddress>(); var startIPBytesArray = startIP.GetAddressBytes(); var endIPBytesArray = endIP.GetAddressBytes(); Array.Reverse(startIPBytesArray); Array.Reverse(endIPBytesArray); _startIP = BitConverter.ToUInt32(startIPBytesArray, 0); _endIP = BitConverter.ToUInt32(endIPBytesArray, 0); double pagesCount = ((double)_endIP + 1) / (double)_recordsPerPage; _totalPages = (int)(Math.Ceiling(pagesCount)); _currentPage = _totalPages > 0 ? 1 : 0; if (_totalPages > 1) { EnableNavigation(true); } navigation.CurrentPage = _currentPage; navigation.TotalPages = _totalPages; }
private List <string> get_ip_list(string start_ip, string end_ip) { System.Net.IPAddress startIP = System.Net.IPAddress.Parse(start_ip); System.Net.IPAddress lastIP = System.Net.IPAddress.Parse(end_ip); byte [] beginIP = startIP.GetAddressBytes(); byte [] endIP = lastIP.GetAddressBytes(); int capacity = 1; for (int i = 0; i < 4; i++) { capacity *= endIP[i] - beginIP[i] + 1; } List <string> ips = new List <string>(capacity); for (int i0 = beginIP[0]; i0 <= endIP[0]; i0++) { for (int i1 = beginIP[1]; i1 <= endIP[1]; i1++) { for (int i2 = beginIP[2]; i2 <= endIP[2]; i2++) { for (int i3 = beginIP[3]; i3 <= endIP[3]; i3++) { ips.Add(new IPAddress(new byte[] { (byte)i0, (byte)i1, (byte)i2, (byte)i3 }).ToString()); } } } } return(ips); }
public static OSD FromIP(IPAddress address) { if (address != null && address != IPAddress.Any) return OSD.FromBinary(address.GetAddressBytes()); else return new OSD(); }
// get IPv6 pseudo-header (adapted from: http://www.winsocketdotnetworkprogramming.com/clientserversocketnetworkcommunication8f_3.html) public static byte[] GetPseudoHeader(IPAddress sourceIP, IPAddress destinationIP, int icmpv6Length, int nextHeader) { byte[] pseudoHeader, byteValue; int offset = 0, payLoadLength; // now build the pseudo header pseudoHeader = new byte[40]; byteValue = sourceIP.GetAddressBytes(); Array.Copy(byteValue, 0, pseudoHeader, offset, byteValue.Length); offset += byteValue.Length; byteValue = destinationIP.GetAddressBytes(); Array.Copy(byteValue, 0, pseudoHeader, offset, byteValue.Length); offset += byteValue.Length; // Packet total length payLoadLength = IPAddress.HostToNetworkOrder(4 + icmpv6Length); byteValue = BitConverter.GetBytes(payLoadLength); Array.Copy(byteValue, 0, pseudoHeader, offset, byteValue.Length); offset += byteValue.Length; // 3 bytes of zero padding pseudoHeader[offset++] = (byte)0; pseudoHeader[offset++] = (byte)0; pseudoHeader[offset++] = (byte)0; pseudoHeader[offset++] = (byte)nextHeader; return pseudoHeader; }
public static IPAddress GetMatchingLocalIP(IPAddress clientAddr) { if (clientAddr.Equals(IPAddress.Any) || clientAddr.Equals(IPAddress.Loopback)) { return IPAddress.Loopback; } var clientBytes = clientAddr.GetAddressBytes(); // find an address that matches the most significant n-1 bytes of the address of the connecting client foreach (var addr in CachedHostEntry.AddressList) { var bytes = addr.GetAddressBytes(); if (bytes.Length != clientBytes.Length) continue; var match = true; for (var i = bytes.Length-2; i >= 0; i--) { if (bytes[i] != clientBytes[i]) { match = false; break; } } if (match) return addr; } return null; }
public static unsafe IPHostEntry GetHostByAddr(IPAddress addr) { // TODO #2891: Optimize this (or decide if this legacy code can be removed): byte[] addressBytes = addr.GetAddressBytes(); var address = new Interop.libc.in_addr { s_addr = unchecked((uint)BitConverter.ToInt32(addressBytes, 0)) }; int bufferSize = 512; byte* stackBuffer = stackalloc byte[bufferSize]; var hostent = default(Interop.libc.hostent); var result = (Interop.libc.hostent*)null; if (TryGetHostByAddr(address, stackBuffer, bufferSize, &hostent, &result)) { return CreateHostEntry(result); } for (; ;) { bufferSize *= 2; fixed (byte* heapBuffer = new byte[bufferSize]) { if (TryGetHostByAddr(address, heapBuffer, bufferSize, &hostent, &result)) { return CreateHostEntry(result); } } } }
public void Initialize(Nic targetNic, IPAddress from = null, IPAddress to = null) { if (from == null) from = targetNic.Ip.V4.PrimaryUnicast.Network.FirstAddress; if (to == null) to = targetNic.Ip.V4.PrimaryUnicast.Network.LastAddress; uint firstUint = BitConverter.ToUInt32(from.GetAddressBytes().Reverse().ToArray(), 0); uint lastUint = BitConverter.ToUInt32(to.GetAddressBytes().Reverse().ToArray(), 0); //for (uint i = firstUint; i <= lastUint; i++) for (uint i = firstUint; i <= lastUint; i++) { var ipAddress = new IPAddress(BitConverter.GetBytes(i).Reverse().ToArray()); var hostScan = new HostScan(ipAddress, targetNic.Ip.V4.PrimaryUnicast.Address); hostScan.Options = Options.HostScanOptions; hostScan.Options.Dns.DnsServer = targetNic.Raw.IpProperties.DnsAddresses.FirstOrDefault(x => x.AddressFamily == AddressFamily.InterNetwork); hostScan.State.Online += HostOnline; hostScan.State.Completed += HostScanCompleted; _scans.Add(hostScan); } Results.SetTotalScans((ushort) Scans.Count); Results.SetLocalNic(targetNic); }
public void Initialize(Nic targetNic, IPAddress from = null, IPAddress to = null) { if (from == null) from = targetNic.Ip.V4.PrimaryUnicast.Network.FirstAddress; if (to == null) to = targetNic.Ip.V4.PrimaryUnicast.Network.LastAddress; uint firstUint = BitConverter.ToUInt32(from.GetAddressBytes().Reverse().ToArray(), 0); uint lastUint = BitConverter.ToUInt32(to.GetAddressBytes().Reverse().ToArray(), 0); //for (uint i = firstUint; i <= lastUint; i++) for (uint i = firstUint; i <= lastUint; i++) { var ipAddress = new IPAddress(BitConverter.GetBytes(i).Reverse().ToArray()); var observer = new HostObserver(ipAddress, targetNic.Ip.V4.PrimaryUnicast.Address); observer.Options = Options.HostObserver; //hostChangeDetector.Options.Dns.DnsServer = targetNic.Raw.IpProperties.DnsAddresses.FirstOrDefault(x => x.AddressFamily == AddressFamily.InterNetwork); observer.State.ObserverSucceeded += ObserverSucceeded; observer.State.Activated += ObserverActivated; observer.State.Deactivated += ObserverDeactivated; _detectors.Add(observer); } Results.SetLocalNic(targetNic); }
public POIBroadcast() { //Find current broadcast address broadCastAddr = IPAddress.Parse("192.168.1.255"); IPAddress[] localAddresses = Dns.GetHostAddresses(Dns.GetHostName()); foreach (IPAddress ip in localAddresses) { if (ip.AddressFamily == AddressFamily.InterNetwork) { //Find local address localAddr = ip; Console.WriteLine(ip.ToString()); //Find broadcast address byte[] bcBytes = IPAddress.Broadcast.GetAddressBytes(); Array.Copy(localAddr.GetAddressBytes(), bcBytes, 3); broadCastAddr = new IPAddress(bcBytes); Console.WriteLine(broadCastAddr.ToString()); } } //Initialize a broadcast channel using UDP broadCastChannel = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); broadCastChannel.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Broadcast, true); }
public void ApplyServerHostnamePatch(IPAddress ipAddress) { if (ipAddress == null) throw new ArgumentNullException("ipAddress"); ApplyServerHostnamePatch(ipAddress.GetAddressBytes()); }
public bool IsInRange(IPAddress address) { // Some people just have to be like that... if (address.AddressFamily != Family || address.GetLength() != LowerBoundary.Length) return false; var bytes = address.GetAddressBytes(); var lowerBoundary = true; var upperBoundary = true; for (var i = 0; i < LowerBoundary.Length && (lowerBoundary || upperBoundary); i++) { var currentByte = bytes[i]; var lowerByte = LowerBoundary[i]; var upperByte = UpperBoundary[i]; if ((lowerBoundary && currentByte < lowerByte) || (upperBoundary && currentByte > upperByte)) return false; lowerBoundary &= currentByte == lowerByte; upperBoundary &= currentByte == upperByte; } return true; }
public static IPAddress GetNetworkAddress(this IPAddress address, IPAddress subnetMask) { var ipAdressBytes = address.GetAddressBytes(); var subnetMaskBytes = subnetMask.GetAddressBytes(); return new IPAddress(GetNetworkAddressBytes(ipAdressBytes, subnetMaskBytes)); }
public static bool CompareAddresses(Net.IPAddress a, Net.IPAddress b) { bool res = true; if ((a == null) && (b == null)) { return(true); } if ((a == null) || (b == null)) { return(false); } if (a.AddressFamily != b.AddressFamily) { return(false); } if (a.AddressFamily == Net.Sockets.AddressFamily.InterNetworkV6) { //IPAddress.Equals works wrong for ipv6 if address has different scope id byte[] bytesA = a.GetAddressBytes(); byte[] bytesB = b.GetAddressBytes(); for (int i = 0; i < bytesA.Length; i++) { if (bytesA[i] != bytesB[i]) { return(false); } } } else { res = IPAddress.Equals(a, b); } return(res); }
public static IPAddress GetLocalAddressFromRadioAddress(IPAddress radioAddress, int iIgnoreBytes) { NetworkInterface[] intfList = GetAvailableInterfaces(); byte[] ipBytes = radioAddress.GetAddressBytes(); if (ipBytes == null) return null; if (intfList == null || intfList.Length <= 0) return null; foreach (NetworkInterface ni in intfList) { IPInterfaceProperties ipProps = ni.GetIPProperties(); foreach (UnicastIPAddressInformation uip in ipProps.UnicastAddresses) { byte[] uipByes = uip.Address.GetAddressBytes(); if (uipByes == null) continue; if (uipByes.Length == ipBytes.Length) { bool b = true; for (int i = 0; i < uipByes.Length - iIgnoreBytes; i++) { b &= (uipByes[i] == ipBytes[i]); } if (b) { return uip.Address; } } } } return null; }
private static IPAddress ParseIPv6AddressScope(Uri uri, IPAddress ipWithoutScope) { // Sometimes this can be escaped, sometimes not var idnHost = WebUtility.UrlDecode(uri.DnsSafeHost); // IdnHost is preferred in .NET 4.6 var hostWithScopeParts = idnHost.Split(new[] { '%' }, 2); // Did they provide a scope? IPAddress ipWithScope; if (hostWithScopeParts.Length > 1) { var scopeName = hostWithScopeParts[1]; // Just in case Syncthing ever starts returning proper scope IDs... long scopeId; if (!Int64.TryParse(scopeName, out scopeId)) { var scopeLevel = ipWithoutScope.IsIPv6SiteLocal ? ScopeLevel.Site : ScopeLevel.Interface; // I've seen Go produce ID and Name var network = NetworkInterface.GetAllNetworkInterfaces().FirstOrDefault(x => x.Id == scopeName || x.Name == scopeName); if (network == null) throw new FormatException($"Unable to find an interface with name {scopeName}"); scopeId = network.GetIPProperties().GetIPv6Properties().GetScopeId(scopeLevel); } ipWithScope = new IPAddress(ipWithoutScope.GetAddressBytes(), scopeId); } else { ipWithScope = ipWithoutScope; } return ipWithScope; }
public static IObservable<UdpReceiveResult> CreateListener(IPAddress remoteAddress, int port) { if (remoteAddress == null) throw new ArgumentNullException(nameof(remoteAddress)); if (port < 0 || port > 65535) throw new ArgumentOutOfRangeException(nameof(port), port, null); IPHostEntry host = Dns.GetHostEntry(Dns.GetHostName()); var remoteIPBytes = remoteAddress.GetAddressBytes(); var localAddress = host.AddressList.FirstOrDefault(ip => ip.AddressFamily == remoteAddress.AddressFamily && ip.GetAddressBytes().Take(3).SequenceEqual(remoteIPBytes.Take(3))); if (localAddress == null) throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Resources.ExceptionMessages.Net_NoInterfaceInSameNetwork, remoteAddress, port)); var localEndPoint = new IPEndPoint(localAddress, port); var remoteEndPoint = new IPEndPoint(remoteAddress, port); return Observable.Using( () => { var client = new UdpClient { ExclusiveAddressUse = false }; client.Client.Bind(localEndPoint); client.Connect(remoteEndPoint.Address, 0); return client; }, client => Observable.While(() => client.Client.Connected, Observable.FromAsync(client.ReceiveAsync))); }
public long ip2long(String ip) { System.Net.IPAddress ipaddress = System.Net.IPAddress.Parse(ip); byte[] bytes = ipaddress.GetAddressBytes(); Array.Reverse(bytes); return(BitConverter.ToUInt32(bytes, 0)); }
public static bool NetAddressIncludesIPAddress(string netaddress, IPAddress target) { int slash = netaddress.IndexOf('/'); int bits = Int32.Parse(netaddress.Substring(slash + 1)); IPAddress net = IPAddress.Parse(netaddress.Substring(0, slash)); if (net.AddressFamily != target.AddressFamily) return false; byte[] bnet = net.GetAddressBytes(); byte[] btarget = target.GetAddressBytes(); Debug.Assert(bnet.Length == btarget.Length); for (int i = 0; i < bnet.Length; i++) { byte b1 = bnet[i]; byte b2 = btarget[i]; if (bits <= 0) return true; else if (bits >= 8) { if (b1 != b2) return false; } else { b1 >>= (8 - bits); b2 >>= (8 - bits); if (b1 != b2) return false; } bits -= 8; } return true; }
private static IResourceRecord Create(Domain domain, IPAddress ip, TimeSpan ttl) { byte[] data = ip.GetAddressBytes(); RecordType type = data.Length == 4 ? RecordType.A : RecordType.AAAA; return new ResourceRecord(domain, data, type, RecordClass.IN, ttl); }
public void UpdateAccountValues(UInt64 accId, UInt32 oneTimeKey, UInt32 sessId1, UInt32 sessId2, IPAddress ipa) { try { var off = ipa.AddressFamily == AddressFamily.InterNetworkV6 ? 12 : 0; var lastIp = String.Format("{0}.{1}.{2}.{3}", ipa.GetAddressBytes()[off + 0], ipa.GetAddressBytes()[off + 1], ipa.GetAddressBytes()[off + 2], ipa.GetAddressBytes()[off + 3]); lock (DataAccess.DatabaseAccess) using (var comm = DataAccess.DatabaseAccess.CreateCommand(String.Format("UPDATE `account` SET `OneTimeKey` = {0}, `SessionId1` = {1}, `SessionId2` = {2}, `LastIP` = '{3}' WHERE `Id` = {4}", oneTimeKey, sessId1, sessId2, lastIp, accId))) comm.ExecuteNonQuery(); } catch (Exception e) { Logger.WriteLog("Exception in UpdateAccountValues! Exception: {0}", LogType.Error, e); } }
public int addIPRangeToPool(IPAddress start, IPAddress end, IPAddress netmask) { byte[] data; data = start.GetAddressBytes(); UInt32 range_start = EndianBitConverter.Big.ToUInt32( data, 0 ); data = end.GetAddressBytes(); UInt32 range_stop = EndianBitConverter.Big.ToUInt32(data, 0); int count = 0; if (range_start <= range_stop) { IPAddress ip; lock (ip_pool) { for (UInt32 i = range_start; i <= range_stop; i++) { ip = new IPAddress(EndianBitConverter.Big.GetBytes(i)); if (!hasNattedIP(ip)) { ip_pool.Add(new xbs_nat_entry(null, null, ip, netmask)); count++; } } } xbs_messages.addDebugMessage("% NAT IP pool filled with " + count + " ip addresses. Total count of IPs in pool: " + ip_pool.Count, xbs_message_sender.NAT); } return count; }
/// <summary> /// Checks if the given IP falls into the specified range /// </summary> /// <param name="target">The IP to check</param> /// <returns>True if it is inside the range, otherwise false</returns> public override bool Matches(System.Net.IPAddress target) { if (target == null) { throw new ArgumentNullException("target"); } byte[] addressBytes = target.GetAddressBytes(); bool lowerBoundary = true, upperBoundary = true; for (int i = 0; i < StartAddress.GetAddressBytes().Length&& (lowerBoundary || upperBoundary); i++) { if ((lowerBoundary && addressBytes[i] < StartAddress.GetAddressBytes()[i]) || (upperBoundary && addressBytes[i] > EndAddress.GetAddressBytes()[i])) { return(false); } lowerBoundary &= (addressBytes[i] == StartAddress.GetAddressBytes()[i]); upperBoundary &= (addressBytes[i] == EndAddress.GetAddressBytes()[i]); } return(true); }
public static string GetMacAddressByIP(System.Net.IPAddress ipAddress) { byte[] macBytes = new byte[6]; int length = 6; SendARP(BitConverter.ToInt32(ipAddress.GetAddressBytes(), 0), 0, macBytes, ref length); return(BitConverter.ToString(macBytes, 0, 6)); }
private uint ReturnFirtsOctet(string ipAddress) { System.Net.IPAddress iPAddress = System.Net.IPAddress.Parse(ipAddress); byte[] byteIP = iPAddress.GetAddressBytes(); uint ipInUint = (uint)byteIP[0]; return(ipInUint); }
public override void Serialize(ref SerializationWriter mySerializationWriter) { mySerializationWriter.CheckNull("mySerializationWriter"); if (_IPAddress != null) { mySerializationWriter.WriteBytesDirect(_IPAddress.GetAddressBytes()); } }
/// <summary> /// Encodes the ip address. /// </summary> /// <param name="bytes">The bytes.</param> /// <param name="offset">The offset.</param> /// <param name="ipAddress">The ip address.</param> /// <returns>offset as int</returns> private static int EncodeIPAddress(this byte[] bytes, int offset, System.Net.IPAddress ipAddress) { offset = bytes.EncodeClassConstructType(offset, Asn1Class.Application, ConstructType.Primitive, (byte)Asn1SnmpTag.IpAddress); offset = bytes.EncodeLength(offset, 4); byte[] bytesEncoded = ipAddress.GetAddressBytes(); Array.Copy(bytesEncoded, 0, bytes, offset, bytesEncoded.Length); return(offset + 4); }
private uint GetIP(string strIp) { System.Net.IPAddress ipaddress = System.Net.IPAddress.Parse(strIp); uint lIp = BitConverter.ToUInt32(ipaddress.GetAddressBytes(), 0); //調整IP地址的字節序 lIp = ((lIp & 0xFF000000) >> 24) + ((lIp & 0x00FF0000) >> 8) + ((lIp & 0x0000FF00) << 8) + ((lIp & 0x000000FF) << 24); return(lIp); }
public static IPAddressMessage Convert(this System.Net.IPAddress address) { switch (address.AddressFamily) { case AddressFamily.InterNetwork: return(new IPAddressMessage { IpV4 = address.GetAddressBytes().ToUInt32() }); case AddressFamily.InterNetworkV6: return(new IPAddressMessage { IpV6 = ByteString.CopyFrom(address.GetAddressBytes()) }); default: return(null); } }
public static Network.IPAddress ToArke(System.Net.IPAddress ip) { if (ip == null) { throw new ArgumentNullException(nameof(ip)); } return(new Network.IPAddress(ip.GetAddressBytes())); }
public static System.Net.IPAddress Not(System.Net.IPAddress mask) { byte[] mm = mask.GetAddressBytes(); for (int i = 0; i < mm.Length; i++) { mm[i] = (byte)(~mm[i]); } return(new System.Net.IPAddress(mm)); }
static public System.Net.IPAddress Minus(System.Net.IPAddress x, byte y) { byte[] New = Minus(x.GetAddressBytes(), y); string ni = New.Length == 4 ? string.Format("{0}.{1}.{2}.{3}", New[0], New[1], New[2], New[3]) : string.Format("{0:x2}{1:x2}:{2:x2}{3:x2}:{4:x2}{5:x2}:{6:x2}{7:x2}:{8:x2}{9:x2}:{10:x2}{11:x2}:{12:x2}{13:x2}:{14:x2}{15:x2}", New[0], New[1], New[2], New[3], New[4], New[5], New[6], New[7], New[8], New[9], New[10], New[11], New[12], New[13], New[14], New[15]); return(System.Net.IPAddress.Parse(ni)); }
private long IPAddressToLong(string IPAddr) { System.Net.IPAddress oIP = System.Net.IPAddress.Parse(IPAddr); byte[] byteIP = oIP.GetAddressBytes(); long ip = (long)byteIP[3] << 24; ip += (long)byteIP[2] << 16; ip += (long)byteIP[1] << 8; ip += (long)byteIP[0]; return(ip); }
public static long IPtoLong(System.Net.IPAddress theIP) // convert IP to number { byte[] IPb = theIP.GetAddressBytes(); // get the octets long addr = 0; // accumulator for address for (int x = 0; x <= 3; x++) { addr |= (System.Convert.ToInt64(IPb[x]) << (3 - x) * 8); } return(addr); }
static public int CompareFor(System.Net.IPAddress x, System.Net.IPAddress y) { if ((x.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork && y.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork) || (x.AddressFamily == System.Net.Sockets.AddressFamily.InterNetworkV6 && y.AddressFamily == System.Net.Sockets.AddressFamily.InterNetworkV6)) { return(IPSeg.CompareFor(x.GetAddressBytes(), y.GetAddressBytes())); } throw new Exception("IP地址类型必须是IPv4或者IPv6才能进行比较"); }
public static int IpToInt(string address) { System.Net.IPAddress ip = null; if (System.Net.IPAddress.TryParse(address.Trim(), out ip)) { return(BitConverter.ToInt32(ip.GetAddressBytes(), 0)); } else { return(0); } }
/// <summary> /// Converts IP address to number. /// </summary> /// <param name="IPAddr">IP address.</param> /// <returns>IP address in number format.</returns> private static uint IPAddressToLongBackwards(string IPAddr) { System.Net.IPAddress oIP = System.Net.IPAddress.Parse(IPAddr); byte[] byteIP = oIP.GetAddressBytes(); uint ip = (uint)byteIP[0] << 24; ip += (uint)byteIP[1] << 16; ip += (uint)byteIP[2] << 8; ip += (uint)byteIP[3]; return(ip); }
/// <summary> /// Converts a string representation of an IP address to a uint. This /// encoding is proper and can be used with other networking functions such /// as the System.Net.IPAddress class. /// </summary> /// <param name="IPAddress">The Ip address to convert.</param> /// <returns>Returns a uint representation of the IP address.</returns> static public uint IPAddressToLong(string IPAddress) { System.Net.IPAddress oIP = System.Net.IPAddress.Parse(IPAddress); byte[] byteIP = oIP.GetAddressBytes(); uint ip = (uint)byteIP[3] << 24; ip += (uint)byteIP[2] << 16; ip += (uint)byteIP[1] << 8; ip += (uint)byteIP[0]; return(ip); }
public static bool InSubnet(System.Net.IPAddress IPAddr, string Subnet) { bool result = false; int cidr = Int32.Parse(Subnet.Split('/')[1]); uint mask = cidr == 0 ? 0 : 0xffffffff << (32 - cidr); byte[] maskBytes = BitConverter.GetBytes(mask); Array.Reverse(maskBytes); byte[] addressBytes = IPAddr.GetAddressBytes(); IPAddress subnet = IPAddress.Parse(Subnet.Split('/')[0]); byte[] maskedAddressBytes = new byte[addressBytes.Length]; for (int i = 0; i < maskedAddressBytes.Length; i++) { maskedAddressBytes[i] = (byte)(IPAddr.GetAddressBytes()[i] & maskBytes[i]); } IPAddress maskedAddress = new IPAddress(maskedAddressBytes); result = (subnet.Equals(maskedAddress)); return(result); }
private int ProcessCHandshake(Protocol _p) { Handshake.CHandshake p = (Handshake.CHandshake)_p; int group = p.Argument.dh_group; if (false == Config.HandshakeOptions.DhGroups.Contains(group)) { p.Sender.Close(new Exception("dhGroup Not Supported")); return(0); } Array.Reverse(p.Argument.dh_data); BigInteger data = new BigInteger(p.Argument.dh_data); BigInteger rand = Handshake.Helper.makeDHRandom(); byte[] material = Handshake.Helper.computeDHKey(group, data, rand).ToByteArray(); Array.Reverse(material); System.Net.IPAddress ipaddress = ((IPEndPoint)p.Sender.Socket.LocalEndPoint).Address; //logger.Debug(ipaddress); if (ipaddress.IsIPv4MappedToIPv6) { ipaddress = ipaddress.MapToIPv4(); } byte[] key = Config.HandshakeOptions.SecureIp != null ? Config.HandshakeOptions.SecureIp : ipaddress.GetAddressBytes(); logger.Debug("{0} localip={1}", p.Sender.SessionId, BitConverter.ToString(key)); int half = material.Length / 2; byte[] hmacMd5 = Digest.HmacMd5(key, material, 0, half); p.Sender.SetInputSecurityCodec(hmacMd5, Config.HandshakeOptions.C2sNeedCompress); byte[] response = Handshake.Helper.generateDHResponse(group, rand).ToByteArray(); Array.Reverse(response); new Handshake.SHandshake(response, Config.HandshakeOptions.S2cNeedCompress, Config.HandshakeOptions.C2sNeedCompress) .Send(p.Sender); hmacMd5 = Digest.HmacMd5(key, material, half, material.Length - half); p.Sender.SetOutputSecurityCodec(hmacMd5, Config.HandshakeOptions.S2cNeedCompress); // 为了防止服务器在Handshake以后马上发送数据, // 导致未加密数据和加密数据一起到达Client,这种情况很难处理。 // 这个本质上是协议相关的问题:就是前面一个协议的处理结果影响后面数据处理。 // 所以增加CHandshakeDone协议,在Client进入加密以后发送给Server。 // OnHandshakeDone(p.Sender); return(0); }
private static System.Net.IPAddress BitOperate(System.Net.IPAddress x, System.Net.IPAddress mask, Operate op) { byte[] xx = x.GetAddressBytes(); byte[] mm = mask.GetAddressBytes(); if (xx.Length != mm.Length) { throw new ApplicationException("IP地址版本不一致,不能执行“或”操作"); } int i = 0; for (i = 0; i < xx.Length; i++) { xx[i] = op(xx[i], mm[i]); } return(new System.Net.IPAddress(xx)); }
/// <summary> /// Returns true if the IPAddress supplied is on the same subnet as this host /// </summary> public static bool IsLocal(NetAddress remote) { var local = GetMyAddress(out var mask); if (mask == null) { return(false); } uint maskBits = BitConverter.ToUInt32(mask.GetAddressBytes(), 0); uint remoteBits = BitConverter.ToUInt32(remote.GetAddressBytes(), 0); uint localBits = BitConverter.ToUInt32(local.GetAddressBytes(), 0); // compare network portions return((remoteBits & maskBits) == (localBits & maskBits)); }
public static System.Net.IPAddress GetNetworkAddress(System.Net.IPAddress address, System.Net.IPAddress subnetMask) { byte[] ipAdressBytes = address.GetAddressBytes(); byte[] subnetMaskBytes = subnetMask.GetAddressBytes(); if (ipAdressBytes.Length != subnetMaskBytes.Length) { throw new ArgumentException("Lengths of IP address and subnet mask do not match."); } byte[] broadcastAddress = new byte[ipAdressBytes.Length]; for (int i = 0; i < broadcastAddress.Length; i++) { broadcastAddress[i] = (byte)(ipAdressBytes[i] & (subnetMaskBytes[i])); } return(new System.Net.IPAddress(broadcastAddress)); }
//Возвращает число единичных бит в маске private int mask_to_short_form(System.Net.IPAddress mask) { byte[] bytes = mask.GetAddressBytes(); int number_of_bits = 0; foreach (var _octet in bytes) { byte octet = _octet; while (octet != 0) { number_of_bits += octet & 1; octet >>= 1; } } return(number_of_bits); }
private static string GetMacString(System.Net.IPAddress ip) { if (ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork) { byte[] mac = new byte[6]; int macLen = mac.Length; int dest = BitConverter.ToInt32(ip.GetAddressBytes(), 0); int res = NativeMethods.SendARP(dest, 0, mac, ref macLen); if ((res == 0) && ((mac[0] != 0) || (mac[1] != 0) || (mac[2] != 0) || (mac[3] != 0) || (mac[4] != 0) || (mac[5] != 0))) { return((mac[0].ToString("x2") + ":" + mac[1].ToString("x2") + ":" + mac[2].ToString("x2") + ":" + mac[3].ToString("x2") + ":" + mac[4].ToString("x2") + ":" + mac[5].ToString("x2")).ToUpper()); } } return(null); }