Initial commit

.idea/.gitignore

@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,17 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="unused" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+      <option name="LOCAL_VARIABLE" value="true" />
+      <option name="FIELD" value="true" />
+      <option name="METHOD" value="true" />
+      <option name="CLASS" value="true" />
+      <option name="PARAMETER" value="true" />
+      <option name="REPORT_PARAMETER_FOR_PUBLIC_METHODS" value="true" />
+      <option name="ADD_MAINS_TO_ENTRIES" value="true" />
+      <option name="ADD_APPLET_TO_ENTRIES" value="true" />
+      <option name="ADD_SERVLET_TO_ENTRIES" value="true" />
+      <option name="ADD_NONJAVA_TO_ENTRIES" value="true" />
+    </inspection_tool>
+  </profile>
+</component>

.idea/kotlinc.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Kotlin2JvmCompilerArguments">
+    <option name="jvmTarget" value="1.8" />
+  </component>
+</project>

.idea/libraries/KotlinJavaRuntime.xml

@@ -0,0 +1,19 @@
+<component name="libraryTable">
+  <library name="KotlinJavaRuntime">
+    <CLASSES>
+      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-stdlib.jar!/" />
+      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-reflect.jar!/" />
+      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-test.jar!/" />
+      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-stdlib-jdk7.jar!/" />
+      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-stdlib-jdk8.jar!/" />
+    </CLASSES>
+    <JAVADOC />
+    <SOURCES>
+      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-stdlib-sources.jar!/" />
+      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-reflect-sources.jar!/" />
+      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-test-sources.jar!/" />
+      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-stdlib-jdk7-sources.jar!/" />
+      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-stdlib-jdk8-sources.jar!/" />
+    </SOURCES>
+  </library>
+</component>

.idea/misc.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="true" project-jdk-name="1.8" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/NetObserve.iml" filepath="$PROJECT_DIR$/NetObserve.iml" />
+    </modules>
+  </component>
+</project>

NetObserve.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
+  </component>
+</module>

src/dev/w1zzrd/extensions/Streams.kt

@@ -0,0 +1,49 @@
+package dev.w1zzrd.extensions
+
+import java.io.InputStream
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+
+fun InputStream.readShort(byteBuffer: ByteBuffer = ByteBuffer.allocate(2)): Short {
+    read(byteBuffer.array(), 0, 2)
+    return byteBuffer.getShort(0)
+}
+
+fun InputStream.readInt(byteBuffer: ByteBuffer = ByteBuffer.allocate(4)): Int {
+    read(byteBuffer.array(), 0, 4)
+    return byteBuffer.getInt(0)
+}
+
+fun InputStream.readLong(byteBuffer: ByteBuffer = ByteBuffer.allocate(8)): Long {
+    read(byteBuffer.array(), 0, 8)
+    return byteBuffer.getLong(0)
+}
+
+fun InputStream.readUShort(byteBuffer: ByteBuffer = ByteBuffer.allocate(2)) =
+        readShort(byteBuffer).toUShort()
+
+fun InputStream.readUInt(byteBuffer: ByteBuffer = ByteBuffer.allocate(4)) =
+        readInt(byteBuffer).toUInt()
+
+fun InputStream.readULong(byteBuffer: ByteBuffer = ByteBuffer.allocate(8)) =
+        readLong(byteBuffer).toULong()
+
+fun InputStream.readFloat(byteBuffer: ByteBuffer = ByteBuffer.allocate(4)): Float {
+    read(byteBuffer.array(), 0, 4)
+    return byteBuffer.getFloat(0)
+}
+
+fun InputStream.readDouble(byteBuffer: ByteBuffer = ByteBuffer.allocate(8)): Double {
+    read(byteBuffer.array(), 0, 8)
+    return byteBuffer.getDouble(0)
+}
+
+
+fun InputStream.readShort(byteOrder: ByteOrder) = readShort(ByteBuffer.allocate(2).order(byteOrder))
+fun InputStream.readInt(byteOrder: ByteOrder) = readInt(ByteBuffer.allocate(4).order(byteOrder))
+fun InputStream.readLong(byteOrder: ByteOrder) = readLong(ByteBuffer.allocate(8).order(byteOrder))
+fun InputStream.readUShort(byteOrder: ByteOrder) = readUShort(ByteBuffer.allocate(2).order(byteOrder))
+fun InputStream.readUInt(byteOrder: ByteOrder) = readUInt(ByteBuffer.allocate(4).order(byteOrder))
+fun InputStream.readULong(byteOrder: ByteOrder) = readULong(ByteBuffer.allocate(8).order(byteOrder))
+fun InputStream.readFloat(byteOrder: ByteOrder) = readFloat(ByteBuffer.allocate(4).order(byteOrder))
+fun InputStream.readDouble(byteOrder: ByteOrder) = readDouble(ByteBuffer.allocate(8).order(byteOrder))

