Scribd
Upload
24 views

Tutorial 2

The document discusses memory safety vulnerabilities like format string vulnerabilities and integer overflows. It provides examples of code vulnerable to these issues and asks questions to assess understanding. Potential attacks and fixes are also explained.

Uploaded by

Agus
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
24 views

Tutorial 2

The document discusses memory safety vulnerabilities like format string vulnerabilities and integer overflows. It provides examples of code vulnerable to these issues and asks questions to assess understanding. Potential attacks and fixes are also explained.

Uploaded by

Agus
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 3

SC3010 Computer Security

Tutorial 2 – Memory Safety Vulnerability

1. Circle the correct answers in the following questions.


1) Which statement is false about the format string vulnerability?

A. Attacker can abuse the format string “%d” to cause confidentiality violation.
B. Attacker can abuse the format string “%i” to cause integrity violation.
C. Attacker can abuse the format string “%s” to cause availability violation.
D. Attacker can abuse the format string “%x” to cause confidentiality violation.

2) Which statements are true about Cross-Site Scripting (XSS) attack?


(i) XSS can target static web applications without users’ input.
(ii) When XSS is exploited, the malicious commands are executed on the victim’s local
computer, instead of the web server.
(iii) In the stored XSS attack, the attacker does not need to connect to the victim computer.
(iv) In the reflected XSS attack, the malicious command can exist in the web server for a
long time.

A. (i) and (iii)


B. (i) and (iv)
C. (ii) and (iii)
D. (ii) and (iv)

3) In a C program, let an unsigned int variable x = UINT_MAX. What will be the result when
we calculate x ++?

A. 0
B. UINT_MAX
C. INT_MAX
D. INT_MIN

2. Answer the following questions.


1) What is the root cause of format string vulnerability? What are the possible consequences?

2) How to prevent integer overflow vulnerabilities?

3) What is the scripting vulnerability?

3. Consider the following fragment of a C program. The program has a vulnerability that would allow
an attacker to cause the program to disclose the content of the variable “secret” at runtime. We
assume that the attacker has no access to the exact implementation of the ‘get_secret()’
function so the attack has to work regardless of how the function ‘get_secret()’ is implemented.
1) Explain how the attack mentioned above works. You do not need to produce the exact
input to the program that would trigger the attack. It is sufficient to explain the strategy
of the attack. Explain why the attack works.

2) The vulnerability above can be fixed by modifying just one statement in the program
without changing its functionality. Show which statement you should modify and how you
would modify it to fix the vulnerability. Show the C code of the proposed solution

int main(int argc, char* argv[]) {


int uid1 = x12345;
int secret = get_secret();
int uid2 = x56789;
char str[256];
if (argc < 2)
return 1;
strncpy(str, argv[1], 255);
str[255] = ‘\0’;
printf(“Welcome”);
printf(str);

return 0;
}

4. You are developing a web service, which accepts the email title ‘title’ and body ‘body’ from
users, and forwards them to [email protected]. This is achieved by the following program.
Identify the security problems in this piece of program

void send_mail(char* body, char* title) {


FILE* mail_stdin;
char buf[512];
sprintf(buf, "mail -s \“Subject: %s\" [email protected]", title);
mail_stdin = popen(buf, "w");
fprintf(mail_stdin, body);
pclose(mail_stdin);
}

5. The following program implements a function in a network socket: ‘get_two_vars’. It receives


two packets, and concatenates the data into a buffer. Use an example to show this program has
integer overflow vulnerability. Note the first integer in the received buffer from ‘recv’ denotes
the size of the buffer.
int get_two_vars(int sock, char *out, int len){
char buf1[512], buf2[512];
int size1, size2;
int size;

if(recv(sock, buf1, sizeof(buf1), 0) < 0)


return -1;
if(recv(sock, buf2, sizeof(buf2), 0) < 0)
return -1;

memcpy(&size1, buf1, sizeof(int));


memcpy(&size2, buf2, sizeof(int));
size = size1 + size2;
if(size > len)
return -1;
memcpy(out, buf1, size1);
memcpy(out + size1, buf2, size2);
return size;
}

You might also like