Los mecanismos de autenticación débiles exponen a las organizaciones a accesos no autorizados.

Los mecanismos de autenticación pueden fallar por varias razones, tales como:
- Contraseñas débiles
- Validación incorrecta
- Gestión de credenciales débil

Los mecanismos de autenticación débiles exponen a las organizaciones a accesos no autorizados.

Los mecanismos de autenticación pueden fallar por varias razones, tales como:
- Contraseñas débiles
- Validación incorrecta
- Gestión de credenciales débil

Los mecanismos de autenticación débiles exponen a las organizaciones a accesos no autorizados.

Los mecanismos de autenticación pueden fallar por varias razones, tales como:
- Contraseñas débiles
- Validación incorrecta
- Gestión de credenciales débil

Los mecanismos de autenticación débiles exponen a las organizaciones a accesos no autorizados.

Los mecanismos de autenticación pueden fallar por varias razones, tales como:
- Contraseñas débiles
- Validación incorrecta
- Gestión de credenciales débil

Los nombres y los valores de las propiedades bean tienen que validarse antes de rellenar cualquier bean. Las funciones de relleno bean permiten a los desarrolladores establecer una propiedad bean o una propiedad anidada. Un atacante puede aprovechar esta funcionalidad para acceder a propiedades bean especiales, como class.classLoader, que le permitirá sobrescribir propiedades del sistema y ejecutar potencialmente código arbitrario.

Ejemplo 1: El código siguiente establece una propiedad bean controlada por el usuario sin validación adecuada del nombre o valor de la propiedad:

String prop = request.getParameter('prop');
String value = request.getParameter('value');
HashMap properties = new HashMap();
properties.put(prop, value);
BeanUtils.populate(user, properties);

La autenticación basada en Touch ID puede implementarse de dos formas diferentes: mediante el marco de trabajo LocalAuthentication o mediante el uso de controles de accesos basados en Touch ID en el servicio de llaves.

Si bien ambas deberían ser lo suficientemente seguras para la mayoría de las aplicaciones, el enfoque de LocalAuthentication tiene algunas características que lo hacen menos adecuado para las aplicaciones de mayor riesgo, como las de los sectores bancario, sanitario y asegurador:

- LocalAuthentication se define fuera de la zona segura del dispositivo, lo que implica que sus API pueden enlazarse y modificarse en dispositivos liberados.
- LocalAuthentication autentica al usuario mediante la evaluación de la directiva de contexto, que solo puede evaluar como true o false. Esta evaluación booleana implica que la aplicación no podrá saber a quién se está autenticando en realidad, solo si se usó, o no, la huella digital que está registrada en el dispositivo. Además, las huellas digitales que podrían registrarse en el futuro también se evaluarán correctamente como true.


Ejemplo 1: el siguiente código usa el marco de trabajo LocalAuthentication para realizar la autenticación del usuario:

    ...
    LAContext *context = [[LAContext alloc] init];  
    NSError *error = nil;  
    NSString *reason = @"Please authenticate using the Touch ID sensor.";
    
    if ([context canEvaluatePolicy:LAPolicyDeviceOwnerAuthenticationWithBiometrics error:&error]) {  
        [context evaluatePolicy:LAPolicyDeviceOwnerAuthenticationWithBiometrics
            localizedReason:reason
                reply:^(BOOL success, NSError *error) {
                    if (success) {
                        // Fingerprint was authenticated
                    } else {
                        // Fingerprint could not be authenticated
                    }
            }
        ];
    ...

La autenticación basada en Touch ID puede implementarse con los servicios de llaves mediante el almacenamiento de un elemento en las llaves y la configuración de un control de accesos que requiera que el usuario utilice su huella digital para recuperar el elemento más tarde. Las siguientes directivas pueden usarse para definir cómo se autenticará al usuario con su huella digital:

- kSecAccessControlUserPresence: restricción de acceso con Touch ID o un código de acceso. No es necesario que Touch ID esté disponible o registrado. Touch ID puede tener acceso al elemento aunque se agreguen o eliminen huellas digitales.
- kSecAccessControlTouchIDAny: restricción de acceso con Touch ID para las huellas digitales registradas. No se invalida el elemento si se agregan o eliminan huellas digitales.
- kSecAccessControlTouchIDCurrentSet: restricción de acceso con Touch ID para las huellas digitales registradas actualmente. Se invalida el elemento si se agregan o eliminan huellas digitales.

Cuando usa Touch ID, debe utilizar el atributo kSecAccessControlTouchIDCurrentSet para impedir que se agreguen o eliminen huellas digitales en el futuro.

Ejemplo 1: el siguiente código usa la restricción kSecAccessControlTouchIDAny que permite que el elemento de las llaves se desbloquee con cualquier huella digital que se registre en el futuro:

    ...
    SecAccessControlRef sacRef = SecAccessControlCreateWithFlags(kCFAllocatorDefault,
                 kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly,
                 kSecAccessControlTouchIDCurrentSet, 
                 nil);
    NSMutableDictionary *dict = [NSMutableDictionary dictionary];
    [dict setObject:(__bridge id)kSecClassGenericPassword forKey:(__bridge id) kSecClass];
    [dict setObject:account forKey:(__bridge id)kSecAttrAccount];
    [dict setObject:service forKey:(__bridge id) kSecAttrService];
    [dict setObject:token forKey:(__bridge id)kSecValueData];
    ...
    [dict setObject:sacRef forKey:(__bridge id)kSecAttrAccessControl];
    [dict setObject:@"Please authenticate using the Touch ID sensor." forKey:(__bridge id)kSecUseOperationPrompt];

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        OSStatus status = SecItemAdd((__bridge CFDictionaryRef)dict, nil);
    });
    ...

