Pernahkah kita bayangkan seberapa aman data yang kita simpan di cloud? Kita ambil contoh Openstack sebagai platform yang cukup populer saat ini. Dengan OpenStack kita bisa membuat infrastruktur berbasis cloud yang fleksibel dibanding platform lain. Tapi bagaimana jika instance atau VM yang kita buat justru rentan terhadap serangan siber?. Untuk itu kita perlu meningkatkan keamanan agar terhindar dari exploitasi sistem seperi serangan brute force.

Salah satu solusi yang bisa diterapkan adalah Snort IDS, yang berfungsi untuk memantau dan menganalisis lalu lintas jaringan, baik yang masuk maupun keluar dari instance. Sementara itu, Cowrie dapat dimanfaatkan sebagai honeypot untuk menipu penyerang dengan menciptakan lingkungan palsu, sehingga akses yang tidak sah tidak langsung menyentuh server asli.

Penasaran bagaimana cara implementasinya di Openstack? Simak sampai selesai kawan!

Tunggu dulu… Sebelum masuk ke langkah-langkahnya, yuk simak dulu teori singkat di bawah ini!

Apa itu OpenStack?

Openstack adalah platform cloud computing yang dirancang untuk menyediakan layanan infrastruktur cloud, baik private maupun public. Openstack memberikan kemudahan ke organisaasi atau individu untuk mengelola lingkungan cloud yang fleksibel melalui interface Web ataupun melalui API ke resource seperti server, database, jaringan dan sebagainya

Apa itu IDS (Intrusion Detection System)?

Intrusion Detection System adalah sistem keamanan komputer yang dirancang untuk mendeteksi aktivitas tidak sah atau mencurigakan pada sebuah perangkat. IDS bekerja dengan menganalisis pola lalu lintas server secara real-time dan aktivitas di dalamnya. Jika ada perubahan pada pola tertentu, sistem ini akan segera memberi informasi kepada perangkat.

Apa itu Snort?

Snort merupakan sistem deteksi dan pencegahan intrusi (Intrusion Detection and Prevention System/IDPS) yang bersifat open-source. Sistem ini dirancang untuk menganalisis lalu lintas jaringan secara real-time dan mencatat paket data. Snort juga dapat beroperasi dalam beberapa mode, yaitu:

Sniffer Mode: Menampilkan dan membaca paket di konsol.
Packet Logger Mode: Mencatat semua paket ke disk untuk analisis lebih lanjut.
Intrusion Detection System (IDS) Mode: Memantau lalu lintas jaringan dan menganalisisnya berdasarkan aturan yang telah ditentukan

Apa itu Honeypot?

Honeypot adalah sebuah server atau sistem jaringan yang dirancang untuk menjadi umpan bagi para hacker. Secara sederhana, honeypot berfungsi sebagai perangkat tiruan yang sengaja dibuat agar terlihat seperti target yang menarik bagi penyerang. Tujuan utamanya adalah untuk mengelabui penyerang agar mereka mengira honeypot sebagai server sebenarnya, sehingga mereka menyerang honeypot bukan server asli yang penting.

Apa itu Cowrie?

Cowrie Honeypot adalah sistem yang dirancang untuk menangkap koneksi SSH dan Telnet . Merekam informasi sesi. Jenis honeypot ini sering kali terhubung ke Internet untuk memantau alat, skrip, dan host yang digunakan oleh penyerang yang menebak kata sandi.

Apa itu Tap-as-a-Service?

Tap-as-a-Service (TaaS) adalah fitur di lingkungan OpenStack yang memungkinkan kita untuk menduplikasi lalu lintas jaringan dari satu VM ke VM lain tanpa mengubah informasi sumber dan tujuan. Fitur ini berguna untuk:

Melakukan network monitoring dan audit
Menganalisis trafik menggunakan IDS seperti Snort
Memeriksa firewall rules dan troubleshooting jaringan

Spesifikasi Node

OS	Ubuntu 22.04-LTS (x86_64)
vCPU	4 core
RAM	12GB
Disk 1	30GB
Disk 2	10GB
Internal Network	192.168.5.0/24
Provider Network	20.5.5.0/24

IP Address & Hostname

hostname	IP Address
node-controller	192.168.5.10
node-compute1	192.168.5.20
node-compute2	192.168.5.30

Tools

Tools	Versions
Kolla Ansible	19.3.0
Ansible Core	2.17.9
Openstack	2024.2
Snort	2.9.15.1
Cowrie	v2.6.1
Postfix	3.6.4
Mailutils	3.14

Topologi

Dari topologi tersebut port yang akan digunakan sebagai akses SSH yang sah adalah port 3333 sedangkan port 22 tetap terbuka namun koneksi akan segera dirouting (diarahkan) ke port 2222 dari honeypot. Snort akan menangkap koneksi yang masuk melalui Tap Service dan mengirimkan notifikasi ke email.

Topologi Tap-as-a-Service (TaaS)

