¿Cómo convertir el rango de direcciones IP a CIDR en Java?

Ya no necesitas investigar más por todo internet ya que llegaste al lugar indicado, contamos con la respuesta que deseas sin problemas.

Solución:

import java.util.ArrayList;
import java.util.List;

public class RangeToCidr 
    public static List range2cidrlist( String startIp, String endIp ) 

    private static long ipToLong(String strIP) 
        String[] ipSegs = strIP.split("\.");
        long res = 0;
        for (int i = 0; i < 4; i++) 
            res += Long.valueOf(ipSegs[i]) << (8 * (3 - i));
        
        return res;
    

    private static String longToIP(long longIP) 
        StringBuffer sb = new StringBuffer();
        sb.append(longIP >>> 24).append(".")
          .append((longIP & 0x00FFFFFF) >>> 16).append(".")
          .append(String.valueOf((longIP & 0x0000FFFF) >>> 8)).append(".")
          .append(String.valueOf(longIP & 0x000000FF));

        return sb.toString();
    

En caso de que no lo hayas descubierto con mis comentarios:

Las matemáticas de IP deben realizarse en binario. Las direcciones IP y las máscaras son números enteros sin signo (32 bits para IPv4, 128 bits para IPv6). Todo lo que necesita saber es una dirección y una máscara, y puede averiguar todo lo demás.

Este es un algoritmo para lo que desea lograr y se aplica tanto a IPv4 como a IPv6.

Según su pregunta, se le proporciona la subred (Entrada 1) y la última dirección (Entrada 2).

1. Reste el entero sin signo de la Entrada 1 del entero sin signo de la Entrada 2. El resultado es la máscara de subred inversa. La máscara de subred inversa debe ser 0, o la máscara de subred inversa más 1 debe ser un poder de 2, de lo contrario, tiene un error en una de las entradas (PARADA, ERROR DE ENTRADA).
2. los NOT de la máscara inversa (resultado del paso 1) es la máscara de subred.
3. Si la entrada 1 AND la máscara de subred no es igual a la Entrada 1, tiene un error en una de las entradas (PARADA, ERROR DE ENTRADA).
4. La longitud de la máscara (número CIDR) es el número de 1 bits en la máscara de subred. Hay varias formas de calcular el número de 1
   bits en un número binario, pero si la máscara de subred es el número entero máximo (o la máscara inversa es 0), entonces la longitud de la máscara es 32
   (IPv4) o 128 (IPv6). Puede realizar un bucle, contando el número de bucles y desplazando la máscara de subred hacia la izquierda hasta que iguale 0, bucle contando el número de bucles y desplazando la máscara inversa hacia la derecha hasta que iguale 0 luego agregando 1 al total y restando el total de 32 (IPv4) o 128 (IPv6), o reste el exponente de la potencia de 2 de la máscara inversa total más 1 de 32 (IPv4) o 128 (IPv6).
5. En este punto, tiene la Entrada 1 (subred) verificada, la Entrada 2 (última dirección) y calculó la longitud de la máscara (número CIDR).
6. El resultado final será /.

Tu ejemplo:

Paso 1 (5.10.127.255 - 5.10.64.0 = 0.0.64.127):

101000010100111111111111111 - 01000010100100000000000000 = 11111111111111

Paso 2 (NOT 0.0.64.255 = 255.255.192.0 es una potencia de dos):

NOT 00000000000000000011111111111111 = 11111111111111111100000000000000

Paso 3 (5.10.64.0 AND 255.255.192.0 = 5.10.64.0):

01000010100100000000000000 AND 11111111111111111100000000000000 = 01000010100100000000000000

Paso 4 (0.0.64.255 + 1 = 0.0.65.0 = 2^14, exponent of 2^14 = 14, 32 - 14 = 18):

00000000000000000011111111111111 + 1 = 00000000000000000100000000000000 = 2^14, exponent of 2^14 = 14, 32 - 14 = 18

Paso 5 (Entrada 1 = 5.10.64.0, Entrada 2 = 5.10.127.255, Longitud de la máscara = 18)

Paso 6 (Resultado final = 5.10.64.0/18)

Entonces, pude encontrar el código Java aquí: en Java, dado un rango de direcciones IP, devuelva la lista mínima de bloques CIDR que cubre el rango

public class IP2CIDR 

    public static void main(String[] args) 
        System.out.println(range2cidrlist("5.104.109.160", "5.104.109.191"));
    

    public static List range2cidrlist( String startIp, String endIp )          
        long start = ipToLong(startIp);         
        long end = ipToLong(endIp);           

        ArrayList pairs = new ArrayList();         
        while ( end >= start )              
            byte maxsize = 32;             
            while ( maxsize > 0)                  
                long mask = CIDR2MASK[ maxsize -1 ];                 
                long maskedBase = start & mask;                 

                if ( maskedBase != start )                      
                    break;                 
                                 

                maxsize--;             
                           
            double x = Math.log( end - start + 1) / Math.log( 2 );             
            byte maxdiff = (byte)( 32 - Math.floor( x ) );             
            if ( maxsize < maxdiff)                  
                maxsize = maxdiff;             
                         
            String ip = longToIP(start);             
            pairs.add( ip + "/" + maxsize);             
            start += Math.pow( 2, (32 - maxsize) );         
                 
        return pairs;     
           

    public static final int[] CIDR2MASK = new int[]  0x00000000, 0x80000000,             
        0xC0000000, 0xE0000000, 0xF0000000, 0xF8000000, 0xFC000000,             
        0xFE000000, 0xFF000000, 0xFF800000, 0xFFC00000, 0xFFE00000,             
        0xFFF00000, 0xFFF80000, 0xFFFC0000, 0xFFFE0000, 0xFFFF0000,             
        0xFFFF8000, 0xFFFFC000, 0xFFFFE000, 0xFFFFF000, 0xFFFFF800,             
        0xFFFFFC00, 0xFFFFFE00, 0xFFFFFF00, 0xFFFFFF80, 0xFFFFFFC0,             
        0xFFFFFFE0, 0xFFFFFFF0, 0xFFFFFFF8, 0xFFFFFFFC, 0xFFFFFFFE,             
        0xFFFFFFFF ;       

    private static long ipToLong(String strIP)          
        long[] ip = new long[4];         
        String[] ipSec = strIP.split("\.");         
        for (int k = 0; k < 4; k++)              
            ip[k] = Long.valueOf(ipSec[k]);         
                 

        return (ip[0] << 24) + (ip[1] << 16) + (ip[2] << 8) + ip[3];     
           

    private static String longToIP(long longIP)          
        StringBuffer sb = new StringBuffer("");         
        sb.append(String.valueOf(longIP >>> 24));         
        sb.append(".");         
        sb.append(String.valueOf((longIP & 0x00FFFFFF) >>> 16));         
        sb.append(".");         
        sb.append(String.valueOf((longIP & 0x0000FFFF) >>> 8));         
        sb.append(".");         
        sb.append(String.valueOf(longIP & 0x000000FF));   

        return sb.toString();     
    

¡Gracias a todos por sus ideas y ayuda!

valoraciones y reseñas

Recuerda algo, que puedes optar por la opción de esclarecer .

---

---

Utiliza Nuestro Buscador