diff --git a/src/SUMMARY.md b/src/SUMMARY.md
index 27f33cff3..2062b6f9d 100644
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@@ -61,6 +61,7 @@
     - [Deofuscation vbs (cscript.exe)](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/desofuscation-vbs-cscript.exe.md)
     - [Discord Cache Forensics](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/discord-cache-forensics.md)
     - [Local Cloud Storage](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/local-cloud-storage.md)
+    - [Mach O Entitlements And Ipsw Indexing](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/mach-o-entitlements-and-ipsw-indexing.md)
     - [Office file analysis](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/office-file-analysis.md)
     - [PDF File analysis](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/pdf-file-analysis.md)
     - [PNG tricks](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/png-tricks.md)
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/README.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/README.md
index 4861d505e..f5d1f3a38 100644
--- a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/README.md
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/README.md
@@ -1,8 +1,8 @@
-# Belirli Yazılım/Dosya Türü Püf Noktaları
+# Belirli Yazılım/Dosya Türü İpuçları
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-Burada belirli dosya türleri ve/veya yazılımlar için ilginç püf noktalarını bulabilirsiniz:
+Burada belirli dosya türleri ve/veya yazılımlar için ilginç ipuçları bulabilirsiniz:
 
 
 {{#ref}}
@@ -54,4 +54,9 @@ video-and-audio-file-analysis.md
 zips-tricks.md
 {{#endref}}
 
+
+{{#ref}}
+mach-o-entitlements-and-ipsw-indexing.md
+{{#endref}}
+
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/mach-o-entitlements-and-ipsw-indexing.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/mach-o-entitlements-and-ipsw-indexing.md
new file mode 100644
index 000000000..820c4c9ff
--- /dev/null
+++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/mach-o-entitlements-and-ipsw-indexing.md
@@ -0,0 +1,213 @@
+# Mach-O Entitlements (İzinler) Çıkarma ve IPSW İndeksleme
+
+{{#include ../../../banners/hacktricks-training.md}}
+
+## Genel Bakış
+
+Bu sayfa, Mach-O ikili dosyalarından programatik olarak entitlements (izinler) nasıl çıkarılacağını — LC_CODE_SIGNATURE içinde gezip code signing SuperBlob'u parse ederek — ve Apple IPSW firmware'leri üzerinde içeriklerini mount edip indeksleyerek adli arama/farklama için bunu nasıl ölçeklendireceğinizi ele alır.
+
+Mach-O formatı ve code signing hakkında bir tazelemeye ihtiyacınız varsa, ayrıca bakınız: macOS code signing and SuperBlob internals.
+- Check macOS code signing details (SuperBlob, Code Directory, special slots): [macOS Code Signing](../../../macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-code-signing.md)
+- Check general Mach-O structures/load commands: [Universal binaries & Mach-O Format](../../../macos-hardening/macos-security-and-privilege-escalation/macos-files-folders-and-binaries/universal-binaries-and-mach-o-format.md)
+
+
+## Entitlements in Mach-O: nerede bulunurlar
+
+Entitlements, LC_CODE_SIGNATURE load command tarafından referans verilen ve __LINKEDIT segmentine yerleştirilen code signature verisinin içinde saklanır. İmza, birden fazla blob içeren CS_SuperBlob'dur (code directory, requirements, entitlements, CMS, vb.). Entitlements blob'u, verisi Apple Binary Property List (bplist00) olan bir CS_GenericBlob'dur ve entitlements anahtarlarını değerlerle eşler.
+
+Ana yapılar (xnu'dan):
+```c
+/* mach-o/loader.h */
+struct mach_header_64 {
+uint32_t magic;
+cpu_type_t cputype;
+cpu_subtype_t cpusubtype;
+uint32_t filetype;
+uint32_t ncmds;
+uint32_t sizeofcmds;
+uint32_t flags;
+uint32_t reserved;
+};
+
+struct load_command {
+uint32_t cmd;
+uint32_t cmdsize;
+};
+
+/* Entitlements live behind LC_CODE_SIGNATURE (cmd=0x1d) */
+struct linkedit_data_command {
+uint32_t cmd;        /* LC_CODE_SIGNATURE */
+uint32_t cmdsize;    /* sizeof(struct linkedit_data_command) */
+uint32_t dataoff;    /* file offset of data in __LINKEDIT */
+uint32_t datasize;   /* file size of data in __LINKEDIT */
+};
+
+/* osfmk/kern/cs_blobs.h */
+typedef struct __SC_SuperBlob {
+uint32_t magic;   /* CSMAGIC_EMBEDDED_SIGNATURE = 0xfade0cc0 */
+uint32_t length;
+uint32_t count;
+CS_BlobIndex index[];
+} CS_SuperBlob;
+
+typedef struct __BlobIndex {
+uint32_t type;    /* e.g., CSMAGIC_EMBEDDED_ENTITLEMENTS = 0xfade7171 */
+uint32_t offset;  /* offset of entry */
+} CS_BlobIndex;
+
+typedef struct __SC_GenericBlob {
+uint32_t magic;   /* same as type when standalone */
+uint32_t length;
+char data[];      /* Apple Binary Plist containing entitlements */
+} CS_GenericBlob;
+```
+Önemli sabitler:
+- LC_CODE_SIGNATURE cmd = 0x1d
+- CS SuperBlob magic = 0xfade0cc0
+- Entitlements blob type (CSMAGIC_EMBEDDED_ENTITLEMENTS) = 0xfade7171
+- DER entitlements özel bir slotta (ör. -7) bulunabilir; özel slotlar ve DER entitlements ile ilgili notlar için macOS Code Signing sayfasına bakın
+
+Not: Multi-arch (fat) binaries birden fazla Mach-O slice içerir. İncelemek istediğiniz mimariye ait slice'ı seçip yükleme komutları (load commands) üzerinde dolaşmalısınız.
+
+
+## Extraction steps (generic, lossless-enough)
+
+1) Mach-O header'ını ayrıştırın; ncmds kadar load_command kaydı üzerinde yineleyin.
+2) LC_CODE_SIGNATURE'ı bulun; linkedit_data_command.dataoff/datasize değerlerini okuyarak __LINKEDIT içine yerleştirilmiş Code Signing SuperBlob'u haritalayın.
+3) CS_SuperBlob.magic == 0xfade0cc0 olduğunu doğrulayın; count adet CS_BlobIndex girdisi üzerinde yineleyin.
+4) index.type == 0xfade7171 (embedded entitlements) olan girdiyi bulun. İşaret edilen CS_GenericBlob'u okuyun ve verisini Apple binary plist (bplist00) olarak ayrıştırıp anahtar/değer entitlements elde edin.
+
+Uygulama notları:
+- Code signature yapıları big-endian alanlar kullanır; little-endian host'larda ayrıştırırken byte sırasını ters çevirin.
+- Entitlements GenericBlob verisi kendisi bir binary plist'tir (standart plist kütüphaneleriyle işlenir).
+- Bazı iOS binary'leri DER entitlements taşıyabilir; ayrıca bazı store/slot'lar platform/versiyona göre farklılık gösterebilir. Gerekirse hem standart hem DER entitlements'ı çapraz kontrol edin.
+- Fat binary'ler için, Mach-O load commands üzerinde dolaşmadan önce doğru slice ve offset'i bulmak amacıyla fat başlıkları (FAT_MAGIC/FAT_MAGIC_64) kullanın.
+
+
+## Minimal parsing outline (Python)
+
+Aşağıdakiler, entitlements'ı bulup decode etmek için kontrol akışını gösteren kompakt bir taslaktır. Kısalık için kasıtlı olarak sağlam sınır kontrolleri ve tam fat binary desteği hariç bırakılmıştır.
+```python
+import plistlib, struct
+
+LC_CODE_SIGNATURE = 0x1d
+CSMAGIC_EMBEDDED_SIGNATURE = 0xfade0cc0
+CSMAGIC_EMBEDDED_ENTITLEMENTS = 0xfade7171
+
+# all code-signing integers are big-endian per cs_blobs.h
+be32 = lambda b, off: struct.unpack_from(">I", b, off)[0]
+
+def parse_entitlements(macho_bytes):
+# assume already positioned at a single-arch Mach-O slice
+magic, = struct.unpack_from("<I", macho_bytes, 0)
+is64 = magic in (0xfeedfacf,)
+if is64:
+ncmds = struct.unpack_from("<I", macho_bytes, 0x10)[0]
+sizeofcmds = struct.unpack_from("<I", macho_bytes, 0x14)[0]
+off = 0x20
+else:
+# 32-bit not shown
+return None
+
+code_sig_off = code_sig_size = None
+for _ in range(ncmds):
+cmd, cmdsize = struct.unpack_from("<II", macho_bytes, off)
+if cmd == LC_CODE_SIGNATURE:
+# struct linkedit_data_command is little-endian in file
+_, _, dataoff, datasize = struct.unpack_from("<IIII", macho_bytes, off)
+code_sig_off, code_sig_size = dataoff, datasize
+off += cmdsize
+
+if code_sig_off is None:
+return None
+
+blob = macho_bytes[code_sig_off: code_sig_off + code_sig_size]
+if be32(blob, 0x0) != CSMAGIC_EMBEDDED_SIGNATURE:
+return None
+
+count = be32(blob, 0x8)
+# iterate BlobIndex entries (8 bytes each after 12-byte header)
+for i in range(count):
+idx_off = 12 + i*8
+btype = be32(blob, idx_off)
+boff  = be32(blob, idx_off+4)
+if btype == CSMAGIC_EMBEDDED_ENTITLEMENTS:
+# GenericBlob is big-endian header followed by bplist
+glen = be32(blob, boff+4)
+data = blob[boff+8: boff+glen]
+return plistlib.loads(data)
+return None
+```
+Usage tips:
+- To handle fat binaries, first read struct fat_header/fat_arch, choose the desired architecture slice, then pass the subrange to parse_entitlements.
+- On macOS you can validate results with: codesign -d --entitlements :- /path/to/binary
+
+
+## Example findings
+
+Privileged platform binaries often request sensitive entitlements such as:
+- com.apple.security.network.server = true
+- com.apple.rootless.storage.early_boot_mount = true
+- com.apple.private.kernel.system-override = true
+- com.apple.private.pmap.load-trust-cache = ["cryptex1.boot.os", "cryptex1.boot.app", "cryptex1.safari-downlevel"]
+
+Searching these at scale across firmware images is extremely valuable for attack surface mapping and diffing across releases/devices.
+
+
+## Scaling across IPSWs (mounting and indexing)
+
+To enumerate executables and extract entitlements at scale without storing full images:
+
+- Use the ipsw tool by @blacktop to download and mount firmware filesystems. Mounting leverages apfs-fuse, so you can traverse APFS volumes without full extraction.
+```bash
+# Download latest IPSW for iPhone11,2 (iPhone XS)
+ipsw download ipsw -y --device iPhone11,2 --latest
+
+# Mount IPSW filesystem (uses underlying apfs-fuse)
+ipsw mount fs <IPSW_FILE>
+```
+- Bağlı hacimleri gezerek Mach-O dosyalarını bul (magic'i kontrol et ve/veya file/otool kullan), sonra entitlements ve imported frameworks'i parse et.
+- Binlerce IPSWs üzerinde lineer büyümeyi önlemek için normalize edilmiş bir görünümü ilişkisel bir veritabanına sakla:
+- executables, operating_system_versions, entitlements, frameworks
+- çoktan-çoğa: executable↔OS version, executable↔entitlement, executable↔framework
+
+Verilen bir executable adını içeren tüm OS versiyonlarını listelemek için örnek sorgu:
+```sql
+SELECT osv.version AS "Versions"
+FROM device d
+LEFT JOIN operating_system_version osv ON osv.device_id = d.id
+LEFT JOIN executable_operating_system_version eosv ON eosv.operating_system_version_id = osv.id
+LEFT JOIN executable e ON e.id = eosv.executable_id
+WHERE e.name = "launchd";
+```
+Notes on DB portability (if you implement your own indexer):
+- Use an ORM/abstraction (e.g., SeaORM) to keep code DB-agnostic (SQLite/PostgreSQL).
+- SQLite requires AUTOINCREMENT only on an INTEGER PRIMARY KEY; if you want i64 PKs in Rust, generate entities as i32 and convert types, SQLite stores INTEGER as 8-byte signed internally.
+
+
+## Açık kaynaklı araçlar ve referanslar (entitlement hunting için)
+
+- Firmware mount/download: https://github.com/blacktop/ipsw
+- Entitlement databases and references:
+- Jonathan Levin’s entitlement DB: https://newosxbook.com/ent.php
+- entdb: https://github.com/ChiChou/entdb
+- Large-scale indexer (Rust, self-hosted Web UI + OpenAPI): https://github.com/synacktiv/appledb_rs
+- Apple headers for structures and constants:
+- loader.h (Mach-O headers, load commands)
+- cs_blobs.h (SuperBlob, GenericBlob, CodeDirectory)
+
+For more on code signing internals (Code Directory, special slots, DER entitlements), see: [macOS Code Signing](../../../macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-code-signing.md)
+
+
+## References
+
+- [appledb_rs: a research support tool for Apple platforms](https://www.synacktiv.com/publications/appledbrs-un-outil-daide-a-la-recherche-sur-plateformes-apple.html)
+- [synacktiv/appledb_rs](https://github.com/synacktiv/appledb_rs)
+- [blacktop/ipsw](https://github.com/blacktop/ipsw)
+- [Jonathan Levin’s entitlement DB](https://newosxbook.com/ent.php)
+- [ChiChou/entdb](https://github.com/ChiChou/entdb)
+- [XNU cs_blobs.h](https://github.com/apple-oss-distributions/xnu/blob/main/osfmk/kern/cs_blobs.h)
+- [XNU mach-o/loader.h](https://github.com/apple-oss-distributions/xnu/blob/main/EXTERNAL_HEADERS/mach-o/loader.h)
+- [SQLite Datatypes](https://sqlite.org/datatype3.html)
+
+{{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-files-folders-and-binaries/universal-binaries-and-mach-o-format.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-files-folders-and-binaries/universal-binaries-and-mach-o-format.md
index a24896f8d..233604729 100644
--- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-files-folders-and-binaries/universal-binaries-and-mach-o-format.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-files-folders-and-binaries/universal-binaries-and-mach-o-format.md
@@ -1,61 +1,61 @@
-# macOS Universal binaries & Mach-O Format
+# macOS Universal ikili dosyalar & Mach-O Formatı
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## Temel Bilgiler
 
-Mac OS ikili dosyaları genellikle **evrensel ikili dosyalar** olarak derlenir. Bir **evrensel ikili dosya** **aynı dosyada birden fazla mimariyi destekleyebilir**.
+Mac OS ikili dosyaları genellikle **evrensel ikili dosya** olarak derlenir. Bir **evrensel ikili dosya**, **aynı dosya içinde birden fazla mimariyi destekleyebilir**.
 
-Bu ikili dosyalar **Mach-O yapısını** takip eder ve bu yapı temelde şunlardan oluşur:
+Bu ikili dosyalar temelde şu öğelerden oluşan **Mach-O yapısını** takip eder:
 
 - Başlık
-- Yükleme Komutları
+- Load Komutları
 - Veri
 
 ![https://alexdremov.me/content/images/2022/10/6XLCD.gif](<../../../images/image (470).png>)
 
-## Fat Başlık
+## Fat Başlığı
 
-Dosyayı aramak için: `mdfind fat.h | grep -i mach-o | grep -E "fat.h$"`
+Dosyayı şu komutla ara: `mdfind fat.h | grep -i mach-o | grep -E "fat.h$"`
 
 <pre class="language-c"><code class="lang-c"><strong>#define FAT_MAGIC	0xcafebabe
 </strong><strong>#define FAT_CIGAM	0xbebafeca	/* NXSwapLong(FAT_MAGIC) */
 </strong>
 struct fat_header {
-<strong>	uint32_t	magic;		/* FAT_MAGIC veya FAT_MAGIC_64 */
-</strong><strong>	uint32_t	nfat_arch;	/* takip eden yapıların sayısı */
+<strong>	uint32_t	magic;		/* FAT_MAGIC or FAT_MAGIC_64 */
+</strong><strong>	uint32_t	nfat_arch;	/* number of structs that follow */
 </strong>};
 
 struct fat_arch {
-cpu_type_t	cputype;	/* cpu belirleyici (int) */
-cpu_subtype_t	cpusubtype;	/* makine belirleyici (int) */
-uint32_t	offset;		/* bu nesne dosyasına dosya ofseti */
-uint32_t	size;		/* bu nesne dosyasının boyutu */
-uint32_t	align;		/* 2'nin kuvveti olarak hizalama */
+cpu_type_t	cputype;	/* cpu specifier (int) */
+cpu_subtype_t	cpusubtype;	/* machine specifier (int) */
+uint32_t	offset;		/* file offset to this object file */
+uint32_t	size;		/* size of this object file */
+uint32_t	align;		/* alignment as a power of 2 */
 };
 </code></pre>
 
-Başlık, **magic** baytları ile başlar ve dosyanın **içerdiği** **mimari** sayısını (`nfat_arch`) takip eder ve her mimari bir `fat_arch` yapısına sahip olacaktır.
+Başlık, **magic** byte'larını ve ardından dosyanın **içerdiği** **mimarilerin** **sayı**sını (`nfat_arch`) içerir ve her mimari için bir `fat_arch` struct'ı olur.
 
-Bunu kontrol etmek için:
+Şununla kontrol et:
 
 <pre class="language-shell-session"><code class="lang-shell-session">% file /bin/ls
-/bin/ls: Mach-O evrensel ikili dosya, 2 mimari ile: [x86_64:Mach-O 64-bit yürütülebilir x86_64] [arm64e:Mach-O 64-bit yürütülebilir arm64e]
-/bin/ls (mimari x86_64 için):	Mach-O 64-bit yürütülebilir x86_64
-/bin/ls (mimari arm64e için):	Mach-O 64-bit yürütülebilir arm64e
+/bin/ls: Mach-O universal binary with 2 architectures: [x86_64:Mach-O 64-bit executable x86_64] [arm64e:Mach-O 64-bit executable arm64e]
+/bin/ls (for architecture x86_64):	Mach-O 64-bit executable x86_64
+/bin/ls (for architecture arm64e):	Mach-O 64-bit executable arm64e
 
 % otool -f -v /bin/ls
-Fat başlıklar
+Fat headers
 fat_magic FAT_MAGIC
 <strong>nfat_arch 2
-</strong><strong>mimari x86_64
+</strong><strong>architecture x86_64
 </strong>    cputype CPU_TYPE_X86_64
 cpusubtype CPU_SUBTYPE_X86_64_ALL
 capabilities 0x0
 <strong>    offset 16384
 </strong><strong>    size 72896
 </strong>    align 2^14 (16384)
-<strong>mimari arm64e
+<strong>architecture arm64e
 </strong>    cputype CPU_TYPE_ARM64
 cpusubtype CPU_SUBTYPE_ARM64E
 capabilities PTR_AUTH_VERSION USERSPACE 0
@@ -64,15 +64,15 @@ capabilities PTR_AUTH_VERSION USERSPACE 0
 </strong>    align 2^14 (16384)
 </code></pre>
 
-ya da [Mach-O View](https://sourceforge.net/projects/machoview/) aracını kullanarak:
+veya [Mach-O View](https://sourceforge.net/projects/machoview/) aracını kullanarak:
 
 <figure><img src="../../../images/image (1094).png" alt=""><figcaption></figcaption></figure>
 
-Düşündüğünüz gibi, genellikle 2 mimari için derlenmiş bir evrensel ikili dosya, sadece 1 mimari için derlenmiş olanın **boyutunu iki katına çıkarır**.
+Muhtemelen düşüneceğiniz gibi, genellikle iki mimari için derlenen bir evrensel ikili dosya, sadece bir mimari için derlenene göre boyutunu **iki katına çıkarır**.
 
 ## **Mach-O Başlığı**
 
-Başlık, dosyanın Mach-O dosyası olarak tanımlanmasını sağlayan magic baytları ve hedef mimari hakkında bilgi gibi temel bilgileri içerir. Bunu şurada bulabilirsiniz: `mdfind loader.h | grep -i mach-o | grep -E "loader.h$"`
+Başlık, dosya hakkında temel bilgileri içerir; örneğin dosyanın Mach-O dosyası olduğunu belirlemek için kullanılan magic byte'lar ve hedef mimariye ilişkin bilgiler. Şunu kullanarak bulabilirsiniz: `mdfind loader.h | grep -i mach-o | grep -E "loader.h$"`
 ```c
 #define	MH_MAGIC	0xfeedface	/* the mach magic number */
 #define MH_CIGAM	0xcefaedfe	/* NXSwapInt(MH_MAGIC) */
@@ -101,18 +101,18 @@ uint32_t	reserved;	/* reserved */
 ```
 ### Mach-O Dosya Türleri
 
-Farklı dosya türleri vardır, bunlar [**örnek olarak burada**](https://opensource.apple.com/source/xnu/xnu-2050.18.24/EXTERNAL_HEADERS/mach-o/loader.h) tanımlanmıştır. En önemli olanları şunlardır:
+Farklı dosya türleri vardır, bunların tanımlamalarını [**source code for example here**](https://opensource.apple.com/source/xnu/xnu-2050.18.24/EXTERNAL_HEADERS/mach-o/loader.h) içinde bulabilirsiniz. En önemlileri şunlardır:
 
-- `MH_OBJECT`: Yeniden yerleştirilebilir nesne dosyası (derleme ara ürünleri, henüz çalıştırılabilir değil).
-- `MH_EXECUTE`: Çalıştırılabilir dosyalar.
+- `MH_OBJECT`: Yeniden konumlandırılabilir object dosyası (derlemenin ara ürünleri, henüz yürütülebilir değiller).
+- `MH_EXECUTE`: Yürütülebilir dosyalar.
 - `MH_FVMLIB`: Sabit VM kütüphane dosyası.
-- `MH_CORE`: Kod Dökümleri
-- `MH_PRELOAD`: Önceden yüklenmiş çalıştırılabilir dosya (XNU'da artık desteklenmiyor)
-- `MH_DYLIB`: Dinamik Kütüphaneler
-- `MH_DYLINKER`: Dinamik Bağlayıcı
-- `MH_BUNDLE`: "Eklenti dosyaları". gcc'de -bundle kullanılarak oluşturulur ve `NSBundle` veya `dlopen` ile açıkça yüklenir.
+- `MH_CORE`: Kod dökümleri
+- `MH_PRELOAD`: Önyüklenmiş yürütülebilir dosya (XNU'da artık desteklenmiyor)
+- `MH_DYLIB`: Dinamik kütüphaneler
+- `MH_DYLINKER`: Dinamik bağlayıcı
+- `MH_BUNDLE`: "Eklenti dosyaları". -bundle in gcc kullanılarak oluşturulur ve `NSBundle` veya `dlopen` ile açıkça yüklenir.
 - `MH_DYSM`: Eşlik eden `.dSym` dosyası (hata ayıklama için semboller içeren dosya).
-- `MH_KEXT_BUNDLE`: Çekirdek Uzantıları.
+- `MH_KEXT_BUNDLE`: Çekirdek uzantıları.
 ```bash
 # Checking the mac header of a binary
 otool -arch arm64e -hv /bin/ls
@@ -120,67 +120,67 @@ Mach header
 magic  cputype cpusubtype  caps    filetype ncmds sizeofcmds      flags
 MH_MAGIC_64    ARM64          E USR00     EXECUTE    19       1728   NOUNDEFS DYLDLINK TWOLEVEL PIE
 ```
-Or using [Mach-O View](https://sourceforge.net/projects/machoview/):
+Veya [Mach-O View](https://sourceforge.net/projects/machoview/):
 
 <figure><img src="../../../images/image (1133).png" alt=""><figcaption></figcaption></figure>
 
 ## **Mach-O Bayrakları**
 
-Kaynak kodu, kütüphaneleri yüklemek için yararlı olan birkaç bayrak tanımlar:
+Kaynak kod ayrıca kütüphanelerin yüklenmesi için faydalı birkaç bayrak tanımlar:
 
-- `MH_NOUNDEFS`: Tanımsız referans yok (tamamen bağlantılı)
-- `MH_DYLDLINK`: Dyld bağlantısı
+- `MH_NOUNDEFS`: Tanımsız referans yok (tam bağlanmış)
+- `MH_DYLDLINK`: Dyld ile bağlama
 - `MH_PREBOUND`: Dinamik referanslar önceden bağlanmış.
-- `MH_SPLIT_SEGS`: Dosya r/o ve r/w segmentlerini ayırır.
-- `MH_WEAK_DEFINES`: İkili zayıf tanımlı sembollere sahiptir
+- `MH_SPLIT_SEGS`: Dosya, yalnızca okunur (r/o) ve okunur/yazılır (r/w) segmentlerine ayrılmıştır.
+- `MH_WEAK_DEFINES`: İkili, zayıf tanımlı semboller içerir
 - `MH_BINDS_TO_WEAK`: İkili zayıf semboller kullanır
-- `MH_ALLOW_STACK_EXECUTION`: Yığını çalıştırılabilir hale getir
-- `MH_NO_REEXPORTED_DYLIBS`: Kütüphane LC_REEXPORT komutları yok
-- `MH_PIE`: Konum Bağımsız Yürütülebilir
-- `MH_HAS_TLV_DESCRIPTORS`: Thread yerel değişkenlerle bir bölüm var
-- `MH_NO_HEAP_EXECUTION`: Yığın/veri sayfaları için yürütme yok
-- `MH_HAS_OBJC`: İkili oBject-C bölümlerine sahiptir
+- `MH_ALLOW_STACK_EXECUTION`: Yığını yürütülebilir yapar
+- `MH_NO_REEXPORTED_DYLIBS`: Kütüphane LC_REEXPORT komutları içermez
+- `MH_PIE`: Konumdan bağımsız yürütülebilir (PIE)
+- `MH_HAS_TLV_DESCRIPTORS`: İş parçacığı yerel değişkenleri içeren bir bölüm vardır
+- `MH_NO_HEAP_EXECUTION`: Heap/veri sayfalarında yürütme yok
+- `MH_HAS_OBJC`: İkili, Objective-C bölümleri içerir
 - `MH_SIM_SUPPORT`: Simülatör desteği
-- `MH_DYLIB_IN_CACHE`: Paylaşılan kütüphane önbelleğinde dylibs/frameworks üzerinde kullanılır.
+- `MH_DYLIB_IN_CACHE`: Paylaşılan kütüphane önbelleğindeki dylibs/framework'lerde kullanılır.
 
-## **Mach-O Yükleme komutları**
+## **Mach-O Load commands**
 
-**Dosyanın bellek düzeni** burada belirtilmiştir, **sembol tablosunun konumu**, yürütme başlangıcındaki ana iş parçacığının bağlamı ve gerekli **paylaşılan kütüphaneler** detaylandırılmıştır. Dinamik yükleyiciye **(dyld)** ikilinin belleğe yüklenme süreci hakkında talimatlar verilir.
+Dosyanın bellekteki düzeni burada belirtilir; sembol tablosunun konumunu, yürütme başlangıcındaki ana iş parçacığının bağlamını ve gerekli paylaşılan kütüphaneleri detaylandırır. Dinamik yükleyiciye (dyld), ikilinin belleğe yüklenme süreci hakkında talimatlar sağlar.
 
-**load_command** yapısını kullanır, belirtilen **`loader.h`** dosyasında tanımlanmıştır:
+Bunun için, bahsedilen `loader.h` içinde tanımlı olan load_command yapısı kullanılır:
 ```objectivec
 struct load_command {
 uint32_t cmd;           /* type of load command */
 uint32_t cmdsize;       /* total size of command in bytes */
 };
 ```
-**Sistem tarafından farklı şekilde işlenen yaklaşık **50 farklı yükleme komutu türü** vardır. En yaygın olanları: `LC_SEGMENT_64`, `LC_LOAD_DYLINKER`, `LC_MAIN`, `LC_LOAD_DYLIB` ve `LC_CODE_SIGNATURE`.
+There are about **50 farklı load command türü** vardır ve sistem bunları farklı şekilde ele alır. En yaygın olanlar: `LC_SEGMENT_64`, `LC_LOAD_DYLINKER`, `LC_MAIN`, `LC_LOAD_DYLIB` ve `LC_CODE_SIGNATURE`.
 
 ### **LC_SEGMENT/LC_SEGMENT_64**
 
 > [!TIP]
-> Temelde, bu tür bir Yükleme Komutu, ikili dosya çalıştırıldığında **\_\_TEXT** (yürütülebilir kod) **ve \_\_DATA** (işlem için veri) **segmentlerini** **Veri bölümünde belirtilen ofsetlere** göre **nasıl yükleyeceğini** tanımlar.
+> Temelde, bu tür bir Load Command, binary çalıştırıldığında **__TEXT'in nasıl yükleneceğini** (çalıştırılabilir kod) **ve __DATA'nın** (işlem için veri) **segmentlerinin** **Data bölümünde belirtilen ofsetlere** göre tanımlar.
 
-Bu komutlar, bir işlem çalıştırıldığında **sanallaştırılmış bellek alanına** **haritalanan segmentleri** **tanımlar**.
+Bu komutlar, yürütüldüğünde bir işlemin **sanal bellek alanına** **haritalanan** **segmentleri tanımlar**.
 
-**\_\_TEXT** segmenti gibi **farklı türde** segmentler vardır; bu segment, bir programın yürütülebilir kodunu tutar ve **\_\_DATA** segmenti, işlem tarafından kullanılan verileri içerir. Bu **segmentler, Mach-O dosyasının veri bölümünde** yer alır.
+Farklı türde segmentler vardır; örneğin programın çalıştırılabilir kodunu barındıran __TEXT segmenti ve işlem tarafından kullanılan verileri içeren __DATA segmenti. Bu segmentler Mach-O dosyasının data bölümünde bulunur.
 
-**Her segment**, daha fazla **bölüme** **ayrılabilir**. **Yükleme komutu yapısı**, ilgili segment içindeki **bu bölümler** hakkında **bilgi** içerir.
+Her segment daha sonra birden fazla section'a bölünebilir. Load command yapısı, ilgili segment içindeki bu bölümler hakkında bilgi içerir.
 
-Başlıkta önce **segment başlığı** bulunur:
+Başlıkta önce segment başlığı bulunur:
 
-<pre class="language-c"><code class="lang-c">struct segment_command_64 { /* 64-bit mimariler için */
+<pre class="language-c"><code class="lang-c">struct segment_command_64 { /* for 64-bit architectures */
 uint32_t	cmd;		/* LC_SEGMENT_64 */
-uint32_t	cmdsize;	/* section_64 yapı boyutunu içerir */
-char		segname[16];	/* segment adı */
-uint64_t	vmaddr;		/* bu segmentin bellek adresi */
-uint64_t	vmsize;		/* bu segmentin bellek boyutu */
-uint64_t	fileoff;	/* bu segmentin dosya ofseti */
-uint64_t	filesize;	/* dosyadan haritalanacak miktar */
-int32_t		maxprot;	/* maksimum VM koruma */
-int32_t		initprot;	/* başlangıç VM koruma */
-<strong>	uint32_t	nsects;		/* segmentteki bölüm sayısı */
-</strong>	uint32_t	flags;		/* bayraklar */
+uint32_t	cmdsize;	/* includes sizeof section_64 structs */
+char		segname[16];	/* segment name */
+uint64_t	vmaddr;		/* memory address of this segment */
+uint64_t	vmsize;		/* memory size of this segment */
+uint64_t	fileoff;	/* file offset of this segment */
+uint64_t	filesize;	/* amount to map from the file */
+int32_t		maxprot;	/* maximum VM protection */
+int32_t		initprot;	/* initial VM protection */
+<strong>	uint32_t	nsects;		/* number of sections in segment */
+</strong>	uint32_t	flags;		/* flags */
 };
 </code></pre>
 
@@ -188,7 +188,7 @@ Segment başlığı örneği:
 
 <figure><img src="../../../images/image (1126).png" alt=""><figcaption></figcaption></figure>
 
-Bu başlık, **sonrasında görünen bölüm başlıklarının sayısını** tanımlar:
+Bu başlık, **ardından gelen bölüm başlıklarının sayısını** tanımlar:
 ```c
 struct section_64 { /* for 64-bit architectures */
 char		sectname[16];	/* name of this section */
@@ -209,58 +209,58 @@ uint32_t	reserved3;	/* reserved */
 
 <figure><img src="../../../images/image (1108).png" alt=""><figcaption></figcaption></figure>
 
-Eğer **bölüm ofsetini** (0x37DC) + **mimari başlangıç ofsetini** eklerseniz, bu durumda `0x18000` --> `0x37DC + 0x18000 = 0x1B7DC`
+Eğer **section offset** (0x37DC) ile **arch starts**'ın bulunduğu **offset**i toplarsanız, bu durumda `0x18000` --> `0x37DC + 0x18000 = 0x1B7DC`
 
 <figure><img src="../../../images/image (701).png" alt=""><figcaption></figcaption></figure>
 
-Ayrıca **başlık bilgilerini** **komut satırından** almak da mümkündür:
+Ayrıca **headers information**'ı **command line** üzerinden şu şekilde almak da mümkündür:
 ```bash
 otool -lv /bin/ls
 ```
-Bu cmd tarafından yüklenen yaygın segmentler:
+Common segments loaded by this cmd:
 
-- **`__PAGEZERO`:** Çekirdeğe **adres sıfırını** **haritalandırmasını** söyler, böylece **okunamaz, yazılamaz veya çalıştırılamaz**. Yapıdaki maxprot ve minprot değişkenleri, bu sayfada **okuma-yazma-çalıştırma hakları olmadığını** belirtmek için sıfıra ayarlanır.
-- Bu tahsis, **NULL işaretçi dereferans zafiyetlerini azaltmak** için önemlidir. Bunun nedeni, XNU'nun ilk sayfanın (sadece ilk) belleğin erişilemez olmasını sağlayan sert bir sayfa sıfırı uygulamasıdır (i386 dışında). Bir ikili, ilk 4k'yi kapsamak için küçük bir \_\_PAGEZERO oluşturarak ve geri kalan 32bit belleği hem kullanıcı hem de çekirdek modunda erişilebilir hale getirerek bu gereksinimleri karşılayabilir.
-- **`__TEXT`**: **okunabilir** ve **çalıştırılabilir** (yazılabilir değil) **kod** içerir. Bu segmentin yaygın bölümleri:
+- **`__PAGEZERO`:** Kernel'e **adres sıfırını haritalamasını** talimat verir; böylece bu adres **okunamaz, yazılamaz veya çalıştırılamaz**. Yapıdaki maxprot ve minprot değişkenleri bu sayfada **okuma-yazma-çalıştırma haklarının olmadığını** göstermek için sıfıra ayarlanır.
+- Bu tahsis, **NULL pointer dereference zaafiyetlerini hafifletmek** için önemlidir. Bunun nedeni XNU'nun ilk sayfanın (sadece ilk) erişilemez olmasını sağlayan sert bir page zero uygulamasıdır (i386 hariç). Bir binary, bu gereksinimi karşılamak için küçük bir \_\_PAGEZERO ( `-pagezero_size` kullanarak) oluşturup ilk 4k'yı kapsayabilir ve kalan 32-bit belleği hem user hem de kernel modunda erişilebilir tutabilir.
+- **`__TEXT`**: **yürütülebilir** **kod** içeren, **okuma** ve **çalıştırma** izinlerine sahip (yazılabilir olmayan) bir segmenttir. Bu segmentin yaygın bölümleri:
 - `__text`: Derlenmiş ikili kod
-- `__const`: Sabit veri (sadece okunabilir)
-- `__[c/u/os_log]string`: C, Unicode veya os log string sabitleri
-- `__stubs` ve `__stubs_helper`: Dinamik kütüphane yükleme sürecinde yer alır
-- `__unwind_info`: Yığın açılma verisi.
-- Tüm bu içeriğin imzalandığını ancak aynı zamanda çalıştırılabilir olarak işaretlendiğini unutmayın (bu ayrıcalığı gerektirmeyen bölümlerin istismar seçeneklerini artırır, örneğin string'e özel bölümler).
-- **`__DATA`**: **okunabilir** ve **yazılabilir** (çalıştırılabilir değil) veri içerir.
-- `__got:` Küresel Ofset Tablosu
-- `__nl_symbol_ptr`: Tembel olmayan (yükleme sırasında bağlanan) sembol işaretçisi
-- `__la_symbol_ptr`: Tembel (kullanımda bağlanan) sembol işaretçisi
-- `__const`: Sadece okunabilir veri olmalıdır (gerçekte değil)
-- `__cfstring`: CoreFoundation string'leri
-- `__data`: Küresel değişkenler (başlatılmış olanlar)
-- `__bss`: Statik değişkenler (başlatılmamış olanlar)
-- `__objc_*` (\_\_objc_classlist, \_\_objc_protolist, vb): Objective-C çalışma zamanı tarafından kullanılan bilgiler
-- **`__DATA_CONST`**: \_\_DATA.\_\_const sabit olacağı garanti edilmez (yazma izinleri), diğer işaretçiler ve GOT da öyle. Bu bölüm, `__const`, bazı başlatıcılar ve GOT tablosunu (bir kez çözüldüğünde) **sadece okunabilir** hale getirir.
-- **`__LINKEDIT`**: Bağlayıcı (dyld) için sembol, string ve yer değiştirme tablosu girişleri gibi bilgileri içerir. `__TEXT` veya `__DATA` içinde olmayan içerikler için genel bir konteynırdır ve içeriği diğer yükleme komutlarında tanımlanır.
-- dyld bilgisi: Yeniden temel alma, Tembel/tembel olmayan/zayıf bağlama opcode'ları ve dışa aktarma bilgisi
+- `__const`: Sabit veriler (yalnızca okunur)
+- `__[c/u/os_log]string`: C, Unicode veya os log dize sabitleri
+- `__stubs` and `__stubs_helper`: Dinamik kütüphane yükleme sürecinde rol alır
+- `__unwind_info`: Yığın unwind verisi
+- Not: Tüm bu içerikler imzalanmıştır ancak aynı zamanda yürütülebilir olarak işaretlenmiştir (bu, string gibi özel bölümlerin de gerekmese bile bu ayrıcalığa sahip olması durumunda sömürü için daha fazla seçenek yaratır).
+- **`__DATA`**: **okunabilir** ve **yazılabilir** (yürütülemez) verileri içerir.
+- `__got:` Global Offset Tablosu
+- `__nl_symbol_ptr`: Non-lazy (yüklemede bağlanır) sembol işaretçisi
+- `__la_symbol_ptr`: Lazy (kullanımda bağlanır) sembol işaretçisi
+- `__const`: Okunur-yalnız veri olması gerekir (aslında çoğunlukla öyle değildir)
+- `__cfstring`: CoreFoundation dizeleri
+- `__data`: Başlatılmış global değişkenler
+- `__bss`: Başlatılmamış statik değişkenler
+- `__objc_*` (\_\_objc_classlist, \_\_objc_protolist, etc): Objective-C runtime tarafından kullanılan bilgiler
+- **`__DATA_CONST`**: \_\_DATA.\_\_const'ın gerçekten sabit olduğu garanti edilmez (yazma izinleri olabilir), diğer pointerlar ve GOT da aynı şekilde. Bu bölüm, `mprotect` kullanarak `__const`, bazı initializers ve GOT tablosunu (çözüldükten sonra) **salt okunur** yapar.
+- **`__LINKEDIT`**: Linker (dyld) için sembol, dize ve relocation tablo girdileri gibi bilgileri içerir. `__TEXT` veya `__DATA` içinde olmayan içerikler için genel bir kapsayıcıdır ve içeriği diğer load command'ler ile tanımlanır.
+- dyld bilgisi: Rebase, Non-lazy/lazy/weak binding opcode'ları ve export bilgisi
 - Fonksiyon başlangıçları: Fonksiyonların başlangıç adresleri tablosu
-- Kod İçindeki Veri: \_\_text içindeki veri adaları
-- Sembol Tablosu: İkili içindeki semboller
-- Dolaylı Sembol Tablosu: İşaretçi/stub sembolleri
-- String Tablosu
+- Data In Code: `__text` içindeki veri adacıkları
+- Sembol Tablosu: Binary içindeki semboller
+- Dolaylı Sembol Tablosu: Pointer/stub sembolleri
+- Dize Tablosu
 - Kod İmzası
-- **`__OBJC`**: Objective-C çalışma zamanı tarafından kullanılan bilgileri içerir. Bu bilgilere \_\_DATA segmentinde, \_\_objc\_\* bölümleri içinde de rastlanabilir.
-- **`__RESTRICT`**: İçeriği olmayan ve **`__restrict`** adında tek bir bölümü olan bir segment (aynı zamanda boş) olup, ikilinin çalıştırılması sırasında DYLD çevresel değişkenlerini göz ardı edeceğini garanti eder.
+- **`__OBJC`**: Objective-C runtime tarafından kullanılan bilgileri içerir. Bu bilgiler bazen \_\_DATA segmenti içindeki çeşitli \_\_objc\_\* bölümlerinde de bulunabilir.
+- **`__RESTRICT`**: İçeriği olmayan ve tek bir bölüm olan **`__restrict`** (o da boş) adlı bir segmenttir; bu, binary çalıştırılırken DYLD çevresel değişkenlerinin göz ardı edilmesini sağlar.
 
-Kodda görüldüğü gibi, **segmentler ayrıca bayrakları destekler** (her ne kadar çok kullanılmasa da):
+As it was possible to see in the code, **segments also support flags** (although they aren't used very much):
 
-- `SG_HIGHVM`: Sadece çekirdek (kullanılmıyor)
-- `SG_FVMLIB`: Kullanılmıyor
-- `SG_NORELOC`: Segmentin yer değiştirmesi yok
-- `SG_PROTECTED_VERSION_1`: Şifreleme. Örneğin, Finder tarafından `__TEXT` segmentini şifrelemek için kullanılır.
+- `SG_HIGHVM`: Core only (not used)
+- `SG_FVMLIB`: Not used
+- `SG_NORELOC`: Segment has no relocation
+- `SG_PROTECTED_VERSION_1`: Encryption. Used for example by Finder to encrypt text `__TEXT` segment.
 
 ### **`LC_UNIXTHREAD/LC_MAIN`**
 
-**`LC_MAIN`** **entryoff** niteliğinde giriş noktasını içerir. Yükleme sırasında, **dyld** bu değeri (bellekteki) **ikili tabanına** **ekler**, ardından **bu talimata atlar** ve ikilinin kodunun yürütülmesine başlar.
+**`LC_MAIN`** giriş noktasını **entryoff özniteliğinde** içerir. Yükleme sırasında **dyld** bu değeri (bellekteki) ikili dosyanın temel adresine ekler, sonra yürütmeyi başlatmak için bu yönergeye **atlar**.
 
-**`LC_UNIXTHREAD`** ana iş parçacığı başlatıldığında kayıtların sahip olması gereken değerleri içerir. Bu zaten kullanımdan kaldırılmıştır ancak **`dyld`** hala bunu kullanır. Bu kayıtların ayarlandığı değerleri görmek mümkündür:
+**`LC_UNIXTHREAD`** ana thread başlatılırken registerların sahip olması gereken değerleri içerir. Bu zaten deprecated olsa da **`dyld`** hâlâ bunu kullanır. Bununla ayarlanan register değerlerini şu şekilde görmek mümkündür:
 ```bash
 otool -l /usr/lib/dyld
 [...]
@@ -286,34 +286,39 @@ cpsr 0x00000000
 ```
 ### **`LC_CODE_SIGNATURE`**
 
-Mach-O dosyasının **kod imzası** hakkında bilgi içerir. Sadece **imza blob'una** **işaret eden** bir **offset** içerir. Bu genellikle dosyanın en sonunda bulunur.\
-Ancak, bu bölüm hakkında bazı bilgileri [**bu blog yazısında**](https://davedelong.com/blog/2018/01/10/reading-your-own-entitlements/) ve bu [**gists**](https://gist.github.com/carlospolop/ef26f8eb9fafd4bc22e69e1a32b81da4) bulabilirsiniz.
+{{#ref}}
+../../../generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/mach-o-entitlements-and-ipsw-indexing.md
+{{#endref}}
+
+
+Macho-O dosyasının **kod imzası** hakkında bilgi içerir. Sadece **imza blob'una işaret eden bir offset** içerir. Bu genellikle dosyanın tam sonunda yer alır.\
+Bununla ilgili bazı bilgileri [**this blog post**](https://davedelong.com/blog/2018/01/10/reading-your-own-entitlements/) ve bu [**gists**](https://gist.github.com/carlospolop/ef26f8eb9fafd4bc22e69e1a32b81da4) üzerinde bulabilirsiniz.
 
 ### **`LC_ENCRYPTION_INFO[_64]`**
 
-İkili şifreleme desteği. Ancak, elbette, bir saldırgan süreci tehlikeye atmayı başarırsa, şifrelenmemiş belleği dökebilecektir.
+Binary şifreleme desteği. Ancak elbette, bir saldırgan süreci ele geçirirse, belleği şifresiz şekilde dump edebilecektir.
 
 ### **`LC_LOAD_DYLINKER`**
 
-Paylaşılan kütüphaneleri süreç adres alanına haritalayan **dinamik bağlayıcı yürütülebilir dosyasının yolunu** içerir. **Değer her zaman `/usr/lib/dyld` olarak ayarlanır**. macOS'ta, dylib haritalamanın **kullanıcı modunda**, çekirdek modunda değil olduğunu belirtmek önemlidir.
+Paylaşılan kütüphaneleri işlem adres alanına eşleyen dynamic linker executable'ın **yolunu içerir**. **Değer her zaman `/usr/lib/dyld` olarak ayarlanır**. macOS'ta dylib eşlemenin **kernel modunda değil, kullanıcı modunda** gerçekleştiğini not etmek önemlidir.
 
 ### **`LC_IDENT`**
 
-Eski ama panik durumunda dökümler oluşturacak şekilde yapılandırıldığında, bir Mach-O çekirdek dökümü oluşturulur ve çekirdek sürümü `LC_IDENT` komutunda ayarlanır.
+Artık modası geçmiştir, ancak panic durumunda dump oluşturacak şekilde yapılandırıldığında bir Mach-O core dump oluşturulur ve kernel sürümü `LC_IDENT` komutunda ayarlanır.
 
 ### **`LC_UUID`**
 
-Rastgele UUID. Doğrudan herhangi bir şey için faydalıdır ama XNU bunu süreç bilgileriyle birlikte önbelleğe alır. Çökme raporlarında kullanılabilir.
+Rastgele UUID. Doğrudan her şey için kullanışlı olmasa da XNU bunu işlem bilgileriyle birlikte önbelleğe alır. Crash raporlarında kullanılabilir.
 
 ### **`LC_DYLD_ENVIRONMENT`**
 
-Süreç çalıştırılmadan önce dyld'ye ortam değişkenlerini belirtmeye olanak tanır. Bu, süreç içinde rastgele kod çalıştırılmasına izin verebileceğinden oldukça tehlikeli olabilir, bu nedenle bu yükleme komutu yalnızca `#define SUPPORT_LC_DYLD_ENVIRONMENT` ile derlenmiş dyld'de kullanılır ve işleme yalnızca `DYLD_..._PATH` biçimindeki değişkenlerle sınırlıdır.
+Süreç çalıştırılmadan önce dyld'e ortam değişkenlerini belirtme imkanı sağlar. Bu oldukça tehlikeli olabilir çünkü süreç içinde rastgele kod çalıştırılmasına izin verebilir; bu yüzden bu load command sadece `#define SUPPORT_LC_DYLD_ENVIRONMENT` ile derlenmiş dyld yapılarında kullanılır ve işleme yalnızca `DYLD_..._PATH` biçimindeki yükleme yollarını belirten değişkenlerle sınırlandırılır.
 
 ### **`LC_LOAD_DYLIB`**
 
-Bu yükleme komutu, **yükleyiciye** (dyld) **söz konusu kütüphaneyi yüklemesi ve bağlaması** talimatını veren bir **dinamik** **kütüphane** bağımlılığını tanımlar. Mach-O ikilisinin ihtiyaç duyduğu **her kütüphane için bir `LC_LOAD_DYLIB` yükleme komutu vardır**.
+Bu load command, loader'ı (dyld) söz konusu kütüphaneyi **yüklemeye ve linklemeye** yönlendiren **dinamik kütüphane** bağımlılığını tanımlar. Mach-O binary'nin gerektirdiği **her kütüphane için bir `LC_LOAD_DYLIB` load command** vardır.
 
-- Bu yükleme komutu, gerçek bağımlı dinamik kütüphaneyi tanımlayan bir struct dylib içeren **`dylib_command`** türünde bir yapıdır:
+- Bu load command, içinde gerçek bağımlı dynamic library'yi tanımlayan bir struct dylib içeren **`dylib_command`** tipinde bir yapıdır:
 ```objectivec
 struct dylib_command {
 uint32_t        cmd;            /* LC_LOAD_{,WEAK_}DYLIB */
@@ -330,7 +335,7 @@ uint32_t compatibility_version;     /* library's compatibility vers number*/
 ```
 ![](<../../../images/image (486).png>)
 
-Bu bilgiyi cli ile de alabilirsiniz:
+Bu bilgiyi ayrıca cli ile şu şekilde alabilirsiniz:
 ```bash
 otool -L /bin/ls
 /bin/ls:
@@ -338,54 +343,54 @@ otool -L /bin/ls
 /usr/lib/libncurses.5.4.dylib (compatibility version 5.4.0, current version 5.4.0)
 /usr/lib/libSystem.B.dylib (compatibility version 1.0.0, current version 1319.0.0)
 ```
-Bazı potansiyel kötü amaçlı yazılım ile ilgili kütüphaneler şunlardır:
+Some potential malware related libraries are:
 
-- **DiskArbitration**: USB sürücüleri izleme
+- **DiskArbitration**: USB sürücülerini izleme
 - **AVFoundation:** Ses ve video yakalama
 - **CoreWLAN**: Wifi taramaları.
 
-> [!NOTE]
-> Bir Mach-O ikili dosyası, **LC_MAIN**'de belirtilen adresten **önce** **çalıştırılacak** bir veya **daha fazla** **constructor** içerebilir.\
-> Herhangi bir constructor'ın ofsetleri, **\_\_DATA_CONST** segmentinin **\_\_mod_init_func** bölümünde tutulur.
+> [!TIP]
+> Bir Mach-O ikili dosyası bir veya **daha fazla** **constructor** içerebilir; bunlar **LC_MAIN** ile belirtilen adresten **önce** **çalıştırılacaktır**.\
+> Herhangi bir constructor'ın offsetleri **\_\_DATA_CONST** segmentinin **\_\_mod_init_func** bölümünde tutulur.
 
 ## **Mach-O Verisi**
 
-Dosyanın merkezinde, yükleme komutları bölgesinde tanımlanan birkaç segmentten oluşan veri bölgesi yer alır. **Her segment içinde çeşitli veri bölümleri barındırabilir**, her bölüm **bir türle ilgili kod veya veriyi** tutar.
+Dosyanın merkezinde, load-commands bölgesinde tanımlanan birkaç segmentten oluşan veri bölgesi bulunur. **Her segment içinde çeşitli veri bölümleri bulunabilir**, her bölüm türüne özgü **kod veya veri** barındırır.
 
 > [!TIP]
-> Veri, esasen yükleme komutları **LC_SEGMENTS_64** tarafından yüklenen tüm **bilgileri** içeren kısımdır.
+> Veri, temelde load commands **LC_SEGMENTS_64** tarafından yüklenen tüm **bilgileri** içeren kısımdır.
 
 ![https://www.oreilly.com/api/v2/epubs/9781785883378/files/graphics/B05055_02_38.jpg](<../../../images/image (507) (3).png>)
 
-Bu şunları içerir:
+This includes:
 
-- **Fonksiyon tablosu:** Program fonksiyonları hakkında bilgi tutar.
-- **Sembol tablosu**: İkili dosya tarafından kullanılan dış fonksiyonlar hakkında bilgi içerir.
-- Ayrıca iç fonksiyon, değişken adları ve daha fazlasını da içerebilir.
+- **Function table:** Program fonksiyonları hakkında bilgi tutar.
+- **Symbol table**: Binary tarafından kullanılan dış fonksiyonlar hakkında bilgi içerir.
+- Ayrıca dahili fonksiyon ve değişken adlarını ve daha fazlasını da içerebilir.
 
-Bunu kontrol etmek için [**Mach-O View**](https://sourceforge.net/projects/machoview/) aracını kullanabilirsiniz:
+To check it you could use the [**Mach-O View**](https://sourceforge.net/projects/machoview/) tool:
 
 <figure><img src="../../../images/image (1120).png" alt=""><figcaption></figcaption></figure>
 
-Ya da cli'dan:
+Veya cli üzerinden:
 ```bash
 size -m /bin/ls
 ```
-## Objetive-C Ortak Bölümler
+## Objetive-C Genel Bölümler
 
-In `__TEXT` segment (r-x):
+`__TEXT` segmentinde (r-x):
 
-- `__objc_classname`: Sınıf adları (dizeler)
-- `__objc_methname`: Metot adları (dizeler)
-- `__objc_methtype`: Metot türleri (dizeler)
+- `__objc_classname`: Sınıf isimleri (stringler)
+- `__objc_methname`: Metod isimleri (stringler)
+- `__objc_methtype`: Metod tipleri (stringler)
 
-In `__DATA` segment (rw-):
+`__DATA` segmentinde (rw-):
 
 - `__objc_classlist`: Tüm Objetive-C sınıflarına işaretçiler
-- `__objc_nlclslist`: Tembel Olmayan Objective-C sınıflarına işaretçiler
+- `__objc_nlclslist`: Non-Lazy Objective-C sınıflarına işaretçiler
 - `__objc_catlist`: Kategorilere işaretçi
-- `__objc_nlcatlist`: Tembel Olmayan Kategorilere işaretçi
-- `__objc_protolist`: Protokol listesi
+- `__objc_nlcatlist`: Non-Lazy Kategorilere işaretçi
+- `__objc_protolist`: Protokoller listesi
 - `__objc_const`: Sabit veri
 - `__objc_imageinfo`, `__objc_selrefs`, `objc__protorefs`...
 
diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-code-signing.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-code-signing.md
index e6e789a56..4ed645beb 100644
--- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-code-signing.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-code-signing.md
@@ -4,12 +4,17 @@
 
 ## Temel Bilgiler
 
-Mach-o ikili dosyaları, ikili dosya içindeki imzaların **offset** ve **boyutunu** belirten **`LC_CODE_SIGNATURE`** adlı bir yükleme komutu içerir. Aslında, GUI aracı MachOView kullanarak, ikili dosyanın sonunda bu bilgileri içeren **Kod İmzası** adlı bir bölüm bulmak mümkündür:
+{{#ref}}
+../../../generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/mach-o-entitlements-and-ipsw-indexing.md
+{{#endref}}
+
+
+Mach-o ikili dosyaları, ikili içindeki imzaların **offset** ve **size** bilgisini gösteren **`LC_CODE_SIGNATURE`** adlı bir load command içerir. Aslında, GUI aracı MachOView kullanılarak ikilinin sonunda bu bilgileri içeren **Code Signature** adlı bir bölüm bulmak mümkündür:
 
 <figure><img src="../../../images/image (1) (1) (1) (1).png" alt="" width="431"><figcaption></figcaption></figure>
 
-Kod İmzasının sihirli başlığı **`0xFADE0CC0`**'dır. Ardından, bunları içeren süperBlob'un uzunluğu ve blob sayısı gibi bilgiler vardır.\
-Bu bilgiyi [kaynak kodda burada](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/osfmk/kern/cs_blobs.h#L276) bulmak mümkündür:
+**Code Signature**'ın magic header'ı **`0xFADE0CC0`**'dir. Sonrasında bunları içeren superBlob'un length ve blob sayısı gibi bilgiler yer alır.\
+Bu bilgiyi [source code here](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/osfmk/kern/cs_blobs.h#L276) içinde bulmak mümkündür:
 ```c
 /*
 * Structure of an embedded-signature SuperBlob
@@ -38,14 +43,14 @@ char data[];
 } CS_GenericBlob
 __attribute__ ((aligned(1)));
 ```
-Yaygın olarak bulunan blob'lar, Kod Dizini, Gereksinimler ve Yetkiler ile Kriptografik Mesaj Sözleşmesi (CMS) içerir.\
-Ayrıca, blob'larda kodlanan verilerin **Big Endian** formatında kodlandığını not edin.
+Common blobs contained are Code Directory, Requirements and Entitlements and a Cryptographic Message Syntax (CMS).\
+Ayrıca, blobs içinde kodlanmış verilerin **Big Endian** ile kodlandığına dikkat edin.
 
-Ayrıca, imzaların ikili dosyalardan ayrılabileceği ve `/var/db/DetachedSignatures` dizininde saklanabileceği (iOS tarafından kullanılır) unutulmamalıdır.
+Ayrıca, imzalar ikili dosyalardan ayrılabilir ve `/var/db/DetachedSignatures` içinde saklanabilir (iOS tarafından kullanılır).
 
-## Kod Dizini Blob
+## Code Directory Blob
 
-[Kod Dizini Blob'unun kod içindeki beyanını](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/osfmk/kern/cs_blobs.h#L104) bulmak mümkündür:
+Koddaki [Code Directory Blob in the code](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/osfmk/kern/cs_blobs.h#L104):
 ```c
 typedef struct __CodeDirectory {
 uint32_t magic;                                 /* magic number (CSMAGIC_CODEDIRECTORY) */
@@ -101,12 +106,11 @@ char end_withLinkage[0];
 } CS_CodeDirectory
 __attribute__ ((aligned(1)));
 ```
-Not edin ki, bu yapının farklı versiyonları vardır ve eski olanlar daha az bilgi içerebilir.
+Bu struct'ın farklı sürümleri olduğunu unutmayın; eski sürümler daha az bilgi içerebilir.
 
-## Kod İmzalama Sayfaları
+## Kod Sayfalarının İmzalanması
 
-Tam ikili dosyanın hash'lenmesi verimsiz ve hatta yararsız olurdu, çünkü bu yalnızca bellekte kısmen yüklendiğinde geçerlidir. Bu nedenle, kod imzası aslında her ikili sayfanın ayrı ayrı hash'lenmesiyle oluşturulan bir hash'ler hash'idir.\
-Aslında, önceki **Kod Dizini** kodunda **sayfa boyutunun belirtildiğini** görebilirsiniz. Ayrıca, ikilinin boyutu bir sayfa boyutunun katı değilse, **CodeLimit** alanı imzanın sonunun nerede olduğunu belirtir.
+Tam ikilinin tamamının hash'lenmesi, yalnızca kısmen belleğe yüklendiğinde verimsiz hatta işe yaramaz olur. Bu nedenle, kod imzası aslında her bir ikili sayfasının ayrı ayrı hash'lendiği hash'lerin bir hash'idir.\ Aslında, önceki **Code Directory** kodunda **sayfa boyutunun alanlardan birinde belirtildiğini** görebilirsiniz. Ayrıca, ikilinin boyutu bir sayfa boyutunun tam katı değilse, **CodeLimit** alanı imzanın nerede sona erdiğini belirtir.
 ```bash
 # Get all hashes of /bin/ps
 codesign -d -vvvvvv /bin/ps
@@ -142,27 +146,27 @@ dd if=$BINARY of=/tmp/`basename $BINARY`.page.$i bs=$PAGESIZE skip=$i count=1
 done
 openssl sha256 /tmp/*.page.*
 ```
-## Yetki Blob'u
+## Entitlements Blob
 
-Uygulamaların tüm yetkilerin tanımlandığı bir **yetki blob'u** içerebileceğini unutmayın. Ayrıca, bazı iOS ikili dosyaları, yetkilerini özel slot -7'de (özel slot -5 yerine) belirtebilir.
+Uygulamaların, tüm yetkilendirmelerin tanımlandığı bir **entitlement blob** içerebileceğini unutmayın. Ayrıca, bazı iOS ikili dosyalarının yetkilendirmeleri özel slot -5 yerine özel slot -7'de yer alabilir.
 
-## Özel Slotlar
+## Special Slots
 
-MacOS uygulamaları, çalıştırmak için ihtiyaç duydukları her şeyi ikili dosya içinde bulundurmazlar, aynı zamanda **harici kaynaklar** (genellikle uygulamaların **paketinde**) kullanırlar. Bu nedenle, ikili dosya içinde bazı ilginç harici kaynakların hash'lerini içeren slotlar bulunmaktadır.
+MacOS uygulamaları yürütmek için ihtiyaç duydukları her şeyi yalnızca ikili dosya içinde barındırmaz; genellikle uygulamanın **bundle**'ı içinde bulunan **dış kaynakları** da kullanırlar. Bu nedenle, ikili dosya içinde bazı ilgi çekici dış kaynakların değiştirilmediğini doğrulamak için onların hash'lerini içeren bazı özel slotlar bulunur.
 
-Aslında, Kod Dizini yapılarında **`nSpecialSlots`** adında özel slot sayısını belirten bir parametre görmek mümkündür. Özel slot 0 yoktur ve en yaygın olanları (-1'den -6'ya kadar) şunlardır:
+Aslında, Code Directory struct'larında özel slot sayısını gösteren **`nSpecialSlots`** adlı bir parametre görülebilir. 0 numaralı özel bir slot yoktur ve en yaygın olanlar (−1 ile −6 arası) şunlardır:
 
-- `info.plist`'in hash'i (veya `__TEXT.__info__plist` içindeki).
-- Gereksinimlerin hash'i
-- Kaynak Dizini'nin hash'i (paket içindeki `_CodeSignature/CodeResources` dosyasının hash'i).
-- Uygulamaya özgü (kullanılmayan)
-- Yetkilerin hash'i
-- Sadece DMG kod imzaları
-- DER Yetkileri
+- `info.plist` (veya `__TEXT.__info__plist` içindekinin) hash'i.
+- Requirements'in hash'i
+- Resource Directory'nin hash'i (`_CodeSignature/CodeResources` dosyasının bundle içindeki hash'i).
+- Uygulamaya özel (kullanılmıyor)
+- Entitlements'in hash'i
+- Sadece DMG code signatures
+- DER Entitlements
 
-## Kod İmzalama Bayrakları
+## Code Signing Flags
 
-Her süreç, çekirdek tarafından başlatılan ve bazıları **kod imzası** ile geçersiz kılınabilen `status` adı verilen bir bitmask ile ilişkilidir. Kod imzalamada dahil edilebilecek bu bayraklar [kodda tanımlanmıştır](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/osfmk/kern/cs_blobs.h#L36):
+Her sürecin kernel tarafından başlatılan ve `status` olarak bilinen ilişkili bir bitmaskesi vardır ve bunların bazıları **code signature** tarafından geçersiz kılınabilir. Code signing içine dahil edilebilen bu bayraklar [kodda tanımlanmıştır](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/osfmk/kern/cs_blobs.h#L36):
 ```c
 /* code signing attributes of a process */
 #define CS_VALID                    0x00000001  /* dynamically valid */
@@ -207,15 +211,15 @@ CS_RESTRICT | CS_ENFORCEMENT | CS_REQUIRE_LV | CS_RUNTIME | CS_LINKER_SIGNED)
 
 #define CS_ENTITLEMENT_FLAGS        (CS_GET_TASK_ALLOW | CS_INSTALLER | CS_DATAVAULT_CONTROLLER | CS_NVRAM_UNRESTRICTED)
 ```
-Not edin ki [**exec_mach_imgact**](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/bsd/kern/kern_exec.c#L1420) fonksiyonu, yürütmeye başlarken `CS_EXEC_*` bayraklarını dinamik olarak ekleyebilir.
+Note that the function [**exec_mach_imgact**](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/bsd/kern/kern_exec.c#L1420) can also add the `CS_EXEC_*` flags dynamically when starting the execution.
 
 ## Kod İmzası Gereksinimleri
 
-Her uygulama, yürütülebilmesi için **karşılaması gereken** bazı **gereksinimler** saklar. Eğer **uygulama, uygulama tarafından karşılanmayan gereksinimler içeriyorsa**, yürütülmeyecektir (muhtemelen değiştirilmiştir).
+Her uygulama, yürütülebilmek için **karşılaması gereken** bazı **gereksinimleri** saklar. Eğer uygulamanın içerdiği **gereksinimler** karşılanmıyorsa, uygulama çalıştırılmaz (muhtemelen değiştirilmiş olduğu için).
 
-Bir ikili dosyanın gereksinimleri, **özel bir dilbilgisi** kullanır; bu, **ifadelerin** bir akışıdır ve `0xfade0c00` sihirli değeri kullanılarak bloblar olarak kodlanır; **hash'i özel bir kod slotunda** saklanır.
+Bir ikili dosyanın gereksinimleri, bir akış halinde **ifadeler** olan bir **özel dilbilgisi** kullanır ve `0xfade0c00` sihirli değeri olarak kullanılarak blob'lar halinde kodlanır; bunların **hash'i özel bir code slot'ta saklanır**.
 
-Bir ikili dosyanın gereksinimleri, çalıştırılarak görülebilir:
+Bir ikili dosyanın gereksinimleri çalışırken şöyle görülebilir:
 ```bash
 codesign -d -r- /bin/ls
 Executable=/bin/ls
@@ -225,10 +229,10 @@ codesign -d -r- /Applications/Signal.app/
 Executable=/Applications/Signal.app/Contents/MacOS/Signal
 designated => identifier "org.whispersystems.signal-desktop" and anchor apple generic and certificate 1[field.1.2.840.113635.100.6.2.6] /* exists */ and certificate leaf[field.1.2.840.113635.100.6.1.13] /* exists */ and certificate leaf[subject.OU] = U68MSDN6DR
 ```
-> [!NOTE]
-> Bu imzaların sertifika bilgileri, TeamID, kimlikler, haklar ve birçok diğer verileri kontrol edebileceğini unutmayın.
+> [!TIP]
+> Bu imzaların sertifika bilgileri, TeamID, IDs, entitlements ve birçok başka veriyi nasıl kontrol edebildiğine dikkat edin.
 
-Ayrıca, `csreq` aracı kullanarak bazı derlenmiş gereksinimler oluşturmak mümkündür:
+Ayrıca, `csreq` aracı kullanılarak bazı derlenmiş gereksinimler oluşturmak mümkündür:
 ```bash
 # Generate compiled requirements
 csreq -b /tmp/output.csreq -r='identifier "org.whispersystems.signal-desktop" and anchor apple generic and certificate 1[field.1.2.840.113635.100.6.2.6] /* exists */ and certificate leaf[field.1.2.840.113635.100.6.1.13] /* exists */ and certificate leaf[subject.OU] = U68MSDN6DR'
@@ -240,55 +244,57 @@ od -A x -t x1 /tmp/output.csreq
 0000020    00  00  00  21  6f  72  67  2e  77  68  69  73  70  65  72  73
 [...]
 ```
+It's possible to access this information and create or modify requirements with some APIs from the `Security.framework` like:
+
 #### **Geçerliliği Kontrol Etme**
 
-- **`Sec[Static]CodeCheckValidity`**: SecCodeRef'in Geçerliliğini Gereksinime göre kontrol et.
-- **`SecRequirementEvaluate`**: Sertifika bağlamında gereksinimi doğrula.
-- **`SecTaskValidateForRequirement`**: Çalışan bir SecTask'ı `CFString` gereksinimine karşı doğrula.
+- **`Sec[Static]CodeCheckValidity`**: Requirement'e göre SecCodeRef'in geçerliliğini kontrol eder.
+- **`SecRequirementEvaluate`**: Sertifika bağlamında gereksinimi doğrular.
+- **`SecTaskValidateForRequirement`**: Çalışan bir SecTask'ı `CFString` gereksinimine karşı doğrular.
 
 #### **Kod Gereksinimlerini Oluşturma ve Yönetme**
 
 - **`SecRequirementCreateWithData`:** Gereksinimi temsil eden ikili veriden bir `SecRequirementRef` oluşturur.
 - **`SecRequirementCreateWithString`:** Gereksinimin string ifadesinden bir `SecRequirementRef` oluşturur.
 - **`SecRequirementCopy[Data/String]`**: Bir `SecRequirementRef`'in ikili veri temsilini alır.
-- **`SecRequirementCreateGroup`**: Uygulama grubu üyeliği için bir gereksinim oluştur.
+- **`SecRequirementCreateGroup`**: app-group üyeliği için bir gereksinim oluşturur.
 
-#### **Kod İmzalama Bilgilerine Erişim**
+#### **Code Signing Bilgilerine Erişim**
 
-- **`SecStaticCodeCreateWithPath`**: Kod imzalarını incelemek için bir dosya sistemi yolundan `SecStaticCodeRef` nesnesini başlatır.
-- **`SecCodeCopySigningInformation`**: Bir `SecCodeRef` veya `SecStaticCodeRef`'den imzalama bilgilerini alır.
+- **`SecStaticCodeCreateWithPath`**: Kod imzalarını incelemek için dosya sistemi yolundan bir `SecStaticCodeRef` nesnesi başlatır.
+- **`SecCodeCopySigningInformation`**: Bir `SecCodeRef` veya `SecStaticCodeRef`'ten imzalama bilgilerini elde eder.
 
 #### **Kod Gereksinimlerini Değiştirme**
 
-- **`SecCodeSignerCreate`**: Kod imzalama işlemleri gerçekleştirmek için bir `SecCodeSignerRef` nesnesi oluşturur.
-- **`SecCodeSignerSetRequirement`**: İmzalama sırasında uygulanacak yeni bir gereksinim belirler.
-- **`SecCodeSignerAddSignature`**: Belirtilen imzalayıcı ile imzalanan koda bir imza ekler.
+- **`SecCodeSignerCreate`**: Kod imzalama işlemleri yapmak için bir `SecCodeSignerRef` nesnesi oluşturur.
+- **`SecCodeSignerSetRequirement`**: İmzalama sırasında uygulanacak yeni bir gereksinimi code signer için ayarlar.
+- **`SecCodeSignerAddSignature`**: Belirtilen signer ile imzalanan koda bir imza ekler.
 
 #### **Gereksinimlerle Kodu Doğrulama**
 
-- **`SecStaticCodeCheckValidity`**: Belirtilen gereksinimlere karşı bir statik kod nesnesini doğrular.
+- **`SecStaticCodeCheckValidity`**: Belirtilen gereksinimlere karşı statik bir kod nesnesini doğrular.
 
-#### **Ekstra Kullanışlı API'ler**
+#### **Ek Yararlı API'ler**
 
-- **`SecCodeCopy[Internal/Designated]Requirement`: SecCodeRef'den SecRequirementRef al**
-- **`SecCodeCopyGuestWithAttributes`**: Belirli özelliklere dayanan bir kod nesnesini temsil eden bir `SecCodeRef` oluşturur, sandboxing için kullanışlıdır.
+- **`SecCodeCopy[Internal/Designated]Requirement`: Get SecRequirementRef from SecCodeRef**
+- **`SecCodeCopyGuestWithAttributes`**: Sandbox için yararlı olan, belirli özniteliklere dayalı bir kod nesnesini temsil eden bir `SecCodeRef` oluşturur.
 - **`SecCodeCopyPath`**: Bir `SecCodeRef` ile ilişkili dosya sistemi yolunu alır.
-- **`SecCodeCopySigningIdentifier`**: Bir `SecCodeRef`'den imzalama tanımlayıcısını (örneğin, Takım ID'si) alır.
-- **`SecCodeGetTypeID`**: `SecCodeRef` nesneleri için tür tanımlayıcısını döndürür.
+- **`SecCodeCopySigningIdentifier`**: Bir `SecCodeRef`'ten imzalama tanımlayıcısını (ör. Team ID) alır.
+- **`SecCodeGetTypeID`**: `SecCodeRef` nesneleri için type identifier döndürür.
 - **`SecRequirementGetTypeID`**: Bir `SecRequirementRef`'in CFTypeID'sini alır.
 
-#### **Kod İmzalama Bayrakları ve Sabitleri**
+#### **Code Signing Bayrakları ve Sabitleri**
 
-- **`kSecCSDefaultFlags`**: Kod imzalama işlemleri için birçok Security.framework fonksiyonunda kullanılan varsayılan bayraklar.
-- **`kSecCSSigningInformation`**: İmzalama bilgilerinin alınması gerektiğini belirtmek için kullanılan bayrak.
+- **`kSecCSDefaultFlags`**: Code signing işlemleri için birçok Security.framework fonksiyonunda kullanılan varsayılan bayraklar.
+- **`kSecCSSigningInformation`**: İmzalama bilgisi alınması gerektiğini belirtmek için kullanılan bayrak.
 
-## Kod İmzası Uygulaması
+## Code Signature Enforcement
 
-**Kernel**, uygulamanın kodunun çalışmasına izin vermeden önce **kod imzasını kontrol eder**. Ayrıca, bellekte yeni kod yazmak ve çalıştırmak için bir yol, `mprotect` çağrıldığında `MAP_JIT` bayrağının kötüye kullanılmasıdır. Uygulamanın bunu yapabilmesi için özel bir yetkiye ihtiyacı olduğunu unutmayın.
+Kernel, uygulamanın kodunun çalışmasına izin vermeden önce code signature'ı kontrol eden bileşendir. Ayrıca, belleğe yeni kod yazıp çalıştırabilmenin bir yolu, `mprotect` `MAP_JIT` bayrağı ile çağrıldığında JIT'i kötüye kullanmaktır. Uygulamanın bunu yapabilmesi için özel bir entitlement'a sahip olması gerektiğini unutmayın.
 
 ## `cs_blobs` & `cs_blob`
 
-[**cs_blob**](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/bsd/sys/ubc_internal.h#L106) yapısı, çalışan sürecin üzerindeki yetki hakkında bilgi içerir. `csb_platform_binary` ayrıca uygulamanın bir platform ikili olup olmadığını bildirir (bu, OS tarafından güvenlik mekanizmalarını uygulamak için farklı zamanlarda kontrol edilir, örneğin bu süreçlerin görev portlarına SEND haklarını korumak için).
+[**cs_blob**](https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/bsd/sys/ubc_internal.h#L106) struct, üzerinde çalışan sürecin entitlement bilgilerini içerir. `csb_platform_binary` ayrıca uygulamanın platform binary olup olmadığını bildirir (OS tarafından bu süreçlerin task ports'larına olan SEND haklarını korumak gibi güvenlik mekanizmalarını uygulamak için farklı zamanlarda kontrol edilir).
 ```c
 struct cs_blob {
 struct cs_blob  *csb_next;
@@ -347,8 +353,8 @@ bool csb_csm_managed;
 #endif
 };
 ```
-## Referanslar
+## Kaynaklar
 
-- [**\*OS İç Yapıları Cilt III**](https://newosxbook.com/home.html)
+- [**\*OS Internals Volume III**](https://newosxbook.com/home.html)
 
 {{#include ../../../banners/hacktricks-training.md}}