src/dev/w1zzrd/json/JSONType.kt

@@ -0,0 +1,191 @@
+package dev.w1zzrd.json
+
+import java.math.BigDecimal
+
+sealed class JSONType {
+    class JSONArray(private val array: MutableList<JSONType> = ArrayList()): JSONType(), MutableList<JSONType> by array {
+        override fun toString(): String {
+            val builder = StringBuilder()
+
+            builder.append('[')
+
+            var isFirst = true
+            for (value in this) {
+                if (isFirst) isFirst = false
+                else builder.append(',')
+
+                builder.append(value.toString())
+            }
+
+            return builder.append(']').toString()
+        }
+    }
+
+    class JSONObject(private val content: MutableMap<String, JSONType> = HashMap()): JSONType(), MutableMap<String, JSONType> by content {
+        override fun toString(): String {
+            val builder = StringBuilder()
+            builder.append('{')
+
+            var isFirst = true
+            for ((key, value) in content) {
+                if (!isFirst) builder.append(',')
+                else isFirst = false
+                builder.append(JSONValue.JSONString(key).toString()).append(':').append(value.toString())
+            }
+
+            return builder.append("}").toString()
+        }
+    }
+
+    sealed class JSONValue<T>(val value: T): JSONType() {
+        class JSONString(value: String): JSONValue<String>(value) {
+            override fun toString() = "\"${value.replace("\\", "\\\\").replace("\"", "\\\"")}\""
+        }
+
+        class JSONNumber(value: BigDecimal): JSONValue<BigDecimal>(value) {
+            override fun toString() = value.toString()
+        }
+
+        override fun equals(other: Any?) = value == other
+        override fun hashCode() = value.hashCode()
+    }
+
+    abstract override fun toString(): String
+
+
+    fun obj() = this as JSONObject
+    fun arr() = this as JSONArray
+    fun str() = this as JSONValue.JSONString
+    fun num() = this as JSONValue.JSONNumber
+
+    companion object {
+        fun parse(content: String) = parseOrNull(content)!!
+
+        private fun String.skipSpaces(from: Int): Int {
+            for (index in from until length)
+                if (!Character.isSpaceChar(this[index]))
+                    return index
+            return -1
+        }
+
+        private fun String.parseString(from: Int): String? {
+            for (index in from + 1 until length)
+                if (this[index] == '"' && this[index - 1] != '\\')
+                    return substring(from + 1 until index)
+            return null
+        }
+
+        private fun String.parseJSONObject(from: Int): Pair<JSONObject?, Int> {
+            var current = skipSpaces(from + 1)
+
+            if (current == -1)
+                return null to 0
+
+            if (this[current] == '}')
+                return JSONObject() to current + 1
+
+            val content = HashMap<String, JSONType>()
+            do {
+                if(this[current] == '"') {
+                    // Read key
+                    val key = parseString(current) ?: return null to 0
+
+                    // Skip ':' delimiter
+                    var after = skipSpaces(current + key.length + 2)
+                    if (after == -1 || this[after] != ':')
+                        return null to 0
+
+                    after = skipSpaces(after + 1)
+                    if (after == -1)
+                        return null to 0
+
+                    // Read value
+                    val value = parseJSONType(after)
+                    if (value.first == null)
+                        return null to 0
+
+                    content[key] = value.first!!
+
+
+                    // Skip ',' (or find end of object)
+                    current = skipSpaces(value.second)
+                    if (this[current] == '}')
+                        return JSONObject(content) to current + 1
+
+                    if (this[current] != ',')
+                        return null to 0
+
+                    current = skipSpaces(current + 1)
+
+                    // Improper placement of closing bracket
+                    if (this[current] == '}')
+                        return null to 0
+                }
+                else return null to 0
+            } while (true)
+        }
+
+        private fun String.parseJSONArray(from: Int): Pair<JSONArray?, Int> {
+            var current = skipSpaces(from + 1)
+
+            val array = ArrayList<JSONType>()
+            while (current < length && this[current] != ']') {
+                val parsed = parseJSONType(current)
+                if (parsed.first == null)
+                    return null to 0
+
+                array.add(parsed.first!!)
+
+                current = skipSpaces(parsed.second)
+                when {
+                    current >= length -> return null to 0
+                    current == length - 1 && this[current] != ']' -> return null to 0
+                    this[current] == ']' -> return JSONArray(array) to current + 1
+                    this[current] != ',' -> return null to 0
+                }
+                current = skipSpaces(current + 1)
+            }
+
+            return JSONArray(array) to current + 1
+        }
+
+        private fun String.parseJSONString(from: Int): Pair<JSONValue.JSONString?, Int> {
+            val string = parseString(from)
+            return if (string != null) JSONValue.JSONString(string) to string.length + from + 2
+            else null to 0
+        }
+
+        private fun String.parseJSONNumber(from: Int): Pair<JSONValue.JSONNumber?, Int> {
+            var hasDecimal = false
+            for (index in from until length)
+                if (this[index] == '-') {
+                    if(index != from)
+                        return null to 0
+                }
+                else if (this[index] == '.') {
+                    if (hasDecimal) return null to 0
+                    else hasDecimal = true
+                }
+                else if (!Character.isDigit(this[index]))
+                    return if (index == from) null to 0
+                    else JSONValue.JSONNumber(substring(from until index).toBigDecimal()) to index
+
+            return JSONValue.JSONNumber(substring(from).toBigDecimal()) to length - 1
+        }
+
+        private fun String.parseJSONType(from: Int): Pair<JSONType?, Int> {
+            val next = skipSpaces(from)
+            if (next == -1)
+                return null to 0
+
+            return when(this[next]) {
+                '[' -> parseJSONArray(next)
+                '"' -> parseJSONString(next)
+                '{' -> parseJSONObject(next)
+                else -> parseJSONNumber(next)
+            }
+        }
+
+        fun parseOrNull(content: String) = content.parseJSONType(0).first
+    }
+}