De acuerdo con las directivas de Apple, la aplicación siempre debe explicar a los usuarios por qué se requieren sus huellas digitales. En caso contrario, puede confundirse al usuario o incluso hacer que la aplicación se rechace en AppStore.

Ejemplo 1: el siguiente código usa Touch ID para autenticar al usuario, pero no proporciona un motivo localizado que explique por qué se requiere la autenticación:

    [context evaluatePolicy:LAPolicyDeviceOwnerAuthenticationWithBiometrics localizedReason:nil
        reply:^(BOOL success, NSError *error) {
            if (success) {
                NSLog(@"Auth was OK");
            } 
    }];

El buffer overflow es probablemente la forma más conocida de vulnerabilidad de seguridad de software. La mayoría de los desarrolladores de software saben lo que es una vulnerabilidad de buffer overflow, pero a menudo este tipo de ataques contra las aplicaciones existentes y desarrolladas recientemente son aún bastante habituales. Parte del problema se debe a la amplia variedad de formas en las que puede producirse un buffer overflow y otra parte se debe a las técnicas proclives a errores que a menudo se utilizan para evitarlas.

En un ataque de buffer overflow clásico, el usuario malintencionado envía datos a un programa, que los almacena en un búfer de pila demasiado pequeño. El resultado es que se sobrescribe la información de la pila de llamadas, incluido el puntero de devolución de la función. Los datos establecen el valor del puntero de devolución para que, cuando se devuelva la función, esta transfiera el control al código malicioso incluido en los datos del usuario malintencionado.

Aunque este tipo de buffer overflow de pila aún es frecuente en algunas plataformas y comunidades de desarrolladores, existen diversos tipos adicionales de buffer overflow, incluidos los desbordamientos del búfer de montón y los errores por uno ("off-by-one"), entre otros. Hay una serie de libros excelentes que ofrecen información detallada sobre cómo funcionan los ataques de buffer overflow, incluidos "Bilding Secure Software" [1], "Writing Secure Code" [2] y "The Shellcoder's Handbook" [3].

En el nivel de código, las vulnerabilidades de buffer overflow normalmente conllevan la infracción de las presuposiciones de un programador. Muchas funciones de manipulación de memoria de C y C++ no realizan comprobaciones de límites y pueden sobrescribir fácilmente los límites asignados de los búferes en los que funcionan. Incluso las funciones limitadas como, por ejemplo, strncpy(), pueden provocar vulnerabilidades cuando se utilizan incorrectamente. La combinación de manipulación de memoria y presuposiciones erróneas acerca del tamaño y la formación de una unidad de datos es el motivo principal de la mayoría de desbordamientos del búfer.

Las vulnerabilidades de buffer overflow suelen producirse en código que:

- Utiliza datos externos para controlar su comportamiento.

- Depende de las propiedades de los datos que se aplican fuera del ámbito inmediato del código.

- Es tan complejo que un programador no puede predecir con precisión su comportamiento.



Los siguientes ejemplos muestran estos tres escenarios.

Ejemplo 1.a: el siguiente código de ejemplo muestra un buffer overflow sencillo que a menudo lo provoca el primer escenario en el que el código utiliza los datos externos para controlar su comportamiento. El código utiliza la función gets() para leer una cantidad arbitraria de datos en un búfer de pila. Como no hay forma de limitar la cantidad de datos leídos por esta función, la seguridad del código depende siempre de que el usuario introduzca un número de caracteres inferior a BUFSIZE.

	...
	char buf[BUFSIZE];
	gets(buf);
	...

Ejemplo 1.b: en este ejemplo se muestra lo fácil que es imitar el comportamiento poco seguro de la función gets() en C++ mediante el uso del operador >> para leer la entrada en una cadena char[].

	...
	char buf[BUFSIZE];
	cin >> (buf);
	...

