mirror of
https://github.com/carlospolop/hacktricks
synced 2024-11-26 14:40:37 +00:00
Translated ['binary-exploitation/heap/bins-and-memory-allocations.md', '
This commit is contained in:
Translator
parent
74710dd109
commit
8a4273a269
4 changed files with 620 additions and 182 deletions
|
|
@ -1,4 +1,4 @@
|
|||
# Bins & Ugawaji wa Kumbukumbu
|
||||
# Bins & Vitengenezaji wa Kumbukumbu
|
||||
|
||||
<details>
|
||||
|
||||
|
|
@ -7,186 +7,598 @@
|
|||
Njia nyingine za kusaidia HackTricks:
|
||||
|
||||
* Ikiwa unataka kuona **kampuni yako ikitangazwa kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA USAJILI**](https://github.com/sponsors/carlospolop)!
|
||||
* Pata [**swag rasmi wa PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa kipekee wa [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) ya kipekee
|
||||
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Shiriki mbinu zako za udukuzi kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
|
||||
* **Shiriki mbinu zako za udukuzi kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos za github.
|
||||
|
||||
</details>
|
||||
|
||||
## Taarifa Msingi
|
||||
|
||||
Ili kuboresha ufanisi wa jinsi vipande vinavyohifadhiwa, kila kipande sio tu kwenye orodha moja iliyounganishwa, bali kuna aina kadhaa. Hizi ni bakuli na kuna aina 5 za bakuli: [62](https://sourceware.org/git/gitweb.cgi?p=glibc.git;a=blob;f=malloc/malloc.c;h=6e766d11bc85b6480fa5c9f2a76559f8acf9deb5;hb=HEAD#l1407) bakuli ndogo, 63 bakuli kubwa, 1 bakuli lisilo na mpangilio, 10 bakuli za haraka na 64 bakuli za tcache kwa kila mnyororo.
|
||||
Ili kuboresha ufanisi wa jinsi vipande vinavyohifadhiwa, kila kipande sio tu kwenye orodha moja ya viungo, lakini kuna aina kadhaa. Hizi ni vitengenezaji na kuna aina 5 za vitengenezaji: [62](https://sourceware.org/git/gitweb.cgi?p=glibc.git;a=blob;f=malloc/malloc.c;h=6e766d11bc85b6480fa5c9f2a76559f8acf9deb5;hb=HEAD#l1407) vitengenezaji vidogo, 63 vitengenezaji vikubwa, 1 kikasha kisichopangwa, 10 vitengenezaji vya haraka na vitengenezaji 64 vya tcache kwa kila mnyororo.
|
||||
|
||||
Anwani ya awali kwa kila bakuli lisilo na mpangilio, bakuli dogo na kubwa iko ndani ya safu moja. Indeksi 0 haifai, 1 ni bakuli lisilo na mpangilio, bakuli 2-64 ni bakuli ndogo na bakuli 65-127 ni bakuli kubwa.
|
||||
Anwani ya awali ya kila kikasha kisichopangwa, kidogo na kikubwa iko ndani ya safu moja. Indeksi 0 haifai, 1 ni kikasha kisichopangwa, vitengenezaji 2-64 ni vitengenezaji vidogo na vitengenezaji 65-127 ni vitengenezaji vikubwa.
|
||||
|
||||
### Bakuli Ndogo
|
||||
### Vitengenezaji wa Tcache (Akiba kwa Kila Mnyororo)
|
||||
|
||||
Bakuli ndogo ni haraka kuliko bakuli kubwa lakini polepole kuliko bakuli za haraka.
|
||||
Ingawa mnyororo unajaribu kuwa na kizimbani chake (angalia [Arenas](bins-and-memory-allocations.md#arenas) na [Subheaps](bins-and-memory-allocations.md#subheaps)), kuna uwezekano kwamba mchakato na mnyororo mwingi (kama seva ya wavuti) **watakamilisha kushiriki kizimbani na mnyororo mwingine**. Katika kesi hii, suluhisho kuu ni matumizi ya **kufunga**, ambayo inaweza **kupunguza kwa kiasi kikubwa kasi ya mnyororo**.
|
||||
|
||||
Kila bakuli kati ya 62 itakuwa na **vipande vya saizi ile ile**: 16, 24, ... (na saizi ya juu ya byte 504 katika bits 32 na 1024 katika bits 64). Hii husaidia katika kasi ya kupata bakuli ambapo nafasi inapaswa kutengwa na kuingiza na kuondoa viingilio kwenye orodha hizi.
|
||||
Kwa hivyo, tcache inafanana na kikasha cha haraka kwa kila mnyororo kwa njia kwamba ni **orodha moja ya viungo** ambayo haifungi vipande. Kila mnyororo ana **vitengenezaji 64 vya tcache vilivyounganishwa kwa mnyororo mmoja**. Kila kikasha kinaweza kuwa na kiwango cha juu cha [vipande vya saizi sawa 7](https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l323) kuanzia [24 hadi 1032B kwenye mifumo ya 64-bit na 12 hadi 516B kwenye mifumo ya 32-bit](https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l315).
|
||||
|
||||
### Bakuli Kubwa
|
||||
**Wakati mnyororo anapofuta** kipande, **ikiwa sio kikubwa sana** kuweza kupangwa kwenye tcache na kikasha cha tcache **hakijajaa** (tayari kuna vipande 7), **kitapangwa hapo**. Ikiwa hakiwezi kwenda kwenye tcache, italazimika kusubiri kizibani cha kizimbani ili iweze kufanya operesheni ya bure kwa ujumla.
|
||||
|
||||
Tofauti na bakuli ndogo, ambazo hushughulikia vipande vya saizi iliyowekwa, kila **bakuli kubwa hushughulikia safu ya saizi za vipande**. Hii ni ya kubadilika zaidi, kuruhusu mfumo kuhifadhi **saizi tofauti** bila kuhitaji bakuli tofauti kwa kila saizi.
|
||||
Wakati kipande kinapopangwa, ikiwa kuna kipande cha bure cha saizi inayohitajika kwenye **Tcache itakitumia**, la sivyo, italazimika kusubiri kizibani cha kizimbani ili iweze kupata moja kwenye vitengenezaji vya jumla au kuunda mpya.\
|
||||
Pia kuna upimaji, katika kesi hii, wakati wa kuwa na kizibani cha kizimbani, mnyororo **atajaza Tcache yake na vipande vya kizimbani (7) vya saizi inayohitajika**, hivyo ikihitaji zaidi, itavipata kwenye Tcache.
|
||||
|
||||
Katika mpangilio wa kumbukumbu, bakuli kubwa huanza pale bakuli ndogo inapoishia. Safu za bakuli kubwa hukua kwa ukubwa unaokua, maana bakuli la kwanza linaweza kufunika vipande kutoka 512 hadi 576 byte, wakati ufuatao unafunika 576 hadi 640 byte. Mtindo huu unaendelea, na bakuli kubwa zaidi ikijumuisha vipande vyote zaidi ya 1MB.
|
||||
<details>
|
||||
|
||||
Bakuli kubwa ni polepole kufanya kazi ikilinganishwa na bakuli ndogo kwa sababu lazima **zipange na kutafuta kupitia orodha ya saizi tofauti za vipande ili kupata saizi bora** kwa kutengwa. Wakati kipande kinapowekwa kwenye bakuli kubwa, lazima kipangwe, na wakati kumbukumbu inatengwa, mfumo lazima ipate kipande sahihi. Kazi hii ya ziada inawafanya kuwa **polepole**, lakini kwa kuwa vipande vikubwa ni nadra kuliko vya kawaida, ni sawa kufanya biashara hiyo.
|
||||
<summary>Ongeza mfano wa kipande cha tcache</summary>
|
||||
```c
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
char *chunk;
|
||||
chunk = malloc(24);
|
||||
printf("Address of the chunk: %p\n", (void *)chunk);
|
||||
gets(chunk);
|
||||
free(chunk);
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
Tafadhali itayarishe na uishe na kosa katika opcode ya ret kutoka kwa kazi kuu. kisha kwa gef unaweza kuona tcache bin inayotumiwa:
|
||||
```bash
|
||||
gef➤ heap bins
|
||||
──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ────────────────────────────────────────────────────────────────────────────────
|
||||
Tcachebins[idx=0, size=0x20, count=1] ← Chunk(addr=0xaaaaaaac12a0, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
|
||||
```
|
||||
</details>
|
||||
|
||||
#### Tcache Structs & Functions
|
||||
|
||||
Katika msimbo ufuatao inawezekana kuona **max bins** na **vipande kwa kila index**, **`tcache_entry`** muundo ulioundwa ili kuepuka kufuta mara mbili na **`tcache_perthread_struct`**, muundo ambao kila mnyororo hutumia kuhifadhi anwani kwa kila index ya benki.
|
||||
|
||||
<details>
|
||||
|
||||
<summary><code>tcache_entry</code> na <code>tcache_perthread_struct</code></summary>
|
||||
```c
|
||||
// From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c
|
||||
|
||||
/* We want 64 entries. This is an arbitrary limit, which tunables can reduce. */
|
||||
# define TCACHE_MAX_BINS 64
|
||||
# define MAX_TCACHE_SIZE tidx2usize (TCACHE_MAX_BINS-1)
|
||||
|
||||
/* Only used to pre-fill the tunables. */
|
||||
# define tidx2usize(idx) (((size_t) idx) * MALLOC_ALIGNMENT + MINSIZE - SIZE_SZ)
|
||||
|
||||
/* When "x" is from chunksize(). */
|
||||
# define csize2tidx(x) (((x) - MINSIZE + MALLOC_ALIGNMENT - 1) / MALLOC_ALIGNMENT)
|
||||
/* When "x" is a user-provided size. */
|
||||
# define usize2tidx(x) csize2tidx (request2size (x))
|
||||
|
||||
/* With rounding and alignment, the bins are...
|
||||
idx 0 bytes 0..24 (64-bit) or 0..12 (32-bit)
|
||||
idx 1 bytes 25..40 or 13..20
|
||||
idx 2 bytes 41..56 or 21..28
|
||||
etc. */
|
||||
|
||||
/* This is another arbitrary limit, which tunables can change. Each
|
||||
tcache bin will hold at most this number of chunks. */
|
||||
# define TCACHE_FILL_COUNT 7
|
||||
|
||||
/* Maximum chunks in tcache bins for tunables. This value must fit the range
|
||||
of tcache->counts[] entries, else they may overflow. */
|
||||
# define MAX_TCACHE_COUNT UINT16_MAX
|
||||
|
||||
[...]
|
||||
|
||||
typedef struct tcache_entry
|
||||
{
|
||||
struct tcache_entry *next;
|
||||
/* This field exists to detect double frees. */
|
||||
uintptr_t key;
|
||||
} tcache_entry;
|
||||
|
||||
/* There is one of these for each thread, which contains the
|
||||
per-thread cache (hence "tcache_perthread_struct"). Keeping
|
||||
overall size low is mildly important. Note that COUNTS and ENTRIES
|
||||
are redundant (we could have just counted the linked list each
|
||||
time), this is for performance reasons. */
|
||||
typedef struct tcache_perthread_struct
|
||||
{
|
||||
uint16_t counts[TCACHE_MAX_BINS];
|
||||
tcache_entry *entries[TCACHE_MAX_BINS];
|
||||
} tcache_perthread_struct;
|
||||
```
|
||||
</details>
|
||||
|
||||
Kazi `__tcache_init` ndio kazi inayounda na kutenga nafasi kwa ajili ya `tcache_perthread_struct` obj
|
||||
|
||||
<details>
|
||||
|
||||
<summary>Msimbo wa tcache_init</summary>
|
||||
```c
|
||||
// From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c#L3241C1-L3274C2
|
||||
|
||||
static void
|
||||
tcache_init(void)
|
||||
{
|
||||
mstate ar_ptr;
|
||||
void *victim = 0;
|
||||
const size_t bytes = sizeof (tcache_perthread_struct);
|
||||
|
||||
if (tcache_shutting_down)
|
||||
return;
|
||||
|
||||
arena_get (ar_ptr, bytes);
|
||||
victim = _int_malloc (ar_ptr, bytes);
|
||||
if (!victim && ar_ptr != NULL)
|
||||
{
|
||||
ar_ptr = arena_get_retry (ar_ptr, bytes);
|
||||
victim = _int_malloc (ar_ptr, bytes);
|
||||
}
|
||||
|
||||
|
||||
if (ar_ptr != NULL)
|
||||
__libc_lock_unlock (ar_ptr->mutex);
|
||||
|
||||
/* In a low memory situation, we may not be able to allocate memory
|
||||
- in which case, we just keep trying later. However, we
|
||||
typically do this very early, so either there is sufficient
|
||||
memory, or there isn't enough memory to do non-trivial
|
||||
allocations anyway. */
|
||||
if (victim)
|
||||
{
|
||||
tcache = (tcache_perthread_struct *) victim;
|
||||
memset (tcache, 0, sizeof (tcache_perthread_struct));
|
||||
}
|
||||
|
||||
}
|
||||
```
|
||||
</details>
|
||||
|
||||
### Bins haraka
|
||||
|
||||
Bins haraka zimeundwa kwa **kusudi la kuharakisha mgawanyo wa kumbukumbu kwa vipande vidogo** kwa kuweka vipande vilivyotolewa hivi karibuni katika muundo wa ufikiaji wa haraka. Bins hizi hutumia njia ya Mwisho-Katika, Mwanzo-Kwanza (LIFO), ambayo inamaanisha kwamba **kipande kilichotolewa hivi karibuni zaidi ndicho kwanza** kutumika tena wakati kuna ombi jipya la mgawo. Tabia hii ni nzuri kwa kasi, kwani ni haraka kuingiza na kuondoa kutoka juu ya steki (LIFO) ikilinganishwa na foleni (FIFO).
|
||||
|
||||
Kwa kuongezea, **bins haraka hutumia orodha za viungo moja**, si viungo vya mara mbili, ambavyo vinaboresha kasi zaidi. Kwa kuwa vipande katika bins haraka havijunganishwi na majirani, hakuna haja ya muundo wenye utata unaoruhusu kuondolewa katikati. Orodha ya viungo moja ni rahisi na haraka kwa operesheni hizi.
|
||||
|
||||
Kimsingi, kinachotokea hapa ni kwamba kichwa (kiashiria cha kipande cha kwanza cha kuangalia) kinaelekeza daima kwenye kipande kilichotolewa hivi karibuni cha ukubwa huo. Kwa hivyo:
|
||||
|
||||
* Wakati kipande kipya kinagawiwa ukubwa huo, kichwa kinaelekeza kwenye kipande huru cha kutumia. Kwa kuwa kipande huru hiki kinaelekeza kwenye kipande kinachofuata cha kutumia, anwani hii imehifadhiwa kwenye kichwa ili mgawo ujao ujue wapi kupata kipande kinachopatikana
|
||||
* Wakati kipande kinapotolewa, kipande huru kitahifadhi anwani ya kipande kinachopatikana kwa sasa na anwani ya kipande hiki kilichotolewa hivi karibuni itawekwa kwenye kichwa
|
||||
|
||||
Ukubwa wa juu wa orodha ya viungo ni `0x80` na zimepangwa ili kipande cha ukubwa wa `0x20-0x2f` kiwe katika indeksi `0`, kipande cha ukubwa wa `0x30-0x3f` kingekuwa katika `idx` `1`...
|
||||
|
||||
{% hint style="danger" %}
|
||||
Vipande katika bins haraka havijawekwa kama vinavyopatikana hivyo vinabaki kama vipande vya bins haraka kwa muda fulani badala ya kuweza kujumuishwa na vipande vingine huru vinavyowazunguka.
|
||||
{% endhint %}
|
||||
```c
|
||||
// From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1711
|
||||
|
||||
/*
|
||||
Fastbins
|
||||
|
||||
An array of lists holding recently freed small chunks. Fastbins
|
||||
are not doubly linked. It is faster to single-link them, and
|
||||
since chunks are never removed from the middles of these lists,
|
||||
double linking is not necessary. Also, unlike regular bins, they
|
||||
are not even processed in FIFO order (they use faster LIFO) since
|
||||
ordering doesn't much matter in the transient contexts in which
|
||||
fastbins are normally used.
|
||||
|
||||
Chunks in fastbins keep their inuse bit set, so they cannot
|
||||
be consolidated with other free chunks. malloc_consolidate
|
||||
releases all chunks in fastbins and consolidates them with
|
||||
other free chunks.
|
||||
*/
|
||||
|
||||
typedef struct malloc_chunk *mfastbinptr;
|
||||
#define fastbin(ar_ptr, idx) ((ar_ptr)->fastbinsY[idx])
|
||||
|
||||
/* offset 2 to use otherwise unindexable first 2 bins */
|
||||
#define fastbin_index(sz) \
|
||||
((((unsigned int) (sz)) >> (SIZE_SZ == 8 ? 4 : 3)) - 2)
|
||||
|
||||
|
||||
/* The maximum fastbin request size we support */
|
||||
#define MAX_FAST_SIZE (80 * SIZE_SZ / 4)
|
||||
|
||||
#define NFASTBINS (fastbin_index (request2size (MAX_FAST_SIZE)) + 1)
|
||||
```
|
||||
<details>
|
||||
|
||||
<summary>Ongeza mfano wa kipande cha fastbin</summary>
|
||||
```c
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
char *chunks[8];
|
||||
int i;
|
||||
|
||||
// Loop to allocate memory 8 times
|
||||
for (i = 0; i < 8; i++) {
|
||||
chunks[i] = malloc(24);
|
||||
if (chunks[i] == NULL) { // Check if malloc failed
|
||||
fprintf(stderr, "Memory allocation failed at iteration %d\n", i);
|
||||
return 1;
|
||||
}
|
||||
printf("Address of chunk %d: %p\n", i, (void *)chunks[i]);
|
||||
}
|
||||
|
||||
// Loop to free the allocated memory
|
||||
for (i = 0; i < 8; i++) {
|
||||
free(chunks[i]);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
Tambua jinsi tunavyoomba na kuachilia vipande 8 vya saizi sawa ili wajaze tcache na cha nane kuhifadhiwa kwenye kisanduku cha haraka.
|
||||
|
||||
Sakinisha na ukague kwa kusitisha kwenye opcode ya ret kutoka kwenye kazi kuu. kisha kwa gef unaweza kuona tcache bin kujaa na kipande kimoja kwenye kisanduku cha haraka:
|
||||
```bash
|
||||
gef➤ heap bins
|
||||
──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ────────────────────────────────────────────────────────────────────────────────
|
||||
Tcachebins[idx=0, size=0x20, count=7] ← Chunk(addr=0xaaaaaaac1770, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) ← Chunk(addr=0xaaaaaaac1750, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) ← Chunk(addr=0xaaaaaaac1730, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) ← Chunk(addr=0xaaaaaaac1710, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) ← Chunk(addr=0xaaaaaaac16f0, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) ← Chunk(addr=0xaaaaaaac16d0, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) ← Chunk(addr=0xaaaaaaac12a0, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
|
||||
───────────────────────────────────────────────────────────────────────── Fastbins for arena at 0xfffff7f90b00 ─────────────────────────────────────────────────────────────────────────
|
||||
Fastbins[idx=0, size=0x20] ← Chunk(addr=0xaaaaaaac1790, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
|
||||
Fastbins[idx=1, size=0x30] 0x00
|
||||
```
|
||||
</details>
|
||||
|
||||
### Bakuli lisilo na mpangilio
|
||||
|
||||
Bakuli lisilo na mpangilio ni **akiba** inayotumiwa na meneja wa bakuli ili kufanya mgawo wa kumbukumbu uwe wa haraka zaidi. Hapa ndivyo inavyofanya kazi: Wakati programu inafuta kipande, na ikiwa kipande hiki hakiwezi kupewa katika tcache au bakuli la haraka na haligongani na kipande cha juu, meneja wa bakuli hauweki mara moja katika bakuli maalum la kipande kidogo au kikubwa. Badala yake, kwanza inajaribu **kulifunga na vipande vingine vya bure vya jirani** ili kuunda kibodi kubwa ya kumbukumbu ya bure. Kisha, inaweka kipande kipya hiki katika bakuli la jumla linaloitwa "bakuli lisilo na mpangilio."
|
||||
|
||||
Wakati programu **inahitaji kumbukumbu**, meneja wa bakuli **huchunguza bakuli lisilo na mpangilio** kuona ikiwa kuna kipande cha ukubwa wa kutosha. Ikiipata, inakitumia mara moja. Ikiwa haitapata kipande kinachofaa katika bakuli lisilo na mpangilio, inahamisha vipande vyote katika orodha hii kwenye bakuli zao husika, iwe ndogo au kubwa, kulingana na ukubwa wao.
|
||||
|
||||
Tafadhali elewa kwamba ikiwa kipande kikubwa kimegawanywa katika sehemu 2 na sehemu iliyobaki ni kubwa kuliko MINSIZE, itarudishwa tena kwenye bakuli lisilo na mpangilio. 
|
||||
|
||||
Kwa hivyo, bakuli lisilo na mpangilio ni njia ya kuharakisha mgawo wa kumbukumbu kwa haraka kutumia tena kumbukumbu iliyofutwa hivi karibuni na kupunguza haja ya kutafuta na kufunga kwa muda mrefu.
|
||||
|
||||
{% hint style="danger" %}
|
||||
Tafadhali elewa kwamba hata ikiwa vipande ni vya makundi tofauti, ikiwa kipande kinachopatikana kinagongana na kipande kingine kinachopatikana (hata ikiwa kwa asili zinatoka kwenye bakuli tofauti), vitafungwa pamoja.
|
||||
{% endhint %}
|
||||
|
||||
<details>
|
||||
|
||||
<summary>Ongeza mfano wa kipande kilichochanganyikana</summary>
|
||||
```c
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
char *chunks[9];
|
||||
int i;
|
||||
|
||||
// Loop to allocate memory 8 times
|
||||
for (i = 0; i < 9; i++) {
|
||||
chunks[i] = malloc(0x100);
|
||||
if (chunks[i] == NULL) { // Check if malloc failed
|
||||
fprintf(stderr, "Memory allocation failed at iteration %d\n", i);
|
||||
return 1;
|
||||
}
|
||||
printf("Address of chunk %d: %p\n", i, (void *)chunks[i]);
|
||||
}
|
||||
|
||||
// Loop to free the allocated memory
|
||||
for (i = 0; i < 8; i++) {
|
||||
free(chunks[i]);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
Tazama jinsi tunavyoomba na kuachilia vipande 9 vya saizi sawa ili vijaze tcache na cha nane kuhifadhiwa kwenye bin isiyoainishwa kwa sababu ni kubwa mno kwa fastbin na cha tisa hakijaachiliwa hivyo cha tisa na cha nane havitaunganishwa na kipande cha juu.
|
||||
|
||||
Sakinisha na uisashe na kizuizi katika opcode ya kurudi kutoka kwa kazi kuu. kisha kwa gef unaweza kuona tcache bin kujaa na kipande kimoja kwenye bin isiyoainishwa:
|
||||
```bash
|
||||
gef➤ heap bins
|
||||
──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ────────────────────────────────────────────────────────────────────────────────
|
||||
Tcachebins[idx=15, size=0x110, count=7] ← Chunk(addr=0xaaaaaaac1d10, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) ← Chunk(addr=0xaaaaaaac1c00, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) ← Chunk(addr=0xaaaaaaac1af0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) ← Chunk(addr=0xaaaaaaac19e0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) ← Chunk(addr=0xaaaaaaac18d0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) ← Chunk(addr=0xaaaaaaac17c0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) ← Chunk(addr=0xaaaaaaac12a0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
|
||||
───────────────────────────────────────────────────────────────────────── Fastbins for arena at 0xfffff7f90b00 ─────────────────────────────────────────────────────────────────────────
|
||||
Fastbins[idx=0, size=0x20] 0x00
|
||||
Fastbins[idx=1, size=0x30] 0x00
|
||||
Fastbins[idx=2, size=0x40] 0x00
|
||||
Fastbins[idx=3, size=0x50] 0x00
|
||||
Fastbins[idx=4, size=0x60] 0x00
|
||||
Fastbins[idx=5, size=0x70] 0x00
|
||||
Fastbins[idx=6, size=0x80] 0x00
|
||||
─────────────────────────────────────────────────────────────────────── Unsorted Bin for arena at 0xfffff7f90b00 ───────────────────────────────────────────────────────────────────────
|
||||
[+] unsorted_bins[0]: fw=0xaaaaaaac1e10, bk=0xaaaaaaac1e10
|
||||
→ Chunk(addr=0xaaaaaaac1e20, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
|
||||
[+] Found 1 chunks in unsorted bin.
|
||||
```
|
||||
</details>
|
||||
|
||||
### Bins Ndogo
|
||||
|
||||
Bins ndogo ni haraka kuliko bins kubwa lakini polepole kuliko fast bins.
|
||||
|
||||
Kila bin kati ya 62 itakuwa na **vipande vya saizi sawa**: 16, 24, ... (ikiwa na saizi ya juu ya 504 baiti katika bits 32 na 1024 katika bits 64). Hii husaidia katika kasi ya kupata bin ambapo nafasi inapaswa kutengwa na kuingiza na kuondoa vipande kwenye orodha hizi.
|
||||
|
||||
Hivi ndivyo saizi ya bin ndogo inavyohesabiwa kulingana na index ya bin:
|
||||
|
||||
* Saizi ndogo zaidi: 2\*4\*index (k.m. index 5 -> 40)
|
||||
* Saizi kubwa zaidi: 2\*8\*index (k.m. index 5 -> 80)
|
||||
```c
|
||||
// From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1711
|
||||
#define NSMALLBINS 64
|
||||
#define SMALLBIN_WIDTH MALLOC_ALIGNMENT
|
||||
#define SMALLBIN_CORRECTION (MALLOC_ALIGNMENT > CHUNK_HDR_SZ)
|
||||
#define MIN_LARGE_SIZE ((NSMALLBINS - SMALLBIN_CORRECTION) * SMALLBIN_WIDTH)
|
||||
|
||||
#define in_smallbin_range(sz) \
|
||||
((unsigned long) (sz) < (unsigned long) MIN_LARGE_SIZE)
|
||||
|
||||
#define smallbin_index(sz) \
|
||||
((SMALLBIN_WIDTH == 16 ? (((unsigned) (sz)) >> 4) : (((unsigned) (sz)) >> 3))\
|
||||
+ SMALLBIN_CORRECTION)
|
||||
```
|
||||
```plaintext
|
||||
Kazi ya kuchagua kati ya makandokando madogo na makandokando makubwa:
|
||||
```
|
||||
```c
|
||||
#define bin_index(sz) \
|
||||
((in_smallbin_range (sz)) ? smallbin_index (sz) : largebin_index (sz))
|
||||
```
|
||||
<details>
|
||||
|
||||
<summary>Wekeza mfano mdogo wa kipande</summary>
|
||||
```c
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
char *chunks[10];
|
||||
int i;
|
||||
|
||||
// Loop to allocate memory 8 times
|
||||
for (i = 0; i < 9; i++) {
|
||||
chunks[i] = malloc(0x100);
|
||||
if (chunks[i] == NULL) { // Check if malloc failed
|
||||
fprintf(stderr, "Memory allocation failed at iteration %d\n", i);
|
||||
return 1;
|
||||
}
|
||||
printf("Address of chunk %d: %p\n", i, (void *)chunks[i]);
|
||||
}
|
||||
|
||||
// Loop to free the allocated memory
|
||||
for (i = 0; i < 8; i++) {
|
||||
free(chunks[i]);
|
||||
}
|
||||
|
||||
chunks[9] = malloc(0x110);
|
||||
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
Tambua jinsi tunavyoomba na kuachilia vipande 9 vya saizi ile ile ili vijaze tcache na cha nane kuhifadhiwa kwenye unsorted bin kwa sababu ni kubwa mno kwa fastbin na cha tisa hakijaachiliwa hivyo cha tisa na cha nane havijunganishwa na kipande cha juu. Kisha tunaomba kipande kikubwa cha 0x110 ambacho kinasababisha kipande kwenye unsorted bin kuingia kwenye small bin.
|
||||
|
||||
Sakinisha na uisas
|
||||
```bash
|
||||
gef➤ heap bins
|
||||
──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ────────────────────────────────────────────────────────────────────────────────
|
||||
Tcachebins[idx=15, size=0x110, count=7] ← Chunk(addr=0xaaaaaaac1d10, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) ← Chunk(addr=0xaaaaaaac1c00, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) ← Chunk(addr=0xaaaaaaac1af0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) ← Chunk(addr=0xaaaaaaac19e0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) ← Chunk(addr=0xaaaaaaac18d0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) ← Chunk(addr=0xaaaaaaac17c0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) ← Chunk(addr=0xaaaaaaac12a0, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
|
||||
───────────────────────────────────────────────────────────────────────── Fastbins for arena at 0xfffff7f90b00 ─────────────────────────────────────────────────────────────────────────
|
||||
Fastbins[idx=0, size=0x20] 0x00
|
||||
Fastbins[idx=1, size=0x30] 0x00
|
||||
Fastbins[idx=2, size=0x40] 0x00
|
||||
Fastbins[idx=3, size=0x50] 0x00
|
||||
Fastbins[idx=4, size=0x60] 0x00
|
||||
Fastbins[idx=5, size=0x70] 0x00
|
||||
Fastbins[idx=6, size=0x80] 0x00
|
||||
─────────────────────────────────────────────────────────────────────── Unsorted Bin for arena at 0xfffff7f90b00 ───────────────────────────────────────────────────────────────────────
|
||||
[+] Found 0 chunks in unsorted bin.
|
||||
──────────────────────────────────────────────────────────────────────── Small Bins for arena at 0xfffff7f90b00 ────────────────────────────────────────────────────────────────────────
|
||||
[+] small_bins[16]: fw=0xaaaaaaac1e10, bk=0xaaaaaaac1e10
|
||||
→ Chunk(addr=0xaaaaaaac1e20, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
|
||||
[+] Found 1 chunks in 1 small non-empty bins.
|
||||
```
|
||||
</details>
|
||||
|
||||
### Bins kubwa
|
||||
|
||||
Tofauti na bins ndogo, ambazo hushughulikia vipande vya saizi za kudumu, kila **bin kubwa hushughulikia safu ya saizi za vipande**. Hii ni ya kubadilika zaidi, ikiruhusu mfumo kuzoea **saizi tofauti** bila haja ya bin tofauti kwa kila saizi.
|
||||
|
||||
Katika mpangishaji wa kumbukumbu, bins kubwa huanza pale ambapo bins ndogo zinaishia. Safu za bins kubwa hukua kwa ukubwa kwa mfululizo, maana bin la kwanza linaweza kufunika vipande kutoka 512 hadi 576 baiti, huku linalofuata likifunika 576 hadi 640 baiti. Mtindo huu unaendelea, na bin kubwa zaidi ikijumuisha vipande vyote zaidi ya 1MB.
|
||||
|
||||
Bins kubwa huchukua muda mrefu kufanya kazi ikilinganishwa na bins ndogo kwa sababu lazima **zipange na kutafuta kupitia orodha ya saizi tofauti za vipande ili kupata saizi bora** kwa ajili ya mgawo. Wakati kipande kinapowekwa kwenye bin kubwa, lazima kipangwe, na wakati kumbukumbu inapogawiwa, mfumo lazima upate kipande sahihi. Kazi hii ya ziada inawafanya kuwa **polepole**, lakini kwa kuwa mgawo wa kubwa ni nadra kuliko vipande vidogo, ni sawa kufanya biashara hiyo.
|
||||
|
||||
Kuna:
|
||||
|
||||
* Bakuli 32 za safu ya 64B
|
||||
* Bakuli 16 za safu ya 512B
|
||||
* Bakuli 8 za safu ya 4096B
|
||||
* Bakuli 4 za safu ya 32768B
|
||||
* Bakuli 2 za safu ya 262144B
|
||||
* Bakuli 1 kwa ajili ya saizi zilizobaki
|
||||
* Bins 32 za safu ya 64B (zinagongana na bins ndogo)
|
||||
* Bins 16 za safu ya 512B (zinagongana na bins ndogo)
|
||||
* Bins 8 za safu ya 4096B (sehemu inagongana na bins ndogo)
|
||||
* Bins 4 za safu ya 32768B
|
||||
* Bins 2 za safu ya 262144B
|
||||
* Bin 1 kwa ajili ya saizi zilizosalia
|
||||
|
||||
### Bakuli Lisilo na Mpangilio
|
||||
<details>
|
||||
|
||||
Bakuli lisilo na mpangilio ni **akiba ya haraka** inayotumiwa na meneja wa kumbukumbu ili kufanya kutenga kwa haraka kwa kumbukumbu. Hivi ndivyo inavyofanya kazi: Wakati programu inaachilia kumbukumbu, meneja wa kumbukumbu haitoi mara moja kwenye bakuli maalum. Badala yake, kwanza inajaribu **kulijumuisha na vipande vya bure vya jirani** ili kuunda kibodi kikubwa cha kumbukumbu ya bure. Kisha, inaweka kipande kipya hiki kwenye bakuli la jumla linaloitwa "bakuli lisilo na mpangilio."
|
||||
<summary>Msimbo wa Saizi za Bins Kubwa</summary>
|
||||
```c
|
||||
// From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1711
|
||||
|
||||
Wakati programu **inaomba kumbukumbu**, meneja wa kumbukumbu **huchunguza bakuli lisilo na mpangilio** kuona ikiwa kuna kipande cha saizi ya kutosha. Ikiwa inapata moja, inaitumia mara moja. Ikiwa haina kipande kinachofaa, inahamisha vipande vilivyofutwa kwenye bakuli zao husika, iwe ndogo au kubwa, kulingana na saizi zao.
|
||||
#define largebin_index_32(sz) \
|
||||
(((((unsigned long) (sz)) >> 6) <= 38) ? 56 + (((unsigned long) (sz)) >> 6) :\
|
||||
((((unsigned long) (sz)) >> 9) <= 20) ? 91 + (((unsigned long) (sz)) >> 9) :\
|
||||
((((unsigned long) (sz)) >> 12) <= 10) ? 110 + (((unsigned long) (sz)) >> 12) :\
|
||||
((((unsigned long) (sz)) >> 15) <= 4) ? 119 + (((unsigned long) (sz)) >> 15) :\
|
||||
((((unsigned long) (sz)) >> 18) <= 2) ? 124 + (((unsigned long) (sz)) >> 18) :\
|
||||
126)
|
||||
|
||||
Kwa hivyo, bakuli lisilo na mpangilio ni njia ya kuharakisha kutenga kwa kumbukumbu kwa haraka kwa kutumia tena kumbukumbu iliyofutwa hivi karibuni na kupunguza haja ya kutafuta na kujumuisha kwa muda mrefu.
|
||||
#define largebin_index_32_big(sz) \
|
||||
(((((unsigned long) (sz)) >> 6) <= 45) ? 49 + (((unsigned long) (sz)) >> 6) :\
|
||||
((((unsigned long) (sz)) >> 9) <= 20) ? 91 + (((unsigned long) (sz)) >> 9) :\
|
||||
((((unsigned long) (sz)) >> 12) <= 10) ? 110 + (((unsigned long) (sz)) >> 12) :\
|
||||
((((unsigned long) (sz)) >> 15) <= 4) ? 119 + (((unsigned long) (sz)) >> 15) :\
|
||||
((((unsigned long) (sz)) >> 18) <= 2) ? 124 + (((unsigned long) (sz)) >> 18) :\
|
||||
126)
|
||||
|
||||
{% hint style="danger" %}
|
||||
Tafadhali kumbuka kwamba hata kama vipande ni vya makundi tofauti, ikiwa kipande kinachopatikana kinaingiliana na kipande kingine kilichopo (hata kama ni vikundi tofauti), vitajumuishwa.
|
||||
{% endhint %}
|
||||
// XXX It remains to be seen whether it is good to keep the widths of
|
||||
// XXX the buckets the same or whether it should be scaled by a factor
|
||||
// XXX of two as well.
|
||||
#define largebin_index_64(sz) \
|
||||
(((((unsigned long) (sz)) >> 6) <= 48) ? 48 + (((unsigned long) (sz)) >> 6) :\
|
||||
((((unsigned long) (sz)) >> 9) <= 20) ? 91 + (((unsigned long) (sz)) >> 9) :\
|
||||
((((unsigned long) (sz)) >> 12) <= 10) ? 110 + (((unsigned long) (sz)) >> 12) :\
|
||||
((((unsigned long) (sz)) >> 15) <= 4) ? 119 + (((unsigned long) (sz)) >> 15) :\
|
||||
((((unsigned long) (sz)) >> 18) <= 2) ? 124 + (((unsigned long) (sz)) >> 18) :\
|
||||
126)
|
||||
|
||||
### Bakuli za Haraka
|
||||
#define largebin_index(sz) \
|
||||
(SIZE_SZ == 8 ? largebin_index_64 (sz) \
|
||||
: MALLOC_ALIGNMENT == 16 ? largebin_index_32_big (sz) \
|
||||
: largebin_index_32 (sz))
|
||||
```
|
||||
</details>
|
||||
|
||||
Bakuli za haraka zimeundwa kuharakisha **kutenga kwa kumbukumbu kwa vipande vidogo** kwa kuweka vipande vilivyofutwa hivi karibuni katika muundo wa kupata haraka. Bakuli hizi hutumia njia ya Mwisho-Kuingia, Mwanzo-Kutoka (LIFO), maana kwamba **kipande kilichofutwa hivi karibuni ndicho kwanza** kutumika wakati kuna ombi jipya la kutenga. Tabia hii ni nzuri kwa kasi, kwani ni haraka kuingiza na kuondoa kutoka juu ya rundo (LIFO) ikilinganishwa na foleni (FIFO).
|
||||
<details>
|
||||
|
||||
Zaidi ya hayo, **bakuli za haraka hutumia orodha za kushikamana moja**, sio mbili, ambayo inaboresha kasi zaidi. Kwa kuwa vipande katika bakuli za haraka havijajumuishwa na majirani, hakuna haja ya muundo tata unaoruhusu kuondolewa katikati. Orodha ya kushikamana moja ni rahisi na haraka kwa shughuli hizi.
|
||||
<summary>Ongeza mfano wa kipande kikubwa</summary>
|
||||
```c
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
|
||||
Kimsingi, kinachotokea hapa ni kwamba kichwa (kiashiria cha kipande cha kwanza cha kuangalia) kinaelekeza daima kwenye kipande kilichofutwa hivi karibuni cha saizi hiyo. Kwa hivyo:
|
||||
int main(void)
|
||||
{
|
||||
char *chunks[2];
|
||||
|
||||
* Wakati kipande kipya kinatengwa cha saizi hiyo, kichwa kinaelekeza kwenye kipande cha bure cha kutumia. Kwa kuwa kipande hiki cha bure kinaelekeza kwenye kipande kinachofuata cha kutumia, anwani hii inahifadhiwa kwenye kichwa ili kutolewa ijayo ijue wapi kupata kipande kinachopatikana
|
||||
* Wakati kipande kinapofutwa, kipande cha bure kitahifadhi anwani ya kipande kinachopatikana kwa sasa na anwani ya kipande hiki kilichofutwa itawekwa kwenye kichwa
|
||||
chunks[0] = malloc(0x1500);
|
||||
chunks[1] = malloc(0x1500);
|
||||
free(chunks[0]);
|
||||
chunks[0] = malloc(0x2000);
|
||||
|
||||
{% hint style="danger" %}
|
||||
Vipande katika bakuli za haraka havijaainishwa moja kwa moja kama vinavyopatikana hivyo vinabaki kama vipande vya bakuli za haraka kwa muda fulani badala ya kuweza kujumuishwa na vipande vingine.
|
||||
{% endhint %}
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
2 alokesheni kubwa zinafanywa, kisha moja inaachiliwa (ikiwekwa kwenye sanduku lisilo na mpangilio) na alokesheni kubwa zaidi inafanywa (ikihamisha ile iliyofunguliwa kutoka kwenye sanduku lisilo na mpangilio kwenda kwenye sanduku kubwa).
|
||||
|
||||
### Bakuli za Tcache (Akiba kwa Mnyororo)
|
||||
Sakinisha na uisashe na kivamizi kwenye opcode ya ret kutoka kwenye kazi kuu. kisha kwa gef unaweza kuona sanduku la tcache likijazwa na kipande kimoja kwenye sanduku kubwa:
|
||||
```bash
|
||||
gef➤ heap bin
|
||||
──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ────────────────────────────────────────────────────────────────────────────────
|
||||
All tcachebins are empty
|
||||
───────────────────────────────────────────────────────────────────────── Fastbins for arena at 0xfffff7f90b00 ─────────────────────────────────────────────────────────────────────────
|
||||
Fastbins[idx=0, size=0x20] 0x00
|
||||
Fastbins[idx=1, size=0x30] 0x00
|
||||
Fastbins[idx=2, size=0x40] 0x00
|
||||
Fastbins[idx=3, size=0x50] 0x00
|
||||
Fastbins[idx=4, size=0x60] 0x00
|
||||
Fastbins[idx=5, size=0x70] 0x00
|
||||
Fastbins[idx=6, size=0x80] 0x00
|
||||
─────────────────────────────────────────────────────────────────────── Unsorted Bin for arena at 0xfffff7f90b00 ───────────────────────────────────────────────────────────────────────
|
||||
[+] Found 0 chunks in unsorted bin.
|
||||
──────────────────────────────────────────────────────────────────────── Small Bins for arena at 0xfffff7f90b00 ────────────────────────────────────────────────────────────────────────
|
||||
[+] Found 0 chunks in 0 small non-empty bins.
|
||||
──────────────────────────────────────────────────────────────────────── Large Bins for arena at 0xfffff7f90b00 ────────────────────────────────────────────────────────────────────────
|
||||
[+] large_bins[100]: fw=0xaaaaaaac1290, bk=0xaaaaaaac1290
|
||||
→ Chunk(addr=0xaaaaaaac12a0, size=0x1510, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
|
||||
[+] Found 1 chunks in 1 large non-empty bins.
|
||||
```
|
||||
</details>
|
||||
|
||||
Ingawa nyuzi zinajaribu kuwa na kumbukumbu yao wenyewe (angalia [Arenas](bins-and-memory-allocations.md#arenas) na [Subheaps](bins-and-memory-allocations.md#subheaps)), kuna uwezekano kwamba mchakato na nyuzi nyingi (kama seva ya wavuti) **itamaliza kushiriki kumbukumbu na nyuzi nyingine**. Katika kesi hii, suluhisho kuu ni matumizi ya **lockers**, ambayo yanaweza **kupunguza kasi kwa kiasi kikubwa nyuzi**.
|
||||
### Kipande cha Juu
|
||||
```c
|
||||
// From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1711
|
||||
|
||||
Kwa hivyo, tcache ni sawa na bakuli la haraka kwa kila nyuzi kwa njia kwamba ni **orodha ya kushikamana moja** ambayo haifanyi vipande. Kila nyuzi ina **bakuli 64 za tcache za kushikamana moja**. Kila bakuli inaweza kuwa na kiwango cha juu cha [vipande 7 vya saizi ile ile](https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l323) kutoka [24 hadi 1032B kwenye mifumo ya 64-bit na 12 hadi 516B kwenye mifumo ya 32-bit](https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l315).
|
||||
/*
|
||||
Top
|
||||
|
||||
**Wakati nyuzi inafuta** kipande, **ikiwa sio kikubwa sana** kutengwa kwenye tcache na bakuli ya tcache **haiko kamili** (tayari vipande 7), **itawekwa hapo**. Ikiwa haitaweza kwenda kwenye tcache, italazimika kusubiri kwa ajili ya kufungua kumbukumbu ili kufanya operesheni ya kufuta kwa jumla.
|
||||
The top-most available chunk (i.e., the one bordering the end of
|
||||
available memory) is treated specially. It is never included in
|
||||
any bin, is used only if no other chunk is available, and is
|
||||
released back to the system if it is very large (see
|
||||
M_TRIM_THRESHOLD). Because top initially
|
||||
points to its own bin with initial zero size, thus forcing
|
||||
extension on the first malloc request, we avoid having any special
|
||||
code in malloc to check whether it even exists yet. But we still
|
||||
need to do so when getting memory from system, so we make
|
||||
initial_top treat the bin as a legal but unusable chunk during the
|
||||
interval between initialization and the first call to
|
||||
sysmalloc. (This is somewhat delicate, since it relies on
|
||||
the 2 preceding words to be zero during this interval as well.)
|
||||
*/
|
||||
|
||||
Wakati **kipande kinapotengwa**, ikiwa kuna kipande cha bure cha saizi inayohitajika kwenye **Tcache itakitumia**, ikiwa la, italazimika kusubiri kwa kufungua kumbukumbu ili kupata moja kwenye bakuli za jumla au kuunda mpya.\
|
||||
Kuna pia uboreshaji, katika kesi hii, wakati wa kufungua kumbukumbu, nyuzi **itajaza Tcache yake na vipande vya kumbukumbu (7) vya saizi inayohitajika**, hivyo ikihitaji zaidi, itavipata kwenye Tcache.
|
||||
## Mchakato wa Kutengwa
|
||||
/* Conveniently, the unsorted bin can be used as dummy top on first call */
|
||||
#define initial_top(M) (unsorted_chunks (M))
|
||||
```
|
||||
Kimsingi, hii ni kipande kinachojumuisha kila kipande cha heap kinachopatikana kwa sasa. Wakati malloc inafanywa, ikiwa hakuna kipande cha bure kinachopatikana kutumika, kipande hiki cha juu kitapunguza ukubwa wake kutoa nafasi inayohitajika. Pointer kwa Kipande cha Juu kuhifadhiwa katika muundo wa `malloc_state`.
|
||||
|
||||
{% hint style="success" %}
|
||||
(Maelezo haya ya sasa yanatoka kwa [https://heap-exploitation.dhavalkapil.com/diving\_into\_glibc\_heap/core\_functions](https://heap-exploitation.dhavalkapil.com/diving\_into\_glibc\_heap/core\_functions). TODO: Angalia toleo la mwisho na ulishe)
|
||||
{% endhint %}
|
||||
Zaidi ya hayo, mwanzoni, ni sawa kutumia kipande kilichochanganyika kama kipande cha juu.
|
||||
|
||||
Uteuzi unafanywa hatimaye na kazi: `void * _int_malloc (mstate av, size_t bytes)` na una mpangilio huu:
|
||||
<details>
|
||||
|
||||
1. Inasasisha `bytes` kuchukua huduma ya **upangaji**, n.k.
|
||||
2. Inachunguza kama `av` ni **NULL** au la.
|
||||
3. Katika kesi ya kutokuwepo kwa **eneo linaloweza kutumika** (wakati `av` ni NULL), inaita `sysmalloc` kupata kipande kwa kutumia mmap. Ikiwa mafanikio, inaita `alloc_perturb`. Inarudisha kipande.
|
||||
4. Kulingana na ukubwa:
|
||||
* \[Ongeza kwa asili] Tumia tcache kabla ya kuangalia fastbin inayofuata.
|
||||
* \[Ongeza kwa asili] Ikiwa hakuna tcache lakini bakuli tofauti inatumika (angalia hatua inayofuata), jaribu kujaza tcache kutoka kwa bakuli hilo
|
||||
* Ikiwa ukubwa unaanguka katika safu ya **fastbin**: 
|
||||
1. Pata kiashiria katika safu ya fastbin ili kupata bakuli sahihi kulingana na ukubwa wa ombi. 
|
||||
2. Ondoa kipande cha kwanza katika bakuli hilo na fanya `victim` ielekee hiyo.
|
||||
3. Ikiwa `victim` ni NULL, endelea kwa kesi inayofuata (smallbin).
|
||||
4. Ikiwa `victim` sio NULL, angalia ukubwa wa kipande ili kuhakikisha kuwa kinamiliki bakuli hilo maalum. Kosa ("malloc(): memory corruption (fast)") hutupwa vinginevyo.
|
||||
5. Inaita `alloc_perturb` na kisha inarudisha kipande.
|
||||
* Ikiwa ukubwa unaanguka katika safu ya **smallbin**:
|
||||
1. Pata kiashiria katika safu ya smallbin ili kupata bakuli sahihi kulingana na ukubwa wa ombi.
|
||||
2. Ikiwa hakuna vipande katika bakuli hili, endelea kwa kesi inayofuata. Hii inachunguzwa kwa kulinganisha pointers `bin` na `bin->bk`.
|
||||
3. `victim` inafanywa sawa na `bin->bk` (kipande cha mwisho katika bakuli). Ikiwa ni NULL (inasababishwa wakati wa `initialization`), ita `malloc_consolidate` na ruka hatua kamili ya kuangalia katika bakuli tofauti.
|
||||
4. Vinginevyo, wakati `victim` sio NULL, angalia ikiwa `victim->bk->fd` na `victim` ni sawa au la. Ikiwa sio sawa, kosa (`malloc(): smallbin double linked list corrupted`) hutupwa.
|
||||
5. Weka biti ya PREV\_INSUSE kwa kipande kinachofuata (kwenye kumbukumbu, sio kwenye orodha iliyofungwa mara mbili) kwa `victim`.
|
||||
6. Ondoa kipande hiki kutoka kwenye orodha ya bakuli.
|
||||
7. Weka biti sahihi ya uwanja kwa kipande hiki kulingana na `av`.
|
||||
8. Inaita `alloc_perturb` na kisha inarudisha kipande.
|
||||
* Ikiwa ukubwa hauna katika safu ya smallbin:
|
||||
1. Pata kiashiria katika safu ya largebin ili kupata bakuli sahihi kulingana na ukubwa wa ombi.
|
||||
2. Angalia ikiwa `av` ina fastchunks au la. Hii inafanywa kwa kuangalia `FASTCHUNKS_BIT` katika `av->flags`. Ikiwa ndivyo, ita `malloc_consolidate` kwenye `av`.
|
||||
5. Ikiwa hakuna kipande kilichorudishwa bado, hii inaonyesha moja au zaidi ya hali zifuatazo:
|
||||
1. Ukubwa unaanguka katika safu ya 'fastbin' lakini hakuna fastchunk inapatikana.
|
||||
2. Ukubwa unaanguka katika safu ya 'smallbin' lakini hakuna smallchunk inapatikana (inaita `malloc_consolidate` wakati wa initialization).
|
||||
3. Ukubwa unaanguka katika safu ya 'largbin'.
|
||||
6. Kisha, **vipande visivyo na mpangilio** vinachunguzwa na vipande vilivyopangwa katika bakuli. Hii ndio mahali pekee ambapo vipande vinawekwa katika bakuli. Pitia bakuli lisilopangwa kutoka 'MKIA'.
|
||||
1. `victim` inaelekeza kipande cha sasa kinachofikiriwa.
|
||||
2. Angalia ikiwa ukubwa wa kipande cha `victim` uko ndani ya kiwango cha chini (`2*SIZE_SZ`) na cha juu (`av->system_mem`). Tupa kosa (`malloc(): memory corruption`) vinginevyo.
|
||||
3. Ikiwa (ukubwa wa kipande kilichoombwa unaanguka katika safu ya smallbin) na (`victim` ni kipande cha mabaki cha mwisho) na (ni kipande kimoja tu katika bakuli lisilopangwa) na (ukubwa wa vipande >= ule ulioombwa): **Gawanya kipande katika vipande 2**:
|
||||
* Kipande cha kwanza kinalingana na ukubwa ulioombwa na kurudishwa.
|
||||
* Kipande kilichobaki kinakuwa kipande kipya cha mabaki cha mwisho. Kinaingizwa tena kwenye bakuli lisilopangwa.
|
||||
1. Weka `chunk_size` na `chunk_prev_size` kwa vipande vyote viwili kwa usahihi.
|
||||
2. Kipande cha kwanza kurudishwa baada ya kuita `alloc_perturb`.
|
||||
3. Ikiwa hali iliyotajwa hapo juu sio kweli, udhibiti unafikia hapa. Ondoa `victim` kutoka kwenye bakuli lisilopangwa. Ikiwa ukubwa wa `victim` unalingana na ukubwa ulioombwa kikamilifu, rudisha kipande hiki baada ya kuita `alloc_perturb`.
|
||||
4. Ikiwa ukubwa wa `victim` unaanguka katika safu ya smallbin, ongeza kipande katika smallbin sahihi kwenye `KICHWA`.
|
||||
5. Vinginevyo ingiza kwenye largebin sahihi wakati wa kudumisha mpangilio uliopangwa:
|
||||
6. Kwanza angalia kipande cha mwisho (kidogo). Ikiwa `victim` ni ndogo kuliko kipande cha mwisho, ingiza kwenye mwisho.
|
||||
7. Vinginevyo, endelea kutafuta kipande chenye ukubwa >= ukubwa wa `victim`. Ikiwa ukubwa ni sawa kabisa, ingiza daima kwenye nafasi ya pili.
|
||||
8. Rudia hatua hii nzima kwa kiwango cha juu cha `MAX_ITERS` (10000) au hadi vipande vyote katika bakuli lisilopangwa vikome.
|
||||
7. Baada ya kuangalia vipande visivyo na mpangilio, angalia ikiwa ukubwa ulioombwa hauna katika safu ya smallbin, ikiwa ndivyo basi angalia **largebins**.
|
||||
1. Pata kiashiria katika safu ya largebin ili kupata bakuli sahihi kulingana na ukubwa wa ombi.
|
||||
2. Ikiwa ukubwa wa kipande kikubwa zaidi (kipande cha kwanza katika bakuli) ni kubwa kuliko ukubwa ulioombwa:
|
||||
1. Pitia kutoka 'MKIA' ili kupata kipande (`victim`) chenye ukubwa mdogo zaidi au sawa na ukubwa ulioombwa.
|
||||
2. Ita `unlink` kuondoa kipande cha `victim` kutoka kwenye bakuli.
|
||||
3. Hesabu `remainder_size` kwa kipande cha `victim` (hii itakuwa ukubwa wa kipande cha `victim` - ukubwa ulioombwa).
|
||||
4. Ikiwa hii `remainder_size` >= `MINSIZE` (ukubwa wa chini wa kipande pamoja na vichwa), gawa kipande katika vipande viwili. Vinginevyo, kipande chote cha `victim` kitarejeshwa. Ingiza kipande kilichobaki kwenye bakuli lisilopangwa (mwisho wa 'MKIA'). Kunaangalia kwenye bakuli lisilopangwa ikiwa `unsorted_chunks(av)->fd->bk == unsorted_chunks(av)`. Kosa hutupwa vinginevyo ("malloc(): corrupted unsorted chunks").
|
||||
5. Rudisha kipande cha `victim` baada ya kuita `alloc_perturb`.
|
||||
8. Mpaka sasa, tumekagua bakuli lisilopangwa na pia bakuli husika la haraka, dogo au kubwa. Tafadhali kumbuka kwamba bakuli moja (haraka au dogo) ilikaguliwa kwa kutumia ukubwa **sahihi** wa kipande kilichoombwa. Rudia hatua zifuatazo hadi bakuli zote zitakapomalizika:
|
||||
1. Kiashiria katika safu ya bakuli huongezwa ili kuangalia bakuli inayofuata.
|
||||
2. Tumia ramani ya `av->binmap` kupita kwenye bakuli zilizo tupu.
|
||||
3. `victim` inaelekezwa kwenye 'MKIA' ya bakuli la sasa.
|
||||
4. Kutumia ramani ya bakuli kuhakikisha kuwa ikiwa bakuli imepita (katika hatua ya 2 hapo juu), bila shaka ni tupu. Walakini, haitahakikishi kuwa bakuli zote tupu zitapuuzwa. Angalia ikiwa `victim` ni tupu au la. Ikiwa tupu, rudia kupita kwenye bakuli na kurudia mchakato huu (au 'endelea' mzunguko huu) hadi tutakapofika kwenye bakuli lisilo tupu.
|
||||
5. Gawa kipande (`victim` inaelekeza kipande cha mwisho cha bakuli lisilo tupu) katika vipande viwili. Ingiza kipande kilichobaki kwenye bakuli lisilopangwa (mwisho wa 'MKIA'). Kunaangalia kwenye bakuli lisilopangwa ikiwa `unsorted_chunks(av)->fd->bk == unsorted_chunks(av)`. Kosa hutupwa vinginevyo ("malloc(): corrupted unsorted chunks 2").
|
||||
6. Rudisha kipande cha `victim` baada ya kuita `alloc_perturb`.
|
||||
9. Ikiwa bado hakuna bakuli tupu iliyopatikana, kipande cha 'juu' kitatumika kuhudumia ombi:
|
||||
1. `victim` inaelekeza `av->juu`.
|
||||
2. Ikiwa ukubwa wa kipande cha 'juu' >= 'ukubwa ulioombwa' + `MINSIZE`, gawa katika vipande viwili. Katika kesi hii, kipande kilichobaki kinakuwa kipande kipya cha 'juu' na kipande kingine kurudishwa kwa mtumiaji baada ya kuita `alloc_perturb`.
|
||||
3. Angalia ikiwa `av` ina fastchunks au la. Hii inafanywa kwa kuangalia `FASTCHUNKS_BIT` katika `av->flags`. Ikiwa ndivyo, ita `malloc_consolidate` kwenye `av`. Rudia hatua ya 6 (ambapo tunachunguza bakuli lisilopangwa).
|
||||
4. Ikiwa `av` haina fastchunks, ita `sysmalloc` na rudisha kipande kilichopatikana baada ya kuita `alloc_perturb`.
|
||||
## Mtiririko wa Bure
|
||||
<summary>Tazama mfano wa Kipande cha Juu</summary>
|
||||
```c
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
|
||||
{% hint style="success" %}
|
||||
(Maelezo haya ya sasa yanatoka kwa [https://heap-exploitation.dhavalkapil.com/diving\_into\_glibc\_heap/core\_functions](https://heap-exploitation.dhavalkapil.com/diving\_into\_glibc\_heap/core\_functions). TODO: Angalia toleo la mwisho na ulishe)
|
||||
{% endhint %}
|
||||
int main(void)
|
||||
{
|
||||
char *chunk;
|
||||
chunk = malloc(24);
|
||||
printf("Address of the chunk: %p\n", (void *)chunk);
|
||||
gets(chunk);
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
Baada ya kuikusanya na kuibugia na kipengee cha kuvunja katika opcode ya ret ya main niliona kwamba malloc ilirudisha anwani: `0xaaaaaaac12a0` na hizi ni vipande:
|
||||
```bash
|
||||
gef➤ heap chunks
|
||||
Chunk(addr=0xaaaaaaac1010, size=0x290, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
|
||||
[0x0000aaaaaaac1010 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................]
|
||||
Chunk(addr=0xaaaaaaac12a0, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
|
||||
[0x0000aaaaaaac12a0 41 41 41 41 41 41 41 00 00 00 00 00 00 00 00 00 AAAAAAA.........]
|
||||
Chunk(addr=0xaaaaaaac12c0, size=0x410, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
|
||||
[0x0000aaaaaaac12c0 41 64 64 72 65 73 73 20 6f 66 20 74 68 65 20 63 Address of the c]
|
||||
Chunk(addr=0xaaaaaaac16d0, size=0x410, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
|
||||
[0x0000aaaaaaac16d0 41 41 41 41 41 41 41 0a 00 00 00 00 00 00 00 00 AAAAAAA.........]
|
||||
Chunk(addr=0xaaaaaaac1ae0, size=0x20530, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) ← top chunk
|
||||
```
|
||||
Mahali ambapo inaweza kuonekana kwamba kipande cha juu kiko kwenye anwani `0xaaaaaaac1ae0`. Hii si mshangao kwa sababu kipande cha hivi karibuni kilichotengwa kilikuwa kwenye `0xaaaaaaac12a0` na ukubwa wa `0x410` na `0xaaaaaaac12a0 + 0x410 = 0xaaaaaaac1ae0`.\
|
||||
Pia ni sawa kuona urefu wa Kipande cha Juu kwenye kichwa chake cha kipande:
|
||||
```bash
|
||||
gef➤ x/8wx 0xaaaaaaac1ae0 - 16
|
||||
0xaaaaaaac1ad0: 0x00000000 0x00000000 0x00020531 0x00000000
|
||||
0xaaaaaaac1ae0: 0x00000000 0x00000000 0x00000000 0x00000000
|
||||
```
|
||||
</details>
|
||||
|
||||
Kazi ya mwisho ya kufuta vipande vya kumbukumbu ni `_int_free (mstate av, mchunkptr p, int have_lock)` :
|
||||
### Kumbusho la Mwisho
|
||||
|
||||
1. Angalia ikiwa `p` iko kabla ya `p + chunksize(p)` kwenye kumbukumbu (ili kuepuka kurudia). Kosa (`free(): invalid pointer`) hutupwa vinginevyo.
|
||||
2. Angalia ikiwa kipande kina ukubwa wa angalau `MINSIZE` au ni maradufu ya `MALLOC_ALIGNMENT`. Kosa (`free(): invalid size`) hutupwa vinginevyo.
|
||||
3. Ikiwa ukubwa wa kipande uko kwenye orodha ya fastbin:
|
||||
1. Angalia ikiwa ukubwa wa kipande kinachofuata uko kati ya ukubwa wa chini na wa juu (`av->system_mem`), kutupa kosa (`free(): invalid next size (fast)`) vinginevyo.
|
||||
2. Piga simu kwa `free_perturb` kwenye kipande.
|
||||
3. Weka `FASTCHUNKS_BIT` kwa `av`.
|
||||
4. Pata indeksi kwenye safu ya fastbin kulingana na ukubwa wa kipande.
|
||||
5. Angalia ikiwa juu ya beni sio kipande tunachotaka kuongeza. Vinginevyo, kutupa kosa (`double free or corruption (fasttop)`).
|
||||
6. Angalia ikiwa ukubwa wa kipande cha fastbin juu ni sawa na kipande tunachoongeza. Vinginevyo, kutupa kosa (`invalid fastbin entry (free)`).
|
||||
7. Ingiza kipande juu ya orodha ya fastbin na rudi.
|
||||
4. Ikiwa kipande sio mmapped:
|
||||
1. Angalia ikiwa kipande ni kipande cha juu au la. Ikiwa ndio, kosa (`double free or corruption (top)`) hutupwa.
|
||||
2. Angalia ikiwa kipande kinachofuata (kwa kumbukumbu) kipo ndani ya mipaka ya uwanja. Ikiwa sivyo, kosa (`double free or corruption (out)`) hutupwa.
|
||||
3. Angalia ikiwa biti ya kutumika kabla ya kipande kinachofuata (kwa kumbukumbu) imehakikishwa au la. Ikiwa sivyo, kosa (`double free or corruption (!prev)`) hutupwa.
|
||||
4. Angalia ikiwa ukubwa wa kipande kinachofuata uko kati ya ukubwa wa chini na wa juu (`av->system_mem`). Ikiwa sivyo, kosa (`free(): invalid next size (normal)`) hutupwa.
|
||||
5. Piga simu kwa `free_perturb` kwenye kipande.
|
||||
6. Ikiwa kipande cha awali (kwa kumbukumbu) hakijatumika, piga simu kwa `unlink` kwenye kipande cha awali.
|
||||
7. Ikiwa kipande kinachofuata (kwa kumbukumbu) sio kipande cha juu:
|
||||
1. Ikiwa kipande kinachofuata hakijatumika, piga simu kwa `unlink` kwenye kipande kinachofuata.
|
||||
2. Unganisha kipande na cha awali, kinachofuata (kwa kumbukumbu), ikiwa kipo huru na kiweke kwenye kichwa cha beni isiyopangwa. Kabla ya kuingiza, angalia ikiwa `unsorted_chunks(av)->fd->bk == unsorted_chunks(av)` au la. Ikiwa sivyo, kosa ("free(): corrupted unsorted chunks") hutupwa.
|
||||
8. Ikiwa kipande kinachofuata (kwa kumbukumbu) kilikuwa kipande cha juu, unganisha vipande kwa usahihi kuwa kipande kimoja cha juu.
|
||||
5. Ikiwa kipande kilikuwa mmapped, piga simu kwa `munmap_chunk`.
|
||||
Wakati malloc inapotumiwa na kipande kinagawanywa (kutoka kwenye orodha isiyofungwa au kutoka kwa kipande cha juu kwa mfano), kipande kilichoundwa kutoka kwa sehemu iliyobaki ya kipande kilichogawanywa huitwa Kumbusho la Mwisho na pointer yake hifadhiwa katika muundo wa `malloc_state`.
|
||||
|
||||
## Angalia Uthibitisho wa Usalama wa Kazi za Beni
|
||||
## Mchakato wa Kutengeneza
|
||||
|
||||
Angalia uthibitisho wa usalama uliofanywa na kazi zinazotumiwa sana kwenye beni katika:
|
||||
Angalia:
|
||||
|
||||
{% content-ref url="heap-functions-security-checks.md" %}
|
||||
[heap-functions-security-checks.md](heap-functions-security-checks.md)
|
||||
{% content-ref url="heap-memory-functions/malloc-and-sysmalloc.md" %}
|
||||
[malloc-and-sysmalloc.md](heap-memory-functions/malloc-and-sysmalloc.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
## Mchakato wa Kuachilia
|
||||
|
||||
Angalia:
|
||||
|
||||
{% content-ref url="heap-memory-functions/free.md" %}
|
||||
[free.md](heap-memory-functions/free.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
## Uchunguzi wa Usalama wa Kazi za Heap
|
||||
|
||||
Angalia ukaguzi wa usalama uliofanywa na kazi zinazotumiwa sana kwenye heap katika:
|
||||
|
||||
{% content-ref url="heap-memory-functions/heap-functions-security-checks.md" %}
|
||||
[heap-functions-security-checks.md](heap-memory-functions/heap-functions-security-checks.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
## Marejeo
|
||||
|
|
@ -194,3 +606,18 @@ Angalia uthibitisho wa usalama uliofanywa na kazi zinazotumiwa sana kwenye beni
|
|||
* [https://azeria-labs.com/heap-exploitation-part-1-understanding-the-glibc-heap-implementation/](https://azeria-labs.com/heap-exploitation-part-1-understanding-the-glibc-heap-implementation/)
|
||||
* [https://azeria-labs.com/heap-exploitation-part-2-glibc-heap-free-bins/](https://azeria-labs.com/heap-exploitation-part-2-glibc-heap-free-bins/)
|
||||
* [https://heap-exploitation.dhavalkapil.com/diving\_into\_glibc\_heap/core\_functions](https://heap-exploitation.dhavalkapil.com/diving\_into\_glibc\_heap/core\_functions)
|
||||
* [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/implementation/tcache/](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/implementation/tcache/)
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Jifunze AWS hacking kutoka sifuri hadi shujaa na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Njia nyingine za kusaidia HackTricks:
|
||||
|
||||
* Ikiwa unataka kuona **kampuni yako ikitangazwa kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA USAJILI**](https://github.com/sponsors/carlospolop)!
|
||||
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) ya kipekee
|
||||
* **Jiunge na** 💬 **kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au **kikundi cha telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Shiriki mbinu zako za udukuzi kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -1,46 +1,54 @@
|
|||
# Kujaa kwa Heap
|
||||
# Kujaza Kijito
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Jifunze AWS hacking kutoka sifuri hadi shujaa na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Jifunze kuhusu kudukua AWS kutoka sifuri hadi shujaa na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Mtaalam wa Timu Nyekundu ya AWS ya HackTricks)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Njia nyingine za kusaidia HackTricks:
|
||||
|
||||
* Ikiwa unataka kuona **kampuni yako ikitangazwa kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA USAJILI**](https://github.com/sponsors/carlospolop)!
|
||||
* Ikiwa unataka kuona **kampuni yako ikionekana kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA USAJILI**](https://github.com/sponsors/carlospolop)!
|
||||
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa kipekee wa [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Shiriki mbinu zako za udukuzi kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos za github.
|
||||
* **Shiriki mbinu zako za kudukua kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos za github.
|
||||
|
||||
</details>
|
||||
|
||||
## Taarifa Msingi
|
||||
|
||||
Kujaa kwa heap ni kama [**kujaa kwa steki**](../stack-overflow/) lakini kwenye heap. Kimsingi inamaanisha kuwa nafasi fulani ilireserviwa kwenye heap kuhifadhi data fulani na **data iliyohifadhiwa ilikuwa kubwa kuliko nafasi iliyoreserviwa.**
|
||||
Kujaza kijito ni kama [**kujaza steki**](../stack-overflow/) lakini kwenye kijito. Kimsingi inamaanisha kuwa nafasi fulani ilireserviwa kwenye kijito kuhifadhi data fulani na **data iliyohifadhiwa ilikuwa kubwa kuliko nafasi iliyoreserviwa.**
|
||||
|
||||
Kwenye kujaa kwa steki tunajua kwamba baadhi ya rejista kama kipima maelekezo au fremu ya steki itarejeshwa kutoka kwenye steki na inaweza kuwa inawezekana kuitumia vibaya. Kwenye kesi ya kujaa kwa heap, **hakuna habari nyeti iliyohifadhiwa kwa chaguo-msingi** kwenye kipande cha heap kinachoweza kujaa. Hata hivyo, inaweza kuwa habari nyeti au pointa, hivyo **umuhimu** wa udhaifu huu **unategemea** ni **data gani inaweza kubadilishwa** na jinsi mshambuliaji anaweza kutumia hii.
|
||||
Kwenye kujaza steki tunajua kwamba baadhi ya rejista kama kipima maelekezo au fremu ya steki itarejeshwa kutoka kwenye steki na inaweza kuwa inawezekana kuitumia vibaya hii. Kwenye kujaza kijito, **hakuna habari nyeti iliyohifadhiwa kwa chaguo-msingi** kwenye kipande cha kijito kinachoweza kujazwa. Hata hivyo, inaweza kuwa habari nyeti au viashiria, hivyo **umuhimu** wa udhaifu huu **unategemea** ni **data gani inaweza kubadilishwa** na jinsi mshambuliaji anaweza kutumia hii.
|
||||
|
||||
{% hint style="success" %}
|
||||
Ili kupata vishikizo vya kujaa unaweza kutumia mifano ile ile kama kwenye [**kujaa kwa steki**](../stack-overflow/#kupata-vishikizo-vya-kujaa-kwa-steki).
|
||||
Ili kupata vishikizo vya kujaza unaweza kutumia mifano ile ile kama kwenye [**kujaza steki**](../stack-overflow/#kupata-vishikizo-vya-kujaza-steki).
|
||||
{% endhint %}
|
||||
|
||||
### Kujaa kwa Steki dhidi ya Kujaa kwa Heap
|
||||
### Kujaza Staki vs Kujaza Kijito
|
||||
|
||||
Kwenye kujaa kwa steki, upangaji na data ambayo itakuwepo kwenye steki wakati udhaifu unaweza kuzinduliwa ni ya kuaminika kwa kiasi kikubwa. Hii ni kwa sababu steki ni mwendelezo, ikiongezeka daima kwenye kumbukumbu inayogongana, kwenye **maeneo maalum ya kukimbia kwa programu kumbukumbu ya steki kawaida inahifadhi aina sawa ya data** na ina muundo maalum na pointa fulani mwishoni mwa sehemu ya steki inayotumiwa na kila kazi.
|
||||
Kwenye kujaza steki, upangaji na data ambayo itakuwepo kwenye steki wakati udhaifu unaweza kuzinduliwa ni wa kuaminika kwa kiasi kikubwa. Hii ni kwa sababu steki ni mstari, daima inaongezeka kwa kugongana kwenye kumbukumbu, kwenye **maeneo maalum ya kukimbia kwa programu kumbukumbu ya steki kawaida inahifadhi aina sawa ya data** na ina muundo maalum na viashiria fulani mwishoni mwa sehemu ya steki inayotumiwa na kila kazi.
|
||||
|
||||
Hata hivyo, kwenye kesi ya kujaa kwa heap, kwa sababu kumbukumbu inayotumiwa si mwendelezo lakini **vipande vilivyotengwa kawaida viko kwenye nafasi tofauti za kumbukumbu** (si moja karibu na nyingine) kwa sababu ya **makandokando na maeneo** yanayotenganisha alokesheni kwa ukubwa na kwa sababu **kumbukumbu iliyotolewa awali inatumika** kabla ya kutenga vipande vipya. Ni **ngumu kujua kitu ambacho kitagongana na kile kilichovumbuliwa** kuwa katika hatari ya kujaa kwa heap. Kwa hivyo, unapopata kujaa kwa heap, ni muhimu kupata **njia ya kuaminika ya kufanya kitu kilichotaka kiwe kifuatacho kwenye kumbukumbu** kutoka kwa kile kinachoweza kujaa.
|
||||
Hata hivyo, kwenye kujaza kijito, kwa sababu kumbukumbu inayotumiwa si mstari lakini **vipande vilivyotengwa kawaida viko kwenye nafasi tofauti za kumbukumbu** (si moja karibu na nyingine) kwa sababu ya **makorongo na maeneo** yanayotenganisha alokesheni kwa ukubwa na kwa sababu **kumbukumbu iliyotolewa awali inatumika** kabla ya kutenga vipande vipya. Ni **ngumu kujua kitu ambacho kitagongana na kile kilichovunjika** kwa kujaza kijito. Kwa hivyo, unapopata kujaza kijito, ni muhimu kupata **njia ya kuaminika ya kufanya kitu kilichotaka kiwe karibu kwenye kumbukumbu** kutoka kile kinachoweza kujazwa.
|
||||
|
||||
Moja ya mbinu zinazotumika kwa hili ni **Kupamba kwa Heap** ambayo hutumiwa kwa mfano [**katika chapisho hili**](https://azeria-labs.com/grooming-the-ios-kernel-heap/). Katika chapisho hilo inaelezea jinsi wakati wa kernel wa iOS unapokosa kumbukumbu ya kuhifadhi vipande vya kumbukumbu, inapanua kwa ukurasa wa kernel, na ukurasa huu unagawanywa katika vipande vya ukubwa uliotarajiwa ambavyo vitatumika kwa mpangilio (hadi toleo la iOS 9.2, kisha vipande hivi vinatumika kwa njia iliyochanganyikiwa ili kufanya ugumu wa kudukua mashambulizi haya).
|
||||
Moja ya mbinu zinazotumika kwa hili ni **Kupamba Kijito** ambayo hutumiwa kwa mfano [**kwenye chapisho hili**](https://azeria-labs.com/grooming-the-ios-kernel-heap/). Kwenye chapisho inaelezea jinsi wakati wa kernel wa iOS unapokosa kumbukumbu ya kuhifadhi vipande vya kumbukumbu, inapanua kwa ukurasa wa kernel, na ukurasa huu unagawanywa katika vipande vya ukubwa uliotarajiwa ambavyo vitatumika kwa mpangilio (hadi toleo la iOS 9.2, kisha vipande hivi vinatumika kwa njia iliyochanganywa ili kufanya ugumu wa kudukua mashambulizi haya).
|
||||
|
||||
Kwa hivyo, katika chapisho la awali ambapo kujaa kwa heap inatokea, ili kulazimisha kitu kilichovuja kugongana na mpangilio wa mwathiriwa, **`kallocs` kadhaa zinalazimishwa na nyuzi kadhaa kujaribu kuhakikisha kuwa vipande vyote vilivyotolewa vimejazwa na ukurasa mpya unatengenezwa**.
|
||||
Kwa hivyo, kwenye chapisho la awali ambapo kujaza kijito kinatokea, ili kulazimisha kitu kilichovunjika kigongane na mpangaji, **`kallocs` kadhaa zinalazimishwa na nyuzi kadhaa kujaribu kuhakikisha kuwa vipande vyote vilivyotolewa vimejazwa na ukurasa mpya unatengenezwa**.
|
||||
|
||||
Ili kulazimisha kujazwa huku na vitu vya ukubwa maalum, **mgawanyo wa nje unaohusishwa na mlango wa iOS mach** ni mgombea bora. Kwa kutengeneza ukubwa wa ujumbe, inawezekana kubainisha kwa usahihi ukubwa wa alokesheni ya `kalloc` na wakati mlango wa mach unaohusika unaharibiwa, alokesheni inayohusiana itaachiliwa mara moja kurudi kwa `kfree`.
|
||||
Ili kulazimisha kujaza hii na vitu vya ukubwa maalum, **mgawanyo wa nje unaohusishwa na mlango wa iOS mach** ni mgombea bora. Kwa kutengeneza ukubwa wa ujumbe, inawezekana kubainisha ukubwa sahihi wa alokesheni ya `kalloc` na wakati mlango wa mach unaohusika unaharibiwa, alokesheni inayohusiana itaachiliwa mara moja kurudi kwa `kfree`.
|
||||
|
||||
Kisha, baadhi ya hizi nafasi zinaweza **kuachiliwa**. **Orodha ya kufungua ya `kalloc.4096` inaachilia vipengele kwa mpangilio wa mwisho kuingia kwanza**, ambayo kimsingi inamaanisha kwamba ikiwa baadhi ya nafasi zinaachiliwa na shambulizi linajaribu kutoa vitu vingi waathiriwa wakati ikijaribu kutenga kitu kinachoweza kujaa, ni uwezekano kwamba kitu hiki kitafuatwa na kitu cha mwathiriwa.
|
||||
Kisha, baadhi ya hizi nafasi zinaweza **kuachiliwa**. **Orodha ya kufungua ya `kalloc.4096` inaachilia vipengele kwa mpangilio wa mwisho kuingia kwanza**, ambayo kimsingi inamaanisha kwamba ikiwa baadhi ya nafasi zimeachiliwa na shambulizi linajaribu kuweka vitu vingi waathiriwa wakati ikijaribu kutenga kitu kilichovunjika, ni uwezekano kwamba kitu hiki kitafuatwa na kitu cha waathiriwa.
|
||||
|
||||
## Mfano wa ARM64
|
||||
### Mfano wa libc
|
||||
|
||||
Kwenye ukurasa [https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/](https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/) unaweza kupata mfano wa kujaa kwa heap ambapo amri itakayotekelezwa imehifadhiwa kwenye kipande kinachofuata kutoka kwa kipande kilichojaa. Kwa hivyo, inawezekana kubadilisha amri itakayotekelezwa kwa kuibadilisha na shambulizi rahisi kama:
|
||||
[**Kwenye ukurasa huu**](https://guyinatuxedo.github.io/27-edit\_free\_chunk/heap\_consolidation\_explanation/index.html) inawezekana kupata uigizaji wa kujaza kijito wa msingi unaonyesha jinsi ya kubadilisha biti ya awali inayotumiwa ya kipande kinachofuata na nafasi ya ukubwa wa awali inawezekana **kuunganisha kipande kilichotumiwa** (kwa kufanya ionekane kama haijatumika) na **kisha kutenga tena** ikiwa inawezekana kubadilisha data inayotumiwa kwenye kielekezi tofauti pia.
|
||||
|
||||
Mfano mwingine kutoka [**protostar kijito 0**](https://guyinatuxedo.github.io/24-heap\_overflow/protostar\_heap0/index.html) unaonyesha mfano wa msingi sana wa CTF ambapo **kujaza kijito** inaweza kutumiwa kuita kazi ya mshindi kupata bendera.
|
||||
|
||||
Kwenye [**protostar kijito 1**](https://guyinatuxedo.github.io/24-heap\_overflow/protostar\_heap1/index.html) mfano inawezekana kuona jinsi ya kutumia kujaza kijito niwezekane **kubadilisha kwenye kipande karibu anwani** ambapo **data ya kupendelea kutoka kwa mtumiaji** itaandikwa.
|
||||
|
||||
### Mfano wa ARM64
|
||||
|
||||
Kwenye ukurasa [https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/](https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/) unaweza kupata mfano wa kujaza kijito ambapo amri itakayotekelezwa imehifadhiwa kwenye kipande kinachofuata kutoka kwenye kipande kilichojazwa. Kwa hivyo, inawezekana kubadilisha amri inayotekelezwa kwa kuibadilisha kwa shambulio rahisi kama:
|
||||
```bash
|
||||
python3 -c 'print("/"*0x400+"/bin/ls\x00")' > hax.txt
|
||||
```
|
||||
|
|
@ -54,6 +62,6 @@ Njia nyingine za kusaidia HackTricks:
|
|||
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) ya kipekee
|
||||
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Shiriki mbinu zako za kuhack kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos za github.
|
||||
* **Shiriki mbinu zako za udukuzi kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos za github.
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ Njia nyingine za kusaidia HackTricks:
|
|||
|
||||
## Taarifa Msingi
|
||||
|
||||
Wakati shambulio hili lilipogunduliwa kwa kiasi kikubwa iliruhusu WWW (Andika Nini Wapi), hata hivyo, **uchunguzi fulani uliongezwa** ukifanya toleo jipya la shambulio kuwa la kuvutia zaidi na **ngumu zaidi na **hakinafaidishi**.
|
||||
Wakati shambulio hili lilipogunduliwa kwa kiasi kikubwa liliruhusu WWW (Andika Nini Wapi), hata hivyo, baadhi ya **uchunguzi uliongezwa** kufanya toleo jipya la shambulio liwe la kuvutia zaidi na **ngumu zaidi na **isiyofaa**.
|
||||
|
||||
### Mfano wa Kanuni:
|
||||
|
||||
|
|
@ -89,51 +89,56 @@ return 0;
|
|||
```
|
||||
</details>
|
||||
|
||||
* Shambulizi halifanyi kazi ikiwa tcaches zinatumika
|
||||
* Shambulizi halifanyi kazi ikiwa tcaches zinatumika (baada ya 2.26)
|
||||
|
||||
### Lengo
|
||||
|
||||
* Badilisha kipande cha kidole kwa kipande kwenye stakishi ili ielekeze kwenye stakishi ili iwezekane kubadilisha maudhui ya stakishi kwa kuandika kwenye kipande
|
||||
* Badilisha kipande cha kidole kwenye steki ili kielekee steki hivyo ni rahisi kubadilisha maudhui ya steki kwa kuandika kwenye kipande
|
||||
|
||||
### Mahitaji
|
||||
|
||||
* Udhibiti fulani katika kumbukumbu (k.m. stakishi) ili uweze kuunda vikundi vichache kwa kutoa thamani kwa baadhi ya sifa.
|
||||
* Kuvuja kwa stakishi ili kuweza kuweka viashiria vya kipande bandia.
|
||||
* Udhibiti fulani kwenye kumbukumbu (k.m. steki) ili uweze kuunda vikundi vya thamani kwa baadhi ya sifa.
|
||||
* Kuvuja kwa steki ili kuweza kuweka viashiria vya kipande bandia.
|
||||
|
||||
### Shambulizi
|
||||
|
||||
* Kuna vikundi vichache (kikundi1 na kikundi2)
|
||||
* Kuna vikundi viwili (kikundi1 na kikundi2)
|
||||
* Mshambuliaji anadhibiti maudhui ya kikundi1 na vichwa vya kikundi2.
|
||||
* Katika kikundi1 mshambuliaji anaunda muundo wa kipande bandia:
|
||||
* Kwenye kikundi1 mshambuliaji anaunda muundo wa kipande bandia:
|
||||
* Ili kuepuka ulinzi anahakikisha kuwa uga `ukubwa` ni sahihi ili kuepuka kosa: `ukubwa ulioharibika dhidi ya ukubwa uliopita wakati wa kufanya kazi`
|
||||
* na viashiria `fd` na `bk` vya kipande bandia vinawaelekeza kwenye eneo ambapo kipande1 pointer kimehifadhiwa kwa vipimo vya -3 na -2 mtawalia hivyo `kikundi_bandia->fd->bk` na `kikundi_bandia->bk->fd` vinawaelekeza kwenye nafasi kwenye kumbukumbu (stakishi) ambapo anwani halisi ya kikundi1 iko:
|
||||
* na maeneo `fd` na `bk` ya kipande bandia yanalingana na mahali pointer wa kikundi1 unahifadhiwa kwa vipimo vya -3 na -2 mtawalia hivyo `kikundi_bandia->fd->bk` na `kikundi_bandia->bk->fd` inaelekeza kwenye nafasi kwenye kumbukumbu (steki) ambapo anwani halisi ya kikundi1 inapatikana:
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (1245).png" alt=""><figcaption><p><a href="https://heap-exploitation.dhavalkapil.com/attacks/unlink_exploit">https://heap-exploitation.dhavalkapil.com/attacks/unlink_exploit</a></p></figcaption></figure>
|
||||
|
||||
* Vichwa vya kikundi2 vinabadilishwa kuonyesha kuwa kipande kilichopita hakijatumika na kwamba ukubwa ni ukubwa wa kipande bandia kilichomo.
|
||||
* Vichwa vya kikundi2 vinabadilishwa kuonyesha kuwa kipande kilichopita hakijatumika na ukubwa ni ukubwa wa kipande bandia kilichomo.
|
||||
* Wakati kipande cha pili kinapofutwa basi kipande bandia hiki kinatenganishwa kutokea:
|
||||
* `kikundi_bandia->fd->bk` = `kikundi_bandia->bk`
|
||||
* `kikundi_bandia->bk->fd` = `kikundi_bandia->fd`
|
||||
* Awali ilifanywa kuwa `kikundi_bandia->fd->bk` na `kikundi_bandia->fd->bk` vinawaelekeza kwenye eneo moja (eneo kwenye stakishi ambapo `kikundi1` ilihifadhiwa, hivyo ilikuwa orodha halali). Kwa kuwa **zote zinaelekeza kwenye eneo moja** ni ile ya mwisho (`kikundi_bandia->bk->fd = kikundi_bandia->fd`) itakayochukua **athari**.
|
||||
* Hii ita**badilisha anwani ya kipande1 kwenye stakishi kwenda kwenye anwani (au herufi) iliyohifadhiwa vipimo 3 kabla kwenye stakishi**.
|
||||
* Hivyo, ikiwa mshambuliaji anaweza kudhibiti tena maudhui ya kikundi1, ataweza **kuandika ndani ya stakishi** akiweza kubadilisha anwani ya kurudi akiruka kifaa cha ulinzi na kubadilisha thamani na viashiria vya mchanganyiko wa ndani. Hata kubadilisha tena anwani ya kikundi1 iliyohifadhiwa kwenye stakishi kwenda eneo tofauti ambapo ikiwa mshambuliaji anaweza kudhibiti tena maudhui ya kikundi1 ataweza kuandika popote.
|
||||
* Awali ilifanywa kuwa `kikundi_bandia->fd->bk` na `kikundi_bandia->fd->bk` inaelekeza kwenye mahali sawa (eneo kwenye steki ambapo `kikundi1` ilihifadhiwa, hivyo ilikuwa orodha halali). Kwa kuwa **zote zinaelekeza kwenye mahali sawa** ni ile ya mwisho (`kikundi_bandia->bk->fd = kikundi_bandia->fd`) itakayochukua **athari**.
|
||||
* Hii ita**badilisha pointer wa kikundi1 kwenye steki kwenda kwenye anwani (au herufi) iliyohifadhiwa nyuma ya anwani 3 kwenye steki**.
|
||||
* Hivyo, ikiwa mshambuliaji anaweza kudhibiti maudhui ya kikundi1 tena, ataweza **kuandika ndani ya steki** na uwezo wa kubadilisha anwani ya kurudi akiruka canary na kubadilisha thamani na viashiria vya mchanganyiko wa ndani. Hata kubadilisha tena anwani ya kikundi1 iliyohifadhiwa kwenye steki kwenda mahali tofauti ambapo ikiwa mshambuliaji anaweza kudhibiti tena maudhui ya kikundi1 ataweza kuandika mahali popote.
|
||||
* Tafadhali elewa kuwa hili lilikuwa linawezekana kwa sababu **anwani zilizohifadhiwa ziko kwenye steki**. Hatari na unyonyaji inaweza kutegemea **anwani za kipande bandia zinahifadhiwa wapi**.
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (1246).png" alt=""><figcaption><p><a href="https://heap-exploitation.dhavalkapil.com/attacks/unlink_exploit">https://heap-exploitation.dhavalkapil.com/attacks/unlink_exploit</a></p></figcaption></figure>
|
||||
|
||||
## Marejeo
|
||||
|
||||
* [https://heap-exploitation.dhavalkapil.com/attacks/unlink\_exploit](https://heap-exploitation.dhavalkapil.com/attacks/unlink\_exploit)
|
||||
* Ingawa itakuwa ajabu kupata shambulizi la unlink hata katika CTF hapa kuna baadhi ya maandishi ambapo shambulizi hili lilikuwa limefanyiwa:
|
||||
* Mfano wa CTF: [https://guyinatuxedo.github.io/30-unlink/hitcon14\_stkof/index.html](https://guyinatuxedo.github.io/30-unlink/hitcon14\_stkof/index.html)
|
||||
* Katika mfano huu, badala ya steki kuna safu ya anwani za malloc'ed. Shambulizi la unlink linatekelezwa ili kuweza kuweka kipande hapa, hivyo kuweza kudhibiti viashiria vya safu ya anwani za malloc'ed. Kisha, kuna utendaji mwingine unaoruhusu kubadilisha maudhui ya vikundi katika anwani hizi, ambayo inaruhusu kuashiria anwani kwa GOT, kubadilisha anwani za kazi kupata vuvuli na RCE.
|
||||
*
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Jifunze kuhusu kuvamia AWS kutoka sifuri hadi shujaa na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Jifunze AWS hacking kutoka sifuri hadi shujaa na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Njia nyingine za kusaidia HackTricks:
|
||||
|
||||
* Ikiwa unataka kuona **kampuni yako ikitangazwa kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA KUJIUNGA**](https://github.com/sponsors/carlospolop)!
|
||||
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) ya kipekee
|
||||
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **fuata** sisi kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Shiriki mbinu zako za kuvamia kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
|
||||
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Shiriki mbinu zako za kuhack kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
# Matumizi Baada ya Kufuta
|
||||
# Matumizi Baada ya Kuachiliwa
|
||||
|
||||
<details>
|
||||
|
||||
|
|
@ -6,9 +6,9 @@
|
|||
|
||||
Njia nyingine za kusaidia HackTricks:
|
||||
|
||||
* Ikiwa unataka kuona **kampuni yako ikitangazwa kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA USAJILI**](https://github.com/sponsors/carlospolop)!
|
||||
* Ikiwa unataka kuona **kampuni yako ikionekana kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA KUJIUNGA**](https://github.com/sponsors/carlospolop)!
|
||||
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) za kipekee
|
||||
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa kipekee wa [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Shiriki mbinu zako za kudukua kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos za github.
|
||||
|
||||
|
|
@ -16,30 +16,28 @@ Njia nyingine za kusaidia HackTricks:
|
|||
|
||||
## Taarifa Msingi
|
||||
|
||||
Kama jina linavyosema, udhaifu huu hutokea wakati programu **inahifadhi nafasi fulani** kwenye heap kwa ajili ya kitu, **inaandika** habari fulani hapo, **inaifuta** kwa sababu labda haifai tena na kisha **kuipata tena**.
|
||||
Kama jina linavyosema, udhaifu huu hutokea wakati programu **inahifadhi nafasi fulani** kwenye heap kwa ajili ya kitu, **inaandika** habari fulani hapo, **inaachilia** kwa sababu inaonekana haifai tena na kisha **kuipata tena**.
|
||||
|
||||
Tatizo hapa ni kwamba si kinyume cha sheria (hakutakuwa na makosa) wakati **nafasi iliyofutwa inapopatikana**. Kwa hivyo, ikiwa programu (au muhusika) itaweza **kuweka data za kubahatisha** kwenye nafasi iliyofutwa, wakati nafasi iliyofutwa inapopatikana kutoka kwa kidude cha awali **data hiyo itakuwa imeandikwa upya** ikisababisha **udhaifu ambao utategemea hisia za data** ambayo ilihifadhiwa awali (ikiwa ilikuwa kidude cha kazi ambacho kingeitwa, muhusika angeweza kukidhibiti).
|
||||
Tatizo hapa ni kwamba si kinyume cha sheria (hakutakuwa na makosa) wakati **nafasi iliyofutwa inapopatikana**. Kwa hivyo, ikiwa programu (au muhusika) itaweza **kuweka data za kubahatisha** kwenye nafasi iliyofutwa, wakati nafasi iliyofutwa inapopatikana kutoka kwa kidude cha awali **data hiyo itakuwa imeandikwa upya** kusababisha **udhaifu ambao utategemea hisia za data** ambayo ilihifadhiwa awali (ikiwa ilikuwa kidude cha kazi ambacho kingeitwa, muhusika anaweza kukiendesha).
|
||||
|
||||
### Shambulio la Kwanza la Kufaa
|
||||
### Shambulio la Kwanza la Kufit
|
||||
|
||||
Shambulio la kwanza la kufaa linalenga njia ambayo baadhi ya wapangaji wa kumbukumbu, kama vile glibc, wanavyosimamia kumbukumbu iliyofutwa. Unapofuta kibodi cha kumbukumbu, inaongezwa kwenye orodha, na maombi mapya ya kumbukumbu yanachukua kutoka kwenye orodha hiyo mwishoni. Wadukuzi wanaweza kutumia tabia hii kudhibiti **ni vikundi vipi vya kumbukumbu vinavyotumika tena, wakipata udhibiti juu yao**. Hii inaweza kusababisha masuala ya "matumizi baada ya kufuta," ambapo muhusika anaweza **kubadilisha maudhui ya kumbukumbu inayopewa upya**, ikiumba hatari ya usalama.\
|
||||
Shambulio la kwanza la kufit linawalenga njia ambazo baadhi ya wapangaji wa kumbukumbu, kama vile glibc, wanavyosimamia kumbukumbu iliyofutwa. Unapofuta kibodi cha kumbukumbu, inaongezwa kwenye orodha, na maombi mapya ya kumbukumbu yanachukua kutoka kwenye orodha hiyo mwishoni. Wadukuzi wanaweza kutumia tabia hii kudhibiti **ni kumbukumbu zipi zinazotumika tena, hivyo kupata udhibiti juu yake**. Hii inaweza kusababisha masuala ya "matumizi baada ya kuachiliwa", ambapo muhusika anaweza **kubadilisha maudhui ya kumbukumbu inayopewa upya**, kuunda hatari ya usalama.\
|
||||
Angalia maelezo zaidi katika:
|
||||
|
||||
{% content-ref url="first-fit.md" %}
|
||||
[first-fit.md](first-fit.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
##
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Jifunze kuhusu kudukua AWS kutoka sifuri hadi shujaa na</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Mtaalam wa Timu Nyekundu ya AWS ya HackTricks)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Njia nyingine za kusaidia HackTricks:
|
||||
|
||||
* Ikiwa unataka kuona **kampuni yako ikitangazwa kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA USAJILI**](https://github.com/sponsors/carlospolop)!
|
||||
* Ikiwa unataka kuona **kampuni yako ikionekana kwenye HackTricks** au **kupakua HackTricks kwa PDF** Angalia [**MIPANGO YA KUJIUNGA**](https://github.com/sponsors/carlospolop)!
|
||||
* Pata [**bidhaa rasmi za PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa [**NFTs**](https://opensea.io/collection/the-peass-family) za kipekee
|
||||
* Gundua [**Familia ya PEASS**](https://opensea.io/collection/the-peass-family), mkusanyiko wetu wa kipekee wa [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Jiunge na** 💬 [**Kikundi cha Discord**](https://discord.gg/hRep4RUj7f) au kikundi cha [**telegram**](https://t.me/peass) au **tufuate** kwenye **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Shiriki mbinu zako za kudukua kwa kuwasilisha PRs kwa** [**HackTricks**](https://github.com/carlospolop/hacktricks) na [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos za github.
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue