From d6444d8c60ec2202a73c7ec820479523c0c26ed3 Mon Sep 17 00:00:00 2001 From: Gabriel Tofvesson Date: Sat, 7 Nov 2020 01:35:57 +0100 Subject: [PATCH] Initial commit --- .idea/.gitignore | 3 + .idea/inspectionProfiles/Project_Default.xml | 17 ++ .idea/kotlinc.xml | 6 + .idea/libraries/KotlinJavaRuntime.xml | 19 ++ .idea/misc.xml | 6 + .idea/modules.xml | 8 + NetObserve.iml | 12 ++ src/dev/w1zzrd/extensions/Streams.kt | 49 +++++ src/dev/w1zzrd/json/JSONType.kt | 191 ++++++++++++++++++ src/dev/w1zzrd/packets/Packet.kt | 137 +++++++++++++ src/dev/w1zzrd/packets/link/EthernetPacket.kt | 22 ++ src/dev/w1zzrd/packets/link/MACAddress.kt | 8 + src/dev/w1zzrd/packets/pcap/CaptureFile.kt | 68 +++++++ .../packets/transport/DatagramProtocol.kt | 163 +++++++++++++++ .../ExplicitCongestionNotification.kt | 5 + src/dev/w1zzrd/packets/transport/IP4Packet.kt | 179 ++++++++++++++++ src/dev/w1zzrd/packets/transport/IPAddress.kt | 27 +++ 17 files changed, 920 insertions(+) create mode 100644 .idea/.gitignore create mode 100644 .idea/inspectionProfiles/Project_Default.xml create mode 100644 .idea/kotlinc.xml create mode 100644 .idea/libraries/KotlinJavaRuntime.xml create mode 100644 .idea/misc.xml create mode 100644 .idea/modules.xml create mode 100644 NetObserve.iml create mode 100644 src/dev/w1zzrd/extensions/Streams.kt create mode 100644 src/dev/w1zzrd/json/JSONType.kt create mode 100644 src/dev/w1zzrd/packets/Packet.kt create mode 100644 src/dev/w1zzrd/packets/link/EthernetPacket.kt create mode 100644 src/dev/w1zzrd/packets/link/MACAddress.kt create mode 100644 src/dev/w1zzrd/packets/pcap/CaptureFile.kt create mode 100644 src/dev/w1zzrd/packets/transport/DatagramProtocol.kt create mode 100644 src/dev/w1zzrd/packets/transport/ExplicitCongestionNotification.kt create mode 100644 src/dev/w1zzrd/packets/transport/IP4Packet.kt create mode 100644 src/dev/w1zzrd/packets/transport/IPAddress.kt diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..26d3352 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,3 @@ +# Default ignored files +/shelf/ +/workspace.xml diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml new file mode 100644 index 0000000..7380573 --- /dev/null +++ b/.idea/inspectionProfiles/Project_Default.xml @@ -0,0 +1,17 @@ + + + + \ No newline at end of file diff --git a/.idea/kotlinc.xml b/.idea/kotlinc.xml new file mode 100644 index 0000000..0dd4b35 --- /dev/null +++ b/.idea/kotlinc.xml @@ -0,0 +1,6 @@ + + + + + \ No newline at end of file diff --git a/.idea/libraries/KotlinJavaRuntime.xml b/.idea/libraries/KotlinJavaRuntime.xml new file mode 100644 index 0000000..1a7265d --- /dev/null +++ b/.idea/libraries/KotlinJavaRuntime.xml @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..0548357 --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 0000000..21f1fd0 --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/NetObserve.iml b/NetObserve.iml new file mode 100644 index 0000000..245d342 --- /dev/null +++ b/NetObserve.iml @@ -0,0 +1,12 @@ + + + + + + + + + + + + \ No newline at end of file diff --git a/src/dev/w1zzrd/extensions/Streams.kt b/src/dev/w1zzrd/extensions/Streams.kt new file mode 100644 index 0000000..d4e29e9 --- /dev/null +++ b/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)) \ No newline at end of file diff --git a/src/dev/w1zzrd/json/JSONType.kt b/src/dev/w1zzrd/json/JSONType.kt new file mode 100644 index 0000000..ef7fe3a --- /dev/null +++ b/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 = ArrayList()): JSONType(), MutableList 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 = HashMap()): JSONType(), MutableMap 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(val value: T): JSONType() { + class JSONString(value: String): JSONValue(value) { + override fun toString() = "\"${value.replace("\\", "\\\\").replace("\"", "\\\"")}\"" + } + + class JSONNumber(value: BigDecimal): JSONValue(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 { + var current = skipSpaces(from + 1) + + if (current == -1) + return null to 0 + + if (this[current] == '}') + return JSONObject() to current + 1 + + val content = HashMap() + 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 { + var current = skipSpaces(from + 1) + + val array = ArrayList() + 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 { + 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 { + 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 { + 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 + } +} \ No newline at end of file diff --git a/src/dev/w1zzrd/packets/Packet.kt b/src/dev/w1zzrd/packets/Packet.kt new file mode 100644 index 0000000..f04aae5 --- /dev/null +++ b/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 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 { + 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(private val byteOffset: UInt, private val toValue: ByteBuffer.(Int) -> T): InnerProvidable() { + 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(byteOffset, ByteBuffer::get) + protected class ShortAt(byteOffset: UInt) : ValueAt(byteOffset, ByteBuffer::getShort) + protected class IntAt(byteOffset: UInt) : ValueAt(byteOffset, ByteBuffer::getInt) + protected class LongAt(byteOffset: UInt) : ValueAt(byteOffset, ByteBuffer::getLong) + protected class FloatAt(byteOffset: UInt) : ValueAt(byteOffset, ByteBuffer::getFloat) + protected class DoubleAt(byteOffset: UInt) : ValueAt(byteOffset, ByteBuffer::getDouble) + + protected class UByteAt(byteOffset: UInt) : ValueAt(byteOffset, { get(it).toUByte() }) + protected class UShortAt(byteOffset: UInt) : ValueAt(byteOffset, { getShort(it).toUShort() }) + protected class UIntAt(byteOffset: UInt) : ValueAt(byteOffset, { getInt(it).toUInt() }) + protected class ULongAt(byteOffset: UInt) : ValueAt(byteOffset, { getLong(it).toULong() }) + + protected class BitsAt(private val byteOffset: UInt, private val bitOffset: UInt, private val count: UInt = 1u): InnerProvidable() { + 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() { + 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() +} \ No newline at end of file diff --git a/src/dev/w1zzrd/packets/link/EthernetPacket.kt b/src/dev/w1zzrd/packets/link/EthernetPacket.kt new file mode 100644 index 0000000..a86d572 --- /dev/null +++ b/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) +} \ No newline at end of file diff --git a/src/dev/w1zzrd/packets/link/MACAddress.kt b/src/dev/w1zzrd/packets/link/MACAddress.kt new file mode 100644 index 0000000..fd1f275 --- /dev/null +++ b/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") + } +} \ No newline at end of file diff --git a/src/dev/w1zzrd/packets/pcap/CaptureFile.kt b/src/dev/w1zzrd/packets/pcap/CaptureFile.kt new file mode 100644 index 0000000..61c483e --- /dev/null +++ b/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 = ArrayList()): List 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) + } + */ + } +} \ No newline at end of file diff --git a/src/dev/w1zzrd/packets/transport/DatagramProtocol.kt b/src/dev/w1zzrd/packets/transport/DatagramProtocol.kt new file mode 100644 index 0000000..acc124a --- /dev/null +++ b/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] + } + } +} \ No newline at end of file diff --git a/src/dev/w1zzrd/packets/transport/ExplicitCongestionNotification.kt b/src/dev/w1zzrd/packets/transport/ExplicitCongestionNotification.kt new file mode 100644 index 0000000..69b8a1e --- /dev/null +++ b/src/dev/w1zzrd/packets/transport/ExplicitCongestionNotification.kt @@ -0,0 +1,5 @@ +package dev.w1zzrd.packets.transport + +enum class ExplicitCongestionNotification { + INCAPABLE, CAPABLE0, CAPABLE1, CONGESTION_ENCOUNTERED +} \ No newline at end of file diff --git a/src/dev/w1zzrd/packets/transport/IP4Packet.kt b/src/dev/w1zzrd/packets/transport/IP4Packet.kt new file mode 100644 index 0000000..49ff554 --- /dev/null +++ b/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 UInt.toEnum(): T where T: Enum { + val values = (T::class.functions.first { it.name == "values" }.call() as Array) + + 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() + 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() + } + + 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 by optionIndices { + init { + if (headerLength == 20u) optionIndices = UIntArray(0) + else { + var readCount = 0u + var total = 0u + + val offsets = ArrayList() + + 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() + 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() + } +} \ No newline at end of file diff --git a/src/dev/w1zzrd/packets/transport/IPAddress.kt b/src/dev/w1zzrd/packets/transport/IPAddress.kt new file mode 100644 index 0000000..f08a991 --- /dev/null +++ b/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 +} \ No newline at end of file