<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Sefa Yıldırım on Medium]]></title>
        <description><![CDATA[Stories by Sefa Yıldırım on Medium]]></description>
        <link>https://medium.com/@sefayildirimmm?source=rss-1f1223b3b46d------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*xLDksLzbmtykLuRq.jpg</url>
            <title>Stories by Sefa Yıldırım on Medium</title>
            <link>https://medium.com/@sefayildirimmm?source=rss-1f1223b3b46d------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 08:12:06 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@sefayildirimmm/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[EKS/ICS Pentest Labı — Bölüm 5: FUXA SCADA ve OpenPLC Entegrasyonu]]></title>
            <link>https://sefayildirimmm.medium.com/eks-ics-pentest-lab%C4%B1-b%C3%B6l%C3%BCm-5-fuxa-scada-ve-openplc-entegrasyonu-d3fbdcc3aff2?source=rss-1f1223b3b46d------2</link>
            <guid isPermaLink="false">https://medium.com/p/d3fbdcc3aff2</guid>
            <category><![CDATA[penetration-testing]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[ics-security]]></category>
            <category><![CDATA[scada-cyber-security]]></category>
            <category><![CDATA[plc]]></category>
            <dc:creator><![CDATA[Sefa Yıldırım]]></dc:creator>
            <pubDate>Sat, 26 Sep 2026 14:02:30 GMT</pubDate>
            <atom:updated>2026-09-26T14:46:11.406Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dhBgOXd0shWNAQ7wxSxUNA.png" /></figure><p>Bölüm 4&#39;te OpenPLC Runtime’ı Docker üzerinde çalıştırarak PLC katmanını oluşturduk. Structured Text kullanarak motor, pompa, vana, tank seviyesi, sıcaklık ve alarm değişkenlerini içeren basit bir proses simülasyonu geliştirdik.</p><p>Ayrıca OpenPLC’nin 502/TCP üzerinden Modbus TCP haberleşmesini doğruladık ve Kali Linux üzerinden mbpoll kullanarak PLC değişkenlerini okuyup değiştirebildik.</p><p>Bu bölümde ise laboratuvarın SCADA katmanını PLC ile birleştireceğiz.</p><p>Amaç, Bölüm 4&#39;te terminal üzerinden gerçekleştirdiğimiz manuel kontrolleri bu kez <strong>FUXA SCADA arayüzü üzerinden gerçekleştirmek</strong> ve PLC ile SCADA arasındaki haberleşmeyi uçtan uca doğrulamaktır.</p><p>Hedeflediğimiz yapı:</p><pre>                         ICS / OT LAB<br>                              |<br>                       Host-Only Network<br>                       192.168.56.0/24<br>                              |<br>                 +------------+------------+<br>                 |                         |<br>            Kali Linux                 OT Server<br>         192.168.56.102             192.168.56.20<br>                                         |<br>                                  Docker Environment<br>                                         |<br>                              +----------+----------+<br>                              |                     |<br>                           FUXA SCADA          OpenPLC Runtime<br>                              |                     |<br>                              +---- Modbus TCP -----+<br>                                    TCP/502</pre><p>Bu bölümün sonunda FUXA üzerinden OpenPLC’ye Modbus TCP bağlantısı kurmuş olacak ve SCADA ekranından PLC üzerindeki proses değerlerini izleyip kontrol edebileceğiz.</p><p>Örneğin hedeflediğimiz akış:</p><pre>FUXA SCADA<br>     |<br>     | Modbus TCP<br>     ▼<br>OpenPLC Runtime<br>     |<br>     ▼<br>PLC Control Logic<br>     |<br>     ├── Motor<br>     ├── Pump<br>     ├── Valve<br>     ├── Tank Level<br>     ├── Temperature<br>     └── Alarm</pre><p>öylece laboratuvarımız, yalnızca doğrudan PLC’ye erişebildiğimiz bir yapıdan, <strong>SCADA → PLC → Proses</strong> ilişkisinin gözlemlenebildiği daha gerçekçi bir OT ortamına dönüşecek.</p><h3>FUXA SCADA Web Arayüzünün Doğrulanması</h3><p>Bölüm 3&#39;te Docker üzerinde kurduğumuz FUXA container’ını yeniden çalıştırdıktan sonra, SCADA Web arayüzüne Kali Linux üzerinden erişimi doğruladık.</p><p>Tarayıcı üzerinden:</p><pre>http://192.168.56.20:1881</pre><p>adresine erişildiğinde FUXA Web arayüzünün başarıyla açıldığı görüldü.</p><p>Bu aşamada SCADA katmanının çalıştığını ve Kali Linux üzerinden OT Server üzerindeki FUXA servisine erişilebildiğini doğrulamış olduk.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*920SSaMKNrBnoyEZHn8hkQ.png" /></figure><h3>FUXA SCADA Projesinin Hazırlanması</h3><p>Şimdi FUXA içerisinde OpenPLC ile haberleşecek SCADA projesini oluşturacağız.</p><p>Amacımız henüz grafik ekran tasarlamak değil. Öncelikle FUXA’nın <strong>OpenPLC’yi bir Modbus TCP cihazı olarak tanımasını</strong> sağlayacağız.</p><p>Hedef bağlantımız:</p><pre>FUXA SCADA<br>     |<br>     | Modbus TCP<br>     | 192.168.56.20:502<br>     ▼<br>OpenPLC Runtime</pre><p>Burada önemli nokta şu:</p><p><strong>FUXA ve OpenPLC aynı OT Server üzerinde Docker container olarak çalışıyor olsa da, bizim SCADA tarafındaki haberleşme hedefimiz OpenPLC’nin OT Server üzerinden yayınladığı </strong><strong>502/TCP Modbus servisi olacak.</strong></p><h3>FUXA Modbus Haberleşme Desteğinin Hazırlanması</h3><p>FUXA Editor içerisinde <strong>Connections</strong> bölümüne geçtiğimizde, cihaz bağlantıları için gerekli protokol sürücülerinin Plugins bölümü üzerinden kurulması gerektiğini gördük.</p><p>Bu nedenle öncelikle FUXA’nın <strong>Plugins</strong> bölümünü açtık.</p><p>Burada farklı endüstriyel haberleşme protokollerine ait çeşitli driver’ların bulunduğu görüldü. Modbus TCP haberleşmesi için ise:</p><pre>MODBUS<br>└── modbus-serial</pre><p>eklenti olarak listeleniyordu.</p><p>Eklentinin mevcut durumu:</p><pre>Plugin       : modbus-serial<br>Version      : 8.0.19<br>Installed    : -</pre><p>Bu nedenle <strong>modbus-serial</strong> eklentisini FUXA içerisine kurduk.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QxzZT1JCyvLicADD7rHRww.png" /></figure><p>Bu aşamayla birlikte FUXA tarafında Modbus cihaz bağlantısını oluşturmak için gerekli driver’ın kurulumu tamamlanmış oldu.</p><h3>OpenPLC’nin FUXA’ya Modbus TCP Cihazı Olarak Eklenmesi</h3><p>Modbus driver kurulumunun ardından FUXA’nın <strong>Connections</strong> bölümüne geri döndük.</p><p>Bu bölüm üzerinden FUXA ile haberleşecek cihazların bağlantı tanımlarını oluşturabiliyoruz. Laboratuvarımızdaki PLC katmanı OpenPLC olduğu için yeni bir bağlantı oluşturarak OpenPLC Runtime’ı FUXA’ya bir <strong>Modbus TCP cihazı</strong> olarak tanımladık.</p><p>Yeni bağlantı oluşturmak için + butonunu kullandık ve bağlantıya:</p><pre>OpenPLC</pre><p>adını verdik.</p><p>Bağlantı tipi olarak ise:</p><pre>ModbusTCP</pre><p>seçeneğini kullandık.</p><p>OpenPLC Runtime’ın OT Server üzerinde 502/TCP portu üzerinden Modbus TCP servisi sunduğunu Bölüm 4&#39;te doğrulamıştık. Bu nedenle FUXA tarafındaki bağlantı hedefini:</p><pre>192.168.56.20:502</pre><p>olarak belirledik.</p><p>OpenPLC’nin Modbus haberleşmesinde kullandığımız Slave ID ise:</p><pre>1</pre><p>olarak tanımlandı.</p><p>Bağlantının temel yapılandırması şu şekilde oldu:</p><p>ParametreDeğerNameOpenPLCTypeModbusTCPPolling500 msConnection OptionsTcpPortSlave IP and Port192.168.56.20:502Slave ID1EnableAktif</p><p>Diğer gelişmiş bağlantı seçeneklerinde FUXA’nın varsayılan değerlerini koruduk.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X0bB6pPCTluSFQynoPQvFw.png" /></figure><p>Yapılandırmayı kaydettikten sonra <strong>Connections</strong> ekranında OpenPLC isimli bağlantının oluşturulduğunu gördük.</p><p>Bağlantı kartında:</p><pre>OpenPLC<br>192.168.56.20:502<br>Modbus-TCP Slave ID: 1</pre><p>bilgileri görüntülendi.</p><p>Ayrıca bağlantının yanında bulunan <strong>yeşil durum göstergesi</strong>, FUXA’nın OpenPLC Runtime ile Modbus TCP bağlantısını aktif olarak kurabildiğini gösterdi.</p><p>Böylece FUXA SCADA ile OpenPLC arasındaki temel haberleşme kanalını oluşturmuş olduk.</p><p>Bu noktada laboratuvarımızdaki iletişim akışı artık şu hale geldi:</p><pre>Kali Linux<br>     |<br>     | HTTP<br>     ▼<br>FUXA SCADA<br>     |<br>     | Modbus TCP<br>     | 192.168.56.20:502<br>     ▼<br>OpenPLC Runtime<br>     |<br>     ▼<br>PLC Control Logic</pre><p>Artık FUXA yalnızca çalışan bir SCADA Web arayüzü olmaktan çıkıp, OpenPLC üzerinde çalışan proses değişkenleriyle haberleşebilen bir SCADA katmanı haline gelmiş durumda.</p><p>İlk olarak OpenPLC içerisinde daha önce oluşturduğumuz Tank_Level değişkenini FUXA tarafında <strong>Tag</strong> olarak tanımladık. Tag yapılandırmasının ardından FUXA&#39;nın OpenPLC&#39;den veri okuyabildiğini doğrulamak amacıyla Tank_Level değerini kontrol ettik.</p><p>FUXA ekranında Tank_Level değişkeninin değerinin <strong>500</strong> olarak görüntülenmesiyle birlikte, SCADA → Modbus TCP → OpenPLC haberleşmesinin başarılı şekilde çalıştığını doğrulamış olduk.</p><h3>OpenPLC Değişkenlerinin FUXA Tag’leri Olarak Tanımlanması</h3><p>Tank_Level değişkeninin başarıyla okunmasının ardından diğer proses değişkenlerini de FUXA tarafında Tag olarak tanımlamaya geçiyoruz.</p><p>Bölüm 4&#39;te oluşturduğumuz PLC programında motor, pompa, vana, tank seviyesi, sıcaklık ve alarm durumlarını temsil eden değişkenler bulunuyordu.</p><p>Modbus tarafında bu değişkenler iki temel veri alanında yer alıyor:</p><pre>Coils<br>    ├── Motor_Command<br>    ├── Pump_Command<br>    ├── Valve_Command<br>    ├── Motor<br>    ├── Pump<br>    ├── Valve<br>    └── Alarm<br><br>Holding Registers<br>    ├── Tank_Level<br>    └── Temperature</pre><p>Bu nedenle FUXA içerisinde Tag oluştururken değişkenin veri tipine göre ilgili Modbus alanını seçmemiz gerekiyor.</p><p>Tank_Level için kullandığımız yapı:</p><p>ParametreDeğerDeviceOpenPLCTagnameTank_LevelRegisterHolding RegistersTypeInt16Address Offset1</p><p>FUXA’da oluşturulan Tag şu şekilde görüntülendi:</p><pre>Name        Address    Connection    Type     Value<br>----------------------------------------------------<br>Tank_Level  400001     OpenPLC       Int16    500</pre><p>Buradaki 500 değeri, Bölüm 4&#39;te Kali Linux üzerinden mbpoll kullanarak OpenPLC&#39;nin ilgili register&#39;ından okuduğumuz değerle aynıdır.</p><p>Böylece FUXA’nın yalnızca OpenPLC’ye bağlantı kurabildiğini değil, <strong>PLC içerisindeki gerçek bir proses değişkenini okuyabildiğini</strong> de doğrulamış olduk.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ttoDcXMDYvSpjJrk8yUF4A.png" /></figure><h3>FUXA Üzerinden PLC Değişkeninin Kontrol Edilmesi</h3><p>FUXA üzerinden yalnızca PLC değişkenlerini okumakla kalmayıp, SCADA arayüzü üzerinden PLC’ye komut gönderebilmek için bir kontrol elemanı oluşturduk.</p><p>İlk testimizde PLC içerisindeki Motor_Command değişkenini kontrol edeceğiz. Bu değişken OpenPLC tarafında bir BOOL olarak tanımlanmış ve Modbus TCP üzerinden <strong>Coil</strong> alanında bulunmaktadır.</p><h3>Motor_Command için Switch Oluşturulması</h3><p>FUXA Editor içerisinde MainView ekranına geçerek <strong>Controls</strong> bölümünde bulunan Switch kontrolünü çalışma alanına ekledik.</p><p>Eklediğimiz Switch’in özelliklerine girerek Tag alanını yapılandırdık. Tag seçim ekranında daha önce oluşturduğumuz:</p><pre>OpenPLC → Motor_Command</pre><p>Tag’ini seçtik.</p><p>Böylece FUXA üzerindeki Switch ile OpenPLC içerisindeki Motor_Command değişkeni arasında doğrudan bir ilişki oluşturmuş olduk.</p><p>Switch yapılandırmasında:</p><p>ParametreDeğerNameswitch_1TagMotor_CommandOff Value0On Value1</p><p>olarak belirlendi.</p><p>Bu yapılandırmayla Switch kapalı durumdayken FUXA Motor_Command değişkenine 0, açık duruma getirildiğinde ise 1 değerini yazacaktır.</p><p>[Switch ayarları ekran görüntüsü]</p><p>Switch’i kaydettikten sonra FUXA’nın çalışma ekranında kontrol elemanının görüntülendiğini gördük.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/727/1*qq64_CccGSAkX2EwXmmN4w.png" /></figure><h3>FUXA → OpenPLC Yazma İşleminin Doğrulanması</h3><p>FUXA çalışma ekranında oluşturduğumuz Switch’i aktif hale getirdik.</p><p>Bunun sonucunda:</p><pre>Motor_Command = 1</pre><p>değerinin OpenPLC’ye Modbus TCP üzerinden gönderilmesini bekledik.</p><p>Yazma işleminin gerçekten PLC’ye ulaştığını doğrulamak için Kali Linux üzerinden mbpoll kullanarak ilgili Coil değerlerini tekrar okuduk:</p><pre>mbpoll -m tcp -a 1 -t 0 -r 1 -c 4 192.168.56.20</pre><p>Elde edilen sonuç:</p><pre>[1]: 1<br>[2]: 0<br>[3]: 0<br>[4]: 1</pre><p>şeklinde oldu.</p><p>Burada:</p><pre>[1] → Motor_Command = 1<br>[4] → Motor = 1</pre><p>olarak görülmektedir.</p><p>Motor_Command değerinin 1 olması FUXA üzerinden gerçekleştirilen yazma işleminin OpenPLC&#39;ye ulaştığını gösterirken, Motor değerinin de 1 olması PLC programındaki kontrol mantığının komutu işlediğini göstermektedir.</p><p>Böylece FUXA ile OpenPLC arasındaki haberleşmeyi yalnızca <strong>okuma</strong> seviyesinde değil, <strong>yazma ve PLC kontrol mantığının çalıştırılması</strong> seviyesinde de doğrulamış olduk.</p><pre>FUXA SCADA<br>     |<br>     | Motor_Command = 1<br>     ▼<br>Modbus TCP<br>     |<br>     ▼<br>OpenPLC<br>     |<br>     | PLC Logic<br>     ▼<br>Motor = 1</pre><p>Bu test ile birlikte laboratuvarımızdaki temel <strong>SCADA → PLC → Proses</strong> iletişim akışı uçtan uca doğrulanmış oldu.</p><h3>SCADA Kontrol Yapısının Tamamlanması</h3><p>Motor kontrolünün FUXA üzerinden başarıyla doğrulanmasının ardından, aynı yapı kullanılarak diğer proses kontrol değişkenleri için de HMI kontrolleri oluşturuldu.</p><p>FUXA MainView üzerinde oluşturulan kontrol yapısı:</p><pre>| HMI Kontrolü | PLC Tag | Modbus Alanı | Görevi |<br>|---|---|---|---|<br>| Motor Switch | `Motor_Command` | Coil `1` | Motor komutu |<br>| Pump Switch | `Pump_Command` | Coil `2` | Pompa komutu |<br>| Valve Switch | `Valve_Command` | Coil `3` | Vana komutu |</pre><p>Bu noktada SCADA ekranı üzerinden PLC’ye gönderilecek temel proses komutları tamamlanmış oldu.</p><p>PLC tarafından üretilen durum ve proses değerleri ise FUXA tarafında daha önce oluşturduğumuz Tag’ler üzerinden izlenmektedir:</p><pre>| PLC Değişkeni | Modbus Alanı | FUXA Tipi |<br>|---|---|---|<br>| `Motor` | Coil `4` | `Bool` |<br>| `Pump` | Coil `5` | `Bool` |<br>| `Valve` | Coil `6` | `Bool` |<br>| `Alarm` | Coil `7` | `Bool` |<br>| `Tank_Level` | Holding Register `400001` | `Int16` |<br>| `Temperature` | Holding Register `400002` | `Int16` |</pre><p>Böylece FUXA tarafında <strong>komut değişkenleri ile PLC tarafından üretilen durum/proses değişkenlerini birbirinden ayıran</strong> temel bir SCADA yapısı oluşturuldu.</p><h3>Uçtan Uca Proses Kontrollerinin Doğrulanması</h3><p>SCADA kontrol yapısının tamamlanmasının ardından, FUXA üzerinden gönderilen komutların OpenPLC tarafından doğru şekilde işlenip işlenmediğini ve PLC kontrol mantığının proses değişkenleri üzerindeki etkisini test ettik.</p><p>Testler sırasında FUXA üzerinden motor, pompa ve vana komutları kontrol edilirken, oluşan durum değişiklikleri FUXA üzerindeki Tag değerlerinden ve Kali Linux üzerinden gerçekleştirilen Modbus TCP okumalarından doğrulandı.</p><p>İlk olarak motor komutu test edildi. Motor_Command değeri 1 yapıldığında PLC tarafından üretilen Motor değerinin de 1 olduğu görüldü. Böylece FUXA üzerinden gönderilen komutun PLC kontrol mantığı tarafından işlendiği doğrulandı.</p><p>Pompa testi sırasında motor aktif durumda tutuldu ve Pump_Command değeri 1 yapıldı. Bunun sonucunda Pump değeri aktif hale gelirken Tank_Level değerinin artarak 1000 seviyesine ulaştığı ve Temperature değerinin 80 seviyesine yükseldiği gözlemlendi.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Fl23u9MoJ_H__x0DKBDqPA.png" /></figure><p>Vana testinde ise motor ve pompa kapalı tutuldu ve yalnızca Valve_Command aktif hale getirildi. Bu durumda Valve değeri 1 olurken Tank_Level değerinin kademeli olarak azalarak 0 seviyesine ulaştığı doğrulandı.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/861/1*C1PN1YavpoJWB_JbR2fzkQ.png" /></figure><p>Son olarak alarm mekanizması test edildi. PLC programındaki kontrol mantığına göre Tank_Level değeri 800 veya üzerinde olduğunda Alarm değeri 1 olmakta, değer 800 seviyesinin altına düştüğünde ise Alarm tekrar 0 olmaktadır. Yapılan testlerde her iki durum da doğrulandı.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LVm-lhImhPkB420Qh7JQmw.png" /><figcaption>Tank Level &gt; 800 Alarm 1</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QxLYR538NMG8mwzQsf4yzQ.png" /><figcaption>Tank Level &lt; 800 Alarm 0</figcaption></figure><p>Test sonuçlarını özetlersek:</p><pre>| Test | Beklenen Davranış | Sonuç |<br>|---|---|---|<br>| Motor kontrolü | `Motor_Command = 1` → `Motor = 1` | Başarılı |<br>| Pompa kontrolü | `Pump_Command = 1` → `Pump = 1` ve `Tank_Level` artışı | Başarılı |<br>| Vana kontrolü | `Valve_Command = 1` → `Valve = 1` ve `Tank_Level` azalışı | Başarılı |<br>| Temperature | Motor aktifken sıcaklığın yükselmesi | Başarılı |<br>| Alarm aktivasyonu | `Tank_Level &gt;= 800` → `Alarm = 1` | Başarılı |<br>| Alarm reset | `Tank_Level &lt; 800` → `Alarm = 0` | Başarılı |</pre><p>Bu testlerle birlikte FUXA üzerinden oluşturduğumuz SCADA kontrol yapısının OpenPLC ile haberleştiği ve PLC’nin aldığı komutları kendi kontrol mantığı üzerinden işleyerek proses değişkenlerini değiştirdiği doğrulanmış oldu.</p><p>Aynı zamanda FUXA’da görüntülenen değerlerin Kali Linux üzerinden mbpoll ile gerçekleştirilen Modbus TCP okumalarıyla karşılaştırılması, SCADA katmanı ile PLC arasındaki veri akışının tutarlı olduğunu gösterdi.</p><p>Sonuç olarak laboratuvarımızdaki temel iletişim ve kontrol zinciri:</p><pre>FUXA SCADA<br>     |<br>     | Modbus TCP<br>     ▼<br>OpenPLC Runtime<br>     |<br>     ▼<br>PLC Control Logic<br>     |<br>     ▼<br>Process Variables<br>     |<br>     ├── Motor<br>     ├── Pump<br>     ├── Valve<br>     ├── Tank_Level<br>     ├── Temperature<br>     └── Alarm</pre><p>şeklinde uçtan uca doğrulanmış oldu.</p><h3>Sonuç</h3><p>Böylece laboratuvarımızdaki <strong>SCADA → PLC → Proses</strong> iletişim ve kontrol zinciri uçtan uca doğrulanmış oldu.</p><p>Bir sonraki bölümde bu yapıyı saldırgan perspektifiyle ele alarak <strong>OT/ICS pentest aşamasına</strong> geçeceğiz.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d3fbdcc3aff2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[EKS/ICS Pentest Labı — Bölüm 4: OpenPLC Kurulumu ve PLC Ortamının Hazırlanması]]></title>
            <link>https://sefayildirimmm.medium.com/eks-ics-pentest-lab%C4%B1-b%C3%B6l%C3%BCm-4-openplc-kurulumu-ve-plc-ortam%C4%B1n%C4%B1n-haz%C4%B1rlanmas%C4%B1-de111e0e2f09?source=rss-1f1223b3b46d------2</link>
            <guid isPermaLink="false">https://medium.com/p/de111e0e2f09</guid>
            <category><![CDATA[ics-security]]></category>
            <category><![CDATA[scada]]></category>
            <category><![CDATA[plc]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[penetration-testing]]></category>
            <dc:creator><![CDATA[Sefa Yıldırım]]></dc:creator>
            <pubDate>Fri, 25 Sep 2026 18:37:08 GMT</pubDate>
            <atom:updated>2026-09-26T15:05:50.605Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SrFJBdcfFENUPSjUgGwGDA.png" /></figure><p>Bir önceki bölümde OT Server üzerinde Docker ortamını kurmuş ve Docker üzerinde FUXA SCADA’yı çalıştırmıştık.</p><p>Bu bölümde ise labımıza PLC katmanını ekleyeceğiz.</p><p>PLC tarafını simüle etmek için <strong>OpenPLC Runtime v3</strong> kullanacağız. OpenPLC’yi Docker üzerinde çalıştırarak OT Server içerisinde sanal bir PLC ortamı oluşturacağız.</p><p>Bölümün sonunda hedeflediğimiz yapı:</p><pre>                         ICS / OT LAB<br>                              |<br>                       Host-Only Network<br>                       192.168.56.0/24<br>                              |<br>                 +------------+------------+<br>                 |                         |<br>            Kali Linux                 OT Server<br>         192.168.56.102             192.168.56.20<br>                 |                         |<br>                 |                    Docker Environment<br>                 |                         |<br>                 |                    +----+----+<br>                 |                    |         |<br>                 |                  FUXA    OpenPLC<br>                 |                 SCADA    Runtime v3<br>                 |                             |<br>                 |                         Modbus TCP<br>                 |                          502/TCP<br>                 |                             |<br>                 +-----------------------------+<br>                       Test / Yönetim</pre><p>Bu bölümde ilk olarak OpenPLC Docker image’ını oluşturup çalıştıracağız. Daha sonraki aşamada OpenPLC web arayüzünü kontrol edecek, PLC runtime’ın çalıştığını doğrulayacak ve ardından <strong>Modbus TCP</strong> tarafına geçeceğiz.</p><p>OpenPLC v3&#39;ü Docker üzerinde çalıştıracağımız için önce OpenPLC v3 kaynak kodunu OT Server’a indireceğiz.</p><p>OT Server üzerinde çalışma dizini oluşturuyorum:</p><pre>mkdir -p ~/ics-lab<br>cd ~/ics-lab</pre><p>Ardından OpenPLC v3 repository’sini klonluyorum:</p><pre>git clone https://github.com/thiagoralves/OpenPLC_v3.git</pre><p>OpenPLC v3&#39;ün resmi repository’sinde Docker kurulumu için repository’nin klonlanması ve ardından Docker image’ının oluşturulması öneriliyor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/742/1*F0ZbIu07Kkkc16CenjWbKg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/871/1*yV-jAXG1a9yYWRL6HmCHfg.png" /></figure><h3>Docker Image’ının Oluşturulması</h3><p>OpenPLC kaynak kodlarının OT Server’a aktarılmasının ardından repository içerisinde bulunan Dockerfile dosyasını kullanarak OpenPLC Runtime için Docker image&#39;ı oluşturacağız.</p><p>OpenPLC v3&#39;ün Docker kurulumunda install.sh scriptini doğrudan host işletim sistemi üzerinde çalıştırmak yerine, repository içerisinde bulunan Dockerfile üzerinden Docker image&#39;ı oluşturulmaktadır. Dockerfile içerisinde install.sh docker parametresi kullanılarak OpenPLC&#39;nin gerekli bağımlılıkları container içerisinde kurulmaktadır.</p><p>Image oluşturma işlemi için:</p><pre>docker build -t openplc:v3 .</pre><p>komutunu kullanacağız.</p><p>Buradaki:</p><ul><li>docker build → Docker image oluşturma işlemini başlatır.</li><li>-t openplc:v3 → oluşturulacak image&#39;a openplc:v3 adını verir.</li><li>. → build context olarak mevcut OpenPLC_v3 dizinini kullanır.</li></ul><p>Build işlemi tamamlandıktan sonra image’ın oluşturulduğunu:</p><pre>docker images</pre><p>komutuyla doğrulayabiliriz.</p><p>Image başarıyla oluşturulduktan sonra OpenPLC Runtime’ı container olarak çalıştıracağız:</p><pre>docker run -it --rm --privileged -p 8080:8080 openplc:v3</pre><p>Bu komutta 8080:8080 port eşlemesi ile OT Server üzerindeki 8080/TCP portu container içerisindeki OpenPLC Web arayüzüne yönlendirilir. --privileged parametresi ise OpenPLC&#39;nin donanım erişimi gerektiren kullanım senaryoları için gerekli yetkileri sağlar. OpenPLC v3&#39;ün resmi Docker kurulum dokümantasyonunda da bu çalışma yöntemi gösterilmektedir</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZIEAMdXVt3-7WiXy_fO6Sg.png" /></figure><p>Görüldüğü üzere Docker build işlemi başarıyla tamamlanmış ve openplc:v3 image&#39;ı oluşturulmuştur.</p><p>Build işleminin tamamlanmasının ardından oluşturulan Docker image’larını kontrol ediyoruz:</p><pre>sudo docker images</pre><p>Çıktıda openplc:v3 image&#39;ının başarıyla oluşturulduğu görülmektedir. Image yaklaşık 1.62 GB boyutundadır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/709/1*aNEvgtvS_Zo2uaS6OYJyNA.png" /></figure><h3>OpenPLC Container’ının Çalıştırılması</h3><p>Docker image’ının başarıyla oluşturulmasının ardından OpenPLC Runtime’ı container olarak çalıştırıyoruz:</p><pre>sudo docker run -it --rm --privileged -p 8080:8080 openplc:v3</pre><p>Container başlatıldığında OpenPLC’nin web sunucusunun 8080/TCP portunda dinlemeye başladığı görülmektedir:</p><pre>* Running on all addresses (0.0.0.0)<br>* Running on http://127.0.0.1:8080<br>* Running on http://172.17.0.3:8080</pre><p>OpenPLC ayrıca başlangıç sırasında HTTPS için self-signed bir sertifika oluşturarak 8443/TCP üzerinde HTTPS servisini başlatmaktadır.</p><p>Bu aşamada Docker port mapping’i yalnızca 8080:8080 olarak tanımlandığı için OT Server üzerinden OpenPLC Web arayüzüne HTTP üzerinden erişeceğiz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*piQqAGXiXItw7qAMtMcZ4A.png" /></figure><h3>OpenPLC Web Arayüzünün Doğrulanması</h3><p>Container’ın çalışmasının ardından OpenPLC Webserver’a erişimi, lab ortamında saldırı/test makinesi olarak kullandığımız Kali Linux üzerinden doğruluyoruz.</p><p>Kali Linux üzerinde tarayıcıdan aşağıdaki adrese erişiyoruz:</p><pre>http://192.168.56.20:8080</pre><p>OpenPLC login ekranının başarıyla görüntülenmesiyle birlikte Kali Linux ile OT Server arasındaki ağ bağlantısının ve Docker üzerindeki 8080/TCP port yönlendirmesinin çalıştığını doğrulamış oluyoruz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GnFmowp_x7yWeLB1Mxxe9Q.png" /><figcaption>Kali Linux üzerinden OT Server üzerindeki OpenPLC Webserver’a erişim.</figcaption></figure><p>Bu aşamada OpenPLC Runtime’ın Docker container içerisinde başarıyla çalıştığını ve Kali Linux üzerinden OT Server’ın 8080/TCP portu aracılığıyla erişilebilir olduğunu doğrulamış olduk.</p><h3>PLC Programının Oluşturulması</h3><p>OpenPLC Runtime’ın çalıştığını doğruladıktan sonra sıradaki adım, PLC üzerinde çalışacak olan proses simülasyonunu oluşturmaktı.</p><p>Bu bölümde gerçek bir fiziksel PLC veya saha ekipmanı kullanmak yerine, laboratuvar ortamında temel bir endüstriyel proses senaryosu simüle edeceğiz.</p><p>Senaryomuzda;</p><ul><li>Motor</li><li>Pompa</li><li>Vana</li><li>Tank seviyesi</li><li>Sıcaklık</li><li>Alarm</li></ul><p>değişkenleri bulunacak.</p><p>Bu yapı sayesinde ilerleyen bölümlerde yalnızca PLC’nin çalışmasını değil, aynı zamanda <strong>Modbus TCP üzerinden PLC değişkenlerinin okunmasını ve değiştirilmesini</strong> de test edebileceğiz.</p><h3>OpenPLC Editor’ın Kurulması</h3><p>PLC programını oluşturmak için OpenPLC Editor kullanıldı.</p><p>Bu laboratuvar ortamında OpenPLC Editor’ın güncel sürümü olan <strong>4.2.3</strong> kullanıldı.</p><p>Editor üzerinden yeni bir PLC projesi oluşturuldu.</p><p>Proje adı:</p><pre>ICS_Process_Lab</pre><p>Proje dizini:</p><pre>/home/kali/ics-lab/ICS_Process_Lab</pre><p>Programlama dili olarak ise <strong>Structured Text (ST)</strong> tercih edildi.</p><p>Structured Text, IEC 61131–3 kapsamında kullanılan PLC programlama dillerinden biridir ve özellikle koşullu ifadeler, matematiksel işlemler ve proses mantığının oluşturulması açısından oldukça kullanışlıdır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7NHcJe1XDVFV8SSnOPdVhg.png" /></figure><h3>PLC Değişkenlerinin Tanımlanması</h3><p>İlk olarak proses içerisinde kullanacağımız değişkenleri tanımladık.</p><pre>VAR<br>    Motor_Command : BOOL := FALSE;<br>    Pump_Command : BOOL := FALSE;<br>    Valve_Command : BOOL := FALSE;<br><br>    Motor : BOOL := FALSE;<br>    Pump : BOOL := FALSE;<br>    Valve : BOOL := FALSE;<br>    Alarm : BOOL := FALSE;<br>    Tank_Level : INT := 500;<br>    Temperature : INT := 25;<br>END_VAR</pre><p>Burada değişkenleri iki temel gruba ayırabiliriz.</p><h3>Komut değişkenleri</h3><pre>Motor_Command<br>Pump_Command<br>Valve_Command</pre><p>Bu değişkenler dışarıdan PLC’ye gönderilecek kontrol komutlarını temsil ediyor.</p><p>Örneğin:</p><pre>Motor_Command = TRUE</pre><p>olduğunda motorun çalışması isteniyor.</p><h3>Proses değişkenleri</h3><pre>Motor<br>Pump<br>Valve<br>Alarm<br>Tank_Level<br>Temperature</pre><p>Bu değişkenler ise PLC içerisindeki gerçek proses durumunu temsil ediyor.</p><p>Örneğin motor komutu verilse bile motorun gerçekten çalışıp çalışmadığını ayrıca Motor değişkeni üzerinden takip ediyoruz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MbL9cW61RuIqf8CXASIcpQ.png" /></figure><h3>PLC Kontrol Mantığının Oluşturulması</h3><p>Değişkenleri tanımladıktan sonra prosesin kontrol mantığını oluşturduk.</p><p>Motor için temel mantığımız:</p><pre>Motor := Motor_Command;</pre><p>şeklinde.</p><p>Yani motor komutu aktif olduğunda motor çalışıyor.</p><p>Pompa için ise bir bağımlılık ekledik:</p><pre>Pump := Pump_Command AND Motor;</pre><p>Buradaki amaç, pompanın yalnızca motor çalışırken devreye girmesini sağlamak.</p><p>Dolayısıyla:</p><pre>Motor = FALSE<br>Pump_Command = TRUE</pre><p>olsa bile:</p><pre>Pump = FALSE</pre><p>olacaktır.</p><p>Vana ise doğrudan kendi komutuna bağlı:</p><pre>Valve := Valve_Command;</pre><p>Bu yapı gerçek endüstriyel sistemlerde karşılaşabileceğimiz interlock mantığının oldukça basitleştirilmiş bir simülasyonunu oluşturuyor.</p><h3>Tank Seviyesi Simülasyonu</h3><p>Tank seviyesini simüle etmek için Tank_Level isimli integer değişkenini kullandık.</p><p>Başlangıç değeri:</p><pre>500</pre><p>olarak belirlendi.</p><p>Pompa çalıştığında tank seviyesinin artmasını sağladık:</p><pre>IF Pump THEN<br>    IF Tank_Level &lt; 1000 THEN<br>        Tank_Level := Tank_Level + 1;<br>    END_IF;<br>END_IF;</pre><p>Burada tank seviyesinin maksimum:</p><pre>1000</pre><p>olmasını sağlıyoruz.</p><p>Pompa çalıştığı sürece:</p><pre>Tank_Level + 1</pre><p>şeklinde artış gerçekleşiyor.</p><p>Vana açıldığında ise tank seviyesini azaltıyoruz:</p><pre>IF Valve THEN<br>    IF Tank_Level &gt; 0 THEN<br>        Tank_Level := Tank_Level - 1;<br>    END_IF;<br>END_IF;</pre><p>Bu şekilde basitleştirilmiş bir tank dolum/boşaltım prosesi oluşturmuş olduk.</p><h3>Alarm ve Sıcaklık Simülasyonu</h3><p>Tank seviyesi belirli bir değerin üzerine çıktığında alarm oluşturmak için:</p><pre>IF Tank_Level &gt;= 800 THEN<br>    Alarm := TRUE;<br>ELSE<br>    Alarm := FALSE;<br>END_IF;</pre><p>mantığını kullandık.</p><p>Buna göre:</p><pre>Tank_Level &lt; 800</pre><p>durumunda alarm pasif.</p><pre>Tank_Level &gt;= 800</pre><p>durumunda ise alarm aktif olacaktır.</p><p>Ayrıca motorun çalışmasına bağlı basit bir sıcaklık simülasyonu da ekledik:</p><pre>IF Motor THEN<br>    IF Temperature &lt; 80 THEN<br>        Temperature := Temperature + 1;<br>    END_IF;<br>ELSE<br>    IF Temperature &gt; 25 THEN<br>        Temperature := Temperature - 1;<br>    END_IF;<br>END_IF;</pre><p>Motor çalışırken sıcaklık artıyor, motor durduğunda ise sıcaklık tekrar başlangıç değeri olan 25 seviyesine doğru düşüyor.</p><p>Böylece PLC içerisinde yalnızca dijital sinyalleri değil, aynı zamanda analog karakterli proses değerlerini de simüle etmiş olduk.</p><h3>PLC Programının Derlenmesi</h3><p>PLC programı hazırlandıktan sonra OpenPLC Editor üzerinden <strong>Build</strong> işlemi gerçekleştirildi.</p><p>Derleme sonucunda Structured Text kodunun OpenPLC Runtime tarafından kullanılabilecek çıktıları oluşturuldu.</p><p>Derleme sırasında:</p><pre>Saving ST file...<br>Parsing complex variables...<br>ST file generated at:<br>/home/kali/ics-lab/ICS_Process_Lab/build/OpenPLC Runtime v3/src/program.st<br><br>Compiling Structured Text to C++ with StrucC++...<br>Debug map...<br>Compile only mode...<br>Compilation complete</pre><p>çıktıları alındı.</p><p>Burada özellikle program.st dosyasının oluşturulması, hazırladığımız Structured Text programının derleme sürecinin başarıyla tamamlandığını gösteriyor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-HMB07CDQ-FCeCiI6Y2yRA.png" /></figure><h3>PLC Programının OpenPLC Runtime’a Yüklenmesi</h3><p>Derleme işlemi tamamlandıktan sonra oluşturulan PLC programı OpenPLC Web arayüzü üzerinden Runtime’a yüklendi.</p><p>Kali Linux üzerinden:</p><pre>http://192.168.56.20:8080</pre><p>adresine erişerek OpenPLC Web arayüzünü açtık.</p><p>Program yükleme ekranında aşağıdaki bilgiler kullanıldı:</p><pre>Program Name:<br>ICS Process Simulator v1.0</pre><p>Açıklama:</p><pre>ICS/OT lab ortamında Motor, Pump, Valve, Tank Level,<br>Temperature ve Alarm kontrolünü simüle eden PLC programı.</pre><p>Programın yüklenmesi ve derlenmesi sırasında OpenPLC tarafından:</p><pre>Generating C files...<br>POUS.c<br>POUS.h<br>LOCATED_VARIABLES.h<br>VARIABLES.csv<br>Config0.c<br>Config0.h<br>Res0.c<br>Including Siemens S7 Protocol via snap7<br>Moving Files...<br>Compiling for Linux<br>Generating object files...<br>Generating glueVars...<br>Compiling main program...<br>Compilation finished successfully!</pre><p>çıktıları üretildi.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*05EpYp4NBH257arCxk5rZw.png" /></figure><p>Bu çıktı, PLC programının OpenPLC Runtime tarafından başarıyla derlendiğini gösteriyor.</p><h3>OpenPLC Runtime’ın Çalıştırılması</h3><p>Programın yüklenmesinden sonra OpenPLC Runtime başlatıldı.</p><p>Dashboard üzerinde:</p><pre>Status: Running<br>Program: ICS Process Simulator v1.0</pre><p>bilgileri görüntülendi.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fCMLNhZ5snJSw4L34_OM4w.png" /></figure><p>Runtime loglarında ayrıca Modbus TCP servisinin 502/TCP portunda başlatıldığı görüldü:</p><pre>Issued start_modbus() command to start on port: 502<br>Server: Listening on port 502<br>Server: waiting for new client...</pre><p>Bunun yanında OpenPLC Runtime’ın farklı endüstriyel protokoller için de servisleri başlattığı görülebiliyor.</p><p>Bu aşamada bizim için kritik olan servis:</p><pre>Modbus TCP → TCP/502</pre><p>oldu.</p><h3>PLC Değişkenlerinin Modbus Adreslerine Eşlenmesi</h3><p>PLC programımız çalışmaya başladıktan sonra değişkenlerin Modbus üzerinden erişilebilir hale gelmesi için OpenPLC içerisindeki değişken adreslerini kontrol ettik.</p><p>Laboratuvar ortamında kullandığımız eşleşme aşağıdaki şekilde oluştu:</p><p>+ — — — — — — — -+ — — — + — — — — — +<br>| Değişken | Tip | Location |<br>+ — — — — — — — -+ — — — + — — — — — +<br>| Motor_Command | BOOL | %QX0.0 |<br>| Pump_Command | BOOL | %QX0.1 |<br>| Valve_Command | BOOL | %QX0.2 |<br>| Motor | BOOL | %QX0.3 |<br>| Pump | BOOL | %QX0.4 |<br>| Valve | BOOL | %QX0.5 |<br>| Alarm | BOOL | %QX0.6 |<br>| Tank_Level | INT | %QW0 |<br>| Temperature | INT | %QW1 |<br>+ — — — — — — — -+ — — — + — — — — — +</p><p>Bu mapping sayesinde daha sonra Kali Linux üzerinden Modbus TCP kullanarak PLC’nin hem dijital hem de sayısal proses değerlerini okuyup değiştirebileceğiz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xrgCR-iVUsEC0COCLRiq2A.png" /></figure><h3>Modbus TCP Servisinin Doğrulanması</h3><p>PLC programının çalışmasıyla birlikte 502/TCP portunun da erişilebilir olması gerekiyordu.</p><p>Kali Linux üzerinden aşağıdaki Nmap komutunu çalıştırdık:</p><pre>nmap -Pn -p 502 192.168.56.20</pre><p>Sonuç:</p><pre>PORT    STATE SERVICE<br>502/tcp open  mbap</pre><p>Burada 502/TCP portunun open olarak görünmesi, OT Server üzerindeki OpenPLC Runtime&#39;ın Modbus TCP bağlantılarını kabul ettiğini gösteriyor.</p><p>Bu noktadan sonra artık yalnızca port seviyesinde bir erişim testi yapmak yerine, gerçek Modbus istekleri göndererek PLC ile haberleşmeyi test edebiliriz.</p><h3>Kali Linux Üzerinden Modbus TCP Testi</h3><p>Modbus TCP testleri için Kali Linux üzerinde mbpoll aracını kullandık.</p><p>Kurulum:</p><pre>sudo apt update<br>sudo apt install -y mbpoll</pre><p>Kurulum tamamlandıktan sonra ilk olarak PLC içerisindeki holding register değerlerini okumayı denedik.</p><pre>mbpoll -m tcp -a 1 -r 1 -c 2 192.168.56.20</pre><p>Buradaki parametreler:</p><pre>-m tcp   → Modbus TCP<br>-a 1     → Slave/Unit ID<br>-r 1     → Başlangıç register adresi<br>-c 2     → 2 register oku</pre><p>şeklinde kullanıldı.</p><p>PLC’nin başlangıç değerleri:</p><pre>Tank_Level  = 500<br>Temperature = 25</pre><p>olarak okunabildi.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/769/1*bai2rCOUYiynmX3Yx-3Tjg.png" /></figure><p>Bu test ile birlikte PLC programındaki proses değişkenlerinin Modbus TCP üzerinden gerçekten erişilebilir olduğunu doğrulamış olduk.</p><h3>Modbus Coil Alanlarının Test Edilmesi</h3><p>Dijital değişkenleri kontrol etmek için Modbus coil alanını test ettik.</p><p>İlk olarak 7 coil değerini okuduk:</p><pre>mbpoll -m tcp -a 1 -t 0 -r 1 -c 7 192.168.56.20</pre><p>Başlangıç durumunda bütün değerler 0 olarak görülüyordu:</p><pre>[1]: 0   Motor_Command<br>[2]: 0   Pump_Command<br>[3]: 0   Valve_Command<br>[4]: 0   Motor<br>[5]: 0   Pump<br>[6]: 0   Valve<br>[7]: 0   Alarm</pre><p>Bu durum PLC’nin başlangıçta herhangi bir kontrol komutunun aktif olmadığını gösteriyor.</p><h3>Modbus Üzerinden PLC Komutunun Değiştirilmesi</h3><p>Bir sonraki adımda yalnızca veri okumak yerine Modbus TCP üzerinden PLC’ye komut göndermeyi test ettik.</p><p>İlk olarak Motor_Command değişkenini aktif hale getirdik:</p><pre>mbpoll -m tcp -a 1 -t 0 -r 1 192.168.56.20 1</pre><p>Komut sonucunda:</p><pre>Written 1 references.</pre><p>çıktısı alındı.</p><p>Ardından coil değerlerini tekrar okuduk:</p><pre>mbpoll -m tcp -a 1 -t 0 -r 1 -c 7 192.168.56.20</pre><p>Sonuçta:</p><pre>[1]: 1   Motor_Command<br>[2]: 0   Pump_Command<br>[3]: 0   Valve_Command<br>[4]: 1   Motor<br>[5]: 0   Pump<br>[6]: 0   Valve<br>[7]: 0   Alarm</pre><p>değerleri görüldü.</p><p>Burada önemli olan nokta, Modbus üzerinden yalnızca Motor_Command değerinin değiştirilmiş olması ancak PLC programının kendi kontrol mantığı doğrultusunda Motor değişkenini de aktif hale getirmesidir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/970/1*rdEssQO41xsErToEQWWt6g.png" /></figure><p>Bu test, Modbus TCP üzerinden gönderilen bir değerin PLC programının içerisindeki kontrol mantığını etkileyebildiğini göstermiş oldu.</p><h3>Pompa ve Tank Prosesinin Test Edilmesi</h3><p>Motor çalışır durumdayken pompa komutunu aktif hale getirdik:</p><pre>mbpoll -m tcp -a 1 -t 0 -r 2 192.168.56.20 1</pre><p>PLC mantığımız:</p><pre>Pump := Pump_Command AND Motor;</pre><p>şeklinde olduğu için hem Pump_Command hem de Motor aktif olduğunda pompa da aktif hale geldi.</p><p>Bu durumda tank seviyesi zaman içerisinde yükselmeye başladı.</p><p>Bir süre sonra holding register değerlerini tekrar okuduk:</p><pre>mbpoll -m tcp -a 1 -t 4 -r 1 -c 2 -1 192.168.56.20</pre><p>Sonuç:</p><pre>[1]: 1000<br>[2]: 80</pre><p>Burada:</p><pre>Tank_Level  = 1000<br>Temperature = 80</pre><p>değerlerini görüyoruz.</p><p>Tank seviyesinin 1000 değerine ulaşması, oluşturduğumuz maksimum tank seviyesi sınırının çalıştığını gösteriyor.</p><p>Aynı zamanda motor çalıştığı için sıcaklık simülasyonu da 80 seviyesine kadar yükselmiş durumda.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/864/1*wchFqgfjaQB9aREMKX20oQ.png" /></figure><h3>Tank Alarmının Tetiklenmesi</h3><p>Tank seviyesi:</p><pre>1000</pre><p>olduğunda daha önce tanımladığımız alarm koşulu da sağlanmış oluyor:</p><pre>IF Tank_Level &gt;= 800 THEN<br>    Alarm := TRUE;<br>ELSE<br>    Alarm := FALSE;<br>END_IF;</pre><p>Dolayısıyla coil değerlerini tekrar okuduğumuzda Alarm değişkeninin aktif hale geldiğini görebiliyoruz.</p><p>Bu küçük simülasyon, ilerleyen bölümlerde güvenlik testleri açısından önemli olacak bir yapı oluşturuyor.</p><p>Çünkü gerçek OT/ICS ortamlarında PLC içerisindeki proses değişkenlerinin değiştirilmesi yalnızca bir veri değişikliği değildir. Proses mantığına bağlı olarak başka ekipmanların veya alarm mekanizmalarının da tetiklenmesine neden olabilir.</p><h3>Vana ile Prosesin Tersine Çevrilmesi</h3><p>Tankı tekrar boşaltmak için önce pompayı kapattık:</p><pre>mbpoll -m tcp -a 1 -t 0 -r 2 192.168.56.20 0</pre><p>Ardından vana komutunu aktif hale getirdik:</p><pre>mbpoll -m tcp -a 1 -t 0 -r 3 192.168.56.20 1</pre><p>Vana aktif hale geldikten sonra tank seviyesinin düşmeye başladığını gözlemledik.</p><p>Bir süre sonra holding register değerleri tekrar okundu:</p><pre>[1]: 0<br>[2]: 80</pre><p>Yani:</p><pre>Tank_Level  = 0<br>Temperature = 80</pre><p>seviyesine ulaşıldı.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/790/1*z0Oi28rty8zHOppAdJjCZQ.png" /></figure><p>Bu test ile birlikte PLC içerisindeki proses simülasyonunun yalnızca statik değerlerden oluşmadığını, Modbus üzerinden verilen komutlara bağlı olarak dinamik şekilde değiştiğini doğrulamış olduk.</p><h3>PLC’nin Güvenli Duruma Alınması</h3><p>Testler tamamlandıktan sonra önce vana, ardından motor komutlarını pasif hale getirdik:</p><pre>mbpoll -m tcp -a 1 -t 0 -r 3 192.168.56.20 0</pre><p>ve:</p><pre>mbpoll -m tcp -a 1 -t 0 -r 1 192.168.56.20 0</pre><p>Son durumda PLC coil değerleri tekrar okunduğunda bütün kontrol ve proses çıkışlarının pasif duruma geçtiği görüldü:</p><pre>[1]: 0<br>[2]: 0<br>[3]: 0<br>[4]: 0<br>[5]: 0<br>[6]: 0<br>[7]: 0</pre><p>Bu şekilde test senaryosunu başlangıçta olduğu gibi güvenli/pasif durumda sonlandırdık.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/867/1*BBzDJIQvo6lUjqvQw2hnlA.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=de111e0e2f09" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[EKS/ICS Pentest Labı — Bölüm 3: Docker ve FUXA/SCADA Kurulumu]]></title>
            <link>https://sefayildirimmm.medium.com/eks-ics-pentest-lab%C4%B1-b%C3%B6l%C3%BCm-3-docker-ve-fuxa-scada-kurulumu-f9c803f122dc?source=rss-1f1223b3b46d------2</link>
            <guid isPermaLink="false">https://medium.com/p/f9c803f122dc</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[ci]]></category>
            <category><![CDATA[penetration-testing]]></category>
            <category><![CDATA[ot-security]]></category>
            <category><![CDATA[scada]]></category>
            <dc:creator><![CDATA[Sefa Yıldırım]]></dc:creator>
            <pubDate>Tue, 22 Sep 2026 15:56:13 GMT</pubDate>
            <atom:updated>2026-09-26T14:55:29.560Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eCe8wNOjMW-YFSJZWolAow.png" /></figure><p>Bir önceki bölümde Ubuntu Server’ı lab ortamımızdaki <strong>OT Server</strong> olarak yapılandırmış ve Kali Linux ile OT Server arasındaki iletişimi test etmiştik.</p><p>Bu bölümde ise OT Server üzerinde Docker ortamını kurarak ilerleyeceğiz. Docker’ın kurulmasının ardından SCADA tarafında kullanacağımız <strong>FUXA</strong> platformunu Docker container olarak çalıştıracağız.</p><p>Bu bölüm boyunca yapılan işlemler tamamen izole lab ortamında gerçekleştirilmektedir. Gerçek üretim sistemleri veya yetkisiz sistemler üzerinde herhangi bir test yapılmamaktadır.</p><p>Bu bölümün temel mimarisi şu şekilde olacaktır:</p><pre>                 Windows Host<br>                      |<br>                 VirtualBox<br>                      |<br>              Host-Only Network<br>              192.168.56.0/24<br>                      |<br>             +--------+--------+<br>             |                 |<br>        Kali Linux          OT Server<br>     192.168.56.102       192.168.56.20<br>             |                 |<br>       Pentest Tools       Docker<br>       Wireshark           FUXA/SCADA<br>       Nmap</pre><p>Ancak Docker ve FUXA kurulumunu gerçekleştirebilmek için OT Server’ın <strong>geçici olarak internet erişimine</strong> ihtiyacı olacak.</p><p>Bu nedenle kuruluma başlamadan önce OT Server’a geçici bir NAT interface ekleyeceğiz.</p><h3>1. OT Server’a Geçici NAT Interface Eklenmesi</h3><p>Lab mimarisinde OT Server’ın normal şartlarda yalnızca Host-Only network üzerinden erişilebilir olmasını istiyoruz.</p><p>Bu nedenle internet erişimini kalıcı olarak OT Server’a vermek yerine, Docker kurulumu ve gerekli paketlerin indirilmesi sırasında kullanılmak üzere <strong>ikinci bir network adapter</strong> ekleyeceğiz.</p><p>VirtualBox üzerinde ICS-OT-Server sanal makinesinin:</p><p><strong>Settings → Network</strong> bölümüne giriyorum.</p><p>Mevcut Adapter 1&#39;i değiştirmeden bırakıyorum.</p><p>Adapter 1:</p><pre>Attached to: Host-only Adapter<br>Name: VirtualBox Host-Only Ethernet Adapter</pre><p>Daha sonra <strong>Adapter 2</strong>&#39;yi etkinleştiriyorum.</p><pre>Enable Network Adapter: ✓<br><br>Attached to:<br>NAT</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/712/1*WMuJxPZcgCVqCab4MB_4aA.png" /></figure><p>Buradaki amaç, OT Server’ın mevcut lab network bağlantısını değiştirmek değil, kurulum sırasında geçici olarak internet erişimi sağlayacak ikinci bir interface oluşturmaktır.</p><p>Bu ayrım önemli. Çünkü ilerleyen aşamalarda OT labımızın tekrar izole hale gelmesini sağlayacağız.</p><h3>2. Ubuntu Server’da Yeni Network Interface’in Kontrol Edilmesi</h3><p>Sanal makineyi başlattıktan sonra Ubuntu Server üzerinde network interface’lerini kontrol ediyorum:</p><pre>ip a</pre><p>Burada daha önce kullandığımız Host-Only interface’in yanında yeni bir interface oluştuğunu görüyoruz.</p><p>Ubuntu tarafında bu interface enp0s8 olarak görülüyor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/876/1*zWp1uarLfiCWvftmsz5yZQ.png" /></figure><p>Interface’in durumunu kontrol ediyorum:</p><pre>ip link</pre><p>Yeni interface’in UP durumda olduğunu kontrol ediyoruz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/910/1*uiWBcMSMTathK4gk378-fg.png" /></figure><p>Bu aşamada artık OT Server üzerinde iki network interface bulunuyor:</p><pre>Host-Only → Lab ağı<br>NAT       → Geçici internet erişimi</pre><p>Burada özellikle dikkat edilmesi gereken nokta, NAT interface’in <strong>lab network’ünün yerine geçmemesi</strong>.</p><h3>3. NAT Interface’in Network Yapılandırması</h3><p>Şimdi Ubuntu Server’ın network yapılandırmasını kontrol ediyorum.</p><p>Ubuntu Server üzerinde Netplan tarafından yönetilen network yapılandırmasını düzenlemek için ilgili YAML dosyasını açıyorum.</p><pre>sudo nano /etc/netplan/50-cloud-init.yaml</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/426/1*uCxIjYdO_8uXgwSTVnLl_A.png" /></figure><p>Buradaki temel amacımız NAT interface’in DHCP üzerinden adres almasını sağlamak.</p><p>Yapılandırmayı kaydettikten sonra Netplan’ı uyguluyorum:</p><pre>sudo netplan apply</pre><p>Ardından network interface’lerini tekrar kontrol ederek NAT interface’in IP adresi alıp almadığını kontrol ediyorum:</p><pre>ip a</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/984/1*OPbkSQBFi8ukwJFxiATM9w.png" /></figure><h3>4. Ubuntu Paket Depolarının Kontrol Edilmesi</h3><p>Docker kurulumuna geçmeden önce Ubuntu’nun paket depolarına erişebildiğimizden emin olmamız gerekiyor.</p><p>İlk olarak:</p><pre>sudo apt update</pre><p>komutunu çalıştırıyorum.</p><p>İlk denemede Ubuntu paket depolarına erişim sırasında timeout problemiyle karşılaşıyorum.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*G8NROx9wHwvSCjxaV-lGzg.png" /></figure><p>Burada önemli olan, problemi hemen Docker kaynaklı olarak değerlendirmemek.</p><p>Öncelikle Ubuntu’nun kullandığı repository adreslerini kontrol ediyorum.</p><h3>5. Ubuntu Repository Yapılandırmasının Kontrolü</h3><p>Ubuntu’nun paket kaynaklarını kontrol etmek için ilgili yapılandırmayı inceliyorum.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/775/1*deh2gVugb0hnuQpSUHc4Uw.png" /></figure><p>Daha sonra repository’lere doğrudan HTTP üzerinden erişimi test ediyorum.</p><pre>curl -I --max-time 10 http://archive.ubuntu.com/ubuntu/</pre><p>Aynı şekilde security repository’sini de kontrol ediyorum:</p><pre>curl -I --max-time 10 http://security.ubuntu.com/ubuntu/</pre><p>Bu testlerde repository sunucularından HTTP yanıtı alabildiğimizi görüyoruz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/913/1*zzoctiw8Uvz2thuz5dkIEA.png" /></figure><p>Bunun ardından tekrar:</p><pre>sudo apt update</pre><p>Çalıştırıyorum.</p><p>Bu kez paket listelerinin başarıyla güncellendiğini görüyoruz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/961/1*s-M-nyJ9-OWekOgMSTZrqg.png" /></figure><p>Bu aşamada Ubuntu’nun paket yönetim sisteminin düzgün şekilde çalıştığını doğrulamış olduk.</p><h3>6. Docker Kurulumu İçin Gerekli Paketlerin Hazırlanması</h3><p>Docker repository’sini eklemeden önce gerekli temel paketleri kontrol ediyorum:</p><pre>sudo apt install ca-certificates curl</pre><p>Sistemde bu paketlerin güncel olduğu görülüyor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/685/1*-eCZkhJTcVyvwY_1G6_-mg.png" /></figure><p>Bu paketler özellikle Docker’ın resmi repository’sine erişim ve repository imza doğrulaması sırasında kullanılacak.</p><h3>7. Docker GPG Anahtarının Eklenmesi</h3><p>Docker paketlerinin resmi repository üzerinden güvenilir şekilde kurulabilmesi için Docker’ın GPG anahtarını sisteme ekliyorum.</p><p>Öncelikle keyrings dizinini oluşturuyorum:</p><pre>sudo install -m 0755 -d /etc/apt/keyrings</pre><p>Ardından Docker’ın GPG anahtarını indiriyorum:</p><pre>sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg \<br>-o /etc/apt/keyrings/docker.asc</pre><p>Anahtarın okunabilir olması için:</p><pre>sudo chmod a+r /etc/apt/keyrings/docker.asc</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*UTOTlMlpSF2F8VEkTFz6vg.png" /></figure><h3>8. Docker Repository’sinin Eklenmesi</h3><p>Şimdi Docker’ın resmi Ubuntu repository’sini APT kaynaklarına ekliyorum.</p><p>Kullandığım komut:</p><pre>echo &quot;deb [arch=amd64 signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu noble stable&quot; | sudo tee /etc/apt/sources.list.d/docker.list</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BsWuekqV681P9FuLtVT1dA.png" /></figure><p>Repository’nin eklenmesinin ardından tekrar:</p><pre>sudo apt update</pre><p>çalıştırıyorum.</p><p>Bu kez Docker repository’sinin de APT tarafından algılandığını görüyoruz:</p><pre>https://download.docker.com/linux/ubuntu noble InRelease</pre><p>ve</p><pre>https://download.docker.com/linux/ubuntu noble/stable amd64 Packages</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/772/1*N5F1VzwV8CEu-VMh_wm_zA.png" /></figure><p>Bu noktada Docker’ın resmi repository’si Ubuntu sistemimize başarıyla eklenmiş durumda.</p><h3>9. Docker’ın Kurulması</h3><p>Docker repository’sini başarıyla ekledikten sonra artık Docker Engine kurulumuna geçebiliriz.</p><p>İlk kurulum denemesinde Docker ile birlikte gerekli paketleri kuruyorum:</p><pre>sudo apt install docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin</pre><p>Kurulum tamamlandıktan sonra Docker servisinin durumunu kontrol ediyorum:</p><pre>sudo systemctl status docker</pre><p>Ancak burada beklemediğimiz bir durumla karşılaşıyoruz:</p><pre>Unit docker.service could not be found.</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/514/1*9RnEy0eTlpERQfCwwI3EJA.png" /></figure><p>Buradaki problemin nedeni, ilk kurulum komutunda <strong>docker-ce paketinin bulunmaması</strong>. Docker CLI, containerd, Buildx ve Compose bileşenleri kurulmuş olsa da Docker Engine&#39;in kendisi kurulmamış durumda.</p><p>Bu nedenle eksik olan Docker Engine paketini ayrıca kuruyorum.</p><pre>sudo apt install docker-ce</pre><p>Kurulum tamamlandıktan sonra Docker servisinin durumunu tekrar kontrol ediyorum:</p><pre>sudo systemctl status docker</pre><p>Bu kez Docker servisinin çalıştığını görüyoruz:</p><pre>Active: active (running)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q5o_01ta19f3VBtMWnJzlQ.png" /></figure><p>Böylece Docker Engine’in OT Server üzerinde başarıyla çalıştığını doğrulamış olduk.</p><h3>10. Docker Kurulumunun Doğrulanması</h3><p>Docker servisinin çalışıyor olması tek başına yeterli değil. Docker Engine’in container çalıştırabildiğini de kontrol etmek istiyorum.</p><p>Öncelikle Docker’ın sistemdeki bilgilerini görüntülüyorum:</p><pre>sudo docker info</pre><p>Çıktıda Docker Server’ın çalıştığını ve sistem bilgilerini görebiliyoruz.</p><p>Örneğin kullanılan işletim sistemi:</p><pre>Ubuntu 24.04.5 LTS</pre><p>Docker Server sürümü:</p><pre>29.8.1</pre><p>ve mimari:</p><pre>x86_64</pre><p>olarak görülüyor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CMTAURbD2e9HstbJ5BrjnQ.png" /></figure><p>Bu aşamada Docker Engine’in düzgün şekilde çalıştığını doğrulamış olduk.</p><h3>11. İlk Docker Container Testi</h3><p>Docker’ın gerçekten container çalıştırabildiğini doğrulamak için Docker’ın test amacıyla sunduğu hello-world image&#39;ını kullanıyorum.</p><p>İlk olarak:</p><pre>sudo docker run hello-world</pre><p>komutunu çalıştırıyorum.</p><p>İlk denemede image lokal sistemde bulunmadığı için Docker image’ı registry üzerinden indirmeye çalışıyor.</p><p>Ancak ilk denemede image’ın indirilmesi sırasında hata ile karşılaşıyoruz.</p><p>Bu aşamada Docker’ın kurulumunun başarısız olduğunu düşünmek yerine image’ın ayrıca indirilmesini deniyorum.</p><pre>sudo docker pull hello-world</pre><p>Image’ın Docker Hub üzerinden başarıyla indirildiğini görüyoruz.</p><p>Çıktının sonunda:</p><pre>Pull complete</pre><p>ve:</p><pre>Status: Downloaded newer image for hello-world:latest</pre><p>ifadelerini görüyoruz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/775/1*sZ0K0CdVG_M1Mfh-0qBAOg.png" /></figure><p>Image artık lokal olarak bulunduğu için tekrar:</p><pre>sudo docker run hello-world</pre><p>komutunu çalıştırıyorum.</p><p>Bu kez container başarıyla çalışıyor ve Docker’ın standart test mesajını alıyoruz:</p><pre>Hello from Docker!</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/841/1*PI9zj94OjX5SMMFIVtfADg.png" /></figure><p>Bu test sonucunda üç önemli noktayı doğrulamış olduk:</p><ul><li>Docker Engine çalışıyor.</li><li>Docker image indirilebiliyor.</li><li>Docker container başarıyla oluşturulup çalıştırılabiliyor.</li></ul><p>Dolayısıyla OT Server üzerinde Docker ortamımızı kullanmaya hazırız.</p><h3>12. Bu Aşamada Labın Durumu</h3><p>Şu ana kadar OT Server üzerinde Docker Engine’i başarıyla kurduk ve temel bir container çalıştırarak Docker ortamını doğruladık.</p><p>Mevcut yapı:</p><pre>VirtualBox<br>                     |<br>          Host-Only Network<br>          192.168.56.0/24<br>                     |<br>             +-------+-------+<br>             |               |<br>        Kali Linux        OT Server<br>     192.168.56.102     192.168.56.20<br>                         |<br>                       Docker<br>                         |<br>                    hello-world</pre><h3>13. FUXA SCADA Kurulumuna Geçiş</h3><p>Docker ortamının çalıştığını doğruladıktan sonra artık OT Server üzerinde SCADA bileşenimizi oluşturmaya geçebiliriz.</p><p>Bu labda SCADA tarafı için <strong>FUXA</strong> kullanacağız.</p><p>FUXA; web tabanlı bir SCADA/HMI geliştirme ortamı olarak kullanılabilen ve Docker container içerisinde çalıştırılabilen açık kaynaklı bir projedir.</p><p>Labımızda FUXA’yı doğrudan Ubuntu Server’a kurmak yerine Docker container olarak çalıştıracağız. Böylece SCADA uygulamasını OT Server üzerindeki Docker ortamından izole bir şekilde yönetebileceğiz.</p><p>Kurulumdan önce Docker’ın FUXA image’ını indireceğiz.</p><h3>14. FUXA Docker Image’ının İndirilmesi</h3><p>Öncelikle FUXA’nın Docker image’ını indiriyorum:</p><pre>sudo docker pull frangoteam/fuxa:latest</pre><p>Bu komut Docker Hub üzerinden FUXA’nın güncel image’ını indirir.</p><p>İndirme sırasında image katmanlarının tek tek sisteme alındığını görebiliriz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/730/1*PXqBJ8s8LEl_SJ9d83pkPw.png" /></figure><h3>15. FUXA Container’ının Oluşturulması</h3><p>Image’ı indirdikten sonra FUXA’yı Docker container olarak çalıştırabiliriz.</p><p>Ancak container’ı oluştururken yalnızca port yönlendirmesi yapmak yerine, FUXA’nın oluşturacağı verilerin container silinse dahi korunabilmesi için <strong>persistent volume</strong> kullanacağız.</p><p>Öncelikle Docker volume oluşturuyorum:</p><pre>sudo docker volume create fuxa-data</pre><p>Ardından FUXA container’ını çalıştırıyorum:</p><pre>sudo docker run -d \<br>  --name fuxa \<br>  -p 1881:1881 \<br>  -v fuxa-data:/usr/src/app/FUXA/storage \<br>  frangoteam/fuxa:latest</pre><p>Buradaki parametrelerin görevleri:</p><pre>-d</pre><p>Container’ın arka planda çalışmasını sağlar.</p><pre>--name fuxa</pre><p>Container’a fuxa adını verir.</p><pre>-p 1881:1881</pre><p>OT Server’ın 1881 portunu FUXA container&#39;ının 1881 portuna yönlendirir.</p><pre>-v fuxa-data:/usr/src/app/FUXA/storage</pre><p>FUXA’nın verilerinin Docker volume üzerinde kalmasını sağlar.</p><pre>frangoteam/fuxa:latest</pre><p>Kullanılacak Docker image’ıdır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fyAHOWaI4RM31Sb2roQyQg.png" /></figure><p>Container oluşturulduktan sonra çalışan container’ları kontrol ediyorum:</p><pre>sudo docker ps</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*46GEiAsm-zA_0H7D7YR-Qg.png" /></figure><h3>16. FUXA Container Loglarının Kontrol Edilmesi</h3><p>Container’ın çalışıyor olması ilk kontrolümüz için yeterli olsa da FUXA’nın uygulama tarafında herhangi bir hata verip vermediğini de kontrol etmek istiyorum.</p><p>Bunun için:</p><pre>sudo docker logs fuxa</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/682/1*pEqplkekiwhD_Cirbso1qA.png" /></figure><p>Loglarda FUXA’nın başlatıldığını ve uygulamanın ilgili port üzerinden dinlemeye başladığını kontrol ediyoruz.</p><p>Eğer container Up durumunda olmasına rağmen uygulama tarafında bir problem varsa, ilk bakılacak yerlerden biri bu loglar olacaktır.</p><h3>17. OT Server Üzerinde 1881 Portunun Kontrol Edilmesi</h3><p>FUXA’nın 1881 portu üzerinden yayın yaptığını doğrulamak için OT Server üzerinde port kontrolü gerçekleştiriyorum.</p><p>Örneğin:</p><pre>sudo ss -lntp | grep 1881</pre><p>Burada 1881 portunun dinleme durumunda olduğunu görmemiz gerekiyor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/814/1*bJuuOb1NV8Q-nixg8aZaYw.png" /></figure><p>Bu kontrol ile Docker port mapping’in OT Server üzerinde oluştuğunu doğrulamış oluyoruz.</p><pre>                 VirtualBox<br>                     |<br>             Host-Only Network<br>             192.168.56.0/24<br>                     |<br>             +-------+-------+<br>             |               |<br>        Kali Linux        OT Server<br>     192.168.56.102     192.168.56.20<br>                             |<br>                          Docker<br>                             |<br>                          FUXA<br>                       TCP/1881</pre><h3>18. Kali Linux Üzerinden FUXA’ya Erişim</h3><p>Artık FUXA’nın OT Server üzerinde çalıştığını doğruladığımıza göre bağlantıyı <strong>Kali Linux üzerinden</strong> test edebiliriz.</p><p>Kali Linux üzerinde öncelikle OT Server’a erişimi kontrol ediyorum:</p><pre>ping -c 4 192.168.56.20</pre><p>Ardından FUXA’nın 1881 portunu kontrol ediyorum:</p><pre>nc -zv 192.168.56.20 1881</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/498/1*GBslfqHha6qhL1MEC7MdOA.png" /></figure><p>Çıktıda:</p><pre>inverse lookup failed: Unknown host</pre><p>mesajını görüyoruz.</p><p>Bu mesaj, 192.168.56.20 adresi için reverse DNS çözümlemesi yapılamadığını ifade ediyor. Ancak bu durum TCP bağlantısının başarısız olduğu anlamına gelmiyor.</p><p>Asıl önemli satır:</p><pre>[UNKNOWN] [192.168.56.20] 1881 (?) open</pre><p>şeklinde geliyor.</p><p>Bu çıktı, Kali Linux üzerinden OT Server’ın 1881/TCP portuna erişilebildiğini ve portun <strong>açık</strong> olduğunu gösteriyor.</p><p>Böylece iletişim zincirini iki ayrı noktadan doğrulamış olduk:</p><pre>Kali Linux<br>    |<br>    | ICMP<br>    v<br>OT Server<br>192.168.56.20<br>    |<br>    | TCP/1881<br>    v<br>Docker / FUXA</pre><p>Bu aşamada FUXA’nın yalnızca container içerisinde çalıştığını değil, aynı zamanda Kali Linux tarafından OT network üzerinden erişilebilir olduğunu da doğrulamış olduk.</p><h3>19. FUXA Web Arayüzüne Erişim</h3><p>Port erişimini doğruladıktan sonra artık FUXA’nın web arayüzünü açabiliriz.</p><p>Kali Linux üzerinde web tarayıcısını açıyorum ve aşağıdaki adresi giriyorum:</p><pre>http://192.168.56.20:1881</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ksYKTOFheYIP_vVXAd2sEg.png" /></figure><p>Bu ekranın görüntülenmesiyle birlikte FUXA’nın:</p><ul><li>Docker üzerinde çalıştığını,</li><li>OT Server üzerinde 1881/TCP portundan yayın yaptığını,</li><li>Kali Linux üzerinden erişilebilir olduğunu</li></ul><p>uygulama katmanında da doğrulamış oluyoruz.</p><p>Mevcut lab mimarimiz artık şu şekilde:</p><pre>ICS / OT LAB<br>                            |<br>                     Host-Only Network<br>                     192.168.56.0/24<br>                            |<br>               +------------+------------+<br>               |                         |<br>          Kali Linux                 OT Server<br>       192.168.56.102              192.168.56.20<br>               |                         |<br>        Pentest Tools                  Docker<br>        Wireshark                         |<br>        Nmap                          FUXA SCADA<br>                                      TCP/1881</pre><p>Bir sonraki bölümde artık <strong>PLC tarafına geçebiliriz</strong>. OT Server üzerinde <strong>OpenPLC</strong> kurarak FUXA ile PLC arasında iletişim kuracağız. Bu aşamada <strong>Modbus TCP</strong> kullanarak SCADA–PLC haberleşmesini oluşturacağız.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f9c803f122dc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[EKS/ICS Pentest Labı — Bölüm 2: OT Server’ın Kurulması]]></title>
            <link>https://sefayildirimmm.medium.com/eks-ics-pentest-lab%C4%B1-b%C3%B6l%C3%BCm-2-ot-server%C4%B1n-kurulmas%C4%B1-b7ffa7267fcb?source=rss-1f1223b3b46d------2</link>
            <guid isPermaLink="false">https://medium.com/p/b7ffa7267fcb</guid>
            <category><![CDATA[ot-security]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[penetration-testing]]></category>
            <category><![CDATA[ci]]></category>
            <dc:creator><![CDATA[Sefa Yıldırım]]></dc:creator>
            <pubDate>Mon, 21 Sep 2026 15:12:41 GMT</pubDate>
            <atom:updated>2026-09-26T14:58:31.390Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DpHpQozUXjgGGNyMT3PsFA.png" /></figure><p>Bu bölümde Ubuntu Server’ı EKS/ICS laboratuvarımızın <strong>OT Server</strong> bileşeni olarak yapılandıracağız. Ubuntu’yu VirtualBox üzerinde oluşturduğumuz izole 192.168.56.0/24 Host-Only ağına bağlayacak ve Kali Linux ile iletişimini doğrulayacağız.</p><p>İlerleyen bölümlerde bu sunucu üzerinde <strong>OpenPLC, FUXA/SCADA ve endüstriyel haberleşme protokollerini</strong> çalıştıracağımız için bu makine labın OT tarafının temelini oluşturacak.</p><blockquote><strong><em>Not:</em></strong><em> Bu laboratuvar izole ve eğitim amaçlıdır. Gerçek üretim EKS/ICS sistemleri üzerinde uygulanmamalıdır.</em></blockquote><h3>1. Ubuntu Server Sanal Makinesinin Oluşturulması</h3><p>Ubuntu Server ISO dosyası hazır olduğuna göre VirtualBox’ı açıyorum.</p><p><strong>Machine → New</strong> seçeneğine tıklıyorum.</p><p>Sanal makineyi aşağıdaki donanım özellikleriyle oluşturuyorum:</p><pre>Name:<br>ICS-OT-Server<br><br>Type:<br>Linux<br><br>Version:<br>Ubuntu (64-bit)<br><br>RAM:<br>4096 MB<br><br>CPU:<br>2-4 CPU<br><br>Disk:<br>40 GB</pre><p>Burada laboratuvarın ilerleyen aşamalarında Docker, FUXA ve OpenPLC gibi bileşenleri çalıştıracağımız için <strong>4 GB RAM ve 4 CPU</strong> tercih ediyorum.</p><p>Disk olarak ise <strong>40 GB dinamik sanal disk</strong> oluşturuyorum.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/676/1*zvAhdhbeSWq30OV8UROTUw.png" /><figcaption>İso Dosyasının Seçilmesi, Katılımsız Kurulumu Atla</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/685/1*w_2WPs9waTwf1D7w32wVUA.png" /><figcaption>Bellek ve İşlemci boyutunun ayarlanması</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/681/1*Mvgl-A29VhXLLh_Gs-4ymg.png" /><figcaption>40GB Sanal Disk Yapılandırılması</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/681/1*KvtaBC9_1pRwQVq0MHl-KA.png" /><figcaption>Yapılandırmaların Gözlemlenmesi</figcaption></figure><h3>2. OT Server Network Yapılandırması</h3><p>Bu laboratuvarın en önemli noktalarından biri, OT Server’ın doğrudan internete bağlı olmaması.</p><p>Daha önce oluşturduğumuz VirtualBox Host-Only Network’ü kullanıyorum.</p><p>VirtualBox üzerinde:</p><p><strong>ICS-OT-Server → Ayarlar→ Ağ</strong></p><p>bölümüne giriyorum.</p><p>Bağdaştırıcı 1&#39;i aşağıdaki şekilde yapılandırıyorum:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/705/1*VFGTCAx9hLOh1RYsJ9v1uQ.png" /></figure><p>Bu yapılandırmayla OT Server yalnızca laboratuvar içerisinde oluşturduğumuz Host-Only network üzerinden haberleşecek.</p><p>Labın temel network yapısı şu hale geliyor:</p><pre>Windows Host<br>      |<br>   VirtualBox<br>      |<br>Host-Only Network<br>192.168.56.0/24<br>      |<br>      +-------------------+<br>      |                   |<br>    Kali              OT Server<br>192.168.56.102       192.168.56.20</pre><p>Buradaki amaç, ilerleyen bölümlerde gerçekleştireceğimiz EKS/ICS güvenlik testlerinin gerçek üretim sistemlerinden tamamen izole edilmesini sağlamak.</p><h3>3. Ubuntu Server Kurulumunun Başlatılması</h3><p>Sanal makineyi başlattığımda Ubuntu Server ISO’sundan boot ediyorum.</p><p>GRUB ekranında:</p><pre>Try or Install Ubuntu Server</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/715/1*d898N8N61YESElIphJBkng.png" /></figure><h3>4. Dil ve Klavye Yapılandırması</h3><p>Kurulum sırasında dil olarak:</p><pre>English</pre><p>seçeneğini kullanıyorum.</p><p>Sunucunun kurulum ve yönetim süreçlerinde İngilizce terminal çıktıları ve dokümantasyonla çalışacağımız için bu tercihi yapıyorum.</p><p>Klavye yapılandırmasında ise:</p><pre>Layout:<br>English (US)</pre><pre>Variant:<br>English (US)</pre><p>olarak bırakıyorum.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-mK8RjulH9sboRh_EjRbxg.png" /><figcaption>Dil seçeneğinin belirlenmesi</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lx3ydd3cKM1THvkQjJU8cw.png" /><figcaption>Klavye yapılandırması</figcaption></figure><h3>5. Ubuntu Server Kurulum Tipi</h3><p>Kurulum tipinde standart:</p><pre>Ubuntu Server</pre><p>seçeneğini kullanıyorum.</p><p>Ubuntu Server (minimized) seçeneğini tercih etmiyorum.</p><p>Ayrıca üçüncü taraf driver kurulumu seçeneğini de etkinleştirmiyorum.</p><p>Bunun temel nedeni, ilerleyen bölümlerde lab ortamını Docker, OpenPLC ve FUXA gibi bileşenlerle genişletecek olmamız ve başlangıçta standart bir Ubuntu Server kurulumu üzerinden ilerlemek istemem.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eozxqUABqTjS8GOLcWsaKA.png" /></figure><h3>6. OT Server Network Yapılandırması</h3><p>Kurulum sırasında Ubuntu, Host-Only network üzerinden enp0s3 isimli network interface&#39;i algılıyor.</p><p>İlk aşamada DHCP üzerinden:</p><pre>192.168.56.103/24</pre><p>adresini aldığını görüyorum.</p><p>Ancak OT Server’ın IP adresinin ilerleyen bölümlerde değişmesini istemiyorum. Bu nedenle DHCP yerine <strong>statik IP adresi</strong> yapılandırıyorum.</p><p>OT Server için lab içerisindeki IP planımı şu şekilde belirliyorum:</p><pre>| Sistem | IP Adresi |<br>|---|---|<br>| Windows Host | `192.168.56.1` |<br>| Kali Linux | `192.168.56.102` |<br>| OT Server | `192.168.56.20` |</pre><p>OT Server için:</p><pre>IPv4 Method:<br>Manual<br>Subnet:<br>192.168.56.0/24<br>Address:<br>192.168.56.20<br>Gateway:<br>Boş<br>Name servers:<br>Boş</pre><p>şeklinde yapılandırıyorum.</p><p>Burada gateway ve DNS tanımlamıyorum. Bunun nedeni, OT Server’ın bu aşamada yalnızca lab network’ü içerisinde haberleşmesini istemem.</p><p>Kurulum ekranında yapılandırma tamamlandığında:</p><pre>enp0s3<br>Static 192.168.56.20/24</pre><p>şeklinde görüntüleniyor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Oqhhl7GiXXjIzPSG-RzCyw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*D1dj6IAI43GeuLULpAEdvA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*V5CKrOztNzuCFkWYSUdERw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RZ91vRtbfGoLXmqQYTqaJA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S7C1I7UVXiYnaDSGr9-YXA.png" /></figure><h3>7. Proxy Yapılandırması</h3><p>Proxy yapılandırması sırasında herhangi bir proxy kullanmadığım için:</p><pre>Proxy address:<br>Boş</pre><p>olarak bırakıyorum.</p><p>Ardından <strong>Done</strong> seçeneğiyle devam ediyorum.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JUkgBc0_BOAjeALoC1AN-w.png" /></figure><h3>8. Ubuntu Archive Mirror</h3><p>Ubuntu Server kurulumunda varsayılan Ubuntu mirror adresini değiştirmiyorum:</p><pre>http://archive.ubuntu.com/ubuntu/</pre><p>Kurulum ekranında network yapılandırmasının dış ağa erişim sağlamaması nedeniyle mirror’ın kontrol edilemediğine ilişkin bir uyarı görüntüleniyor.</p><p>Bu aşamada varsayılan mirror adresini değiştirmeden kuruluma devam ediyorum.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*baodTfBWVy7cPhdt7X4FQg.png" /></figure><h3>9. Disk Yapılandırması</h3><p>OT Server için oluşturduğumuz <strong>40 GB sanal diski</strong> Ubuntu’nun guided storage yapılandırmasıyla kullanıyorum.</p><p>Seçenekler:</p><pre>Use an entire disk:<br>[X]<br>Set up this disk as an LVM group:<br>[X]<br>Encrypt the LVM group with LUKS:<br>[ ]</pre><p>Lab ortamında disk şifrelemesine ihtiyaç duymadığım için LUKS’u etkinleştirmiyorum.</p><p>Ubuntu kurulumu sonucunda yaklaşık olarak:</p><pre>/<br>    18.996 GB<br>    ext4<br>/boot<br>    2 GB<br>    ext4<br>ubuntu-vg<br>    LVM</pre><p>yapısı oluşturuluyor.</p><p>Burada dikkat edilmesi gereken nokta, kullanılan diskin gerçek fiziksel disk değil, VirtualBox tarafından oluşturulan <strong>40 GB’lık sanal disk</strong> olması.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_Hw5k75B_ICZjX4l7qr8Ig.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JMI7wNrqh7Vdq_mOCwXdJA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*d2aZzm-e18jI_OBHUrtA7A.png" /></figure><h3>10. OT Server Kullanıcısının Oluşturulması</h3><p>Kurulum sırasında sunucu üzerinde kullanacağımız kullanıcı hesabını oluşturuyorum.</p><p>Bu lab için:</p><pre>Your name:<br>ICS OT Lab<br><br>Your server&#39;s name:<br>ics-ot-server<br><br>Pick a username:<br>icsadmin</pre><p>şeklinde yapılandırıyorum.</p><p>Parolayı ise yalnızca lab ortamında kullanılacak şekilde kendim belirliyorum.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s6_BMavgN-SuzGiLM4D_4w.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zX3WOUuDqok4QebdbQeZnA.png" /></figure><h3>11. Ubuntu Pro</h3><p>Kurulum sırasında Ubuntu Pro etkinleştirme seçeneği geliyor.</p><p>Bu lab için Ubuntu Pro kullanmayacağım.</p><p>Bu nedenle:</p><pre>Skip Ubuntu Pro setup for now</pre><p>seçeneğini kullanıyorum.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CkkCEdKxebV5q-eVHePBRg.png" /></figure><h3>12. SSH Server Kurulumu</h3><p>OT Server’a ilerleyen aşamalarda Kali Linux üzerinden bağlanabilmek için kurulum sırasında OpenSSH Server’ı etkinleştiriyorum.</p><p>Seçenek:</p><pre>[X] Install OpenSSH server</pre><p>Password authentication seçeneğini de lab ortamında kolay yönetim sağlayabilmek amacıyla etkin bırakıyorum.</p><pre>[X] Allow password authentication over SSH</pre><p>SSH key import işlemi ise bu aşamada yapılmıyor.</p><p>Bu yapılandırma sayesinde kurulum tamamlandıktan sonra Kali Linux üzerinden:</p><pre>ssh icsadmin@192.168.56.20</pre><p>şeklinde OT Server’a bağlanabileceğiz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HViRTl4wEZH5zlOyypNGYA.png" /></figure><h3>13. Ubuntu Server Kurulumunun Tamamlanması</h3><p>Kurulum tamamlandığında:</p><pre>Installation complete!</pre><p>mesajı görüntüleniyor.</p><p>Kurulum sonrasında sistemin yeniden başlatılması gerekiyor.</p><p>Bu aşamada önemli bir ayrıntıyla karşılaşıyorum.</p><p>Ubuntu:</p><pre>[FAILED] Failed unmounting cdrom.mount - /cdrom.<br>Please remove the installation medium, then press ENTER:</pre><p>mesajını gösteriyor.</p><p>Buradaki problem Ubuntu kurulumunun başarısız olması değil. Kurulum ISO’su hâlâ sanal CD-ROM’a bağlı olduğu için kurulum medyası unmount edilemiyor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/814/1*BPbFbU62Xk-rsSM78iNSAg.png" /></figure><h3>14. Kurulum ISO’sunun Çıkarılması</h3><p>Bu problemi çözmek için sanal makineyi kapattıktan sonra:</p><p><strong>ICS-OT-Server → Settings → Storage</strong></p><p>bölümüne giriyorum.</p><p>Depolama yapılandırmasında Ubuntu ISO’sunun bağlı olmadığı ve yalnızca:</p><pre>ICS-OT-Server_vdi<br>40 GB</pre><p>sanal diskinin bulunduğu doğrulanıyor.</p><p>ISO çıkarıldıktan sonra sanal makineyi yeniden başlatıyorum.</p><p>Bu kez sistem kurulum ISO’sundan değil, oluşturduğumuz <strong>40 GB sanal diskten</strong> boot ediyor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/919/1*I4RsJz8ayTTkO7FEd-0q5Q.png" /></figure><h3>15. Ubuntu Server’a İlk Giriş</h3><p>Sistem yeniden başladıktan sonra Ubuntu Server login ekranı geliyor.</p><p>Oluşturduğumuz kullanıcıyla giriş yapıyorum:</p><pre>icsadmin</pre><p>Başarılı giriş sonrasında:</p><pre>icsadmin@ics-ot-server:~$</pre><p>shell prompt’unu görüyorum.</p><p>Böylece Ubuntu Server kurulumu tamamlanmış oluyor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tOqKuDm0EW2EWfpc6m5dQg.png" /></figure><h3>16. OT Server IP Adresinin Doğrulanması</h3><p>Kurulumdan sonra ilk olarak network yapılandırmasını kontrol ediyorum.</p><pre>ip a</pre><p>çıktısında enp0s3 interface&#39;i üzerinde:</p><pre>inet 192.168.56.20/24</pre><p>adresinin bulunduğunu görüyorum.</p><p>Interface’in aktif olduğu da:</p><pre>state UP</pre><p>ifadesinden doğrulanabiliyor.</p><p>Ardından routing tablosunu kontrol ediyorum:</p><pre>ip route</pre><p>çıktısında:</p><pre>192.168.56.0/24 dev enp0s3 proto kernel scope link src 192.168.56.20</pre><p>satırını görüyorum.</p><p>Bu çıktı, OT Server’ın 192.168.56.0/24 Host-Only network&#39;ünü enp0s3 üzerinden kullandığını doğruluyor</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/942/1*e-p3WNE0_K75RovCGp613w.png" /></figure><h3>17. Kali Linux ↔ OT Server Bağlantısının Doğrulanması</h3><p>Network yapılandırmasının gerçekten çalıştığını doğrulamak için iki yönlü ICMP testi gerçekleştiriyorum.</p><p>Öncelikle OT Server üzerinden Kali Linux’a ping gönderiyorum:</p><pre>ping -c 4 192.168.56.102</pre><p>Sonuç:</p><pre>4 packets transmitted, 4 received, 0% packet loss</pre><p>Ardından Kali Linux üzerinden OT Server’a ping gönderiyorum:</p><pre>ping -c 4 192.168.56.20</pre><p>Bu testte de:</p><pre>4 packets transmitted, 4 received, 0% packet loss</pre><p>sonucunu alıyorum.</p><p>Böylece iki sistem arasındaki <strong>çift yönlü network iletişimini</strong> doğrulamış oluyorum.</p><p>Labın mevcut network mimarisi artık şu şekilde:</p><pre>Windows Host<br>                              |<br>                           VirtualBox<br>                              |<br>                    Host-Only Network<br>                     192.168.56.0/24<br>                              |<br>              +---------------+---------------+<br>              |                               |<br>              |                               |<br>        Kali Linux                       OT Server<br>      192.168.56.102                   192.168.56.20<br>              |                               |<br>       Pentest Tools                    Ubuntu Server<br>       Nmap / Wireshark                 SSH<br>       ICS Tools                        Docker</pre><p>Bu noktada temel EKS/ICS lab network altyapımız hazır durumda.</p><h3>Sonuç</h3><p>Bu bölümde EKS/ICS pentest laboratuvarımızın OT tarafının temelini oluşturduk.</p><p>Yaptığımız işlemleri özetlersek:</p><ul><li>VirtualBox üzerinde ICS-OT-Server isimli Ubuntu Server VM oluşturduk.</li><li>VM için <strong>4 GB RAM, 4 CPU ve 40 GB disk</strong> kullandık.</li><li>OT Server’ı VirtualBox <strong>Host-Only Network</strong> üzerine dahil ettik.</li><li>OT Server’a statik olarak:</li></ul><pre>192.168.56.20/24</pre><p>adresini verdik.</p><ul><li>OpenSSH Server’ı etkinleştirdik.</li><li>Ubuntu Server kurulumunu tamamladık.</li><li>Kurulum ISO’sunu sanal CD-ROM’dan çıkardık.</li><li>ip a ve ip route ile network yapılandırmasını doğruladık.</li><li>Kali Linux ile OT Server arasında iki yönlü ICMP iletişimini başarıyla test ettik.</li></ul><p>Şu anda elimizde güvenlik testlerinin gerçekleştirilebileceği <strong>temel bir OT Server</strong> bulunuyor.</p><p>Ancak henüz bu sunucu gerçek bir ICS ortamını temsil etmiyor. Bir sonraki aşamada bu sunucuya OT/ICS dünyasında kullanacağımız servis ve bileşenleri eklemeye başlayacağız.</p><h3>Bir Sonraki Bölüm</h3><p>Bir sonraki bölümde <strong>OT Server üzerinde Docker ortamını hazırlayacağız.</strong></p><p>Ardından Docker üzerinde <strong>FUXA’yı SCADA/HMI bileşeni olarak çalıştırarak</strong>, oluşturduğumuz laboratuvara ilk endüstriyel kontrol bileşenini ekleyeceğiz.</p><p>Sonraki aşamalarda ise bu yapıya <strong>OpenPLC ve Modbus TCP</strong> ekleyerek Kali Linux üzerinden keşif ve güvenlik testleri gerçekleştirebileceğimiz daha gerçekçi bir ICS topolojisi oluşturacağız.</p><pre>Kali Linux<br>     |<br>     | 192.168.56.0/24<br>     |<br> OT Server<br>     |<br>     +------ FUXA / SCADA<br>     |<br>     +------ OpenPLC<br>                 |<br>              Modbus TCP<br>                 |<br>            PLC Process</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b7ffa7267fcb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[EKS/ICS Pentest Labı — Bölüm 1: Network Altyapısının Hazırlanması]]></title>
            <link>https://sefayildirimmm.medium.com/eks-ics-pentest-lab%C4%B1-b%C3%B6l%C3%BCm-1-network-altyap%C4%B1s%C4%B1n%C4%B1n-haz%C4%B1rlanmas%C4%B1-9a2bca75b2f4?source=rss-1f1223b3b46d------2</link>
            <guid isPermaLink="false">https://medium.com/p/9a2bca75b2f4</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[penetration-testing]]></category>
            <category><![CDATA[ci]]></category>
            <category><![CDATA[network-security]]></category>
            <category><![CDATA[ot-security]]></category>
            <dc:creator><![CDATA[Sefa Yıldırım]]></dc:creator>
            <pubDate>Mon, 21 Sep 2026 15:07:52 GMT</pubDate>
            <atom:updated>2026-09-26T14:59:56.365Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Nsc_LW-loKdMh9xd2gSxXg.png" /></figure><p>Bu bölümde EKS/ICS pentest çalışmalarında kullanacağımız izole laboratuvar ortamının network altyapısını hazırlayacağız. VirtualBox üzerinde Host-Only Network oluşturacak, Kali Linux’u bu ağa dahil edecek ve network bağlantımızı ip, routing, ARP ve ICMP kontrolleriyle doğrulayacağız. Bir sonraki bölümlerde ise bu altyapının üzerine OT Server, PLC, SCADA ve endüstriyel haberleşme protokollerini ekleyerek gerçek EKS/ICS pentest senaryolarına yaklaşacağız.</p><p>Bu serideki tüm çalışmalar izole ve yetkili bir laboratuvar ortamında gerçekleştirilecektir. Gerçek üretim sistemleri üzerinde test yapılmayacaktır.</p><p>Endüstriyel Kontrol Sistemleri (EKS/ICS) üzerinde pentest çalışmaları yaparken, gerçek üretim sistemlerine dokunmadan önce izole bir test ortamı oluşturmak oldukça önemlidir.</p><p>Bu çalışmada amacım, ilerleyen aşamalarda <strong>PLC, SCADA, HMI, Modbus TCP, OPC UA, S7, RTU ve farklı OT protokolleri</strong> üzerinde kontrollü güvenlik testleri gerçekleştirebileceğim bir EKS/OT laboratuvarı oluşturmaktır.</p><p>Kuracağımız yapı zaman içerisinde aşağıdaki mimariye dönüşecektir:</p><pre>                         Windows Host<br>                              |<br>                       VirtualBox<br>                              |<br>                    Host-Only Network<br>                     192.168.56.0/24<br>                              |<br>             +----------------+----------------+<br>             |                                 |<br>        Kali Linux                         OT Server<br>      192.168.56.102                    192.168.56.x<br>             |                                 |<br>       Pentest Tools                     OpenPLC / FUXA<br>       Wireshark                           SCADA / PLC<br>       Nmap</pre><p>İlk aşamada Kali Linux, pentest istasyonu olarak yapılandırılacak ve izole OT laboratuvar ağının temel altyapısı hazırlanacaktır. Sonraki bölümlerde bu ağa OT Server eklenerek laboratuvar genişletilecektir.</p><h3>1. Kullanılan Sanallaştırma Ortamı</h3><p>Laboratuvarı oluşturmak için <strong>Oracle VirtualBox</strong> kullanıyorum.</p><p>Mevcut Kali Linux sanal makinem pentest tarafında kullanılacak. Buna ek olarak ayrı bir Ubuntu Server sanal makinesi oluşturularak OT tarafını temsil etmesi planlanıyor.</p><p>Temel mimarimiz:</p><pre>Kali Linux<br>    |<br>    | Pentest<br>    |<br>    +------ EKS/OT LAB ------+<br>                             |<br>                         OT Server</pre><p>Buradaki temel prensip, test edilecek sistemlerin mümkün olduğunca <strong>izole bir sanal ağ içerisinde tutulmasıdır.</strong></p><h3>2. VirtualBox’ta Host-Only Network Oluşturulması</h3><p>İlk olarak VirtualBox içerisinde EKS laboratuvarımız için ayrı bir network kullanmamız gerekiyor.</p><p>VirtualBox açıldıktan sonra:</p><p><strong>Tools → Network</strong></p><p>bölümüne giriyorum.</p><p>Burada sistemimde daha önce oluşturulmuş Host-Only network’leri görüyorum.</p><p>Kullanacağım network:</p><pre>VirtualBox Host-Only Ethernet Adapter<br><br>IPv4 Address:<br>192.168.56.1<br><br>Network Mask:<br>255.255.255.0</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/787/1*PQaRpB7S36QkaDkQBTEE6g.png" /></figure><h3>3. Kali Linux’un EKS Lab Ağına Bağlanması</h3><p>Kali Linux’u hem internete erişebilen hem de EKS labına bağlanabilen bir pentest makinesi olarak kullanmak istiyorum.</p><p>Bu nedenle Kali’ye iki network interface tanımlıyorum.</p><p>VirtualBox:</p><p><strong>Kali Linux → Settings → Network</strong></p><p>bölümüne giriyorum.</p><p>İlk adaptör mevcut internet bağlantısı için kullanılmaya devam ediyor.</p><p>İkinci adaptörü ise aktif hale getiriyorum.</p><h4>Adapter 2</h4><pre>Enable Network Adapter: ✓<br><br>Attached to:<br>Host-only Adapter<br><br>Name:<br>VirtualBox Host-Only Ethernet Adapter</pre><p>Bu yapı sayesinde Kali’nin iki farklı ağı olacak:</p><pre>eth0<br>10.0.2.5<br>     |<br>     +---- NAT / Internet<br><br><br>eth1<br>192.168.56.102<br>     |<br>     +---- EKS Lab</pre><p>Bu ayrım ileride oldukça önemli olacak.</p><p>Çünkü:</p><ul><li>eth0 → paket indirme, güncelleme vb.</li><li>eth1 → EKS/OT laboratuvarı</li></ul><p>için kullanılacak.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/711/1*MRmvVX4tLcX1M_tt0HOgpA.png" /></figure><h3>4. Kali Linux’ta Network Yapısının Kontrol Edilmesi</h3><p>Kali Linux’u başlattıktan sonra network interface’lerini kontrol ediyorum.</p><pre>ip a</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/829/1*3oaHMNOHONkGLQFm9ANicw.png" /></figure><p>Komutunun sonucunda iki önemli interface görüyorum:</p><pre>eth0<br>inet 10.0.2.5/24</pre><pre>eth1<br>inet 192.168.56.102/24</pre><p>Dolayısıyla Kali’nin network yapısı şu hale geliyor:</p><pre>Interface       IP Address          Görev<br><br>eth0            10.0.2.5            NAT / Internet<br><br>eth1            192.168.56.102      EKS Lab</pre><h3>5. Kali’nin Host-Only Network Üzerindeki Erişiminin Kontrol Edilmesi</h3><p>Host-Only network’ümüzün Windows tarafındaki adresi:</p><pre>192.168.56.1</pre><p>Kali’nin bu network üzerinden hangi interface’i kullanacağını kontrol ediyorum:</p><pre>ip route get 192.168.56.1</pre><p>Çıktım:</p><pre>192.168.56.1 dev eth1 src 192.168.56.102</pre><p>Çünkü Kali’nin:</p><pre>192.168.56.1</pre><p>adresine giderken:</p><pre>eth1</pre><p>interface’ini kullandığını ve kaynak adresinin:</p><pre>192.168.56.102</pre><p>olduğunu doğruluyor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/424/1*mug23MJQomqb_5Goqchxkw.png" /></figure><h3>6. ARP Kontrolü</h3><p>Bir sonraki kontrolde Kali’nin Host-Only adaptörünün MAC adresini öğrenip öğrenemediğini kontrol ediyorum.</p><pre>ip neigh show 192.168.56.1</pre><p>Çıktı:</p><pre>192.168.56.1 dev eth1 lladdr 0a:00:27:00:00:11 STALE</pre><p>Burada 192.168.56.1 için bir MAC adresi görüyoruz.</p><p>Bu çıktı, Kali’nin 192.168.56.1 adresi için ARP çözümlemesi gerçekleştirebildiğini ve ilgili MAC adresini öğrendiğini göstermektedir.</p><p>STALE durumu tek başına bir hata değildir; ARP komşu kaydının mevcut fakat yakın zamanda yeniden doğrulanmamış olduğunu gösteren bir durumdur.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/475/1*OWGkEzR8B_wQiOATZ0Q5cg.png" /></figure><h3>7. Ping Kontrolü</h3><p>Son olarak, Kali Linux’un Host-Only network üzerindeki bağlantısını ICMP üzerinden kontrol etmek amacıyla aşağıdaki komutu çalıştırıyorum:</p><pre>ping -c 4 192.168.56.1</pre><p>Bu test sırasında 192.168.56.1 adresinden ICMP yanıtı alınamadı.</p><p>Bununla birlikte, daha önce gerçekleştirdiğimiz ARP kontrolünde 192.168.56.1 adresi için MAC adresinin başarıyla çözümlendiği ve routing kontrolünde ilgili trafiğin eth1 interface&#39;i üzerinden 192.168.56.102 kaynak adresiyle yönlendirildiği görüldü.</p><p>Bu nedenle, <strong>ping yanıtının alınamaması tek başına Host-Only network yapılandırmasının başarısız olduğunu göstermemektedir.</strong> ICMP trafiğinin Windows tarafındaki firewall veya ağ yapılandırması tarafından engellenmesi gibi farklı nedenler söz konusu olabilir.</p><p>Bu aşamada labın temel network yapılandırmasını tamamlanmış kabul ederek bir sonraki aşamaya geçiyorum. Bir sonraki bölümde <strong>Ubuntu Server’ı OT Server olarak yapılandıracak ve Kali Linux ile OT Server arasındaki bağlantıyı test edeceğim.</strong></p><h3>Sonuç</h3><p>Bu bölümde EKS/ICS pentest laboratuvarının temel network altyapısı hazırlanmıştır.</p><p>Laboratuvar için 192.168.56.0/24 adres bloğu kullanılmış ve Kali Linux&#39;un ikinci network interface&#39;i Host-Only network&#39;e bağlanmıştır.</p><p>Son durumda Kali Linux üzerinde:</p><pre>eth0 → 10.0.2.5<br>       NAT / Internet</pre><pre>eth1 → 192.168.56.102<br>       EKS/ICS Lab Network</pre><p>yapısı oluşturulmuştur.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9a2bca75b2f4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Dosya Adı Olarak Kurgulanan Cache Kurallarının Tespiti & Exploit Edilmesi]]></title>
            <link>https://sefayildirimmm.medium.com/dosya-ad%C4%B1-olarak-kurgulanan-cache-kurallar%C4%B1n%C4%B1n-tespit-exploit-edilmesi-4eea4fecde39?source=rss-1f1223b3b46d------2</link>
            <guid isPermaLink="false">https://medium.com/p/4eea4fecde39</guid>
            <category><![CDATA[web-cache-deception]]></category>
            <category><![CDATA[web-security]]></category>
            <category><![CDATA[csrf-attack]]></category>
            <category><![CDATA[portswigger-lab]]></category>
            <dc:creator><![CDATA[Sefa Yıldırım]]></dc:creator>
            <pubDate>Sat, 31 Aug 2024 17:04:01 GMT</pubDate>
            <atom:updated>2024-09-01T10:30:02.929Z</atom:updated>
            <content:encoded><![CDATA[<p>Önceki bölümde cache server’ın normalizasyon tutarsızlıklarından yararlanarak, cache server’ın static dizinleri cache kuralı olarak kurguladığı durumların nasıl tespit ve exploit edileceğini teorik ve uygulamalı anlattım. Bu bölümde ise dosya adının cache kuralı olarak kurgulandığı durumların normalizasyon tutarsızlıklarından yararlanarak nasıl tespit ve exploit edileceğini teorik ve uygulamalı anlatacağım.</p><h3>Exploiting file name cache rules</h3><p>Bazı dosyalar (örneğin, robots.txt, index.html, favicon.ico) web server’larında yaygın olarak bulunur ve sık değişmedikleri için genellikle cache’e alınırlar. Cache kuralları, bu dosyaları tam dosya adı eşleşmesine göre hedefler.</p><ul><li>Olası bir dosya için bir GET request’i göndererek response’ın cache’e alınıp alınmadığını kontrol etmek gerekir.</li><li>Eğer response cache’e alınıyorsa, bu durum dosya adına dayalı bir cache kuralı olduğunu gösterebilir.</li></ul><h3>Detecting normalization discrepancies</h3><p><a href="https://medium.com/@sefayildirimmm/static-dizin-olarak-kurgulanan-cache-kurallar%C4%B1n%C4%B1n-exploit-edilmesi-normalization-discrepancies-ba687f69512a">Orijin server’ın path’i nasıl normalleştirdiğini test etmek için</a>, daha önce statik dizin cache kuralları için kullandığımız yöntemi kullanabilirsiniz.</p><p>Cache server’ın path’i nasıl normalleştirdiğini görmek için, path traversal karekterleri ve dosya adından önce rastgele bir dizin içeren request gönderelim. Örneğin, /profile%2f%2e%2e%2findex.html.</p><p><strong>Response cache’e alındıysa:</strong> Bu durum cache server’ının path’i /index.html olarak normalleştirdiğini gösterir.</p><p><strong>Response cache’e alınmadıysa:</strong> Bu durum cache server’ının path’i /profile%2f%2e%2e%2findex.html olarak yorumladığını ve / ve dot-segment’i çözümlemediğini gösterir.</p><h3>Exploiting normalization discrepancies</h3><p>Response yalnızca request’in tam dosya adıyla eşleşmesi durumunda cache’e alındığı için, yalnızca cache server’ının encoding path traversal karekterlerini decode yaptığı ancak origin server’ın decode yapamadığı bir tutarsızlıktan yararlanabiliriz. Statik dizin cache kurallarıyla aynı yöntemi kullanabiliriz. Statik dizin önekini dosya adıyla değiştirmemiz yeterlidir. Daha fazla bilgi için, <a href="https://medium.com/@sefayildirimmm/static-dizin-olarak-kurgulanan-cache-kurallar%C4%B1n%C4%B1n-exploit-edilmesi-detecting-exploit-4361605e08ba">Cacher server tarafından normalizasyon ile exploit</a> konusuna bakabilirsiniz.</p><h3>Lab: Exploiting exact-match cache rules for web cache deception</h3><p>Laboratuvarımızda web cache deception zafiyeti bulunmaktadır. Bizden istenen bu zafiyetten yararlanarak administrator’e ait e-mail adresinin değiştirilmesidir.</p><p>Kurbanın response’ını web cache deception zafiyeti ile elde edersek csrf token bilgisini elde edebiliriz. Daha sonra bu bilgi ile CSRF saldırısı düzenleyerek e-mail’i değiştirebiliriz.</p><p>İlk olarak bir hedef endpoint belirlememiz gerekir. Bunun için uygulamamızı inceliyoruz. my-account response’ında,</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yLqvs0y8nbsXub3D4zYpDA.png" /></figure><p>Csrf token olduğunu gözlemliyoruz. O halde bu response’ı cache’e kaydetmenin bir yolunu bulmamız gerekiyor.</p><p>Origin server delimiter karekterlere nasıl tepki verdiğini kontrol edelim. my-account request’imizi burp intruder’a gönderelim <a href="https://portswigger.net/web-security/web-cache-deception/wcd-lab-delimiter-list">Delimiter karekterlerimizi</a> payload type’ını simple list seçerek ekleyelim. Payloads sekmesinin en altından payload encoding seçimini kaldıralım ve atağımızı başlatalım.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/828/1*Js8_dMUD8dnSun6k4EVnqA.png" /></figure><p>Görüyoruz ki ; , ? karekterleri delimiter karekter olarak kullanılabiliyor. Request’i my-account?sefa.js ve my-account?sefa.js olarak gönderdiğimizde response’da cache’e dair herhangi bi işaret göremiyoruz. Bu da cache server’ında delimiter karekterlere göre normalizayon yaptığını veya normalizasyon yapmadığını ve statik js uzantılı bir cache kuralının olmadığını bize gösterir.</p><p>Oluşabilecek normalizasyon farklılıklarını incelemeye devam edelim.</p><p>Uygulamamızı incelerken resources static dizininin olduğunu gözlemlemiştik. /resources%2f%2e%2e%2fmy-account request’ini gönderelim ve origin server’ın ve cache server’ın nasıl davrandığını inceleyelim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YpJz0m6UxYGKGAqncEfcaA.png" /></figure><p>404 response alıyor olmamız origin server’ın encoding karekterleri decode yapmadığını ve path’i çözümleyemediğini gösterir. Aynı zamanda resources dizini ile başlamamıza rağmen response’da cache’e dait birşeyler göremiyoruz. Bu durum da static dizine dayalı bir cache kuralının olmadığını gösterebilmektedir.</p><p>Cache server’lar bazen sık kullanılan adı pek değiştirilmeyen robots.txt, index.html gibi dosyaları cache’e alabilmektedir. Dosya adına göre bir cache kuralı var mıdır kontrol edelim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Vq3aHp4ZOqtgM4-s3GBSXw.png" /></figure><p>Görüldüğü üzere GET /robots.txt request’inde response’ın cache’e alındığını gözlemliyoruz. O halde biliyoruz ki dosya adına göre bir cache kuralı varsa static dizin olarak kurgulanan cache kuralarının, cache server normalizasyonundan faydalanarak exploit etme sürecini burada da kullanabiliriz.</p><p>Payload nasıl olmalı,</p><p>GET /my-account; yazarak delimiter karekterini de kullanarak origin server’ın delimiter karekterden sonrasını yok saymasını ve my-account response’ını dönmesini sağlıyoruz. Devamında,</p><p>GET /my-account;%2f%2e%2e%2frobots.txt ile cache server’ın path karekterlerini decode ederek path’i normalleştirmesini ve cache kuralının olduğu robots.txt dosyasına göre my-account response’nın cache’e alınmasını sağlamak istiyoruz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xeaXutXaIXk7o_uFVWuLFw.png" /></figure><p>Görüldüğü üzere my-account response’ını cache’e almayı başarıyoruz. Şimdi bu payload’ımızı kurbana iletmek için uygulamanın exploit server’ını kullanalım.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fwZ9S3IDTaztkE4klAug3w.png" /></figure><p>Görüldüğü şekilde payload’ımızı gönderelim. Sonrasında aynı endpoint’e burp ile request’te bulunduğumuzda,</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eKlH2E64y9BSWBtzMlbx8w.png" /></figure><p>Görüyoruz ki administrator’e ait response’ı alıyoruz. Sonraki adımımız bir csrf POC hazırlayarak kurbanın csrf ile e-mail’ini değiştirmek olacaktır.</p><p>Kendi hesabımızdan e-mail güncelleme request’inde bulunalım. Burp Pro’da bu request’e sağ tıklayarak,</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TMOuFHja9WrQFGXgbeX2UQ.png" /></figure><p>CSRF PoC oluşturabiliriz.</p><pre>&lt;html&gt;<br>  &lt;!-- CSRF PoC - generated by Burp Suite Professional --&gt;<br>  &lt;body&gt;<br>    &lt;form action=&quot;https://0a1500aa0473d0a4801808ea00d50041.web-security-academy.net/my-account/change-email&quot; method=&quot;POST&quot;&gt;<br>      &lt;input type=&quot;hidden&quot; name=&quot;email&quot; value=&quot;sefa2&amp;#64;sefa2&amp;#46;net&quot; /&gt;<br>      &lt;input type=&quot;hidden&quot; name=&quot;csrf&quot; value=&quot;9aXceMKFJeuFUm4KV7JHeudhzycDgjje&quot; /&gt;<br>      &lt;input type=&quot;submit&quot; value=&quot;Submit request&quot; /&gt;<br>    &lt;/form&gt;<br>    &lt;script&gt;<br>      history.pushState(&#39;&#39;, &#39;&#39;, &#39;/&#39;);<br>      document.forms[0].submit();<br>    &lt;/script&gt;<br>  &lt;/body&gt;<br>&lt;/html&gt;</pre><p>Daha sonra burada farklı bir e-mail ve kurban kişiden elde ettiğimiz csrf token’ı da değiştirerek exploit server’ımız ile,</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*US3HfC7pueE3y73aOiojfw.png" /></figure><p>Kurbana iletiyoruz. Sonuç olarak,</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lCP9pLaF7q_8qMkMQbWeDA.png" /></figure><p>Laboratuvar çözümünü başarı ile tamamlıyoruz.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4eea4fecde39" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Static Dizin Olarak Kurgulanan Cache Kurallarının Exploit Edilmesi #Detecting & Exploit…]]></title>
            <link>https://sefayildirimmm.medium.com/static-dizin-olarak-kurgulanan-cache-kurallar%C4%B1n%C4%B1n-exploit-edilmesi-detecting-exploit-4361605e08ba?source=rss-1f1223b3b46d------2</link>
            <guid isPermaLink="false">https://medium.com/p/4361605e08ba</guid>
            <category><![CDATA[normalization-discrepancy]]></category>
            <category><![CDATA[portswigger-lab]]></category>
            <category><![CDATA[web-cache-deception]]></category>
            <category><![CDATA[web-security]]></category>
            <dc:creator><![CDATA[Sefa Yıldırım]]></dc:creator>
            <pubDate>Fri, 30 Aug 2024 19:28:50 GMT</pubDate>
            <atom:updated>2024-08-31T21:03:20.800Z</atom:updated>
            <content:encoded><![CDATA[<h3>Static Dizin Olarak Kurgulanan Cache Kurallarının Exploit Edilmesi #Detecting &amp; Exploit normalization by the cache server</h3><p>Bir önceki bölümde normalization tutarsızlıklarının ne olduğunu nasıl tespit edilebileceğini yazdım. Ayrıca static dizinlerin cache kurallarında kurgulanmasını göz önünde bulundurarak da origin server üzerinden normalization’ın tespit edilmesini ve exploit edilmesini uygulamalı olarak anlattım. Bu bölümde ise aynı işi cache server üzerinden normalization’ın tespitinin ve exploit’inin nasıl olacağını anlatacağım.</p><h3>Detecting normalization by the cache server</h3><p>Cache’in path’i nasıl normalleştirdiğini test etmek için birkaç farklı yöntem kullanabiliriz.</p><p>Öncelikle, cache’de saklanan statik dizinleri tanımlamamız gerekir. Bunun için,</p><p><strong>Proxy &gt; HTTP History</strong> kısmında, yaygın olarak kullanılan statik dizin öneklerine (/assets, /js, /images, vb.) ve cache’e alınmış response’lara sahip request’leri aramamız gerekir.</p><p>HTTP history filtresini, yalnızca 2xx response’ları ve script, image, CSS gibi MIME type’larını gösteren mesajlara ayarlamamız gerekir.</p><p>Daha sonra, cache’e alınmış bir response içeren request’i seçerek ve bu request’i path traversal string’i ve statik path’in başında rastgele bir dizinle yeniden gönderelim. Örneğin,</p><p>/aaa/..%2fassets/js/stockCheck.js gibi bir path kullanabiliriz.</p><p><strong>Elde Edilebilecek Sonuçlar</strong></p><p><strong>Response Artık Cache’e Alınmadıysa:</strong> Bu durum cache server’ının path’i endpoint’e eşlemeden önce normalleştirmediğini gösterir. /assets öneki temelinde bir cache kuralı olduğunu gösterir.</p><p><strong>Response Hala Cache Alınıyorsa:</strong> Bu durum, cache’in path’i /assets/js/stockCheck.js olarak normalleştirmiş olabileceğini gösterebilir.</p><p><strong>Dizin Önekinden Sonra Path’e Eklemeler Yapmak:</strong> Alternatif olarak, dizin önekinden sonra bir path traversal string’i ekleyelim. Örneğin, /assets/js/stockCheck.js path&#39;ini /assets/..%2fjs/stockCheck.js olarak değiştirelim.</p><p><strong>Elde Edilebilecek Sonuçlar</strong></p><p><strong>Response Artık Cache’e Alınmadıysa:</strong> Bu durum cache’in / karekterini decode yaptığını ve dot-segment’i (..) normalizasyon sırasında çözümlediğini, yani path&#39;i /js/stockCheck.js olarak yorumladığını gösterir. Bu da /assets önekine dayalı bir cache kuralı olduğunu gösterir.</p><p><strong>Response Hala Cache’e Alınıyorsa:</strong> Bu durum, cache’in / karekterini decode yapmadığını veya dot-segment’i çözümlemediğini ve path&#39;i /assets/..%2fjs/stockCheck.js olarak yorumladığını gösterebilir.</p><p><strong>Diğer Cache Kurallarına da Bakmak Gerekir:</strong> Her iki durumda da response’ın hala cache’e alınmış olması, başka bir cache kuralı nedeniyle de olabilir (örneğin, dosya uzantısına dayalı bir kural). Cache kuralının statik dizine dayalı olup olmadığını doğrulamak için:</p><p>Dizin önekinden sonraki path’i rastgele bir string ile değiştirelim. Örneğin, /assets/sefaolarak.</p><p><strong>Elde Edilebilecek Sonuçlar</strong></p><p><strong>Response Hala Cache’e Alınıyorsa:</strong> Bu durum cache kuralının /assets önekine dayalı olduğunu doğrular.</p><p><strong>Response Cache’e Alınmamış Görünüyorsa:</strong> Bu durum mutlaka statik dizine dayalı bir cache kuralı olmadığı anlamına gelmez, bazen 404 response’ları cache’e alınmayabilir.</p><h3>Exploiting normalization by the cache server</h3><p><strong>Normalizasyon Tutarsızlığı</strong></p><p><strong>Cache Server</strong>: Encoded dot-segmentleri (örneğin, %2f%2e%2e%2f) decode edebilir ve bu segmentleri path’in bir parçası olarak kabul eder.</p><p><strong>Origin Server</strong>: Dot-segmentleri decode etmez ve path’te olduğu gibi tutar. Bu durum, potansiyel bir zafiyet yaratır.</p><p><strong>Payload Yapısı</strong></p><p>/dynamic-path%2f%2e%2e%2f&lt;static-directory-prefix&gt; yapısında bir payload oluşturulması gerekir.</p><p>Bu yapı da dynamic-path dinamik içerik (örneğin, kullanıcı profili) barındıran path’dir ve static-directory-prefix statik içerik (örneğin, resimler veya CSS dosyaları) içeren bir path önekidir.</p><p><strong>Normalizasyon Tutarsızlığının Exploit Edilmesi</strong></p><p>Örnek Payload: /profile%2f%2e%2e%2fstatic</p><p><strong>Cache Server’ı</strong>: Path&#39;i/static olarak yorumlar.</p><p><strong>Origin Server</strong>: Path&#39;i /profile%2f%2e%2e%2fstatic olarak yorumlar ve muhtemelen bir hata döner çünkü bu path’i tanımaz.</p><p><strong>Delimiter (Ayırıcı) Kullanımı</strong></p><p>Normalizasyon tutarsızlığını exploit etmek için bir delimiter (örneğin, ;) kullanılması gerekir.</p><p><strong>Cache Server</strong>: Delimiter’i kullanmaz ve path&#39;i /static olarak yorumlar.</p><p><strong>Origin Server</strong>: Delimiter’i kullanır ve path’i /profile olarak yorumlar, bu da dinamik içerik (örneğin, profil bilgisi) döndürmesine neden olur.</p><p><strong>Exploit Senaryosu</strong></p><p><strong>Örnek Payload</strong>: /profile;%2f%2e%2e%2fstatic</p><p><strong>Cache Server</strong>: /static olarak yorumlar ve bu içeriği cache’e alır.</p><p><strong>Origin S-</strong>: /profile olarak yorumlar ve profil bilgilerini döner.</p><p>Bu durumda, dinamik içerik cache’e alınır ve potansiyel olarak başka kullanıcılara açık hale gelir.</p><h3>Lab: Exploiting cache server normalization for web cache deception</h3><p>Laboratuvarımızda web cache deception zafiyeti bulunmaktadır. Bizden istenen carlos kullanıcısının API Key bilgisini elde etmektir.</p><p>wiener:peter kullanıcı bilgileri ile giriş yaptıktan sonra ilk adımımız hedefimizi belirlemek olacaktır. Uygulamayı incelerken,</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JcQVyGxIrTiW2RN7CZifyg.png" /></figure><p>GET /my-account request’ine dönen response’da API Key bilgisinin olduğunu gözlemliyoruz. Bu bilgi önemli olacağından bu endpoit’i seçiyoruz.</p><p>GET /my-account/sefa &amp; GET /my-accountsefa request&#39;lerinde bulunarak daha sonra delimiter payload&#39;lar ekleyerek, server&#39;ın davranışını anlamaya çalışıyoruz. sefa string’ini eklediğimizde 404 response’ı alıyoruz. Delimiter karekterler’in sonucunu gözlemlemek için Burp Intruder kullanıyorum.</p><p>GET /my-account§§sefa olacak şekilde payload alanımı belirliyorum. Delimiter karekterlere<a href="https://portswigger.net/web-security/web-cache-deception/wcd-lab-delimiter-list"> buradan</a> ulaşabilirsiniz. Bu karekterleri Burp Intruder payload sekmesinden payload type’ını simple list seçerek ekliyorum. Burp Intruder özel karekterleri default’ta URL encode yaptığından pencerenin altında bulunan payload encoding tikini kaldırıyorum. Saldırıyı başlatıyorum ve status code’a göre sıralıyorum.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/672/1*JDga42TknshGfbcAcTMOsQ.png" /></figure><p>Görüldüğü üzere ?, #, %23, %3Fdelimiter karekterleri için 200 response’ını alıyorum.</p><p>Tespit ettiğimiz delimiter karekterleri kullanarak response’ları inceleyelim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3MFrFmGSC7fGoDFYi9At3Q.png" /></figure><p>Response’da bir değişiklik yok bu durum cache’in var olabileceğini ama cache server’ında ? karekterini delimiter karekter olarak kullanabileceğini gösteriyor olabilir ya da .js uzantılı bir kuralın olmadığını gösteriyor olabilir. Diğer karekterleri deniyelim. Ancak # karekterinin browser’lar tarafında delimiter olarak kullanıldığını biliyoruz. Request server’a gitmeden browser bunu işleyecektir bu sebeple %23, %3F karekterlerini de deneyelim.</p><p>Aynı şekilde response’da bir değişiklik <strong>gözlemleyemiyoruz. </strong>Şimdi path normalizasyon tutarsızlıklarını inceleyelim.</p><p>Rastgele bir dizin ile başlayarak encoding path traversal sonrasında my-account response’ını almaya çalıştığımda,</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fypeIF67YL7c2_mFEVcgBg.png" /></figure><p>404 hatası alıyor olmamın sebebi origin server’ın path’i decode edemediği ve path’i olduğu gibi aldığı anlamına gelir. Static dizinleri incelediğimde,</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*R-mKX83hk3EJNokmHlahmg.png" /></figure><p>resources ile başlayan dizinlerin cache’e alındığını görüyoruz. O halde,</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jTATekDjcwOQI1rhTtI1DA.png" /></figure><p>Görüldüğü üzere rastgele bir dizin ile başladığımda ve encoding path traversal sonrasında resources endpoint’e ulaşmaya çalıştığımda response’ın cache’e alındığını görüyorum bu durum cache server’ın encoding karekterleri decode yaptığını, path’i işlediğini ve resources ile başlayan cache kuralı olduğunu gösterir. Ancak response’ın farklı cache kuralı sayesinde cache’lenmiş olabilme ihtimali vardır yine de emin olmak için başka testler de yapmak gerekir.</p><p>Şimdi daha farklı bir payload ile,</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Yuq72s6w6QsE2vWK9CecGA.png" /></figure><p>GET /resources%2f%2e%2e%2fjs/tracking.js request&#39;inde bulunduğumuzda response’ın cache’e alınmaması yine cache server’ın path’i çözümlediğini ve /js/tracking.js olarak request’in iletilmesinden kaynaklanabilir. Cache server’ın resources prefix’ini görmediğinden cache’e almaması durumu resources’a dayalı bir cache kuralı olduğunu gösterebilir.</p><p>Şimdi elimde ne var bakalım. Orign server’ın %23 karekterini delimiter olarak kullandığını ve encoding path’i decode yapmadığını biliyorum. Cache server’ın ise encoding path’i decode yaparak işlediğini ve resources önekine dayalı bir cache kuralı olduğunu biliyorum.</p><p>Bu bilgileri kullanarak,</p><p>/my-account%23 yazarak origin server’ın my-account response’ı vermesini delimiter karekter ile sağlıyorum. Devamında ise /my-account%23%2f%2e%2e%2f/resources ile cache server’ın path’in tamamını işleyerek resources öneki başta olduğundan response’ı cache’e alması gerektiğinin kararını verecektir. O halde,</p><pre>&lt;script&gt;document.location=&quot;https://0a1600c3048faf0b812ce9f900eb009a.web-security-academy.net/my-account%23%2f%2e%2e%2fresources?sefa&quot;&lt;/script&gt;</pre><p>Payload’ı ile kurbanın response’ını elde edebiliriz. Exploit server’da deliver exploit to victim ile kurbana payload’ımızı iletelim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uMO51VOgrCwCO4ZTJf4S5w.png" /></figure><p>Sonrasında aynı endpoint’te request’te bulunduğumuzda,</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*u-WGeJ1J_T8D-P2xcKTUgw.png" /></figure><p>carlos kullanıcısının API Key bilgisini elde ediyoruz. Elde ettiğimiz bu bilgiyi laboratuvarımızda submit solution’a ekleyerek,</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Yii2HAgt8vTOOEeHHiihmQ.png" /></figure><p>Laboratuvar çözümünü başarı ile tamamlıyoruz.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4361605e08ba" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Static Dizin Olarak Kurgulanan Cache Kurallarının Exploit Edilmesi #Normalization discrepancies |…]]></title>
            <link>https://sefayildirimmm.medium.com/static-dizin-olarak-kurgulanan-cache-kurallar%C4%B1n%C4%B1n-exploit-edilmesi-normalization-discrepancies-ba687f69512a?source=rss-1f1223b3b46d------2</link>
            <guid isPermaLink="false">https://medium.com/p/ba687f69512a</guid>
            <category><![CDATA[web-security]]></category>
            <category><![CDATA[web-cache-deception]]></category>
            <category><![CDATA[normalization-discrepancy]]></category>
            <category><![CDATA[portswigger-lab]]></category>
            <dc:creator><![CDATA[Sefa Yıldırım]]></dc:creator>
            <pubDate>Thu, 29 Aug 2024 02:39:13 GMT</pubDate>
            <atom:updated>2024-08-31T08:43:08.859Z</atom:updated>
            <content:encoded><![CDATA[<h3>Static Dizin Olarak Kurgulanan Cache Kurallarının Exploit Edilmesi #Normalization discrepancies | Detecting &amp; Exploit normalization by the origin server</h3><p>Bir önceki bölümde statik dosya uzantılarını kullanarak origin ile cache server arasında delimiter tutatsızlıklarının ne olduğunu, bu durumun potansiyel web cache deception zafiyetine nasıl yol açtığını anlattım. Ayrıca delimiter tutarsızlığının nasıl tespit edileceğini, bu zafiyetin uygulamalı örneğini yaptım ve yazdım. Bu bölümde ise iki server arasında static dizinleri kullanarak normalization tutarsızlıklarının web cache deception zafiyetine nasıl yol açacağını ve bu tutarzızlıkların tespiti ile zafiyetin nasıl exploit edileceğini anlatacağım.</p><p>Web server’ların statik kaynakları belirli dizinlerde depolaması yaygın bir uygulamadır. Cache kuralları genellikle bu dizinleri /static, /assets, /scripts veya /images gibi belirli URL path’i önekleriyle eşleştirerek hedefler. Bu kurallar ayrıca web cache deception saldırısına karşı da savunmasız olabilir.</p><h3>Normalization discrepancies</h3><p><strong>Normalizasyon</strong>, URL path’lerinin çeşitli temsillerini standart bir formata dönüştürme işlemidir. Bu süreç, encoding karakterlerin decode edilmesini ve . veya .. gibi segmentlerin çözümlemesini (path’in geri kalan kısmından çıkarılmasını) içerebilir. Ancak, bu işlemler server’dan server’a parser’a göre önemli ölçüde değişiklik gösterebilir.</p><p><strong>Normalizasyon Farklılıklarının Güvenlik Açıkları Yaratması</strong></p><ul><li>Cache server ve origin server , URL’i farklı şekilde normalize edebilir. Bu farklılıklar, bir saldırganın <strong>path traversal </strong>saldırısı yaparak her iki server’ın URL’i farklı şekilde yorumlamasını sağlamasına olanak tanır.</li><li>Örneğin, /static/..%2fprofile URL&#39;ini ele alalım.</li><li><strong>Origin server</strong>, %2f encoding&#39;ini / olarak decode eder ve .. segmentini çözümler. Bu nedenle path&#39;i /profile olarak normalize eder ve profile bilgilerini döndürür.</li><li><strong>Cache server </strong>ise %2f encoding’ini decode yapmaz ve .. segmentini çözümlemez. Bu nedenle path&#39;i/static/..%2fprofile olarak değerlendirir. Eğer cache server /static öneki ile başlayan request’lerin response’larını cache&#39;e alıyorsa, profile bilgilerini cache&#39;ler ve bunları döndürür.</li></ul><p><strong>Saldırıya Dair Kritik Noktalar</strong></p><ul><li>URL’deki . ve .. gibi segmentler, dosya sistemlerinde bir dizin yukarı çıkmayı veya bir dizinin içindeki dosyalara erişmeyi ifade eder. Bu segmentler genellikle <strong>path traversal</strong> saldırılarında kullanılır.</li><li>Ancak, browser’lar URL’deki bu segmentleri otomatik olarak çözümleyebilirler ve normal hale getirebilir. Bu durumda, URL’deki .. gibi bir segment, browser tarafından bir üst dizine çık olarak yorumlanabilir ve request browser’dan çıkmadan önce değiştirilir.</li><li>Bunu önlemek için, . ve .. segmentlerini encoding yapmak gerekir. Yani, . karakterini %2e ve / karakterini %2f olarak encoding yaparsak, browser bu segmentleri çözümleyemez ve bu sayede URL, saldırı için kullanılabilir hale gelir.</li></ul><p>Bu nedenle, exploit edilebilir bir normalleştirme farklılığı, cache veya origin server’ın, nokta segmentlerini çözümlemenin yanı sıra path traversal sırasındaki karakterlerin decoding’ini yapması gerekir.</p><h3>Detecting normalization by the origin server</h3><p><strong>URL’yi Değiştirme: </strong>URL’e path traversal karekterleri ekleyerek test yapabiliriz. Örneğin, /profile URL&#39;ini /aaa/..%2fprofile olarak değiştirelim. Burada %2f encoding bir / karakteridir.</p><p><strong>Kaynağı Seçme:</strong> Test için, cache’lenmeyen bir kaynak kullanmamız gerekir. Genellikle POST gibi non-idempotent(farklı sonuçların oluşabileceği) method’larla erişilen kaynaklar bu amaca uygundur.</p><p><strong>Response’ın Uyuşması:</strong> Eğer response , temel response’la (örneğin, /profile URL&#39;sinden gelen response) eşleşiyorsa ve profil bilgilerini döndürüyorsa, bu, origin server’ın path traversal dizisini /profile olarak yorumladığını ve / karakterini decode yaptığını gösterir. Ayrıca, .. segmentini çözümlemiş ve /profile path’ini kullanmıştır.</p><p><strong>Response’ın Eşleşmemesi:</strong> Eğer response temel response ile eşleşmiyorsa, örneğin 404 hata mesajı alıyorsak, bu durumda origin server’ı path&#39;i /aaa/..%2fprofile olarak yorumlamış ve / karakterini decode yapmamış veya .. segmentini çözümlememiş olabilir.</p><h4>Diğer Önemli Noktalar</h4><p>Normalizasyonu test ederken, nokta segmentindeki yalnızca ikinci slash’ı encoding yaparak başlamak gerekir. <strong>Neden? </strong>Bazı CDN’ler, statik dizin öneki sonrası gelen / karakterini eşleştirebilir ve bu durum saldırıyı etkileyecek bir farklılık yaratabilir. Örneğin, /static/../profile gibi bir path, bazı CDN&#39;ler tarafından /static/ dizini olarak yorumlanabilir.</p><p>Yine bu testlerde, sadece bir slash’ı encoding yapmak yerine tüm path traversal string’ini encoding yapabiliriz. Örneğin, ../ string’ini%2e%2e%2f olarak tamamen encoding yapmak.</p><p>Slash karakteri (/) yerine nokta (.) karakterini encoding yapmak da test edilmesi gereken bir yöntemdir. Örneğin, ../ string&#39;ini%2e/ olarak yazmak.</p><p>Bu stratejiler, server’ın veya CDN’nin bu karakterleri nasıl çözümlediğini ve URL’i nasıl yorumladığını gözlemlemek için kullanılabilir.</p><h3>Exploiting normalization by the origin server</h3><p>Origin server encoding nokta segmentlerini decoding yapıyor ancak cache yapmıyorsa, aşağıdaki yapıya göre bir payload oluşturarak bu tutarsızlıktan yararlanmayı deneyebiliriz.</p><pre>/&lt;static-directory-prefix&gt;/..%2f&lt;dynamic-path&gt;</pre><p>Örneğin, /assets/..%2fprofile payload’ını düşünelim.</p><p>Bu durumda cache, path’i /assets/..%2fprofile şeklinde yorumlar. Ancak origin server /profile olarak yorumlar. Sonuç,</p><ul><li>Origin server, /profile path’ine ait dinamik bilgileri döner, ancak cache server’ı bu dinamik bilgiyi /assets/..%2fprofile path’i ile ilişkilendirir ve cache&#39;e kaydeder.</li><li>Sonraki request’lerde, /assets/..%2fprofile path’ine yapılan request’ler, aslında /profile için cache&#39;lenmiş olan dinamik içeriği döndürür.</li></ul><h3>Lab: Exploiting origin server normalization for web cache deception</h3><p>Laboratuvarımızda web cache deception zafiyeti bulunmaktadır. Bizden istenen carlos kullanıcısının API Key bilgisini elde etmektir.</p><p>wiener:peter kullanıcı bilgileri ile giriş yaptıktan sonra ilk adımımız hedefimizi belirlemek olacaktır. Uygulamayı incelerken,</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4rp76K5wwjEqUh__aoRhDQ.png" /></figure><p>GET /my-account request’ine dönen response’da API Key bilgisinin olduğunu gözlemliyoruz. Bu bilgi önemli olacağından bu endpoit’i seçiyoruz.</p><p>GET /my-account/sefa &amp; GET /my-accountsefa request&#39;lerinde bulunarak daha sonra delimiter payload&#39;lar ekleyerek, server&#39;ın davranışını anlamaya çalışıyoruz. sefa string’ini eklediğimizde 404 response’ı alıyoruz. Delimiter karekterler’in sonucunu gözlemlemek için Burp Intruder kullanıyorum.</p><p>GET /my-account§§sefa olacak şekilde payload alanımı belirliyorum. Delimiter karekterlere<a href="https://portswigger.net/web-security/web-cache-deception/wcd-lab-delimiter-list"> buradan</a> ulaşabilirsiniz. Bu karekterleri Burp Intruder payload sekmesinden payload type’ını simple list seçerek ekliyorum. Burp Intruder özel karekterleri default’ta URL encode yaptığından pencerenin altında bulunan payload encoding tikini kaldırıyorum. Saldırıyı başlatıyorum ve status code’a göre sıralıyorum.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xJACndR6vwN2vaNwgy-9BA.png" /></figure><p>Görüldüğü üzere ? delimiter karekteri için 200 response’ını alıyorum. Bu karekteri kullanabileceğimi biliyorum. Cache server’ların query string parametresini cache kurallarında kullanıldığını biliyoruz. Bu işimize daha sonra yarayabilir.</p><p>Sonraki adımımız iki server arasında normalizasyon farklılıklarının var olup olmadığını test edelim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_gg5RkqR-PeZ7vwYH_K10g.png" /></figure><p>Görüldüğü üzere GET /sefa/../my-account request’i path traversal ile my-account response’ını ürettiğini gözlemliyoruz. Ancak burada dikkat edilmesi gereken bir nokta da ben request’i burp suite ile göndersem de kurbana browser üzerinden yönlendirme yapacağımızdan browser ../ üst dizine çık işlemini request’i göndermeden önce normalize eder ve request’i öyle gönderir böyle bir durumda saldırımız başarısız olacaktır. Bu sebeple encoding göndermemiz gerekecektir.</p><p>Cache kurallarında yazılabilecek bir durum ise static dizinlerin olabileceğini biliyoruz. Bu sebeple GET /static/..%2fmy-account gibi bir request gönderdiğimizde origin server my-account response’ı dönerken static prefix’i ile başlayan bir dizin gördüğünden ve ../ normalizasyonunu yapmadığından bu URL’i cache’e alabilir. Bu durumu test edelim.</p><p>Request’lerimizi incelediğimizde,</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/665/1*oxLXoqS-Wf6YW_Vbai-xhQ.png" /></figure><p>resources static dizininin olduğunu gözlemliyoruz o halde GET /resources/../my-account HTTP/2 request&#39;ini gönderdiğimizde,</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yrGt2q2E9Ocl0M3qHXey_w.png" /></figure><p>Cache’lendiğini gözlemliyoruz. resources prefix’i ile başladığından, farklı bir cache kuralı olmadığından emin olmak için resources/sefa request’inde bulunduğumuzda da cache’e alındığını gözlemliyerek emin oluyoruz.</p><p>O halde exploit server’ı kullanarak,</p><pre>&lt;script&gt;document.location=&quot;https://0a25007d031ac9cd82dd52510014004c.web-security-academy.net/resources/..%2fmy-account&quot;&lt;/script&gt;</pre><p>Payload’ını kurbana ilettiğimizde, yönlendirmeyi alarak my-account response’ı kurbana dönerken aynı zamanda, URL’i /resources/..%2fmy-account olacak şekilde response cache’e alındı. Aynı endpoint’e request’te bulunursak,</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZWFOPFy0eANrJjJEG_fnJw.png" /></figure><p>Carlos kullanıcısının response’ının bana cache’den döndüğünü görüyoruz ve API Key bilgisini elde ediyoruz. Bu API Key bilgisini uygulamamızda submit solution’a eklediğimizde,</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DGxPd9urOTSjuVsCvIzt6Q.png" /></figure><p>Laboratuvar çözümünü başarı ile tamamlıyoruz.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ba687f69512a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Static Uzantı Olarak Kurgulanan Cache Kurallarının Exploit Edilmesi #Delimiter discrepancies |…]]></title>
            <link>https://sefayildirimmm.medium.com/static-uzant%C4%B1-olarak-kurgulanan-cache-kurallar%C4%B1n%C4%B1n-exploit-edilmesi-delimiter-discrepancies-a7317074b3d2?source=rss-1f1223b3b46d------2</link>
            <guid isPermaLink="false">https://medium.com/p/a7317074b3d2</guid>
            <category><![CDATA[portswigger-lab]]></category>
            <category><![CDATA[web-security]]></category>
            <category><![CDATA[web-cache-deception]]></category>
            <category><![CDATA[delimiter-discrepancies]]></category>
            <dc:creator><![CDATA[Sefa Yıldırım]]></dc:creator>
            <pubDate>Tue, 27 Aug 2024 23:20:35 GMT</pubDate>
            <atom:updated>2024-08-29T00:12:18.151Z</atom:updated>
            <content:encoded><![CDATA[<h3>Static Uzantı Olarak Kurgulanan Cache Kurallarının Exploit Edilmesi #Delimiter discrepancies | Delimiter decoding discrepancies</h3><p>Bir önceki bölümde origin server ile cache server arasında path mapping tutarsızlığı oluştuğunda nasıl expoloit edilebileceğini teorik ve uygulamalı anlattım. Bu bölümde ise server’lar arasında delimiter arasındaki farklı yorumlamalardan kaynaklanan zafiyeti anlatacağım.</p><h3>Delimiter discrepancies</h3><p>Delimiter’lar , URL’lerde farklı öğeler arasındaki sınırları belirleyen karakterler veya string’lerdir. Örneğin, <strong>?</strong> işareti genellikle URL path’ini query string’den ayırmak için kullanılır. Ancak, URI RFC’si oldukça esnektir ve bu nedenle farklı framework’ler veya teknolojiler arasında bu delimiter’ların kullanımıyla ilgili bazı farklılıklar meydana gelebilir.</p><p>Cache ve origin server’ın karakterleri ve string’leri delimiter olarak kullanma biçimindeki farklılıklar, web cache deception zafiyetlerine yol açabilir.</p><h4>Örnek 1: Java Spring Framework ve ; Karakteri</h4><ul><li><strong>Java Spring Framework</strong>: Java Spring framewrok’ü, ; karakterini matris değişkenleri olarak bilinen parametreleri eklemek için kullanır. Origin server Java Spring kullanıyorsa, ; karakterini bir delimiter olarak yorumlar. Bu durumda, /profile;foo.css request’i gönderildiğinde, server path&#39;i /profile olarak algılar ve profil bilgilerini döndürür.</li><li><strong>Diğer Framework’ler</strong>: Çoğu diğer framework; karakterini delimiter olarak kullanmaz. Dolayısıyla, Java Spring kullanmayan bir cache, ; karakterini ve sonrasını path’in bir parçası olarak yorumlayabilir. Eğer cache, .css ile biten request’lerin response’larını saklamak için yapılandırılmışsa, profil bilgilerini CSS dosyası gibi cache’e alıp sunabilir.</li></ul><h4>Örnek 2: Ruby on Rails Framework ve . Karakteri</h4><ul><li><strong>Ruby on Rails Framework</strong>: Ruby on Rails, . karakterini response formatını belirtmek için bir delimiter olarak kullanır.</li><li>/profile: Bu request, varsayılan HTML formatlayıcısı tarafından işlenir ve kullanıcı profil bilgilerini döndürür.</li><li>/profile.css: Bu request, bir CSS uzantısı olarak algılanır. Ruby on Rails&#39;te bir CSS formatlayıcısı olmadığı için, request kabul edilmez ve bir hata döner.</li><li>/profile.ico: Bu request, .ico uzantısını kullanır, bu da Ruby on Rails tarafından tanınmaz. Dolayısıyla, varsayılan HTML formatlayıcısı bu request’i işleyip profil bilgilerini döndürür. Eğer cache, .ico ile biten request’lerin response’larını saklamak üzere yapılandırılmışsa, profil bilgilerini statik bir dosya gibi cache’e alıp sunabilir.</li></ul><h4>Örnek 3: Encoding Karakterler ve %00 Karakteri</h4><ul><li><strong>OpenLiteSpeed Server</strong>: OpenLiteSpeed server’ı , encoding null karakteri %00&#39;ı bir delimiter olarak kullanır. OpenLiteSpeed kullanan bir origin server, /profile%00foo.js request&#39;ini/profile olarak yorumlar.</li><li><strong>Diğer Framework’ler </strong>: Çoğu diğer framework, URL’de %00 karakteri varsa bir hata response’ı döndürür. Ancak, cache sistemi Akamai veya Fastly kullanıyorsa, %00 karakterini ve sonrasını path’in bir parçası olarak yorumlayabilir.</li></ul><h4>Sonuç</h4><p>Bu tutarsızlıklar, bir saldırganın belirli karakterleri ve encoding string’leri kullanarak cache’i yanıltmasına olanak tanır. Origin server bu karakterleri göz ardı ederken, cache bunları dikkate alabilir ve yanlış bir şekilde hassas bilgileri cache’e alabilir, bu da saldırganın bu bilgilere erişmesine yol açabilir.</p><h3>Exploiting delimiter discrepancies</h3><h4>Amaç</h4><p><strong>Delimiter discrepancies</strong>’i kullanarak, cache tarafından görülen ancak origin server tarafından görülmeyen bir statik uzantıyı URL path’ine eklemek. Bu tür bir saldırı, farklı karakterlerin cache ve origin server tarafından nasıl ele alındığını manipüle ederek gerçekleştirilebilir.</p><h4>Adımlar</h4><p><strong>Origin Server Tarafından Kullanılan Delimiter Karakterleri Belirleme</strong></p><ul><li>Hedef URL’i değiştirmek için rastgele bir string ekleyelim. Örneğin, /settings/users/list URL&#39;ni /settings/users/listaaaolarak değiştirelim.(Bu noktada beklenen response 404 olabilir)</li><li>Bu değişikliğe response olarak dönen cevabı, delimiter karakterlerini test ederken referans olarak kullanalım</li></ul><p><strong>Not:</strong> Eğer bu response, origin response ile aynıysa, request yönlendiriliyor olabilir. Bu durumda, test etmek için farklı bir endpoint seçmemiz gerekebilir.</p><p><strong>Muhtemel Delimiter Karakterleri Test Etme</strong></p><ul><li>Origin path’e olası bir delimiter karakter ekleyelim, örneğin /settings/users/list;aaa olarak değiştirelim.</li><li>Response, origin response ile aynıysa, bu, ; karakterinin bir delimiter olarak kullanıldığını ve server’ın path&#39;i /settings/users/list olarak yorumladığını gösterir.</li><li>Eğer response, eklenen rastgele string ile eşleşiyorsa, bu, ; karakterinin bir delimiter olarak kullanılmadığını ve server’ın path’i /settings/users/list;aaa olarak yorumladığını gösterir.</li></ul><p><strong>Cache Tarafından Kullanılan Delimiter’lları Test Etme</strong></p><ul><li>Bulduğumuz delimiter karakterlerin cache tarafından da kullanılıp kullanılmadığını test edelim. Bunun için, path’in sonuna bir statik uzantı ekleyelim (örneğin .js). Response cache’e alındıysa, bu durum şunları gösterir,</li></ul><p>Cache, delimiter’i kullanmaz ve tam URL path’ini statik uzantıyla birlikte yorumlar.</p><p>.js gibi uzantılarla biten request’lerin response’larını saklamak için bir cache kuralı vardır.</p><p><strong>Tüm ASCII Karakterlerini ve Yaygın Uzantıları Test Etmek</strong></p><ul><li>ASCII karakterlerinin tamamı ve yaygın olarak kullanılan .css, .ico, .exe gibi dosya uzantıları test etmemiz gerekir</li><li>Bu karakterleri test etmek için Burp Suite’in Intruder modülünü kullanabiliriz.</li><li>Burp Intruder, otomatik karakter encoding yapar, ancak bu encoding’i devre dışı bırakmamız gerekir.</li></ul><p><strong>Saldırıyı Gerçekleştirme</strong></p><ul><li>Cache kuralını tetikleyecek bir exploit oluşturabiliriz. Örneğin, /settings/users/list;aaa.js payloadı.</li><li>Cache, path&#39;i /settings/users/list;aaa.js olarak yorumlar.</li><li>Origin server, path&#39;i /settings/users/list olarak yorumlar.</li></ul><p>Origin server, cache’de saklanan dinamik profil bilgilerini döndürür.</p><p>Delimiter’lar genellikle her server’da tutarlı bir şekilde kullanıldığından, bu saldırıyı çoğu zaman birçok farklı endpoint’te kullanabiliriz.</p><p><strong>Not:</strong> Bazı delimiter karakterler, kurbanın browser’ı tarafından cache’e gönderilmeden önce işlenebilir. Bu nedenle, bu tür karakterler bir exploit’te kullanılamaz. Örneğin {}, &lt;, &gt; gibi karakterler URL&#39;de encode’lanır ve # işareti yolu kısaltmak için kullanılır. Ancak, cache veya origin server bu karakterleri decode yaparsa , exploit&#39;te encoding version’u kulllanılabilir.</p><h4>Özet</h4><p>Cache ve origin server’ın URL path’inde ki delimiter karakterleri farklı yorumlayabileceği durumları kullanarak bir saldırı gerçekleştirmek mümkündür. Bu saldırı, bir kullanıcının dinamik bilgilerini, statik bir dosya gibi cache’e aldırarak gerçekleştirilebilir.</p><h3>Lab: Exploiting path delimiters for web cache deception</h3><p>Laboratuvarımızda web cache deception zafiyeti bulunmaktadır. Bizden istenen carlos kullanıcısının API Key bilgisini elde etmektir.</p><p>wiener:peter kullanıcı bilgileri ile giriş yaptıktan sonra, GET /my-account request&#39;inin sonuna rastgele string karekterle ekleyelim ve response gözlemleyelim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gKsYE_w1rSIOxZV8uHZ_ZQ.png" /></figure><p>Görüldüğü üzere 404 response alıyoruz. Aynı karekterleri delimiter karekterleri kullanarak request’te bulunalım ve origin server’ın ne tepki verdiğini inceleyelim.</p><p>GET /my-account endpoint’imizi Burp Intruder’a gönderelim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8muGtarOTBqQOHW5X7pZ3g.png" /></figure><p>GET /my-account$$sefa olacak şekilde payload’larımızın deneneceği işaretlemeyi yapalım. Delimiter karekterlerin listesine <a href="https://portswigger.net/web-security/web-cache-deception/wcd-lab-delimiter-list">buradaki </a>adresten ulaşabiliriz. Sonrasında payload’ı simple list olarak seçtikten sonra delimiter karekterlerimizi buraya yapıştıralım. Son olarak Payload penceresinin en altında bulunan payload encoding seçeneğini desable yapalım ve salıdırıyı başlatarak response durum kod’larını göre sıralayalım.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ARkhbgTM0Awo6Wz2armWBA.png" /></figure><p>Sonuçları gözlemlediğimizde, ; ve ? karekterlerinin 200 response vermesi bu karekterlerin delimiter olarak kullanıldığını ve server’ın request’i GET /my-account olarak yorumladığını söyleyebiliriz. Burada origin server delimiter karekterden sonrasını görmezden geliyor ve ilk gördüğü my-account endpoint’ine göre response üretiyor.</p><p>Origin server’ın delimiter karekter olarak yorumladığı karekterleri bu kez web cache’in nasıl davrandığını inceleyelim.</p><p>Aynı request’in sonuna .js statik uzantısını ekleyerek ? delimiter karekteri ile request’imizi gönderelim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q-z4nu0_EURcWmrQhhemsg.png" /></figure><p>Aynı response’ı alıyor olmamız ? karekterinin de cache server tarafından delimiter karekter olarak kullanıldığını gösterebilir. Şimdi ise ; delimiter karekterini aynı şekilde kullanalım.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SuzhEahesz2Gk415mIy29Q.png" /></figure><p>Görüldüğü üzere X-Cache:miss header’ından response’ın cache’e alındığını anlıyoruz. Request’i tekrar gönderdiğinizde, X-Cache header&#39;ının hit olarak değiştiğini gözlemliyoruz. Bu durum cache’in ; karakterini delimiter olarak <strong>kullanmadığını </strong>ve .js statik uzantısına dayalı bir cache kuralı olduğunu gösterir.</p><p>Web cache deception zafiyetinin tespitini yaptıktan sonra bizim belirlediğimiz statik uzantılı path’i kurbana göndermemiz ve response’ının cache’e kaydetmesini sağlamamız gerekir. Daha sonra aynı path’e request’te bulunduğumuzda cache’deki kurbanın response’ı bana dönecektir.</p><p>Uygulamamızda exploit server üzerinde bu saldırıyı yapabiliriz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yf2MWKgJAnBpou_QD1JMwQ.png" /></figure><p>Script kodumuzu delimiter karekterini ve statik uzantıyı kullanarak oluşturuyoruz. Store ve deliver exploit to victim butonlarına tıklayarak kurban’a iletilmesini sağlıyoruz. Access log’lardan kurbana iletildiğini gözlemleyebilirsiniz. Daha sonra burp suite ile,</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mfSlWIcQ96xZKxeT3HJhsA.png" /></figure><p>Aynı endpoint’e request’te bulunursak response cache’den kurbanın response’ı olarak döncektir. Elde ettiğimiz API Key bilgisini submit solution’a eklediğimizde,</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HFJlAADJOokqbcFeFCH1ww.png" /></figure><p>Laboratuvar çözümünü başarı ile tamamlıyoruz.</p><h3>Delimiter decoding discrepancies</h3><p><strong>URL’deki Delimiter Karakterlerin Kodlanması:</strong></p><p>Web sitelerinin bazen delimiter’lar gibi URL’lerde özel anlamı olan karakterleri içeren verileri URL’de göndermesi gerekir. Bu karakterlerin veri olarak yorumlanmasını sağlamak için genellikle encoding işlemi yapılır. Ancak bazı parser’lar, URL’i işlemeden önce belirli karakterlerin decoding işlemini yapar. Bir delimiter karakter decode edilirse , URL path’ini kesen bir delimiter olarak değerlendirilebilir.</p><p><strong>Cache ve Origin Server Arasındaki Farklılıklar</strong></p><p>Cache server ve origin server, URL’i farklı şekilde yorumlayabilir. Örneğin, /profile%23wcd.css URL&#39;inde %23, # karakterini temsil eder. Origin server %23&#39;ü decode yapar ve URL&#39;i /profile olarak yorumlar, yani # karakterini bir delimiter olarak kullanır ve devamını görmezden gelir.</p><p>Cache server ise %23&#39;ü decode yapmaz ve URL&#39;i olduğu gibi /profile%23wcd.css olarak kabul eder. Eğer .css uzantısı için bir cache kuralı varsa, bu response’ı cache&#39;e alabilir.</p><p><strong>Cache Server’ının Davranış Farklılıkları</strong></p><p>Bazı cache server’ları , URL’i decode ettikten sonra bu decode URL’i origin server’a iletirken, bazıları önce orijinal (encoding) URL üzerinden cache kurallarını uygular, sonra URL’i encode ederek origin server’a iletir. Bu durum origin server ve cache server’ının URL’i farklı şekillerde işlemesine neden olabilir.</p><p><strong>Örnek Senaryo:</strong></p><p>/myaccount%3fwcd.css URL&#39;inde %3f, ? karakterini temsil eder.</p><p>Cache server , bu URL’i encoding haliyle değerlendirip .css uzantısı nedeniyle cache&#39;e alır ve sonra %3f&#39;i ? karakterine decode eder, URL&#39;i /myaccount?wcd.css olarak origin server’a iletir.</p><p>Origin server ise ? karakterini bir delimiter olarak kullanır ve URL&#39;i /myaccount olarak yorumlar.</p><h3>Exploiting delimiter decoding discrepancies</h3><p>Origin server tarafından değil, cache tarafından görüntülenen path’e statik bir uzantı eklemek için encoding bir delimiter kullanarak decode tutarsızlığından yararlanabiliriz.</p><p>Yukarıda anlattığımız delimiter tutarsızlıklarını tanımlamak ve bunlardan yararlanmak için kullandığınız test metodolojisinin aynısını bu durum için de kullanabiliriz, burada tek fark encoding karakter kullanmak olacaktır. . Ayrıca encoding yazdırılamayan karakterleri, özellikle %00, %0A ve %09&#39;u da test etmemiz gerekir. Bu karakterler decode edilirse URL path’ini de kesebilirler.</p><ul><li>%00: Null karakter</li><li>%0A: Line Feed (LF)</li><li>%09: Horizontal Tab (HT)</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a7317074b3d2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Static Uzantı Olarak Kurgulanan Cache Kurallarının Exploit Edilmesi #Path mapping discrepancies]]></title>
            <link>https://sefayildirimmm.medium.com/static-uzant%C4%B1-olarak-kurgulanan-cache-kurallar%C4%B1n%C4%B1n-exploit-edilmesi-path-mapping-discrepancies-9a9608a6602b?source=rss-1f1223b3b46d------2</link>
            <guid isPermaLink="false">https://medium.com/p/9a9608a6602b</guid>
            <category><![CDATA[path-mapping-discrepancy]]></category>
            <category><![CDATA[portswigger-lab]]></category>
            <category><![CDATA[web-cache-deception]]></category>
            <category><![CDATA[web-security]]></category>
            <dc:creator><![CDATA[Sefa Yıldırım]]></dc:creator>
            <pubDate>Tue, 27 Aug 2024 18:34:10 GMT</pubDate>
            <atom:updated>2024-08-28T20:21:45.601Z</atom:updated>
            <content:encoded><![CDATA[<p>Bir önceki yazımda web cache deception zafiyetini nasıl ortaya çıkarabileceğimize dair teorik anlatımda bulunmuştum. Bu yazıda ise teorik anlatımı detaylandırarak uygulamalı laboratuvar çözümlerine odaklanacağız.</p><p>Cache kuralları genellikle .css veya .js gibi yaygın dosya uzantılarını eşleştirerek statik kaynakları hedefler. Bu durum çoğu CDN’deki varsayılan davranıştır.</p><p>Cache ve origin server’ın URL path’ini kaynaklarla eşleştirme veya delimeter’leri(sınırlayıcıları) kullanma biçiminde farklılıklar varsa, bir saldırgan, origin server tarafından yok sayılan ancak cache tarafından görüntülenen statik uzantılı dinamik bir kaynak için request oluşturabilir.</p><h3>Path mapping discrepancies</h3><p>URL yolu eşleme, bir server’daki dosyalar, script’ler veya command execution gibi kaynakları URL path’leri ile ilişkilendirme işlemidir. Farklı framework’ler ve teknolojiler tarafından kullanılan iki yaygın yol eşleme stili vardır. Bunlar, <strong>Geleneksel URL Eşleme</strong> ve <strong>RESTful URL Eşleme</strong>.</p><h4>Geleneksel URL Eşleme</h4><p>Bu stil, URL’in doğrudan server’ın dosya sistemindeki bir kaynağa giden path’i temsil ettiği anlamına gelir. Örneğin,</p><ul><li>http://example.com/path/in/filesystem/resource.html</li><li>http://example.com: Server’ı işaret eder.</li><li>/path/in/filesystem/: Server’ın dosya sistemindeki dizin yolunu temsil eder.</li><li>resource.html: Erişilen belirli dosyadır.</li></ul><h4>RESTful URL Eşleme</h4><p>Bu stil, fiziksel dosya yapısına doğrudan karşılık gelmez. Bunun yerine dosya yollarını API’ın mantıksal parçalarına ayırır. Örneğin,</p><ul><li>http://example.com/path/resource/param1/param2</li><li>http://example.com: Server’ı işaret eder.</li><li>/path/resource/: Bir kaynağı temsil eden endpoint’tir.</li><li>param1 ve param2: Server’ın request’i işlemesi için kullanılan path parametreleridir.</li></ul><p>Cache ve origin server’ın URL path’ini kaynaklara nasıl eşlediği konusundaki tutarsızlıklar, web cache deception güvenlik açıklarına neden olabilir. Aşağıdaki örneği düşünleim,</p><p>http://example.com/user/123/profile/wcd.css</p><ul><li>RESTful URL eşleme kullanan bir origin server, bu URL’i /user/123/profile endpoint’i için bir request olarak yorumlayabilir ve wcd.css&#39;i önemsiz bir parametre olarak görmezden gelir. Bu durumda, server 123 numaralı kullanıcının profil bilgilerini döndürür.</li><li>Geleneksel URL eşleme kullanan bir cache ise bu URL’i /user/123/profile dizini altında wcd.css adlı bir dosya için bir request olarak görebilir. Yani, URL path&#39;ini /user/123/profile/wcd.css olarak yorumlar. Eğer cache.css ile biten path’ler için response’ları saklamak üzere yapılandırılmışsa, profil bilgilerini CSS dosyasıymış gibi cache’e alır ve saklar.</li></ul><p>Bu tür bir durum, bir saldırganın origin server ve cache arasındaki bu tutarsızlıkları kullanarak web cache deception saldırısı gerçekleştirmesine olanak tanır.</p><h3>Exploiting path mapping discrepancies</h3><p><strong>Origin Server’ı Test Etme</strong></p><p>Origin server’ın URL path’ini kaynaklara nasıl eşlediğini test etmek için, hedef endpoint’in URL’ine rastgele bir path bölümü ekleriz. Eğer response, eklediğimiz bölüm yokmuş gibi aynı hassas verileri içeriyorsa, bu durum server’ın URL path’ini soyutladığını ve eklenen bölümü görmezden geldiğini gösterir. Örneğin, /api/orders/123 path&#39;ini /api/orders/123/sefaolarak değiştirdiğimizde, hala aynı sipariş bilgilerini döndürüyor olması bu duruma örnektir.</p><p><strong>Cache’i Test Etme</strong></p><p>Cache’in URL path’ini kaynaklara nasıl eşlediğini test etmek için, path’in sonuna statik bir uzantı ekleyerek bir cache kuralıyla eşleşip eşleşmediğini kontrol ederiz. Örneğin, /api/orders/123/foo path&#39;ini /api/orders/123/foo.js olarak güncelleriz. Eğer response cache’e alınmışsa, bu durum şunları gösterir,</p><ol><li>Cache’in, statik uzantıyla birlikte tam URL path’ini yorumladığını.</li><li>.js ile biten request’lerin response’larını saklamak için bir cache kuralının var olduğunu.</li></ol><p>Cache’lerin belirli statik uzantılara dayalı kuralları olabilir. .css, .ico ve .exe gibi farklı uzantıları da denemeniz önerilir.</p><p><strong>Saldırı Senaryosu</strong></p><p>Bu testlerden sonra, dinamik bir response döndüren ve cache’e alınan bir URL oluşturabiliriz. Ancak, bu durumun saldırının yalnızca test ettiğimiz belirli endpoint ile sınırlı olduğunu unutmamak gerekir, çünkü origin server farklı endpoint’ler için farklı soyutlama kurallarına sahip olabilir.</p><h3>Lab: Exploiting path mapping for web cache deception</h3><p>Laboratuvarımızda web cache deception zafiyeti bulunmaktadır. Bizden istenen carlos kullanıcısının API Key bilgisini elde etmektir.</p><p>wiener:peter kullanıcı bilgileri ile giriş yaptıktan sonra origin server’ın eklediğimiz path bölümüne nasıl tepki verdiğini gözlemliyoruz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9xttfiSfZul2Iek9iy7sHg.png" /></figure><p>Görüldüğü üzere origin server eklediğimiz path bölümünü görmezden geliyor ve aynı response’ı üretiyor.</p><p>Şimdi ise aynı path bölümüne static dosya uzantısı .js olarak eklediğimde ne olduğunu gözlemleyelim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mjZQ0fSNVrQYMVwzSStJ-w.png" /></figure><p>Response’ı incelediğimizde response’ımızın cache’e alındığını ve aynı içeriği ürettiğini gözlemliyoruz.</p><p>Bu durumda ben kurbanı GET /my-account/sefa1.js enpoint’ine yönlendirebilirsem, kurbanın response’ı cache’e alınacaktır. Ben de daha sonra bu endpoint’e request’te bulunduğumda kurbanın cache’e alınmış response’ı bana dönecektir.</p><p>Bu saldırı için,</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zZyPM4VRf7Q5UxfVDOLjRQ.png" /></figure><p>Exploit server’a script kodumuzu yazarak istediğimiz static uzantılı endpoint’e yönlendirmeyi yapalım. Kurban bu yönlendirmeyi aldıktan sonra,</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*i9j2c1CfocrvHwf3HdBQDg.png" /></figure><p>Aynı endpoint’e request’te bulunduğumuzda görüldüğü üzere carlos kullanıcısının API Key bilgisine ulaşabildiğimizi görüyoruz. API Key bilgisini submit solution’a ekleyerek,</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/976/1*gYQhUYdG-U0r33qUVUPDpA.png" /></figure><p>Laboratuvar çözümünü tamamlıyoruz.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9a9608a6602b" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>