Ejemplo 2: el código de este ejemplo utiliza también la entrada de usuario para controlar su comportamiento, pero añade un nivel de indirección con el uso de la función de copia de memoria limitada memcpy(). Esta función acepta un búfer de destino y uno de origen, y el número de bytes que se va a copiar. El búfer de entrada se llena con una llamada limitada a read(). Sin embargo, el usuario especifica el número de bytes que memcpy() copia.

	...
char buf[64], in[MAX_SIZE];
printf("Enter buffer contents:\n");
read(0, in, MAX_SIZE-1);
printf("Bytes to copy:\n");
scanf("%d", &bytes);
memcpy(buf, in, bytes);
	...

Nota: este tipo de vulnerabilidad de buffer overflow (en el que un programa lee datos y, a continuación, confía en un valor de los datos de las operaciones de memoria posteriores en los datos restantes) ha surgido con frecuencia en bibliotecas de imágenes, audio y otros archivos.

Ejemplo 3: este es un ejemplo del segundo escenario en el que el código depende de propiedades de los datos que no se han verificado localmente. En este ejemplo una función denominada lccopy() utiliza una cadena como argumento y devuelve la copia asignada por montón de la cadena con las letras en mayúsculas convertidas a minúsculas. La función no realiza ninguna comprobación de límites en esta entrada por esquema que str sea siempre menor que BUFSIZE. Si un usuario malintencionado omite las comprobaciones del código que llama a lccopy() o si un cambio realizado en ese código invalida la presuposición acerca del tamaño de str, lccopy() desbordará buf con la llamada a strcpy() no limitada.

char *lccopy(const char *str) {
	char buf[BUFSIZE];
	char *p;

	strcpy(buf, str);
	for (p = buf; *p; p++) {
		if (isupper(*p)) {
			*p = tolower(*p);
		}
	}
	return strdup(buf);
}

Ejemplo 4: El siguiente código demuestra el tercer escenario en el que el código es tan complejo que su comportamiento no se puede predecir fácilmente. Este código proviene del popular decodificador de imágenes libPNG, que es utilizado por una amplia gama de aplicaciones.

El código parece realizar con seguridad la comprobación de límites porque comprueba el tamaño de la longitud de variable, que se utiliza posteriormente para calcular la cantidad de datos copiados por png_crc_read(). Sin embargo, justo después de que se pruebe la longitud, el código realiza una comprobación en png_ptr->mode y, si esta presenta errores, se emite una advertencia y el proceso continúa. Como length se prueba en un bloque else if, length no se probará si la primera comprobación presenta errores y se utilizará ciegamente en la llamada a png_crc_read(), provocando un posible buffer overflow de pila.

Aunque el código de este ejemplo no es el más complejo que hayamos visto, muestra por qué debe reducirse al mínimo la complejidad en el código que realiza operaciones de memoria.

if (!(png_ptr->mode & PNG_HAVE_PLTE)) {
	/* Should be an error, but we can cope with it */
png_warning(png_ptr, "Missing PLTE before tRNS");
}
else if (length > (png_uint_32)png_ptr->num_palette) {
png_warning(png_ptr, "Incorrect tRNS chunk length");
png_crc_finish(png_ptr, length);
return;
}
...
png_crc_read(png_ptr, readbuf, (png_size_t)length);

Ejemplo 5: en este ejemplo también se muestra el tercer escenario en el que la complejidad del programa lo expone a desbordamientos del búfer. En ese caso, la exposición se debe a la interfaz ambigua de una de las funciones en lugar de a la estructura del código (como sí lo hacía en el ejemplo anterior).

La función getUserInfo() utiliza un nombre de usuario especificado por una cadena multibyte y un puntero a una estructura para la información de usuario, y rellena la estructura con información del usuario. Como la autenticación de Windows utiliza Unicode para los nombres de usuario, el argumento username se convierte primero de una cadena multibyte a una Unicode. A continuación, esta función transfiere de forma incorrecta el tamaño de unicodeUser en bytes en lugar de caracteres. Así pues, la llamada a MultiByteToWideChar() puede escribir hasta (UNLEN+1)*sizeof(WCHAR) caracteres anchos o
(UNLEN+1)*sizeof(WCHAR)*sizeof(WCHAR) bytes en la matriz unicodeUser, que solo tiene (UNLEN+1)*sizeof(WCHAR) bytes asignados. Si la cadena username contiene más de UNLEN caracteres, la llamada a MultiByteToWideChar() desbordará el búfer unicodeUser.

void getUserInfo(char *username, struct _USER_INFO_2 info){
WCHAR unicodeUser[UNLEN+1];
	MultiByteToWideChar(CP_ACP, 0, username, -1,
    	      			unicodeUser, sizeof(unicodeUser));
NetUserGetInfo(NULL, unicodeUser, 2, (LPBYTE *)&info);
}