src/dev/w1zzrd/packets/Packet.kt

@@ -0,0 +1,137 @@
+package dev.w1zzrd.packets
+
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import kotlin.reflect.KProperty
+
+/**
+ * Packet structure:
+ *
+ *      Byte Array:
+ *
+ *          [...,*,*,*,*,H,H,H,H,D,D,D,*,*,*,*,...]
+ *
+ *      *: Not packet
+ *
+ *      H: Packet Header
+ *
+ *      D: Packet data
+ *
+ *      Data before first 'H' is the offset.
+ *
+ *      Length between first 'H' and last 'D' is length.
+ *
+ *      Length between first 'H' and last 'H' is headerLength.
+ */
+open class Packet(
+        val data: ByteArray,
+        val offset: UInt,
+        val contentLength: UInt,
+        val headerSize: UInt,
+        val byteOrder: ByteOrder = ByteOrder.BIG_ENDIAN
+) {
+    constructor(wrap: Packet, headerLength: UInt, byteOrder: ByteOrder = ByteOrder.BIG_ENDIAN) :
+            this(
+                    wrap.data,
+                    wrap.offset + wrap.headerSize,
+                    if (headerLength > wrap.contentLength)
+                        throw IllegalArgumentException("Length of header exceeds content bounds")
+                    else wrap.contentLength - headerLength,
+                    headerLength,
+                    byteOrder
+            )
+
+    init {
+        if (data.size.toUInt() < offset + headerSize + contentLength)
+            throw IllegalArgumentException("Packet exceeds array bounds!")
+    }
+
+
+    protected fun offsetAt(offset: UInt) = (this.offset + offset).toInt()
+
+    protected abstract class InnerProvidable<T, R> where T: Any {
+        private var _thisRef: T? = null
+        protected val thisRef
+            get() = _thisRef!!
+
+        operator fun getValue(thisRef: Any?, property: KProperty<*>) = getValue(property)
+        abstract fun getValue(property: KProperty<*>): R
+
+
+        // This is a hack to provide delegates referencing fields in outer classes
+        operator fun provideDelegate(thisRef: Any, property: KProperty<*>): InnerProvidable<T, R> {
+            val outer = thisRef.javaClass.declaredFields.firstOrNull { it.name == "this$0" }
+            outer?.isAccessible = true
+
+            _thisRef =
+                    if (outer != null) outer.get(thisRef) as T
+                    else thisRef as T
+            return this
+        }
+    }
+    protected open class ValueAt<T>(private val byteOffset: UInt, private val toValue: ByteBuffer.(Int) -> T): InnerProvidable<Packet, T>() {
+        override fun getValue(property: KProperty<*>) =
+                ByteBuffer
+                        .wrap(thisRef.data, thisRef.offset.toInt(), thisRef.data.size - thisRef.offset.toInt())
+                        .order(thisRef.byteOrder)
+                        .toValue(byteOffset.toInt())
+    }
+
+    protected class ByteAt(byteOffset: UInt) : ValueAt<Byte>(byteOffset, ByteBuffer::get)
+    protected class ShortAt(byteOffset: UInt) : ValueAt<Short>(byteOffset, ByteBuffer::getShort)
+    protected class IntAt(byteOffset: UInt) : ValueAt<Int>(byteOffset, ByteBuffer::getInt)
+    protected class LongAt(byteOffset: UInt) : ValueAt<Long>(byteOffset, ByteBuffer::getLong)
+    protected class FloatAt(byteOffset: UInt) : ValueAt<Float>(byteOffset, ByteBuffer::getFloat)
+    protected class DoubleAt(byteOffset: UInt) : ValueAt<Double>(byteOffset, ByteBuffer::getDouble)
+
+    protected class UByteAt(byteOffset: UInt) : ValueAt<UByte>(byteOffset, { get(it).toUByte() })
+    protected class UShortAt(byteOffset: UInt) : ValueAt<UShort>(byteOffset, { getShort(it).toUShort() })
+    protected class UIntAt(byteOffset: UInt) : ValueAt<UInt>(byteOffset, { getInt(it).toUInt() })
+    protected class ULongAt(byteOffset: UInt) : ValueAt<ULong>(byteOffset, { getLong(it).toULong() })
+
+    protected class BitsAt(private val byteOffset: UInt, private val bitOffset: UInt, private val count: UInt = 1u): InnerProvidable<Packet, UByte>() {
+        init {
+            // This is a limitation for performance reasons
+            if (count + bitOffset > 8u)
+                throw IndexOutOfBoundsException("Cannot index bits across byte boundary")
+        }
+
+        override fun getValue(property: KProperty<*>) =
+                (thisRef.data[thisRef.offsetAt(byteOffset)].toUInt() and 0xFFu shr bitOffset.toInt() and (0xFFu shr (8 - count.toInt()))).toUByte()
+    }
+
+    protected class SequenceAt(private val byteOffset: UInt, private val length: UInt): InnerProvidable<Packet, ByteArray>() {
+        override fun getValue(property: KProperty<*>) =
+                thisRef.data.slice(thisRef.offsetAt(byteOffset) until thisRef.offsetAt(byteOffset) + length.toInt()).toByteArray()
+    }
+
+
+
+
+    protected fun bitAt(byteOffset: UInt, bitOffset: UInt) =
+            if (bitOffset > 7u) throw RuntimeException("Bit offset cannot exceed 7")
+            else (data[offsetAt(byteOffset)].toInt() shr bitOffset.toInt() and 1).toUInt()
+
+    protected fun bitsAt(byteOffset: UInt, bitOffset: UInt, seqLength: UInt) =
+            when {
+                bitOffset > 7u -> throw RuntimeException("Bit offset cannot exceed 7")
+                seqLength > 8u - bitOffset -> throw RuntimeException("Sequence length cannot exceed byte limit")
+                seqLength == 0u -> throw RuntimeException("Sequence length cannot be zero")
+                else -> (data[offsetAt(byteOffset)].toInt() shr bitOffset.toInt() and (0xFF ushr (8u - seqLength).toInt())).toUInt()
+            }
+
+    protected fun byteAt(offset: UInt) = data[offsetAt(offset)]
+    protected fun shortAt(offset: UInt) = ByteBuffer.wrap(data).order(this.byteOrder).getShort(offsetAt(offset))
+    protected fun intAt(offset: UInt) = ByteBuffer.wrap(data).order(this.byteOrder).getInt(offsetAt(offset))
+    protected fun longAt(offset: UInt) = ByteBuffer.wrap(data).order(this.byteOrder).getLong(offsetAt(offset))
+
+    protected fun uByteAt(offset: UInt) = byteAt(offset).toUByte()
+    protected fun uShortAt(offset: UInt) = shortAt(offset).toUShort()
+    protected fun uIntAt(offset: UInt) = intAt(offset).toUInt()
+    protected fun uLongAt(offset: UInt) = longAt(offset).toULong()
+
+    protected fun floatAt(offset: UInt) = ByteBuffer.wrap(data).order(this.byteOrder).getFloat(offsetAt(offset))
+    protected fun doubleAt(offset: UInt) = ByteBuffer.wrap(data).order(this.byteOrder).getDouble(offsetAt(offset))
+
+    protected fun sequenceAt(offset: UInt, length: UInt) = data.slice(offsetAt(offset) until length.toInt()).toByteArray()
+}