Dalam penerapan Tap-as-a-Service, diperlukan 2 resource lain yaitu Tap Service dan Tap Flow. Tap Service digunakan untuk mendefinisikan port mana yang akan dijadikan sebagai destinasi dari mirroring traffic (port dari snort instance). Sedangkan Tap Flow digunakan untuk mendefinisikan port target yang trafficnya perlu kita mirror.

Workflow

Implementasi

Persiapan Environment

\ Eksekusi di semua node*

Ubah Hostname

  # node controller
  ~$ sudo hostnamectl set-hostname node-controller

  # node compute1
  ~$ sudo hostnamectl set-hostname node-compute1

  # node compute2
  ~$ sudo hostnamectl set-hostname node-compute2

Map Hostname ke /etc/hosts

  192.168.5.10 node-controller
  192.168.5.20 node-compute1
  192.168.5.30 node-compute2

Buat dan distribusikan SSH Key

  ~$ ssh-keygen
  ...
  ~$ ssh-copy-id student@node-controller
  ~$ ssh-copy-id student@node-compute1
  ~$ ssh-copy-id student@node-compute2

Buat Swap

  # Alokasikan disk space ke /swapfile
  ~$ sudo fallocate -l 4G /swapfile

  # Ubah permission
  ~$ sudo chmod 600 /swapfile

  # Buat swap dari /swapfile
  ~$ sudo mkswap /swapfile

  # Aktifkan swap dari /swapfile
  ~$ sudo swapon /swapfile

  # Tambahkan konfigurasi di fstab
  ~$ sudo vim /etc/fstab
  ...
  /swapfile swap swap defaults 0 0

Instalasi Openstack Cluster

*Eksekusi di node-controller

Upgrade paket dan install dependensi

  ~$ sudo apt update
  ~$ sudo apt-get install python3-dev libffi-dev gcc libssl-dev python3-selinux python3-setuptools python3-venv -y

Buat virtual environment sehingga package dan dependensi yang diinstall tidak konflik dengan package global di VM
```
  ~$ python3 -m venv venv-simulasi
  ~$ source venv-simulasi/bin/activate
```

Install Ansible dan Kolla Ansible

  # Perbarui pip
  (venv-simulasi) student@node-controller:~$ pip install -U pip

  # Install ansible core versi 2.17.9
  (venv-simulasi) student@node-controller:~$ pip install 'ansible-core>=2.17.9'

  # Install kolla ansible
  (venv-simulasi) student@node-controller:~$ pip install git+https://opendev.org/openstack/kolla-ansible@stable/2024.2

  # Install dependensi
  (venv-simulasi) student@node-controller:~$ kolla-ansible install-deps

Buat Direktori /etc/kolla

  # Buat direktori /etc/kolla
  (venv-simulasi) student@node-controller:~$ sudo mkdir -p /etc/kolla

  # Ubah ownership direktori
  (venv-simulasi) student@node-controller:~$ sudo chown $USER:$USER /etc/kolla

