ă recomandat ă evaluare -...

Securitatea sistemelor şi a aplicaţiilor

Cursul I. Noţiuni introductive. Securitatea codului scris în C/C++

U.T. Cluj-Napoca Marius Joldoş

Obiectivele cursului

Să pună fundamente solide pentru înţelegerea securităţiiSă vă ofere informaţii esenţiale referitoare la construcţia sistemelor sigureSă prezinte o paletă de subiecte din securitateSă vă trezească interesul pentru studiu mai aprofundat

SSA curs 1 - M.Joldoş 2

Resurse, lectură recomandată

Web– http://users.utcluj.ro/~jim/SSA (public)

Resurse– CD_SSA (accesibil numai în laborator)– Paginile web ale cursului

Cărți– Security in Computing, Charles P. Pfleeger & Shari

Lawrence Pfleeger– Secure Coding in C and C++, Robert Seacord– The CERT Oracle Secure Coding Standard for Java,

Fred Long et. al


EvaluareComponente– Laborator (40%)

Teste in laborator – 20%Bonus de compensare <= 10%Miniproiect / eseu – 20%

– Examene (60%)Parţial (săptămâna a VII-a?, 30% din

cota examenelor)Final (în sesiunea din iunie, 70% din cota

examenelor)


Securitate

Majoritate ştiinţei calculatoarelor este preocupată de obţinerea unui comportament dorit– Într-un anume sens, securitatea este preocupată de

prevenirea comportamentului nedorit

Alt mod de gândire!Un inamic/oponent/hacker/adversar poate încerca activ şi rău intenţionat (maliciously) să evite măsurile de protecţie existente


Securitate. De ce?

Majoritatea problemelor sunt cauzate de oameni (potrivit lui Stallings)– 55% erori umane– 10% angajaţi nemulţumiţi– 10% angajaţi necinstiţi– 10% accese din afară– ”Acte ale Domnului” (foc, inundaţii etc)

Calculatoarele nu atacă calculatoare. Oamenii însă, daRăzboiul informaţional este aici şi va rămâne. Ce e de făcut?


Impactul tot mai larg al securităţii

Interes exploziv în securitateImpact asupra/interes pentru ~ din majoritatea ariilor Ştiinţei Calculatoarelor– Teorie (în special criptografie)– Baze de date– Sisteme de operare– IA/teoria învăţării– Reţele de calculatoare– Arhitectura calculatoarelor/hardware– Limbaje de programare/compilatoare– HCI


De ce securitatea este o problemă?

Mediul de calcul (computing environment) monoculturalAplicaţii web, e-commerce, & colaborativeInternetul nu se opreşte la graniţele statelorPractici de programare necorespun-zătoare


Analiza beneficii/costuri

Important de evaluat ce nivel de securitate este necesar/potrivitCostul susţinerii unui anumit atac vs. valoarea atacului pentru adversarCostul daunelor în urma atacului vs. costul apărării împotriva ataculuiProbabilitatea unui anumit atac


"Mai" sigur nu e întotdeauna mai bine

“Nu are rost să pui un turn mai înalt atunci când inamicul îl poate ocoli"– Trebuie identificată veriga cea mai slabă– Securitatea unui sistem nu este mai bună

decât punctul său cel mai slab– Securitatea nu este un “glonţ magic”– Securitatea este un proces nu un produs


Factorul uman

D.e. parolele...Atacurile din exterior vs. cele din interiorConfigurarea greşită a softwareNeaplicarea corecţiilor de securitateIngineria socialăSecuritatea fizică


Importanţa specificării precise

Politica de securitate– Declararea a ce e permis şi ce este interzis

Mecanismul de securitate– Metodă de impunere a unei politici

Sunt nonsensuri una fără alta


Prevenirea nu e singura grijă

Detecţia şi răspunsul– Cum ştiu că sunt atacat?– Cât de repede pot stopa atacul?– Pot preveni reapariţia atacului?

Recuperarea– Poate fi mult mai importanta decât prevenirea

Aspecte legale?


Monitorizarea controlată a securităţii

Starea de securitate a reţelei este necorespunzătoare?Monitorizarea reţelei; gestiunea riscurilorAtacurile vor apărea; este imposibil să ai protecţie completăSecuritatea trebuie văzută ca un proces, nu ca un produs…


Încrederea în încredere

În cine ai încredere?– ...