src/dev/w1zzrd/packets/link/EthernetPacket.kt

@@ -0,0 +1,22 @@
+package dev.w1zzrd.packets.link
+
+import dev.w1zzrd.packets.Packet
+import java.nio.ByteOrder
+
+class EthernetPacket: Packet {
+    constructor(
+            data: ByteArray,
+            offset: UInt,
+            contentLength: UInt,
+            byteOrder: ByteOrder = ByteOrder.BIG_ENDIAN
+    ) : super(data, offset, contentLength, 14u, byteOrder)
+    constructor(
+            wrap: Packet,
+            byteOrder: ByteOrder = ByteOrder.BIG_ENDIAN
+    ) : super(wrap, 14u, byteOrder)
+
+    val destination by lazy { MACAddress(*sequenceAt(0u, 6u)) }
+    val source by lazy { MACAddress(*sequenceAt(6u, 12u)) }
+    val type: UShort
+        get() = uShortAt(12u)
+}

src/dev/w1zzrd/packets/link/MACAddress.kt

@@ -0,0 +1,8 @@
+package dev.w1zzrd.packets.link
+
+class MACAddress(vararg addr: Byte) {
+    init {
+        if (addr.size != 6)
+            throw IllegalArgumentException("Not a MAC address")
+    }
+}