Salin file globals.yml dan passwords.yml

  (venv-simulasi) student@node-controller:~$ cp -r venv-simulasi/share/kolla-ansible/etc_examples/kolla/* /etc/kolla

Salin file inventori multinode. Inventori multinode diperlukan jika kita ingin membangun cluster openstack yang terdiri dari lebih 1 node. Jika ingin install secara single node maka bisa pilih inventori all-in-one
```
  (venv-simulasi) student@node-controller:~$ cp venv-simulasi/share/kolla-ansible/ansible/inventory/multinode .
```
Ubah konfigurasi inventori seperti berikut

```bash [control] node-controller

[network] node-controller

[compute] node-compute1 node-compute2

[monitoring] node-controller

[storage] node-controller node-compute1 node-compute2

[deployment] localhost ansible_connection=local


* Buat konfigurasi ansible di /etc/ansible/ansible.cfg

    ```bash
    (venv-simulasi) student@node-controller:~$ sudo mkdir -p /etc/ansible
    (venv-simulasi) student@node-controller:~$ sudo vim /etc/ansible/ansible.cfg

    ...
    [defaults]
    host_key_checking = False
    pipelining = True
    forks = 100

Generate password untuk file passwords.yml yang nantinya akan dibutuhkan pada saat deployment.
```
  (venv-simulasi) student@node-controller:~$ kolla-genpwd
```

Edit konfigurasi globals.yml sesuai kebutuhan cluster

  kolla_base_distro: "ubuntu"
  openstack_release: "2024.2"
  network_interface: "ens3"
  neutron_external_interface: "ens4"
  kolla_internal_vip_address: "192.168.5117"
  neutron_plugin_agent: "openvswitch"
  enable_keystone: "yes"
  enable_horizon: "yes"
  enable_neutron_provider_networks: "yes"
  enable_cinder: "yes"
  enable_cinder_backend_lvm: "yes"
  enable_neutron_taas: "yes"

Verifikasi konfigurasi globals.yml

  (venv-simulasi) student@node-controller:~$ cat /etc/kolla/globals.yml | grep -v "#" | tr -s [:space:]

Buat Volume group (VG) sebagai backend storage cinder

*Eksekusi step ini di semua node

  (venv-simulasi) student@node-controller:~$ sudo pvcreate /dev/vdb
  (venv-simulasi) student@node-controller:~$ sudo vgcreate cinder-volumes /dev/vdb
  (venv-simulasi) student@node-controller:~$ sudo vgs

Deploy Openstack Cluster

Jalankan proses bootstrap server untuk menyiapkan environment

  (venv-simulasi) student@node-controller:~$ kolla-ansible bootstrap-servers -i ~/multinode

Jalankan proses prechecks untuk memastikan semua dependensi dan service yang dibutuhkan berjalan dengan benar
```
  (venv-simulasi) student@node-controller:~$ kolla-ansible prechecks -i ~/multinode
```

Jalankan proses deployment openstack cluster

  (venv-simulasi) student@node-controller:~$ kolla-ansible deploy -i ~/multinode

Jalankan proses post-deploy untuk membuat file kredensial admin (admin- openrc.sh)

  (venv-simulasi) student@node-controller:~$ kolla-ansible post-deploy -i ~/multinode

Install openstack client menggunakan pip

  (venv-simulasi) student@node-controller:~$ pip install openstackclient

Cek service yang sudah berjalan

  (venv-simulasi) student@node-controller:~$ source /etc/kolla/admin-openrc.sh
  (venv-simulasi) student@node-controller:~$ openstack service list

Contoh Output:

  (venv-simulasi) student@node-controller:~$ openstack service list
  +----------------------------------+-----------+----------------+
  | ID                               | Name      | Type           |
  +----------------------------------+-----------+----------------+
  | 48fbd910170a4fd598e05893f5d3f01e | heat-cfn  | cloudformation |
  | 590b69815c8a46d1855683940b165e83 | placement | placement      |
  | a2b19cb971a44687a614ef732a99ed06 | cinderv3  | volumev3       |
  | b69bf0671bb641e7ab9647939c92e157 | neutron   | network        |
  | b935f9008d45487f9217c9233eefd869 | heat      | orchestration  |
  | c4e9bd6e2102410abd822606fad42fa4 | nova      | compute        |
  | ec3581871e2e4f9cb44e26a7ef7e08a1 | glance    | image          |
  | fd99076b81d741d8bf115cd869366c87 | keystone  | identity       |
  +----------------------------------+-----------+----------------+

Persiapan sebelum konfigurasi instance

*Eksekusi di node-controller

Buat External network yang akan digunakan untuk akses ke internet untuk instance di cluster openstack

  (venv-simulasi) student@node-controller:~$ openstack network create --external --share --provider-physical-network physnet1 --provider-network-type flat external-network

Kita bisa melihat physical network yang dipakai di /etc/kolla/neutron-server/ml2_conf.ini

  (venv-simulasi) student@node-controller:~$ cat /etc/kolla/neutron-server/ml2_conf.ini
  ...
  [ml2_type_flat]
  flat_networks = physnet1

Unduh image ubuntu yang akan digunakan untuk membuat instance snort & client

  (venv-simulasi) student@node-controller:~$ wget https://cloud-images.ubuntu.com/jammy/20250221/jammy-server-cloudimg-amd64.img

Cek extension taas (Tap-as-a-Service) di cluster openstack

  (venv-simulasi) student@node-controller:~$ openstack extension list | grep taas
  ...
  +-------------------------------------------------+---------------------------------------------+--------------------------------------------------+
  | Neutron Tap as a Service                        | taas                                        | Neutron Tap as a Service Extension.              |
  | VLAN filtering for Neutron Tap as a Service     | taas-vlan-filter                            | Neutron Tap as a Service Extension for filtering |
  |                                                 |                                             | VLANs.                                           |
  +-------------------------------------------------+---------------------------------------------+--------------------------------------------------+

Buat direktori simulasi-deploy untuk mengelompokan playbook inventori dan roles yang diperlukan

  (venv-simulasi) student@node-controller:~$ mkdir ~/simulasi-deploy && cd ~/simulasi-deploy

Buat Ansible roles dengan nama deploy-instance. Karena ansible diinstall di virtual environment maka setiap proses yang berkaitan dengan ansible maupun kolla-ansible harus berada di virtual environment tersebut
```
  (venv-simulasi) student@node-controller:~/simulasi-deploy$ ansible-galaxy init deploy-instance
```

Buat Ansible roles dengan nama snort khusus untuk instalasi snort di instance snort-server

  (venv-simulasi) student@node-controller:~/simulasi-deploy$ ansible-galaxy init snort

Buat Ansible roles dengan nama cowrie khusus untuk instalasi cowrie di instance snort client
```
  (venv-simulasi) student@node-controller:~/simulasi-deploy$ ansible-galaxy init cowrie
```

Buat inventory untuk host yang akan digunakan oleh playbook.

  (venv-simulasi) student@node-controller:~/simulasi-deploy$ vim inventory
  ...
  [snortvm]
  monitor ansible_host=20.5.5.110 ansible_user=ubuntu ansible_ssh_private_key_file=~/.ssh/id_rsa

  [clientvm]
  client1 ansible_host=20.5.5.120 ansible_user=ubuntu
  client2 ansible_host=20.5.5.130 ansible_user=ubuntu

Buat playbook.yml

  (venv-simulasi) student@node-controller:~/simulasi-deploy$ vim playbook.yml
  ...

  - name: Create instance for snort server and client
    hosts: localhost
    become: no
    roles:
      - deploy-instance
    tags: deploy

  - name: Snort Setup on snort server
    hosts: snortvm
    become: yes
    vars_files: /home/student/simulasi-deploy/snort/vars/secret.yaml
    roles:
      - snort
    tags: snort

  - name: Cowrie setup on cowrie node / snort-client
    hosts: clientvm
    become: yes
    roles:
      - cowrie
    tags: cowrie

Konfigurasi role deploy instance

Buat variable di ~/simulasi-deploy/deploy-instance/vars/main.yaml

Variable untuk otentikasi ke OpenStack Cluster

  auth_params:
    auth_url: http://192.168.5.117:5000
    username: admin
    password: PASS
    project_name: admin
    domain_name: Default

Variable flavor

  flavor_name: flavor-simulasi
  flavor_ram: 1024
  flavor_disk: 4
  flavor_vcpus: 1

Variable security group

  sg_name_monitor: sg_monitor
  sg_name_client: sg_client
  sg_rule_name:

Variable keypair

  keypair_name: key-simulasi
  keypair_file: /home/student/.ssh/id_rsa.pub

Variable yang berhubungan dengan networking OpenStack

  network_internal_name: network-simulasi
  subnet_name: subnet-simulasi
  cidr: 172.16.5.0/24
  router_name: router-simulasi
  external_network: external-network

  port_snort: port-snort-server
  port_client1: port-snort-client1
  port_client2: port-snort-client2

  ip_port_snort: 172.16.5.110
  ip_port_client1: 172.16.5.120
  ip_port_client2: 172.16.5.130

  snort_floating_ip: 20.5.5.110
  client1_floating_ip: 20.5.5.120
  client2_floating_ip: 20.5.5.130

Variable untuk image dan instance

  image_name: image-simulasi
  image_file:  /home/student/jammy-server-cloudimg-amd64.img

  snort_server_name: snort-server
  snort_client1_name: snort-client1
  snort_client2_name: snort-client2

Variable Tap-as-a-Service

  tap_service_name: TS-Simulasi
  tap_flow_client1: TF-client1
  tap_flow_client2: TF-client2

Buat tasks di ~/simulasi-deploy/deploy-instance/tasks/main.yaml

Buat image yang akan digunakan untuk instance menggunakan module

openstack.cloud.image

  - name: Create Image for snort and client vm
    openstack.cloud.image:
      auth: "{{ auth_params }}"
      filename: "{{ image_file }}"
      disk_format: qcow2
      container_format: bare
      name: "{{ image_name }}"
      state: present
    tags: provision

Buat Flavor untuk instance

  - name: Create flavor
    openstack.cloud.compute_flavor:
      state: present
      auth: "{{ auth_params }}"
      name: "{{ flavor_name }}"
      ram: "{{ flavor_ram }}"
      disk: "{{ flavor_disk }}"
      vcpus: "{{ flavor_vcpus }}"
    tags: provision

Buat Security Group untuk instance snort server

  - name: Create security group for snort VM
    openstack.cloud.security_group:
      auth: "{{ auth_params }}"
      name: "{{ sg_name_monitor }}"
      state: present
      description: "Allow all incoming traffic"
    tags: provision

Buat Security Group untuk instance snort client

  - name: Create security group for client VM
    openstack.cloud.security_group:
      auth: "{{ auth_params }}"
      name: "{{ sg_name_client }}"
      state: present
      description: "Allow only ICMP and SSH (with trusted IP) connections"
    tags: provision

Buat Security Group Rule untuk semua port dari protokol TCP di security group snort server

  - name: Create security group rule for "{{ sg_name_monitor }}"
    openstack.cloud.security_group_rule:
      auth: "{{ auth_params }}"
      security_group: "{{ sg_name_monitor }}"
      protocol: tcp
      port_range_min: 1
      port_range_max: 65535
    tags: provision

Buat Security Group Rule yang mengizinkan protokol ICMP di security group snort server

  - name: Create security group rule for "{{ sg_name_monitor }}"
    openstack.cloud.security_group_rule:
      auth: "{{ auth_params }}"
      security_group: "{{ sg_name_monitor }}"
      protocol: icmp
    tags: provision

Buat Security Group Rule yang mengizinkan port 22 dan port 23 di security group snort client

  - name: Create security group rule for "{{ sg_name_client }}"
    openstack.cloud.security_group_rule:
      auth: "{{ auth_params }}"
      security_group: "{{ sg_name_client }}"
      protocol: tcp
      port_range_min: 22
      port_range_max: 23
      remote_ip_prefix: 0.0.0.0/0
    tags: provision

Buat Security Group Rule yang mengizinkan port 2222 (ssh honeypot) dan port 2223 (telnet honeypot) di security group snort client

  - name: Create security group rule for redirect port from 22 and 23 (honeypot)
    openstack.cloud.security_group_rule:
      auth: "{{ auth_params }}"
      security_group: "{{ sg_name_client }}"
      protocol: tcp
      port_range_min: 2222
      port_range_max: 2223
      remote_ip_prefix: 0.0.0.0/0
    tags: provision

Buat Security Group Rule untuk mengizinkan port 3333 (port untuk koneksi ssh yan sah) di security group snort client

  - name: Create security group rule for real ssh and telnet port
    openstack.cloud.security_group_rule:
      auth: "{{ auth_params }}"
      security_group: "{{ sg_name_client }}"
      protocol: tcp
      port_range_min: 3333
      port_range_max: 3333
      remote_ip_prefix: 172.16.5.0/24
    tags: provision

Buat Security Group Rule untuk mengizinkan koneksi dari protokol ICMP di security group snort client

  - name: Create security group rule icmp for "{{sg_name_client}}"
    openstack.cloud.security_group_rule:
      auth: "{{ auth_params }}"
      security_group: "{{ sg_name_client}}"
      protocol: icmp
      remote_ip_prefix: 0.0.0.0/0
    tags: provision

Buat keypair untuk ssh melalui public key ke instance Sebelum membuat keypair kita perlu generate ssh key terlebih dahulu menggunakan command ssh-keygen

  - name: Create Keypair
    openstack.cloud.keypair:
      auth: "{{ auth_params }}"
      name: "{{ keypair_name }}"
      state: present
      public_key_file: "{{ keypair_file }}"
    tags: provision

Buat internal network untuk komunikasi internal antar instance

  - name: Create internal network
    openstack.cloud.network:
      auth: "{{ auth_params }}"
      state: present
      name: "{{ network_internal_name }}"
      external: false
    tags: provision

Buat subnet untuk internal network

  - name: Create subnet for internal network
    openstack.cloud.subnet:
      auth: "{{ auth_params }}"
      name: "{{ subnet_name }}"
      state: present
      network_name: "{{ network_internal_name }}"
      cidr: 172.16.5.0/24
      dns_nameservers:
        - 8.8.8.8
        - 8.8.4.4
    tags: provision

Buat router untuk menghubungkan internal network dengan external network

  - name: Create router attached to external network with one internal network
    openstack.cloud.router:
      auth: "{{ auth_params }}"
      state: present
      name: "{{router_name}}"
      network: "{{ external_network }}"
      interfaces:
        - "{{ subnet_name }}"
    tags: provision

Buat port dengan fixed ip (ip statis) yang akan diberikan ke instance

  - name: Create port with fixed ip address for snort and client VM
    openstack.cloud.port:
      auth: "{{ auth_params }}"
      name: "{{ item.name }}"
      network: "{{network_internal_name}}"
      fixed_ips:
        - ip_address: "{{ item.ip }}"
    loop:
      - { name: "{{ port_snort }}", ip: "{{ ip_port_snort }}" }
      - { name: "{{ port_client1 }}", ip: "{{ ip_port_client1 }}" }
      - { name: "{{ port_client2 }}", ip: "{{ ip_port_client2 }}" }
    register: port_results

Buat variable yang berisi id dari port yang sebelumnya dibuat. Variable ini akan diperlukan saat pembuatan floating ip.

  - name: Get port id that previously created
    set_fact:
      port_ids: "{{ port_ids | default({}) | combine({item.item.name: item.port.id}) }}"
    loop: "{{ port_results.results }}"
    when: item.port is defined

Buat instance untuk snort-server and snort client.

  - name: Create Instance for  snort server & snort client
    os_server:
      auth: "{{ auth_params }}"
      name: "{{ item.name }}"
      image: "{{ image_name }}"
      key_name: "{{ keypair_name }}"
      timeout: 200
      security_groups: "{{ item.sg }}"
      flavor: "{{ flavor_name }}"
      nics:
        - port-id: "{{ item.portid }}"
      floating_ips: "{{ item.floating_ip }}"
    loop:
      -  { name: "{{ snort_server_name }}", portid: "{{ port_ids['port-snort-server'] }}", sg: "{{ sg_name_monitor }}",  floating_ip: "{{ snort_floating_ip }}" }
      -  { name: "{{ snort_client1_name }}", portid: "{{ port_ids['port-snort-client1'] }}", sg: "{{ sg_name_client }}",  floating_ip: "{{ client1_floating_ip }}"}
      -  { name: "{{ snort_client2_name }}", portid: "{{ port_ids['port-snort-client2'] }}", sg: "{{ sg_name_client }}", floating_ip:  "{{ client2_floating_ip }}" }
    tags: provision

Buat Tap Service

  - name: Create tap service for mirroring traffic from client VMs
    command: >
      openstack tap service create
      --name "{{ tap_service_name }}"
      --port "{{ port_ids['port-snort-server'] }}"
    tags: taas

Buat Tap Flow

  - name: Create tap flow to capture traffic from port client
    command: >
      openstack tap flow create
      --name "{{ item.name }}"
      --port "{{ item.port }}"
      --direction IN
      --tap-service "{{ tap_service_name }}"
    tags: taas
    loop:
      - { name: "{{ tap_flow_client1 }}", port: "{{ port_ids['port-snort-client1'] }}" }
      - { name: "{{ tap_flow_client2 }}", port: "{{ port_ids['port-snort-client2'] }}" }

Konfigurasi role snort

Konfigurasi Ansible Vault untuk menyimpan variable smtp user dan smtp password

  (venv-simulasi) student@node-controller:~/simulasi-deploy$ ansible-vault create snort/vars/secret.yaml
  New Vault password:
  Confirm New Vault password:
  ...
  smtp_user: user_email
  smtp_password: user_password

Buat tasks di ~/simulasi-deploy/snort/tasks/main.yml

Update repository dan install snort

  - name: Update repository and install snort
    apt:
      update_cache: yes
      name: snort

Edit konfigurasi snort di bagian HOME_NET Variable

  - name: Edit snort configuration
    lineinfile:
      path: /etc/snort/snort.conf
      regexp: "ipvar HOME_NET any"
      line: "ipvar HOME_NET 172.16.5.0/24"
      state: present

Salin konfigurasi snort rules

  - name: Copy file rules
    copy:
      src: local.rules
      dest: /etc/snort/rules/local.rules
      mode: '0644'

Salin konfigurasi systemd untuk snort service.

  - name: Copy systemd configuration for snort IDS
    copy:
      src: snort-service
      dest: /etc/systemd/system/snort
      mode: '0644'

Install postfix untuk mailing system

  - name: Install Postfix for alerting                         
    apt:
      update_cache: yes
      name:                                                         
        - postfix
        - libsasl2-modules
        - ca-certificates
        - mailutils

Konfigurasi postfix di /etc/postfix/main.cf

  - name: Configure postfix                                                 lineinfile:
      path: /etc/postfix/main.cf
      regexp: "^relayhost"
      line: "relayhost = [smtp.gmail.com]:587"
      state: present

Tambahkan konfigurasi autentikasi smtp

  - name: Configure postfix authentication
    blockinfile:
      path: /etc/postfix/main.cf
      block: |
        # authentication
        smtp_sasl_auth_enable= yes
        smtp_sasl_password_maps= hash:/etc/postfix/sasl_passwd
        smtp_sasl_security_options = noanonymous
        smtp_use_tls = yes
        smtp_tls_security_level= may
        header_size_limit =  4096000
        # ssl
        smtp_tls_CAfile= /etc/ssl/certs/ca-certificates.crt
      state: present

Tambahkan smtp user untuk proses mailing

  - name: Add user and app-password for your email
    copy:
      dest: /etc/postfix/sasl_passwd
      content: |
        [smtp.gmail.com]:587 {{ smtp_user }}:{{ smtp_password }}
      owner: root
      group: root
      mode: '0600'

Hash password dari smtp user

  - name: Hash passowrd file
    command:  postmap /etc/postfix/sasl_passwd

Restart Postfix

  - name: Restart Postfix
    systemd_service:
      name: postfix
      state: restarted
      enabled: true

Salin scripting untuk alerts ke email

  - name: Copy snort alerts to email
    copy:
      src: email-alerts.sh
      dest: /usr/sbin/email-alerts.sh
      mode: '775'

Salin email-body file sebagai isi pesan untuk alerts

  - name: Copy email body
    copy:
      src: email-body
      dest: /etc/snort
      mode: '775'

Salin file email-service untuk konfigurasi systemd snort-alerts.

  - name: Copy file systemd for email alerts
    copy:
      src: email-service
      dest: /etc/systemd/system/snort-alerts
      mode: '0644'

Restart snort & snort-alerts service

  - name: Reload systemd daemon
    systemd_service:
      daemon_reload: true

  - name: start snort service
    systemd_service:
      name: snort                                                             state: started
      enabled: true
                                                                          - name: start snort-alerts service
    systemd_service:
      name: snort-alerts
      state: started
      enabled: true

Buat semua file yang dibutuhkan di ~/simulasi-deploy/snort/files/

local.rules

  # rules for icmp connection
  alert icmp any any -> $HOME_NET any ( msg:"Ping Detected";  priority:5; sid:100001; rev:1; )

  alert tcp any any -> $HOME_NET 22 ( msg:"SSH Action Detected. Connection redirected to honeypot"

  alert tcp any any -> $HOME_NET 23 ( msg:"Telnet Action Detected. Connection redirected to honeypot";  priority:1; sid:100002; rev:1; )

snort-service


  [Unit]
  Description = Snort IDS Service
  After = network.target

  [Service]
  Type=simple
  ExecStart=/usr/sbin/snort -A fast -c /etc/snort/snort.conf -q -i ens3 -l/var/log/snort
  User=root
  Group=root
  LimitCore=infinity

  [Install]
  WantedBy=multi-user.target

email-alerts.sh

  #!/bin/bash

  # Required variables
  SNORT_LOG_FILE="/var/log/snort/alert"
  EMAIL_TO="tsaniakhilyatin@gmail.com"
  EMAIL_FROM="tsaniakhilya@gmail.com"

  # Install inotify-tools if not installed
  if ! command -v inotifywait &> /dev/null; then
      echo "Installing inotify-tools..."
      sudo apt install inotify-tools -y
  fi

  # Loop to monitor file changes
  while inotifywait -e modify "$SNORT_LOG_FILE"; do
      # Capture latest alert
      ALERTS=$(tail -n 1 "$SNORT_LOG_FILE")

      # log parsing
      DATE=$( echo "$ALERTS" | awk '{print $1}' | awk -F'-' '{print $1}' | awk -v year=$(date +%Y) '{print $1 "/" year}' )
      MESSAGE_LOG=$( echo "$ALERTS" |  awk -F'*]' '{print $2}' | awk -F']' '{print $2}' | sed 's/\[.*//' )
      SOURCE_IP=$( echo "$ALERTS" | awk -F' -> ' '{print $1}' | awk '{print $NF}' )
      DEST_IP=$(echo "$ALERTS" |  awk -F' -> ' '{print $2}' | sed 's/:.*//')

      # Email contents
      EMAIL_SUBJECT="🚨 Snort Alert Detected 🚨"
      EMAIL_BODY=$(cat /etc/snort/email-body | \
      sed "s|\$DATE|$DATE|g" | \
      sed "s|\$MESSAGE_LOG|$MESSAGE_LOG|g" | \
      sed "s|\$SOURCE_IP|$SOURCE_IP|g" | \
      sed "s|\$DEST_IP|$DEST_IP|g" | \
      sed "s|\$SNORT_LOG_FILE|$SNORT_LOG_FILE|g")

      # Send email
      echo -e "$EMAIL_BODY" | mail -s "$EMAIL_SUBJECT" -r "$EMAIL_FROM" "$EMAIL_TO"

      # Tambahkan delay agar tidak spam email
      sleep 60
  done

