Restreindre une adresse IP s'il s'agit d'une plage d'adresses IP

Question

D'accord, nous sommes vendredi après-midi et j'ai eu une longue semaine, j'apprécierais donc de l'aide! Actuellement, j'ai une liste de plages d'adresses IP, comme suit:

List<IPRange> ipRanges = new List<IPRange>();

ipRanges.Add(new IPRange { From = "145.36.0.0", To = "145.36.255.255" });
ipRanges.Add(new IPRange { From = "194.183.227.184", To = "194.183.227.191" });
ipRanges.Add(new IPRange { From = "193.131.192.0", To = "193.131.223.255" });

Après avoir obtenu l'adresse IP du client, si celle-ci se situe entre ces ensembles de plages, ils doivent être redirigés ailleurs.

Par exemple,

Si quelqu'un visitait le site avec l'adresse IP 192.168.0.1, il serait autorisé à y accéder. S'ils visitaient avec 145.36.1.0, l'accès ne leur serait pas autorisé car il se situe entre la première plage de cette liste.

Je pourrais diviser chaque adresse IP par la période et déterminer où la plage commence à changer, puis faire une comparaison, mais cela serait lourd pour le serveur.

Je sais que les adresses IP ne sont en fait que des nombres décimaux, mais je ne sais pas trop comment cela fonctionne.

Quelqu'un est-il déjà tombé sur cette image?

À la vôtre, Sean.

Answer 1

Convertissez chaque adresse IP vers le numéro , puis vérifiez si l'adresse IP de l'utilisateur est comprise entre ces numéros.

public double Dot2LongIP(string DottedIP)
{
    int i;
    string [] arrDec;
    double num = 0;
    if (DottedIP == "")
    {
       return 0;
    }
    else
    {
       arrDec = DottedIP.Split('.');
       for(i = arrDec.Length - 1; i >= 0 ; i --)
       {
          num += ((int.Parse(arrDec[i])%256) * Math.Pow(256 ,(3 - i )));
       }
       return num;
    }
}

Answer 2

Je voudrais convertir les adresses IP en nombres 32 bits, puis effectuer un simple > = de et < = pour vérifier si elle est dans la plage.

Par exemple, 192.168.1.1 - > 192 * 256 ^ 3 + 168 * 256 ^ 2 + 1 * 256 + 1.

Travailler avec vos valeurs, 145.36.0.0 - > 2435055616 et 145.36.0.0 - & Gt; 2435121151. Donc 145.36.200.30 - & Gt; 2435106846, et tombe dans cette plage, il est donc valide. Mais 145.35.255.255 - & Gt; 2435055615 n'est pas dans la plage (à peine), donc il échoue.

Answer 3

J'écrirais ma classe IPRange de sorte que le getter / setters convertisse en interne la chaîne IP en un nombre:

new IPRange { From = "145.36.0.0", To = "145.36.255.255" }

Définirait en interne:

int from = 145036000000;
int to = 145036255255;

Ajoutez ensuite une méthode .IsInRange (string ip) qui convertit l’adresse IP entrante en nom de forme int et effectue une comparaison simple.

public bool IsInRange(string ipStr)
{
    int ip = ConvertIPStringToInt(ipStr);
    return (from <= ip && ip <= to);
}

De cette façon, vous ne devez pas séparer les IP de la plage par périodes à chaque vérification.

Answer 4

Juste pour le plaisir (et un semblant d’exhaustivité) - l’autre façon évidente de faire est de vous assurer que vous utilisez toujours 3 chiffres pour chaque segment de l’adresse IP stockée sous forme de chaîne, c’est-à-dire 145.36.0.0 devrait être 145,036. 000.000 - Ainsi, les chaînes seraient directement comparables.

Et le moins évident serait d’avoir une classe d’adresses IP explicite et de définir votre propre logique de comparaison (j’assume de façon imprudente qu’il n’ya pas déjà quelque chose comme cela enfoui dans les profondeurs du framework .NET. ..)

Answer 5

J'ai lu à ce sujet il y a quelques jours.

Vous pouvez convertir et comparer vos plages d'adresses IP.

IF exists (SELECT * from dbo.sysobjects 
    WHERE id = object_id(N'[dbo].[IsPrivateIP]') 
    AND OBJECTPROPERTY(id, N'IsScalarFunction') = 1)