src/dev/w1zzrd/packets/pcap/CaptureFile.kt

@@ -0,0 +1,68 @@
+package dev.w1zzrd.packets.pcap
+
+import dev.w1zzrd.extensions.readInt
+import dev.w1zzrd.extensions.readUInt
+import dev.w1zzrd.extensions.readUShort
+import dev.w1zzrd.packets.Packet
+import java.io.File
+import java.io.FileNotFoundException
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+
+class CaptureFile(file: File, private val packets: ArrayList<Packet> = ArrayList()): List<Packet> by packets {
+    val byteOrder: ByteOrder
+
+    val h_magic_number: UInt
+    val h_version_major: UShort
+    val h_version_minor: UShort
+    val h_thiszone: Int
+    val h_sigfigs: UInt
+    val h_snaplen: UInt
+    val h_network: UInt
+
+    val packetCount: Int
+        get() = packets.size
+
+    init {
+        // Check that the file exists
+        if (!file.isFile)
+            throw FileNotFoundException()
+
+        // Check that the PCAP global header exists
+        if (file.length() < 24)
+            throw IllegalArgumentException("File is not long enough")
+
+        // Read PCAP global header
+        val buf = ByteArray(4)
+        val bufWrap = ByteBuffer.wrap(buf)
+        val istream = file.inputStream()
+
+        h_magic_number = istream.readUInt(bufWrap)
+
+        byteOrder = when (h_magic_number) {
+            0xa1b2c3d4u -> ByteOrder.BIG_ENDIAN
+            0xd4c3b2a1u -> ByteOrder.LITTLE_ENDIAN
+            else -> throw RuntimeException("Bad file magic")
+        }
+
+        bufWrap.order(byteOrder)
+
+        h_version_major = istream.readUShort(bufWrap)
+        h_version_minor = istream.readUShort(bufWrap)
+        h_thiszone = istream.readInt(bufWrap)
+        h_sigfigs = istream.readUInt(bufWrap)
+        h_snaplen = istream.readUInt(bufWrap)
+        h_network = istream.readUInt(bufWrap)
+
+        // Read packets
+        /*
+        var readCount = 24
+        while (readCount < file.length()) {
+            val packet = Packet(istream, byteOrder)
+
+            readCount += 32 + packet.packetData.size
+            packets.add(packet)
+        }
+        */
+    }
+}