email-body

  SNORT DETECT ACTIVITY!

  Detail:

  📅 Date: $DATE
  ⚠  Alert: $MESSAGE_LOG
  🌍 Source  : $SOURCE_IP
  🎯 Destination : $DEST_IP
  📜 Log file : $SNORT_LOG_FILE

  Please check the log file for more details.

email-service

  [Unit]
  Description=Snort Alert Email Sender
  After=network.target

  [Service]
  Type=simple
  ExecStart=/usr/sbin/email-alerts.sh
  Restart=always
  User=root

  [Install]
  WantedBy=multi-user.target

Konfigurasi role cowrie

Buat variable di ~/simulasi-deploy/cowrie/vars/main.yml

  cowrie_path: /opt/cowrie
  cowrie_env: /opt/cowrie-env

  url_repo: http://github.com/cowrie/cowrie
  systemd_path: /etc/systemd/system

  cowrie_service: /opt/cowrie/docs/systemd/etc/systemd/system/cowrie.service
  cowrie_socket: /opt/cowrie/docs/systemd/etc/systemd/system/cowrie.socket

  cowrie_conf: /opt/cowrie/etc/cowrie.cfg

Buat tasks di ~/simulasi-deploy/cowrie/tasks/main.yml

Update repository dan install dependensi cowrie

  - name: Install dependecies
    apt:
      update_cache: yes
      name:
        - git
        - python3-venv
        - libssl-dev
        - libffi-dev
        - build-essential
        - libpython3-dev
        - python3-minimal
        - authbind
        - iptables-persistent