El buffer overflow es probablemente la forma más conocida de vulnerabilidad de seguridad de software. La mayoría de los desarrolladores de software saben lo que es una vulnerabilidad de buffer overflow, pero a menudo este tipo de ataques contra las aplicaciones existentes y desarrolladas recientemente son aún bastante habituales. Parte del problema se debe a la amplia variedad de formas en las que puede producirse un buffer overflow y otra parte se debe a las técnicas proclives a errores que a menudo se utilizan para evitarlas.

En un ataque de buffer overflow clásico, el usuario malintencionado envía datos a un programa, que los almacena en un búfer de pila demasiado pequeño. El resultado es que se sobrescribe la información de la pila de llamadas, incluido el puntero de devolución de la función. Los datos establecen el valor del puntero de devolución para que, cuando se devuelva la función, esta transfiera el control al código malicioso incluido en los datos del usuario malintencionado.

Aunque este tipo de buffer overflow de pila aún es frecuente en algunas plataformas y comunidades de desarrolladores, existen diversos tipos adicionales de buffer overflow, incluidos los desbordamientos del búfer de montón y los errores por uno ("off-by-one"), entre otros. Hay una serie de libros excelentes que ofrecen información detallada sobre cómo funcionan los ataques de buffer overflow, incluidos "Bilding Secure Software" [1], "Writing Secure Code" [2] y "The Shellcoder's Handbook" [3].

En el nivel de código, las vulnerabilidades de buffer overflow normalmente conllevan la infracción de las presuposiciones de un programador. Muchas funciones de manipulación de la memoria de C y C++ no realizan la comprobación de límites y pueden traspasar fácilmente los límites asignados de los búferes en los que operan. Incluso las funciones limitadas como, por ejemplo, strncpy(), pueden provocar vulnerabilidades cuando se utilizan incorrectamente. La combinación de manipulación de memoria y presuposiciones erróneas acerca del tamaño y la formación de una unidad de datos es el motivo principal de la mayoría de desbordamientos del búfer.

En este caso, una cadena de formato construida incorrectamente provoca que el programa escriba más allá de los límites de la memoria asignada.

Ejemplo 1: El código siguiente desborda c porque el tipo double necesita más espacio que el asignado para c.

void formatString(double d) {
    char c;

    scanf("%d", &c)
}

El buffer overflow es probablemente la forma más conocida de vulnerabilidad de seguridad de software. La mayoría de los desarrolladores de software saben lo que es una vulnerabilidad de buffer overflow, pero a menudo este tipo de ataques contra las aplicaciones existentes y desarrolladas recientemente son aún bastante habituales. Parte del problema se debe a la amplia variedad de formas en las que puede producirse un buffer overflow y otra parte se debe a las técnicas proclives a errores que a menudo se utilizan para evitarlas.

En un ataque de buffer overflow clásico, el usuario malintencionado envía datos a un programa, que los almacena en un búfer de pila demasiado pequeño. El resultado es que se sobrescribe la información de la pila de llamadas, incluido el puntero de devolución de la función. Los datos establecen el valor del puntero de devolución para que, cuando se devuelva la función, esta transfiera el control al código malicioso incluido en los datos del usuario malintencionado.

Aunque este tipo de buffer overflow de pila aún es frecuente en algunas plataformas y comunidades de desarrolladores, existen diversos tipos adicionales de buffer overflow, incluidos los desbordamientos del búfer de montón y los errores por uno ("off-by-one"), entre otros. Hay una serie de libros excelentes que ofrecen información detallada sobre cómo funcionan los ataques de buffer overflow, incluidos "Bilding Secure Software" [1], "Writing Secure Code" [2] y "The Shellcoder's Handbook" [3].

En el nivel de código, las vulnerabilidades de buffer overflow normalmente conllevan la infracción de las presuposiciones de un programador. Muchas funciones de manipulación de la memoria de C y C++ no realizan la comprobación de límites y pueden traspasar fácilmente los límites asignados de los búferes en los que operan. Incluso las funciones limitadas como, por ejemplo, strncpy(), pueden provocar vulnerabilidades cuando se utilizan incorrectamente. La combinación de manipulación de memoria y presuposiciones erróneas acerca del tamaño y la formación de una unidad de datos es el motivo principal de la mayoría de desbordamientos del búfer.

En este caso, una cadena de formato construida incorrectamente provoca que el programa escriba más allá de los límites de la memoria asignada.

Ejemplo 1: El código siguiente desborda buf porque, según el tamaño de f, el especificador de cadena de formato "%d %.1f ... " puede superar la cantidad de memoria asignada.

void formatString(int x, float f) {
   char buf[40];
   sprintf(buf, "%d %.1f ... ", x, f);
}

