Subnetting, CIDR Calculus & IPv4/IPv6 Address Allocation in Modern Cloud Architecture

IP Address: 192.168.10.45
Octet 1: 192 -> 11000000
Octet 2: 168 -> 10101000
Octet 3:  10 -> 00001010
Octet 4:  45 -> 00101101
Binary: 11000000.10101000.00001010.00101101

CIDR Prefix: /27 (27 consecutive 1s)
Binary Mask: 11111111.11111111.11111111.11100000
Decimal:     255.     255.     255.     224

/**
 * High-Performance CIDR & Subnetting Engine in Pure TypeScript
 */
export interface SubnetDetails {
  cidr: string;
  ipAddress: string;
  prefixLength: number;
  netmask: string;
  wildcardMask: string;
  networkAddress: string;
  broadcastAddress: string;
  firstUsableIp: string;
  lastUsableIp: string;
  totalAddresses: number;
  usableHosts: number;
  awsUsableHosts: number;
  binaryNetmask: string;
}

export class SubnetCalculatorEngine {
  /**
   * Converts a dotted-decimal IPv4 string into a 32-bit unsigned integer.
   */
  public static ipToInt(ip: string): number {
    return ip.split(".").reduce((acc, octet) => ((acc << 8) + parseInt(octet, 10)) >>> 0, 0);
  }

  /**
   * Converts a 32-bit unsigned integer back into dotted-decimal IPv4 string.
   */
  public static intToIp(int: number): string {
    return [
      (int >>> 24) & 0xff,
      (int >>> 16) & 0xff,
      (int >>> 8) & 0xff,
      int & 0xff
    ].join(".");
  }

  /**
   * Calculates comprehensive subnet metrics from an IP and CIDR prefix.
   */
  public static calculateSubnet(ipStr: string, prefix: number): SubnetDetails {
    if (prefix < 0 || prefix > 32) {
      throw new Error("Invalid prefix length. Must be between 0 and 32.");
    }

    const ipInt = this.ipToInt(ipStr);
    
    // Generate 32-bit subnet mask: p ones followed by (32 - p) zeros
    const maskInt = prefix === 0 ? 0 : (~0 << (32 - prefix)) >>> 0;
    const wildcardInt = ~maskInt >>> 0;

    // Bitwise AND for network address, bitwise OR with wildcard for broadcast
    const networkInt = (ipInt & maskInt) >>> 0;
    const broadcastInt = (networkInt | wildcardInt) >>> 0;

    const totalAddresses = Math.pow(2, 32 - prefix);
    const usableHosts = prefix >= 31 ? 0 : totalAddresses - 2;
    const awsUsableHosts = prefix >= 29 ? Math.max(0, totalAddresses - 5) : totalAddresses - 5;

    const firstUsableInt = prefix >= 31 ? networkInt : networkInt + 1;
    const lastUsableInt = prefix >= 31 ? broadcastInt : broadcastInt - 1;

    // Binary representation
    const binaryNetmask = (maskInt >>> 0).toString(2).padStart(32, "0").match(/.{8}/g)!.join(".");

    return {
      cidr: this.intToIp(networkInt) + "/" + prefix,
      ipAddress: ipStr,
      prefixLength: prefix,
      netmask: this.intToIp(maskInt),
      wildcardMask: this.intToIp(wildcardInt),
      networkAddress: this.intToIp(networkInt),
      broadcastAddress: this.intToIp(broadcastInt),
      firstUsableIp: this.intToIp(firstUsableInt),
      lastUsableIp: this.intToIp(lastUsableInt),
      totalAddresses,
      usableHosts,
      awsUsableHosts: Math.max(0, awsUsableHosts),
      binaryNetmask
    };
  }
}