MBFuzzer projesi geldiği aşamada HTTP/HTTPS proxy hizmetini sunmaktadır. Bunun yanı sıra mobil bir uygulama ile sunucu arasında gerçekleşen iletişimde sunucunun mobil uygulamaya gönderdiği cevapların içeriğinde hazırlanan yapılandırma dosyası kullanılarak RAW ve XML içeriklerde değişikler yapmakta ve sonrasında değişiklik yapılan bu içeriği uzunluğu gibi gerekli bilgilerinide düzenleyerek mobil uygulama tarafına göndermektedir.
Yapılandırma dosyası içerisinde belirlenen ve içeriklere uygulanacak şimdilik “searchreplace“(bul ve değiştir), “bigdata“(büyük veri yerleştir) yapıları bulunmaktadır. Mobil uygulamanın yaptığı istek doğrultusunda sunucudan gelen içeriklerde değiştirmek istediğimiz herhangi bir veri bulunuyorsa, bunu yapılandırma dosyasında bulunan searchreplace yapısına,
<searchreplace>
<target>değiştirilmesi hedeflenen veri</target>
<newdata>girilmek istenen yeni veri</newdata>
</searchreplace>
gerekli olan bilgileri ekleyerek değiştirmek istenilen veri yapılandırma dosyasındaki yerini almaktadır. Bir diğer yapı bigdata ise aynı şekilde sunucu tarafından gönderilen ve mobil uygulama tarafında bir değişken içerisinde tutulacak bir verinin değiştirilerek beklenmeyecek şekilde büyük boyutlu bir değişken yerleştirme işlemi için,
<bigdata>
<name>hedeflenen değişken ismi</name>
<data>yerleştirilmek istenen veri</data>
<count>verinin kaç defa tekrar edeceği</count>
</bigdata>
yapısına uygun bilgilerin yapılandırma dosyasına yerleştirilmesi halinde hedeflenen değişkene büyük verinin göderilmesi sonraki adım için hazır hale gelmektedir.
MBFuzzer projesi için yapılandırma dosyasında hazırlanan searchreplace ve bigdata yapılarının kullanımı MBContent sınıfının içerisinde bulunan load_actions fonksiyonu yardımı ile ilk olarak parse edilmekte ve kullanıma hazır hale getirilmektedir.
# load_actions fonksiyonu yapılandırma dosyası ile çalışmaktadır
def load_actions(config_file)
# yapılandırma dosyasında bulunan yapıların parse işlemi
action = XmlSimple.new.xml_in(config_file, { 'ForceArray' => false })
# her yapı uygun hash yapısına aktarılmaktadır
action.each do |a_name,a_attr|
case a_name
when "searchreplace" then @actions['searchreplace'] = a_attr
when "bigdata" then @actions['bigdata'] = a_attr
end
end
end
MBProxy mobil uygulama ve sunucu arasındaki iletişimi üzerinden geçirirken şimdilik sadece HTTP cevaplarını MBContent katmanındaki analiz kısmana göndermekte ve oradaki içeriğin türüne göre ayrıştırılması yapılarak hazırlanan yapılar RAW için searchreplace ve XML içerikleri içinde bigdata işlemleri yapılmaktadır. Yaptığım bazı denemelerde yapılandırma dosyasına Name değişkenine sahip bigdata yapısı ekledim ve sanal mobil cihaza yüklediğim bazı uygulamarda sonucunu gözlemledim ve uygulamanın hazırladığım yapı nedeniyle uygulamanın çökmesi ile karşılaştım. Bunun ile beraber RAW data olarak da belirlediğim searchreplace yapısında belirlediğim verinin görünmesini de MBFuzzer sağlamış oldu.
MBFuzzer projesinin son hali kullanabilmek için mobil sanal cihaz kurmalı ve proxy ayarları hazır şekild ebaşlatmasınız ki bunu önceki blog yazılarımda bulabilirsiniz. Sonrasında mevcut searchreplace ve bigdata yapısına uygun farkı veriler girerek MBFuzzer'ın test klasörü altında bulunan proxy_test dosyasının çalıştırılmasınından sonra mobil uygulamaların vereceği cevapları gözlemleyebilirsiniz.
MBProxy
kütüphanesi sayesinde mobil uygulama ile sunucu arasında gerçekleşen
HTTP/HTTPS istek ve cevaplarının yönledirmesini sağlanıyor. Bundan
sonraki adımda ise bu istek ve cevapların analizinin yapıldıkdan sonra
uygun fuzzing içeriklerinin bu istek ve cevaplara yerleştirilmesi işlemi
vardır. Bu hedef uygun, içeriklerin analizini ve parse işlemini yapan
MBContent kütüphanesi hazırladım.
MBContent
kütüphanesi başlangıç olarak gelen istek veya cevap içeriklerini XML
yapısında kabul edip ki bu tür içeriği basit bir koşul ifadesi ile
sağlanıyor. XML türündeki içeriği analyse_content metodu ile alıp kendi
içerisinde Content-Type içeriğin ne tür de olacağını belirtir,
Content-Length gelen içeriğin uzunuluğunu verir, vb. türdeki değişkenler
içerik hakkındaki temel özellikleri belirtmektedir. MBContent’in
analyse_content() metodu ile bu özellikleri içerik ile ilgili
değişiklik yaptığımızda uzunluğu değişecek ve bozuk bir içerik olmaması
sağlamak için Content-Length’de düzenleme yapmak gerekecektir. Bu
nedenle, analyse_content() metodu içerik özelliklerini parse ederek bir
yapı içerisine yerleştirir. İçeriğin temel özelliklerini belirten bu
tür bilgilerden sonra “\n\n” gerçek içeriğin başladığını belirtmektedir.
# içerik içerisinde xml türünün olup olmadığına bakar
# xml olan içeriği analiz etmeye başlar
if content =~ /Content-Type: text\/xml/
new_content = MBContent.new.analyse_content(content)
end
Şimdilik
XML içeriklerini ele aldığım için doğrudan XML içeriğini parse eden ve
bunu yaparken Ruby’nin XmlSimple kütüphanesini kullanan bir XMLParser
kütüphanesi hazırladım. Bu kütüphanenin şu anda xml içeriği hash map’e
ve hash map de bulunan içeriğide XML’e çeviren iki işlevi bulunmaktadır.
Bu özelliklerin iyileştirmesi üzerinde çalışmaktayım.
# xml kütüphanesi işlevelerinin kullanımı
hash_xml_content = XMLParser.new().parse(xml_content)
xml_content = XMLParser.new().convert_from_hash(hash_xml_content)
MBContent
kütüphanesi son olarak analiz ettiği içeriği tekrardan birleştire
görevi gören create_new_content() metoduna sahiptir. Bu metod ile mevcut
içerik özellikleri tekrardan içerik yapısına uygun şekilde
birleştirilir ve Content-Length’inde yeni XML içeriğinin uzunluğu
belirlenerek düzenlenir. Tabi ki şu anda fuzzing işlemi yapılmadığı için
XML içeriğinde bir değişme gözlenmemektedir.
Mobil
uygulamaların güvenilirliğini test etmek için sunucu ve uygulama
arasındaki iletişimin takip edilmesi ve sunucudan dönen cevaplarda
değişiklikler yaparak uygulama tarafına gönderilmesi gerekmektedir. Bu
amaca hizmet etmesi için geliştirilen MBProxy kütüphanesinin android cihazı ile konfigürasyonunu gerçekleştirerek sunucu
ve uygulamalar arasındaki iletişim izlenebilir.
Öncelikle
sanal bir android cihazının kurulması gerekmektedir. Bu kurulumun
detaylarını Google’ın geliştiriceler için hazırladığı kaynakları
kullanabilir. Oluşturulan sanal android cihazı proxy ayarları için
iki yöntem kullanabilirsiniz;
emulator -avd [ sanal_cihaz_adı ] -http-proxy [ proxy_adresi : port ]
komutu ile sanal cihazı proxy ayarları yapılı bir şekilde başlatabilirsiniz ya da
Ayarlar → Diğer ayarlar → Mobil Ağlar → Erişim Noktası Adları → Operatör Adı →
Proxy : [proxy_adresi]
Bağlantı noktası : [port]
parametrelerini girerek oluşturabiliriz.
Sanal android cihazı için proxy ayarlarını yaptıktan sonra aynı proxy adresi ve port numaras ile MBFuzzer
projesinin sahip olduğu MBProxy kütüphanesini çalıştırıp mobil uygulama
ve sunucu arasındaki iletişimi proxy üzerinden gerçekleşmesini
sağlayabilirsiniz.
#proxy’nin çalışması için #proxy’i durdurmak için Ctrl+C
MBProxy.new(proxyt_adresi,port)
Yakından
Eğitim MBFuzzer projesi başlangıcı 1 Nisan 2013 tarihinden itibaren
proje mentörü Fatih Özavcı’nın proje için belirlediği adımlar
doğrultusunda geliştirme sürecine devam edilmektedir. MBFuzzer
projesinin hedefi bir mobil uygulamanın güvenilirliğin test edilmesini
sağlamaktır. Bu kapsamda uygulamaya proxy desteği sunarak uygulama ve
sunucu arasındaki iletişimin analiz edilmesiyle beraber içeriğinin
değiştirilmesi ve bozuk cevapların incelenerek mobil uygulamanın
güvenilirliğinin test edilmesidir. MBFuzzer projesinin geldiği bir aylık
döneminde geliştirme sürecinde tamamlanan kısımları anlatarak, projenin
şimdiye kadarki durumu hakkında bilgi verecektir.
HTTP/HTTPS Proxy Desteği
MBFuzzer
projesi, ortadaki adam saldırısı yapan bir fuzzing aracı olarak
kullanılacağı için uygulamalardan gelen HTTP/HTTPS isteklerini kabul
edip sunucuya gönderen ve sunucudan gelen cevapları da uygulamaya iletme
işlevini gören bir kütüphane olarak tasarlandı ve bu hedef
doğrultusunda kütüphane geliştirildi.
İlk
olarak HTTP isteklerinin kabul edilip sunucuya yönlendirilmesi sağlandı
ve sunucudan gelen cevaplar uygulama tarafına iletildi. Burada uygulama
ve sunucu arasındaki iletişim proxy üzerinden sağlandı. Sonraki adımda
HTTPS isteklerinin kabul edilmesi ve sunucu ile bağlantısının sağlanması
üzerine çalışıldı. Burada HTTPS isteklerini de HTTP istekleri gibi
kabul ederek iletişimin sunucu tarafı ile bağlantısında IO üzerinden
bağlanılması sağlandı ve dönen cevapları HTTPS CONNECT çevirimi
yapılarak iletişim sürdürüldü.
Kütüphanenin sahip olduğu ve yaptığı işler,
Uygulamalardan
gelecek olan isteklerin dinlenileceği adres ve port bilgilerini
aldıktan sonra ara bir sunucu olarak istekleri bekler ve gelen her
isteğin kabul edilmesi ile beraber paralel olarak çalışmasını
sağlamaktadır.
Gelen
isteklerin içeriğinin okunması ve başlık bilgilerinin analizi yapılarak
isteğin türünü(HTTP/HTTPS) belirler. Bu doğrultuda istek türüne göre
sonraki adımında sunucu ile iletişime geçmesi sağlar.
HTTP
isteklerinin bağlanmak istediği uzak sunucu tarafından gelen cevapların
okumasını yaparak uygulama tarafına iletilmesini sağlar.
HTTPS istekleri için bağlanılacak uzak sunucunun adres ve port bilgileri ile bağlantı oluşturmasını gerçekleştirir.
Gelen
HTTPS isteklerinin uygulama tarafına bağlantı kuruldu mesajı
gönderildikten ve uzak sunucu ile bağlantı kurulduktan sonra uygulama
tarafı ile IO üzerinden sunucu olarak iletişim kurulmasını
sağlamaktadır.
Proxy’nin açık olan tüm bağlantıları kapatılır..
Sertifika Üretme
Uygulama
tarafından gelen HTTPS istekleri için uzak sunucuya bağlandıktan sonra
elde edilen bağlantı bilgilerinden mevcut sertifika bilgileri yardımıyla
ve uygulama tarafına bağlantının kurulduğu mesajı iletildikten sonra
gerçekleşen HTTPS oturumunda gerekli olan sertifikanın hazırlanmasını
sağlayan bir kütüphane hazırlandı. Bu kütüphanenin yapmış olduğu işlev,
İlk
olarak sertifika için kullanılacak olan key üretimini
gerçekleştirmektedir. Sonrasında, gelen mevcut sertifikanın bilgilerini
kullanarak ve üretilen key ile birlikte sertifikanın imzalanması
gereçekleştirilmektedir. Özet olarak, hem sertifikayı hem de key
bilgilerini hazırlamaktadır.
Fuzzing İçeriklerinin hazırlanması
MBFuzzer’ın ana işlevinin mobil uygulamalara çeşitli veriler
gönderilerek mobil uygulamalarda oluşan bozulmaları veya geri dönen
cevapların yapısına göre uygulamanın güvenilirliğini test etmektir. Bu
nedenle, fuzzing işlemleri için sonraki adımlarda kullanılacak
içerikler hazırlandı. Bu içerikler;
BufferOverflow : Mobil uygulamanın kodlama aşamasında hafıza kullanımını test edilmesinde kullanılmak üzere veri setleri hazırlandı.
FormatString :
Mobil uygulamanın kod yapısında beklediği bir değişken türünün üzerinde
değişiklikler yapılarak uygulamanın test edilmesini sağlayacak veri
setleri hazırlandı.
Yakından
Eğitim MBFuzzer projesinin ara dönemine kadar geçen sürede yukardıda
bahsettiğim adımları gerçekleştirdik. Bu süreçte, bir proxy’nin çalışma
prensibi, HTTP/HTTPS bağlantı türlerinin nasıl gerçekleştiği, SSL
hakkında sıkıntı yaşasamda bu kavram yapısının detayları ile ilgili
temel bilgiler edindim. MBFuzzer projesi ile açık kaynak bir proje
geliştirirken konuya bağlı olarak atılacak ilk adımlar, izlenmesi
gereken yollar, araştırma gibi başlıklarda yanlışlarımla veya
doğrularımla deneyimler kazandım.
SSL Sertifika Hazırlanması
MBFuzzer
projesinde HTTP/HTTPS destekli proxy’nin geliştirilmesinden sonraki
adım olan uygulama ve proxy arasındaki iletişimin sertifika sorunu
yaşamadan devam edebilmesi geçerli bir sertifika oluşturulmasına
dayanmaktadır.Bunun için daha önce hazırlamış olduğum sertifika
kütüphanesi üzerinde bazı düzenlemeler yaptım.
Sertifika kütüphanesinde geliştirdiğimiz proxy'deki ssl_open ile baglanilan SSL oturumunun sertifika bilgilerini ruby’nin openssl kütüphanesi
sayesinde
elde edebiliyoruz.
#serverssl, ssl_open dönen SSL oturum değişkenidir
real_cert = OpenSSL::X509::Certificate.new(serverssl.peer_cert)
#real_cert bilgilerini oluşturduğum Cert isimli kütüphaneye yollayarak
#yeni sertifika ve key bilgilerini elde eder
ncert, nkey = Cert.new.ssl_cert(real_cert)
Cert
kütüphanesinde ilk olarak RSA key oluşturma işlemi gerçekleşiyor.
Sonrasında gelen sertifika bilgileri ile birlikte ve oluşturulan key ile
bilrlikte sertifikanın gerekli parametreleri sağlanması ile birlikte
sertifikanın imzalama aşamasına geçiliyor. Mevcut bilgilerle
oluşturulmuş sertifikanın imzalama algoritması olarak SHA1 ve
başlangıçtaki RSA key ile birlikte sertifika üzerinde imza
oluşturuluyor.
#kullanılan key ve imzalama algoritması
cert.sign(key, OpenSSL::Digest::SHA1.new)
Kütüphaneyi
bu şekilde kullanıldığımda sertifika üretimi gerçekleşiyor; ancak proxy ve uygulama
üzerinde yapılan iletişimde sertifika imzasından kaynaklanan hata
bulunmaktadır. Bu sorunun üzerinde çalışmaktayım ve çözüme ulaştığımda
gerekli düzeltmeleri yapacağım.
Fuzzing içerikleri
MBFuzzer projesinin mobil uygulamaların üzerindeki temel görevi fuzzing
yapacak olmasıdır. Bu doğrultuda fuzzing için gerekli alt yapının yani
fuzzing içeriklerinin hazır hale getirilmesi gerekmektedir.
Mobil uygulamarın kodlama olarak hafıza kontrolünün nasıl olduğunu test
etmek için ilk olarak "buffer overflow" olarak adlandırılan içerikler
hazırlandı. Detaylı şekilde açıklayacak olursam, uygulama azami 10
karakter uzuluğunda bir veri bekliyor; ancak 1000 karakter uzunluğunda
gelen bir veri olursa uygulamanın davranışları ne olur sorusunun
cevabını aramak diyebiliriz. Bunun haricinde, "format string" olarak
adlandırılan gene uygulamanın beklediği bir verinin değişken türünün
değiştirilmesi durumundaki davranışlarını gözlemlemek içinde içerikler
hazırlandı.
Buffer Overlflow için,
a * 100
a * 1000
a * 10000 ....
Format String için,
MBFuzzer
için geliştirdiğim ve yalnızca HTTP istekleri üzerinden çalışan proxy
kütüphanesine HTTPS desteğini sağlamak üzere ilk olarak trağin nasıl bir
yol izlediğini anlamak için wireshark uygulamasını kullanarak analizler
yaptım. HTTP için trafik üçlü el sıkışmanın gerçekleşmesinden sonra
yalın bir şekilde paket akışı gerçekleşmekte; ancak, MBFuzzer için SSL
sertifika hazırlanması başlıklı blog yazımda SSL kavramından da
bahsettiğim gibi gelen HTTPS istekleri üçlü el sıkışma gerçekleştikten
sonra karşılıklı sertifika kontrolleri ile paket trafiği şifreli bir
şekilde devam etmekte. 
Burada
gelen istekleri uygulama katmanınamı yoksa daha alt katmanlaramı
yönlendirerek trafiği yönetme konusunda bazı sorunlar yaşadım. Bunun
sebebi daha önce geliştirdiğim kütüphanede HTTP isteklerini uygulama
katmanı üzerinde yönlendirmemdi; ancak HTTPS istekleri için aynı durum
geçerliliğini sağlamadığından çözüme gitme konusunda zorlandım. MBFuzzer
proje mentörüm Fatih Özavcı’nın hem bilgi hem de kodlama konusunda
yardımları ile öncelikle gelen tüm isteklerin HTTP bir bağlantı isteği
olduğunu varsayarak almak ve gelen bir isteğin tamamını tek seferde
aldıktan sonra başlık bilgisinin analinizini yaptıktan sonra isteğin
türünü, hedef sunucu bilgilerini çıkarttık.
#istek IO ile okunuyor
content = connection.sysread(63535)
head = content.split("\n")[0]
#İsteğin başlık bilgilerini çıkartır
type = head[/^\w+/]
url = head[/^\w+\s+(\S+)/, 1]
http = head[/HTTP\/(1\.\d)\s*$/, 1]
Buradaki
önemli bir husus ise gelen istekleri bir IO okuması yaparak almak çünkü
HTTP/HTTPS isteklerinde gelen verileri gerekli sunucuya port üzerinden
yönlendirerek trafiğin devam etmesi sağlanmaktadır.
HTTP
istekleri için daha önce ki blog yazımda anlattığım gibi gelen isteği
sunucuya iletip oradan gelen cevabıda kullanıcıya aktarıyoruz. Burada
yaptığımız değişiklik trafiği IO üzerinden akmasının sağlanması oldu.
HTTPS istekleri için ilk olarak gelen istekden bağlanılacak uzak sunucu
adresi ve portuna bir SSL bağlantısını açtıktan sonra kullanıcıya
bağlantının kurulduğu mesajı “HTTP/1.1 200 Connection Established\r\n”
gönderilerek iletşimin bir sonraki adım olan sertifika kontrolüne
geçmesi sağlanıyor. SSL sertifika kontrolünde MBFuzzer için hazırlanmış
olan sertifika dosyaları kullanılarak yalnızca sonraki süreçte
düzeltilecek olan bir bug haricinde kalan kısımda kullanıcı ve sunucu
arasındaki paket trafiğinin proxy üzerinden gerçekleşmesi
sağlanmaktadır. HTTPS konusunda yaşadığım sıkıntılı süreçte proje mentörüm
Fatih Özavcı’nın katkıları sayesinde proxy’nin HTTPS CONNECT desteği
sağlandı.
MBFuzzer
için geliştirilen Proxy kütüphanesini kullanmak için GitHub proje
sayfasında bulunan test kodunu kullanabilirsiniz. Örnek olarak,
require './lib/proxy.rb'
#proxy adresi ve portu
address = "127.0.0.1"
port = 8080
#proxy’nin başlatılması
create(address, port)
MBFuzzer
projesinde daha önce kullanıcılar tarafından gönderilen http
isteklerini alarak sunucuya ileten ve sunucu tarafından gelen yanıtları
tekrar kendi üzerinden kullanıcıya iletmeye yarayan bir proxy
kütüphanesi hazırlamıştım. Bu haftaki süreçte HTTPistekleri için
hazırlanan bu kütüphanenin geliştirilerek aynı görevi HTTPS isteklerini
sunucuya doğrudan yönledirip ve cevapları üzerinde de gerçekleştirmesini
sağlamak için Secure Socket Layer(SSL) kavramını inceledim.
SSL
kavramı temel olarak uygulamalar ile sunucu arasında güvenli olarak
iletişim kurmak için gereken bilgileri sağlayan bir sertifikaya
dayanmaktadır. Bu katman sayesinde hem kullanıcı hem de sunucu tarafında
güvenlik kontrolleri(sertifika, şifreleme algoritmaları) yapılarak
trafikte dolaşan verinin güvenliği artmaktadır. MBFuzzer için
geliştirilen proxy kütüphanesine SSL desteğinin sağlanması için ilk
olarak self-signed SSL sertifikasını oluşturan bir kütüphaneyi ruby
dökümantasyonlarındaki openssl kütüphanesi inceleyerek hazırladım. Proxy kütüphanesine eklencek SSL desteği için sertifika kütüphanesi etkili bir yere sahip olacak.
MBFuzzer için hazırlanmış bu kütüphaneyi kullanarak self-signed SSL
sertifikanızı yapmak isterseniz birkaç satırlık kod yardımı ile doğrudan
sertifika oluşturabilirsiniz. (Sertifika bilgilerini değiştirmek için
kütüphane içerisindeki “OpenSSL::X509::Name” verilerini kendiniz
yazmanız gerekmektedir.
File.new('/tmp/cert.pem','w')
cert_file = File.open('/tmp/cert.pem','w')
cert_file << ssl_cert
cert_file.close
MBFuzzer proje takibi : https://github.com/YakindanEgitim/mbfuzzer
Ruby-Doc OpenSSL : http://www.ruby-doc.org/stdlib-2.0/libdoc/openssl/rdoc/OpenSSL.html
Yakından
Eğitim proje süreleri başladıktan sonra MBFuzzer projesi üzerinde daha
net fikir sahibi olmak açısından Fatih Özavcı tarafından mobil uygulama
denetimi eğitimi aldım. MBFuzzer projesine başvurduğumda benden neler
beklendiği, projeyi nasıl geliştiriceğim konularında fikir sahibiydim;
ancak mobil uygulama eğitimi sayesinde MBFuzzer projesinin nasıl bir
işleyiş ile çalışacağını ve projeyi geliştirirken benden beklenenleri,
nasıl bir yol izlemem ve nelere dikkat etmem gerektiği konularında daha
net ve faydalı bilgiler edindim.
MBFuzzer
projesine hem başlangıç hem de sonraki adımlarda geliştirilerek
işlevinin artacağı ve temel bir görev görecek basit bir http proxy
desteği sunan bir kütüphane hazırlanması ilk hedef olarak görüldü. Bu
proxy kütüphanesinin amacı kullanıcının bağlanmak istediği sunucuya
gönderilen http isteklerini alıp kendi üzerinden sunucuya yollamasını ve
sunucu tarafından gelen cevaplarıda aynı şekilde alıp kullanıcıya
iletmesini sağlamaktır.
Kütüphanenin
temel olarak kullanacağı bu yapı sayesinde kullanıcı ve sunucu
arasındaki iletişimi proxy üzerinden geçirerek arada oluşan tarifğin
kontrol altına alınması sağlanmış olucaktır. Bu yapıyı örnek alarak ve
Ruby’nin kendi içindeki bazı kütüphaneleri kullanarak http proxy hizmeti
sunan bir kütüphane hazırladım. Genel olarak hedeflenen hizmeti sunuyor
olsada ileri ki aşamalarda daha verimli bir şekilde hizmet edecektir.