El buffer overflow es probablemente la forma más conocida de vulnerabilidad de seguridad de software. La mayoría de los desarrolladores de software saben lo que es una vulnerabilidad de buffer overflow, pero a menudo este tipo de ataques contra las aplicaciones existentes y desarrolladas recientemente son aún bastante habituales. Parte del problema se debe a la amplia variedad de formas en las que puede producirse un buffer overflow y otra parte se debe a las técnicas proclives a errores que a menudo se utilizan para evitarlas.

En un ataque de buffer overflow clásico, el usuario malintencionado envía datos a un programa, que los almacena en un búfer de pila demasiado pequeño. El resultado es que se sobrescribe la información de la pila de llamadas, incluido el puntero de devolución de la función. Los datos establecen el valor del puntero de devolución para que, cuando se devuelva la función, esta transfiera el control al código malicioso incluido en los datos del usuario malintencionado.

Aunque este tipo de error por uno ("off-by-one") sigue siendo normal en algunas plataformas y comunidades de desarrollo, hay más tipos de buffer overflow, entre los que se incluyen los desbordamientos de búfer de pila y de montón. Hay una serie de libros excelentes que ofrecen información detallada sobre cómo funcionan los ataques de buffer overflow, incluidos "Bilding Secure Software" [1], "Writing Secure Code" [2] y "The Shellcoder's Handbook" [3].

En el nivel de código, las vulnerabilidades de buffer overflow normalmente conllevan la infracción de las presuposiciones de un programador. Muchas funciones de manipulación de la memoria de C y C++ no realizan la comprobación de límites y pueden traspasar fácilmente los límites asignados de los búferes en los que operan. Incluso las funciones limitadas como, por ejemplo, strncpy(), pueden provocar vulnerabilidades cuando se utilizan incorrectamente. La combinación de manipulación de memoria y presuposiciones erróneas acerca del tamaño y la formación de una unidad de datos es el motivo principal de la mayoría de desbordamientos del búfer.

Ejemplo 1: El código siguiente contiene un desbordamiento del búfer por una unidad, que se produce cuando recv devuelve el máximo de bytes leídos: sizeof(buf). En este caso, la siguiente desreferencia de buf[nbytes] escribirá el byte null fuera de los límites de memoria asignada.

void receive(int socket) {
   char buf[MAX];
   int nbytes = recv(socket, buf, sizeof(buf), 0);
   buf[nbytes] = '\0';
   ...
}

El buffer overflow es probablemente la forma más conocida de vulnerabilidad de seguridad de software. La mayoría de los desarrolladores de software saben lo que es una vulnerabilidad de buffer overflow, pero a menudo este tipo de ataques contra las aplicaciones existentes y desarrolladas recientemente son aún bastante habituales. Parte del problema se debe a la amplia variedad de formas en las que puede producirse un buffer overflow y otra parte se debe a las técnicas proclives a errores que a menudo se utilizan para evitarlas.

En un ataque de buffer overflow clásico, el usuario malintencionado envía datos a un programa, que los almacena en un búfer de pila demasiado pequeño. El resultado es que se sobrescribe la información de la pila de llamadas, incluido el puntero de devolución de la función. Los datos establecen el valor del puntero de devolución para que, cuando se devuelva la función, esta transfiera el control al código malicioso incluido en los datos del usuario malintencionado.

Aunque este tipo de buffer overflow de pila aún es frecuente en algunas plataformas y comunidades de desarrolladores, existen diversos tipos adicionales de buffer overflow, incluidos los desbordamientos del búfer de montón y los errores por uno ("off-by-one"), entre otros. Hay una serie de libros excelentes que ofrecen información detallada sobre cómo funcionan los ataques de buffer overflow, incluidos "Bilding Secure Software" [1], "Writing Secure Code" [2] y "The Shellcoder's Handbook" [3].

En el nivel de código, las vulnerabilidades de buffer overflow normalmente conllevan la infracción de las presuposiciones de un programador. Muchas funciones de manipulación de la memoria de C y C++ no realizan la comprobación de límites y pueden traspasar fácilmente los límites asignados de los búferes en los que operan. Incluso las funciones limitadas como, por ejemplo, strncpy(), pueden provocar vulnerabilidades cuando se utilizan incorrectamente. La combinación de manipulación de memoria y presuposiciones erróneas acerca del tamaño y la formación de una unidad de datos es el motivo principal de la mayoría de desbordamientos del búfer.

Ejemplo 1: El código siguiente intenta evitar un buffer overflow por una unidad comprobando que el valor no confiable leído desde getInputLength() tiene un tamaño menor que el de la output del búfer de destino. Sin embargo, como la comparación entre len y MAX tiene signo, si len es negativo, se convertirá en un número positivo muy largo cuando se convierta a un argumento sin signo para memcpy().