Trebuie să fim atât de paranoici??– Probabil că nu– Uneori, da

Aceasta arată că securitatea este complexă…şi,în esenţă, imposibilă– Revenim la compromisul riscuri/beneficii


Terminologie fundamentală (I)

Confidenţialitate: permiterea accesului la informaţie doar pentru entităţi autorizate– Accesul în citire al unui fişier, vizualizarea pe ecran, accesul la

materiale tipărite, cunoaşterea faptului că informaţia există.– Cea mai directă dintre proprietăţi.

Integritate: permiterea modificării informaţiei doar pentru entităti autorizare, în moduri autorizate.– Scriere, schimbarea stării, actualizare, creare, ştergere– Integritatea are semnificaţii diferite în contexte diferite (d.e.

acurateţe, precizie, nemodificare, consistenţă, cu înţeles etc.)

Disponibilitate: Info este accesibilă entităţilor autorizate la momentul potrivit.– Cea mai ambiguă şi mai puţin studiată


Terminologie fundamentala (II)


Confidenţialitate

Integritate Confidenţialitate

Integritate

Integritate IntegritateConfidenţialitate Confidenţialitate

Disponibilitate "Contabilizabilitate"

Terminologie fundamentală (III)

Pentru a securiza un sistem, avem nevoie de abilitatea de a restrânge accesul sau privilegiile asupra sistemului.– Controlul accesului este un mecanism

important de asigurare a securităţii.

– De obicei clasificat ca AAA (Autentificare, autorizare, contabilizare [Accounting])


Terminologie fundamentală (IV)

Securitatea comunicaţiilor – patru proprietăţi importante pentru mesaje:– Confidenţialitate: mesajul nu este expus( citit) pe ruta

spre receptor– Integritate: ceea ce vede receptorul este ceea ce a

fost trimis– Autenticitatea emiţătorului: receptorul este sigur că

mesajul a fost trimis de un anume emiţător.– Ne-repudierea: Emiţătorul nu poate nega că a trimis

mesajulMulte dintre aceste proprietăţi pot fi implementate şi impuse prin mecanisme criptografice


Terminologie fundamentală (IV)

Anonimitate– Un utilizator poate folosi o resursă sau un

serviciu fără a-şi dezvălui identitatea– Anonimitatea emiţătoruli/receptorului

Pseudonimitate– Un utilizator identificat printr-un pseudonim

poate folosi o resursa sau un serviciu fără a-şi dezvălui identitatea

– Criptografică, auto-generată, de referinţă, într-un singur sens


Terminologie fundamentală (V)

Ne-legabilitatea (sic) – [Unlinkability]– Un utilizator poate folosi o resursa sau un

serviciu fără ca alţii să poată face legătura între aceste utilizări

– Caracterizarea orientată pe eveniment

Ne-observabilitatea– Un utilizator poate folosi o resursa sau un

serviciu fără ca alţii să poată observa că resursa sau serviciul este folosit


Împotriva a ce protejăm sistemele?Adeseori este convenabil:– să vedem cum poate eşua un sistem şi – să producem o listă de vulnerabilităţi care nu ne-ar permite să

atingem unul sau mai multe dintre obiectivele de securitateVulnerabilitate: o slăbiciune în sistemul de securitate care poate fi exploatată pentru a cauza pierderi sau a dăuna– Ex. Un program care nu verifică lungimea unei intrări de date şir,

interactiveAmeninţare: mai serioasă ca vulnerabilitatea. Un set de circumstanţe care are potenţialul de a cauza pierderi sau a dăuna– Un model de protecţie pentru SO care permite programului Dvs.

să scrie şi să returneze adresa stivei de execuţie, dă acces supervizor şi permite schimbarea adresei de retur de pe stivă pentru a indica o locaţie la alegere.


Împotriva a ce protejăm sistemele?

O persoană (sau o entitate care acţionează în numele persoanei) care exploatează o vulnerabilitate, pătrunde într-un sistem şi atacă sistemul– Ex. Un utilizator care lansează un atac de tipul buffer Depășire

attack pentru a obţine privilegii de supervizor şi distruge fişiere

Control: măsură de protecţie care înlătură sau reduce o vulnerabilitate– Verificarea limitelor de tablouri– Folosirea compilatorului în acest scop

O ameninţare este blocată de controlul unei vulnera-bilităţi


Scopuri ale securităţii

Prevenirea– Sa prevină violarea politicilor de securitate

