259 lines
10 KiB
JavaScript
259 lines
10 KiB
JavaScript
const test = require('fresh-tape')
|
|
const Buffer = require('buffer').Buffer
|
|
const { encode, decode, sizeOf, familyOf, v4, v6 } = require('.')
|
|
const crypto = require('crypto')
|
|
|
|
test('IPv4 addresses tests', t => {
|
|
t.ok(v4.isFormat('0.0.0.0'))
|
|
t.ok(v4.isFormat('1.1.1.1'))
|
|
t.ok(v4.isFormat('1.1.1.1'))
|
|
t.ok(v4.isFormat('11.11.11.11'))
|
|
t.ok(v4.isFormat('111.111.111.111'))
|
|
t.ok(v4.isFormat('255.255.255.255'))
|
|
t.notOk(v4.isFormat(''))
|
|
t.notOk(v4.isFormat('1'))
|
|
t.notOk(v4.isFormat('1.1.1'))
|
|
t.notOk(v4.isFormat(' 1.1.1.1 '))
|
|
t.notOk(v4.isFormat('1.1.1.1 '))
|
|
t.notOk(v4.isFormat(' 1.1.1.1'))
|
|
t.notOk(v4.isFormat('1000.1.1.1'))
|
|
t.notOk(v4.isFormat('1.1000.1.1'))
|
|
t.notOk(v4.isFormat('1.1.1000.1'))
|
|
t.notOk(v4.isFormat('1.1.1.1000'))
|
|
t.end()
|
|
})
|
|
|
|
test('IPv6 addresses tests', t => {
|
|
t.ok(v6.isFormat('0:0:0:0:0:0:0:0'), '8 octets')
|
|
t.ok(v6.isFormat('ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff'), '8 full octets')
|
|
t.ok(v6.isFormat('::'), 'expanding ::')
|
|
t.ok(v6.isFormat('::1'), '0-9')
|
|
t.ok(v6.isFormat('::f'), 'a-f')
|
|
t.ok(v6.isFormat('::F'), 'upper characters need to match')
|
|
t.ok(v6.isFormat('::ff'), '2 chars')
|
|
t.ok(v6.isFormat('::fff'), '3 chars')
|
|
t.ok(v6.isFormat('::ffff'), '4 chars')
|
|
t.ok(v6.isFormat('::0:0:0:0:0:0:0'), 'expanding left')
|
|
t.ok(v6.isFormat('0:0:0:0:0:0:0::'), 'expanding right')
|
|
t.ok(v6.isFormat('0:0:0:0::0:0:0'), 'expanding middle')
|
|
t.ok(v6.isFormat('::ffff:127.0.0.1'), 'ipv4 in v6')
|
|
t.ok(v6.isFormat('::127.0.0.1')) // TODO: Likely non-standard?!
|
|
t.notOk(v6.isFormat(' 0:0:0:0:0:0:0:0'), 'spaces')
|
|
t.notOk(v6.isFormat('0:0:0:0:0:0:0:0 '), 'spaces')
|
|
t.notOk(v6.isFormat('::g'), 'invalid v6')
|
|
t.notOk(v6.isFormat('::g0'), 'invalid v6')
|
|
t.notOk(v6.isFormat('::gg'), 'invalid v6')
|
|
t.notOk(v6.isFormat('::g'), 'invalid v6')
|
|
t.notOk(v6.isFormat('::ffff:127.0.0.1.1'), 'too many ipv4 numbers')
|
|
t.notOk(v6.isFormat('::ffff:127.0.0'), 'incomplete ipv4')
|
|
t.notOk(v6.isFormat('::ffff:127.0'), 'less complete ipv4')
|
|
t.notOk(v6.isFormat('0:0:0:0:::0:0:0:0'), 'too much expansion')
|
|
t.notOk(v6.isFormat('0:0:0:0:0:0:0:0:0'), 'too many octets')
|
|
t.notOk(v6.isFormat('0:0:0:0:0:0:0:10000'), 'too many digits')
|
|
t.notOk(v6.isFormat(':0:0:0:0:0:0:0:0'), '8 octets + expanding left')
|
|
t.end()
|
|
})
|
|
|
|
test('should convert to buffer IPv4 address', t => {
|
|
const buf = encode('127.0.0.1')
|
|
t.equal(Buffer.from(buf).toString('hex'), '7f000001')
|
|
t.equal(decode(buf), '127.0.0.1')
|
|
t.end()
|
|
})
|
|
|
|
test('should convert to buffer IPv4 address in-place', t => {
|
|
const buf = Buffer.alloc(128)
|
|
const offset = 64
|
|
encode('127.0.0.1', buf, offset)
|
|
t.equal(buf.toString('hex', offset, offset + 4), '7f000001')
|
|
t.equal(decode(buf, offset, 4), '127.0.0.1')
|
|
|
|
// Non-standard encodings that are technically working
|
|
// Changing these would mean a breaking change...
|
|
t.equal(decode(encode('256.0.0.0')), '0.0.0.0')
|
|
t.equal(decode(encode('258.0.0.0')), '2.0.0.0')
|
|
t.equal(decode(encode('0.534.0.0')), '0.22.0.0')
|
|
t.equal(decode(encode('0.0.990.0')), '0.0.222.0')
|
|
t.equal(decode(encode('0.0.0.671')), '0.0.0.159')
|
|
// Zero prefixing is allowed, as the encoder supports it.
|
|
// However we need to be aware that
|
|
// https://datatracker.ietf.org/doc/html/rfc3986#section-7.4
|
|
// clearly specifies that this is not a valid URI format.
|
|
t.equal(decode(encode('01.0.0.0')), '1.0.0.0')
|
|
t.equal(decode(encode('0.01.0.0')), '0.1.0.0')
|
|
t.equal(decode(encode('0.0.01.0')), '0.0.1.0')
|
|
t.equal(decode(encode('0.0.0.01')), '0.0.0.1')
|
|
t.equal(decode(encode('001.0.0.0')), '1.0.0.0')
|
|
t.equal(decode(encode('0.001.0.0')), '0.1.0.0')
|
|
t.equal(decode(encode('0.0.001.0')), '0.0.1.0')
|
|
t.equal(decode(encode('0.0.0.001')), '0.0.0.1')
|
|
t.end()
|
|
})
|
|
|
|
test('should convert to buffer IPv6 address', t => {
|
|
const buf = encode('::1')
|
|
t.match(Buffer.from(buf).toString('hex'), /(00){15,15}01/)
|
|
t.equal(decode(buf), '::1')
|
|
testV6(t, '1::', '1::')
|
|
testV6(t, 'abcd::dcba', 'abcd::dcba')
|
|
testV6(t, 'ABCD::DCBA', 'abcd::dcba')
|
|
testV6(t, '::ffff:c0a8:100', '::ffff:c0a8:100')
|
|
testV6(t, '::ffff:ff00', '::ffff:ff00')
|
|
|
|
// Non-standard encodings that are technically working
|
|
// Changing these would mean a breaking change...
|
|
testV6(t, ':', '::', 'dangling colon')
|
|
testV6(t, ':::', '::', 'colon parade?!')
|
|
testV6(t, '::::::::::::::::::', '::', 'colon parade++')
|
|
testV6(t, ':12', '::12', 'dangling colon at start')
|
|
testV6(t, '12:', '12::', 'dangling colon at end')
|
|
testV6(t, '1', '1::', '1 octet')
|
|
testV6(t, '1:2', '1:2::', '2 octets')
|
|
testV6(t, '1:2:3', '1:2:3::', '3 octets')
|
|
testV6(t, '1:2:3:4', '1:2:3:4::', '4 octets')
|
|
testV6(t, '1:2:3:4:5', '1:2:3:4:5::', '5 octets')
|
|
testV6(t, '1:2:3:4:5:6', '1:2:3:4:5:6::', '6 octets')
|
|
testV6(t, '1:2:3:4:5:6:7', '1:2:3:4:5:6:7:0', '7 octets')
|
|
testV6(t, '1:2:3:4::5:6:7:8', '1:2:3:4:0:5:6:7', '8 octets + expanding')
|
|
testV6(t, '1:2:3:4:5:6:7:8:', '1:2:3:4:5:6:7:8', '8 octets + expanding right')
|
|
testV6(t, '12345678', '5678::', 'no colon between numbers')
|
|
testV6(t, '::12345', '::2345', 'too many digits')
|
|
testV6(t, '0111:0:0:0:0:0:0', '111::', '0 prefixing')
|
|
testV6(t, '0011:0:0:0:0:0:0', '11::', '0 prefixing')
|
|
testV6(t, '011:0:0:0:0:0:0', '11::', '0 prefixing')
|
|
testV6(t, '001:0:0:0:0:0:0', '1::', '0 prefixing')
|
|
testV6(t, '01:0:0:0:0:0:0', '1::', '0 prefixing')
|
|
testV6(t, '0:01:0:0:0:0:0', '0:1::', '0 prefixing')
|
|
testV6(t, '0:0:01:0:0:0:0', '::1:0:0:0:0:0', '0 prefixing')
|
|
testV6(t, '0:0:0:01:0:0:0', '::1:0:0:0:0', '0 prefixing')
|
|
testV6(t, '0:0:0:0:01:0:0', '::1:0:0:0', '0 prefixing')
|
|
testV6(t, '0:0:0:0:0:01:0', '::1:0:0', '0 prefixing')
|
|
testV6(t, '0:0:0:0:0:0:01', '::1:0', '0 prefixing')
|
|
testV6(t, '0:0:0:0:0:0:001', '::1:0', '0 prefixing')
|
|
testV6(t, '0:0:0:0:0:0:011', '::11:0', '0 prefixing')
|
|
testV6(t, '0:0:0:0:0:0:0011', '::11:0', '0 prefixing')
|
|
testV6(t, '0:0:0:0:0:0:0111', '::111:0', '0 prefixing')
|
|
testV6(t, '::abcd::', '::abcd:0:0', ':: at end and start')
|
|
testV6(t, '::abcd::9876', '::abcd:0:9876', ':: at middle and start')
|
|
testV6(t, 'abcd::9876::', 'abcd:0:9876::', ':: at middle and end')
|
|
testV6(t, '::abcd::9876::', '::abcd:0:9876:0:0', ':: everywhere')
|
|
testV6(t, 'abcd::9876:123:', 'abcd:0:9876:123::', 'dangling colon + expansion')
|
|
testV6(t, '123:::789::::456::::::', '123::789:0:0:0:456')
|
|
testV6(t, 'abcd98764532', '4532::')
|
|
t.end()
|
|
})
|
|
|
|
test('should convert to buffer IPv6 address in-place', t => {
|
|
const buf = Buffer.alloc(128)
|
|
const offset = 64
|
|
encode('::1', buf, offset)
|
|
t.ok(/(00){15,15}01/.test(buf.toString('hex', offset, offset + 16)))
|
|
t.equal(decode(buf, offset, 16), '::1')
|
|
t.equal(decode(encode('1::', buf, offset),
|
|
offset, 16), '1::')
|
|
t.equal(decode(encode('abcd::dcba', buf, offset),
|
|
offset, 16), 'abcd::dcba')
|
|
t.end()
|
|
})
|
|
|
|
test('should convert to buffer IPv6 mapped IPv4 address', t => {
|
|
let buf = encode('::ffff:127.0.0.1')
|
|
t.equal(Buffer.from(buf).toString('hex'), '00000000000000000000ffff7f000001')
|
|
t.equal(decode(buf), '::ffff:7f00:1')
|
|
|
|
buf = encode('ffff::127.0.0.1')
|
|
t.equal(Buffer.from(buf).toString('hex'), 'ffff000000000000000000007f000001')
|
|
t.equal(decode(buf), 'ffff::7f00:1')
|
|
|
|
buf = encode('0:0:0:0:0:ffff:127.0.0.1')
|
|
t.equal(Buffer.from(buf).toString('hex'), '00000000000000000000ffff7f000001')
|
|
t.equal(decode(buf), '::ffff:7f00:1')
|
|
|
|
// Non-standard encodings that are technically working
|
|
// Changing these would mean a breaking change...
|
|
testV6(t, '127.0.0.1', '7f00:1::', 'ipv4 standalone')
|
|
testV6(t, '127.0.0.1::', '7f00:1::', 'endling ::')
|
|
testV6(t, '::127.0.0.1::', '::7f00:1:0:0', ':: start and end ::')
|
|
testV6(t, ':0:ff::127.0.0.1::', '::ff:0:7f00:1:0:0', 'dangling double colon')
|
|
testV6(t, ':0:ff::127.0.0.1:', '::ff:0:7f00:1:0', 'dangling colon')
|
|
testV6(t, '127.0.0.1:::::::::::::', '7f00:1::', 'colon parade')
|
|
testV6(t, '::ffff:999.0.0.1', '::ffff:e700:1', 'wrong ipv4')
|
|
testV6(t, '::ffff:1.999.0.1', '::ffff:1e7:1', 'wrong ipv4')
|
|
testV6(t, '::ffff:1.0.999.1', '::ffff:100:e701', 'wrong ipv4')
|
|
testV6(t, '::ffff:1.0.0.999', '::ffff:100:e7', 'wrong ipv4')
|
|
testV6(t, ':0:ff::999.1.1.1:', '::ff:0:e701:101:0', 'alt wrong ipv4')
|
|
testV6(t, ':0:ff::1.999.1.1:', '::ff:0:1e7:101:0', 'alt wrong ipv4')
|
|
testV6(t, ':0:ff::1.1.999.1:', '::ff:0:101:e701:0', 'alt wrong ipv4')
|
|
testV6(t, ':0:ff::1.1.1.999:', '::ff:0:101:1e7:0', 'alt wrong ipv4')
|
|
testV6(t, '127.0.0.1:0:0', '7f00:1::', 'ipv4 at the start')
|
|
// the regular encoder would identify the ip as ipv4 here, using ipv6 instead
|
|
t.equal(decode(v6.encode('127.0.0.1')), '7f00:1::', 'ipv4 as is shouldnt work')
|
|
t.end()
|
|
})
|
|
|
|
function testV6 (t, input, output, message) {
|
|
message = `${input} → ${output}${message ? `- ${message}` : ''}`
|
|
let result = v6.decode(v6.encode(input))
|
|
// First, lets do a general en- & decode
|
|
if (result === output) {
|
|
// Then, use a own input buffer to make sure that all bytes are written
|
|
result = v6.decode(v6.encode(input, crypto.randomBytes(v6.size), 0), 0)
|
|
if (result === output) {
|
|
// Then use a buffer that has random data before & after and write in the
|
|
// middle to make sure that the implementation doesn't exceed bounds.
|
|
// (Do this more than once to make sure randomness doesn't hide error
|
|
let buffSlice, safeSlice
|
|
for (let i = 0; i < 4; i++) {
|
|
const buff = crypto.randomBytes(v6.size + 8)
|
|
const safe = Buffer.from(buff)
|
|
v6.decode(v6.encode(input, buff, 4), 4)
|
|
buffSlice = sliceBounds(buff)
|
|
safeSlice = sliceBounds(safe)
|
|
if (buffSlice !== safeSlice) {
|
|
break
|
|
}
|
|
}
|
|
t.equal(buffSlice, safeSlice, `${message} (verified)`)
|
|
} else {
|
|
t.equal(result, output, `${message} (0 offset byob)`)
|
|
}
|
|
} else {
|
|
t.equal(result, output, message)
|
|
}
|
|
}
|
|
|
|
function sliceBounds (buff) {
|
|
return Buffer.concat([buff.slice(0, 4), buff.slice(buff.length - 4)]).toString('hex')
|
|
}
|
|
|
|
test('error decoding a buffer of unexpected length', t => {
|
|
t.throws(() => decode(Buffer.alloc(0)))
|
|
t.end()
|
|
})
|
|
|
|
test('should use on-demand allocation', t => {
|
|
let buf = encode('127.0.0.1', Buffer.alloc)
|
|
t.equal(buf.toString('hex'), '7f000001')
|
|
buf = encode('127.0.0.1', size => Buffer.alloc(size + 2), 4)
|
|
t.equal(buf.toString('hex'), '000000007f0000010000')
|
|
t.end()
|
|
})
|
|
|
|
test('dedicated encoding v4/v6', t => {
|
|
t.deepEqual(encode('127.0.0.1'), v4.encode('127.0.0.1'))
|
|
t.deepEqual(encode('::'), v6.encode('::'))
|
|
t.end()
|
|
})
|
|
|
|
test('sizeOf/familyOf test', t => {
|
|
t.equal(sizeOf('127.0.0.1'), 4)
|
|
t.equal(familyOf('127.0.0.1'), 1)
|
|
t.equal(sizeOf('::'), 16)
|
|
t.equal(familyOf('::'), 2)
|
|
t.throws(() => sizeOf(''))
|
|
t.throws(() => familyOf(''))
|
|
t.throws(() => sizeOf('?'))
|
|
t.throws(() => familyOf('?'))
|
|
t.end()
|
|
})
|