Deep Packet Inspection

Dalam menjamin keamanan paket data yang dikirimkan menggunakan jaringan internet berbagai usaha untuk melakukan penyaringan paket telah dilakukan. Untuk beberapa metode konvensional tersebut, router Internet membaca label pada paket tersebut untuk menentukan apa yang mereka, yang dari mereka, dan kemana mereka seharusnya pergi. Namun, seringkali terdapat paket data yang berisi konten yang berbahaya lolos dari policy metode-metode konvensional ini.
Untuk mencegah lebih banyak paket data yang tidak baik masuk digunakan sebuah metode bernama deep packet inspection. Metode ini merupakan metode penyaringan paket yang berfungsi pada Application layer pada pemodelan TCP/IP. Kegunaannya adalah untuk memungkinkan pencarian, pengidentifikasian, klasifikasi, routing ulang, dan pengeblokan dari paket-paket yang lolos tahap penyaringan konvensional.

Diluar keuntungan yang didapatkan dalam menggunakan DPI, terdapat beberapa batasan yang disebabkan penggunaan DPI tersebut:
1. Penjaminan keamanan terhadap beberapa jenis paket berbahaya, namun juga dapat dieksploitasi untuk memfasilitasi penyebaran paket berbahaya tersebut.
2. Peningkatan kompleksitas lingkungan firewall dan aplikasi keamanan lainnya, disebabkan kebutuhan DPI untuk melakukan pembaharuan secara berkala.
3. Penggunaan DPI membebani processor komputer sehingga melambatkan kerja komputer.

Referensi:
http://searchnetworking.techtarget.com/definition/deep-packet-inspection-DPI
http://www.yac.mx/id/pc-tech-tips/internet/What_Is_Deep_Packet_Inspection.html

Server-Client Vs. Peer to Peer

Pada dasarnya terdapat dua macam struktur komunikasi antar mesin dalam Local Area Network (LAN).

Server-Client Network

Pada jaringan ini, baik client maupun server memiliki perannya masing-masing. Server berperan untuk membagikan file-file dan resource yang dimilikinya pada komputer client melalui suatu jaringan. Server biasanya diletakkan pada sebuah lokasi yang aman dalam bentuk storage locker atau data center. Komputer client pada umumnya hanya berinteraksi dengan server, tidak dengan client lain. Sistem client adalah sebuah PC standar yang menjalankan operating system seperti Windows. Melalui tempat kerja client, pengguna dapat mengakses sebagian besar file yang disimpan dalam server. Server akan menentukan file mana yang dapat diakses pengguna melalui jaringan.

 

 

 

 

 

Peer to Peer