src/dev/w1zzrd/packets/transport/DatagramProtocol.kt

@@ -0,0 +1,163 @@
+package dev.w1zzrd.packets.transport
+
+enum class DatagramProtocol {
+    HOPOPT,
+    ICMP,
+    IGMP,
+    GGP,
+    IP_in_IP,
+    ST,
+    TCP,
+    CBT,
+    EGP,
+    IGP,
+    BBN_RCC_MON,
+    NVP_II,
+    PUP,
+    ARGUS,
+    EMCON,
+    XNET,
+    CHAOS,
+    UDP,
+    MUX,
+    DCN_MEAS,
+    HMP,
+    PRM,
+    XNS_IDP,
+    TRUNK_1,
+    TRUNK_2,
+    LEAF_1,
+    LEAF_2,
+    RDP,
+    IRTP,
+    ISO_TP4,
+    NETBLT,
+    MFE_NSP,
+    MERIT_INP,
+    DCCP,
+    THIRD_PARTY,
+    IDPR,
+    XTP,
+    DDP,
+    IDPR_CMTP,
+    TPPP,
+    IL,
+    IPv6,
+    SDRP,
+    IPv6_Route,
+    IPv6_Frag,
+    IDRP,
+    RSVP,
+    GREs,
+    DSR,
+    BNA,
+    ESP,
+    AH,
+    I_NLSP,
+    SwIPe,
+    NARP,
+    MOBILE,
+    TLSP,
+    SKIP,
+    IPv6_ICMP,
+    IPv6_NoNxt,
+    IPv6_Opts,
+    ANY_INTERNAL,
+    CFTP,
+    ANY_LOCAL,
+    SAT_EXPAK,
+    KRYPTOLAN,
+    RVD,
+    IPPC,
+    ANY_DISTRIBUTED_FS,
+    SAT_MON,
+    VISA,
+    IPCU,
+    CPNX,
+    CPHB,
+    WSN,
+    PVP,
+    BR_SAT_MON,
+    SUN_ND,
+    WB_MON,
+    WB_EXPAK,
+    ISO_IP,
+    VMTP,
+    SECURE_VMTP,
+    VINES,
+    TTP,
+    IPTM,
+    NSFNET_IGP,
+    DGP,
+    TCF,
+    EIGRP,
+    OSPF,
+    Sprite_RPC,
+    LARP,
+    MTP,
+    AX_25,
+    OS,
+    MICP,
+    SCC_SP,
+    ETHERIP,
+    ENCAP,
+    ANY_PRIVATE_ENCRYPTION,
+    GMTP,
+    IFMP,
+    PNNI,
+    PIM,
+    ARIS,
+    SCPS,
+    QNX,
+    ACTIVE_NETWORKS,
+    IPComp,
+    SNP,
+    Compaq_Peer,
+    IPX_in_IP,
+    VRRP,
+    PGM,
+    ANY_0_HOP,
+    L2TP,
+    DDX,
+    IATP,
+    STP,
+    SRP,
+    UTI,
+    SMP,
+    SM,
+    PTP,
+    IS_IS_OVER_IPv4,
+    FIRE,
+    CRTP,
+    CRUDP,
+    SSCOPMCE,
+    IPLT,
+    SPS,
+    PIPE,
+    SCTP,
+    FC,
+    RSVP_E2E_IGNORE,
+    Mobility_Header,
+    UDPLite,
+    MPLS_in_IP,
+    manet,
+    HIP,
+    Shim6,
+    WESP,
+    ROHC,
+    Ethernet,
+
+    Unassigned,
+    Experimentation,
+    Reserved;
+
+    companion object {
+        fun UByte.toDatagramProtocol() =
+                when(this.toUInt() and 0xFFu) {
+                    in 0x90u until 0xFDu -> Unassigned
+                    in 0xFDu until 0xFFu -> Experimentation
+                    0xFFu -> Reserved
+                    else -> values()[this.toInt() and 0xFF]
+                }
+    }
+}

src/dev/w1zzrd/packets/transport/ExplicitCongestionNotification.kt

@@ -0,0 +1,5 @@
+package dev.w1zzrd.packets.transport
+
+enum class ExplicitCongestionNotification {
+    INCAPABLE, CAPABLE0, CAPABLE1, CONGESTION_ENCOUNTERED
+}