void TypeConvert() {
   char input[MAX];
   char output[MAX];

   fillBuffer(input);
   int len = getInputLength();

   if (len <= MAX) {
      memcpy(output, input, len);
   }
   ...
}

El sistema de administración de dependencias automatizado Apache Ivy permite a los usuarios especificar un estado de versión, conocido como revisión dinámica, para una dependencia en lugar de enumerar la específica. Si un atacante puede comprometer el repositorio de dependencias o engañar al sistema de compilación para que descargue dependencias de un repositorio bajo su control, entonces un especificador de revisión dinámica puede ser todo lo que haga falta para que el sistema de compilación descargue y ejecute silenciosamente la dependencia comprometida. Aparte de los riesgos de seguridad, las revisiones dinámicas también introducen un elemento de riesgo en el frente de la calidad del código: Las revisiones dinámicas colocan la seguridad y la estabilidad de su software bajo el control de terceros que desarrollan y liberan las dependencias que utiliza su software.

En el momento de la compilación, Ivy se conecta al repositorio e intenta recuperar una dependencia que coincida con el estado indicado.

Ivy acepta los siguientes especificadores de revisión dinámica:

- latest.integration: selecciona la última revisión del módulo de dependencias.
- latest.[any status]: selecciona la última revisión del módulo de dependencias con al menos el estado especificado. Por ejemplo, latest.milestone seleccionará la última versión que sea un hito o un lanzamiento, y latest.release solo seleccionará el último lanzamiento.
- Cualquier revisión que termine en +: selecciona la última subrevisión del módulo de dependencias. Por ejemplo, si la dependencia existe en las revisiones 1.0.3, 1.0.7 y 1.1.2, una revisión especificada como 1.0.+ seleccionará la revisión 1.0.7.
- Intervalos de versiones: la notación matemática para intervalos, como <y>, se puede utilizar para hacer coincidir un intervalo de versiones.

Ejemplo 1: La siguiente entrada de configuración indica a Ivy que recupere la última versión de lanzamiento del componente clover:

<dependencies>
        <dependency org="clover" name="clover"
                    rev="latest.release" conf="build->*"/>
	...

Si el repositorio está comprometido, un atacante podría simplemente cargar una versión que cumpla con los criterios dinámicos para hacer que Ivy descargue una versión malintencionada de la dependencia.

Existen varias herramientas dentro del mundo del desarrollo de Java que facilitan la administración de dependencias: tanto Apache Ant como Apache Maven son sistemas de compilación que incluyen funcionalidad específicamente diseñada para facilitar la administración de dependencias, y Apache Ivy está diseñado expresamente como administrador de dependencias. Aunque existen diferencias en su comportamiento, estas herramientas comparten la funcionalidad común de descargar de forma automática dependencias externas especificadas en el proceso de compilación en tiempo de compilación. Así, resulta mucho más sencillo para un desarrollador B compilar software de la misma forma que un desarrollador A. Los desarrolladores simplemente almacenan información de dependencias en el archivo de compilación, lo que significa que cada desarrollador e ingeniero de compilación tiene una forma consistente de obtener dependencias, compilar el código y llevar a cabo la implementación sin las complicaciones de la administración de dependencias que supone la administración manual. En los siguientes ejemplos, se ilustra cómo Ivy, Ant y Maven se pueden utilizar para administrar dependencias externas como parte de un proceso de compilación.

Los desarrolladores especifican las dependencias externas en un destino de Ant mediante una tarea <get>, que recupera la dependencia especificada por la dirección URL correspondiente. Este enfoque es funcionalmente equivalente al escenario en el que un desarrollador documenta cada dependencia externa como un artefacto incluido en el proyecto de software, pero es más deseable porque automatiza la recuperación e incorporación de las dependencias cuando se realiza una compilación.

Ejemplo 1: El siguiente extracto de un archivo de configuración build.xml de Ant muestra una referencia típica a una dependencia externa:

<get src="http://people.apache.org/repo/m2-snapshot-repository/org/apache/openejb/openejb-jee/3.0.0-SNAPSHOT/openejb-jee-3.0.0-SNAPSHOT.jar"
dest="${maven.repo.local}/org/apache/openejb/openejb-jee/3.0.0-SNAPSHOT/openejb-jee-3.0.0-SNAPSHOT.jar"
usetimestamp="true" ignoreerrors="true"/>

Dos tipos distintos de escenarios de ataque afectan a estos sistemas: Un atacante podría comprometer el servidor que hospeda la dependencia o el servidor DNS que utiliza la máquina de compilación para redirigir las solicitudes de nombre de host del servidor que hospeda la dependencia a una máquina controlada por el atacante. Ambos escenarios dan lugar a que el atacante consiga inyectar una versión malintencionada de una dependencia en una compilación que se ejecuta en una máquina no comprometida.