Detecţia– Să detecteze activităţile care violează o politică de securitate– Sa verifice eficacitatea mecanismelor de prevenire

Recuperarea– Să oprească violările de politică (atacurile)– Să stabilească şi să repare daunele– Să asigure disponibilitatea în prezenţa unui atac– Să repare vulnerabilităţile pentru prevenirea atacurilor viitoare– Răspunsul la atac (asupra atacatorului)


Codul sigur

Alan Paller, director de cercatare la SANS Institute “tot ce este pe [SANS Institute Top 20 Internet Security] lista de vulnerabilități este rezultatul tehnicilor slabe de scriere a codului, de testare și de inginerie software. (...). Exista soluții tehnice pentru toate, dar pur și simplu nu sunt implementate"


Codul sigur în C/C++. Şirurile

Nu sunt tip preconstruit în C/C++Şir:– pointer la– lungime– valoare– caractere: char (string)/ wchar_t (wide string)– C: terminat prin null char/wchar

Nepotrivire cu C++ basic_string


Codul sigur în C/C++. Şirurile. Erori frecvente

Citirea fără limitare din intrare

Copierea şi concatenarea fără limitare


1. int main(void) {2. char Password[80];3. puts("Enter 8 character password:");4. gets(Password);

...5. }

1. int main(int argc, char *argv[]) {2. char name[2048];3. strcpy(name, argv[1]);4. strcat(name, " = ");5. strcat(name, argv[2]);

...6. }


Alocarea dinamică


1. int main(int argc, char *argv[]) {2. char *buff = (char *)malloc(strlen(argv[1])+1);3. if (buff != NULL) {4. strcpy(buff, argv[1]);5. printf("argv[1] = %s.\n", buff);6. }7. else {

/* Couldn't get the memory - recover */8. }9. return 0;

10. }


Extragerea de caractere din cin în tablou (C++)

Limitare prin cin.width


1. #include <iostream>2. int main(void) {3. char buf[12];4. cin >> buf;5. cout << "echo: " << buf << endl;6. }

1. #include <iostream>2. int main(void) {3. char buf[12];4. cin.width(12);5. cin >> buf;6. cout << "echo: " << buf << endl;7. }


Erori de depăşire cu 1


1. int main(int argc, char* argv[]) {2. char source[10];3. strcpy(source, "0123456789");4. char *dest = (char *)malloc(strlen(source));5. int i;6. for (i=1; i <= 11; i++) {7. dest[i] = source[i];8. }9. dest[i] = '\0';

10. printf("dest = %s", dest);11. }


Lipsa terminatorului de şir


1. int main(int argc, char* argv[]) {2. char a[16];3. char b[16];4. char c[32];

5. strcpy(a, "0123456789abcdef");6. strcpy(b, "0123456789abcdef");7. strcpy(c, a);8. strcat(c, b);9. printf("a = %s\n", a);

10. return 0;11. }


Manipularea defectuoasă a argumentelor


1. int main(int argc, char *argv[]) {2. int i = 0;3. char buff[128];4. char *arg1 = argv[1];

5. while (arg1[i] != '\0' ) {6. buff[i] = arg1[i];7. i++;8. }9. buff[i] = '\0';

10. printf("buff = %s\n", buff);11. }

Codul sigur în C/C++. Şirurile. Vulnerabilităţi

Depăşirea de zonă alocată. Exemplu vulnerabil


1. bool IsPasswordOkay(void) {2. char Password[12];3. gets(Password);4. if (!strcmp(Password, "goodpass"))5. return(true);6. else return(false);7. }8. void main(void) {9. bool PwStatus;

10. puts("Enter password:");11. PwStatus = IsPasswordOkay();12. if (PwStatus == false) {13. puts("Access denied");14. exit(-1);15. }16. else puts("Access granted");17. }


Zona de memorie şi depăşirea– Depăşirile apar când se scrie în afara zonei

alocate


16 octeţi de date

Destinaţie

SursăOperaţie de

copiere

Zona depăşităMemoria alocată,12 octeţi

Codul sigur în C/C++. Şirurile. Vulnerabilităţi

Memoria alocată unui proces


Codul sigur în C/C++. Gestiunea stivei. Cadrul de stivă

Apelul unei funcţii