src/dev/w1zzrd/packets/transport/IP4Packet.kt

@@ -0,0 +1,179 @@
+package dev.w1zzrd.packets.transport
+
+import dev.w1zzrd.packets.Packet
+import dev.w1zzrd.packets.transport.DSCPType.Companion.getDSCPType
+import dev.w1zzrd.packets.transport.DatagramProtocol.Companion.toDatagramProtocol
+import dev.w1zzrd.packets.transport.IP4OptionType.Companion.toIP4OptionType
+import java.nio.ByteOrder
+import kotlin.experimental.and
+import kotlin.reflect.full.functions
+
+inline fun <reified T> UInt.toEnum(): T where T: Enum<T> {
+    val values = (T::class.functions.first { it.name == "values" }.call() as Array<T>)
+
+    if (this < values.size.toUInt()) return values[this.toInt()]
+    else throw IllegalArgumentException("Index out of bounds")
+}
+
+enum class ToSPrecedenceType(val literal: UInt) {
+    ROUTINE(0b000u),
+    PRIORITY(0b001u),
+    IMMEDIATE(0b010u),
+    FLASH(0b011u),
+    FLASH_OVERRIDE(0b100u),
+    ECP(0b101u),
+    INTERNET_CONTROL(0b110u),
+    NETWORK_CONTROL(0b111u)
+}
+
+enum class DSCPGrade {
+    NONE, GOLD, SILVER, BRONZE
+}
+
+enum class DSCPType {
+    BEST_EFFORT, CLASSED, EXPRESS_FORWARDING, EXPEDITED_FORWARDING, CONTROL;
+
+    companion object {
+        fun UByte.getDSCPType() =
+                when(this.toUInt() and 0x3Fu) {
+                    0u -> BEST_EFFORT
+                    in 8u until 40u -> CLASSED
+                    in 40u until 46u -> EXPRESS_FORWARDING
+                    in 46u until 48u -> EXPEDITED_FORWARDING
+                    in 48u until 63u -> CONTROL
+                    else -> throw IllegalStateException("This is impossible to reach")
+                }
+    }
+}
+
+enum class IP4OptionType {
+    CONTROL, DEBUG_MEASURE, RESERVED;
+
+    companion object {
+        fun UByte.toIP4OptionType() =
+                when (this.toUInt()) {
+                    0u -> CONTROL
+                    2u -> DEBUG_MEASURE
+                    1u, 3u -> RESERVED
+                    else -> throw IllegalArgumentException("Out of acceptable range")
+                }
+    }
+}
+
+class IP4Packet: Packet {
+    companion object {
+        private fun readHeaderLength(data: ByteArray, offset: UInt) = ((data[offset.toInt()] and 0xF).toInt() shl 2).toUInt()
+    }
+
+    inner class TypeOfService {
+        val rawPrecedence by BitsAt(1u, 5u, 3u)
+        val precedence get() = rawPrecedence.toUInt().toEnum<ToSPrecedenceType>()
+        val delay by BitsAt(1u, 4u)
+        val throughput by BitsAt(1u, 3u)
+        val reliability by BitsAt(1u, 2u)
+        val cost by BitsAt(1u, 1u)
+        val MBZ by BitsAt(1u, 0u)
+    }
+
+
+    open inner class DifferentiatedServicesCodePoint internal constructor() {
+        val rawType by BitsAt(1u, 2u, 6u)
+        val type get() = rawType.getDSCPType()
+    }
+    inner class GradedService : DifferentiatedServicesCodePoint() {
+        val serviceClass by BitsAt(1u, 5u, 3u)
+
+        val rawServiceGrade by BitsAt(1u, 3u, 2u)
+        val serviceGrade get() = rawServiceGrade.toUInt().toEnum<DSCPGrade>()
+    }
+
+    inner class IP4Flags {
+        val reserved by BitsAt(6u, 7u)
+        val dontFragment by BitsAt(6u, 6u)
+        val moreFragments by BitsAt(6u, 5u)
+        val fragmentOffset by BitsAt(6u, 0u, 5u)
+    }
+
+    // IPv4 options field parser
+    inner class IP4Options(private var optionIndices: UIntArray = UIntArray(0)): Collection<UInt> by optionIndices {
+        init {
+            if (headerLength == 20u) optionIndices = UIntArray(0)
+            else {
+                var readCount = 0u
+                var total = 0u
+
+                val offsets = ArrayList<UInt>()
+
+                do {
+                    ++total
+                    offsets.add(readCount)
+
+                    val option = IP4Option(readCount)
+
+                    readCount += option.optionSize
+                } while (readCount < headerLength && option.optionNumber != 0u.toUByte())
+
+                optionIndices = offsets.toUIntArray()
+            }
+        }
+
+        operator fun get(index: Int): IP4Option {
+            if (index >= optionIndices.size || index < 0)
+                throw IndexOutOfBoundsException("Getting IPv4 option out of bounds")
+
+            return IP4Option(optionIndices[index])
+        }
+    }
+
+    // IPv4 option field
+    inner class IP4Option(offset: UInt) {
+        // EOOL and NOP do not declare a length
+        val isSimpleOption
+            get() = optionNumber == 0u.toUByte() || optionNumber == 1u.toUByte()
+        val copied by BitsAt(offset, 7u)
+        val rawOptionClass by BitsAt(offset, 5u, 2u)
+        val optionClass
+            get() = rawOptionClass.toIP4OptionType()
+        val optionNumber by BitsAt(offset, 0u, 5u)
+        val optionSize
+            get() = if(isSimpleOption) 1u else byteAt(offset + 1u).toUInt()
+        val optionData
+            get() = sequenceAt(offset + 2u, optionSize - 2u)
+    }
+
+
+
+    constructor(data: ByteArray, offset: UInt, contentLength: UInt, byteOrder: ByteOrder) :
+            super(data, offset, contentLength, readHeaderLength(data, offset), byteOrder)
+    constructor(wrap: Packet, byteOrder: ByteOrder) :
+            super(wrap, readHeaderLength(wrap.data, wrap.offset + wrap.headerSize), byteOrder)
+
+
+
+    // IPv4 header fields
+            val version         by      BitsAt(0u, 4u, 4u)
+            val headerLength    get() = bitsAt(0u, 0u, 4u) shl 2
+            val typeOfService =         TypeOfService()
+    private val ECNBits         by      BitsAt(1u, 0u, 2u)
+            val ECN             get() = ECNBits.toUInt().toEnum<ExplicitCongestionNotification>()
+    private val DSCPBits        by      BitsAt(1u, 2u, 6u)
+            val DSCP            get() = DSCPBits.toDSCP()
+            val reportedLength  by      ShortAt(2u)
+            val id              by      ShortAt(5u)
+            val fragments =             IP4Flags()
+            val TTL             by      UByteAt(7u)
+    private val protocolByte    by      UByteAt(8u)
+            val protocol        get() = protocolByte.toDatagramProtocol()
+            val checksum        by      UShortAt(10u)
+            val source          get() = IPAddress.IPv4Address(sequenceAt(12u, 4u))
+            val destination     get() = IPAddress.IPv4Address(sequenceAt(16u, 4u))
+            val options =               IP4Options()
+
+
+
+    private fun UByte.toDSCP() =
+            when(getDSCPType()) {
+                DSCPType.CLASSED -> GradedService()
+                else -> DifferentiatedServicesCodePoint()
+            }
+}

src/dev/w1zzrd/packets/transport/IPAddress.kt

@@ -0,0 +1,27 @@
+package dev.w1zzrd.packets.transport
+
+import java.nio.ByteBuffer
+
+sealed class IPAddress(val addr: ByteArray, bytes: UInt) {
+    class IPv4Address(addr: ByteArray) : IPAddress(addr, 4u) {
+        override fun toString() = "${addr[0]}.${addr[1]}.${addr[2]}.${addr[3]}"
+    }
+
+    class IPv6Address(addr: ByteArray) : IPAddress(addr, 16u) {
+        override fun toString(): String {
+            val bb = ByteBuffer.wrap(addr)
+            fun addrPart(idx: Int) =
+                    if (bb.getShort(idx shl 1) == 0.toShort()) ""
+                    else bb.getShort(idx shl 1).toString(16)
+
+            return "${addrPart(0)}:${addrPart(1)}:${addrPart(2)}:${addrPart(3)}:${addrPart(4)}:${addrPart(5)}:${addrPart(6)}:${addrPart(7)}"
+        }
+    }
+
+    init {
+        if (addr.size != bytes.toInt())
+            throw IllegalArgumentException("Not a valid address")
+    }
+
+    abstract override fun toString(): String
+}