Independientemente del vector de ataque utilizado para entregar la dependencia de troyano, estos escenarios comparten el elemento común de que el sistema de compilación acepta ciegamente el archivo binario malintencionado y lo incluye en la compilación. Dado que el sistema de compilación no tiene ningún recurso para rechazar el binario malintencionado y que los mecanismos de seguridad existentes, como la revisión del código, suelen centrarse en el código desarrollado internamente y no en las dependencias externas, este tipo de ataque tiene un gran potencial para pasar desapercibido a medida que se extiende por el entorno de desarrollo y, potencialmente, a producción.

Aunque existe cierto riesgo de que se introduzca una dependencia comprometida en un proceso de compilación manual, la tendencia de los sistemas de compilación automatizados a recuperar la dependencia de un origen externo cada vez que el sistema de compilación se ejecuta en un nuevo entorno aumenta enormemente la ventana de oportunidad para un atacante. Un atacante solo necesita comprometer el servidor de dependencias o el servidor DNS durante una de las muchas veces que se recupera la dependencia para comprometer la máquina en la que se está produciendo la compilación.

Existen varias herramientas dentro del mundo del desarrollo de Java que facilitan la administración de dependencias: tanto Apache Ant como Apache Maven son sistemas de compilación que incluyen funcionalidad específicamente diseñada para facilitar la administración de dependencias, y Apache Ivy está diseñado expresamente como administrador de dependencias. Aunque existen diferencias en su comportamiento, estas herramientas comparten la funcionalidad común de descargar de forma automática dependencias externas especificadas en el proceso de compilación en tiempo de compilación. Así, resulta mucho más sencillo para un desarrollador B compilar software de la misma forma que un desarrollador A. Los desarrolladores simplemente almacenan información de dependencias en el archivo de compilación, lo que significa que cada desarrollador e ingeniero de compilación tiene una forma consistente de obtener dependencias, compilar el código y llevar a cabo la implementación sin las complicaciones de la administración de dependencias que supone la administración manual. En los siguientes ejemplos, se ilustra cómo Ivy, Ant y Maven se pueden utilizar para administrar dependencias externas como parte de un proceso de compilación.

En Ivy, en lugar de enumerar las direcciones URL explícitas de las que recuperar las dependencias, los desarrolladores especifican los nombres y las versiones de las dependencias, e Ivy se basa en su configuración subyacente para identificar los servidores de los que recuperar las dependencias. Para los componentes de uso común, esta medida evita que el desarrollador tenga que investigar las ubicaciones de las dependencias.

Ejemplo 1: El siguiente extracto de un archivo ivy.xml de Ivy muestra cómo un desarrollador puede especificar múltiples dependencias externas usando su nombre y versión:

<dependencies>
  <dependency org="javax.servlet"
             name="servletapi"
              rev="2.3" conf="build->*"/>
  <dependency org="javax.jms"
             name="jms"
              rev="1.1" conf="build->*"/>  ...
</dependencies>

Dos tipos distintos de escenarios de ataque afectan a estos sistemas: Un atacante podría comprometer el servidor que hospeda la dependencia o el servidor DNS que utiliza la máquina de compilación para redirigir las solicitudes de nombre de host del servidor que hospeda la dependencia a una máquina controlada por el atacante. Ambos escenarios dan lugar a que el atacante consiga inyectar una versión malintencionada de una dependencia en una compilación que se ejecuta en una máquina no comprometida.

Independientemente del vector de ataque utilizado para entregar la dependencia de troyano, estos escenarios comparten el elemento común de que el sistema de compilación acepta ciegamente el archivo binario malintencionado y lo incluye en la compilación. Dado que el sistema de compilación no tiene ningún recurso para rechazar el binario malintencionado y que los mecanismos de seguridad existentes, como la revisión del código, suelen centrarse en el código desarrollado internamente y no en las dependencias externas, este tipo de ataque tiene un gran potencial para pasar desapercibido a medida que se extiende por el entorno de desarrollo y, potencialmente, a producción.

Aunque existe cierto riesgo de que se introduzca una dependencia comprometida en un proceso de compilación manual, la tendencia de los sistemas de compilación automatizados a recuperar la dependencia de un origen externo cada vez que el sistema de compilación se ejecuta en un nuevo entorno aumenta la ventana de oportunidad para un atacante. Un atacante solo necesita comprometer el servidor de dependencias o el servidor DNS durante una de las muchas veces que se recupera la dependencia para comprometer la máquina en la que se está produciendo la compilación.