1. bool IsPasswordOkay(void) {2. char Password[12];3. gets(Password);4. if (!strcmp(Password, "goodpass"))5. return(true);6. else return(false);7. }8. void main(void) {9. bool PwStatus;

10. puts("Enter password:");11. PwStatus = IsPasswordOkay();12. if (PwStatus == false) {13. puts("Access denied");14. exit(-1);15. }16. else puts("Access granted");17. }


Apelul unei funcţii


void foo(int, char *); //prototip

int main(int argc, char *argv[]) {int MyInt=1; // variabil ă pe stiv ă

// aflat ă la ebp-8char *MyStrPtr="MyString";

// variabil ă pe stiv ă la ebp-4...

foo(MyInt,MyStrPtr); // apel1. mov eax, [ebp-4]2. push eax3. mov ecx, [ebp-8]4. push ecx5. call foo6. add esp, 8

...}

Prologul şi epilogul unei funcţiivoid foo(int, char *); //prototip

int main(int argc, char *argv[]) {int MyInt=1; // variabil ă pe stiv ă

// aflat ă la ebp-8char *MyStrPtr="MyString";

// variabil ă pe stiv ă la ebp-4...

foo(MyInt,MyStrPtr); // apel1. mov eax, [ebp-4]2. push eax3. mov ecx, [ebp-8]4. push ecx5. call foo6. add esp, 8

...}

void foo (int i, char *name) {char LocalChar[24];int LocalInt;1. push ebp2. mov ebp, esp3. sub esp, 28

...

...return;1. mov esp, ebp2. pop ebp3. ret}


foo(int i, char* name)

Adresă Valoare Descriere Lungime

0x0012FF4C ? Ultima variabilă locală - LocalInt 4

0x0012FF50 ? Prima variabilă locală - String -LocalChar

24

0x0012FF68 0x12FF80 Cadrul funcţiei apelante: main() 4

0x0012FF6C 0x401040 Adresa de retur a funcţiei apelante: main()

4

0x0012FF70 1 Arg: primul argument MyInt (int) 4

0x0012FF74 0x40703C Arg: al doilea argument: Pointer toMyString (char *)

4


Codul sigur în C/C++. Gestiunea stivei. Distrugerea stivei

Stiva este distrusă de o parolă prea lungă, de 20 octeţi


Codul sigur în C/C++. Gestiunea stivei. Distrugerea stivei

Efectul unui şir special pregătit: orice parolă se acceptă


Codul sigur în C/C++. Injectarea de cod

Prin injectarea de cod special conceput se poate provoca execuţia de cod arbitrarInjectarea de cod se poate face şi folosind înlănţuiri de apeluri inserate în stivă (arc injection)– După care se execută codul care trebuia

executat în mod normal


Codul sigur în C/C++. Strategii de moderare a vulnerabilităţilor legate de şiruri

Prevenire– Validarea lungimii intrării– Folosirea funcţiilor care limitează lungimea

intrării: fgets, gets_s– Folosirea funcţiilor care limitează lungimea şirului transferat: memcpy_s, memmove_s, strcpy_s, strcat_s (versiunile ..._s)

– Microsoft Strsafe– Extragerea din cin în std::string


Codul sigur în C/C++. Strategii de moderare a vulnerabilităţilor legate de şiruri

Detecţia şi recuperarea– Activarea la compilare a verificărilor la rulare (runtime

checks)MSC /RTC

– Folosirea stivelor ne-executabile (problematică din cauza unor programe care se bazează pe execuţia din stivă)

– Folosirea stivelor cu goluri de dimensiuni variabilePoziţia codului folosit la atac nu se va mai şti precis

– Gcc flag –f[no]stack-protector, -f[no]stack-protector-all– Biblioteci cu verificări de limite


Codul sigur în C/C++. Gestiunea memoriei

malloc(size_t size);– Alocă size octeți și returnează un pointer spre

memorie. Conținutul nu este șters.

free(void * p);– Eliberează memoria pointată de p, memorie

care trebuie să fi fost obținută printr-un apel anterior la malloc(), calloc(), sau realloc(). Altfel, sau la apel multiplu comportamentul este nedefinit. Dacă p este NULL, nu face nimic.



realloc(void *p, size_t size);– Schimbă dimensiunea unui bloc de memorie pointat

de p la size octeți. – Vechiul conținut va fi neschimbat la minimum dintre

mărimea veche și cea nouă; memoria alocată nouă nu este inițializată.

– p == NULL, => malloc(size); – size==zero, => free(p). – Dacă p != NULL, memoria trebuie sa fi provenit din

