<?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 Orçun ULUTAŞ on Medium]]></title>
        <description><![CDATA[Stories by Orçun ULUTAŞ on Medium]]></description>
        <link>https://medium.com/@orcunulutas?source=rss-4ee03ee848d0------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*HdYE5ip-QwU_vGd_54WyIQ@2x.jpeg</url>
            <title>Stories by Orçun ULUTAŞ on Medium</title>
            <link>https://medium.com/@orcunulutas?source=rss-4ee03ee848d0------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 20:45:18 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@orcunulutas/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[Monster TD3 AIO LCD Ekranını Linux’ta Uyandırmak: Bir Reverse Engineering Hikayesi]]></title>
            <link>https://orcunulutas.medium.com/monster-td3-aio-lcd-ekran%C4%B1n%C4%B1-linuxta-uyand%C4%B1rmak-bir-reverse-engineering-hikayesi-3c58e1735ebb?source=rss-4ee03ee848d0------2</link>
            <guid isPermaLink="false">https://medium.com/p/3c58e1735ebb</guid>
            <category><![CDATA[aio-lcd]]></category>
            <category><![CDATA[usb]]></category>
            <category><![CDATA[reverse-engineering]]></category>
            <category><![CDATA[v8]]></category>
            <category><![CDATA[hardware]]></category>
            <dc:creator><![CDATA[Orçun ULUTAŞ]]></dc:creator>
            <pubDate>Sat, 22 Aug 2026 08:04:50 GMT</pubDate>
            <atom:updated>2026-08-22T08:20:39.888Z</atom:updated>
            <content:encoded><![CDATA[<blockquote><strong><em>Not:</em></strong><em> Bu çalışma, bağımsız bir mühendislik, eğitim ve reverse engineering vaka çalışması kapsamında gerçekleştirilmiştir. Monster veya ilgili donanım üreticileri tarafından geliştirilmiş, desteklenmiş ya da onaylanmış resmi bir çözüm değildir.</em></blockquote><blockquote><em>Burada açıklanan protokol analizi, yazılım ve daemon implementasyonu belirli bir test sistemi ve donanım üzerinde yapılan gözlemlere dayanmaktadır. Farklı donanım revizyonlarında, firmware sürümlerinde veya sistem yapılandırmalarında aynı davranışın görüleceği garanti edilmez.</em></blockquote><blockquote><em>Çalışmanın amacı üretici yazılımının yerini alacak, donanım güvenliğini garanti eden veya üretim ortamında kullanıma hazır bir çözüm sunmak değil; kapalı kaynak bir uygulamanın cihazla iletişiminin nasıl analiz edilebileceğini ve elde edilen bulguların Linux üzerinde deneysel bir istemciye nasıl dönüştürülebileceğini belgelemektir.</em></blockquote><blockquote><em>Uygulama USB/HID üzerinden doğrudan donanımla iletişim kurduğu için kullanımı donanım kararlılığını, sistem davranışını veya cihazın beklenmeyen şekilde çalışmasını etkileyebilir. Bu nedenle kod ve teknik bilgiler eğitim, araştırma ve kontrollü test amacıyla değerlendirilmelidir.</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_ADsx9MDPmpyWmvAcA6Nlw.png" /></figure><h3>Monster AIO LCD protokolünü V8 bytecode’dan çıkarıp çalışan bir HID istemcisine dönüştürme süreci</h3><p>Monster TULPAR sistemimdeki AIO soğutucunun üzerinde bulunan LCD ekran, Windows tarafında üreticinin Electron tabanlı uygulamasıyla kontrol ediliyordu. Linux’a geçtiğimde donanım USB aygıtı olarak görünmeye devam ediyordu; ancak ekranı yönetecek resmi bir Linux uygulaması veya yayımlanmış protokol dokümantasyonu yoktu.</p><p>Amacım yalnızca ekrana rastgele USB paketleri göndermek değildi. Ortaya çıkacak çözümün şu koşulları karşılamasını istiyordum:</p><ul><li>LCD’yi uyandırabilmek,</li><li>Ekranın yeniden kapanmasını önlemek,</li><li>Üretici uygulamasının kullandığı gerçek paket biçimini uygulamak,</li><li>USB bağlantısı kesildiğinde kendini toparlamak,</li><li>Linux üzerinde arka planda servis olarak çalışmak,</li><li>Donanım olmadan test edilebilen protokol bileşenlerine sahip olmak.</li></ul><p>Elimde kaynak kod değil, Electron uygulamasından çıkarılmış derlenmiş bir .jsc dosyası vardı. Çalışmanın çıkış noktası buydu.</p><h3>.jsc dosyasının ne olduğunu belirlemek</h3><p>İlk adım dosya formatını doğru sınıflandırmaktı.</p><p>.jsc uzantısı tek başına standart bir format ifade etmiyor. Farklı JavaScript motorları veya paketleme araçları aynı uzantıyı kullanabiliyor. Bu nedenle dosyanın Hermes bytecode, JavaScriptCore çıktısı veya V8 code cache olup olmadığı doğrudan varsayılamazdı.</p><p>Uygulamanın paket bilgileri incelendiğinde şu çalışma ortamı ortaya çıktı:</p><pre>Monster AIO Cooler v1.0.7<br>Electron 25.9.7<br>V8 11.4</pre><p>Electron sürümü ve dosyanın yapısı, bunun V8 tarafından üretilmiş bir code-cache/bytecode çıktısı olduğunu gösteriyordu.</p><p>Bu ayrım kritik çünkü V8 bytecode sürüme bağımlıdır. Farklı V8 sürümleri opcode numaralarını, snapshot biçimini ve dahili nesne yapılarını değiştirebilir. Dosyayı rastgele bir Node.js sürümüyle açmaya çalışmak, geçersiz bytecode veya uyumsuz cache hataları üretir.</p><p>Dolayısıyla analiz ortamının uygulamanın kullandığı Electron ve V8 sürümüne mümkün olduğunca yakın olması gerekiyordu.</p><h3>Bytecode’u güvenli şekilde incelemek</h3><p>Derlenmiş bir JavaScript artefaktını çalıştırmak ile analiz etmek aynı şey değildir. Dosyanın ne yapacağını bilmediğim için yürütme ortamını doğrudan ana sisteme açmak istemedim.</p><p>Bu amaçla küçük bir Linux sandbox çalıştırıcısı kullandım. Çalıştırıcı:</p><ul><li>Ortam değişkenlerini temizliyor,</li><li>PR_SET_NO_NEW_PRIVS etkinleştiriyor,</li><li>Seccomp ile ağ ve tehlikeli sistem çağrılarını engelliyor,</li><li>Landlock ile dosya sistemi erişimini yalnızca çalışma diziniyle sınırlandırıyor,</li><li>Standart çıktıyı ayrı bir analiz dosyasına yönlendiriyordu.</li></ul><p>Engellenen işlemler arasında şunlar bulunuyordu:</p><pre>socket / connect / bind<br>mount / chroot<br>ptrace<br>process_vm_readv / process_vm_writev<br>kernel module operations<br>keyring operations<br>chmod / chown / xattr değişiklikleri</pre><p>Amaç .jsc dosyasını normal bir uygulama gibi kullanmak değil, V8 runtime’ın yüklediği fonksiyon ve bytecode yapılarını kontrollü biçimde dışarı almaktı.</p><p>Bu işlem sonucunda iki temel çıktı elde ettim:</p><pre>monster_lcd_main.disassembly.txt<br>monster_lcd_main_decompiled.js</pre><p>Birincisi ham V8 bytecode disassembly’sini, ikincisi ise bunun yaklaşık JavaScript rekonstrüksiyonunu içeriyordu.</p><h3>Neden yalnızca decompile edilmiş JavaScript’e güvenmedim?</h3><p>V8 register tabanlı klasik bir sanal makine gibi çalışmaz. Birçok opcode işlemini accumulator üzerinden yürütür. Decompiler’ın accumulator’daki değeri yanlış takip etmesi, ortaya sözdizimsel olarak geçerli fakat anlamsal olarak hatalı JavaScript çıkarabilir.</p><p>Örneğin aşağıdaki türde bir çıktı görülebilir:</p><pre>this[&quot;intervalMS&quot;] = &quot;Set&quot;(scope)</pre><p>Bu ifade kaynak kodda gerçekten Set nesnesinin interval olarak kullanıldığı anlamına gelmez. Ham bytecode incelendiğinde aynı noktada şu opcode görülebilir:</p><pre>LdaSmi.Wide [1000]<br>SetNamedProperty &lt;this&gt;, intervalMS</pre><p>Gerçek anlamı şudur:</p><pre>this.intervalMS = 1000;</pre><p>Bu nedenle analiz boyunca bir kanıt hiyerarşisi kullandım:</p><ol><li>Ham V8 bytecode ve constant pool,</li><li>SharedFunctionInfo metadata’sı,</li><li>Yaklaşık JavaScript rekonstrüksiyonu,</li><li>Gerçek donanım davranışı.</li></ol><p>Decompiler, kod içerisinde gezinmek ve ilgili fonksiyonları bulmak için oldukça faydalıydı. Ancak frame uzunluğu, checksum, timer ve byte dizileri gibi protokol açısından kritik değerleri ham disassembly ile doğruladım.</p><p>SharedFunctionInfo kayıtlarını JavaScript fonksiyonlarıyla eşleştirmek için ayrıca metadata ekleyen küçük bir Node.js aracı kullandım. Böylece her fonksiyonun:</p><ul><li>V8 adresi,</li><li>Orijinal veya inferred adı,</li><li>Fonksiyon türü,</li><li>Parametre sayısı,</li><li>Kaynak pozisyon aralığı</li></ul><p>rekonstrüksiyon üzerine not olarak eklenebildi.</p><p>Bu, binlerce anonim fonksiyon arasında özellikle HID, paketleme ve güç yönetimiyle ilgili akışları takip etmeyi ciddi ölçüde kolaylaştırdı.</p><h3>Protokolü bulmak için semantik işaretlerden ilerlemek</h3><p>Tüm uygulamayı satır satır anlamlandırmaya çalışmak verimli değildi. Bunun yerine protokolü ele veren string ve API çağrılarını aradım.</p><p>Öne çıkan işaretler şunlardı:</p><pre>HID<br>SerialPort<br>powerMonitor<br>SeqNumber<br>AckNumber<br>ContentType<br>ContentLength<br>conn<br>power<br>brightness<br>rotate<br>recovery<br>STATE<br>all<br>resume<br>suspend</pre><p>Bu stringlerin kullanıldığı SharedFunctionInfo blokları takip edildiğinde protokol birkaç katmana ayrıldı:</p><pre>Electron powerMonitor olayları<br>        ↓<br>Komut nesnesinin oluşturulması<br>        ↓<br>HTTP benzeri iç mesaj<br>        ↓<br>Binary frame encoder<br>        ↓<br>HID veya SerialPort transport</pre><p>Aynı uygulama içerisinde medya aktarımı için ayrı bir 0x5C TLV yolu da bulunuyordu. Ancak kontrol komutlarının call graph’ı bu medya yoluna değil, 0x5A delimiter kullanan başka bir frame encoder’a gidiyordu.</p><p>Bu nedenle kontrol ve medya protokollerini birbirinden ayırdım:</p><pre>Kontrol komutları → 0x5A framed protocol<br>Medya blokları   → 0x5C TLV protocol</pre><p>Çalışan LCD istemcisi yalnızca doğrulanmış kontrol yolunu uyguluyor. Medya aktarımı ise blok başlığı ve zamanlama davranışı tam olarak doğrulanana kadar kapsam dışında tutuluyor.</p><h3>İç mesaj biçiminin yeniden oluşturulması</h3><p>Kontrol frame’inin içerisinde HTTP’ye benzeyen fakat tamamen uygulamaya özel bir metin protokolü bulunuyor.</p><p>Bir resume isteğinin payload’u şu şekilde oluşturuluyor:</p><pre>POST power 1\r\n<br>SeqNumber=42\r\n<br>Date=1700000000000\r\n<br>ContentType=json\r\n<br>ContentLength=18\r\n<br>\r\n<br>{&quot;event&quot;:&quot;resume&quot;}</pre><p>İlk satır üç parçadan oluşuyor:</p><pre>METHOD COMMAND VERSION</pre><p>Örneğin:</p><pre>POST power 1<br>STATE all 1</pre><p>Her istekte artan bir SeqNumber bulunuyor. Date alanı epoch milisaniye biçiminde oluşturuluyor.</p><p>JSON body varsa şu iki header ekleniyor:</p><pre>ContentType=json<br>ContentLength=&lt;UTF-8 byte uzunluğu&gt;</pre><p>Burada ContentLength karakter sayısı değil, UTF-8’e çevrilmiş body’nin byte uzunluğu olmalı.</p><p>Header bölümü her durumda şu terminatörle bitiyor:</p><pre>\r\n\r\n</pre><p>Bu kural gövdesiz komutlar için de geçerli. Örneğin POST conn body taşımıyor ancak mesaj yine CRLFCRLF ile sonlanıyor.</p><p>JSON serializasyonunda gereksiz boşlukların kaldırıldığı compact biçim kullanılıyor:</p><pre>{&quot;event&quot;:&quot;resume&quot;}</pre><p>Bu gövde tam olarak 18 byte uzunluğunda.</p><h3>Binary kontrol frame’inin çıkarılması</h3><p>Metin payload’u doğrudan HID’e yazılmıyor. Önce özel bir binary frame içerisine alınıyor.</p><p>Ham bytecode’dan çıkardığım yapı şu şekilde:</p><pre>[0x5A]<br>[escaped(uint16BE(payload_length + 5) + payload + checksum)]<br>[0x5A]</pre><p>Toplam uzunluk alanı:</p><pre>total_length = payload_length + 5</pre><p>olarak hesaplanıyor.</p><p>Buradaki beş byte:</p><ul><li>İki delimiter,</li><li>İki byte big-endian uzunluk,</li><li>Bir byte checksum</li></ul><p>alanından geliyor.</p><p>Checksum yalnızca payload üzerinden hesaplanmıyor. İki byte uzunluk alanı da toplama dahil:</p><pre>checksum =<br>    sum(uint16BE(payload_length + 5) + payload) &amp; 0xFF</pre><p>Bu algoritmayı doğrulamak için küçük ve elle denetlenebilir bir test vektörü kullandım.</p><p>Payload:</p><pre>abc</pre><p>Hex karşılığı:</p><pre>61 62 63</pre><p>Toplam uzunluk:</p><pre>3 + 5 = 8</pre><p>Uzunluk alanı:</p><pre>00 08</pre><p>Checksum:</p><pre>(00 + 08 + 61 + 62 + 63) &amp; FF = 2E</pre><p>Nihai frame:</p><pre>5A 00 08 61 62 63 2E 5A</pre><p>Python testinde bunun tam karşılığı:</p><pre>assert pack_frame(b&quot;abc&quot;).hex() == &quot;5a00086162632e5a&quot;</pre><p>Bu test, frame encoder’ın yalnızca “benzer” değil byte seviyesinde beklenen çıktıyı ürettiğini gösteriyor.</p><h3>Delimiter escape mekanizması</h3><p>0x5A hem başlangıç hem bitiş delimiter’ı olduğu için frame içeriğinde doğrudan bulunamaz. 0x5B ise escape marker olarak kullanılıyor.</p><p>Dönüşüm kuralları:</p><pre>0x5A → 0x5B 0x01<br>0x5B → 0x5B 0x02</pre><p>Encoder, uzunluk alanı, payload ve checksum’dan oluşan iç bölümü tarayarak bu dönüşümü uyguluyor.</p><p>Decoder ise işlemi tersine çeviriyor:</p><pre>0x5B 0x01 → 0x5A<br>0x5B 0x02 → 0x5B</pre><p>Bilinmeyen bir escape kodu, eksik escape dizisi, hatalı uzunluk veya yanlış checksum taşıyan frame geçersiz kabul ediliyor.</p><p>USB okumaları tek seferde tam frame döndürmeyebileceği için decoder incremental tasarlandı. Gelen parçalar bir buffer içinde biriktiriliyor ve yalnızca başlangıç/bitiş delimiter’ları tamamlandığında parse ediliyor.</p><p>Bu sayede aşağıdaki durumlar destekleniyor:</p><ul><li>Bir frame’in birden fazla USB read işlemine bölünmesi,</li><li>Tek read içerisinde birden fazla frame bulunması,</li><li>Frame’ler arasında sıfır padding bulunması,</li><li>Bozuk bir frame’den sonra geçerli frame aranmaya devam edilmesi.</li></ul><h3>HID transport katmanının uygulanması</h3><p>Electron uygulaması cihaz tipine göre hem HID hem de SerialPort transport destekliyordu. Linux tarafında ilk hedef HID oldu.</p><p>Python istemcide hidapi kullanıldı:</p><pre>python3 -m pip install hidapi</pre><p>HID aygıtları önce enumerate edilerek listeleniyor. Böylece vendor ve product ID değerleri tahmin edilmek yerine sistemden doğrulanabiliyor.</p><p>Donanım üzerinde kullanılan kimlik:</p><pre>VID:PID = 1d6b:0130</pre><p>hidapi, unnumbered HID report’larında bile API buffer’ının ilk byte’ında report ID bekliyor. Bu nedenle frame yazılırken başına sıfır report ID ekleniyor:</p><pre>report = b&quot;\x00&quot; + frame<br>device.write(report)</pre><p>Bu sıfır byte, protokol frame’inin bir parçası değil; HID API çağrısının report ID alanı.</p><p>Okuma tarafında ise bazı hidapi sürümleri report ID’yi geri döndürebildiği için, frame delimiter’dan önce gelen sıfır byte toleranslı biçimde kaldırılıyor.</p><p>Cihaz erişiminde sabit bir HID path kullanmak yerine VID, PID, opsiyonel serial number ve interface index üzerinden seçim yapılıyor. USB yeniden bağlandığında path değişebilse bile cihaz tekrar bulunabiliyor.</p><h3>Cihazın başlangıç akışını bulmak</h3><p>Protokol mesajlarını tek tek bulmak yeterli değildi. Cihaz bağlandığında hangi sırayla gönderildiklerini de belirlemek gerekiyordu.</p><p>Uygulamanın cihaz senkronizasyon akışında şu sıra ortaya çıktı:</p><pre>POST conn<br>POST power {}<br>STATE all</pre><p>Bunun ardından sistemin aktif olduğunu bildiren power olayı gönderiliyor:</p><pre>POST power<br>{&quot;event&quot;:&quot;resume&quot;}</pre><p>Böylece başlangıç dizisi şu hale geliyor:</p><pre>conn<br>  ↓<br>power {}<br>  ↓<br>STATE all<br>  ↓<br>power {&quot;event&quot;:&quot;resume&quot;}</pre><p>power {} ile power {&quot;event&quot;:&quot;resume&quot;} aynı komut adı altında gönderilse de farklı amaçlara sahip. İlki başlangıç senkronizasyonunun, ikincisi ise işletim sistemi güç durumunun parçası.</p><p>Electron uygulamasında izlenen güç olayları da bytecode içerisinde açıkça görülüyordu:</p><pre>suspend<br>resume<br>on-ac<br>on-battery<br>shutdown<br>lock-screen<br>unlock-screen</pre><p>Bu olayların tamamı POST power ve JSON içerisindeki event alanı üzerinden cihaza iletiliyor.</p><h3>İlk donanım deneyi: Yanıt yoktu, ekran uyandı</h3><p>Frame encoder ve resume komutu oluşturulduktan sonra ilk gerçek HID deneyi yapıldı.</p><p>İstemci paketi gönderdi ancak iki saniye içerisinde eşleştirilebilir bir cevap bulamadı:</p><pre>UYARI: init yanıtı alınamadı; uyuyan cihaz için resume doğrudan deneniyor.<br>HATA: SeqNumber=10 için 2.0s içinde geçerli yanıt yok</pre><p>Buna rağmen LCD fiziksel olarak açılmıştı.</p><p>Bu gözlem araştırmanın dönüm noktası oldu. Çünkü iki farklı başarı kavramı birbirinden ayrılıyordu:</p><pre>Transport başarısı:<br>Frame HID üzerinden cihaza yazıldı mı?</pre><pre>Protokol cevabı:<br>Cihaz parse edilebilir ve ilgili SeqNumber ile eşleşen ACK döndürdü mü?</pre><p>Donanım, gönderilen komutu uyguladığı halde istemci geçerli bir ACK alamıyordu.</p><p>Bunun birkaç olası nedeni vardı:</p><ul><li>resume isteği için uygulama seviyesinde cevap üretilmiyor olabilir,</li><li>Cevap başka bir HID interface üzerinden geliyor olabilir,</li><li>Report ID veya padding davranışı farklı olabilir,</li><li>Cevap frame’inin henüz ele alınmayan bir çeşidi bulunabilir.</li></ul><p>Fakat ekranın fiziksel olarak açılması, TX paketinin doğru olduğunu güçlü biçimde doğruluyordu.</p><p>Bu nedenle nihai istemcide ACK, resume komutunun başarı koşulu olmaktan çıkarıldı. Gelen cevaplar hâlâ parse ediliyor ve debug telemetrisi olarak gösteriliyor; ancak cevap gelmemesi çalışan gönderimi başarısız hale getirmiyor.</p><h3>Ekranın neden yeniden kapandığını bulmak</h3><p>İlk deney sırasında komut belirli aralıklarla tekrarlandığı sürece ekran açık kalıyordu. İstemci kapandıktan bir süre sonra LCD yeniden sönüyordu.</p><p>Bu davranış, cihaz tarafında bir watchdog veya bağlantı yaşam döngüsü bulunduğunu düşündürdü.</p><p>Bunun üzerine bytecode’daki setInterval, powerMonitor, resumeDevice ve status synchronization fonksiyonlarına odaklandım.</p><p>Ham disassembly’de power event döngüsünde şu değer bulundu:</p><pre>LdaSmi.Wide [1000]<br>setInterval(...)</pre><p>Aynı şekilde status synchronization servisi de constructor içerisinde şu değeri atıyordu:</p><pre>this.intervalMS = 1000</pre><p>Uygulama iki bağımsız saniyelik döngü çalıştırıyordu.</p><p>Birinci döngü, son power event’i bağlı cihazlara tekrar gönderiyordu:</p><pre>POST power<br>{&quot;event&quot;:&quot;resume&quot;}</pre><p>İkinci döngü cihaz durumunu sorguluyordu:</p><pre>STATE all</pre><p>Dolayısıyla üretici uygulamasının davranışı tek seferlik bir “wake” çağrısından ibaret değildi. Uygulama HID bağlantısını açık tutuyor ve her saniye kontrol trafiği oluşturmaya devam ediyordu.</p><p>Tam çalışma modeli şöyleydi:</p><pre>Başlangıç<br>   │<br>   ├── POST conn<br>   ├── POST power {}<br>   ├── STATE all<br>   └── POST power {&quot;event&quot;:&quot;resume&quot;}<br>             │<br>             └── Her 1000 ms<br>                    ├── power/resume<br>                    └── STATE all</pre><p>Bu bulgu, çalışan Linux istemcisinin mimarisini belirledi.</p><h3>Kalıcı istemcinin tasarımı</h3><p>Ortaya çıkan Python uygulaması klasik bir “istek gönder, cevabı bekle, çık” aracı olarak değil, uzun süre çalışan bir daemon olarak tasarlandı.</p><h3>ACK-opsiyonel gönderim</h3><p>Her komutta:</p><ol><li>Artan bir SeqNumber üretiliyor,</li><li>Epoch milisaniye değeri ekleniyor,</li><li>JSON body compact biçimde serialize ediliyor,</li><li>HTTP benzeri payload oluşturuluyor,</li><li>Uzunluk ve checksum hesaplanıyor,</li><li>Escape uygulanıyor,</li><li>HID report yazılıyor.</li></ol><p>Yazma işlemi başarılıysa daemon yaşam döngüsüne devam ediyor. Cevap bulunursa decoder tarafından işleniyor; bulunamazsa bu durum fatal hata sayılmıyor.</p><h3>Bir saniyelik keep-alive</h3><p>Başlangıç dizisinin ardından daemon varsayılan olarak her saniye şunları gönderiyor:</p><pre>power {&quot;event&quot;:&quot;resume&quot;}<br>STATE all</pre><p>İki döngü aynı interval üzerinden yürütülse de ayrı frame olarak yazılıyor.</p><p>Timer uygulamasında geciken çevrimlerin bir anda arka arkaya gönderilmemesine dikkat edildi. Bir transport işlemi beklenenden uzun sürerse kaçırılan tick’ler burst halinde telafi edilmiyor; zamanlayıcı mevcut andan itibaren yeniden dengeleniyor.</p><p>Bu yaklaşım olası USB flooding riskini azaltıyor.</p><p>Komut satırından interval değiştirilebiliyor:</p><pre>--interval 1.0</pre><p>Ancak 100 milisaniyenin altındaki değerler güvenlik amacıyla reddediliyor.</p><h3>Reconnect</h3><p>USB bağlantısı kesildiğinde veya HID write/read işlemi hata verdiğinde daemon:</p><pre>Transport’u kapat<br>       ↓<br>Belirlenen süreyi bekle<br>       ↓<br>Cihazı VID/PID ile yeniden bul<br>       ↓<br>Başlangıç dizisini tekrar gönder<br>       ↓<br>Keep-alive’a devam et</pre><p>Bu sayede servis açıldığında cihaz henüz hazır değilse uygulama kapanmıyor. USB cihazı sonradan geldiğinde bağlantı kurulabiliyor.</p><h3>Kontrollü kapanma</h3><p>Daemon SIGINT ve SIGTERM sinyallerini işliyor.</p><p>Böylece:</p><pre>Ctrl+C</pre><p>veya:</p><pre>systemctl --user stop monster-lcd-keepalive.service</pre><p>kullanıldığında döngü güvenli biçimde duruyor ve HID handle kapatılıyor.</p><h3>Test yaklaşımı</h3><p>Donanım protokolü geliştirirken yalnızca “ekran açıldı” gözlemine güvenmek yeterli değil. Paket oluşturma ve daemon kontrol akışı donanımdan bağımsız olarak test edilebilir olmalıydı.</p><p>Bu nedenle transport katmanını bir interface arkasına aldım:</p><pre>class Transport:<br>    def write_frame(self, frame: bytes) -&gt; int: ...<br>    def read(self, size: int, timeout_ms: int) -&gt; bytes: ...<br>    def close(self) -&gt; None: ...</pre><p>Testlerde gerçek HID aygıtı yerine memory transport kullanılıyor. Yazılan frame’ler bellekte tutuluyor, daha sonra decoder ile tekrar açılarak içerikleri doğrulanıyor.</p><p>Toplam 12 otomatik test şu davranışları kapsıyor:</p><ul><li>Bilinen checksum vektörü,</li><li>Bilinen tam frame vektörü,</li><li>0x5A escape round-trip,</li><li>0x5B escape round-trip,</li><li>Parçalı stream decoding,</li><li>Padding toleransı,</li><li>Bozuk checksum’un reddedilmesi,</li><li>Gövdesiz mesajlarda CRLFCRLF,</li><li>{} JSON gövdesinin kaybolmaması,</li><li>Tam {&quot;event&quot;:&quot;resume&quot;} içeriği,</li><li>ACK gelmeden keep-alive’ın sürmesi,</li><li>Transport hatasından sonra reconnect.</li></ul><p>Test komutu:</p><pre>python3 -m unittest -v \<br>  test_monster_lcd_protocol.py \<br>  test_monster_lcd_daemon_v2.py</pre><p>Sonuç:</p><pre>Ran 12 tests<br>OK</pre><p>Ayrıca systemd unit dosyası da sözdizimi ve bağımlılık açısından doğrulandı:</p><pre>systemd-analyze verify \<br>  systemd/monster-lcd-keepalive.service</pre><h3>Linux üzerinde çalıştırma</h3><p>Bağımlılıklar:</p><pre>python3 -m pip install -r requirements.txt</pre><p>Cihazları listelemek için:</p><pre>python3 monster_lcd_control_fixed_v2.py list</pre><p>LCD daemon’ını başlatmak için:</p><pre>python3 monster_lcd_control_fixed_v2.py \<br>  --transport hid \<br>  --vid 0x1d6b \<br>  --pid 0x0130 \<br>  run</pre><p>Bu komutun terminale geri dönmemesi beklenen davranış. HID bağlantısını açık tutarak keep-alive döngüsünü çalıştırıyor.</p><p>Sınırlı bir test yapmak için çevrim sayısı belirtilebilir:</p><pre>python3 monster_lcd_control_fixed_v2.py \<br>  --transport hid \<br>  --vid 0x1d6b \<br>  --pid 0x0130 \<br>  run --cycles 120</pre><p>Bir saniyelik varsayılan interval ile bu test yaklaşık iki dakika sürüyor.</p><h3>systemd ile otomatik başlatma</h3><p>Daemon’ın kullanıcı oturumu açıldığında otomatik çalışması için repository içerisinde bir systemd user unit bulunuyor.</p><p>Kurulum:</p><pre>mkdir -p ~/.config/systemd/user</pre><pre>cp systemd/monster-lcd-keepalive.service \<br>   ~/.config/systemd/user/</pre><pre>systemctl --user daemon-reload<br>systemctl --user enable --now monster-lcd-keepalive.service</pre><p>Durum kontrolü:</p><pre>systemctl --user status monster-lcd-keepalive.service</pre><p>Canlı log:</p><pre>journalctl --user \<br>  -u monster-lcd-keepalive.service \<br>  -f</pre><p>USB bağlantısı servis başladıktan sonra hazır olsa bile dahili reconnect döngüsü cihazı bulup başlangıç senkronizasyonunu çalıştırıyor.</p><h3>Sonuç</h3><p>Bu çalışmanın başlangıcında elimde yalnızca kapalı kaynak bir Electron uygulamasına ait .jsc dosyası ve Linux üzerinde kontrol edilemeyen bir LCD ekran vardı.</p><p>Çalışan çözüme ulaşmak için izlenen yol şuydu:</p><pre>.jsc artefaktını sınıflandır<br>        ↓<br>V8 sürümünü belirle<br>        ↓<br>Sandbox içinde bytecode disassembly üret<br>        ↓<br>SharedFunctionInfo kayıtlarını fonksiyonlarla eşleştir<br>        ↓<br>HID ve powerMonitor call graph’ını çıkar<br>        ↓<br>HTTP benzeri iç protokolü yeniden oluştur<br>        ↓<br>0x5A framing, checksum ve escaping’i doğrula<br>        ↓<br>Başlangıç ve resume komutlarını belirle<br>        ↓<br>Gerçek donanım üzerinde TX davranışını test et<br>        ↓<br>ACK ile fiziksel başarıyı birbirinden ayır<br>        ↓<br>1000 ms power ve STATE döngülerini bytecode’dan çıkar<br>        ↓<br>Reconnect destekli kalıcı Linux daemon’ı oluştur<br>        ↓<br>Otomatik testler ve systemd ile ürünleştir</pre><p>Buradaki en önemli ders, donanım reverse engineering çalışmalarında tek bir paketi bulmanın yeterli olmamasıydı.</p><p>Ekranı uyandıran frame’i elde etmek protokolün yalnızca bir bölümünü çözüyordu. Gerçek çalışma davranışı; zamanlayıcılar, bağlantı ömrü, cevap politikası, yeniden bağlanma ve işletim sistemi olaylarıyla birlikte ortaya çıkıyordu.</p><p>Sonuçta V8 bytecode içerisindeki kapalı kaynak kontrol mantığı, Linux üzerinde çalışan, test edilebilir ve servis olarak yönetilebilen bağımsız bir HID istemcisine dönüştürüldü.</p><h3>Kaynak kod</h3><p>Protokol implementasyonu, daemon, testler ve systemd servis dosyası:</p><p><a href="https://github.com/orcunulutas/monster-td3-aio-lcd-linux">github.com/orcunulutas/monster-lcd-jsc-decompile</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3c58e1735ebb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Following a Permission Denied Log: Investigating Why Microsoft 365 Couldn’t Open Samsung Email…]]></title>
            <link>https://orcunulutas.medium.com/following-a-permission-denied-log-investigating-why-microsoft-365-couldnt-open-samsung-email-e41f0ed2c678?source=rss-4ee03ee848d0------2</link>
            <guid isPermaLink="false">https://medium.com/p/e41f0ed2c678</guid>
            <category><![CDATA[android-development]]></category>
            <category><![CDATA[microsoft-365]]></category>
            <category><![CDATA[reverse-engineering]]></category>
            <category><![CDATA[debugging]]></category>
            <category><![CDATA[mobile-development]]></category>
            <dc:creator><![CDATA[Orçun ULUTAŞ]]></dc:creator>
            <pubDate>Sat, 18 Jul 2026 08:38:35 GMT</pubDate>
            <atom:updated>2026-07-18T08:38:35.635Z</atom:updated>
            <content:encoded><![CDATA[<h3>Following a Permission Denied Log: Investigating Why Microsoft 365 Couldn’t Open Samsung Email Attachments</h3><blockquote><strong>Disclaimer:</strong> This article reflects an independent technical investigation performed using publicly observable application behavior, Android framework logs, manifest analysis and reverse engineering techniques. It does not represent internal knowledge of either Samsung or Microsoft products.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MYkx-DTnver8GyY5F6yu-Q.png" /></figure><h3><strong>Methodology</strong></h3><p>This article documents a reverse engineering case study based on Android framework logs, publicly observable application behavior, Android manifests, and partially decompiled application code.</p><p>Since neither Samsung Email nor Microsoft 365 is open source, some observations presented here are interpretations derived from reverse engineering rather than statements about the original implementations.</p><p>Whenever the article discusses decompiled execution paths or inferred application behavior, those sections should be understood as engineering hypotheses supported by the available evidence — not verified implementation details.</p><p>Throughout this article, I intentionally distinguish between evidence collected from runtime analysis and interpretations derived from reverse engineering. Readers should interpret the latter accordingly.</p><h3>The Day an Excel File Refused to Open</h3><p><em>A reverse engineering case study of Samsung Email, Microsoft 365 and Android Content Providers</em></p><blockquote><em>“Permission Denied.”</em></blockquote><p>That was all the user could tell us.</p><p>An Excel attachment received through Samsung Email simply refused to open with Microsoft 365.</p><p>Nothing else.</p><p>No crash.</p><p>No stack trace.</p><p>No user-friendly explanation.</p><p>Just a document that worked everywhere else but failed on one specific combination:</p><ul><li>Samsung Email</li><li>Microsoft 365</li><li>Android</li></ul><p>At first glance, it looked like another enterprise policy issue.</p><p>Perhaps an Exchange policy.</p><p>Maybe an Intune restriction.</p><p>Possibly an MDM configuration.</p><p>Those would have been reasonable assumptions.</p><p>However, the available evidence quickly suggested that the problem originated elsewhere.</p><p>This investigation eventually led through Android framework logs, application manifests, reverse engineered code, Android’s Content Provider security model, and finally Android’s modern Scoped Storage architecture.</p><p>This article documents that journey.</p><h3>Reproducing the Issue</h3><p>The problem was surprisingly simple to reproduce.</p><p>A user receives an Excel attachment inside Samsung Email.</p><p>They tap the attachment.</p><p>Samsung Email launches Microsoft 365.</p><p>Instead of opening the workbook, Microsoft 365 immediately reports that the file cannot be opened.</p><p>Visually, the flow should be:</p><pre>Samsung Email<br>        │<br>        ▼<br>Android Intent<br>        │<br>        ▼<br>Microsoft 365<br>        │<br>        ▼<br>Excel document</pre><p>Instead, the process stops before the Office application can even begin loading the workbook.</p><p>The obvious question becomes:</p><blockquote><em>Where exactly does the failure occur?</em></blockquote><h3>Starting with Evidence</h3><blockquote><strong>Evidence:</strong> The observations in this section are taken directly from Android framework logs.</blockquote><p>Rather than making assumptions, the first step was collecting Android debug logs.</p><p>This immediately produced something interesting.</p><pre>Permission Denial: opening provider<br><br>com.samsung.android.email.provider.provider.attachment.AttachmentProvider<br><br>from<br><br>com.microsoft.office.officehubrow<br><br>requires<br><br>com.samsung.android.email.permission.ACCESS_PROVIDER</pre><p>This single message already tells us several important facts.</p><p>First, Microsoft 365 is attempting to access a Content Provider exposed by Samsung Email.</p><p>Second, Android itself — not Microsoft 365 — is rejecting the request.</p><p>Third, the denial occurs before the Office application has access to the attachment.</p><p>Already, the investigation has shifted.</p><p>This is no longer an Office document parsing problem.</p><p>It is becoming an Android framework permission problem.</p><h3>What Exactly Is AttachmentProvider?</h3><p>Android applications cannot simply browse another application’s private storage.</p><p>Instead, Android exposes shared data through Content Providers.</p><p>Think of them as controlled gateways between applications.</p><p>Rather than sharing files directly, an application exposes a URI similar to:</p><pre>content://...</pre><p>The receiving application reads data through that URI.</p><p>In our case the architecture looks approximately like this:</p><pre>Samsung Email<br><br>      │<br><br>AttachmentProvider<br><br>      │<br><br>content:// URI<br><br>      │<br><br>Microsoft 365</pre><p>Everything looked perfectly normal.</p><p>Until Android refused access.</p><h3>Looking Beyond the Error Message</h3><p>Most investigations would probably stop here.</p><p>Permission denied.</p><p>Problem solved.</p><p>Except it wasn’t.</p><p>The error itself raised another question.</p><p>If Samsung Email intentionally shares attachments with external applications…</p><p>Why would Android immediately reject Microsoft’s request?</p><p>Something didn’t fit.</p><p>That inconsistency became the turning point of the investigation.</p><h3>Verifying the Intent</h3><p>The next step was examining the Activity launch itself.</p><p>Android’s WindowManager logs showed the complete Intent used to launch Microsoft 365.</p><p>Among hundreds of lines, one field immediately stood out:</p><pre>flg=0x10000001</pre><p>Decoding the flags reveals:</p><pre>FLAG_ACTIVITY_NEW_TASK<br><br>FLAG_GRANT_READ_URI_PERMISSION</pre><p>This is significant.</p><p>Samsung Email is explicitly granting temporary read permission to the attachment URI.</p><p>In other words…</p><p>Samsung Email appears to be following Android’s recommended file-sharing mechanism.</p><p>So why is Android still producing a Permission Denial?</p><p>At this point the investigation became considerably more interesting.</p><p>The framework logs and the Intent behavior appeared to contradict each other.</p><p>Something deeper was happening.</p><h3>Looking Beyond the Permission Denial</h3><p>At this point, the investigation had already established one important fact:</p><p>Android was denying Microsoft 365 access to Samsung Email’s AttachmentProvider.</p><p>If we had stopped there, it would have been easy to conclude that Samsung Email simply wasn’t allowing Microsoft 365 to read the attachment.</p><p>But Android debugging rarely ends with the first error message.</p><p>The next logical question was:</p><blockquote><strong><em>If Samsung Email launches Microsoft 365 to open the attachment, why would it intentionally deny access to the same application?</em></strong></blockquote><p>Something didn’t add up.</p><p>Instead of assuming the framework log told the entire story, I decided to inspect both applications more closely.</p><h3>Reverse Engineering the Applications</h3><blockquote><strong><em>Reverse Engineering Notice</em></strong></blockquote><blockquote><em>The following analysis is based on a partially decompiled version of the application.</em></blockquote><blockquote><em>Decompiled code does not perfectly reconstruct the original source code. Method names, variable names, control flow and even execution order may differ from the original implementation.</em></blockquote><blockquote><em>The observations below therefore represent an interpretation of the application’s apparent behavior rather than verified implementation details.</em></blockquote><p>Since neither Samsung Email nor Microsoft 365 is open source, the only practical option was reverse engineering.</p><p>I decompiled both APKs using JADX to better understand how attachments were exchanged between the two applications.</p><p>Like most commercial Android applications, complete source reconstruction wasn’t possible. Parts of the code were heavily obfuscated, making it impossible to recover the exact implementation.</p><p>Nevertheless, enough information remained to understand the overall architecture and identify several interesting behaviors.</p><p>Rather than relying solely on runtime logs, I now had two additional sources of evidence:</p><ul><li>Android framework logs</li><li>Decompiled application code</li></ul><p>The next step was comparing them.</p><h3>Inspecting Samsung Email’s Manifest</h3><blockquote><strong>Evidence:</strong> The following findings are based on Samsung Email’s AndroidManifest.xml.</blockquote><p>The AndroidManifest.xml of Samsung Email immediately confirmed something interesting.</p><p>The application’s AttachmentProvider is protected by a custom permission:</p><pre>&lt;permission<br>    android:name=&quot;com.samsung.android.email.permission.ACCESS_PROVIDER&quot;<br>    android:protectionLevel=&quot;signatureOrSystem&quot;/&gt;</pre><p>At first glance, this seems consistent with the framework log.</p><p>Android rejected Microsoft 365 because it doesn’t own this permission.</p><p>However, another manifest entry complicated the picture.</p><p>The provider is also configured with:</p><pre>android:grantUriPermissions=&quot;true&quot;</pre><p>This changes the interpretation significantly.</p><p>According to Android’s Content Provider model, grantUriPermissions=&quot;true&quot; allows an application to temporarily grant another application access to a specific content:// URI without exposing unrestricted access to the provider itself.</p><p>In other words, Based on its manifest configuration, Samsung Email appears to expose two distinct permission mechanisms simultaneously :</p><ul><li>Permanent provider access, restricted to Samsung-signed applications.</li><li>Temporary URI access, granted dynamically through Android Intents.</li></ul><p>This distinction became one of the most important observations during the investigation.</p><h3>Verifying the Intent</h3><blockquote><strong>Evidence:</strong> The following observations are derived directly from Android WindowManager logs.</blockquote><p>To determine which permission model was actually being used, I returned to the Android framework logs.</p><p>The WindowManager output showed the exact Intent used to launch Microsoft 365.</p><p>Among the many parameters, one field immediately stood out:</p><pre>flg=0x10000001</pre><p>Decoding this value reveals two familiar Android flags:</p><ul><li>FLAG_ACTIVITY_NEW_TASK</li><li>FLAG_GRANT_READ_URI_PERMISSION</li></ul><p>This is exactly what Android recommends when sharing private files through a ContentProvider.</p><p>The presence of FLAG_GRANT_READ_URI_PERMISSION strongly suggests that Samsung Email intended to share the attachment using temporary URI permissions rather than unrestricted filesystem access.</p><p>At this point, the evidence appeared contradictory.</p><p>On one hand:</p><ul><li>The provider requires a Samsung-only permission (signatureOrSystem).</li></ul><p>On the other:</p><ul><li>The launching Intent explicitly grants temporary read permission.</li></ul><p>Both observations are true.</p><p>Both are visible in the logs.</p><p>Yet Microsoft 365 still receives a permission-related failure.</p><p>The obvious question became:</p><blockquote><strong><em>What exactly was Microsoft 365 trying to access?</em></strong></blockquote><p>That question eventually shifted the investigation away from Android permissions and toward how Microsoft 365 processes incoming attachment URIs.</p><h3>Following the _data Trail</h3><blockquote><strong>Observation:</strong> The following analysis is derived from reverse engineering and should be interpreted as an inference rather than verified implementation behavior.</blockquote><p>Until this point, every observation came directly from either Android framework logs or Samsung Email’s manifest.</p><p>The next step was understanding what Microsoft 365 actually does after receiving the content:// URI.</p><p>Since the original source code is not publicly available, I continued the investigation using the decompiled application.</p><p>Although large portions of the application were obfuscated, the external file opening workflow was still partially visible.</p><p>That workflow revealed something unexpected.</p><p>Instead of treating the incoming content:// URI purely as a stream, Microsoft 365 appeared to perform additional processing before opening the document.</p><p>One particular code path repeatedly drew my attention.</p><p>During the external open workflow, the application appeared to invoke components responsible for Intune Mobile Application Management (MAM) policy evaluation before the document was opened.</p><p>While analyzing this flow, I noticed references suggesting that the application attempts to retrieve metadata associated with the incoming document.</p><p>One of those metadata fields appeared to be the _data column.</p><p>At this point, it is important to stress that this observation comes from decompiled code and should not be interpreted as Microsoft’s original implementation. Decompiled applications inevitably lose semantic information, and some method names or control flow may not perfectly reflect the original source.</p><p>Nevertheless, the observed execution path was consistent enough to justify further investigation.</p><h3>Why _data Matters</h3><p><em>According to the Android documentation, applications should avoid relying on the </em><em>_data column, which has been deprecated as part of the Scoped Storage model introduced in Android 10.</em></p><p>Developers who have worked with Android for many years may remember the _data column.</p><p>Historically, _data contained the physical filesystem path behind a content:// URI.</p><p>Applications commonly queried it to obtain a File object and continue working with traditional filesystem APIs.</p><p>For years, this was considered common practice.</p><p>That changed with Android 10.</p><p>As part of the Scoped Storage initiative, Google deprecated the use of _data.</p><p>Modern applications are expected to consume the content:// stream directly rather than resolving it into a physical filesystem path.</p><p>In fact, Android documentation explicitly discourages relying on _data, as many providers no longer expose it at all.</p><p>Some providers simply return null.</p><p>Others never implemented it.</p><p>From Android’s perspective, this behavior is perfectly valid.</p><h3>Comparing Different Email Clients</h3><p>To validate this assumption, I compared Samsung Email with another widely used mail client: Gmail.</p><p>Unlike Samsung Email, Gmail exposes attachments through SapiUiProvider.</p><p>Researching both the Android documentation and community discussions revealed that Gmail’s provider does not rely on exposing _data.</p><p>Instead, applications are expected to consume the provided URI as a stream.</p><p>This aligns closely with Android’s modern storage model introduced in API level 29.</p><p>In other words, the physical location of the file is intentionally abstracted away.</p><p>Applications should not need to know where the file resides on disk.</p><p>They simply receive a stream and process it.</p><h3>Correlating the Evidence</h3><p>At this stage, several independent observations had emerged:</p><ul><li>Android framework logs show a Permission Denial originating from Samsung Email&#39;s AttachmentProvider.</li><li>Samsung Email protects its provider using a signatureOrSystem permission while simultaneously enabling temporary URI permissions through grantUriPermissions.</li><li>The launch Intent includes FLAG_GRANT_READ_URI_PERMISSION, indicating that Samsung Email attempts to share the attachment through Android&#39;s recommended mechanism.</li><li>During static analysis of the decompiled application, I identified execution paths that appear to perform additional processing after the incoming URI is received.Although the original source code is unavailable, portions of these execution paths were consistent with classes and components associated with Intune Mobile Application Management (MAM).</li><li>During that workflow, the application appears to access metadata that may include the deprecated _data column.</li><li>Android’s modern storage model no longer guarantees the availability of _data.</li></ul><p>Individually, none of these observations fully explain the failure.</p><p>Together, however, they suggest a plausible explanation.</p><h3>A Working Hypothesis</h3><blockquote><strong>Hypothesis:</strong> The following explanation correlates multiple independent observations but cannot be verified without access to the original source code.</blockquote><p>Based on the available evidence, my working hypothesis is the following:</p><p>Samsung Email appears to share attachments using Android’s modern URI-based sharing model.</p><p>Microsoft 365, however, appears to perform additional metadata validation during its Intune/MAM evaluation process before opening externally shared documents.</p><p>If that validation attempts to resolve information that ultimately depends on filesystem-style metadata — such as _data—the workflow may diverge from Samsung Email&#39;s URI-only sharing model.</p><p>If this interpretation is correct, the observed failure is not caused by either application violating Android’s APIs.</p><p>Instead, it may represent an interoperability issue where two independently valid implementation strategies make different assumptions about how externally shared content should be consumed.</p><p>It is important to emphasize that this remains a hypothesis.</p><p>Without access to Microsoft’s original source code or Samsung’s internal implementation, it is impossible to prove this conclusion definitively.</p><p>However, the Android framework logs, application manifests, decompiled execution paths, and Android’s documented storage model all point toward this explanation.</p><h3>Lessons Learned</h3><p>One of the most valuable aspects of this investigation had nothing to do with Microsoft 365 or Samsung Email.</p><p>It was a reminder that effective debugging is rarely about finding a single log entry.</p><p>Instead, it often requires correlating multiple independent sources of evidence.</p><p>In this case, the investigation combined:</p><ul><li>Android framework logs</li><li>Android manifest analysis</li><li>Reverse-engineered application behavior</li><li>Android platform documentation</li><li>Modern Scoped Storage architecture</li></ul><p>None of these sources alone explained the problem.</p><p>Together, they formed a coherent picture.</p><p>Perhaps the biggest lesson is this:</p><blockquote><strong><em>A “Permission Denied” message isn’t always the root cause. Sometimes it’s merely the first observable symptom of a deeper architectural interaction.</em></strong></blockquote><h3>Conclusion</h3><p>This investigation began with a simple support case: <em>“An Excel attachment won’t open.”</em></p><p>What followed was a journey through Android’s permission framework, Content Providers, manifest analysis, reverse engineering, and Scoped Storage.</p><p>Whether the underlying cause ultimately lies in Samsung Email, Microsoft 365, or the interaction between the two is something only the original development teams can answer with certainty.</p><p>My goal was not to assign blame, but to document the evidence, correlate independent observations, and present a technically grounded hypothesis.</p><p>If nothing else, I hope this case study demonstrates the value of approaching complex platform issues with curiosity rather than assumptions.</p><p>Sometimes the most valuable outcome of debugging is not finding a bug, but understanding where the available evidence ends and engineering inference begins.</p><h3>Limitations</h3><p>Like every reverse engineering exercise, this investigation has several important limitations.</p><ul><li>The original Microsoft 365 source code is unavailable.</li><li>Samsung Email’s internal implementation is proprietary.</li><li>Decompiled code is inherently incomplete and may not exactly match the original implementation.</li><li>Runtime behavior may differ from what is inferred from static analysis.</li></ul><p>For these reasons, this article does <strong>not</strong> claim to identify the definitive root cause.</p><p>Instead, it presents a technically plausible explanation supported by Android framework logs, manifest analysis, platform documentation and reverse engineered execution paths.</p><h3>What This Article Does Not Claim</h3><p>This investigation does <strong>not</strong> claim that:</p><ul><li>Samsung Email contains a defect.</li><li>Microsoft 365 contains a defect.</li><li>Either implementation violates Android platform requirements.</li></ul><p>Instead, it documents a set of observations collected through reverse engineering and Android framework analysis, followed by a technically plausible hypothesis that explains the observed behavior.</p><p>Future evidence or access to the original source code may support, refine, or invalidate this hypothesis.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e41f0ed2c678" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Güvenli Parola Şifreleme ve Çözme İçin Statik ve Zamana Dayalı Token Kullanımı]]></title>
            <link>https://orcunulutas.medium.com/g%C3%BCvenli-parola-%C5%9Fifreleme-ve-%C3%A7%C3%B6zme-i%CC%87%C3%A7in-statik-ve-zamana-dayal%C4%B1-token-kullan%C4%B1m%C4%B1-3a3c087b6ba3?source=rss-4ee03ee848d0------2</link>
            <guid isPermaLink="false">https://medium.com/p/3a3c087b6ba3</guid>
            <category><![CDATA[aes256]]></category>
            <category><![CDATA[encryption]]></category>
            <category><![CDATA[totp]]></category>
            <category><![CDATA[powershell]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Orçun ULUTAŞ]]></dc:creator>
            <pubDate>Sun, 10 Nov 2024 20:01:11 GMT</pubDate>
            <atom:updated>2024-11-10T20:01:11.238Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*AeNxKqK-FJFQtO-Uvr1jJw.png" /></figure><p>Verilerinizi güvende tutmak istiyorsanız, parola yönetim sisteminizin güvenliği en üst düzeyde olmalıdır. Bu yazıda, AES-256 şifreleme algoritması, Azure Key Vault ve hem statik hem de zamana dayalı token kullanarak parola güvenliğini nasıl sağlayabileceğinizi adım adım anlatacağım.</p><p><strong>Giriş</strong></p><p>Modern uygulamalarda parola saklama ve yönetimi, güvenlik açıklarını kapatmak için kritik bir süreçtir. Bu yazıda, <strong>AES-256</strong> şifreleme ile parolanızı güvenli hale getirecek, Azure Key Vault’ta saklayacak ve çözme işlemini iki katmanlı bir token yapısıyla gerçekleştireceğiz. Birinci token sabit (statik), ikinci token ise zamana dayalı olarak değişen bir <strong>TOTP</strong> (Time-Based One-Time Password) olacak.</p><p>Bu yapıyla, hem zamana dayalı güvenliği hem de statik güvenlik kontrolünü sağlayarak uygulamalarınızı daha güvenli hale getireceksiniz.</p><p><strong>Gerekli Kütüphaneler</strong></p><p>Bu uygulama için aşağıdaki Python kütüphanelerine ihtiyacınız olacak:</p><pre>pip install pyotp requests cryptography flask azure-identity azure-keyvault-secrets</pre><p><strong>Adım 1: AES Anahtarını Oluşturma</strong></p><p>AES-256 şifrelemesi için 32 byte (256-bit) uzunluğunda bir anahtar gerekiyor. Bu anahtarı get_random_bytes fonksiyonuyla oluşturacağız. AES, blok şifreleme moduyla çalışır ve NoPadding modunda olduğumuz için şifrelenecek veriyi 16 byte’ın katlarına tamamlamamız gerekiyor.</p><p>Python;</p><pre>from Crypto.Random import get_random_bytes<br><br>def generate_aes_key():<br>    aes_key = get_random_bytes(32)<br>    return aes_key</pre><p>Powershell;</p><pre>function Generate-AESKey {<br>    $aesKey = [System.Security.Cryptography.RandomNumberGenerator]::Create()<br>    $key = New-Object byte[] (32)<br>    $aesKey.GetBytes($key)<br>    [System.Convert]::ToBase64String($key)<br>}<br><br># AES Anahtarı<br>$generatedKey = Generate-AESKey<br>Write-Output &quot;AES Anahtarı (Base64): $generatedKey&quot;</pre><p><strong>Adım 2: Şifreleme ve Şifre Çözme Fonksiyonları</strong></p><p>AES-256 şifrelemesi ile parolayı şifreleyip çözecek fonksiyonları yazıyoruz. Şifreleme işlemi için ECB modunu kullanıyoruz ve NoPadding moduyla çalıştığımız için veriyi elle 16 byte’ın katlarına tamamlıyoruz.</p><pre>import base64<br>from Crypto.Cipher import AES<br><br>def pad_password(password):<br>    while len(password) % 16 != 0:<br>        password += &#39; &#39;<br>    return password<br><br>def encrypt_password(password, aes_key):<br>    cipher = AES.new(aes_key, AES.MODE_ECB)<br>    padded_password = pad_password(password)<br>    encrypted_password = cipher.encrypt(padded_password.encode())<br>    encrypted_password_b64 = base64.b64encode(encrypted_password).decode()<br>    return encrypted_password_b64<br><br>def decrypt_password(encrypted_password_b64, aes_key):<br>    encrypted_password = base64.b64decode(encrypted_password_b64)<br>    cipher = AES.new(aes_key, AES.MODE_ECB)<br>    decrypted_password = cipher.decrypt(encrypted_password).decode()<br>    return decrypted_password.strip()</pre><p><strong>PowerShell (AES Şifreleme ve Şifre Çözme):</strong></p><pre>function Pad-Password($password) {<br>    while ($password.Length % 16 -ne 0) {<br>        $password += &#39; &#39;<br>    }<br>    return $password<br>}<br><br>function Encrypt-Password {<br>    param (<br>        [string]$password,<br>        [byte[]]$aesKey<br>    )<br>    <br>    $aes = [System.Security.Cryptography.Aes]::Create()<br>    $aes.Mode = [System.Security.Cryptography.CipherMode]::ECB<br>    $aes.Key = $aesKey<br>    <br>    $encryptor = $aes.CreateEncryptor()<br>    $paddedPassword = [System.Text.Encoding]::UTF8.GetBytes((Pad-Password -password $password))<br>    $encryptedPassword = $encryptor.TransformFinalBlock($paddedPassword, 0, $paddedPassword.Length)<br>    [System.Convert]::ToBase64String($encryptedPassword)<br>}<br><br>function Decrypt-Password {<br>    param (<br>        [string]$encryptedPasswordB64,<br>        [byte[]]$aesKey<br>    )<br>    <br>    $aes = [System.Security.Cryptography.Aes]::Create()<br>    $aes.Mode = [System.Security.Cryptography.CipherMode]::ECB<br>    $aes.Key = $aesKey<br>    <br>    $decryptor = $aes.CreateDecryptor()<br>    $encryptedPassword = [System.Convert]::FromBase64String($encryptedPasswordB64)<br>    $decryptedPasswordBytes = $decryptor.TransformFinalBlock($encryptedPassword, 0, $encryptedPassword.Length)<br>    ([System.Text.Encoding]::UTF8.GetString($decryptedPasswordBytes)).Trim()<br>}</pre><p><strong>Adım 3: Zamana Dayalı Token (TOTP) ve Statik Token Üretimi</strong></p><p>Bu yapıda iki güvenlik katmanı var: statik token ve zamana dayalı token. <strong>Statik token</strong> gizli bir anahtar olup, istemci ve sunucu arasında paylaşılır. <strong>Zamana dayalı token</strong> ise her istekte değişir ve TOTP kullanarak oluşturulur.</p><p><strong>İstemci Tarafı</strong></p><p>İstemci tarafında statik token ve zamana dayalı token birleştirilir ve sunucuya gönderilir.</p><p><strong>Python (TOTP ve Statik Token):</strong></p><pre>import pyotp<br>import requests<br><br># Statik token (sabit bir gizli anahtar)<br>static_token = &quot;static_secret_token&quot;<br><br># Zamana dayalı token oluşturma (TOTP kullanarak)<br>shared_secret = &quot;JBSWY3DPEHPK3PXP&quot;<br>totp = pyotp.TOTP(shared_secret)<br>time_based_token = totp.now()<br><br># Tokenleri birleştirip sunucuya gönderme<br>combined_token = f&quot;{static_token}:{time_based_token}&quot;<br>response = requests.post(&quot;http://sunucu-adresi/decrypt_password&quot;, json={&quot;token&quot;: combined_token})<br>print(response.json())</pre><p><strong>PowerShell (TOTP ve Statik Token):</strong></p><pre>Install-Module -Name PSSecret -Scope CurrentUser -Force<br><br># Statik token<br>$staticToken = &quot;static_secret_token&quot;<br><br># TOTP oluşturma<br>function Generate-TOTP {<br>    param (<br>        [string]$sharedSecret<br>    )<br>    $otp = New-Object -TypeName PSSecret.OtpAuthenticator -ArgumentList $sharedSecret<br>    $otp.GetCode()<br>}<br><br># TOTP oluştur ve statik token ile birleştir<br>$sharedSecret = &quot;JBSWY3DPEHPK3PXP&quot;<br>$timeBasedToken = Generate-TOTP -sharedSecret $sharedSecret<br>$combinedToken = &quot;$staticToken:$timeBasedToken&quot;<br><br>Write-Output &quot;Birleşik Token: $combinedToken&quot;</pre><p><strong>Adım 4: Sunucu Tarafında Token Doğrulama ve Parola Çözme</strong></p><p>Sunucu, önce gelen tokeni ayrıştırır, ardından her iki tokeni doğrular. Eğer iki token de geçerliyse, Azure Key Vault’ta saklanan şifreli parola AES-256 ile çözülür.</p><p>Python:</p><pre>import pyotp<br>import base64<br>from Crypto.Cipher import AES<br>from flask import Flask, request, jsonify<br>from azure.keyvault.secrets import SecretClient<br>from azure.identity import DefaultAzureCredential<br><br>app = Flask(__name__)<br><br># Azure Key Vault konfigürasyonu<br>vault_url = &quot;https://&lt;key_vault_adresiniz&gt;.vault.azure.net/&quot;<br>credential = DefaultAzureCredential()<br>client = SecretClient(vault_url=vault_url, credential=credential)<br><br># Statik ve zamana dayalı tokenlar için sır değerler<br>static_token_secret = &quot;static_secret_token&quot;  # Sabit token<br>shared_secret = &quot;JBSWY3DPEHPK3PXP&quot;  # TOTP için ortak sır<br><br>def decrypt_password(encrypted_password, aes_key):<br>    cipher = AES.new(aes_key, AES.MODE_ECB)<br>    decrypted_password = cipher.decrypt(base64.b64decode(encrypted_password))<br>    return decrypted_password.strip()<br><br>@app.route(&quot;/decrypt_password&quot;, methods=[&quot;POST&quot;])<br>def decrypt_password_endpoint():<br>    data = request.json<br>    combined_token = data.get(&quot;token&quot;)<br><br>    # Tokenleri ayırma<br>    try:<br>        static_token, time_based_token = combined_token.split(&quot;:&quot;)<br>    except ValueError:<br>        return jsonify({&quot;error&quot;: &quot;Geçersiz token formatı&quot;}), 400<br><br>    # Statik token doğrulama<br>    if static_token != static_token_secret:<br>        return jsonify({&quot;error&quot;: &quot;Geçersiz statik token&quot;}), 403<br><br>    # Zamana dayalı token doğrulama<br>    totp = pyotp.TOTP(shared_secret)<br>    if not totp.verify(time_based_token):<br>        return jsonify({&quot;error&quot;: &quot;Geçersiz veya süresi dolmuş zamana dayalı token&quot;}), 403<br><br>    # Azure Key Vault&#39;tan şifreli parolayı çekme<br>    encrypted_password_secret = client.get_secret(&quot;encrypted-password&quot;)<br>    encrypted_password = encrypted_password_secret.value<br><br>    # AES-256 anahtarıyla şifre çözme<br>    aes_key = b&quot;32byte_AES_key________________&quot;  # 32 byte uzunluğunda anahtar (256 bit)<br>    decrypted_password = decrypt_password(encrypted_password, aes_key)<br><br>    return jsonify({&quot;password&quot;: decrypted_password.decode()})<br><br>if __name__ == &quot;__main__&quot;:<br>    app.run(debug=True)</pre><p><strong>PowerShell (Token Doğrulama ve Parola Çözme):</strong></p><p>PowerShell tarafında, System.Security.Cryptography kullanarak AES ile şifre çözme yapacağız. Ayrıca Azure Key Vault’tan şifreli parolayı almak için gerekli komutları da ekleyeceğiz.</p><pre>Import-Module Az.KeyVault<br><br># Statik token ve TOTP için sır değerler<br>$staticTokenSecret = &quot;static_secret_token&quot;<br>$sharedSecret = &quot;JBSWY3DPEHPK3PXP&quot;<br><br># Azure Key Vault ayarları<br>$vaultName = &quot;&lt;key_vault_adresiniz&gt;&quot;<br>$secretName = &quot;encrypted-password&quot;<br><br># AES anahtarı<br>$aesKey = [Convert]::FromBase64String(&quot;32byte_AES_key________________&quot;)<br><br># TOTP oluşturma fonksiyonu<br>function Generate-TOTP {<br>    param (<br>        [string]$sharedSecret<br>    )<br>    $otp = New-Object -TypeName PSSecret.OtpAuthenticator -ArgumentList $sharedSecret<br>    $otp.GetCode()<br>}<br><br># Token doğrulama fonksiyonu<br>function Verify-Tokens {<br>    param (<br>        [string]$combinedToken,<br>        [string]$expectedStaticToken,<br>        [string]$sharedSecret<br>    )<br><br>    $tokens = $combinedToken -split &#39;:&#39;<br>    if ($tokens.Length -ne 2) { return $false }<br><br>    $staticToken = $tokens[0]<br>    $timeBasedToken = $tokens[1]<br><br>    if ($staticToken -ne $expectedStaticToken) {<br>        return $false<br>    }<br><br>    $otp = New-Object -TypeName PSSecret.OtpAuthenticator -ArgumentList $sharedSecret<br>    if ($otp.GetCode() -ne $timeBasedToken) {<br>        return $false<br>    }<br><br>    return $true<br>}<br><br># AES şifre çözme fonksiyonu<br>function Decrypt-Password {<br>    param (<br>        [string]$encryptedPasswordB64,<br>        [byte[]]$aesKey<br>    )<br><br>    $aes = [System.Security.Cryptography.Aes]::Create()<br>    $aes.Mode = [System.Security.Cryptography.CipherMode]::ECB<br>    $aes.Key = $aesKey<br><br>    $decryptor = $aes.CreateDecryptor()<br>    $encryptedPassword = [System.Convert]::FromBase64String($encryptedPasswordB64)<br>    $decryptedPasswordBytes = $decryptor.TransformFinalBlock($encryptedPassword, 0, $encryptedPassword.Length)<br>    ([System.Text.Encoding]::UTF8.GetString($decryptedPasswordBytes)).Trim()<br>}<br><br># Azure Key Vault&#39;tan şifreli parolayı alma ve çözme<br>function Retrieve-And-Decrypt-Password {<br>    param (<br>        [string]$combinedToken<br>    )<br><br>    # Token doğrulama<br>    if (-not (Verify-Tokens -combinedToken $combinedToken -expectedStaticToken $staticTokenSecret -sharedSecret $sharedSecret)) {<br>        return &quot;Geçersiz veya süresi dolmuş token&quot;<br>    }<br><br>    # Azure Key Vault&#39;tan şifreli parolayı alma<br>    $encryptedPasswordSecret = (Get-AzKeyVaultSecret -VaultName $vaultName -Name $secretName).SecretValueText<br><br>    # Şifreli parolayı çözme<br>    $decryptedPassword = Decrypt-Password -encryptedPasswordB64 $encryptedPasswordSecret -aesKey $aesKey<br>    return $decryptedPassword<br>}<br><br># Kullanım<br>$combinedToken = &quot;static_secret_token:123456&quot;  # Gerçek bir token ile değiştirilmelidir<br>$decryptedPassword = Retrieve-And-Decrypt-Password -combinedToken $combinedToken<br>Write-Output &quot;Çözülmüş Parola: $decryptedPassword&quot;</pre><p><strong>Açıklamalar</strong></p><p>1. <strong>Token Doğrulama</strong>: PowerShell ve Python’da combined_token doğrulanır, statik ve zamana dayalı tokenler kontrol edilir.</p><p>2. <strong>Azure Key Vault ile Parola Alma</strong>: Azure Key Vault’tan şifrelenmiş parolayı almak için PowerShell’de Get-AzKeyVaultSecret komutu, Python’da ise SecretClient nesnesi kullanılır.</p><p>3. <strong>Parola Çözme</strong>: Her iki dilde AES-256 ve ECB moduyla şifre çözme işlemi yapılır. NoPadding moduna dikkat edilmesi gerektiğinden, çözme sonrası gereksiz boşluklar Trim() ya da strip() ile kaldırılır.</p><p>Bu tam bir doğrulama ve şifre çözme sürecidir; her iki dilde de token doğrulaması, şifreli parolanın çözülmesi ve kullanıcıya geri döndürülmesi sağlanır.</p><p><strong>Sonuç</strong></p><p>Bu yapı ile parolanız AES-256 ile güvenli bir şekilde şifrelenip saklanıyor ve iki faktörlü bir token doğrulaması ile yalnızca yetkili erişimlerde çözülüyor. <strong>Statik token</strong> sabit güvenlik sağlarken, <strong>zamana dayalı token</strong> (TOTP) isteğin geçerliliğini ve süresini kontrol ediyor. Azure Key Vault ile de şifreli parola güvenli bir ortamda saklanıyor.</p><p>Bu yöntemi kullanarak veri güvenliğinizi artırabilir ve güvenli parola yönetim sistemlerini uygulamalarınıza entegre edebilirsiniz.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3a3c087b6ba3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Podman ve Snort ile WordPress Güvenlik Test Ortamı Kurulumu: Kubernetes Formatında Adım Adım Rehber]]></title>
            <link>https://orcunulutas.medium.com/podman-ve-snort-ile-wordpress-g%C3%BCvenlik-test-ortam%C4%B1-kurulumu-kubernetes-format%C4%B1nda-ad%C4%B1m-ad%C4%B1m-rehber-9598e4cc1d09?source=rss-4ee03ee848d0------2</link>
            <guid isPermaLink="false">https://medium.com/p/9598e4cc1d09</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[wordpress]]></category>
            <category><![CDATA[snort]]></category>
            <category><![CDATA[güvenlik]]></category>
            <dc:creator><![CDATA[Orçun ULUTAŞ]]></dc:creator>
            <pubDate>Fri, 08 Nov 2024 20:24:07 GMT</pubDate>
            <atom:updated>2024-11-08T20:24:07.681Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*vNeEFrmtM37ZD9Cc3ZVUOw.png" /></figure><p>Bu yazıda, Podman’ın Kubernetes uyumlu yapısını kullanarak bir WordPress güvenlik test ortamı kuracağız. Test ortamımızda, WordPress’e gelen trafiği Snort ile analiz edip güvenlik tehditlerini tespit edeceğiz. Bu yapı, uygulama geliştirme sürecinde güvenlik kontrollerini test etmek için oldukça faydalıdır.</p><p><strong>İçerik</strong></p><p>• Podman Kubernetes uyumluluğu ile ortam kurulumu.</p><p>• WordPress ve MySQL kapsayıcılarının Kubernetes YAML dosyalarıyla başlatılması.</p><p>• Snort için kuralların Kubernetes ortamına entegre edilmesi ve trafiğin izlenmesi.</p><p><strong>1. Giriş</strong></p><p><strong>Podman ve Kubernetes Uyumlu Yapı Nedir?</strong></p><p>Podman, root ayrıcalığı gerektirmeden çalışan bir konteyner yönetim aracıdır. Ayrıca Kubernetes YAML dosyalarını doğrudan çalıştırarak Kubernetes uyumlu bir ortam sağlar. Bu sayede, Kubernetes kümelerine kolay geçiş yapmak isteyenler için yerel test ortamı olarak kullanılabilir.</p><p><strong>Snort Nedir?</strong></p><p>Snort, IDS (Intrusion Detection System) ve IPS (Intrusion Prevention System) olarak işlev görebilen bir güvenlik yazılımıdır. Bu yazıda, Snort’u IDS olarak yapılandırarak, WordPress’e gelen trafiği izleyeceğiz.</p><h3><strong>2. Kubernetes Uyumluluğu ile Test Ortamı Kurulumu</strong></h3><p>Ben test ortamı için Podman i tercih ediyorum</p><p>Podman, Kubernetes YAML dosyalarını çalıştırarak yerel bir Kubernetes benzeri ortam kurmanıza olanak tanır yada farklı bir kubernet ortamına da test senaryosu için kurulum yapılabilir.</p><p><strong>MySQL için Kubernetes YAML Dosyası (mysql-deployment.yaml)</strong></p><pre>apiVersion: v1<br>kind: Pod<br>metadata:<br>  name: mysql-pod<br>spec:<br>  containers:<br>    - name: mysql-container<br>      image: mysql:5.7<br>      ports:<br>        - containerPort: 3306<br>      env:<br>        - name: MYSQL_ROOT_PASSWORD<br>          value: &quot;rootpassword&quot;<br>        - name: MYSQL_DATABASE<br>          value: &quot;wordpress&quot;<br>        - name: MYSQL_USER<br>          value: &quot;wordpress&quot;<br>        - name: MYSQL_PASSWORD<br>          value: &quot;wordpresspassword&quot;<br>      volumeMounts:<br>        - mountPath: /var/lib/mysql<br>          name: mysql-storage<br>  volumes:<br>    - name: mysql-storage<br>      emptyDir: {}</pre><p><strong>WordPress için Kubernetes YAML Dosyası (wordpress-deployment.yaml)</strong></p><pre>apiVersion: v1<br>kind: Pod<br>metadata:<br>  name: wordpress-pod<br>spec:<br>  containers:<br>    - name: wordpress-container<br>      image: wordpress<br>      ports:<br>        - containerPort: 80<br>          hostPort: 8080<br>      env:<br>        - name: WORDPRESS_DB_HOST<br>          value: &quot;mysql-pod:3306&quot;<br>        - name: WORDPRESS_DB_NAME<br>          value: &quot;wordpress&quot;<br>        - name: WORDPRESS_DB_USER<br>          value: &quot;wordpress&quot;<br>        - name: WORDPRESS_DB_PASSWORD<br>          value: &quot;wordpresspassword&quot;</pre><p><strong>Snort için Kubernetes YAML Dosyası (snort-deployment.yaml)</strong></p><pre>apiVersion: v1<br>kind: Pod<br>metadata:<br>  name: snort-pod<br>spec:<br>  containers:<br>    - name: snort-container<br>      image: docker.io/jasonish/snort3<br>      command: [&quot;snort&quot;, &quot;-c&quot;, &quot;/etc/snort/snort.conf&quot;, &quot;-i&quot;, &quot;eth0&quot;]<br>      volumeMounts:<br>        - mountPath: /etc/snort/rules<br>          name: snort-rules-volume<br>  volumes:<br>    - name: snort-rules-volume<br>      hostPath:<br>        path: ./snort-rules</pre><p><strong>Podman ile Kubernetes YAML Dosyalarını Çalıştırma</strong></p><p>YAML dosyalarını çalıştırmak için podman play kube komutunu kullanın:</p><pre>podman play kube mysql-deployment.yaml<br>podman play kube wordpress-deployment.yaml<br>podman play kube snort-deployment.yaml</pre><p><strong>3. Snort Kurulumu ve Kuralların Kubernetes Ortamına Entegre Edilmesi</strong></p><p>WordPress’e gelen trafiği izlemek için Snort’u Kubernetes podu olarak yapılandıracağız.</p><p><strong>Adım 1: Snort Kural Dosyalarını Hazırlama</strong></p><p>Snort’un trafiği analiz edebilmesi için bazı güvenlik kuralları yazmamız gerekiyor. Aşağıdaki örnek kuralları ./snort-rules/local.rules dosyasında saklayacağız.</p><p><strong>Snort Kural Yazma Rehberi</strong></p><p>Snort kuralları, saldırı tespiti için oluşturulan mantıksal ifadelerden oluşur. Her kural, bir saldırıyı tanımlamak ve belirli bir protokol, kaynak veya hedef IP adresini izlemek üzere yapılandırılır.</p><ul><li><strong>Kural Formatı</strong>:</li></ul><pre>[action] [protocol] [source IP] [source port] -&gt; [destination IP] [destination port] (msg:&quot;message&quot;; options)</pre><p>• <strong>action</strong>: Kuralın yapılmasını istediği eylem. Örneğin, alert (uyarı).</p><p>• <strong>protocol</strong>: Kuralın izlediği protokol (örneğin, tcp, udp).</p><p>• <strong>source IP</strong>: Kaynak IP adresi.</p><p>• <strong>destination IP</strong>: Hedef IP adresi.</p><p>• <strong>msg</strong>: Tespit edilen saldırı ile ilgili kısa açıklama.</p><p>• <strong>options</strong>: Diğer kural parametreleri (örneğin, content, http_uri).</p><p><strong>Örnek Kurallar</strong></p><ol><li><strong>SQL Injection Basit Örneği</strong>:</li></ol><pre>alert tcp any any -&gt; any 80 (msg:&quot;SQL Injection attempt detected&quot;; content:&quot;UNION SELECT&quot;; http_uri; sid:100001; rev:1;)</pre><p>• <strong>content</strong>: “UNION SELECT” ifadesini içeriyorsa SQL Injection tespiti yapar.</p><p>2. <strong>Brute Force Tespiti</strong>:</p><pre>alert tcp any any -&gt; any 80 (msg:&quot;Brute force login attempt&quot;; content:&quot;POST /wp-login.php&quot;; threshold:type both, track by_src, count 5, seconds 60; sid:100002; rev:1;)</pre><ul><li><strong>threshold</strong>: Bir dakika içinde beş kez wp-login.php giriş denemesi varsa brute force tespiti yapar.</li></ul><p>• <strong>wp-login.php brute force saldırılarını algılama:</strong></p><p>WordPress sitelerinde brute force saldırılarını tespit etmek için, “wp-login.php” dosyasına çok sayıda istek yapılması izlenebilir.</p><pre>alert tcp $EXTERNAL_NET any -&gt; $HOME_NET 80 (msg:&quot;WordPress wp-login.php brute force attempt&quot;; \<br>content:&quot;POST /wp-login.php&quot;; flow:to_server,established; detection_filter:track by_src, count 10, seconds 60; \<br>sid:1000001; rev:1;)</pre><p>Bu kural, aynı IP’den kısa bir süre içinde 10’dan fazla istek yapılması durumunda brute force saldırısını algılar.</p><p>Aşağıdaki kural, belirli bir kullanıcı adıyla (admin) yapılan giriş denemelerini takip eder. Aynı kullanıcı adına, farklı IP adreslerinden belirli bir süre içinde yapılan giriş denemeleri eşik değerini aşarsa kural tetiklenir ve alarm verir.</p><pre>alert tcp any any -&gt; any 80 (msg:&quot;Distributed brute force login attempt detected for user &#39;admin&#39;&quot;; content:&quot;POST /wp-login.php&quot;; http_method; content:&quot;username=admin&quot;; http_client_body; threshold: type both, track by_dst, count 10, seconds 300; sid:100006; rev:1;)</pre><ul><li><strong>msg</strong>: Kural tetiklendiğinde logda gösterilecek mesaj. Burada, belirli bir kullanıcıya yönelik brute force girişimini tanımlıyor.</li><li><strong>content:“POST /wp-login.php”</strong>: WordPress giriş sayfasına yapılan POST isteklerini takip eder.</li><li><strong>http_method</strong>: HTTP metodunun POST olup olmadığını kontrol eder.</li><li><strong>content:“username=admin”</strong>: HTTP isteği gövdesinde, belirli bir kullanıcı adına (admin) yapılan giriş denemelerini hedefler. admin kullanıcı adı yerine farklı bir kullanıcı adı belirleyebilirsiniz.</li><li><strong>http_client_body</strong>: HTTP isteğinin gövdesinde username parametresini arar.</li><li><strong>threshold</strong>: Eşik belirler. Burada, track by_dst ile aynı hedef IP adresine yapılan giriş denemelerini takip ediyoruz.</li><li><strong>type both</strong>: Hem belirlenen süre içinde ardışık denemeler hem de belirtilen sayıya ulaşılması durumunda alarm verir.</li><li><strong>track by_dst</strong>: Hedef IP adresine göre izler (WordPress sunucusu).</li><li><strong>count 10</strong>: 10 giriş denemesine ulaşıldığında tetiklenir.</li><li><strong>seconds 300</strong>: Belirtilen eşik değeri (10 deneme) 300 saniye (5 dakika) içinde sağlanırsa tetiklenir.</li></ul><p>3. <strong>Dosya Yükleme Tespiti</strong>:</p><pre>alert tcp any any -&gt; any 80 (msg:&quot;File upload attempt detected&quot;; content:&quot;multipart/form-data&quot;; content:&quot;filename=&quot;; http_client_body; sid:100003; rev:1;)</pre><ul><li><strong>content</strong>: filename= ifadesini arar ve dosya yüklemeleri takip eder.</li></ul><pre>alert tcp any any -&gt; any 80 (msg:&quot;Executable file upload attempt detected&quot;; file_data; content:&quot;MZ&quot;; offset:0; sid:100004; rev:1;)</pre><ul><li><strong>file_data</strong>: HTTP isteğinin gövdesini işaret eder, böylece dosya başlığındaki veriyi inceleyebiliriz.</li><li><strong>content:“MZ”</strong>: Dosyanın MZ ile başladığını kontrol eder, .exe dosyalarının tanımlayıcı sihirli sayısıdır.</li><li><strong>offset:0</strong>: Dosya başlığının başlangıcını işaret eder, böylece ilk baytları kontrol ederiz.</li></ul><p>Başka dosya türleri için de benzer kontroller yapılabilir. Örneğin, PDF dosyaları %PDF- ile başlar, JPEG dosyaları FFD8FF hex değeri ile başlar. Aşağıda JPEG dosyaları için bir örnek bulunmaktadır:</p><pre>alert tcp any any -&gt; any 80 (msg:&quot;JPEG file upload attempt detected&quot;; file_data; content:&quot;|FF D8 FF|&quot;; offset:0; sid:100005; rev:1;)</pre><ul><li><strong>content:”|FF D8 FF|”</strong>: JPEG dosyaları için karakteristik bir sayı olan FFD8FF baytlarını arar.</li></ul><p><strong>Adım 2: Snort Kubernetes Pod Yapılandırması</strong></p><p>Snort’u Kubernetes podu olarak çalıştıracağız. ./snort-rules dizinindeki kuralları mount ederek Snort’un bu kuralları kullanmasını sağlayacağız.</p><pre>apiVersion: v1<br>kind: Pod<br>metadata:<br>  name: snort-pod<br>spec:<br>  containers:<br>    - name: snort-container<br>      image: docker.io/jasonish/snort3<br>      command: [&quot;snort&quot;, &quot;-c&quot;, &quot;/etc/snort/snort.conf&quot;, &quot;-i&quot;, &quot;eth0&quot;]<br>      volumeMounts:<br>        - mountPath: /etc/snort/rules<br>          name: snort-rules-volume<br>  volumes:<br>    - name: snort-rules-volume<br>      hostPath:<br>        path: ./snort-rules</pre><p>Bu dosyayı snort-deployment.yaml olarak kaydedin ve aşağıdaki komutla Snort podunu başlatın:</p><pre>podman play kube snort-deployment.yaml</pre><p><strong>Adım 3: Kubernetes Ortamında Snort Kurallarını Güncelleme</strong></p><p>Kural dosyalarını güncellemek için ./snort-rules/local.rules dosyasında değişiklik yapabilirsiniz. Kuralları değiştirdikten sonra Snort podunu yeniden başlatmanız gerekecek:</p><pre>podman pod restart snort-pod</pre><p>Bu işlem, yeni kuralların aktif hale gelmesini sağlar.</p><p><strong>4. Test Senaryoları ile Trafik İzleme</strong></p><p>Artık WordPress trafiğini izlemek ve Snort kurallarını test etmek için çeşitli saldırı senaryolarını deneyebiliriz.</p><p><strong>Test 1: SQL Injection</strong></p><p>Aşağıdaki URL’yi açarak SQL Injection saldırısını tetiklemeyi deneyin:</p><pre>http://localhost:8080/?id=1+UNION+SELECT</pre><p><strong>Test 2: Brute Force</strong></p><p>WordPress giriş sayfasında birçok başarısız giriş denemesi yaparak brute force saldırısını simüle edin.</p><p><strong>Snort Loglarını İnceleme</strong></p><p>Yukarıdaki test saldırılarını yaptıktan sonra, Snort podunda üretilen alarmları ve logları kontrol edebilirsiniz. Logları görmek için aşağıdaki komutu kullanabilirsiniz:</p><pre>podman exec -it snort-pod cat /var/log/snort/alert</pre><p>Örneğin, SQL Injection veya brute force gibi bir saldırı Snort tarafından algılandığında, log dosyasında aşağıdakine benzer bir uyarı görüntülenir:</p><pre>11/08-12:34:56.789123  [**] [100001:1:0] SQL Injection attempt detected [**] [Priority: 0] {TCP} 192.168.1.1:443 -&gt; 172.17.0.2:80</pre><p>Bu log, saldırının IP adreslerini ve kullanılan protokolü belirterek ayrıntılı bilgi sağlar.</p><p><strong>Sonuç</strong></p><p>Bu rehberde, Podman’ın Kubernetes uyumluluğunu kullanarak WordPress ve MySQL kapsayıcıları ile bir güvenlik test ortamı kurduk. Snort’u IDS olarak kullanarak, saldırı girişimlerini tespit edebilmek için çeşitli kurallar yazdık. Ayrıca, Snort kurallarını güncelleyip Kubernetes ortamında aktif hale getirmenin yolunu gösterdik.</p><p>Bu yapı, kapsayıcı tabanlı bir WordPress uygulaması için güvenlik testi yaparken ihtiyacınız olan esnekliği sağlar. Aynı zamanda Podman’ın Kubernetes uyumluluğu sayesinde, bu ortamı Kubernetes kümelerine taşımak oldukça kolaydır.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9598e4cc1d09" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Golang ile ADFS Entegrasyonu: crewjam/saml Kullanımı]]></title>
            <link>https://orcunulutas.medium.com/golang-ile-adfs-entegrasyonu-crewjam-saml-kullan%C4%B1m%C4%B1-5139e4a95a38?source=rss-4ee03ee848d0------2</link>
            <guid isPermaLink="false">https://medium.com/p/5139e4a95a38</guid>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[saml2]]></category>
            <category><![CDATA[saml2-sso]]></category>
            <category><![CDATA[go]]></category>
            <dc:creator><![CDATA[Orçun ULUTAŞ]]></dc:creator>
            <pubDate>Fri, 01 Mar 2024 08:38:28 GMT</pubDate>
            <atom:updated>2024-03-01T08:39:14.008Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_wVAaAfjSw1mNdRmtb645A.png" /></figure><p>Günümüzde Single Sign-On (SSO) yetenekleri, kullanıcıların birden fazla sistem veya uygulamaya tek bir kimlik doğrulama mekanizması ile erişimini sağlayarak, güvenlik ve kullanıcı deneyimini önemli ölçüde iyileştirmektedir. Bu yazıda, Golang tabanlı bir uygulamanın, Active Directory Federation Services (ADFS) kullanarak SSO yetenekleri nasıl entegre edebileceğini crewjam/saml kütüphanesi üzerinden adım adım anlatacağız.</p><p>ADFS, Microsoft’un SAML protokolünü destekleyen bir Kimlik Sağlayıcı servisidir. Bu servis, farklı uygulamalar arasında güvenli bir şekilde kimlik bilgisi paylaşımı yapılmasını sağlar. crewjam/saml kütüphanesi ise Golang projelerinde SAML tabanlı kimlik doğrulama işlemlerini kolaylaştıran popüler bir kütüphanedir. Aşağıda, bu kütüphaneyi kullanarak nasıl bir ADFS entegrasyonu yapabileceğiniz üzerine bir örnek sunulmaktadır.</p><h3>Gerekli Paketlerin İmport Edilmesi</h3><pre>import (<br> &quot;context&quot;<br> &quot;crypto/rsa&quot;<br> &quot;crypto/tls&quot;<br> &quot;crypto/x509&quot;<br> &quot;fmt&quot;<br> &quot;log&quot;<br> &quot;net/http&quot;<br> &quot;net/url&quot;<br> &quot;github.com/crewjam/saml/samlsp&quot;<br>)</pre><p>Bu bölümde, entegrasyon için gerekli olan standart Go paketleri ve crewjam/saml/samlsp kütüphanesi import edilmektedir.</p><h3>Ön Tanımlamalar ve URL’ler</h3><pre>var (<br> metdataurl = &quot;https://fs.example.com/federationmetadata/2007-06/FederationMetadata.xml&quot;<br> sessioncert = &quot;./sessioncert&quot;<br> sessionkey = &quot;./sessionkey&quot;<br> servercert = &quot;./servercert&quot;<br> serverkey = &quot;./serverkey&quot;<br> serverurl = &quot;https://yourapp.example.com:8000&quot;<br> listenAddr = &quot;0.0.0.0:8000&quot;<br>)</pre><p>Bu kısımda, IDP (Identity Provider — Kimlik Sağlayıcı) tarafından sağlanan metadata URL’si, SSL/TLS için kullanılacak sertifika dosyalarının yolları ve uygulamanın dinleyeceği adres gibi önemli bilgiler tanımlanmaktadır.</p><h3>Hello Handler Fonksiyonu</h3><pre>func hello(w http.ResponseWriter, r *http.Request) {<br> // Kullanıcı session bilgisi ve attribute&#39;larını yazdırma<br>  s := samlsp.SessionFromContext(r.Context())<br>   if s == nil {<br>      return<br>   }<br>   sa, ok := s.(samlsp.SessionWithAttributes)<br>   if !ok {<br>      return<br>   }<br><br>   fmt.Fprintf(w, &quot;Token contents, %+v!&quot;, sa.GetAttributes())<br>}</pre><p>Bu fonksiyon, başarılı bir SSO oturumunun ardından kullanıcıya özel bilgileri (örneğin, kullanıcı öznitelikleri) göstermek için basit bir HTTP handler olarak işlev görür.</p><h3>SAML Yapılandırma ve Oturum Yönetimi</h3><p>Bu örnekte, samlsp.New fonksiyonu ile bir SAMLSP nesnesi oluşturulmakta ve bu nesne üzerinden SAML oturum yönetimi ve kimlik doğrulama akışı yönetilmektedir. AllowIDPInitiated seçeneği, IDP tarafından başlatılan oturumların kabul edilip edilmeyeceğini belirler.</p><pre>samlSP, _ := samlsp.New(samlsp.Options{<br>  URL:         *rootURL,<br>  Key:         keyPair.PrivateKey.(*rsa.PrivateKey),<br>  Certificate: keyPair.Leaf,<br>  IDPMetadata: idpMetadata, <br>  AllowIDPInitiated: true,<br> })</pre><p><strong>Start.sh hazırlanması</strong></p><pre>#!/bin/bash<br><br># Ortam değişkenlerini ayarla<br>export METADATA_URL=&quot;https://idpServer/federationmetadata/2007-06/FederationMetadata.xml&quot;<br>export SESSION_CERT=&quot;./sessioncert&quot;<br>export SESSION_KEY=&quot;./sessionkey&quot;<br>export SERVER_KEY=&quot;./serverkey&quot;<br>export SERVER_CERT=&quot;./servercert&quot;<br>export SERVER_URL=&quot;https://localhost:8000&quot;<br>export LISTEN_ADDR=&quot;0.0.0.0:8000&quot;<br><br># Uygulamayı çalıştır<br>go run ./cmd/app</pre><p>uygulamamıza ilgili ayarları env değişkenkenleri ile sağlayacağımız için start.sh da env ları da belirterek uygulama çalıştırma özelliğini kazandırıyoruz. Öncesinde SSL sertifikası generate edilmesi ve start.sh altında da path lerinin belirtilmesi gerekir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/414/1*N3jiujKpNK-QQ8isdu-u5w.png" /></figure><p>env değerlerini okuması için bir cmd\internal\config paketi altında bir config.go dosyası hazırlıyoruz ;</p><pre>package config<br><br>import &quot;os&quot;<br><br>type Config struct {<br> MetadataURL string<br> SessionCert string<br> SessionKey  string<br> ServerKey   string<br> ServerCert  string<br> ServerURL   string<br> ListenAddr  string<br>}<br><br>func LoadConfig() (*Config, error) {<br> return &amp;Config{<br>  MetadataURL: os.Getenv(&quot;METADATA_URL&quot;),<br>  SessionCert: os.Getenv(&quot;SESSION_CERT&quot;),<br>  SessionKey:  os.Getenv(&quot;SESSION_KEY&quot;),<br>  ServerKey:   os.Getenv(&quot;SERVER_KEY&quot;),<br>  ServerCert:  os.Getenv(&quot;SERVER_CERT&quot;),<br>  ServerURL:   os.Getenv(&quot;SERVER_URL&quot;),<br>  ListenAddr:  os.Getenv(&quot;LISTEN_ADDR&quot;),<br> }, nil<br>}</pre><p>cmd\internal\server paketinde server.go dosyası oluşturuyoruz;</p><pre>package server<br><br>import (<br> &quot;net/http&quot;<br> &quot;path/filepath&quot;<br> &quot;vkmanagment/cmd/internal/config&quot;<br> &quot;vkmanagment/cmd/internal/handlers&quot;<br><br> &quot;github.com/crewjam/saml/samlsp&quot;<br>)<br><br>func StartHTTPServer(samlSP *samlsp.Middleware, cfg *config.Config) {<br><br> http.Handle(&quot;/saml/&quot;, samlSP)<br> http.Handle(&quot;/hello&quot;, samlSP.RequireAccount(http.HandlerFunc(handlers.Hello)))<br><br> err := http.ListenAndServeTLS(cfg.ListenAddr, cfg.ServerCert, cfg.ServerKey, nil)<br> if err != nil {<br>  panic(&quot;HTTP sunucusu başlatılırken hata: &quot; + err.Error())<br> }<br>}</pre><p>server.go ile Handle fonksiyonlarını tanımlıyoruz. ADFS le login korumasına ihtiyaç duyulan sayfalarda handler’larsamlSP.RequireAccount() fonksiyonu altında belirtilmesi gerekiyor.</p><p>cmd\internal\saml paketi altnda da metaurl’leri işleyeceğimiz fonksiyonları tanımlıyoruz ;</p><pre>package saml<br><br>import (<br> &quot;context&quot;<br> &quot;crypto/rsa&quot;<br> &quot;crypto/tls&quot;<br> &quot;crypto/x509&quot;<br> &quot;log&quot;<br> &quot;net/http&quot;<br> &quot;net/url&quot;<br> &quot;vkmanagment/cmd/internal/config&quot;<br><br> &quot;github.com/crewjam/saml/samlsp&quot;<br>)<br><br>func InitializeSAMLServiceProvider(cfg *config.Config) (*samlsp.Middleware, error) {<br> keyPair, err := tls.LoadX509KeyPair(cfg.SessionCert, cfg.SessionKey)<br> if err != nil {<br>  return nil, err<br> }<br> keyPair.Leaf, err = x509.ParseCertificate(keyPair.Certificate[0])<br> if err != nil {<br>  return nil, err<br> }<br><br> rootURL, err := url.Parse(cfg.ServerURL)<br> if err != nil {<br>  return nil, err<br> }<br><br> metadataURL := mustParseURL(cfg.MetadataURL)<br> ctx := context.Background()<br> client := http.DefaultClient<br> idpMetadata, err := samlsp.FetchMetadata(ctx, client, *metadataURL)<br> if err != nil {<br>  log.Fatalf(&quot;IDP metadata yüklenirken hata: %v&quot;, err)<br> }<br> samlSP, err := samlsp.New(samlsp.Options{<br>  URL:               *rootURL,<br>  Key:               keyPair.PrivateKey.(*rsa.PrivateKey),<br>  Certificate:       keyPair.Leaf,<br>  IDPMetadata:       idpMetadata,<br>  AllowIDPInitiated: true,<br> })<br> if err != nil {<br>  return nil, err<br> }<br><br> return samlSP, nil<br>}<br><br>func mustParseURL(rawURL string) *url.URL {<br> parsedURL, err := url.Parse(rawURL)<br> if err != nil {<br>  panic(&quot;URL parse hatası: &quot; + err.Error())<br> }<br> return parsedURL<br>}</pre><p>son olarak cmd\internal\handlers altında handle fonksiyonunu oluşturarak artık tokenları ekrana yazdırıyoruz ;</p><pre>func Hello(w http.ResponseWriter, r *http.Request) {<br> s := samlsp.SessionFromContext(r.Context())<br> if s == nil {<br>  return<br> }<br> sa, ok := s.(samlsp.SessionWithAttributes)<br> if !ok {<br>  return<br> }<br> CreateToken(w, sa.GetAttributes().Get(&quot;http://schemas.xmlsoap.org/ws/2005/05/identity/claims/upn&quot;))<br><br> fmt.Fprintf(w, &quot;Token contents, %+v!\n&quot;, sa.GetAttributes())<br> fmt.Fprintf(w, &quot;UPN, %+v!&quot;, sa.GetAttributes().Get(&quot;http://schemas.xmlsoap.org/ws/2005/05/identity/claims/upn&quot;))<br> <br>}</pre><h4>ADFS Ayarları;</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AYMi3hnXo1g5U846XyvI7w.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nWJ59gzRwH9hlsfMAjm9WQ.png" /></figure><p>crewjam\saml kütüphanesi bizim yerimize uygulamamız için metadata xml yayınlanmasını sağlıyor olacak url formatı olarak saml/metadata üzerinden erişim sağlanabiliyor olacaktır.</p><p>crewjam\saml tarafından yayınlanan metadata url yardımıyla ADFS wizard üzerinden entegrasyonu sağlayabiliriz.</p><p>URL yardımı ile olmadan XML dosyası ile entegrasyonlar da yani 2. seçenek için de ADFS sunucusunun uygulama sunucusuna firewall izinlerinin verilmiş olması gerekiyor.</p><p>entegrasyonlar sağlandıktan sonra da claim ayarlarının yapılması gerekiyor ;</p><h4>Send LDAP Attributes as Claims</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mTr2RE64WaqlHm8Xww7RGg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*chiCnMP9Mej3S6yhXAcJeg.png" /></figure><h4>Transform an Incoming Claim</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SnMzEqYCfgFkg14qAydpFQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*28_cSlM-CRimD2Q0sNvsnA.png" /></figure><p><a href="https://github.com/orcunulutas/golang-adfs-example">GitHub - orcunulutas/golang-adfs-example</a></p><h3>Sonuç</h3><p>Bu rehber, Golang ile ADFS entegrasyonunun temel adımlarını ve crewjam/saml kütüphanesinin nasıl kullanılacağını özetlemektedir. Entegrasyon sürecinde, IDP tarafından sağlanan metadata&#39;nın doğru şekilde kullanılması, SSL/TLS sertifikalarının güvenli bir şekilde yönetilmesi ve uygulama tarafında doğru endpoint&#39;lerin konfigüre edilmesi önemlidir. Bu örnek, temel bir SSO entegrasyonunu gerçekleştirmek için iyi bir başlangıç noktası sunar, ancak gerçek dünya senaryolarında daha karmaşık yapılandırmalar ve güvenlik önlemleri gerekebilir.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5139e4a95a38" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kişisel Şifreleme Alfabesi Nasıl Oluşturuluyor]]></title>
            <link>https://orcunulutas.medium.com/ki%C5%9Fisel-%C5%9Fifreleme-alfabesi-nas%C4%B1l-olu%C5%9Fturuluyor-331067d0a456?source=rss-4ee03ee848d0------2</link>
            <guid isPermaLink="false">https://medium.com/p/331067d0a456</guid>
            <category><![CDATA[şifreleme]]></category>
            <category><![CDATA[kriptoloji]]></category>
            <category><![CDATA[sezar-şifreleme]]></category>
            <category><![CDATA[kişisel-alfabe]]></category>
            <dc:creator><![CDATA[Orçun ULUTAŞ]]></dc:creator>
            <pubDate>Thu, 09 Nov 2023 06:00:14 GMT</pubDate>
            <atom:updated>2023-11-09T06:00:14.592Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*f57o2ToKTG7JpIvmDz5_Hg.png" /></figure><p>Biraz felsefi biraz da fantastik bir yaklaşımla kendi el yazısına bir gizlilik seviyesi ekleyen kullanıcılar oluyor. Bu yazıda da bu yöntemlere karışı decryption atakları ve ne seviye de hangi yöntemler uygulanması gerektiği konularına değindim. Giriş seviyesi bir yaklaşım aslında genel olarak ders kitaplarında bahsedilen yaklaşımları bir araya getirerek fantastik bir çalışma sağlamış oldum. Fakat bu yöntemi uygulayan insanlar da benzer bir yolda ilerliyorlar.</p><p>Bunu nasıl yapıyorlar çok mu zor ?</p><p>Gerçekten bir anlam ifade ediyor mu ?</p><p>İşte kendi kişisel şifreleme alfabenizi yaratma adımları:</p><h3>Adım 1: Temel Alfabeyi Seçilmesi</h3><p>İlk adım olarak, normal alfabe (A’dan Z’ye) ile başlanıyor. Bu, her bir harfe özel bir sembol atayacağınız temel çerçeve yaratılmış oluyor.</p><h3>Adım 2: Sembollerin Belirlenmesi</h3><p>Her bir harf için bir sembol atanıyor. Örnek olarak kullanabileceğiniz bir alfabe şöyledir:</p><ul><li>A ⨁</li><li>B Δ</li><li>C Σ</li><li>D ∇</li><li>E Ξ</li><li>F Φ</li><li>G Γ</li><li>H Ψ</li><li>I ι</li><li>J Ж</li><li>K Κ</li><li>L λ</li><li>M μ</li><li>N ν</li><li>O ο</li><li>P π</li><li>Q Ω</li><li>R ρ</li><li>S σ</li><li>T τ</li><li>U υ</li><li>V ν</li><li>W ω</li><li>X ξ</li><li>Y ψ</li><li>Z ζ</li></ul><p>Bu semboller, matematiksel işaretler, Yunan alfabesi, ve çeşitli bilimsel simgelerden alınmıştır. Ancak, bu sembollerin seçimi tamamen kullanıcıya kalmıştır; daha karmaşık ve kişisel olmaları, şifrenin güvenliğini artırır ama şifrenin doğası gereği güvenli olmayacaktır. Sonuçta bir insan tarafından insan düşüncesi ile o anda yapılan şifrelemeleri ve deşifre işlemlerini içeriyor çok ta gizli bir akışı olmayacaktır.</p><h3>Adım 3: Şifrenin Kişiselleştirilmesi</h3><p>Bu şifreleme yöntemi, özelleştirilebilir olması açısından çok esnektir. Kendi çizimlerinizi, işaretlerinizi ekleyebilir veya yazı stilinizi bu sembollerle birleştirebilirsiniz. Önemli olan, seçtiğiniz simgelerin yalnızca sizin tarafınızdan anlaşılabilir ve çözülebilir olmasıdır.</p><h3>Adım 4: Pratik Yapın</h3><p>Yeni alfabe setinizi kullanarak yazı yazmayı alışkanlık haline getirin. Bu, şifrelenmiş notlarınızı hızlı ve doğru bir şekilde okumanıza yardımcı olacaktır.</p><h3>Adım 5 Obfuscation Felsefesi: Gizliliği Artırmanın Bir Yolu</h3><p>Obfuscation, veri veya kodun kasıtlı olarak anlaşılmasını zorlaştırma sürecidir. Bu teknik, genellikle yazılımın mühendislik çalışmalarını zorlaştırmak için kullanılır, ancak kişisel şifreleme alfabesi oluştururken de benzer prensipler uygulanabilir. Obfuscation, notlarınızın üzerinden birinin geçmesi durumunda, anlamalarını daha da zorlaştırarak ek bir güvenlik katmanı ekler.</p><h3>Obfuscation Örnekleri</h3><h4>1. Sembolik Karıştırma:</h4><p>Normal bir şifreleme alfabesinde, her harfe karşılık gelen sabit bir sembol atarsınız. Obfuscation ile bu semboller rastgele karıştırılabilir. Örneğin, ‘A’ harfi için farklı zamanlarda farklı semboller kullanılabilir. Bu, bir düzenin teşhis edilmesini zorlaştırır.</p><h4>2. Ekstra Karakterler:</h4><p>Mesajınıza anlamı olmayan ekstra karakterler ekleyerek okunmasını zorlaştırabilirsiniz. Örneğin, her kelimenin arasına rastgele semboller yerleştirerek gerçek mesajınızın üzerini örtebilirsiniz.</p><h4>3. Anagram Kullanımı:</h4><p>Yazdığınız kelimeleri anagram olarak şifreleyebilirsiniz. Bu şekilde, mesajınızın doğru sıralamasını ve sembol eşleştirmesini bilmeyen biri için anlamsız bir dizi sembol oluşur.</p><h3>Obfuscation Uygulaması</h3><p>Şifreleme alfabenizi obfuscation teknikleriyle birleştirerek, örneğin, ‘A’ harfinin yerine her gün farklı bir sembol kullanmayı tercih edebilirsiniz. Pazartesi günleri ‘A’ ⨁, Salı günleri ‘A’ Δ olabilir. Veya her kelimenin sonuna anlamsız bir sembol ekleyerek mesajın akıcılığını kasıtlı olarak bozabilirsiniz.</p><p>Önemli olan, kullanılan obfuscation yöntemlerinin sadece sizin tarafınızdan bilinmesi ve uygulanmasıdır. Bu, yazılarınızın güvenliğini önemli ölçüde artıracaktır.</p><h3>Sezar Şifrelemesi ile Obfuscation</h3><p>Sezar şifrelemesi, metni obfuscate etmek için kullanılabilecek klasik bir yöntemdir. Sezar şifrelemesi, her harfi alfabede belli bir sayıda yer ileriye veya geriye kaydırarak çalışır. İşte özel bir alfabe için basit bir Sezar şifrelemesi örneği:</p><p>Varsayalım ki özel alfabemizde şu harfler ve karşılık gelen sembollerimiz var:</p><ul><li>A = ⨁</li><li>B = ♦</li><li>C = ⬡</li><li>D = ⚙</li><li>E = ★</li><li>F = ⚜</li><li>… (ve diğer harfler ve semboller)</li></ul><p>3 harflik bir kaydırma (3 yer ileri) uygulayarak obfuscation yapabiliriz. Bu durumda, ‘A’ yerine ‘D’ harfinin sembolünü, ‘B’ yerine ‘E’ harfinin sembolünü kullanırız ve bu şekilde devam ederiz. İşte özel alfabe ve Sezar şifrelemesi uygulandıktan sonra oluşacak yeni semboller:</p><ul><li>A (⨁) -&gt; D (⚙)</li><li>B (♦) -&gt; E (★)</li><li>C (⬡) -&gt; F (⚜)</li><li>… (ve diğer harfler ve semboller için benzer kaydırmalar)</li></ul><p>Bu şifreleme yöntemi, bir kişinin kendi notlarını şifrelemesi için oldukça basit ve etkili bir yöntemdir. Ancak, Sezar şifrelemesi modern kriptografik standartlarla karşılaştırıldığında zayıf kabul edilir ve genellikle eğitim amaçlı olarak kullanılır. El yazısı ile yapılan şifrelemeler de tercih edilebilir.</p><h3>Örnekler</h3><p>ilk olarak mevcut alfabenin Sezar Şifrelemesine göre dizliminin değiştirildiğini varsayalım;</p><pre>Orijinal Alfabe:  ABCDEFGHIJKLMNOPQRSTUVWXYZ<br>Şifreli Alfabe:   QWERTYUIOPASDFGHJKLZXCVBNM</pre><p>yani A yerine Q . Q yerine de J yazılacağını varsayalım. Sonrasında da ilk bölümde bahsettiğimiz semboller ile değiştirileceğini.</p><p>A ==&gt; Q ==&gt; Ω</p><p>Q ==&gt; J ==&gt; Ж</p><p>gibi 2. aşamalı bir sonuç elde edilmiş oldu.</p><p>artık A değeri Ω ile simgelenmiş, Q harfi de Ж ile simgelenmiş oldu.</p><p>Tam bir örnek yapalım;</p><pre>Orijinal: &quot;HELLO WORLD&quot;<br><br>Şifreli: &quot;EAQQO XOTQR&quot;<br><br>Sembol karışılı : &quot;Ξ⨁ΩΩο ξοτΩρ&quot;</pre><p>string şifreleme teknolojisinde en zayıf yanlarından biri de padding konusu yani yukarıda ki metinde hangi kelimenin kaç harf içerdiği belli.</p><p>bu nedenle de gruplama yapmak daha güvenli hale getirir ;</p><pre>Sembol karışılı : &quot;Ξ⨁ΩΩο ξοτΩρ&quot;<br>Gruplanmış hali : &quot;Ξ⨁-ΩΩο-ξο-τΩρ&quot;</pre><p>her X karakter de N adet anlamsız sembol eklenir.</p><p>X ve N değerleri dinamik bir kural oluşturulabilir. Ben örnek için X’i 4 N’yi de 2 alıyorum;</p><pre>Sembol karışılı                 : &quot;Ξ⨁ΩΩο ξοτΩρ&quot;<br>Geçersiz Karakterler eklenince  : &quot;Ξ⨁ΩΩ∇λοξοτωμΩρ&quot;<br>Gruplanmış hali                 : &quot;Ξ⨁-ΩΩ∇λ-οξ-οτωμ-Ωρ&quot;</pre><p>gruplamayı da 2 ve 4 er karakter şeklinde yaptığımda eklediğim boş karakterler hep 4&#39;lü bloğun son 2 karakteri olduğunu da biliyor olduğumdan okurken anlamam daha kolay olacaktır.</p><p>Gruplanmış halinde kelime değil tüm cümlenin gruplanmış hali olursa okurken anlamata kolay olacaktır.</p><p>bazı Sezar Şifreleme uyarlamalarında eğer tekrar eden harflar yan yana geliyorsa onlar için tek bir harf kullanılır. Bu durumuda sadece okuyucu taraf emin olacağı için otomatik decryption ataklarında bir seviye daha direnç sağlanmış olabilir. Ek olarak bilinçli bir şekilde kelimeler yanlış yazılabilir.</p><blockquote>HELLO WORLD yerine “HELLO W0RD” gibi hem eksik karakter hem de “O” yerine “0” plain text aşamasında da farklı karakterler tercih edilebilir.</blockquote><h3>Alfabeyi Kırmak</h3><p>Kendi oluşturduğunuz bu alfabeyi kırmak ve decrypt edilmeye çalışılması çok zor değil uygulayacağınız obfuscation yöntemleri burada çok önemli.</p><p>Özellikle kelimelerin boyundan yani karakter sayısına göre bir sözlükte yer alan kelimeler karşılaştırılarak veya metin içerisinde mutlaka olması gerektiği tahmin edilen bir kelime den alfabe kırılabilir.</p><p>Özellikle kelimenin yeri de biliniyorsa çorap söküğü gibi tüm alfabe deşifre edilebilir. Yani gerçekten tahmin edilemeyen veya kırılamayan bir alfabe yaratılması çok zor hatta teorik olarak bakıldığında imkansız.</p><p>kendi encrypted kümeniz için yapılacak bazı ataklar ;</p><pre>import collections<br><br># Özel alfabe karakterleri<br>alfabe = {&#39;⨁&#39;: &#39;A&#39;, &#39;♦&#39;: &#39;B&#39;, &#39;⬡&#39;: &#39;C&#39;, &#39;⚙&#39;: &#39;D&#39;, &#39;★&#39;: &#39;E&#39;, &#39;⚜&#39;: &#39;F&#39;}  # ve diğerleri...<br><br># Şifreli metnin frekans analizini yap<br>def frekans_analizi(sifreli_metin):<br>    # Sembollerin frekansını say<br>    frekanslar = collections.Counter(sifreli_metin)<br>    # En sık kullanılan sembolleri bul<br>    sirali_frekanslar = frekanslar.most_common()<br>    return sirali_frekanslar<br><br># Frekans analizi sonuçlarına göre bir eşleştirme yap<br>def sifreyi_coz(frekanslar):<br>    # Türkçede en sık kullanılan harfler varsayılarak bir harf sıralaması<br>    # Bu örnek için &#39;A&#39; en sık kullanılan harf olarak kabul edildi.<br>    sirali_turkce_harfler = &#39;AEINO...&#39;  # Tam listeye ihtiyaç var<br>    cozum_tablosu = {}<br>    <br>    for index, (sembol, _) in enumerate(frekanslar):<br>        cozum_tablosu[sembol] = sirali_turkce_harfler[index] if index &lt; len(sirali_turkce_harfler) else &#39;?&#39;<br>    <br>    return cozum_tablosu<br><br># Şifreli metni çöz<br>def metni_coz(sifreli_metin, cozum_tablosu):<br>    cozulmus_metin = &quot;&quot;<br>    for sembol in sifreli_metin:<br>        if sembol in cozum_tablosu:<br>            cozulmus_metin += cozum_tablosu[sembol]<br>        else:<br>            cozulmus_metin += sembol<br>    return cozulmus_metin<br><br># Şifreli metni örnek olarak kullan<br>sifreli_metin = &quot;⚙⨁♦⚙★⬡&quot;  # Bu metin &#39;DAEBDC&#39; olmalıdır<br><br># Frekans analizi yap<br>frekanslar = frekans_analizi(sifreli_metin)<br><br># Şifreyi çözmek için eşleştirme yap<br>cozum_tablosu = sifreyi_coz(frekanslar)<br><br># Metni çöz<br>cozulmus_metin = metni_coz(sifreli_metin, cozum_tablosu)<br><br>print(&quot;Şifreli Metin: &quot;, sifreli_metin)<br>print(&quot;Çözüm Tablosu: &quot;, cozum_tablosu)<br>print(&quot;Çözülmüş Metin: &quot;, cozulmus_metin)</pre><p>Yapay zekadan yardım olarak bu tür metinler kırılmaya çalışabilir ;</p><p>Bir derin öğrenme modeli, özellikle bir dizin tahmin görevi için Recurrent Neural Network (RNN) veya daha gelişmiş bir versiyonu olan Long Short-Term Memory (LSTM) ağları kullanılabilir.</p><pre>from tensorflow.keras.models import Sequential<br>from tensorflow.keras.layers import LSTM, Dense, Embedding<br><br># Sözlük boyutunu ve girdi uzunluğunu belirle<br>vocab_size = 100  # Özel alfabedeki karakter sayısı + 1<br>max_length = 50   # Maksimum şifreli metin uzunluğu<br><br># LSTM modeli<br>model = Sequential()<br>model.add(Embedding(vocab_size, 64, input_length=max_length))<br>model.add(LSTM(128, return_sequences=True))<br>model.add(LSTM(128))<br>model.add(Dense(vocab_size, activation=&#39;softmax&#39;))<br><br>model.compile(loss=&#39;categorical_crossentropy&#39;, optimizer=&#39;adam&#39;, metrics=[&#39;accuracy&#39;])<br>model.summary()<br><br># Eğitim verilerini ve etiketlerini yükle<br># X_train, şifreli metinleri; y_train, karşılık gelen açık metinleri temsil eder<br># X_train, y_train = load_data() # Bu fonksiyonun tanımlanması gerekiyor<br><br># Modeli eğit<br># model.fit(X_train, y_train, epochs=10, batch_size=64)</pre><h3>Diğer Decryption Atak yöntemleri;</h3><ol><li><strong>Frekans Analizi</strong>: Her dilin karakter ve kelime frekanslarına ilişkin belirli örüntüleri vardır. Frekans analizi, şifreli metindeki harflerin veya karakter gruplarının (bigram, trigram vb.) sıklığını analiz ederek hangi harflerin hangi karakterlere karşılık geldiğini tahmin etmeye çalışır.</li><li><strong>Bilinen Düz Metin Atakları (Known-plaintext attacks):</strong> Eğer bir saldırgan hem şifreli hem de eşleşen düz metnin bir parçasını biliyorsa, bu bilgiyi kullanarak şifreleme algoritmasını tersine çevirebilir ve kalan şifreyi çözebilir.</li><li><strong>Sezar Şifreleme Analizi</strong>: Eğer özel alfabe sadece harflerin yerlerini değiştiriyor ve harflerin yer değiştirdiği yöntem basit bir kaydırma (shift) ise, Sezar şifrelemesinde olduğu gibi, tüm olası kaydırmalar denenerek düz metin elde edilebilir.</li><li><strong>Sözlük Atağı (Dictionary attack)</strong>: Eğer şifreli metin belirli kelimelerin yer değiştirilmesiyle oluşturulduysa, saldırganlar bu kelimelerin şifreli karşılıklarını bir sözlükte toplayarak ve bu sözlüğü kullanarak şifreyi çözebilirler.</li><li><strong>Pattern Recognition:</strong> Özel bir alfabede bile, bazı harfler veya harf kombinasyonları belirli desenler oluşturabilir. Bu desenleri tanıyarak ve analiz ederek, metin üzerinde çıkarımlar yapılabilir.</li><li><strong>Yarı Otomatik ve Otomatik Araçlar</strong>: Şifre çözme için özel yazılımlar kullanılabilir. Bu araçlar, yukarıda belirtilen tekniklerin bir kombinasyonunu ve daha fazlasını kullanarak şifreli metni otomatik olarak analiz edebilir.</li><li><strong>Brute Force Atağı (Brute-force attack):</strong> Eğer şifreleme algoritması yeterince basitse ve çok fazla olasılık yoksa, tüm olası kelimeleri deneyerek doğru olanı bulmak mümkün olabilir. Bir not içinde kesinlikle en az bir kere geçmesi gereken bir kelime varsa onun üzerinden tahminleme yapılabilir.</li><li><strong>Kriptoanalitik Yazılımlar:</strong> Aralarında ADFGVX, Enigma, ve Vigenère gibi klasik şifreleri çözebilen özel kriptoanaliz yazılımları da bulunur. Bu tür yazılımlar özel alfabeye uyarlama yapılabilirse kullanılabilir.</li></ol><p>Şifreyi kırmak için hangi yöntemin uygulanacağı, şifrenin karmaşıklığına, saldırganın şifre hakkında ne kadar bilgiye sahip olduğuna ve kullanılan özel alfabenin yapısına bağlıdır. Genellikle saldırganlar, şifreyi çözmek için birden fazla yöntemi bir arada kullanır.</p><h3>Son Düşünceler</h3><p>Bu basit adımlarla, günlük notlarınızı ya da günlüğünüzü sadece sizin anlayabileceğiniz bir dille yazabilirsiniz. Unutmayın ki bu, sadece bir başlangıçtır ve eğitim tabanlı bir giriş. Gerçek güvenlik için daha detaylı şifreleme yöntemlerinin kullanılması gerekir. Ancak, bu özelleştirilmiş alfabe, kişisel notlarınız için ek bir gizlilik katmanı sunar ve şifreleme dünyasına eğlenceli bir giriş yapmanızı sağlar ama hiç bir zaman gerçek bir gizlilik sağlamaz sadece eğlence amaçlı ve bir seviyede anlamsız bir bakış sunmayı sağlar.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=331067d0a456" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kriptografik Kale: Kimlik Bilgisi Çalınmasına Karşı Dirençli Zaman-Doğrulamalı Mesajlaşma Protokolü…]]></title>
            <link>https://orcunulutas.medium.com/kriptografik-kale-kimlik-bilgisi-%C3%A7al%C4%B1nmas%C4%B1na-kar%C5%9F%C4%B1-diren%C3%A7li-zaman-do%C4%9Frulamal%C4%B1-mesajla%C5%9Fma-protokol%C3%BC-e4525eda042b?source=rss-4ee03ee848d0------2</link>
            <guid isPermaLink="false">https://medium.com/p/e4525eda042b</guid>
            <category><![CDATA[güvenli-mesajlaşma]]></category>
            <category><![CDATA[kriptografi]]></category>
            <category><![CDATA[bilgi-güvenliği]]></category>
            <dc:creator><![CDATA[Orçun ULUTAŞ]]></dc:creator>
            <pubDate>Wed, 08 Nov 2023 22:01:11 GMT</pubDate>
            <atom:updated>2023-11-08T22:01:11.450Z</atom:updated>
            <content:encoded><![CDATA[<h3>Kriptografik Kale: Kimlik Bilgisi Çalınmasına Karşı Dirençli Zaman-Doğrulamalı Mesajlaşma Protokolü Yaklaşımı</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IgvcJzqj5K7njmRLgOzYmg.png" /></figure><p>Güvenlik, dijital çağda her geçen gün daha fazla önem kazanıyor. Kullanıcıların verilerini koruma altına almak ve siber saldırılara karşı dayanıklı hale getirmek için yeni yaklaşımlara ihtiyacımız var. Bu makalede, zaman damgası, nonce, ve şifrelenmiş zincirleme transaction ID’ler kullanan dinamik bir şifreleme protokolünü ele alacağız.</p><p>Temel motivasyonu iletişim ağında ki source’lardan birinin kaybolması veya çalınması durumunda mesajların okunmasını veya modern kriptoloji saldırı yöntemlerine karşı dirençli bir yapı oluşturmak.</p><p>Data yı collect edecek endpoint her açılışta yeni bir request ile mesajları talep edeceği için mesajlar endpoint tarafında ram de tutuluyor olacak ve sunucu tarafından ilgili endpoint’in key leri drop edilerek iletişim sonlandırılır.</p><p>Her istemciye verilen unique key’ler ile endpointte trafik başlatıldıktan sonra artık block chain benzeri bir yaklaşım ile transaction başlar böylece key ‘ler çalınmış veya taklit edilmiş bile olsa iletişim gerçekleşmez.</p><h3>Anahtar Yönetimi</h3><p>Sistemimiz, iki taraf arasında özel ve genel anahtarların (private/public keys) bir kombinasyonunu kullanarak güçlü bir şifreleme sunar. Her kullanıcı, kendi özel anahtarını ve diğer tarafın genel anahtarını tutarak bir E2E şifreleme oluşturur.</p><p>Anahtar exchange işlemi endpoint’in registration işlemi sırasında yapılır ve istemciye gönderilen key’ler istemci tarafında saklanır ve her istemci endpoint’e unique key verilir.</p><h3>Random Key Üretimi ve Nonce</h3><p>Her iletişim oturumu için, istemci tarafından benzersiz bir random key ve nonce oluşturulur. Bu yaklaşım, iletişimin tekrarlanan ataklara (replay attacks) karşı korunmasını sağlar.</p><h3>Transaction Zinciri</h3><p>Her yeni istek, önceki isteğin SHA256 ile hash’lenmiş değerini içerir. Bu bağlantılı işlem zinciri, tüm işlemlerin sıralı ve değiştirilemez olduğu anlamına gelir.</p><h3>Veritabanı Kaydı ve İşlem Doğrulaması</h3><p>Sistemin güvenliği, her transaction’ın veritabanında kaydedilmesi ve her yeni işlemin geçmiş işlemleri doğrulamasıyla artırılır. Eğer bir işlem tekrarlanmaya çalışılırsa, sistem bunu tespit eder ve reddeder.</p><h3>Next-Key Mekanizması</h3><p>Her mesajla birlikte bir sonraki anahtarın (next-key) değeri sunulur ve istemcinin bir sonraki işleminde bu değeri kullanması beklenir. Bu adım, iki faktörlü doğrulama sistemine benzer bir güvenlik katmanı ekler.</p><h3>Zaman Damgası ve Nonce Entegrasyonu</h3><p>Her mesaj bir zaman damgası ve nonce ile birlikte gelir, bu da mesajların sadece belirli bir zaman dilimi için geçerli olduğunu ve tekrar kullanılamayacağını garantiler.</p><h3>Güvenlik Protokolü Akışı</h3><ol><li><strong>Anahtar Yönetimi:</strong></li></ol><ul><li>Kullanıcı X, kendi private key’ine ve sunucunun public key’ine sahiptir.</li><li>Sunucu, kendi private key’ine ve kullanıcı X’in public key’ine sahiptir.</li></ul><p><strong>2. İstemci Tarafından Random Key Üretimi ve İletişim Başlatma:</strong></p><ul><li>Kullanıcı X tarafından bir random key (random-id) ve bir nonce oluşturulur.</li><li>Kullanıcı X, bu random key, zaman damgası, nonce ve önceki işlemin SHA256 hash değerini içeren bir JSON nesnesi oluşturur.</li><li>Bu JSON, kullanıcı X’in private key’i ile şifrelenir ve sunucuya gönderilir.</li></ul><pre>{&quot;key&quot;&quot;:&quot;&lt;random-id&gt;&quot;,<br>&quot;zaman&quot;:&quot;08.11.2023 23:00&quot;,<br>&quot;nonce&quot;:&quot;random-bir-token-uretiliyor&quot;,<br>&quot;transaction&quot;:&quot;&lt;bir-onceki-json-sha256&gt;&quot;}</pre><p><strong>3. Sunucu Tarafında İşlem Doğrulama:</strong></p><ul><li>Sunucu, gelen şifreli veriyi kendi private key’i ile çözerek içerikleri elde eder.</li><li>Sunucu, gelen transaction’ın geçerliliğini, veritabanındaki önceki transaction hash değerleriyle karşılaştırarak doğrular.</li></ul><p><strong>4. Mesajların Şifrelenmesi ve Gönderilmesi:</strong></p><ul><li>Sunucu, kullanıcı Y’den gelen mesajları kullanıcı X tarafından oluşturulan random-id ile şifreler.</li><li>Her mesajın içerisine, sunucu tarafından üretilen bir sonraki key (next-key) eklenir. Bu key, kullanıcı X’in bir sonraki isteğindeki transaction JSON’ının SHA256 hash’i ile şifrelenir.</li></ul><p><strong>5. Şifrelenmiş Mesajların İletilmesi:</strong></p><ul><li>Şifrelenmiş mesajlar, kullanıcı X’in public key’i ile tekrar şifrelenir ve kullanıcı X’e gönderilir.</li></ul><p><strong>6. Next-Key Kullanımı:</strong></p><ul><li>Kullanıcı X, bir sonraki istekte bulunurken, sunucunun gönderdiği şifrelenmiş next-key’i çözer ve bu değeri yeni transaction JSON’ına ekler.</li></ul><pre>{&quot;messages&quot;&quot;:[<br>{&quot;gonderen&quot;:&quot;Y&quot;,<br>&quot;message&quot;:&quot;&lt;encrypted-with-random-key&gt;&quot;,<br>&quot;zaman&quot;:&quot;08.11.2023 23:01&quot;,<br>&quot;nextkey&quot;:&quot;next-key&quot;}<br>]}</pre><pre>{&quot;key&quot;&quot;:&quot;&lt;random-id&gt;&quot;,<br>&quot;zaman&quot;:&quot;08.11.2023 23:00&quot;,<br>&quot;nonce&quot;:&quot;random-bir-token-uretiliyor&quot;,<br>&quot;transaction&quot;:&quot;&lt;bir-onceki-json-sha256&gt;&quot;,<br>&quot;nextkey&quot;:&quot;decrypted-next-key&quot;}</pre><h3>Pseudo Kodu</h3><pre>function initiateCommunication(X_privateKey, server_publicKey):<br>    randomKey = generateRandomKey()<br>    nonce = generateNonce()<br>    previousTransactionHash = getPreviousTransactionHash()<br>    timestamp = getCurrentTimestamp()<br><br>    jsonPayload = encryptWithPrivateKey({<br>        &quot;key&quot;: randomKey,<br>        &quot;time&quot;: timestamp,<br>        &quot;nonce&quot;: nonce,<br>        &quot;transaction&quot;: previousTransactionHash<br>    }, X_privateKey)<br><br>    sendToServer(jsonPayload, server_publicKey)<br><br>function serverProcess(server_privateKey, X_publicKey, receivedPayload):<br>    decryptedPayload = decryptWithPrivateKey(receivedPayload, server_privateKey)<br>    isValid = validateTransaction(decryptedPayload.transaction)<br><br>    if isValid:<br>        messages = getMessagesForX()<br>        nextKey = generateNextKey()<br><br>        encryptedMessages = encryptWithRandomKey({<br>            &quot;messages&quot;: messages,<br>            &quot;nextKey&quot;: encryptWithSHA256(nextKey)<br>        }, decryptedPayload.key)<br><br>        sendBackToClient(encryptWithPublicKey(encryptedMessages, X_publicKey))<br><br>function continueCommunication(X_privateKey, server_publicKey, nextKey):<br>    newRandomKey = generateRandomKey()<br>    nonce = generateNonce()<br>    timestamp = getCurrentTimestamp()<br>    decryptedNextKey = decryptWithPrivateKey(nextKey, X_privateKey)<br><br>    newJsonPayload = encryptWithPrivateKey({<br>        &quot;key&quot;: newRandomKey,<br>        &quot;time&quot;: timestamp,<br>        &quot;nonce&quot;: nonce,<br>        &quot;transaction&quot;: getSHA256OfPreviousJson(),<br>        &quot;nextKey&quot;: decryptedNextKey<br>    }, X_privateKey)<br><br>    sendToServer(newJsonPayload, server_publicKey)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-xXtNCRM2Qgp1wrstRyYbw.png" /></figure><h3>Güvenlik Analizi</h3><ol><li><strong>Özel ve Genel Anahtarlar (Private/Public Keys):</strong></li></ol><ul><li>E2E (end-to-end) şifreleme sağlıyor, bu da sadece mesajın sahibi ve alıcının mesajı okuyabileceği anlamına geliyor.</li></ul><p><strong>2. Random Key ve Nonce Kullanımı:</strong></p><ul><li>Her oturum için benzersiz bir şifreleme anahtarı ve nonce oluşturarak replay attack’ları engelliyor ve mesajların yalnızca bir kez kullanılmasını sağlıyor.</li></ul><p><strong>3. Transaction Chain:</strong></p><ul><li>Her isteğin önceki isteğin hash değeri ile bağlantılı olması, işlemlerin sıralı ve bağlantılı bir şekilde ilerlemesini sağlıyor. Bu zincirleme yaklaşım, blockchain teknolojisindeki gibi işlem tarihini korur ve herhangi bir işlemde yapılan değişikliğin tüm zinciri etkilemesine neden olur.</li></ul><p><strong>4. Database Kaydı ve Doğrulama:</strong></p><ul><li>SHA256 ile hash’lenmiş transaction değerlerinin veritabanında saklanması ve her yeni isteğin bu değerleri kontrol etmesi, güvenliği daha da artırıyor. Aynı transaction değeri tekrar kullanılmaya çalışıldığında, sistem bunu reddediyor.</li></ul><p><strong>5. Next-Key Mekanizması:</strong></p><ul><li>Her mesajdan sonra “next-key” adında yeni bir anahtar sağlayarak, istemcinin bir sonraki isteğinde bu anahtarı kullanması gerektiği bir adım ekleniyor. Bu adım, güvenliği artırmak için iki faktörlü bir doğrulama gibi işlev görüyor.</li></ul><p><strong>6. Zaman Damgası ve Nonce Entegrasyonu:</strong></p><ul><li>Zaman damgası ve nonce birleşimi, mesajların zaman sınırlılığını ve tekrar kullanılamamasını garanti altına alıyor.</li></ul><h3>Sonuç ve Gelecek Perspektifleri</h3><p>Bu makalede tartışılan algoritma, mesajlaşma güvenliğinin yalnızca statik bir savunma hattıyla sınırlı kalmaması gerektiğini vurgulamaktadır. Yenilikçi güvenlik mekanizması, kullanıcının cihaz güvenliğini dinamik ve proaktif bir şekilde yönetmesine olanak tanır. Bu yaklaşım, güvenlik ihlallerinin önlenebilmesi için esneklik ve derinlemesine savunma katmanları sunar.</p><p>Algoritmanın benzersiz yönü, her işlem için rastgele anahtarların üretilmesi ve bu anahtarların sıradaki işlemde kullanılmasıdır. Bu yöntem, yetkisiz erişim ve veri hırsızlığına karşı ek bir koruma sağlar ve mevcut güvenlik protokollerini güçlendirir. Ayrıca, işlemler arasında tutarlılık sağlayarak, olayların izlenebilirliğini ve denetlenebilirliğini artırır.</p><p>Algoritmamızın sunduğu dinamik güvenlik protokolü, geleceğin siber güvenlik tehditleriyle mücadelede önemli bir rol oynayabilir. Güvenlik dünyasında sürekli evrilen tehditler karşısında, algoritmamız gibi esnek ve uyarlanabilir sistemler, kullanıcı verilerinin korunmasında kritik öneme sahip olacaktır.</p><p>Son olarak, bu algoritmanın uygulanabilirliği ve etkinliği, kapsamlı simülasyonlar ve gerçek dünya testleri ile daha da doğrulanabilir. Gelecekteki çalışmalarda, algoritmanın farklı senaryolarda performansının ve güvenlik seviyesinin değerlendirilmesi, bu yaklaşımın mesajlaşma güvenliği alanındaki potansiyelini ortaya koyacaktır.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e4525eda042b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Derinlemesine Tasarım Desenleri — 3 (Abstract Factory Tasarım Deseni)]]></title>
            <link>https://orcunulutas.medium.com/derinlemesine-tasar%C4%B1m-desenleri-3-abstract-factory-tasar%C4%B1m-deseni-7b3c0292b371?source=rss-4ee03ee848d0------2</link>
            <guid isPermaLink="false">https://medium.com/p/7b3c0292b371</guid>
            <category><![CDATA[abstract-factory-pattern]]></category>
            <category><![CDATA[tasarım-desenleri]]></category>
            <dc:creator><![CDATA[Orçun ULUTAŞ]]></dc:creator>
            <pubDate>Thu, 02 Nov 2023 12:19:53 GMT</pubDate>
            <atom:updated>2023-11-02T12:19:53.088Z</atom:updated>
            <content:encoded><![CDATA[<h3>Derinlemesine Tasarım Desenleri — 3 (Abstract Factory Tasarım Deseni)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/0*IzBAAl2jkDcZNmRi.png" /></figure><h3>Abstract Factory Deseni Nedir?</h3><p>Abstract Factory, yazılım tasarım desenlerinden biridir ve bir grup ilişkilendirilmiş veya bağımlı nesne oluşturmak için bir arayüz sağlar. Bu desenin güzelliği, bir nesne ailesini oluştururken somut sınıfların gerçekleştirimlerinden bağımsız olmasıdır.</p><h4>Bileşenler</h4><ol><li><strong>Abstract Factory:</strong> Tüm somut fabrikaların uyması gereken bir arayüz veya soyut sınıftır.</li><li><strong>Concrete Factory:</strong> Abstract Factory yöntemlerini uygulayan sınıf.</li><li><strong>Abstract Product:</strong> Tüm ürün aileleri için genel bir ürün arayüzüdür.</li><li><strong>Concrete Product:</strong> Concrete factory tarafından yaratılan ve soyut ürün arayüzünü uygulayan gerçek üründür.</li><li><strong>Client</strong>: concrete factory nin sunduğu arayüzü kullanarak ürünleri yaratır.</li></ol><h4>Örnek: Temalı GUI Bileşenleri</h4><p>Düşünelim ki farklı işletim sistemlerinde çalışan grafiksel kullanıcı arayüzü (GUI) bileşenleri oluşturmak istiyoruz: Windows ve MacOS.</p><ol><li><strong>Abstract Factory</strong>: GUIFactory, createWindow ve createButton gibi yöntemleri tanımlar.</li><li><strong>Concrete Factory</strong>: WindowsFactory ve MacOSFactory gibi sınıflar.</li><li><strong>Abstract Product</strong>: Genel bir Window ve Button arayüzü.</li><li><strong>Concrete Product</strong>: WindowsWindow, MacOSWindow, WindowsButton ve MacOSButton gibi platforma özgü sınıflar.</li><li><strong>Client</strong>: İlgili platform için fabrikayı seçer (örn. WindowsFactory) ve bu fabrika üzerinden GUI bileşenleri oluşturur.</li></ol><p><strong>Senaryo:</strong></p><p>Bu örnekte, iki farklı işletim sistemi için UI bileşenleri oluşturuyoruz: Windows ve MacOS.</p><p>Her işletim sistemi için bir Button ve bir Window bileşeni oluşturmak istiyoruz.</p><p><strong>Nasıl Çalışıyor?</strong></p><ol><li><strong>Arayüzler (Interfaces):</strong></li></ol><ul><li>AbstractFactory: Tüm fabrikaların uygulaması gereken arayüz. createButton ve createWindow metodlarını tanımlar.</li><li>Button: Bütün düğmelerin (Windows ve MacOS için) uygulaması gereken arayüz.</li><li>Window: Bütün pencerelerin (Windows ve MacOS için) uygulaması gereken arayüz.</li></ul><p>2. <strong>Somut Fabrikalar (Concrete Factories):</strong></p><ul><li>WindowsFactory: Windows için bileşenleri oluşturur.</li><li>MacOSFactory: MacOS için bileşenleri oluşturur.</li></ul><p>3. <strong>Somut Ürünler (Concrete Products):</strong></p><ul><li>WindowsButton ve MacOSButton: İşletim sistemine özgü düğme bileşenleri.</li><li>WindowsWindow ve MacOSWindow: İşletim sistemine özgü pencere bileşenleri.</li></ul><p>4. <strong>Client (Müşteri) tarafı:</strong></p><ul><li>İstediği platform için gerekli fabrikayı seçer (örn. WindowsFactory).</li><li>Bu fabrikayı kullanarak UI bileşenlerini (düğme ve pencere) oluşturur.</li><li>Bileşenleri kullanarak UI’yi render eder.</li></ul><p>Bu yapı sayesinde, yeni bir işletim sistemi için UI bileşenleri eklemek istediğinizde sadece yeni bir fabrika ve bu fabrikanın ürettiği bileşenleri eklemeniz yeterlidir. Örneğin, Linux için UI bileşenleri eklemek isterseniz, sadece LinuxFactory, LinuxButton ve LinuxWindow sınıflarını eklemeniz yeterlidir.</p><p>Özetle, Abstract Factory deseni sayesinde, nesnelerin oluşturulmasını ve hangi nesnelerin kullanıldığını soyutlar, böylece uygulamanın geri kalanı bu detaylardan bağımsız olarak çalışabilir.</p><p><strong>Java;</strong></p><p>ilk olarak 3 farklı interface yaratıyoruz ;</p><pre>public interface AbstractFactory {<br>    Button createButton();<br>    Window createWindow();<br>}<br></pre><pre>public interface Button {<br>    void render();<br>}<br></pre><pre>public interface Window {<br>    void render();<br>}</pre><p>ikinci adımda Abstract Factory class larını oluşturuyoruz ;</p><pre>public class WindowsFactory implements AbstractFactory {<br>    public Button createButton() {<br>        return new WindowsButton();<br>    }<br>    public Window createWindow() {<br>        return new WindowsWindow();<br>    }<br>}</pre><pre>public class MacOSFactory implements AbstractFactory {<br>    public Button createButton() {<br>        return new MacOSButton();<br>    }<br>    public Window createWindow() {<br>        return new MacOSWindow();<br>    }<br>}</pre><p>Abstract Factory’ler methodlar da hangi classların objeleştirileceğine karar veriyor yani bileşenlerin hangi class’lar tarafından sağlanacağını belirtmiş oluyor. Örn: Button bir bileşen ve bu Button bileşeni WindowsButton class ile sağlanacağını belirtiyoruz.</p><p>Concrete Products’ları oluşturuyoruz;</p><pre>public class WindowsButton implements Button {<br>    public void render() {<br>        System.out.println(&quot;Windows Button&quot;);<br>    }<br>}</pre><pre>public class MacOSButton implements Button {<br>    public void render() {<br>        System.out.println(&quot;MacOS Button&quot;);<br>    }<br>}</pre><p>Window yapısı için concrete product lar ;</p><pre>public class WindowsWindow implements Window {<br>    public void render() {<br>        System.out.println(&quot;Windows Window&quot;);<br>    }<br>}</pre><pre>public class MacOSWindow implements Window {<br>    public void render() {<br>        System.out.println(&quot;MacOS Window&quot;);<br>    }<br>}</pre><p>Client aşaması ;</p><pre>public class Client {<br><br>    private Button button;<br>    private Window window;<br><br>    public Client(AbstractFactory factory) {<br>        button = factory.createButton();<br>        window = factory.createWindow();<br>    }<br><br>    public void renderUI() {<br>        button.render();<br>        window.render();<br>    }<br><br>    public static void main(String[] args) {<br>        // Örneğin Windows UI bileşenleri için fabrika kullanılıyor.<br>        AbstractFactory factory = new WindowsFactory();<br>        Client client = new Client(factory);<br>        client.renderUI();<br><br>        // Eğer MacOS UI bileşenlerini görmek isterseniz:<br>        // AbstractFactory factory = new MacOSFactory();<br>        // Client client = new Client(factory);<br>        // client.renderUI();<br>    }<br>}</pre><p><strong>GO;</strong></p><pre>package main<br><br>import &quot;fmt&quot;<br><br>type AbstractFactory interface {<br>    CreateButton() Button<br>    CreateWindow() Window<br>}<br><br>type Button interface {<br>    Render()<br>}<br><br>type Window interface {<br>    Render()<br>}<br><br>type WindowsFactory struct{}<br>func (w *WindowsFactory) CreateButton() Button {<br>    return &amp;WindowsButton{}<br>}<br>func (w *WindowsFactory) CreateWindow() Window {<br>    return &amp;WindowsWindow{}<br>}<br><br>type MacOSFactory struct{}<br>func (m *MacOSFactory) CreateButton() Button {<br>    return &amp;MacOSButton{}<br>}<br>func (m *MacOSFactory) CreateWindow() Window {<br>    return &amp;MacOSWindow{}<br>}<br><br>type WindowsButton struct{}<br>func (w *WindowsButton) Render() {<br>    fmt.Println(&quot;Windows Button&quot;)<br>}<br><br>type MacOSButton struct{}<br>func (m *MacOSButton) Render() {<br>    fmt.Println(&quot;MacOS Button&quot;)<br>}<br><br>type WindowsWindow struct{}<br>func (w *WindowsWindow) Render() {<br>    fmt.Println(&quot;Windows Window&quot;)<br>}<br><br>type MacOSWindow struct{}<br>func (m *MacOSWindow) Render() {<br>    fmt.Println(&quot;MacOS Window&quot;)<br>}<br><br>func main() {<br>    var factory AbstractFactory<br>    factory = &amp;WindowsFactory{}<br>    button := factory.CreateButton()<br>    button.Render()<br>    window := factory.CreateWindow()<br>    window.Render()<br>}</pre><p><strong>C++;</strong></p><p>AbstractFactory header file;</p><pre>class Button {<br>public:<br>    virtual void render() = 0;<br>};<br><br>class Window {<br>public:<br>    virtual void render() = 0;<br>};<br><br>class AbstractFactory {<br>public:<br>    virtual Button* createButton() = 0;<br>    virtual Window* createWindow() = 0;<br>};</pre><p>Concrete Factory header file;</p><pre>#include &quot;AbstractFactory.h&quot;<br>#include &lt;iostream&gt;<br><br>class WindowsButton : public Button {<br>public:<br>    void render() {<br>        std::cout &lt;&lt; &quot;Windows Button&quot; &lt;&lt; std::endl;<br>    }<br>};<br><br>class MacOSButton : public Button {<br>public:<br>    void render() {<br>        std::cout &lt;&lt; &quot;MacOS Button&quot; &lt;&lt; std::endl;<br>    }<br>};<br><br>class WindowsWindow : public Window {<br>public:<br>    void render() {<br>        std::cout &lt;&lt; &quot;Windows Window&quot; &lt;&lt; std::endl;<br>    }<br>};<br><br>class MacOSWindow : public Window {<br>public:<br>    void render() {<br>        std::cout &lt;&lt; &quot;MacOS Window&quot; &lt;&lt; std::endl;<br>    }<br>};<br><br>class WindowsFactory : public AbstractFactory {<br>public:<br>    Button* createButton() {<br>        return new WindowsButton();<br>    }<br>    Window* createWindow() {<br>        return new WindowsWindow();<br>    }<br>};<br><br>class MacOSFactory : public AbstractFactory {<br>public:<br>    Button* createButton() {<br>        return new MacOSButton();<br>    }<br>    Window* createWindow() {<br>        return new MacOSWindow();<br>    }<br>};</pre><p>Client ;</p><pre>#include &quot;ConcreteFactory.h&quot;<br><br>int main() {<br>    AbstractFactory* factory = new WindowsFactory();<br>    Button* button = factory-&gt;createButton();<br>    button-&gt;render();<br>    Window* window = factory-&gt;createWindow();<br>    window-&gt;render();<br>    <br>    delete button;<br>    delete window;<br>    delete factory;<br><br>    return 0;<br>}</pre><h4>Avantajları:</h4><ul><li>Esneklik: Somut sınıfların oluşturulma biçimini değiştirmeden yeni sınıflar eklemek kolaydır.</li><li>Genişletilebilirlik: Yeni ürün aileleri eklemek için mevcut kodu değiştirmeye gerek yoktur. Sadece yeni bir fabrika ekleyerek genişletebiliriz.</li><li>Modülerlik: Sistem, hangi somut sınıflarla çalıştığını bilmeden belirli bir ürün ailesi ile çalışabilir.</li></ul><h4>Dezavantajları:</h4><ul><li>Sınıf sayısında artışa neden olabilir, çünkü her ürün ailesi için ayrı fabrikalar ve ürünler oluşturulmalıdır.</li><li>Yeni bir ürün (örneğin, bir ‘Slider’ bileşeni) eklemek istendiğinde, tüm fabrikaları güncellemek gerekebilir.</li></ul><h4>Kullanım alanları ve Factory Pattern ile farkları;</h4><ol><li><strong>Grafik Kütüphanesi:</strong></li></ol><ul><li>Factory: Sadece Button oluşturur.</li><li>Abstract Factory: Hem Button hem de Window oluşturur. Yani, Windows için bir factory, WindowsButton ve WindowsWindow oluştururken, MacOS için bir factory MacOSButton ve MacOSWindow oluşturur.</li></ul><ol><li><strong>Oyun Karakterleri:</strong></li></ol><ul><li>Factory: Sadece “Savaşçı” karakterini oluşturur.</li><li>Abstract Factory: Hem “Savaşçı” hem de onun eşyalarını (kılıç, kalkan) oluşturur. Yani, Orta Çağ teması için bir factory, “Savaşçı” ve “Kılıç” oluştururken, Geleceğe Yolculuk teması için bir fabrika “Uzaylı Savaşçı” ve “Lazer Tabanca” oluşturur.</li></ul><ol><li><strong>Online Ödeme Sistemleri:</strong></li></ol><ul><li>Factory: Sadece bir ödeme yöntemi oluşturur, örneğin kredi kartı.</li><li>Abstract Factory: Hem ödeme yöntemini (kredi kartı, banka havalesi) hem de ilgili doğrulama mekanizmasını (SMS doğrulama, e-posta doğrulama) oluşturur.</li></ul><p>Bu örneklerde, Abstract Factory’nin birden fazla ilişkili veya bağımlı nesneyi aynı anda nasıl oluşturduğunu görebilirsiniz. Bu, Factory Pattern ile elde edilemez. Factory Pattern sadece tek bir nesne türünü oluştururken, Abstract Factory birden fazla ilişkili nesne türünü aynı anda oluşturur.</p><p>Özetle, Abstract Factory, bir grup ilişkili nesneyi birlikte oluşturmak için kullanılırken, Factory Pattern genellikle tek bir nesne oluşturmak için kullanılır.</p><h4>Sonuç</h4><p>Abstract Factory deseni, ürün aileleri arasında kesin bir ayrım yaparak sistemin genel esnekliğini ve genişletilebilirliğini artırır. Ancak, bu deseni kullanırken sınıf yapısının karmaşıklığına dikkat etmek önemlidir.</p><p>Bu deseni, aynı türdeki nesnelerin farklı varyasyonlarını oluşturmanız gerektiğinde, özellikle de bu varyasyonlar arasında belirgin bir sınırlama veya ilişkilendirme olduğunda düşünmelisiniz.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7b3c0292b371" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Derinlemesine Tasarım Desenleri — 2 (Factory Tasarım Deseni)]]></title>
            <link>https://orcunulutas.medium.com/derinlemesine-tasar%C4%B1m-desenleri-2-factory-tasar%C4%B1m-deseni-4c8ba26f2598?source=rss-4ee03ee848d0------2</link>
            <guid isPermaLink="false">https://medium.com/p/4c8ba26f2598</guid>
            <category><![CDATA[factory-pattern]]></category>
            <category><![CDATA[java-design-pattern]]></category>
            <category><![CDATA[tasarım-desenleri]]></category>
            <category><![CDATA[go-design-patterns]]></category>
            <dc:creator><![CDATA[Orçun ULUTAŞ]]></dc:creator>
            <pubDate>Wed, 01 Nov 2023 22:11:52 GMT</pubDate>
            <atom:updated>2023-11-01T22:11:52.453Z</atom:updated>
            <content:encoded><![CDATA[<h3>Derinlemesine Tasarım Desenleri — 2 (Factory Tasarım Deseni)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6M_a6xVXu9oumDdM.png" /></figure><h3>Factory Pattern Nedir?</h3><p>Factory Pattern,</p><blockquote><strong>bir işlemi gerçekleştirmenin birden fazla yolu olduğunda ve hangi yolun seçileceğine runtime’da karar verilmesi gerektiğinde kullanılan bir tasarım kalıbıdır.</strong></blockquote><p>Bu pattern, istemci kodunun belirli bir sınıfın örneğini direkt olarak oluşturmasını engeller. Bunun yerine, bir “fabrika” sınıfı aracılığıyla bu örneği oluşturmayı sağlar.</p><p>Koyu ile işaretlenmiş olan cümle bu pattern’in odak noktasıdır tam olarak bu pattern koyu cümlede ki kritere göre belirleriz.</p><p>daha iyi anlatabilmek adına bir kaç kullanım alını senaryosu paylaşayım ;</p><h3>Gerçek Hayattan Örnekler</h3><p>Factory Pattern’ın gerçek yazılım dünyasında nasıl kullanılabileceğine dair örnekler:</p><ul><li><strong>Ödeme Yöntemleri: </strong>Kredi kartı, banka havalesi, PayPal gibi farklı ödeme yöntemleri arasında seçim yapabiliriz. Bir eticaret siteniz var case’niz ödeme alma. Ödeme almak içinse birden fazla yönteminiz var ve her yöntem de akışlar farklı bu durumda terich edeceğimiz pattern türü oluyor.</li><li><strong>Veritabanı Bağlantıları:</strong> MySQL, PostgreSQL gibi farklı veritabanlarına bağlanma yöntemleri. Son kullanıcı için bir ürün geliştirdiniz ve kullanıcınız tercih ettiği bir database kullanacak, bu bağlantı akışını factory pattern ile yapabilirsiniz. Bir amacınız var ve o amacınız içinse birden fazla yöntem.</li><li><strong>Grafik Arayüz Widget’ları:</strong> Windows, MacOS, Linux için farklı arayüz bileşenleri oluşturma.</li><li><strong>Loglama Mekanizması:</strong> Bir loglama süreci oluşturmak istiyorsunuz ama birden fazla yönteminiz var ; elasticsearch, file, database, bulut bir servis vs gibi.</li><li><strong>Bilgilendirme gönderimi: </strong>SMS, SMTP, Exchange, push message</li><li><strong>Üyelik Türlerinin yönetimi:</strong> Free, Standart, Premium</li><li><strong>Authentication Servisleri:</strong> Bir login servisi oluşturuyorsunuz. Kullanıcıların login olması için birden fazla opsiyon sunmanız gerekiyorsa örn: OpenID, SAML, LDAP, Email Auth</li></ul><h3>Factory Pattern’ın Avantajları</h3><ol><li><strong>Esneklik:</strong> Yeni bir sınıf eklemek veya mevcut bir sınıfı değiştirmek istediğimizde, sadece fabrika sınıfını değiştirerek bu işlemi kolayca gerçekleştirebiliriz.</li><li><strong>Genişletilebilirlik:</strong> Yeni işlevselliği mevcut kodu bozmadan ekleyebiliriz.</li><li><strong>Soyutlama:</strong> İstemci, oluşturulacak nesnenin gerçek sınıfını bilmez. Bu, istemcinin sadece arayüzle iletişim kurmasını sağlar.</li></ol><h3>Örnek Senaryo</h3><p>Bir e-ticaret platformumuz var ve farklı ödeme yöntemleri sunuyoruz: Kredi Kartı, Banka Havalesi ve Kredi. Her ödeme yönteminin farklı bir işlem süreci var. Factory pattern’ı kullanarak bu ödeme yöntemlerini temsil eden sınıfları oluşturalım.</p><h3>Java:</h3><p>ilk adımda bir ödeme yöntemi için interface oluşturuyoruz ;</p><pre>public interface PaymentMethod {<br>    void processPayment(double amount);<br>}</pre><p>Sonrasında; Kredi kartı, Banka Havalesi ve kredi olmak üzere 3 farklı yöntemi implemente ediyor olacağız.</p><h4>Kredi kartı;</h4><pre>public class CreditCard implements PaymentMethod {<br>    @Override<br>    public void processPayment(double amount) {<br>        System.out.println(amount + &quot; TL kredi kartı ile ödendi.&quot;);<br>    }<br>}</pre><h4>Havale;</h4><pre>public class BankTransfer implements PaymentMethod {<br>    @Override<br>    public void processPayment(double amount) {<br>        System.out.println(amount + &quot; TL banka havalesi ile ödendi.&quot;);<br>    }<br>}</pre><h4>Kredi;</h4><pre>public class CreditMoney implements PaymentMethod {<br>    @Override<br>    public void processPayment(double amount) {<br>        System.out.println(amount + &quot; TL kredi ile ödendi.&quot;);<br>    }<br>}</pre><p>Bir Factory class’i oluşturarak objelerimizi yaratıyor olacağız. Fatory ‘nin burada bize avantajı ne oluyor olacak busines logic içerisinde koşullar yaratarak method seçimi yaptırmamış oluyor böylece ileride bir değişikliğe ihtiyacımız olduğunda business logic te kod değişikliğine ihtiyaç duymuyor olacağız.</p><p>bu süreçleri merkezileştirerek Factory class ın da yapıyor olacağız.</p><p>Birde genişlenetilebilirlikten bahsetmiştik, ileride online bir ödeme sistemiyle anlaşıldı bunu kodumuzda bir çok yerde değişiklik yaparak değil sadece factory class’ında değişiklik yaparak sağmamıza imkan sağlamış oluyor.</p><pre>public class PaymentFactory {<br>    public PaymentMethod getPaymentMethod(String method) {<br>        if (method == null) {<br>            return null;<br>        }<br>        if (method.equalsIgnoreCase(&quot;CREDITCARD&quot;)) {<br>            return new CreditCard();<br>        } else if (method.equalsIgnoreCase(&quot;BANKTRANSFER&quot;)) {<br>            return new BankTransfer();<br>        } else if (method.equalsIgnoreCase(&quot;CREDITMONEY&quot;)) {<br>            return new CreditMoney();<br>        }<br>        return null;<br>    }<br>}</pre><p>Koşullarak göre hangi class’in obje olarak yaratılarak döndürüleceğini PaymentFactory de belirlemiş olduk.</p><p>Peki PaymentFactory yi nasıl çağırırız ;</p><pre>public class ECommercePlatform {<br>    public static void main(String[] args) {<br>        PaymentFactory paymentFactory = new PaymentFactory();<br><br>        // Kredi Kartı ile ödeme yapılıyor.<br>        PaymentMethod method1 = paymentFactory.getPaymentMethod(&quot;CREDITCARD&quot;);<br>        method1.processPayment(500.0);<br><br>        // Banka Havalesi ile ödeme yapılıyor.<br>        PaymentMethod method2 = paymentFactory.getPaymentMethod(&quot;BANKTRANSFER&quot;);<br>        method2.processPayment(300.0);<br><br>        // Kredi ile ödeme yapılıyor.<br>        PaymentMethod method3 = paymentFactory.getPaymentMethod(&quot;CREDITMONEY&quot;);<br>        method3.processPayment(250.0);<br>    }<br>}</pre><h4>GO;</h4><p>ilk olarak yeni bir modül oluşturuyoruz</p><pre>go mod init factorydemo</pre><p>sonrasında main paketi altında bir payment_method.go dosyası ile interface oluşturuyoruz;</p><pre>package main<br><br>type PaymentMethod interface {<br> ProcessPayment(amount float64) string<br>}</pre><p>Daha düzenli bir süreç olması adına GO da her bir yöntem için ayrı bir go file ile struct oluşturuyoruz. örn; credit_card.go ;</p><pre>package main<br><br>import (<br> &quot;fmt&quot;<br>)<br><br>type CreditCard struct{}<br><br>func (c *CreditCard) ProcessPayment(amount float64) string {<br> return fmt.Sprintf(&quot;₺%.2f kredi kartı ile ödendi.&quot;, amount)<br>}</pre><p>bank_transfer.go ;</p><pre>package main<br><br>import (<br> &quot;fmt&quot;<br>)<br><br>type BankTransfer struct{}<br><br>func (b *BankTransfer) ProcessPayment(amount float64) string {<br> return fmt.Sprintf(&quot;₺%.2f banka havalesi ile ödendi.&quot;, amount)<br>}</pre><p>credit_money.go</p><pre>package main<br><br>import &quot;fmt&quot;<br><br>type CreditMoney struct{}<br><br>func (cm *CreditMoney) ProcessPayment(amount float64) string {<br> return fmt.Sprintf(&quot;%.2f t kredi ile ödendi.&quot;, amount)<br>}</pre><p>koşullara göre bizim adımıza struct ları oluşturacak olan factory.go dosyasını oluşturuyoruz;</p><pre>package main<br><br>func PaymentFactory(method string) PaymentMethod {<br> switch method {<br> case &quot;credit_card&quot;:<br>  return &amp;CreditCard{}<br> case &quot;bank_transfer&quot;:<br>  return &amp;BankTransfer{}<br> case &quot;credit_money&quot;:<br>  return &amp;CreditMoney{}<br> default:<br>  return nil<br> }<br>}</pre><p>son olarak PaymentFactory struct larımızı çağıralım ;</p><pre>package main<br><br>import &quot;fmt&quot;<br><br>func main() {<br> payment := PaymentFactory(&quot;credit_card&quot;)<br> fmt.Println(payment.ProcessPayment(500.0))<br><br> payment = PaymentFactory(&quot;bank_transfer&quot;)<br> fmt.Println(payment.ProcessPayment(300.0))<br><br> payment = PaymentFactory(&quot;credit_money&quot;)<br> fmt.Println(payment.ProcessPayment(250.0))<br>}</pre><h4>C++;</h4><p>ilk olarak PaymentMethod header dosyasını oluşturuyoruz ;</p><h4>PaymentMethod.h</h4><pre>#ifndef PaymentMethod_h<br>#define PaymentMethod_h<br><br>#include &lt;string&gt;<br><br>class PaymentMethod {<br>public:<br>    virtual std::string ProcessPayment (float amount)=0;<br>};<br><br>pa#endif /* PaymentMethod_h */</pre><p>Methodlarımıza ait olan classları oluşturuyoruz; CreditCard, BankTransfer, CreditMoney</p><h4>CreditCard.h</h4><pre>#ifndef CreditCard_h<br>#define CreditCard_h<br><br>#include &quot;PaymentMethod.h&quot;<br><br>class CreditCard : public PaymentMethod {<br>public:<br>    std::string ProcessPayment (float amount) override;<br>    <br>};<br><br><br>#endif /* CreditCard_h */</pre><h4>CreditCard.cpp</h4><pre>#include &quot;CreditCard.h&quot;<br>#include &lt;stdio.h&gt;<br>#include &lt;sstream&gt;<br><br>std::string CreditCard::ProcessPayment(float amount) {<br>    std::ostringstream oss;<br>        oss &lt;&lt; &quot;₺&quot; &lt;&lt; amount &lt;&lt; &quot; kredi kartı ile ödendi.&quot;;<br>        return oss.str();<br>}</pre><h4>BankTransfer.hpp</h4><pre>#ifndef BankTransfer_hpp<br>#define BankTransfer_hpp<br><br>#include &quot;PaymentMethod.h&quot;<br>#include &lt;stdio.h&gt;<br><br>class BankTransfer : public PaymentMethod {<br>public:<br>    std::string ProcessPayment(float amount) override;<br>};<br><br>#endif /* BankTransfer_hpp */</pre><h4>BankTransfer.cpp</h4><pre>#include &quot;BankTransfer.hpp&quot;<br>#include &lt;sstream&gt;<br><br>std::string BankTransfer::ProcessPayment(float amount) {<br>    std::ostringstream oss;<br>    oss &lt;&lt; &quot;₺&quot; &lt;&lt; amount &lt;&lt; &quot; banka transferi ile ödendi.&quot;;<br>    return oss.str();<br>}</pre><h4>CreditMoney.hpp</h4><pre>#ifndef CreditMoney_hpp<br>#define CreditMoney_hpp<br><br>#include &quot;PaymentMethod.h&quot;<br>#include &lt;stdio.h&gt;<br><br>class CreditMoney : public PaymentMethod {<br>public:<br>    std::string ProcessPayment (float amount) override;<br>};<br><br>#endif /* CreditMoney_hpp */</pre><h4>CreditMoney.cpp</h4><pre>#include &quot;CreditMoney.hpp&quot;<br>#include &lt;sstream&gt;<br><br>std::string CreditMoney::ProcessPayment(float amount) {<br>    std::ostringstream oss;<br>    oss &lt;&lt; &quot;₺&quot; &lt;&lt; amount &lt;&lt; &quot; kredi ile ödendi.&quot;;<br>    return oss.str();<br>    <br>}</pre><p>Artık method class larımıza da oluşturduğumuz için Factory yapısına yani class’larımızı objeleştirerek onları oluşturacak olan sınıfımızı yaratabiliriz ;</p><p><strong>Factory.hpp</strong></p><pre>#ifndef Factory_hpp<br>#define Factory_hpp<br><br>#include &quot;PaymentMethod.h&quot;<br>#include &quot;CreditCard.h&quot;<br>#include &quot;BankTransfer.hpp&quot;<br>#include &quot;CreditMoney.hpp&quot;<br>#include &lt;string&gt;<br><br>class Factory {<br>    public :<br>    static PaymentMethod* PaymentFactory (const std::string&amp; method);<br>};<br><br><br>#endif /* Factory_hpp */</pre><p><strong>Factory.cpp</strong></p><pre>#include &quot;Factory.hpp&quot;<br><br>PaymentMethod* Factory::PaymentFactory(const std::string&amp; method) {<br>    if (method==&quot;creditcard&quot;) return new CreditCard();<br>    if (method==&quot;banktransfer&quot;) return new BankTransfer();<br>    if(method==&quot;creditmoney&quot;) return new CreditMoney();<br>    return nullptr;<br>    <br>}</pre><p>Son olarakta artık class larımızı çağırabiliriz ;</p><p><strong>main.cpp</strong></p><pre>#include &quot;Factory.hpp&quot;<br>#include &lt;iostream&gt;<br><br>int main() {<br>    PaymentMethod* payment = Factory::PaymentFactory(&quot;creditcard&quot;);<br>    std::cout &lt;&lt; payment-&gt;ProcessPayment(100.50) &lt;&lt; std::endl;<br>    delete payment;<br>    return 0;<br>}</pre><h3>Sonuç</h3><p>Factory Pattern, yazılım tasarımında esneklik ve genişletilebilirlik sağlayan güçlü bir araçtır. İster bir ödeme gateway’i entegre ediyor olun, ister farklı veritabanları arasında geçiş yapmayı planlıyor olun, Factory Pattern ile kodunuz daha düzenli ve yönetilebilir hale gelir.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4c8ba26f2598" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Derinlemesine Tasarım Desenleri — 1 (Singleton Tasarım Deseni)]]></title>
            <link>https://orcunulutas.medium.com/derinlemesine-tasar%C4%B1m-desenleri-1-singleton-tasar%C4%B1m-deseni-240e6c088160?source=rss-4ee03ee848d0------2</link>
            <guid isPermaLink="false">https://medium.com/p/240e6c088160</guid>
            <category><![CDATA[singleton-design-pattern]]></category>
            <category><![CDATA[tasarım-desenleri]]></category>
            <category><![CDATA[singleton-pattern]]></category>
            <dc:creator><![CDATA[Orçun ULUTAŞ]]></dc:creator>
            <pubDate>Sun, 29 Oct 2023 12:17:05 GMT</pubDate>
            <atom:updated>2023-10-29T12:17:05.875Z</atom:updated>
            <content:encoded><![CDATA[<h3>Derinlemesine Tasarım Desenleri — 1 (Singleton Tasarım Deseni)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lmu3hLdO4Vt64gC2poAjDg.png" /></figure><p>Singleton tasarım deseni, bir sınıfın yalnızca bir kez örneklenmesini ve bu tek örneğin programın her yerinden erişilebilir olmasını sağlar. Singleton, global değişkenlerin dezavantajlarını gidermek için kullanılabilir.</p><p>Aslında tıpkı bir global valiable gibi global bir class oluşturmuş oluyorsunuz artık uygulamanın yaşam döngüsü boyunca o tek obje çağrılmış oluyor.</p><p>Bize ikinci bir objenin yaratılmasına izin vermiyor.</p><p>Nedir bunun avantajı ?</p><p>Örneğin bir sqlite veritabanı dosyanız var, bu dosya içinde sorgu yapacaksınız sqlite bir backend sunucuya sahip olmadığından aslında bir ayar dosyası gibi çalıştığı için aynı anda tek bir işlem yapabilirsiniz. iki farklı resource ile dosyaya yazamazsınız. işte bu süreci güvenli hale getirmek için bir singleton class ile yönetebilirsiniz aksi halde kararsızlığa neden olabilirsiniz.</p><p>ilk olarak java da inceleyelim ;</p><h3>Java :</h3><pre>public class Singleton {<br>    private static Singleton instance;<br><br>    private Singleton() {}<br><br>    public static synchronized Singleton getInstance() {<br>        if (instance == null) {<br>            instance = new Singleton();<br>        }<br>        return instance;<br>    }<br>}</pre><p>singleton da constructor private yapılarak yeni bir obje yaratılması bloklanır yani ;</p><pre>Singleton singleton = new Singleton();</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/862/1*HMo2ecKukRzOCKRlkTVauA.png" /></figure><p>şeklinde artık kullanarak bir obje initialize edemezsiniz. Bunu da constructr’ı private yaparak sağlıyoruz.</p><p>Pool thread desteği sağlayabilmek için yani concurrency çağrımlar da işlemleri lock layarak serileştirmek için synchronized bir yapı sağlıyoruz.</p><p>peki neden örneğin sqlite için bir write işlemi başlatıyoruz ve aynı anda iki farklı thread den write talebi geldi. aynı anca dosyaya write işlemi yapamayacağımız için işlemi kilitleyerek diğer thread beklemeye alıyoruz. Bu nedenle de public static synchronized Singleton gibi bir method yaratıyoruz.</p><p>methodun içinde farkettiyseniz bir koşul yer alıyor ;</p><pre>if (instance == null) {<br>    instance = new Singleton();<br> }<br>return instance;</pre><p>bu koşul eğer daha önceden bir obje olarak class’ımız yaratıldıysa mevcut olan objeyi döndürmesi eğer ilk defa çağrıldıysa da yeni bir class yaratması için sağlanıyor.</p><p>Eğer bu koşulu kullanmamış olsaydık ne olurdu ?</p><p>Singleton class ;</p><pre>package com.designpattern;<br><br>public class Singleton {<br>    private static Singleton instance;<br>    private int randomId = (int) (Math.random() * (10));<br>    <br>    private Singleton() {}<br><br>    public static synchronized Singleton getInstance() {<br>    //    if (instance == null) {<br>            instance = new Singleton();<br>     //   }<br>        return instance;<br>    }<br>    <br>    public int getId () {<br>     return randomId;<br>    }<br>    <br>}</pre><p>Client side;</p><pre>public class Main {<br><br> public static void main(String[] args) {<br>  Singleton s1 = Singleton.getInstance();<br>  System.out.println(String.format(&quot;S1 ID %d&quot;, s1.getId()));<br>  <br>  Singleton s2 = Singleton.getInstance();<br>  System.out.println(String.format(&quot;S2 ID %d&quot;, s2.getId()));<br> }<br><br>}</pre><p>Output:</p><pre>S1 ID 9<br>S2 ID 5</pre><p>S1 ve s2 için iki farklı id dönüyor olacaktı yani aslında iki farklı obje yaratılmış olacaktı bu da bizim tasarım patternimize aykırı bu nedenle eğer biz koşulumuzu tekrar enable edersek artık hem S1 in hem de s2 nin aynı id ye sahip olduğunu görüyor olacağız bu nedenle if koşulumuz patternimizin oluşmasında bize yardımcı oluyor.</p><p>Java da Spring boot içinde yer alan ldapTemplate ve Configuration anotasyonu singleton ‘a örnek olarak verilebilir.</p><h3>GO:</h3><p>Java da incelediğimiz patternimizi şimdi bir de GO ile bakalım;</p><pre>package main<br><br>type singleton struct{}<br><br>var instance *singleton<br><br>func GetInstance() *singleton {<br> if instance == nil {<br>  instance = &amp;singleton{}<br> }<br> return instance<br>}</pre><p>go da farklı olarak dilin bize imkan sağladığı pointer ları da kullanabiliyoruz. Böylece struct ın memory referansını döndürerek objenin tekil olmasını garanti altına almış oluyoruz.</p><p>singleton dosyamıza bir de id ekleyelim ve thread pool yeteneği kazandıralım, once.Do bize içeriğinin sadece tek bir kere çalıştırıldığının garantisini veriyor olacak böylece concurreny ile gelen taleplerde karışıklığa neden olmamış olacak.</p><pre><br>package main<br><br>import (<br>        &quot;math/rand&quot;<br>        &quot;sync&quot;<br>        &quot;time&quot;<br>)<br><br>var instance *Singleton<br>var once sync.Once<br><br>// random için bir seed sağlanmış oluyor.<br>func init() {<br>  rand.Seed(time.Now().UnixNano())<br>}<br><br>type Singleton struct {<br>        RandomId int<br>}<br><br>func GetInstance() *Singleton {<br>        once.Do (func () {<br>          instance = &amp;Singleton{RandomId: rand.Intn(10)}<br>        })<br>   return instance<br>}</pre><p>Gelelim go da nasıl çağrıldığına ;</p><pre>package main<br><br>import &quot;fmt&quot;<br><br>func main() {<br>        s1 := GetInstance()<br>        fmt.Printf(&quot;S1 ID %d\n&quot;,s1.RandomId)<br><br>        s2 := GetInstance()<br>        fmt.Printf(&quot;S2 ID %d\n&quot;,s2.RandomId)<br>}<br><br></pre><p>bize çıktı olarak hep aynı id değerini veriyor olduğunu göreceksiniz.</p><h3>C++</h3><pre>class Singleton {<br>private:<br>    static Singleton* instance;<br>    Singleton() {}<br><br>public:<br>    static Singleton* getInstance() {<br>        if (!instance)<br>            instance = new Singleton;<br>        return instance;<br>    }<br>};<br>Singleton* Singleton::instance = nullptr;</pre><p>C++ da da Go diline çok benzer şekilde Singleton implementasyonu gerçekleştirebiliyoruz.</p><h3>Demostration 2 :</h3><p>Demo olarak Java, Go, C++ ile sqlite bağlantısı yapan bir singleton class oluşturuyor olacağız, aslında demostration bölümünü sizlerin yapmanız ve son durumda da kontrol edilmesi gereken bir bölüm olarak değerlendirilmeli. bu nedenle nihai class kodlarını paylaşıyorum ;</p><h3>Java:</h3><pre><br>public class DatabaseSingleton {<br> private static DatabaseSingleton instance;<br> private static int id = (int) (Math.random()*10);<br> <br> private DatabaseSingleton() {}<br> <br> public synchronized DatabaseSingleton getInstance () {<br>  if (instance==null) {<br>   instance = new DatabaseSingleton();<br>  }<br>  <br>  return instance;<br> }<br>}</pre><p>konu anlatımında standart bir Singleton class yapısının başlangıç hali yukarıdaki gibi olacaktır. Şimdi class’ımıza database connection özelliklerini ekleyelim;</p><pre><br>import java.sql.*;<br><br>public class DatabaseSingleton {<br> private static DatabaseSingleton instance;<br> private static int id = (int) (Math.random()*10);<br> <br> //database mimarisi icin<br> private Connection connection;<br> private String url = &quot;jdbc:sqlite:sample.db&quot;;<br> <br> private DatabaseSingleton() {}<br> <br> public synchronized DatabaseSingleton getInstance () throws SQLException {<br>  if (instance==null) {<br>   instance = new DatabaseSingleton();<br>  } else if (instance == null || connection.isClosed()) {<br>   // connection kapandıysa veya instance null geldiyse DB connection yapıyoruz<br>   instance.openConenction();<br>  }<br>  <br>  return instance;<br> }<br> <br> private void openConenction() throws SQLException {<br>  connection = DriverManager.getConnection(url);<br> }<br> <br> private void writeData (String data) throws SQLException {<br>  Statement stm = connection.createStatement();<br>  stm.execute(&quot;INSERT INTO data_table (data) VALUES (&#39;&quot; + data + &quot;&#39;);&quot;);<br> }<br> <br> public ResultSet readData() throws SQLException {<br>  Statement stm = connection.createStatement();<br>  return stm.executeQuery(&quot;SELECT data FROM data_table;&quot;);<br> }<br> <br>}</pre><p><strong>Go:</strong></p><pre>package main<br><br>import (<br> &quot;database/sql&quot;<br> &quot;math/rand&quot;<br> &quot;sync&quot;<br>)<br><br>var instance *DatabaseSingleton<br>var once sync.Once<br><br>type DatabaseSingleton struct {<br> RandomId   int<br> connection *sql.DB<br>}<br><br>func GetInstance() *DatabaseSingleton {<br> once.Do(func() {<br>  instance = &amp;DatabaseSingleton{RandomId: rand.Intn(10)}<br> })<br> if instance.connection == nil {<br>  instance.openConnection()<br> }<br> return instance<br>}<br><br>func (db *DatabaseSingleton) openConnection() {<br> connetion, err := sql.Open(&quot;sqlite3&quot;, &quot;./sample.db&quot;)<br> if err != nil {<br>  panic(err)<br> }<br> db.connection = connetion<br>}<br><br>func (db *DatabaseSingleton) writeData(data string) {<br> statement, _ := db.connection.Prepare(&quot;INSERT INTO data_table (data) VALUES (?)&quot;)<br> statement.Exec(data)<br>}<br><br>func (db *DatabaseSingleton) readData() *sql.Rows {<br> rows, _ := db.connection.Query(&quot;SELECT data FROM data_table&quot;)<br> return rows<br>}</pre><h3>C++</h3><pre>// Ensure SQLite C library is installed.<br>#include &lt;sqlite3.h&gt;<br>#include &lt;iostream&gt;<br><br>class Database {<br>    private:<br>        static Database* instance;<br>        sqlite3* db;<br><br>        Database() {<br>            sqlite3_open(&quot;sample.db&quot;, &amp;db);<br>        }<br><br>    public:<br>        static Database* getInstance() {<br>            if (!instance)<br>                instance = new Database();<br>            return instance;<br>        }<br><br>        void writeData(const char* data) {<br>            char* errMsg = 0;<br>            std::string sql = &quot;INSERT INTO data_table (data) VALUES (&#39;&quot; + std::string(data) + &quot;&#39;);&quot;;<br>            sqlite3_exec(db, sql.c_str(), 0, 0, &amp;errMsg);<br>        }<br>};<br><br>Database* Database::instance = 0;</pre><h3>Gerçek Dünya Senaryoları</h3><p>Singleton yapısının gerçek dünya da hangi alanlar da kullanıldığını görmek bu pattern in daha iyi anlaşılmasını sağlayacağını düşündüğüm için örnek kullanım alanlarını da ekliyorum ;</p><ol><li><strong>Veritabanı Bağlantıları: </strong>Tek bir veritabanına erişim sağlayan bir uygulama için, her seferinde yeni bir bağlantı oluşturmak yerine, bir Singleton veritabanı bağlantısı kullanılır.</li><li><strong>Logger: </strong>Günlük kaydı (logging) için bir Singleton sınıfı, tüm uygulamada tutarlılık sağlar.</li><li><strong>Konfigürasyon Yönetimi:</strong> Uygulama için konfigürasyon bilgilerini okuyan ve bu bilgilere erişim sağlayan bir Singleton sınıfı oluşturulabilir.</li><li><strong>Cache Sistemi:</strong> Önbelleğe alınmış verilere erişim sağlamak için Singleton bir önbellek yöneticisi.</li><li><strong>Ağ Sunucusu:</strong> Bir ağ sunucusunun birden fazla istemciyle iletişim kurduğunu düşünün. Sunucunun durumu tüm istemciler için aynıdır ve bu duruma erişim sağlayan bir Singleton sınıfı kullanılabilir.</li><li><strong>Lisans Yönetimi:</strong> Yazılımların lisans kontrolü için Singleton kullanılır.</li><li><strong>Load Balancer:</strong> Yük dengeleyici, gelen talepleri çeşitli sunucular arasında dengelemek için kullanılır ve genellikle bir Singleton olarak uygulanır.</li><li><strong>Uygulama Durumu:</strong> Bir web uygulamasında oturum bilgilerini veya diğer global durum bilgilerini saklamak için.</li><li><strong>Dosya Yöneticisi:</strong> Disk üzerindeki dosyalara erişim sağlamak için Singleton bir dosya yöneticisi.</li><li><strong>Driverlar:</strong> Bir donanım cihazıyla iletişim kurmak için driverlar genellikle Singleton olarak uygulanır.</li><li><strong>Registry Kayıtları: </strong>Sistem kayıtlarını yönetmek için bir Singleton registry yöneticisi.</li><li><strong>Thread Pool:</strong> Çalışan threadlerin bir havuzunu yöneten bir Singleton sınıfı.</li><li><strong>Uygulama Counter: </strong>Uygulamanın kaç kez kullanıldığına dair bilgileri tutan bir sayaç.</li><li><strong>Hizmet Aracı:</strong> Farklı servislere erişim sağlayan bir aracı olarak Singleton kullanılır.</li><li><strong>Print Spooler: </strong>Yazdırma işlerini yönetmek için bir Singleton sınıfı.</li><li><strong>Clipboard Yönetimi:</strong> İşletim sistemlerinde panoya erişim sağlayan Singleton bir clipboard yöneticisi.</li><li><strong>Uygulama Ayarları:</strong> Kullanıcının özelleştirdiği uygulama ayarlarına erişim sağlamak için.</li><li><strong>Font Yönetimi: </strong>Sistemde kullanılan fontlara erişim sağlamak için Singleton bir font yöneticisi.</li><li><strong>Window Manager: </strong>İşletim sistemlerinde açık olan pencereleri yöneten bir Singleton sınıfı.</li><li><strong>Resource Manager:</strong> Oyunlarda ve grafik uygulamalarında kullanılan kaynaklara (resimler, sesler, metinler vb.) erişim sağlamak için bir Singleton kaynak yöneticisi.</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=240e6c088160" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>