Jaringan Peer-to-Peer memiliki konsep untuk saling berbagi file dan printer dengan biaya sekecil mungkin. Jaringan ini tidak memiliki server utama dan tiap client memiliki fungsi sebagai client dan juga sebagai server. Tidak ada keamanan pusat yang dapat mengontrol file yang dibagikan. Pengguna bebas menggunakan kewenangan untuk membagi file mereka.
(http://www.techrepublic.com/article/understanding-the-differences-between-client-server-and-peer-to-peer-networks/)













(http://withfriendship.com/images/b/8494/Peer-to-peer-picture.jpg)

Berikut tabel perbandingan kedua jaringan:

(http://www.buzzle.com/articles/peer-to-peer-vs-client-server-networks.html)

Source Code Socket Programming

Berikut contoh source code dari socket programming yang diimplementasikan dalam beberapa bahasa:

1. C
Model server-client dapat diimplementasikan menggunakan 2 source code, souce code untuk server dan client.

Server Source Code:
#include<stdio.h>
#include<netinet/in.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netdb.h>
#include<stdlib.h>
#include<string.h>
#define MAX 80
#define PORT 43454
#define SA struct sockaddr
void func(int sockfd)
{
char buff[MAX];
int n;
for(;;)
{
bzero(buff,MAX);
read(sockfd,buff,sizeof(buff));
printf("From client: %s\t To client : ",buff);
bzero(buff,MAX);
n=0;
while((buff[n++]=getchar())!='\n');
write(sockfd,buff,sizeof(buff));
if(strncmp("exit",buff,4)==0)
{
printf("Server Exit...\n");
break;
}
}
}
int main()
{
int sockfd,connfd,len;
struct sockaddr_in servaddr,cli;
sockfd=socket(AF_INET,SOCK_STREAM,0);
if(sockfd==-1)
{
printf("socket creation failed...\n");
exit(0);
}
else
printf("Socket successfully created..\n");
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family=AF_INET;
servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
servaddr.sin_port=htons(PORT);
if((bind(sockfd,(SA*)&servaddr, sizeof(servaddr)))!=0)
{
printf("socket bind failed...\n");
exit(0);
}
else
printf("Socket successfully binded..\n");
if((listen(sockfd,5))!=0)
{
printf("Listen failed...\n");
exit(0);
}
else
printf("Server listening..\n");
len=sizeof(cli);
connfd=accept(sockfd,(SA *)&cli,&len);
if(connfd<0)
{
printf("server acccept failed...\n");
exit(0);
}
else
printf("server acccept the client...\n");
func(connfd);
close(sockfd);
}

Client Source Code:
#include<stdio.h>
#include<netinet/in.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netdb.h>
#include<string.h>
#include<stdlib.h>
#define MAX 80
#define PORT 43454
#define SA struct sockaddr
void func(int sockfd)
{
char buff[MAX];
int n;
for(;;)
{
bzero(buff,sizeof(buff));
printf("Enter the string : ");
n=0;
while((buff[n++]=getchar())!='\n');
write(sockfd,buff,sizeof(buff));
bzero(buff,sizeof(buff));
read(sockfd,buff,sizeof(buff));
printf("From Server : %s",buff);
if((strncmp(buff,"exit",4))==0)
{
printf("Client Exit...\n");
break;
}
}
}

int main()
{
int sockfd,connfd;
struct sockaddr_in servaddr,cli;
sockfd=socket(AF_INET,SOCK_STREAM,0);
if(sockfd==-1)
{
printf("socket creation failed...\n");
exit(0);
}
else
printf("Socket successfully created..\n");
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family=AF_INET;
servaddr.sin_addr.s_addr=inet_addr("127.0.0.1");
servaddr.sin_port=htons(PORT);
if(connect(sockfd,(SA *)&servaddr,sizeof(servaddr))!=0)
{
printf("connection with the server failed...\n");
exit(0);
}
else
printf("connected to the server..\n");
func(sockfd);
close(sockfd);
}

Setelah melakukan compile kedua source code pada terminal yang berbeda maka akan dibuat sebuah socket sehingga terminal server dan terminal client menjadi terhubung. Berikut tampilan pada kedua terminal ketika dua program dijalankan:

Program client akan meminta masukkan string, ketika dienter string akan dikirim ke terminal server, server juga dapat mengirimkan pesan untuk terminal client. Hal ini membukitkan bahwa kedua terminal terhubung.
(http://mcalabprogram.blogspot.com/2012/01/tcp-sockets-chat-applicationserver.html)

2. Java

Server Source Code:
 // File Name GreetingServer.java
import java.net.*;
import java.io.*;

public class GreetingServer extends Thread
{
   private ServerSocket serverSocket;
   public GreetingServer(int port) throws IOException
   {
      serverSocket = new ServerSocket(port);
      serverSocket.setSoTimeout(99999);
   }
   public void run()
   {
      while(true)
      {
         try
         {
            System.out.println("Waiting for client on port " + serverSocket.getLocalPort() + "...");
            Socket server = serverSocket.accept();
            System.out.println("Just connected to "+ server.getRemoteSocketAddress());
            DataInputStream in = new DataInputStream(server.getInputStream());
            System.out.println(in.readUTF());
            DataOutputStream out = new DataOutputStream(server.getOutputStream());
            out.writeUTF("Thank you for connecting to " + server.getLocalSocketAddress() + "\nGoodbye!");
            server.close();
         }catch(SocketTimeoutException s)
         {
            System.out.println("Socket timed out!");
            break;
         }catch(IOException e)
         {
            e.printStackTrace();
            break;
         }
      }
   }
   public static void main(String [] args)
   {
      int port = Integer.parseInt(args[0]);
      try
      {
         Thread t = new GreetingServer(port);
         t.start();
      }catch(IOException e)
      {
         e.printStackTrace();
      }
   }
}

Client Source Code:
 // File Name GreetingClient.java

import java.net.*;
import java.io.*;

public class GreetingClient
{
   public static void main(String [] args)
   {
      String serverName = args[0];
      int port = Integer.parseInt(args[1]);
      try
      {
         System.out.println("Connecting to " + serverName + " on port " + port);
         Socket client = new Socket(serverName, port);
         System.out.println("Just connected to " + client.getRemoteSocketAddress());
         OutputStream outToServer = client.getOutputStream();
         DataOutputStream out = new DataOutputStream(outToServer);
         out.writeUTF("Hello from " + client.getLocalSocketAddress());
         InputStream inFromServer = client.getInputStream();
         DataInputStream in = new DataInputStream(inFromServer);
         System.out.println("Server says " + in.readUTF());
         client.close();
      }catch(IOException e)
      {
         e.printStackTrace();
      }
   }
}

Jalankan kedua program kembali pada terminal yang berbeda, maka akan muncul tampilan seperti berikut:

Dengan memasukkan command : java GreetingServer <port yang ingin digunakan> pada terminal pertama, program akan membuat socket pada port yang telah dimasukkan pengguna.
Pada terminal kedua, masukkan command java GreetingClient localhost <port yang dimasukkan pada terminal server>.
Terminal Client akan meminta pada server untuk memberikan sambungan. Setelah disambungkan, baik client maupun server akan diberi pesan bahwa koneksi telah terhubung sebelumnya.
(http://www.tutorialspoint.com/java/java_networking.htm)

3. Python

Source Code Server:

#!/usr/bin/env python

# server.py

import socket

import select

import config as cfg

import Queue

from threading import Thread

from time import sleep

from random import randint

import sys

class ProcessThread(Thread):

    def __init__(self):

        super(ProcessThread, self).__init__()

        self.running = True

        self.q = Queue.Queue()

    def add(self, data):

        self.q.put(data)

    def stop(self):

        self.running = False

    def run(self):

        q = self.q

        while self.running:

            try:

                # block for 1 second only:

                value = q.get(block=True, timeout=1)

                process(value)

            except Queue.Empty:

                sys.stdout.write('.')

                sys.stdout.flush()

        #

        if not q.empty():

            print "Elements left in the queue:"

            while not q.empty():

                print q.get()

t = ProcessThread()

t.start()

def process(value):

    """

    Implement this. Do something useful with the received data.

    """

    print value

    sleep(randint(1,9))    # emulating processing time

def main():

    s = socket.socket()         # Create a socket object

    host = socket.gethostname() # Get local machine name

    port = cfg.PORT                # Reserve a port for your service.

    s.bind((host, port))        # Bind to the port

    print "Listening on port {p}...".format(p=port)

    s.listen(5)                 # Now wait for client connection.

    while True:

        try:

            client, addr = s.accept()

            ready = select.select([client,],[], [],2)

            if ready[0]:

                data = client.recv(4096)

                #print data

                t.add(data)

        except KeyboardInterrupt:

            print

            print "Stop."

            break

        except socket.error, msg:

            print "Socket error! %s" % msg

            break

    #

    cleanup()

def cleanup():

    t.stop()

    t.join()

#########################################################

if __name__ == "__main__":

    main()

Source Code Client:

#!/usr/bin/env python

# client.py

import config as cfg

import sys

import socket

def main(elems):

    try:

        for e in elems:

            client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

            host = socket.gethostname()

            client.connect((host, cfg.PORT))

            clientfff.send(e)

            client.shutdown(socket.SHUT_RDWR)

            client.close()

    except Exception as msg:

        print msg

#########################################################

if __name__ == "__main__":

    main(sys.argv[1:])

Siapkan satu file lagi yang akan digunakan untuk mengkonfigurasi port. File tersebut mengandung source code sbb:

# config.py
PORT=3030




Letakkan file tersebut pada directory yang sama dengan server.py. Lakukan compile pada file server.py pada terminal maka akan muncul tampilan sebagai berikut:

Tampilan diatas menunjukkan bahwa server sedang menunggu pesan yang akan dikirimkan client.

Langkah selanjutnya adalah mengcompile file client.py pada terminal lain menggunakan command : python client.py <pesan yang ingin dikirimkan>. Program client.py akan tersambung dengan server lalu mengirimkan pesannya. Berikut tampilan eksekusinya:

(http://pythonadventures.wordpress.com/2013/07/06/a-basic-socket-client-server-example/)

Socket Programming

Socket

Socket adalah suatu teknologi computer networking yang memperkenankan aplikasi untuk saling berkomunikasi menggunakan mekanisme standar yang diterapkan dalam network hardware dan operating system. Aplikasi software  yang bergantung pada internet dan jaringan komputer lainnya, seperti web browser dan instant messaging, bergantung pada socket.

Dewasa ini, socket biasa digunakan untuk berhubungan dengan protokol internet (internet protocol, transmission control protocol, dan user datagram protocol). Untuk dapat berkomunikasi melalui internet, IP socket libraries menggunakan alamat IP untuk mengidentifikasi suatu komputer tertentu. (http://compnetworking.about.com/od/itinformationtechnology/l/aa083100a.html)

Socket terdiri dari elemen-elemen utama sebagai berikut:

1. Protokol.

2. Local IP.

3. Local Port.

4. Remote IP. 

5. Remote Port.

Contoh komunikasi sederhana adalah komunikasi antara komputer A dan komputer B. Baik komputer A maupun komputer B harus memiliki identitas unik, yang direpresentasikan oleh IP masing-masing. Komunikasi yang terjadi melalui port, sehingga baik komputer A maupun komputer B harus memiliki port yang dapat diakses satu sama lain.

Salah satu elemen penting yang digunakan dalam aplikasi socket adalah port. Port merupakan sebuah koneksi data virtual yang digunakan aplikasi untuk bertukar data secara langsung. 

 

TCP dan UDP 

Pemrograman socket adalah cara untuk menggunakan komponen/API (Application Programming Interface) socket untuk membuat sebuah aplikasi.

Aplikasi socket umumnya terdiri dari dua kategori berdasarkan pengiriman datanya, yaitu:

1. Datagram socket (menggunakan UDP).

2. Stream socket (menggunakan TCP). 

TCP dapat dijelaskan melalui gambar dibawah:

(http://49012020handi.wordpress.com/2012/04/19/pengertian-socket-programming/)

UDP tidak memerlukan proses koneksi terlebih dahulu untuk dapat mengirimkan data, paket-paket data yang dikirimkan UDP bisa jadi melalui rute yang berbeda-beda, sehingga hasil yang diterima bisa jadi tidak berurutan. Datagram socket memprioritaskan pengumpulan data.

 (http://edwincool07.blogspot.com/2012/03/pemrograman-socket.html)

Secure Shell

Secure Shell atau SSH adalah protokol jaringan yang banyak digunakan pada sistem berbasis Linux dan Unix. SSH memungkinkan pertukaran data melalui saluran yang aman antara dua perangkat jaringan. Enkripsi yang digunakan SSH menyediakan kerahasiaan dan integritas data melalui jaringan yang tidak aman seperti internet.
Jika diibaratkan pada dunia nyata, menggunakan internet dengan SSH adalah seperti halnya mengendarai mobil di terowongan pribadi dengan kecepatan tinggi, selain cepat perjalanan kita akan aman karena tidak ada kendaraan lain.
Kita tidak merugikan operator seluler manapun karena kita tidak memakai bandwidth dari operator, tapi koneksi internet yang dipakai berasal dari server SSH.
(http://id.wikipedia.org/wiki/SSH, http://mblembetozvpn.blogspot.com/2013/10/mengapa-ssh-cepat.html)

Untuk memasang protokol jaringan SSH pada linux dapat menggunakan aplikasi OpenSSH yang disediakan oleh Ubuntu's Advanced Packaging Tool (apt-get) dengan mengetikkan apt-get install openssh-server openssh-client setelah masuk dalam terminal sebagai root.
Sistem kemudian akan mengidentifikasi aplikasi-aplikasi yang dianggap sesuai. Sistem akan meminta masukkan user untuk menyetujui untuk melanjutkan instalasi, setelah kita menyetujui instalasi akan diselesaikan secara otomatis.

Sistem Meminta Konfirmasi user untuk melanjutkan Instalasi.

Proses instalasi OpenSSH yang telah selesai.

Secure Socket Layer dan Aplikasi OpenSSL

SSL atau secure socket layer adalah protokol yang digunakan untuk keamanan, teknologi ini membangun suatu tautan enkripsi antara server dan client sehingga tidak bisa dibaca oleh pihak lain. Fungsinya adalah untuk menjaga keamanan informasi yang tersebar dalam internet. (http://www.digicert.com/ssl.html)

Pada sistem operasi berbasis Linux terdapat aplikasi opensource bernama openSLL yang mengembangkan SSL dan TLS (Transport Layer Security). Aplikasi ini melakukan fungsi kriptografi dasar yang menyediakan berbagai kegunaan, diantaranya:

1. Penciptaan RSA, DH dan DSA parameter kunci
2. Penciptaan sertifikat X.509, CSRs dan CRLs
3. Perhitungan Pesan Digests
4. Enkripsi dan Dekripsi dengan Ciphers
5. Pengujian SSL / TLS Client dan Server
6. Penanganan S/MIME signed or encrypted mail

(http://en.wikipedia.org/wiki/OpenSSL, http://littlebro-note.blogspot.com/2009/08/tentang-openssl.html)

Memasang perangkat OpenSSL pada Linux (ubuntu) dapat menggunakan perintah apt-get install.
Pada langkah awal, pastikan komputer terhubung dengan jaringan komputer. Kemudian masuklah sebagai root pada terminal dengan perintah sudo su. Untuk memulai mengunduh aplikasi dan memulai instalasi gunakan perintah apt-get install openssl openssl-devel mod_ssl. Berikut tampilan setelah instalasi selesai dilakukan :

Langkah berikutnya adalah menyalakan ulang XAMPP dengan perintah opt/lampp/lampp restart agar web server yang sudah diupdate dengan openSSL dapat bekerja dengan semestinya.

Tampilan setelah selesai me-restart XAMPP.

Setting Jaringan Komputer Pada Linux

Dalam jaringan komputer dikenali beberapa istilah seperti IP address, subnet mask, gateway, dan DNS server address. Masing-masing memiliki peran-perannya sendiri.
IP Address berperan untuk mengidentifikasi host jaringan dan sebagai alamat lokasi jaringan (http://fadhilgalery.blogspot.com/2011/11/mari-mengenal-pengertian-dan-fungsi-ip.html)
Subnet Mask berperan untuk membedakan antara network ID dengan Host ID dan untuk menentukan alamat tujuan data. (http://como-ank3rs.blogspot.com/2008/12/fungsi-subnet-mask.html)
Gateway berperan untuk menghubungan satu jaringan komputer dengan lainnya menggunakan protokol komunikasi yang berbeda sehingga informasi dari satu jaringan komputer dapat diberikan kepada jaringan komputer lain dengan protokol yang berbeda. (http://yunibrave.wordpress.com/2011/07/20/fungsi-gateway/)
Alamat DNS server berperan untuk melakukan pencarian nama komputer yang memiliki TCP/IP. DNS merupakan sebuah aplikasi service yang digunakan di internet seperti web browser untuk memudahkan pengguna mengakses "nama" alamat yang kemudian diterjemahkan menjadi alamat IP. (http://defas56.blogspot.com/2012/10/pengertian-dan-fungsi-dns-server.html)

Pengaturan LAN atau Local Area Network pada Linux dapat dilakukan melalui terminal menggunakan beberapa perintah. Beberapa perintah yang akan digunakan pada pengaturan LAN yang saya gunakan adalah : ifconfig, cat, route add default gw, dan echo.

Perintah ifconfig digunakan untuk menampilkan atapun merubah setting TCP/IP pada interface jaringan yang kita miliki. (http://bocahperantau.blogspot.com/2010/10/comment-comment-dalam-linux.html)
Berikut tampilan terminal saat dimasukkan perintah ifconfig:

Dapat dilihat pengaturan default dari ethernet, local loopback, dan wlan.

Kemudian dengan menggunakan perintah cat /etc/resolv.conf dapat menampilkan alamat DNS server, berikut tampilannya :

Pada gambar diatas nameserver yang tertera adalah 127.0.1.1

Dengan mengetikkan perintah ifconfig eth0 192.168.1.x (isi x sesuai yang diinginkan(contoh saya menggunakan angka 18)) netmask 255.255.255.0 lalu dilanjutkan dengan perintah route add default gw 192.168.1.1 kita dapat melakukan pengaturan terhadap IP ethernet card client.

Berikut keluaran ifconfig setelah dilakukan pengaturan :

Dapat dilihat pada data eth0, setelah dilakukan pengaturan, internet address sesuai dengan nilai yang dimasukkan pada perintah, yaitu 192.168.1.18.

Kemudian untuk melakukan pengaturan nama DNS server (misal nama server diganti menjadi 8.8.8.8) dapat menggunakan perintah echo "nameserver 8.8.8.8" > /etc/resolv.conf. Setelah itu nama DNS server bisa kembali dicek menggunakan perintah cat /etc/resolv.conf seperti tampilan dibawah: