[HWSW]

Inkább érdekessége, mint veszélyessége miatt érdemel figyelemre a Google Project Zero mérnökei által nemrég nyilvánosságra hozott, Rowhammer névre keresztelt sérülékenység. A hiba kivételesen nem szoftveres, hanem hardveres eredetû: a DDR3 memóriamodulok fizikai felépítésének tökéletlenségét kihasználva egy sort néhány ezredmásodperc alatt több százezres nagyságrendben végrehajtott memóriahozzáférési mûvelettel bombázva a szomszédos sorban megfordítható egy bit. Az eredmény: korlátlan memóriahozzáférés.
https://www.hwsw.hu/hirek/53685/rowhammer-memoriakorrupcio-dram-bit-bitforditas-biztonsag-linux-kernel-x86.html

[ricsip]

..vagy korlátozni kell memória kontrollerbõl ugyanazon címre történõ próbálkozások ismétlésének max. számát adott idõegységen belül.

[bogdan]

"A zaklatást a szomszéd szívja meg"?
gratulalok!

"Az ECC-n kívül további védelmet jelentenek a virtuális gépek,"?
a cikkben epp az ellenkezoje van leirva!

[Meister]

@ricsip: Pontosan. Az eredeti dokumentumban írják is, hogy az egyik notebookon egy BIOS-frissítést követõen már nem tudták reprodukálni a problémát, viszont a tesztkódjuk a korábbi idõ többszöröse alatt futott csak le. A kutatók feltételezik, hogy a frissítés átállította a RAM-elérés idõzítését.

['Geri']

nem tudom, hogy én rontok -e el valamit, vagy a gépem nem érintett, de én nem kapok semmilyen hibát.

:~/Desktop # g++ bitfliptest.c -o bitfliptest -O0
:~/Desktop # ./bitfliptest

#include <stdio.h>
#include <stdlib.h>


inline void clflush( void *p){  asm  ("clflush (%0)" :: "r"(p));}

int main(){ 
  if(sizeof(void*)!=8){
	printf("64bit only\n");
	exit(0);
  }
  printf("bitfliptest by Geri\n");
   unsigned long long * m=(  unsigned long long * )malloc(1024*1024*128*sizeof( unsigned long long ));
  for(unsigned long long sz=0;sz<100LL;sz++){
	if(1){
  	for(int i=0;i<1024*1024*128;i++) m[i]=0;
  	for(int k=0;k<10;k++){
	long long r1=(rand()%1024*1024*128)&4;
	long long r2=(rand()%1024*1024*128)&4;
	while((r1&4)!=0) r1=(rand()%1024*1024*128)&4;
	while((r2&4)!=0) r2=(rand()%1024*1024*128)&4;
	for(long long i=0;i<2061587ULL;i++){
	  unsigned long long *m1cs=&m[r1];
	  unsigned long long *m2cs=&m[r2];
	  *m1cs=++i;
	  *m2cs=++i;
	  clflush(m1cs);clflush(m2cs);
	  *m1cs=++i;
	  *m2cs=++i;
	  clflush(m1cs);clflush(m2cs);
	  *m1cs=++i;
	  *m2cs=++i;
	  clflush(m1cs);clflush(m2cs);
	  *m1cs=++i;
	  *m2cs=++i;
	  clflush(m1cs);clflush(m2cs);
	  *m1cs=++i;
	  *m2cs=++i;
	  clflush(m1cs);clflush(m2cs);
	  *m1cs=++i;
	  *m2cs=++i;
	  clflush(m1cs);clflush(m2cs);
	  *m1cs=++i;
	  *m2cs=++i;
	  clflush(m1cs);clflush(m2cs);
	  *m1cs=++i;
	  *m2cs=++i;
	  clflush(m1cs);clflush(m2cs);
	  *m1cs=++i;
	  *m2cs=++i;
	  clflush(m1cs);clflush(m2cs);
	  *m1cs=++i;
	  *m2cs=++i;
	  clflush(m1cs);clflush(m2cs);
	  *m1cs=0;
	  *m2cs=0;
	}
  	}
  	long long t=0;
  	for(long long i=0;i<1024ULL*1024ULL*128ULL;i++){
	t+=m[i];
  	}
  	if(t!=0){
	printf("vulnerable! %d\n", (int)t);
	exit(0);
  	}else{
	printf("%d%% ok\n", (int)sz);
  	}
	}
  }
  printf("not vulnerable\n");
}

 

