IPv8 From Scratch
Implementasi eksperimental IPv8 dari nol menggunakan bahasa C, berdasarkan spesifikasi dan konsep yang didefinisikan dalam Internet-Draft:
Project ini dibuat sebagai implementasi low-level untuk memahami bagaimana sebuah protokol jaringan bekerja dari level address representation, packet format, checksum, routing, hingga komunikasi antar-host.
Tidak menggunakan implementasi IPv8 yang sudah ada sebagai basis.
Project Status
Early Development
Saat ini project berfokus pada fondasi IPv8:
- IPv8 address representation
- ASN calculation
- Host address representation
- 64-bit IPv8 address
- Address parser
- Address formatter
- Address packing/unpacking
- Packet structure
- Checksum
- Ethernet transport
- Linux network namespace testing
Fitur routing dan protocol pendukung akan dikembangkan secara bertahap.
1. Konsep IPv8 Address
IPv8 menggunakan address dengan panjang:
64-bitAddress dibagi menjadi dua bagian:
+----------------------+----------------------+
| Routing / ASN | Host Address |
| 32-bit | 32-bit |
+----------------------+----------------------+
Sehingga:
IPv8 Address = ASN + Host Address
ASN menggunakan 32-bit.
Host address juga menggunakan 32-bit.
Total:
32 + 32 = 64 bit
2. Representasi IPv8
IPv8 dapat direpresentasikan menggunakan delapan octet:
XX.XX.XX.XX.XX.XX.XX.XX
Empat octet pertama merepresentasikan bagian ASN.
Empat octet terakhir merepresentasikan host address.
Contoh:
0.0.255.255.10.173.84.1
Strukturnya:
0.0.255.255 | 10.173.84.1
ASN Host Address
3. ASN 32-bit
ASN merupakan angka integer 32-bit.
Range secara numerik:
0
-
4294967295
Contoh ASN yang digunakan untuk testing project ini:
65535
ASN:
65535
akan dikonversi menjadi empat octet.
4. Perhitungan ASN
Konversi ASN ke empat octet dilakukan menggunakan pembagian basis 256.
Konsep dasarnya:
1 octet = 8 bit
Sehingga:
4 octet = 32 bit
Setiap octet mempunyai nilai:
0 - 255
Karena:
256 = 2^8
5. Algoritma Perhitungan
Perhitungan menggunakan metode pembagian 256 secara bertingkat.
Format dasar:
AS ÷ 256 = hasil_1
hasil_1 × 256 = hasil_2
ASN - hasil_2 = hasil_akhir
hasil_1 ÷ 256 = hasil_kecil
hasil_kecil × 256 = hasil_baru
hasil_1 - hasil_baru = hasil_final
hitungan ini dibuat intruksi dari saya agar lebih memahami cara penghitungan hasil akhir nantinya….
Nilai hasil pembagian yang digunakan untuk menentukan octet adalah integer quotient.
Secara konsep:
remainder = ASN - (quotient × 256)
Kemudian quotient dibagi lagi dengan 256 untuk mendapatkan octet berikutnya.
6. Contoh ASN 65535
ASN yang digunakan:
ASN = 65535
Step 1
Hitung:
65535 ÷ 256
Integer quotient:
hasil_1 = 255
Kemudian:
255 × 256 = 65280
Sehingga:
65535 - 65280 = 255
Maka:
hasil_akhir = 255
Octet terakhir:
255
Step 2
Sekarang gunakan quotient sebelumnya:
hasil_1 = 255
Hitung:
255 ÷ 256 = 0
Maka:
hasil_kecil = 0
Kemudian:
0 × 256 = 0
Sehingga:
255 - 0 = 255
Maka:
hasil_final = 255
Octet berikutnya:
255
Step 3
Karena quotient sudah:
0
maka dua octet paling kiri bernilai:
0
0
Hasil lengkap:
0.0.255.255
Jadi:
ASN 65535
direpresentasikan sebagai:
0.0.255.255
7. IPv8 Address Dengan Host
Empat octet ASN kemudian digabungkan dengan empat octet host.
Format:
ASN ASN ASN ASN | HOST HOST HOST HOST
Untuk:
ASN = 65535
didapat:
0.0.255.255
Misalnya host address:
192.0.2.1
Maka IPv8 address:
0.0.255.255.192.0.2.1
Strukturnya:
0.0.255.255.192.0.2.1
|----------|-----------|
ASN HOST
8. Contoh Lain
ASN 155
155 ÷ 256 = 0Remainder:
155 - (0 × 256) = 155Hasil:
0.0.0.155ASN 256
256 ÷ 256 = 1Kemudian:
1 × 256 = 256Remainder:
256 - 256 = 0Quotient:
1Kemudian:
1 ÷ 256 = 0Remainder:
1 - (0 × 256) = 1Hasil:
0.0.1.0ASN 257
257 ÷ 256 = 1Remainder:
257 - (1 × 256) = 1Kemudian:
1 ÷ 256 = 0Hasil:
0.0.1.1ASN 15565
15565 ÷ 256 = 60Remainder:
15565 - (60 x 256) = 205Kemudian:
205 ÷ 256 = 0Hasil:
0.0.60.205 + 192.168.1.1 (host) = 0.0.60.205.192.168.1.1/56 (255.255.255.255.255.255.255.0)ASN 65535
65535 ÷ 256 = 255Remainder:
65535 - (255 × 256) = 255
Kemudian:
255 ÷ 256 = 0
Remainder:
255 - (0 × 256) = 255
Hasil:
0.0.255.255
9. Formula Umum
Secara matematis, konversi ASN ke empat octet dapat ditulis:
octet[3] = ASN % 256
octet[2] = (ASN / 256) % 256
octet[1] = (ASN / 65536) % 256
octet[0] = (ASN / 16777216) % 256
Dengan integer division.
Atau menggunakan algoritma pembagian berulang:
value = ASN
octet[3] = value % 256
value = value / 256
octet[2] = value % 256
value = value / 256
octet[1] = value % 256
value = value / 256
octet[0] = value % 256
Kedua pendekatan menghasilkan representasi yang sama.
10. Implementasi C
Representasi address internal menggunakan struktur:
struct ipv8_addr {
uint32_t asn;
uint32_t host;
};
Contoh:
struct ipv8_addr addr;
addr.asn = 65535;
addr.host = 0xC0000201;
ASN kemudian dapat dikonversi menjadi empat octet:
uint8_t asn_octets[4];
uint32_t value = addr.asn;
asn_octets[3] = value % 256;
value /= 256;
asn_octets[2] = value % 256;
value /= 256;
asn_octets[1] = value % 256;
value /= 256;
asn_octets[0] = value % 256;
Untuk:
ASN = 65535
hasilnya:
asn_octets[0] = 0
asn_octets[1] = 0
asn_octets[2] = 255
asn_octets[3] = 255
Sehingga:
0.0.255.255
11. Packed 64-bit Address
Walaupun address lebih mudah diproses sebagai:
struct ipv8_addr
address juga dapat dipacking menjadi satu nilai 64-bit.
Format:
63 32 31 0
+----------------------------+----------------------------+
| ASN | HOST |
| 32-bit | 32-bit |
+----------------------------+----------------------------+
Secara konsep:
uint64_t packed;
packed =
((uint64_t)asn << 32) |
host;
Contoh:
ASN = 65535
HOST = 192.0.2.1
Representasi ASN:
0.0.255.255
Representasi host:
192.0.2.1
IPv8:
0.0.255.255.192.0.2.1
12. Address Layout
Setiap IPv8 address terdiri dari:
8 octets
Layout:
Octet tersebut bisa dilihat dari tabel dibawah:
/8 = 1 octet
/16 = 2 octet
/24 = 3 octet
/32 = 4 octet
/40 = 5 octet
/48 = 6 octet
/56 = 7 octet
/64 = 8 octetOctet 0 Octet 1 Octet 2 Octet 3
| | | |
+---------+---------+---------+
ASN 32-bit
Octet 4 Octet 5 Octet 6 Octet 7
| | | |
+---------+---------+---------+
Host 32-bit
Contoh:
0.0.255.255.192.0.2.1
dapat dibaca:
ASN:
0.0.255.255
Host:
192.0.2.1
Misalnya kita punya prefix:
0.2.36.158.10.173.84.xKarena IPv8 = 8 octet = 64 bit, dan kalau 7 octet pertama tetap, octet ke-8 bisa:
0.2.36.158.10.173.84.1
0.2.36.158.10.173.84.2
0.2.36.158.10.173.84.3
...
0.2.36.158.10.173.84.254
0.2.36.158.10.173.84.255Itu berarti prefix-nya:
0.2.36.158.10.173.84.0/56Karena:
7 octet × 8 bit = 56 bitJadi:
0.2.36.158.10.173.84 | x
──────────────────── ─
/56 hostDan x punya 256 kemungkinan nilai:
0 → 255Kalau mengikuti pola subnet seperti IPv4 dan kita bicara usable host, biasanya orang mengecualikan .0 dan .255, sehingga:
.1 → .254Tapi secara nilai octet murni, memang:
00 → FF
0 → 255– Subnetting
IPv8 Subnetting
Subnetting adalah cara membagi sebuah jaringan menjadi bagian network dan host.
IPv8 menggunakan alamat sepanjang 64 bit.
64 bit = 8 octet
1 octet = 8 bit
Contoh alamat IPv8:
0.2.36.158.10.173.84.1
Terdiri dari:
0 2 36 158 10 173 84 1
│ │ │ │ │ │ │ │
└──────────────────── 64 bit ────────────────────────┘
Setiap octet memiliki nilai dari:
0 - 255
Apa itu /53?
Angka setelah / disebut prefix length.
Contoh:
0.2.36.158.10.173.84.1/53
Artinya 53 bit pertama digunakan sebagai network prefix.
Karena total IPv8 adalah 64 bit:
64 - 53 = 11
Maka:
53 bit = network
11 bit = host
Jumlah kombinasi host secara matematis:
2^11 = 2048
Mengapa menggunakan octet?
Satu octet selalu terdiri dari 8 bit:
8 bit = 1 octet
Karena IPv8 memiliki 64 bit:
64 / 8 = 8 octet
Kita dapat membayangkan alamat IPv8 sebagai:
[ 8 ][ 8 ][ 8 ][ 8 ][ 8 ][ 8 ][ 8 ][ 8 ]
Menghitung subnet mask
Cara paling mudah adalah membagi prefix dengan 8.
Misalnya:
/53
Hitung:
53 / 8 = 6 sisa 5
Artinya:
6 octet penuh
5 bit pada octet berikutnya
Jadi bentuk mask-nya:
255.255.255.255.255.255.??? .0
Sekarang kita perlu mencari nilai ???.
Memahami nilai setiap bit
Satu octet memiliki 8 bit.
Nilai setiap posisi selalu:
128 64 32 16 8 4 2 1
Nilai tersebut berasal dari pangkat 2:
2^7 = 128
2^6 = 64
2^5 = 32
2^4 = 16
2^3 = 8
2^2 = 4
2^1 = 2
2^0 = 1
Contoh:
11111000
Cocokkan dengan nilainya:
Binary:
1 1 1 1 1 0 0 0
│ │ │ │ │ │ │ │
128 64 32 16 8 4 2 1
Bit yang bernilai 1 dijumlahkan:
128 + 64 + 32 + 16 + 8
Hasilnya:
248
Jadi:
11111000 = 248
/53 menjadi 248
Kembali ke:
/53
Hitung:
53 / 8 = 6 sisa 5
Berarti kita membutuhkan 5 bit 1:
11111000
Nilainya:
128 + 64 + 32 + 16 + 8
= 248
Maka subnet mask /53 adalah:
255.255.255.255.255.255.248.0
Visualisasinya:
11111111.11111111.11111111.11111111.
11111111.11111111.11111000.00000000
Hitung jumlah bit 1:
8 + 8 + 8 + 8 + 8 + 8 + 5
= 53
Maka benar:
/53
Cara cepat mencari partial octet
Tidak perlu selalu menghitung binary.
Gunakan:
partial_mask = 256 - 2^(8 - remaining_bits)
Untuk /53:
53 / 8 = 6 sisa 5
Maka:
remaining_bits = 5
Kemudian:
256 - 2^(8 - 5)
256 - 2^3
256 - 8
248
Jadi:
/53
→ 6 octet penuh
→ 5 bit
→ 248
Mask:
255.255.255.255.255.255.248.0
Tabel nilai bit
Bit 1 | Binary | Nilai |
|---|---|---|
| 1 | 10000000 | 128 |
| 2 | 11000000 | 192 |
| 3 | 11100000 | 224 |
| 4 | 11110000 | 240 |
| 5 | 11111000 | 248 |
| 6 | 11111100 | 252 |
| 7 | 11111110 | 254 |
| 8 | 11111111 | 255 |
Ini adalah nilai yang sering muncul ketika membuat subnet mask.
Contoh /47
Mulai dengan:
/47
Bagi dengan 8:
47 / 8 = 5 sisa 7
Artinya:
5 octet penuh
7 bit pada octet berikutnya
7 bit 1:
11111110
Nilainya:
128 + 64 + 32 + 16 + 8 + 4 + 2
= 254
Maka:
/47
memiliki mask:
255.255.255.255.255.254.0.0
Contoh /50
50 / 8 = 6 sisa 2
2 bit:
11000000
Nilainya:
128 + 64
= 192
Mask:
255.255.255.255.255.255.192.0
Contoh /51
51 / 8 = 6 sisa 3
3 bit:
11100000
Nilainya:
128 + 64 + 32
= 224
Mask:
255.255.255.255.255.255.224.0
Contoh /52
52 / 8 = 6 sisa 4
4 bit:
11110000
Nilainya:
128 + 64 + 32 + 16
= 240
Mask:
255.255.255.255.255.255.240.0
Contoh /53
53 / 8 = 6 sisa 5
5 bit:
11111000
Nilainya:
128 + 64 + 32 + 16 + 8
= 248
Mask:
255.255.255.255.255.255.248.0
Contoh /54
54 / 8 = 6 sisa 6
6 bit:
11111100
Nilainya:
128 + 64 + 32 + 16 + 8 + 4
= 252
Mask:
255.255.255.255.255.255.252.0
Contoh /55
55 / 8 = 6 sisa 7
7 bit:
11111110
Nilainya:
128 + 64 + 32 + 16 + 8 + 4 + 2
= 254
Mask:
255.255.255.255.255.255.254.0
Contoh /56
/56 tepat berada di batas octet.
56 / 8 = 7 sisa 0
Tidak ada partial octet.
Maka:
255.255.255.255.255.255.255.0
Contoh /59
59 / 8 = 7 sisa 3
3 bit:
11100000
Nilai:
128 + 64 + 32
= 224
Mask:
255.255.255.255.255.255.255.224
Contoh /63
63 / 8 = 7 sisa 7
7 bit:
11111110
Nilai:
254
Mask:
255.255.255.255.255.255.255.254
Host bit:
64 - 63 = 1
Secara matematis terdapat:
2^1 = 2
kombinasi nilai host.
Prefix yang berada tepat di batas octet
Kalau prefix habis dibagi 8, tidak ada partial octet.
/8
/16
/24
/32
/40
/48
/56
/64
Contoh:
/48
48 / 8 = 6 sisa 0
Mask:
255.255.255.255.255.255.0.0
Ringkasan /47 sampai /56
/47 → 255.255.255.255.255.254.0.0
/48 → 255.255.255.255.255.255.0.0
/49 → 255.255.255.255.255.255.128.0
/50 → 255.255.255.255.255.255.192.0
/51 → 255.255.255.255.255.255.224.0
/52 → 255.255.255.255.255.255.240.0
/53 → 255.255.255.255.255.255.248.0
/54 → 255.255.255.255.255.255.252.0
/55 → 255.255.255.255.255.255.254.0
/56 → 255.255.255.255.255.255.255.0
Menghitung jumlah host
Karena IPv8 memiliki 64 bit:
host_bits = 64 - prefix
Jumlah kombinasi alamat host:
addresses = 2^host_bits
Contoh /53:
64 - 53 = 11
2^11 = 2048
Contoh /56:
64 - 56 = 8
2^8 = 256
Contoh /60:
64 - 60 = 4
2^4 = 16
Contoh /63:
64 - 63 = 1
2^1 = 2
Cara mengingat subnetting IPv8
Tidak perlu menghafal semuanya.
Cukup ingat:
1 octet = 8 bit
Kemudian:
prefix / 8 → jumlah octet penuh
prefix % 8 → sisa bit
Contoh:
53 / 8 = 6 sisa 5
Berarti:
6 × 255
+
5 bit
5 bit:
11111000
Nilainya:
128 + 64 + 32 + 16 + 8
= 248
Hasil:
255.255.255.255.255.255.248.0
Rumus untuk implementasi C
Perhitungan subnet dapat langsung diterapkan ke program.
int full_octets = prefix / 8;
int remaining_bits = prefix % 8;
Kemudian isi octet penuh dengan 255:
for (int i = 0; i < full_octets; i++)
mask[i] = 255;
Jika masih ada bit tersisa:
if (remaining_bits != 0)
mask[full_octets] =
256 - (1 << (8 - remaining_bits));
Untuk /53:
prefix = 53
full_octets = 53 / 8 = 6
remaining_bits = 53 % 8 = 5
Kemudian:
mask[0] = 255
mask[1] = 255
mask[2] = 255
mask[3] = 255
mask[4] = 255
mask[5] = 255
mask[6] = 248
mask[7] = 0
Hasil:
255.255.255.255.255.255.248.0
Cheat Sheet
IPv8
│
├── 64 bit
│
├── 8 octet
│
├── 1 octet = 8 bit
│
├── prefix / 8
│ └── full octet
│
├── prefix % 8
│ └── remaining bit
│
├── host bits
│ └── 64 - prefix
│
└── jumlah alamat
└── 2^(64 - prefix)
Untuk partial octet:
1 bit → 128
2 bit → 192
3 bit → 224
4 bit → 240
5 bit → 248
6 bit → 252
7 bit → 254
8 bit → 255
Dan nilai bit satu octet selalu:
128 64 32 16 8 4 2 1
Jadi kalau ketemu:
11111000
tinggal:
128 + 64 + 32 + 16 + 8
= 248
Itulah dasar subnetting IPv8.
13. Address Parsing
Program harus dapat menerima address dalam format:
ASN.HOST
Contoh:
65535.192.0.2.1
dan mengubahnya menjadi:
ASN:
65535
Host:
192.0.2.1
Kemudian representation internal:
struct ipv8_addr {
uint32_t asn;
uint32_t host;
};
14. Address Formatting
Program juga harus dapat melakukan reverse conversion.
Input:
asn = 65535
host = 192.0.2.1
Output:
0.0.255.255.192.0.2.1
Formatting harus memastikan setiap nilai octet berada dalam range:
0 - 255
15. Host Address
Host address menggunakan 32-bit.
Karena terdiri dari empat octet:
XX.XX.XX.XX
maka jumlah kemungkinan host address adalah:
2^32
atau:
4,294,967,296
nilai.
Contoh:
10.173.84.1
digabung dengan ASN:
65535
menjadi:
0.0.255.255.10.173.84.1
16. Contoh Network
Misalnya digunakan:
IPv8 Network:
0.0.255.255.10.173.84.0/56
Router:
0.0.255.255.10.173.84.1
Host A:
0.0.255.255.10.173.84.2
Host B:
0.0.255.255.10.173.84.3
Secara konsep:
IPv8 Router
|
|
0.0.255.255.10.173.84.1
|
+-------------+-------------+
| |
| |
Host A Host B
| |
...84.2/56 ...84.3/56
17. Gateway
Gateway bukan bagian tambahan dari IPv8 address.
Gateway merupakan address IPv8 milik router yang digunakan sebagai next-hop.
Contoh:
Host A:
Address:
0.0.255.255.10.173.84.2/56
Gateway:
0.0.255.255.10.173.84.1
Jika destination masih berada dalam prefix lokal, host dapat mengirim secara langsung sesuai mekanisme link-layer yang digunakan.
Jika destination berada di luar prefix lokal, packet dikirim menuju router/gateway.
18. Routing Concept
Routing IPv8 akan dipisahkan secara konseptual menjadi:
Routing Domain
|
v
ASN / Routing Prefix
|
v
Host Address
Router pertama menentukan routing domain tujuan berdasarkan bagian routing/ASN.
Setelah packet mencapai routing domain yang sesuai, host address digunakan untuk menentukan destination host.
Contoh:
Source:
0.0.255.255.10.173.84.2
Destination:
0.1.100.10.10.20.30.40
Router dapat melihat bagian:
Destination ASN:
0.1.100.10
dan bagian host:
10.20.30.40
19. Routing Table
Implementasi routing nantinya akan menyediakan tabel seperti:
Prefix Next-Hop
0.0.255.255.10.173.84.0/56 connected
0.1.100.10.0.0.0.0/32 ...
0.2.36.158.0.0.0.0/32 ...
0.0.0.0.0.0.0.0/0 ...
Format default route dan detail routing akan mengikuti semantics yang ditentukan oleh spesifikasi IPv8 yang sedang diimplementasikan.
Jangan mengasumsikan aturan IPv4 atau IPv6 jika aturan tersebut tidak didefinisikan oleh spesifikasi IPv8.
20. CIDR
IPv8 menggunakan address 64-bit.
Maka prefix dapat berada pada range:
/0
-
/64
Contoh:
/8
berarti:
8 bit fixed
56 bit host
/16
berarti:
16 bit fixed
48 bit host
/24
berarti:
24 bit fixed
40 bit host
/32
berarti:
32 bit fixed
32 bit host
/48
berarti:
48 bit fixed
16 bit host
/56
berarti:
56 bit fixed
8 bit host
/64
berarti:
64 bit fixed
0 bit host
Implementasi prefix matching harus dilakukan berdasarkan bit address sebenarnya, bukan sekadar membandingkan string.
21. Address Comparison
IPv8 address harus dapat dibandingkan secara binary.
Contoh:
A:
0.0.255.255.10.173.84.1
B:
0.0.255.255.10.173.84.2
Bagian ASN sama:
0.0.255.255
Host berbeda:
10.173.84.1
10.173.84.2
Secara internal:
addr_a.asn == addr_b.asn
dan:
addr_a.host != addr_b.host
22. Prefix Matching
Untuk prefix:
0.0.255.255.10.173.84.0/56
address:
0.0.255.255.10.173.84.1
match.
Address:
0.0.255.255.10.173.84.100
juga match.
Sedangkan address dengan bit prefix berbeda tidak match.
Implementasi prefix matching akan menggunakan:
uint64_t address;
uint64_t prefix;
uint8_t prefix_len;
dengan mask yang sesuai.
23. Packet Architecture
Setelah address layer selesai, project akan dilanjutkan ke packet layer.
Target arsitektur:
Application
|
v
ICMPv8
|
v
IPv8 Packet
|
v
Ethernet
|
v
Linux AF_PACKET
|
v
NIC
Packet akan diproses melalui:
Receive
|
v
Ethernet validation
|
v
IPv8 header validation
|
v
Checksum validation
|
v
Destination check
|
v
Routing lookup
|
v
Forward / Local delivery
24. Linux Transport
Implementasi awal dilakukan di userspace Linux.
Transport layer akan menggunakan:
AF_PACKET
sehingga program dapat mengirim dan menerima Ethernet frame secara langsung.
Target awal:
Linux Namespace A
|
veth
|
Linux Namespace B
Kedua namespace akan digunakan untuk testing packet IPv8 secara langsung.
25. Initial Test Topology
Target topology:
+-------------------+
| namespace: host1 |
| |
| IPv8 |
| 0.0.255.255...1 |
+---------+---------+
|
veth
|
+---------+---------+
| namespace: host2 |
| |
| IPv8 |
| 0.0.255.255...2 |
+-------------------+
Target pertama bukan internet connectivity.
Target pertama adalah:
IPv8 packet
|
v
host1
|
v
Ethernet
|
v
veth
|
v
host2
dan packet dapat divalidasi secara binary.
26. ICMPv8
Setelah IPv8 packet berhasil dikirim, layer berikutnya adalah ICMPv8.
Target utility:
ping8
Contoh:
ping8 0.0.255.255.10.173.84.2
Expected flow:
ping8
|
v
ICMPv8 Echo Request
|
v
IPv8
|
v
Ethernet
|
v
Network
|
v
ICMPv8 Echo Reply
27. CLI
Utility utama yang direncanakan:
ip8
ping8
traceroute8
Contoh:
ip8 addr
ip8 route
ip8 route add ...
ping8 0.0.255.255.10.173.84.2
traceroute8 0.1.100.10.10.20.30.40
28. Source Tree
Struktur project:
ipv8/
├── Makefile
├── README.md
├── LICENSE
│
├── include/
│ ├── ipv8.h
│ ├── ipv8_addr.h
│ ├── ipv8_packet.h
│ └── ipv8_checksum.h
│
├── src/
│ ├── main.c
│ ├── addr.c
│ ├── packet.c
│ ├── checksum.c
│ └── ethernet.c
│
├── tools/
│ ├── ip8.c
│ ├── ping8.c
│ └── traceroute8.c
│
└── tests/
├── test_addr.c
├── test_packet.c
└── test_checksum.c
29. Address API
Target API:
typedef struct {
uint32_t asn;
uint32_t host;
} ipv8_addr_t;
Parser:
int ipv8_addr_parse(
const char *str,
ipv8_addr_t *addr
);
Formatter:
int ipv8_addr_format(
const ipv8_addr_t *addr,
char *buf,
size_t len
);
Pack:
uint64_t ipv8_addr_pack(
const ipv8_addr_t *addr
);
Unpack:
void ipv8_addr_unpack(
uint64_t value,
ipv8_addr_t *addr
);
30. Address Validation
Setiap address harus divalidasi sebelum digunakan.
Validasi meliputi:
ASN range
Host range
Octet range
String format
Prefix length
Packed representation
ASN:
0 <= ASN <= 4294967295
Host:
0 <= HOST <= 4294967295
Setiap octet:
0 <= octet <= 255
31. ASN Calculation Test
Minimal test case:
ASN IPv8 ASN representation
0 0.0.0.0
1 0.0.0.1
255 0.0.0.255
256 0.0.1.0
257 0.0.1.1
65535 0.0.255.255
65536 0.1.0.0
Test wajib memastikan:
ASN
↓
4 octets
↓
ASN
menghasilkan nilai awal yang sama.
Contoh:
65535
↓
0.0.255.255
↓
65535
32. Important Implementation Rule
Perhitungan ASN tidak boleh menggunakan floating-point untuk menentukan octet.
Gunakan:
uint32_t
dan integer division.
Contoh:
uint32_t value = asn;
octet[3] = value % 256;
value /= 256;
octet[2] = value % 256;
value /= 256;
octet[1] = value % 256;
value /= 256;
octet[0] = value % 256;
Alasannya sederhana:
ASN adalah integer.
Octet juga integer.
Tidak diperlukan:
float
double
untuk address conversion.
33. Endianness
Karena IPv8 memiliki representasi 64-bit, implementasi harus memperhatikan byte order.
Internal representation:
struct ipv8_addr
digunakan agar operasi address lebih mudah.
Packed representation:
uint64_t
digunakan untuk kebutuhan binary/wire representation.
Konversi byte order harus eksplisit.
Jangan mengandalkan:
CPU endian
sebagai wire format.
34. Design Philosophy
Project ini tidak bertujuan membuat:
IPv4 dengan nama berbeda
atau:
IPv6 dengan address lebih panjang
Tujuannya adalah memahami dan mengimplementasikan konsep IPv8 berdasarkan specification yang tersedia.
Setiap fitur harus mempunyai dasar dari:
IPv8 Internet-Draft
Jika specification tidak menjelaskan sesuatu secara eksplisit:
Jangan mengarang behavior.
Catat sebagai:
TODOatau:
IMPLEMENTATION NOTE
dan pisahkan antara:
Specification
dengan:
Implementation decision
35. Development Roadmap
Phase 1 — Address
[ ] ASN parser
[ ] ASN → octet conversion
[ ] Host parser
[ ] IPv8 address parser
[ ] IPv8 formatter
[ ] Address packing
[ ] Address unpacking
[ ] Address validation
[ ] Unit tests
Phase 2 — Prefix
[ ] Prefix parser
[ ] Prefix validation
[ ] Prefix mask
[ ] Prefix matching
[ ] Longest prefix matching
Phase 3 — Packet
[ ] IPv8 header
[ ] Header parser
[ ] Header serializer
[ ] Checksum
[ ] Packet validation
Phase 4 — Ethernet
[ ] AF_PACKET socket
[ ] Ethernet frame TX
[ ] Ethernet frame RX
[ ] IPv8 EtherType handling
[ ] Packet filtering
Phase 5 — ICMPv8
[ ] Echo Request
[ ] Echo Reply
[ ] Error handling
[ ] ping8
Phase 6 — Routing
[ ] Routing table
[ ] Connected routes
[ ] Static routes
[ ] Next-hop
[ ] Longest-prefix matching
[ ] Forwarding
[ ] TTL / hop handling
Phase 7 — Routing Protocols [Draft]
Future work:
[ ] OSPF8
[ ] iBGP8
[ ] eBGP8
Phase 8 — Network Services [Draft]
Future work may include:
[ ] ARP8
[ ] DHCP8
[ ] DNS A8
[ ] WHOIS8
[ ] XLATE8
[ ] NetLog8
[ ] Zone Server
Implementasi setiap fitur harus terlebih dahulu dibandingkan dengan specification.
36. Testing Philosophy
Testing dilakukan dari layer paling bawah.
Urutan:
Physical / virtual interface
↓
Ethernet
↓
IPv8 address
↓
IPv8 header
↓
Checksum
↓
Packet
↓
ICMPv8
↓
Routing
↓
Application
Jangan langsung debugging application layer jika packet bahkan belum benar pada Ethernet atau IPv8 layer.
37. Debugging
Tools yang akan digunakan:
tcpdump
Wireshark
iproute2
ip netns
ethtool
strace
gdb
Contoh:
ip netns list
ip link
tcpdump -i veth0 -nn -XX
Tujuan debugging adalah melihat packet secara binary.
Contoh:
Ethernet Header
↓
IPv8 Header
↓
Payload
38. Security
Implementasi packet parser harus menganggap seluruh network input sebagai untrusted input.
Parser wajib melakukan:
length validation
bounds checking
integer overflow checking
header validation
checksum validation
destination validation
Jangan melakukan parsing seperti:
strcpy()
sprintf()
tanpa batas ukuran.
Gunakan fungsi yang memiliki size boundary.
39. Coding Rules
Project menggunakan:
C
Prioritas:
simple
explicit
portable
readable
low-level
Hindari abstraction berlebihan.
Address layer harus mudah dibaca.
Contoh:
typedef struct {
uint32_t asn;
uint32_t host;
} ipv8_addr_t;
lebih diutamakan daripada menyimpan semuanya sebagai string.
String hanya digunakan pada:
input
output
CLI
logging
Binary operation menggunakan:
uint32_t
uint64_t
uint8_t
40. ASN 65535 Reference
ASN testing utama:
65535
Perhitungan:
65535 ÷ 256 = 255
255 × 256 = 65280
65535 - 65280 = 255
Kemudian:
255 ÷ 256 = 0
0 × 256 = 0
255 - 0 = 255
Dua octet tersisa:
0
0
Maka:
ASN 65535
↓
0.0.255.255
Dengan host:
10.173.84.1
maka:
0.0.255.255.10.173.84.1
41. Reference Example
Input:
ASN:
65535
HOST:
10.173.84.1
Output:
IPv8:
0.0.255.255.10.173.84.1
Binary layout:
ASN:
0 0 255 255
00000000 00000000 11111111 11111111
HOST:
10 173 84 1
00001010 10101101 01010100 00000001
Total:
64 bit
42. Current Primary Goal
Milestone pertama project:
ASN
↓
IPv8 Address
↓
Binary Representation
↓
Ethernet Frame
↓
Linux veth
↓
IPv8 Packet Received
Setelah tahap tersebut berhasil:
IPv8 Ping
menjadi target berikutnya.
43. Specification First
Referensi utama:
Dokumentasi project ini tidak boleh dianggap menggantikan specification.
Jika terdapat perbedaan antara:
README
dan:
IETF Draft
maka specification harus diperiksa kembali sebelum implementation decision dibuat.
License
License project dimiliki oleh IETF
Author
Ryan Achmad Juliansyah
Network Engineer / Security Engineer / Linux Enthusiast
Project:
IPv8 From Scratch
Implementasi ini bertujuan eksperimental IPv8 menggunakan C dengan bantuan AI dan pengetahuan diri sendiri untuk mengimplementasikan draft yang terlah dikeluarkan sejak april 2026.
I’m Ryan, a Network Engineer from Indonesia focused on network infrastructure, Server Management, and system administration, with a background in network security and cybersecurity. I enjoy building, troubleshooting, and understanding complex systems from the ground up.