Clone git repository

  - name: Clone git repository
    git:
      repo: https://github.com/cowrie/cowrie.git
      dest: /opt/cowrie
      version: "main"
      clone: yes
    ignore_errors: yes

Buat virtual environment untuk cowrie

  - name: Create virtual env in /opt
    command: python3 -m venv /opt/cowrie-env
    args:
      creates: /opt/cowrie-env/bin/activate

Install dependensi cowrie dari file requirements.txt

  - name: install Cowrie dependencies
    pip:
      requirements: "{{ cowrie_path }}/requirements.txt"
      virtualenv: /opt/cowrie-env

Salin konfigurasi cowrie

  - name: copy configuration file
    copy:
      src: "{{ cowrie_path }}/etc/cowrie.cfg.dist"
      dest: "{{ cowrie_conf }}"
      remote_src: yes

Edit konfigurasi di bagian telnet

  - name: Edit file configuration
    lineinfile:
      path: "{{ cowrie_conf }}"
      regexp: '^enabled = false'
      line: 'enabled = true'
      insertafter: '^\[telnet\]'
      state: present

Edit listen endpoint di bagian ssh

  - name: Edit listen port to systemd
    lineinfile:
      path: "{{ cowrie_conf }}"
      regexp: '^listen_endpoints =.*'
      line: 'listen_endpoints = systemd:domain=INET6:index=0'
      insertafter: '^\[ssh\]'
      state: present