Existen varias herramientas dentro del mundo del desarrollo de Java que facilitan la administración de dependencias: tanto Apache Ant como Apache Maven son sistemas de compilación que incluyen funcionalidad específicamente diseñada para facilitar la administración de dependencias, y Apache Ivy está diseñado expresamente como administrador de dependencias. Aunque existen diferencias en su comportamiento, estas herramientas comparten la funcionalidad común de descargar de forma automática dependencias externas especificadas en el proceso de compilación en tiempo de compilación. Así, resulta mucho más sencillo para un desarrollador B compilar software de la misma forma que un desarrollador A. Los desarrolladores simplemente almacenan información de dependencias en el archivo de compilación, lo que significa que cada desarrollador e ingeniero de compilación tiene una forma consistente de obtener dependencias, compilar el código y llevar a cabo la implementación sin las complicaciones de la administración de dependencias que supone la administración manual. En los siguientes ejemplos, se ilustra cómo Ivy, Ant y Maven se pueden utilizar para administrar dependencias externas como parte de un proceso de compilación.

En Maven, en lugar de enumerar las direcciones URL explícitas de las que recuperar las dependencias, los desarrolladores especifican los nombres y las versiones de las dependencias y Maven se basa en su configuración subyacente para identificar los servidores de los que recuperar las dependencias. Para los componentes de uso común, esta medida evita que el desarrollador tenga que investigar las ubicaciones de las dependencias.

Ejemplo 1: El siguiente extracto de un archivo pom.xml de Maven muestra cómo un desarrollador puede especificar múltiples dependencias externas usando su nombre y versión:

<dependencies>
  <dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.1</version>
  </dependency>
  <dependency>
    <groupId>javax.jms</groupId>
    <artifactId>jms</artifactId>
    <version>1.1</version>
  </dependency>
  ...
</dependencies>

Dos tipos distintos de escenarios de ataque afectan a estos sistemas: Un atacante podría comprometer el servidor que hospeda la dependencia o el servidor DNS que utiliza la máquina de compilación para redirigir las solicitudes de nombre de host del servidor que hospeda la dependencia a una máquina controlada por el atacante. Ambos escenarios dan lugar a que el atacante consiga inyectar una versión malintencionada de una dependencia en una compilación que se ejecuta en una máquina no comprometida.

Independientemente del vector de ataque utilizado para entregar la dependencia de troyano, estos escenarios comparten el elemento común de que el sistema de compilación acepta ciegamente el archivo binario malintencionado y lo incluye en la compilación. Dado que el sistema de compilación no tiene ningún recurso para rechazar el binario malintencionado y que los mecanismos de seguridad existentes, como la revisión del código, suelen centrarse en el código desarrollado internamente y no en las dependencias externas, este tipo de ataque tiene un gran potencial para pasar desapercibido a medida que se extiende por el entorno de desarrollo y, potencialmente, a producción.

Aunque existe cierto riesgo de que se introduzca una dependencia comprometida en un proceso de compilación manual, la tendencia de los sistemas de compilación automatizados a recuperar la dependencia de un origen externo cada vez que el sistema de compilación se ejecuta en un nuevo entorno aumenta enormemente la ventana de oportunidad para un atacante. Un atacante solo necesita comprometer el servidor de dependencias o el servidor DNS durante una de las muchas veces que se recupera la dependencia para comprometer la máquina en la que se está produciendo la compilación.

CakePHP puede configurarse para que exponga información de depuración que incluya errores, advertencias, instrucciones SQL y seguimientos de la pila. La información de depuración no se debe utilizar en los entornos de producción.

Ejemplo 1:

    Configure::write('debug', 3);

el segundo parámetro para el método Configure::write() indica el nivel de depuración. Cuanto mayor sea el número, más detallados serán los mensajes de registro.

Cuanto más tiempo permanezca una sesión abierta, más oportunidades tendrá un atacante para poner en peligros las cuentas de los usuarios. Durante el tiempo que una sesión permanece activa, un usuario malintencionado puede ser capaz de forzar el robo de la contraseña de un usuario, descifrar la clave de cifrado inalámbrico de un usuario o dirigir una sesión desde un explorador abierto. Los tiempos de expiración de sesión largos pueden, además, impedir que se libere memoria y que se produzca al final una denegación de servicio si se crea un número de sesiones suficientemente largo.

Ejemplo 1: en el siguiente ejemplo se muestra CakePHP configurado con la sesión de seguridad low.

    Configure::write('Security.level', 'low');

Junto con la opción Session.timeout, las opciones Security.level definen cuánto tiempo es válida una sesión. El tiempo de espera de sesión real es igual al Session.timeout por uno de los siguientes múltiplos:

'high' = x 10
'medium' = x 100
'low' = x 300

Incluso aunque Castor cree un bloqueo en un objeto, eso no impide que otros subprocesos lean o escriban en él. Las consultas de solo lectura son también unas siete veces más rápidas en comparación con el modo compartido predeterminado.

Ejemplo 1: el ejemplo siguiente especifica el modo de consulta como SHARED, que permite tener acceso de lectura y escritura.

results = query.execute(Database.SHARED);