persze valószínűleg csak az én figyelmemet kerülte el valami.

Szerkesztette: 'Geri' 2015. 03. 13. 03:45 -kor

[bogdan]

talan mert megsem vagy annyira jo programozo..? ;-)

toltsd le szepen a cikkben hivatkozott kutatok programjat, oszt azzal probalkozz!

[philcsy]

Geri:
Mit fostál már ide te programozók gyöngye? while((r1&4)!=0) r1=(rand()%1024*1024*128)&4;
Sejted mit csinál ez?
r1 értéke 0 vagy 4. 4 esetében a ciklus újrakezdődik, 0-nál tovább megy. Úgy is fogalmazhatok, hogy ez a kód egy nagy 0.
Tanulj már meg programozni, ha már ennyire vered magadat a semmire.

[vhunor]

@Meister: Nem éppen. Reprodukálták, csak jóval több idõ alatt.

"We initially thought this BIOS update had fixed the issue. However, after almost 40 minutes of sequentially hammering memory, some locations exhibited bit flips. We conjecture that the BIOS update increased the DRAM refresh rate, making it harder but not impossible to cause enough disturbance between DRAM refresh cycles."

[Gabibácsi]

Geri, programozz inkább abakuszt

[NancsiBacsi]

@philcsy: Hagyjad már - látványosan akar nullát dobni "véletlenül"

[bogdan]

philcsy: ezen kivul meg nem inicializalja a pszeudorandom generatort egy srand()-al, tovabba nem veszi figyelembe, hogy a RAND_MAX nem szokott 128 ezer lenni, hanem inkabb 32 ezer..

no meg persze az a while ciklus hatul tesztelos kene, hogy legyen. felesleges ketszer leirni ugyanazt..

meg tudnam, hogy ha mar c programot ir, akkor miert g++ -al forditja vajon?

meg minek hasznal egy boszme nagy m[] tombot, ha csak ket elemet birizgal belole??

a for cikluson beluli rengeteg "++i"-rol mar nem is beszelve. hogy nez az mar ki? miert nem while akkor mar? kell a vegere az az i leptetes?

es csak most vettem eszre a gyonyoruseges "if(1)"-t az elejen! epic..

na, hany hibat talalunk meg a programban..?

Szerkesztette: bogdan 2015. 03. 13. 13:06 -kor

['Geri']

éjjel 3kor írtam, majd mindjárt javítom.

amúgy felesleges nyálat verni, mert ha olyan okosak lennétek, akkor ti írnátok testcaset, de persze ez nem így van.

[philcsy]

bogdan:
Azért g++, mert ez kőkemény C++ kód! A for cikluson belül definiálja a ciklusváltozót.

Szerkesztette: philcsy 2015. 03. 13. 16:02 -kor

['Geri']

#include <stdio.h>
#include <stdlib.h>


inline void clflush( void *p){  asm  ("clflush (%0)" :: "r"(p));}

int main(){ 
  if(sizeof(void*)!=8){
	printf("64bit only\n");
	exit(0);
  }
  printf("bitfliptest by Geri\n");
   unsigned long long * m=(  unsigned long long * )malloc(1024+1024*1024*128*sizeof( unsigned long long ));
  for(unsigned long long sz=0;sz<100LL;sz++){
	if(1){
  	for(int i=0;i<1024*1024*128;i++) m[i]=0;
  	for(int k=0;k<10;k++){
	long long r1=(rand()%1024*1024*128);
	long long r2=(rand()%1024*1024*128);
	while((r1&4)!=0) r1=(rand()%1024*1024*128);
	while((r2&4)!=0) r2=(rand()%1024*1024*128);
	for(long long i=0;i<2061587ULL;i++){
	  unsigned long long *m1cs=&m[r1];
	  unsigned long long *m2cs=&m[r2];
	  *m1cs=++i;
	  *m2cs=++i;
	  clflush(m1cs);clflush(m2cs);
	  *m1cs=++i;
	  *m2cs=++i;
	  clflush(m1cs);clflush(m2cs);
	  *m1cs=++i;
	  *m2cs=++i;
	  clflush(m1cs);clflush(m2cs);
	  *m1cs=++i;
	  *m2cs=++i;
	  clflush(m1cs);clflush(m2cs);
	  *m1cs=++i;
	  *m2cs=++i;
	  clflush(m1cs);clflush(m2cs);
	  *m1cs=++i;
	  *m2cs=++i;
	  clflush(m1cs);clflush(m2cs);
	  *m1cs=++i;
	  *m2cs=++i;
	  clflush(m1cs);clflush(m2cs);
	  *m1cs=++i;
	  *m2cs=++i;
	  clflush(m1cs);clflush(m2cs);
	  *m1cs=++i;
	  *m2cs=++i;
	  clflush(m1cs);clflush(m2cs);
	  *m1cs=++i;
	  *m2cs=++i;
	  clflush(m1cs);clflush(m2cs);
	  *m1cs=0;
	  *m2cs=0;
	}
  	}
  	long long t=0;
  	for(long long i=0;i<1024ULL*1024ULL*128ULL;i++){
	t+=m[i];
  	}
  	if(t!=0){
	printf("vulnerable! %d\n", (int)t);
	exit(0);
  	}else{
	printf("%d%% ok\n", (int)sz);
  	}
	}
  }
  printf("not vulnerable\n");
}

Szerkesztette: 'Geri' 2015. 03. 13. 15:48 -kor

['Geri']

Idézet: bogdan - Dátum: 2015. 03. 13. 13:00

na, hany hibat talalunk meg a programban..?

eddig egy volt benne, és azt philcsy találta meg. az, hogy valamit nem értesz, az még nem hiba.

[philcsy]

Még mindig nem tudsz programozni!

while((r1&4)!=0)
Ennek mi értelme?

unsigned long long *m1cs=&m[r1];
És ennek a for cikluson belül, mikor r1 nem változik?

Ez gépelés, nem programozás!

['Geri']

hogy 32 bájtosával alignálva legyen. elvileg így vagyunk a memory slotok határán.

[NancsiBacsi]

@"Geri": Te figyelj má, ne erõltesd ezt a ciklus dolgot az r1, r2-vel, mert egyrészt nem megy neked, másrészt ránézni is rossz. Most ha 1000-el osztható kéne, akkor bekúrnál oda egy ciklust, ami átlagban 1000x fut le, te optimalizálóbajnok? Hát ezért kell neked 1024 magos processzor.
Inkább így csináld:
A. Dobjál egy számot, aztán tolj rá egy and bitmûveletet 0x7f...fc-vel (megfelelõ számú f betû középen), és akkor pont olyan véletlen számot kapsz, ami osztható 4-el.
B. Dobjál egy 4xkisebb számot, és szorozd meg 4-el (ha bitmûvelet buzi vagy, told el balra 2-vel) - így ugyancsak egy 4-el osztható véletlen számot kapsz.

Nem attól fogsz tudni programozni, hogy C-ben meg ASM-ben tolod, hanem attól, hogy olyan kódot gyártasz, amitõl nem hányja el magát aki ránéz.

['Geri']

nem optimizálgatunk, hanem a hibát próbáljuk reprodukálni. biztos meg lehetne 5x ennyi sorból írni racionálisabban, csak most ez nem erről szól. szüval ne a nyáladat verd a megmosolyogtató féltudásodra, hanem vagy segíts reprodukálni a hibajelenséget amiről a cikk szól, vagy fogd be a pofádat.

[philcsy]

long long r1=(rand()%1024*1024*128);
while((r1&4)!=0) r1=(rand()%1024*1024*128);

A harmadik bitet maszkolod, és vársz amíg nem lesz 0. Ennek nincs semmi értelme. Ha ezt szeretnéd, akkor állítsd egyből 0-ra.
long long r1=(rand()%1024*1024*128)&~4;

Az eredmény pedig a következő számok egyike 0-3,8-11,16-19,... Ami szerintem nem az amit te akarsz...

Szerkesztette: philcsy 2015. 03. 13. 16:49 -kor