Edit listen endpoint di bagian telnet

  - name: Edit listen port systemd on telnet section
    lineinfile:
      path: "{{ cowrie_conf }}"
      regexp: '^listen_endpoints =.*'
      line: 'listen_endpoints = systemd:domain=INET6:index=1'
      insertafter: '^\[telnet\]'
      state: present

Salin file systemd service cowrie

  - name: copy systemd file for cowrie service
    copy:
      src: "{{ cowrie_service }}"
      dest: "{{ systemd_path }}"
      remote_src: yes

  - name: copy systemd file for cowrie socket
    copy:
      src: "{{ cowrie_socket }}"
      dest: "{{ systemd_path }}"
      remote_src: yes

Buat user cowrie tanpa password

  - name: Add cowrie user
    user:
      name: cowrie
      shell: /bin/bash
      create_home: yes
      system: yes
      password: ''

Ubah kepemilikan direktori cowrie dan cowrie-env

  - name: Change ownership of cowrie directory
    file:
      path: "{{ cowrie_path }}"
      state: directory
      owner: cowrie
      group: cowrie

  - name: Change ownership of cowrie-env
    file:
      path: "{{ cowrie_env }}"
      state: directory
      owner: cowrie
      group: cowrie

Restart dan enable cowrie service dan cowrie socket

  - name: Restart and enable cowrie socket
    systemd:
      daemon_reload: true
      name: cowrie.socket
      state: restarted
      enabled: true

  - name: Restart and enabled cowrie service
    systemd:
      name: cowrie.service
      state: restarted
      enabled: true

Ubah konfigurasi ssh di instance agar port yang digunakan untuk ssh adalah 3333 dan melarang ssh melalui root user

  - name: Change port ssh
    lineinfile:
      path: /etc/ssh/sshd_config
      regexp: '^#Port'
      line: 'Port 3333'
      state: present

  - name: Change permission root login
    lineinfile:
      path: /etc/ssh/sshd_config
      regexp: '^#PermitRootLogin'
      line: 'PermitRootLogin no'
      state: present

Restart sshd service

  - name: Change permission root login
    lineinfile:
      path: /etc/ssh/sshd_config
      regexp: '^#PermitRootLogin'
      line: 'PermitRootLogin no'
      state: present

Ubah rules dari iptables sehingga koneksi yang masuk ke port 22 akan diteruskan ke port 2222 sedangkan koneksi ke port 23 (telnet) akan diteruskan ke port 2223

  - name: Change iptables rules for ssh connection
    command: >
      iptables -t nat -A PREROUTING -p tcp --dport 22 -j REDIRECT --to-port 2222

  - name: Change iptables rules for telnet connection
    command: >
      iptables -t nat -A PREROUTING -p tcp --dport 23 -j REDIRECT --to-port 2223

Jalankan Playbook

Jalankan playbook yang sudah dibuat dengan command berikut

  (venv-simulasi) student@node-controller:~/simulasi-deploy$ ansible-playbook -i inventory --ask-vault-pass playbook.yaml

