.. 제목: IPv6 서브넷 계산기
.. 슬러그: ipv6-calc
.. 날짜: 2025-12-26 15:00:00 UTC
.. 태그: 네트워킹, 계산기, 도구
.. 카테고리: 계산기
.. 링크:
.. 설명: 접두사, 호스트 수, 네트워크 주소 및 주소 범위에 대한 IPv6 서브넷 계산기입니다. 최신 듀얼 스택 및 IPv6 전용 네트워크 설계를 위해 /48부터 /128까지의 접두사를 처리합니다.
.. 유형: 텍스트
<style>
    .ipv6-calc-container {
        max-width: 1000px;
        margin: 20px auto;
        padding: 20px;
    }

    .calc-header {
        margin-bottom: 30px;
        padding: 25px;
        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
        border-radius: 12px;
        box-shadow: 0 4px 6px rgba(0,0,0,0.1);
        color: white;
    }

    .calc-header h1 {
        margin-top: 0;
        color: white;
        font-size: 28px;
        margin-bottom: 10px;
    }

    .calc-header p {
        margin: 10px 0;
        opacity: 0.95;
        font-size: 15px;
    }

    .input-group {
        display: flex;
        gap: 10px;
        margin-top: 20px;
    }

    #ipaddress {
        flex: 1;
        padding: 14px;
        font-size: 16px;
        border: 2px solid rgba(255,255,255,0.3);
        border-radius: 6px;
        font-family: 'Courier New', monospace;
        background: rgba(255,255,255,0.95);
        transition: all 0.3s ease;
    }

    #ipaddress:focus {
        outline: none;
        border-color: #4CAF50;
        background: white;
        box-shadow: 0 0 0 3px rgba(76, 175, 80, 0.1);
    }

    .calc-button {
        padding: 14px 35px;
        font-size: 16px;
        background: #4CAF50;
        color: white;
        border: none;
        border-radius: 6px;
        cursor: pointer;
        font-weight: bold;
        transition: all 0.3s ease;
        box-shadow: 0 2px 4px rgba(0,0,0,0.2);
    }

    .calc-button:hover {
        background: #45a049;
        transform: translateY(-1px);
        box-shadow: 0 4px 8px rgba(0,0,0,0.3);
    }

    .calc-button:active {
        background: #3d8b40;
        transform: translateY(0);
    }

    .error-message {
        background: #ffebee;
        color: #c62828;
        padding: 15px 20px;
        border-radius: 8px;
        border-left: 4px solid #c62828;
        margin: 20px 0;
        display: none;
    }

    .error-message.show {
        display: block;
    }

    .result-section {
        background: white;
        border: 1px solid #e0e0e0;
        border-radius: 8px;
        margin-top: 20px;
        overflow: hidden;
        box-shadow: 0 2px 4px rgba(0,0,0,0.05);
        transition: all 0.3s ease;
    }

    .result-section:hover {
        box-shadow: 0 4px 8px rgba(0,0,0,0.1);
    }

    .section-header {
        background: linear-gradient(135deg, #4CAF50 0%, #45a049 100%);
        color: white;
        padding: 15px 20px;
        font-size: 20px;
        font-weight: bold;
        margin: 0;
    }

    .section-content {
        padding: 20px;
        background: #fafafa;
    }

    .data-row {
        display: flex;
        margin: 12px 0;
        padding: 10px;
        background: white;
        border-radius: 4px;
        border-left: 3px solid #4CAF50;
    }

    .data-label {
        font-weight: bold;
        color: #555;
        min-width: 250px;
        flex-shrink: 0;
    }

    .data-value {
        color: #333;
        font-family: 'Courier New', monospace;
        word-break: break-word;
    }

    /* Responsive design */
    @media (max-width: 768px) {
        .input-group {
            flex-direction: column;
        }

        .calc-button {
            width: 100%;
        }

        .data-row {
            flex-direction: column;
        }

        .data-label {
            margin-bottom: 5px;
            min-width: auto;
        }
    }
</style>
<div class="ipv6-calc-container">
<div class="calc-header">
<h1>IPv6 서브넷 계산기</h1>
<p>IPv6 주소와 접두사 길이를 입력하여 네트워크 세부 정보, 주소 범위, 유형 정보 및 (해당되는 경우) 사용 가능한 /64 서브넷 수를 계산합니다.</p>
<form id="subnetform">
<div class="input-group">
<input autocomplete="off" id="ipaddress" placeholder="e.g., 2001:db8::1/64" type="text" value="2001:db8::1/64"/>
<button class="calc-button" type="submit">믿다</button>
</div>
</form>
</div>
<div class="error-message" id="errorBox"></div>
<div class="result-section">
<div class="section-header">결과</div>
<div class="section-content">
<div class="data-row">
<div class="data-label">입력한 주소:</div>
<div class="data-value" id="ipAddress"></div>
</div>
<div class="data-row">
<div class="data-label">주소 유형:</div>
<div class="data-value" id="ipType"></div>
</div>
<div class="data-row">
<div class="data-label">네트워크 접두사:</div>
<div class="data-value" id="network"></div>
</div>
<div class="data-row">
<div class="data-label">접두사 길이:</div>
<div class="data-value" id="prefixLength"></div>
</div>
<div class="data-row">
<div class="data-label">접두어 주소:</div>
<div class="data-value" id="prefixAddress"></div>
</div>
<div class="data-row">
<div class="data-label">주소 범위:</div>
<div class="data-value" id="addressRange"></div>
</div>
<div class="data-row">
<div class="data-label">접두사의 총 주소:</div>
<div class="data-value" id="totalNumofAddress"></div>
</div>
<div class="data-row" id="num64Row" style="display:none;">
<div class="data-label">/64 서브넷 수:</div>
<div class="data-value" id="num64Subnets"></div>
</div>
<div class="data-row">
<div class="data-label">바이너리 인터페이스 ID:</div>
<div class="data-value" id="binaryID"></div>
</div>
<div class="data-row">
<div class="data-label">IPv6 특정 유형:</div>
<div class="data-value" id="ipv6Type"></div>
</div>
<div class="data-row">
<div class="data-label">멀티캐스트 플래그(해당되는 경우):</div>
<div class="data-value" id="multicastFlagsSet"></div>
</div>
<div class="data-row">
<div class="data-label">헥세트 분석:</div>
<div class="data-value" id="ipBreakdown"></div>
</div>
</div>
</div>
</div>
<script>
// IPv6 Helper Functions
function expandIPv6(address) {
    // Split on :: if present
    if (address.includes('::')) {
        const parts = address.split('::');
        if (parts.length !== 2) return null;
        const left = parts[0] ? parts[0].split(':') : [];
        const right = parts[1] ? parts[1].split(':') : [];
        const needed = 8 - (left.length + right.length);
        if (needed < 0) return null;
        const zeros = Array(needed + 1).join('0:').split(':');
        zeros.pop();
        return [...left, ...zeros, ...right];
    }
    return address.split(':');
}

function compressIPv6(hextets) {
    let str = hextets.map(h => h.toLowerCase()).join(':');
    // Find longest run of zeros
    const zeroRun = /(:0)+(?::0)*/g;
    let longest = '';
    let match;
    while ((match = zeroRun.exec(str)) !== null) {
        if (match[0].length > longest.length) longest = match[0];
    }
    if (longest.length >= 3) { // at least two zeros
        str = str.replace(longest, '::');
    }
    return str.replace(/^:/, '::').replace(/:$/, '::');
}

function validateAndParse(input) {
    const regex = /^([0-9a-fA-F:]+)\/(\d+)$/;
    const match = input.trim().match(regex);
    if (!match) throw new Error('Invalid format. Use IPv6/prefix (e.g. 2001:db8::1/64)');
    
    const prefixLen = parseInt(match[2], 10);
    if (prefixLen < 0 || prefixLen > 128) throw new Error('Prefix length must be 0-128');

    const addrPart = match[1];
    const hextets = expandIPv6(addrPart);
    if (!hextets || hextets.length !== 8) throw new Error('Invalid IPv6 address');
    
    // Validate each hextet
    for (let h of hextets) {
        if (!/^[0-9a-fA-F]{1,4}$/.test(h)) throw new Error('Invalid hextet: ' + h);
    }
    
    // Convert to lower case and pad
    const fullHextets = hextets.map(h => ('0000' + h.toLowerCase()).slice(-4));
    return { hextets: fullHextets, prefixLen };
}

function getNetworkAddress(hextets, prefixLen) {
    const net = hextets.slice();
    const fullBits = prefixLen;
    const hextetIndex = Math.floor(fullBits / 16);
    const bitOffset = fullBits % 16;
    
    if (bitOffset > 0) {
        const mask = parseInt('ffff'.slice(0, bitOffset / 4), 16) << (16 - bitOffset);
        net[hextetIndex] = (parseInt(net[hextetIndex], 16) & mask).toString(16).padStart(4, '0');
    }
    for (let i = hextetIndex + (bitOffset > 0 ? 1 : 0); i < 8; i++) {
        net[i] = '0000';
    }
    return net;
}

function getFirstLastAddress(networkHextets, prefixLen) {
    const first = networkHextets.slice();
    const last = networkHextets.slice();
    
    if (prefixLen === 128) {
        return { first: first.join(':'), last: first.join(':') };
    }
    
    // Last address: flip all bits after prefix
    const bitsAfter = 128 - prefixLen;
    const lastIncrement = BigInt('0x' + 'f'.repeat(bitsAfter / 4));
    let lastBig = BigInt('0x' + last.join('')) | lastIncrement;
    let lastHex = lastBig.toString(16).padStart(32, '0');
    const lastArr = [];
    for (let i = 0; i < 32; i += 4) lastArr.push(lastHex.substr(i, 4));
    
    // First is network, last is network + (2^bitsAfter - 1)
    return {
        first: compressIPv6(first),
        last: compressIPv6(lastArr)
    };
}

function getAddressType(hextets) {
    const first = hextets[0];
    if (first === '0000') return 'Unspecified / Loopback / IPv4-mapped';
    if (first === 'fe80') return 'Link-Local Unicast';
    if (first.startsWith('fc') || first.startsWith('fd')) return 'Unique Local Unicast (ULA)';
    if (first === '2001' && hextets[1].startsWith('db8')) return 'Documentation';
    if (first.startsWith('2')) return 'Global Unicast';
    if (first === 'ff00') return 'Multicast';
    return 'Other / Reserved';
}

function getSpecificType(hextets) {
    if (hextets.join('').replace(/^0+/, '') === '1') return 'Loopback (::1)';
    if (hextets[0] === '0000' && hextets.slice(1,6).every(h => h === '0000') && hextets[6] === 'ffff') return 'IPv4-mapped';
    if (hextets[0] === 'ff00') {
        const flags = parseInt(hextets[1].substr(0,1), 16);
        const scope = parseInt(hextets[1].substr(1,1), 16);
        const scopes = ['Reserved','Interface-Local','Link-Local','Reserved','Admin-Local','Site-Local','Reserved','Reserved','Organization-Local','Reserved','Reserved','Reserved','Reserved','Reserved','Global','Reserved'];
        return `Multicast (${scopes[scope] || 'Reserved'} scope)`;
    }
    return '-';
}

function getMulticastFlags(hextets) {
    if (hextets[0] !== 'ff00') return '-';
    const flagsHex = hextets[1].substr(0,1);
    const flags = parseInt(flagsHex, 16);
    const r = (flags & 8) ? 'Rendezvous Point Embedded' : 'No Rendezvous Point';
    const p = (flags & 4) ? 'Prefix-dependent' : 'Not prefix-dependent';
    const t = (flags & 2) ? 'Transient' : 'Permanent';
    return `${t}, ${p}, ${r}`;
}

function calculate() {
    const errorBox = document.getElementById('errorBox');
    errorBox.classList.remove('show');

    try {
        const input = document.getElementById('ipaddress').value.trim();
        const { hextets, prefixLen } = validateAndParse(input);

        const expandedInput = hextets.map(h => h.toLowerCase()).join(':');
        const compressedInput = compressIPv6(hextets);

        const networkHextets = getNetworkAddress(hextets, prefixLen);
        const networkCompressed = compressIPv6(networkHextets);

        const { first, last } = getFirstLastAddress(networkHextets, prefixLen);

        const totalAddresses = BigInt(2) ** BigInt(128 - prefixLen);
        const totalFormatted = totalAddresses >= 1000000000000000n
            ? (totalAddresses / 1000000000000000n).toString() + ' quadrillion'
            : totalAddresses.toString();

        const interfaceID = hextets.slice(Math.ceil(prefixLen / 16)).join('').toUpperCase();
        const binaryID = hextets.slice(Math.ceil(prefixLen / 16)).map(h =>
            parseInt(h, 16).toString(2).padStart(16, '0')
        ).join(' ');

        const type = getAddressType(hextets);
        const specific = getSpecificType(hextets);
        const mcFlags = getMulticastFlags(hextets);

        const breakdown = hextets.map((h,i) => `${i+1}: ${h.toUpperCase()}`).join(' | ');

        // Show number of /64 subnets if prefix < 64
        const num64Row = document.getElementById('num64Row');
        if (prefixLen < 64) {
            const num64 = BigInt(2) ** BigInt(64 - prefixLen);
            const num64Str = num64 >= 1000000000n
                ? (num64 / 1000000000n).toString() + ' billion'
                : num64.toString();
            document.getElementById('num64Subnets').textContent = num64Str;
            num64Row.style.display = 'flex';
        } else {
            num64Row.style.display = 'none';
        }

        document.getElementById('ipAddress').textContent = compressedInput + '/' + prefixLen;
        document.getElementById('ipType').textContent = type;
        document.getElementById('network').textContent = networkCompressed + '/' + prefixLen;
        document.getElementById('prefixLength').textContent = '/' + prefixLen;
        document.getElementById('prefixAddress').textContent = networkCompressed;
        document.getElementById('addressRange').textContent = first + ' — ' + last;
        document.getElementById('totalNumofAddress').textContent = totalFormatted;
        document.getElementById('binaryID').textContent = binaryID || '(none)';
        document.getElementById('ipv6Type').textContent = specific;
        document.getElementById('multicastFlagsSet').textContent = mcFlags;
        document.getElementById('ipBreakdown').textContent = breakdown;

    } catch (e) {
        errorBox.textContent = e.message;
        errorBox.classList.add('show');
    }
}

document.getElementById('subnetform').addEventListener('submit', function (evt) {
    evt.preventDefault();
    calculate();
});

// Run on page load
calculate();

</script>