Análisis de códigos

Este segmento de código no hce comprobación de longitud de entrada if (path != null && path.length() > 0 && path.length() < = MAXPATH){ fileOperation(path); }. Verdadero. Falso.

Este segmento de código valida los datos de entrada: String delimiter; for (int i=0; i < arg.length; i++) { if ( args[i].startsWith("--delimiter=) ) { delimiter = args[i].substring(12); } } .. for (int i = 0; i < dropSQL[i]; if (delimiter!=null) formatted += delimiter; ... fileOutput.write(formatted + "\n" ); }. Falso. Verdadero.

Diga si el siguiente segmento de código es correcto o incorrecto y por que int (*cmp) (char* ,char*); int *p = (int*) malloc(sizeof(int)); *p = 1; cmp = (int(*)(char* ,char*))p; cmp("hola","adios");. Incorrecto. Porque viola la seguridad de la memoria. Porque viola la seguridad de los tipos. Correcto.

Diga si el siguiente segmento de código es correcto o incorrecto y por que unsigned int readamt; readamt = getstringsize(); if (readamt > 1024 return -1; readamt--; buf = malloc(readamt);. Incorrecto. Correcto. Porque es una vulnerabilidad de integer overflow. Porque es una vulnerabilidad de heap overflow.

Diga si el siguiente segmento de código es correcto o incorrecto y por que cahr var[128], val[15 * 1024], ..., boundary[128], buffer[15*1024]; ... for(;;){ ... inChar = getchar(); if (inChar == ´;´){ ... scanf(" Formato: %s ", buffer);. Incorrecto. Correcto. Porque es un desbordamiento de buffer por llamada insegura a función de string. Porque es un desbordamiento de string.

¿Que tipo de vulnerabilidad se comete en este código? struct hostend *hp; struct in_addr myaddr; char* tHost = "trustme.com"; myaddr.s_addr = inet_addr(ip_addr_string); hp = gethostbyaddr((char*) &myaddr, sizeof(struct in_addr), AF_INET); if (hp && !strncmp(hp->h_name, tHost, sizeof(tHost))){ trusted = true; } else { trusted = false; }. Memory leaks. Bufer overflow. Validación límites de confianza. Validación de entrada DNS.

Diga si el siguiente segmento de código es correcto o incorrecto y por que #include <stdio.h> #include <unistd.h> #define BUFSIZER1 512 #DEFINE bufsizer2 ((BUFSIZER1/2) -8) int main(int argc, char **argv) { char *buf1R1; char *buf2R1; char *buf2R2; char *buf3R2; buf1R1 = (char *) malloc(BUFSIZER1); buf2R1 = (char *) malloc(BUFSIZER1); free(buf2R1); buf2R2 = (char *) malloc(BUFSIZER2); buf3R2 = (char *) malloc(BUFSIZER2); strncpy(buf2R1, argv[1], BUFSIZER1-1); free(buf1R1); free(buf2R2); free(buf3R2); }. Incorrecto. Correcto. Porque es un heap overflow de tipo deference after free. Porque es un heap overflow de tipo use after free.

Diga si el siguiente segmento de código es correcto o incorrecto y por que String val = request.getParameter("val"); try { int value = Integer.parseInt(val); } ctah (NumberFormatException) { log.info("Failed to parse val = " + val); }. Incorrecto. Correcto. Porque permite la falsificación de logs. Porque permite la inyección de comandos.

Diga si el siguiente segmento de código es correcto o incorrecto y por que void* doAlloc(int sz) { return malloc(sz); }. Incorrecto. Correcto. Porque no comprueba que un número negativo pueda provocar reservar mucha memoria. Porque no comprueba la longitud de entrada.

Diga si el siguiente segmento de código es correcto o incorrecto y Porque ... if (tryOperation() == OPERATION_FAILED) { free(ptr); errors++; } ... if (errors > 0) { logError("operation aborted before commit", ptr); }. Incorrecto. Correcto. Porque es un heap overflow de tipo use after free. Porque es un heap overflow de tipo deference after free.

Diga si el siguiente segmento de código es correcto o incorrecto y Porque #include <stdlib.h> int main(int argc, char *argv[]){ int k=0; int *p=(int *)NULL; switch(k) { case 0: if (*p) k = *p; default: break; } return 0; }. Incorrecto. Correcto. Porque es un heap overflow de tipo deference after free. Porque es un heap overflow de tipo null deference.

¿Que tipo de vulnerabilidad se comete en este código? public ResultSet execSQL(connection conn, String sql) { Statement stmt = null; ResultSet rs = null; try { stmt = conn.createStatement(); rs = stmt.executeQuery(sql); } catch (SQLException sqe) { logger.log(Level.WARNING, "error executing: " + sql, sqe); } finally { close(stmt); } return rs; }. Integer overflows. Manipulación de información privada. Format string. Desbordamiento de buffer.

Diga si el siguiente segmento de código es correcto o incorrecto y Porque if (auth_sys == KRB5_RECVAUTH_V4) { strcat(cmdbuf, "/v4rcp"); } else { strcat(cmdbuf, "/rcp"); } if (stat((char *)cmdbuf + offst, &s) >= 0) strcat(cmdbuf, cp); else strcpy(cmdbuf, copy);. Incorrecto. Correcto. Porque es un desbordamiento de buffer por llamada insegura a función de string. Porque es un desbordamiento de string.

Diga si el siguiente segmento de código es correcto o incorrecto y Porque char *FixFilename(char *filename, int cd, int *ret) { ... char fn[128], user[128], *s; ... s = strrchr(filename,´/´); if(s) { strcpy(fn,s+1);. Incorrecto. Correcto. Porque es un desbordamiento de buffer por llamada insegura a función de string. Porque es un desbordamiento de string.

Diga si el siguiente segmento de código es correcto o incorrecto y Porque String userName = ctx.getAuthenticatedUserName(); String itemName = request.getParameter("itemName"); String query = "SELECT *FROM items Where owner = ´" + userName + "ÁND itemname = ´" + itemName + ""; Statement stmt = conn.createStatement(); ResultSet rs = stmt.executeQuery(query);. Incorrecto. Correcto. Porque no comprueba la longitud de entrada. Porque lo deja abierto a ataques de inyección SQL.

Diga si el siguiente segmento de código es correcto o incorrecto y Porque String rName = request.getParameter("reportName"); Fuile rFile = new File("/usr/local/apfr/reports/" + rName); rfile.delete();. Incorrecto. Correcto. Porque se permite en las entradas de un usuario meta-caracteres de sistemas de ficheros. Porque no usa sentencias parametrizadas.

Diga si el siguiente segmento de código es correcto o incorrecto y Porque #include <unistd.h> int main() { char *scode[2]; scode[0] = "/bin/sh"; scode[1] = NULL; execve (scode[0], scode, NULL); }. Incorrecto. Correcto. Porque viola la seguridad de los tipos. Porque permite un ataque de desbordamiento de buffer basado en el stack.

Diga si el siguiente segmento de código es correcto o incorrecto y Porque String btype = request.getParameter(("backuptype"); String cmd = new String("cmd.exe /K \"c:\\util\\rmanDB.bat" + btype + "&&c:\\utl\\cleanup.bat\"") Runtime.getRuntime().exec(cmd);. Incorrecto. Correcto. Porque permite la manipulación de rutas. Porque permite la inyección de comandos.

Diga si el siguiente segmento de código es correcto o incorrecto y Porque char* processNext(char* strm) { char buf[512]; short len = *(short*) strm; strm += si<eof(len); if (len <= 512) { memcpy(buf, strm, len); process(buf); return strm + len; } else { return -1; } }. Incorrecto. Correcto. Porque es una vulnerabilidad de integer overflow. Porque es una vulnerabilidad de buffer overflow.

Diga si el siguiente segmento de código es correcto o incorrecto y Porque #include <stdlib.h> void function_wich_allocates(void) { float *a = malloc(sizeof(float) * 45); return } int main(void) { function_wich_allocates();. Incorrecto. Correcto. Porque es un heap overflow de tipo after free. Porque es un heap overflow de tipo memory leaks.

¿Que tipo de vulnerabilidad se comete en este código? String user_state = "Unknown"; try { HttpSession user_session = Init.sessions.get(tmpUser.getUser()); user_state = user_session == null ? "Unknown" : (String)user_session.getAttribute("USER_STATUS"); user_state = user_state == null ? "Available" : user_state; } ... %> <%=user_state %>. Uso de datos invalidados. Integer overflows. Desbordamiento de buffer. Use after free.

Diga si el siguiente segmento de código es correcto o incorrecto y Porque void trouble() { int a = 32; char line[128]; gets(line); }. Incorrecto. Correcto. Porque permite un ataque de desbordamiento de buffer basado en el stack. Porque permite la inyección de comandos.

Diga si el siguiente segmento de código es correcto o incorrecto y Porque String item = request.getParameter("item"); String q="SELECT * FROM records WHERE item=" + item; PreparedStatement stmt = conn.prepareStatement(q); ResultSet results = stmt.executeQuery();. Incorrecto. Correcto. Porque no usa sentencias parametrizadas. Porque combina sentencias parametrizadas y concatenadas.

¿Que tipo de vulnerabilidad se comete en este código? while (fgets(buf, sizeof buf, f)) { Ireply(200, buf); ... } void Ireply(int n, char *fmt, ...) { char buf [BUFSIZ]; ... vsnprintf(buf, sizeof buf, fmt, ap); ... }. Use after free. Integer overflows. Format string. Desbordamiento de buffer.

Diga si el siguiente segmento de código es correcto o incorrecto y Porque #include <stdio.h> int main(void) { char texto[30]; scanf("%29s", texto); printf(texto); return 0; }. Incorrecto. Correcto. Porque es una vulnerabilidad de formato string. Porque es un desbordamiento de buffer.

Este segmento de código viola un límite de confianza: status = request.getParameter("status"); if (status != null && status.length() > 0) { session.setAttribute("USER_STATUS", status); }. Falso. Verdadero.

¿Que tipo de vulnerabilidad se comete en este código? char *stringcopy(char *str1, char *str2) { while (*str2) *str1++ = *str2++; return str2; } main(int argc, char **argv) { char *buffer = (char *)malloc(16 * sizeof(char)); stringcopy(buffer, argv[1]); printf("%s\n", buffer); }. Fortmat string. Use after free. Integer overflows. Desbordamiento de buffer.

Diga si el siguiente segmento de código es correcto o incorrecto y Porque int * ab = (int*) malloc (SIZE); ... if (c == ´EOF´) { free(ab); } ... free(ab);. Incorrecto. Correcto. Porque es un heap overflow de tipo double free. Porque es un heap overflow de tipo deference after free.

¿El siguiente código es correcto? if (path != null && path.length() > 0 && path.length() < = MAXPATH){ fileOperation(path); }. Ninguna de las anteriores. No se puede determinar. Es incorrecto. Es correcto.

¿Que tipo de vulnerabilidad se comete en este código? u_int nresp; nresp = packet_get_int(); if (nresp > 0) { responde = xmalloc(nresp*sizeof(char*)); for (i = 0; i < nresp; i++) response [i] = packet_get_strng(NULL); }. Use after free. Desbordamiento de buffer. Integer overflows. Format String.