Contoh progres deployment

Testing

Testing Snort

Uji coba snort rules pertama yaitu koneksi ICMP
Uji coba snort rules kedua yaitu koneksi ssh ke honeypot
Uji coba snort rules ketiga yaitu koneksi Telnet

Testing Cowrie

Uji coba masuk ke instance snort-client1 melalui port 22
Uji coba masuk ke instance snort-client2 melalui port 22

Testing Alerts

Uji coba alert untuk snort rules pertama
Uji coba alert untuk snort rules kedua
Uji coba alert untuk snort rules ketiga

Kesimpulan

Mengamankan OpenStack dari serangan siber itu penting untuk menjaga sistem tetap aman dan stabil. Dengan Snort IDS, kita bisa memantau lalu lintas jaringan dan mendeteksi aktivitas mencurigakan lebih cepat. Sementara itu, Cowrie berperan sebagai honeypot yang menjebak penyerang, sehingga akses ilegal bisa diamati tanpa membahayakan sistem utama.

Kombinasi keduanya memungkinkan kita untuk lebih proaktif dalam menghadapi ancaman, mendeteksi serangan lebih awal, dan memperkuat keamanan infrastruktur cloud. Dengan langkah ini, sistem OpenStack bisa lebih tangguh dalam menghadapi berbagai risiko siber di masa depan. 🚀

Referensi

Penjelasan tentang Openstack

https://dcloud.co.id/blog/apa-itu-openstack.html
Penjelasan tentang Tap-as-a-Service

https://docs.openstack.org/developer/dragonflow/specs/tap_as_a_service.html
Penjelasan tentang Snort

https://itbox.id/blog/apa-itu-snort/
Penjelasan tentang Cowrie

https://hackertarget.com/cowrie-honeypot-analysis-24hrs/
Instalasi OpenStack cluster dengan kolla-ansible

https://adinusa.id/
Konfigurasi Tap-as-a-Service
- https://youtu.be/rpIt9K2IsAc?si=q8Uote8FC1ydGJl-
- https://youtu.be/_cAkRUB3TCE?si=wvXVK12Nbl61ZpgL
Konfigurasi Snort

https://youtu.be/uPdCmuFh40M?si=QezpelqELFqu6Wri
Konfigurasi Cowrie
- https://docs.cowrie.org/en/latest/INSTALL.html
- https://docs.cowrie.org/en/latest/systemd/README.html
Pembuatan alert ke email

https://youtu.be/MEy0c3o_ifE?si=vNPS1QSCtKElzWMi

Securing OpenStack Instances with Snort IDS and Cowrie (Honeypot)

Table of contents