DROP FUNCTION [dbo].[IsPrivateIP]
GO


CREATE FUNCTION dbo.IsPrivateIP( @vcIPAddress varchar(15))
/**************************************************************************
DESCRIPTION: Returns Numeric IP if not private, otherwise returns null

PARAMETERS:
        @vcIPAddress    - The string containing a valid IP

RETURNS:    IP converted to bigint or null if a private IP

USAGE:      SELECT dbo.IsPrivateIP( '207.158.26.10')

DEPENDANCIES:    dbo.IPStringToNumber() function    

AUTHOR: Karen Gayda

DATE:   06/11/2003

MODIFICATION HISTORY:
    WHO     DATE        DESCRIPTION
    ---     ----------  ---------------------------------------------------

***************************************************************************/

    RETURNS bigint
AS
BEGIN
    DECLARE @biClassALo bigint ,
        @biClassAHi bigint ,
        @biClassBLo bigint ,
        @biClassBHi bigint ,
        @biClassCLo bigint ,
        @biClassCHi bigint ,
        @biIP       bigint,
        @bTemp      int 

    SET @biClassALo = 167772160
    SET @biClassAHi = 169549375
    SET @biClassBLo = 2885681152
    SET @biClassBHi = 2887778303
    SET @biClassCLo = 3232235520
    SET @biClassCHi = 3232301055


    SET @biIP = dbo.IPStringToNumber(@vcIPAddress)
    IF @biIP BETWEEN @biClassALo AND @biClassAHi OR @biIP BETWEEN @biClassBLo AND @biClassBHi 
        OR @biIP BETWEEN @biClassCLo AND @biClassCHi 
        SET @biIP = NULL

    RETURN @biIP
END
GO

Voici la fonction IPStringToNumber dont elle a besoin:

IF exists (SELECT * from dbo.sysobjects 
    WHERE id = object_id(N'[dbo].[IPStringToNumber]') 
    AND OBJECTPROPERTY(id, N'IsScalarFunction') = 1)
DROP FUNCTION [dbo].[IPStringToNumber]
GO

CREATE FUNCTION dbo.IPStringToNumber( @vcIPAddress varchar(15))
/**************************************************************************
DESCRIPTION: Returns Numeric IP, otherwise returns null

PARAMETERS:
        @vcIPAddress    - The string containing a valid IP

RETURNS:    IP converted to bigint or null if not a valid IP

USAGE:         SELECT  dbo.IPStringToNumber( '10.255.255.255')



AUTHOR: Karen Gayda

DATE:   06/11/2003

MODIFICATION HISTORY:
    WHO     DATE        DESCRIPTION
    ---     ----------  ---------------------------------------------------

***************************************************************************/

    RETURNS bigint
AS
BEGIN
    DECLARE 
        @biOctetA   bigint,
        @biOctetB   bigint,
        @biOctetC   bigint,
        @biOctetD   bigint,
        @biIP           bigint

    DECLARE @tblArray TABLE 
       (
        OctetID     smallint,       --Array index
        Octet       bigint          --Array element contents
       )

    --split the IP string and insert each octet into a table row
    INSERT INTO @tblArray
    SELECT ElementID, Convert(bigint,Element) FROM dbo.Split(@vcIPAddress, '.')

    --check that there are four octets and that they are within valid ranges
    IF (SELECT COUNT(*) FROM @tblArray WHERE Octet BETWEEN 0 AND 255) = 4
    BEGIN
        SET @biOctetA = (SELECT (Octet * 256 * 256 * 256) FROM @tblArray WHERE OctetID = 1)
        SET @biOctetB = (SELECT (Octet * 256 * 256 ) FROM @tblArray WHERE OctetID = 2)
        SET @biOctetC = (SELECT (Octet * 256 ) FROM @tblArray WHERE OctetID = 3)
        SET @biOctetD = (SELECT (Octet) FROM @tblArray WHERE OctetID = 4)
        SET @biIP = @biOctetA + @biOctetB + @biOctetC + @biOctetD
    END

    RETURN(@biIP)
END

Références:

http://www.sqlservercentral.com/scripts/Miscellaneous/31036/

http://www.sqlservercentral.com/Authors/Scripts/kgayda/ 17134 /