apel la malloc(), calloc(), or realloc().



calloc(size_t nmemb, size_t size);– Aloc ă memorie pentru un tablou de nmemb elemente

de size octeți fiecare și returnează un pointer la memoria alocată.

– Memoria este zeroizată.

Pentru calloc() și malloc(), valoarea returnată este un pointer la memoria alocată, aliniat corespunzător pentru orice tip de variabilă sau NULL la eșecul apelului


Codul sigur în C/C++. Gestiunea memoriei. Erori frecvente

Citirea memoriei neinițializate


1. /* return y = Ax */2. int *matvec(int **A, int *x, int n) {3. int *y = malloc(n * sizeof(int));4. int i, j;

5. for (i = 0; i < n; i++)6. for (j = 0; j < n; j++)7. y[i] += A[i][j] * x[j];8. return y;9. }


Neverificarea valorii returnate la alocare


1. int *i_ptr;2. i_ptr = (int *) malloc(sizeof(int)*nelements_wanted);3. if (i_ptr != NULL) {4. i_ptr[i] = i;5. }6. else {

/* Couldn't get the memory - recover */7. }


Tratarea excepțiilor aruncate de new


1. try {2. int *pn = new int;3. int *pi = new int(5);4. double *pd = new double(55.9);5. int *buf = new int[10];

. . .6. }7. catch (bad_alloc) {

// handle failure from new8. }


Folosirea incorectă a lui new


1. int *ip = new int;2. if (ip) { // condition always true

...3. }4. else {

// will never execute5. }


Referențierea memoriei eliberate

Eliberarea multiplă


for (p = head; p != NULL; p = p->next)free(p);

for (p = head; p != NULL; p = q) {q = p->next;free(p);

}

1. x = malloc(n * sizeof(int));2. /* manipulate x */3. free(x);4. y = malloc(n * sizeof(int));5. /* manipulate y */6. free(x);


Atenție: structuri de date partajate



Apeluri incorect împerecheate

Notă. C++: – new și delete folosiți la alocarea/dealocarea

scalarelor– new[] și delete pentru tablouri


1. int *ip = new int(12);. . .

2. free(ip); // gresit!3. ip = static_cast<int *>(malloc(sizeof(int)));4. *ip = 12;

. . .5. delete ip; // gresit!

Codul sigur în C/C++. Gestiunea memoriei. Doug Lea’s heap

Heap


Codul sigur în C/C++. Gestiunea memoriei. DL Heap


Codul sigur în C/C++. Gestiunea memoriei. DL Heap .

Macro unlink

Exploatarea pentru unlink: depăşire de zonă tampon pentru a manipula etichetele de limită de pe bucătile de memorie – să determine macro unlink să scrie 4 octeți la o locație arbitrară


1. #define unlink(P, BK, FD) { \2. FD = P->fd; \3. BK = P->bk; \4. FD->bk = BK; \5. BK->fd = FD; \6. }

Codul sigur în C/C++. Gestiunea memoriei. Exploatarea unlink

Cod vulnerabil


1. #include <stdlib.h>2. #include <string.h>3. int main(int argc, char *argv[]) {4. char *first, *second, *third;5. first = malloc(666);6. second = malloc(12);7. third = malloc(12);8. strcpy(first, argv[1]);9. free(first);

10. free(second);11. free(third);12. return(0);13. }

Codul sigur în C/C++. Gestiunea memoriei.

Cod vulnerabil. Efectul execuției



Cod vulnerabil. Utilizarea exploatării



Alte exploatări– Tehnica bazată pe macro frontlink (cf.

Seacord)


1. BK = bin;2. FD = BK->fd;3. if (FD != BK) {4. while (FD != BK && S < chunksize(FD)) {5. FD = FD->fd;6. }7. BK = FD->bk;8. }9. P->bk = BK;

10. P->fd = FD;11. FD->bk = BK->fd = P;

Codul sigur în C/C++. Gestiunea memoriei. DL Heap

Eliberarea memoriei de mai multe ori (fără realocare între ele)Suprascrierea eliberate – asemănătoare folosirii eliberării duble


Codul sigur în C/C++. Gestiunea memoriei. Strategii de moderare

Setați pointerii la NULL după freeConvenții de gestiune a memoriei consistente– Același șablon la alocare/dealocare

C++, alocare în constructori; dealocare în destructors. C, definiți create() și destroy() cu funcțiuni similare

– Alocați memoria în același modul, la același nivel de abstracțiune

Eliberarea memorie în subrutine duce la confuzii– Împerecheați alocările cu dealocările


Codul sigur în C/C++. Gestiunea memoriei. Strategii de moderare

Detectarea integrității heapphkmalloc – rescriere a malloc: detectează eliberări duble (Unix)Randomizarea adreselor returnate de mallocPagini de gardă– Pagini de memorie nemapate amplasate între toate alocările de

memorie de mărimea unei pagini sau mai mari. Generează erori (Segm. Fault) la fiecare acces

Folosirea instrumentelor de analiză– http://en.wikipedia.org/wiki/Electric_Fence– http://code.google.com/p/drmemory/– http://www.codersnotes.com/sleepy– http://valgrind.org/


Codul sigur în C/C++. Întregii

Întregii sunt o sursa din ce în ce mai mare și subapreciată de vulnerabilități în programele C/C++Verificarea gamei de valori nu s-a aplicat sistematic la dezvoltarea majoritătii programelor– Există slăbiciuni în securitate care implică întregi– O seamă e probabil sa fie vulnerabilități

Poate apărea o vulnerabilitate software la evaluarea unui întreg la o valoarea neașteptată într-un program



Reprezentări– Mărime și semn– Complement față de 1– Complement față de 2

Reprezentările diferă pentru numerele Negativ





Tipuri standard– char– short int– int– long int– long long int

Tipuri extinse – depind de implementare– intptr_t , uintptr_t

Tipuri dependente de platformă– E.g. Microsoft API: BYTE, LONG64, __int8



Câteva game pentru întregi



Conversii– Promovări:

tipurile mai mici (gama) decât int sunt promovate la efectuarea de operații pe eleDacă toate valorile tipului original se pot reprezenta ca int, valoarea mai mică se convertește la int; altfel se convertește la unsigned int.


Codul sigur în C/C++. Întregi fără semn. Conversii


Codul sigur în C/C++. Întregi cu semn. Conversii



Depășiri de capacitate


1. int i;2. unsigned int j;

3. i = INT_MAX; // 2,147,483,6474. i++;5. printf("i = %d\n", i); /* i = -2,147,483,648 */

6. j = UINT_MAX; // 4,294,967,295;7. j++;8. printf("j = %u\n", j); /* j = 0 */

9. i = INT_MIN; // -2,147,483,648;10. i--;11. printf("i = %d\n", i); /* i = 2,147,483,647 */

12. j = 0;13. j--;14. printf("j = %u\n", j); /* j = 4,294,967,295 */


Erori de semn

Erori de trunchiere


1. int i = -3;2. unsigned short u;

3. u = i;4. printf("u = %hu\n", u); /* u = 65533 */

1. unsigned short int u = 32768;2. short int i;

3. i = u;4. printf("i = %d\n", i); /* i = -32768 */

5. u = 65535;6. i = u;7. printf("i = %d\n", i); /* i = -1 */


Detecția erorilor

– Prin hardware

– Înainte de apariție pe baza preconditiilor

– După apariție pe baza postcondițiilor


Codul sigur în C/C++. Operații pe întregi

Registrul de flaguri– Depășire – depăşire aritmetică cu semn– Carry – depăşire aritmetică fără semn



Operațiile asupra întregilor pot duce la erori și la valori neașteptateValorile neașteptate pot cauza– comportamente neașteptate ale programelor– Vulnerabilităti de securitate

Majoritatea operatiilor pot duce la conditii de excepție.



Adunarea: folosită cu 2 operanzi aritmetici sau un pointer și un întregDacă ambii operanzi sunt aritmetici, se efectuează conversiile uzualeAdunarea întreagă poate duce la depășire de capacitate dacă suma nu se poate reprezenta pe precizia alocată









Adunare. Precondiții– Fără semn: LHS + RHS => depășire dacă

suma > UINT_MAX pentru int sau ULLONG_MAX pentru unsigned long long

– Cu semn:


LHS RHS Condiții de excepție

Pozitiv Pozitiv Depășire dacă INT_MAX - LHS <= RHS

Pozitiv Negativ Nu e posibilă

Negativ Pozitiv Nu e posibilă

Negativ Negativ Depășire dacă LHS <= INT_MIN - RHS


Adunare. Postcondiții– sum = lhs + rhs.

Notații: sum=suma; lhs=membrul stâng, rhs=membrul drept

– Depășire dacă:Cu semn

– lhs >= 0 && sum < rhs sau– lhs < 0 && sum > rhs

Fără semn– sum < lhs || sum < rhs



Scădere. Precondiții. Depășire dacă– Fără semn: LHS < RHS– Cu semn semne diferite și:

lhs < 0 && rhs > 0 lhs >= INT_MAX + rhs.lhs >= 0 && rhs < 0 lhs <= INT_MAX + rhs.

Scădere. Postcondiții. Depășire dacă dif=lhs-rhsși:– Cu semn

rhs >=0 && dif > lhsrhs < 0 && dif < lhs

– Fără semn: dif > lhs



Înmulțire. Precondiție–A > MAX_INT/B–Depășire: cast la urmatoarea

precizie și Fără semn: sunt biți de ordin superiorCu semn:biții de ordin superior nu sunt toți 0 sau 1

Postcondiție: prea laboriosSSA curs 1 - M.Joldoş 83


Împărțirea: depășire dacă numărătorul = minimum && numitor = -1 || numitor=0Postcondiție. Tratarea excepțiilor în C++ nu permite recuperarea de la exceptie sau eroare hardware de genul violării de acces sau împărțirii cu zero– Microsoft are extensii în SO și în VC++


Codul sigur în C/C++. Întregii. Vulnerabilități

Depășire

La alocarea memoriei, în calculul dimensiunii unei regiuni– Rezultatul poate fi mai mic > depășire de

zonă SSA curs 1 - M.Joldoş 85

1. void getComment(unsigned int len, char *src) {2. unsigned int size;

3. size = len - 2;4. char *comment = (char *)malloc(size + 1);5. memcpy(comment, src, size);6. return;7. }

8. int _tmain(int argc, _TCHAR* argv[]) {9. getComment(1, "Comment ");

10. return 0;11. }


Erori de semn


1. #define BUFF_SIZE 10

2. int main(int argc, char* argv[]){3. int len;4. char buf[BUFF_SIZE];5. len = atoi(argv[1]);6. if (len < BUFF_SIZE){7. memcpy(buf, argv[2], len);8. }9. else

10. printf("Too much data\n");11. }


Trunchierea sumei a două lungimi

Implementare vulnerabilă la exploatare


1. int main(int argc, char *const *argv) {2. unsigned short int total;3. total = strlen(argv[1])+strlen(argv[2])+1;4. char *buff = (char *) malloc(total);5. strcpy(buff, argv[1]);6. strcat(buff, argv[2]);7. }

1. bool func(char *name, long cbBuf) {2. unsigned short bufSize = cbBuf;3. char *buf = (char *)malloc(bufSize);4. if (buf) {5. memcpy(buf, name, cbBuf);6. if (buf) free(buf);7. return true;8. }9. return false;

10. }

Codul sigur în C/C++. Întregii. Erori logice

Indici negativi


1. int *table = NULL;

2. int insert_in_table(int pos, int value){3. if (!table) {4. table = (int *)malloc(sizeof(int) * 100);5. }6. if (pos > 99) {7. return -1;8. }9. table[pos] = value;

10. return 0;11. }

Codul sigur în C/C++. Întregii. Strategii de moderare

Verificarea gamei

Tipuri de date mai potriviteFolosirea verificărilor oferite de compilator– MsVC: /RTC– gcc: -ftrapv


1. #define BUFF_SIZE 10

2. int main(int argc, char* argv[]){3. unsigned int len;4. char buf[BUFF_SIZE];5. len = atoi(argv[1]);6. if ((0 < len) && (len < BUFF_SIZE) ){7. memcpy(buf, argv[2], len);8. }9. else

10. printf("Too much data\n");11. }

Codul sigur în C/C++. Întregii. Strategii de moderare

Biblioteci care asigură verificările– Clasa SafeInt– IntegerLib– GNU Multiple Precision Arithmetic (GMP)

Testarea riguroasă

Auditarea codului sursă


Rezumat

Noţiuni introductive

Codul sigur în C/C++

– Probleme legate de şiruri

Modificarea stivei

– Probleme legate de gestiunea memorie

Modificare heap

– Probleme legate de lucrul cu întregi

Depăşiri nesemnalate şi valori neaşteptate


ă recomandat ă evaluare -...

Documents