Ir al contenido principal

TCrypto: Una biblioteca de almacenamiento de valores-clave cifrada simple - Bibliotecas de PHP

Imagen relacionada
TCrypto en Github: TCrypto.
TCrypto es una biblioteca de almacenamiento de valores-clave en la memoria PHP 5.3+ simple y flexible. De forma predeterminada, se usará una cookie como back-end de almacenamiento.
TCrypto ha sido diseñado desde cero con la seguridad en mente. Algoritmos y modos seguros Creación automática y segura de vectores de inicialización. Creación de claves de encriptación y autenticación (Keytool) usando fuerte aleatoriedad. Rotación de teclas (teclas versionadas).
TCrypto se puede usar como un "controlador de sesión" escalable. Especialmente escalable, si las cookies se utilizan como back-end de almacenamiento. Esto es un poco como las sesiones de Ruby on Rails.
Hay un artículo que describe el uso básico de TCrypto en websec.io : TCrypto: almacenamiento de datos cifrados para aplicaciones PHP
Esta es una versión de vista previa (aunque se considera estable). El cifrado de clave estará disponible en la versión 1.0.0. De lo contrario, no se planean otros cambios entre el maestro de desarrollo actual y 1.0.0.
Nota de seguridad importante sobre la compresión de datos:
Antes del 6 de agosto de 2013, TCrypto permitía usar la compresión de datos cuando los datos también se codificaban. Esto puede llevar a la divulgación del texto plano (confidencial). Se recomienda a todos los usuarios de TCrypto actualizarse al maestro de desarrollo actual. Especialmente si CompressPlugin () se usó con encriptación de datos.
TCrypto se coloca en el dominio público.

Requisitos

TCrypto requiere PHP versión 5.3 o superior. Para utilizar el cifrado, la extensión Mcrypt o OpenSSL debe estar disponible. Si OpenSSL se utiliza para el cifrado, se requiere PHP 5.3.3 o superior. El complemento de compresión opcional requiere zlib.

Nota de instalación

TCrypto admite la instalación con Composer, pero asegúrese de utilizar al menos Composer versión 1.0.0-beta1 para instalar TCrypto (Composer era vulnerable a los ataques MITM anteriores a 1.0.0-beta1):

Cambios hacia atrás incompatibles

04 de diciembre de 2015 String () StorageHandler se renombró a PlainString ().

TCrypto Keymanager y Keytool

Keytool es una pequeña aplicación de línea de comandos que se utiliza para crear claves de encriptación y autenticación. Keytool también se puede usar para eliminar claves inactivas.
Antes de comenzar a utilizar TCrypto, ejecute Keytool y cree su primer conjunto de claves:
$ cd /path/to/TCrypto/bin
$ php keytool
Asegúrese de seleccionar el archivo de clave correcto (si es necesario, cambie el archivo de clave) y seleccione la opción 1 "Agregar nuevas claves".
Para eliminar las claves inactivas, ejecute Keytool y seleccione la opción 2 "Eliminar claves inactivas". Siempre debe eliminar las claves inactivas antes de agregar nuevas claves. Esto se debe a que las claves inactivas se determinan comparando la marca de tiempo de la clave primaria (actual) y la duración de la clave (las claves que no pueden estar activas se eliminan).
Hay algunas configuraciones de Keytool que puede ajustar. Archivo TCrypto/bin/keytool.config.php:
  • 'keyfile_permissions' : los permisos predeterminados del sistema de archivos para el archivo de claves
  • 'bytes_in_key_name' : longitud del nombre de la clave
  • 'key_max_lifetime' : debe ser igual a $ _macMaxLifetime en TCrypto
  • 'ubicación_archivo_clave' : la ubicación predeterminada del archivo de clave
Si elimina o comenta la configuración 'keyfile_permissions', chmod () no se ejecutará en absoluto para el archivo de claves.
Keytool almacena claves como una matriz PHP simple. El formato de clave es el siguiente:
<?php
array (
  'tcrypto_key_data' => 
  array (
    'keys' => 
    array (
      'index_xxx' => 
      array (
        'encryption' => 'key_xxx',
        'authentication' => 'key_xxx',
        'time' => xxx,
      ),
    ),
    'meta_data' => 
    array (
      'primary_index' => 'index_xxx',
      'last_key_creation_time' => xxx,
    ),
  ),
);

Ejemplo

<?php
require '/path/to/library/TCrypto/Loader.php';
$loader = new TCrypto\Loader();
$loader->register();

<?php
// Keymanager handles encryption/authentication keys. By default, Filesystem()
// method looks the keyfile from `TCrypto/Keystore/default` file. If you want to use
// another keyfile, simply give the full path of the keyfile to Filesystem()'s
// constructor. E.g.
// $keymanager = new TCrypto\KeyManager\Filesystem('/path/to/keyfile');
$keymanager = new TCrypto\KeyManager\Filesystem();
// You can also inject the key data as a plain PHP array using setKeysAsArray():
// $keymanager->setKeysAsArray(array('tcrypto_key_data'...));

// The data will be stored to a cookie.
$storage = new TCrypto\StorageHandler\Cookie();
// You can pass a boolean false as the first parameter for Cookie,
// this makes it possible to use cookies even if there is no HTTPS connection,
// although this is not recommended.
// The second parameter for Cookie specifies the name of the cookie.
// $storage = new TCrypto\StorageHandler\Cookie(false, 'my_cookie_name');

// or, to get TCrypto payload immediately back as a string:
// $storage = new TCrypto\StorageHandler\PlainString();
// $tcryptoPayload = $tcrypto->save();
// To feed back previously used TCrypto payload, pass it as a first argument to PlainString():
// $storage = new TCrypto\StorageHandler\PlainString($tcryptoPayload);

// In short, you can save TCrypto payload to, say, a database
// (without the need to use a specific database StorageHandler).
// Then you can fetch the TCrypto payload from the database, and
// feed it back into TCrypto.
// NOTE, using PlainString() StorageHandler will make
// $tcrypto->save() to output the actual payload.

// Initialize encryption using either OpenSSL or Mcrypt (optional).
$crypto = new TCrypto\CryptoHandler\OpenSslAes128Cbc();
// or
$crypto = new TCrypto\CryptoHandler\OpenSslAes256Cbc();
// or
$crypto = new TCrypto\CryptoHandler\McryptAes128Cbc();
// or
$crypto = new TCrypto\CryptoHandler\McryptAes256Cbc();

// Initialize the default plugin (serialize/unserialize).
$plugins = new TCrypto\PluginContainer();

// Attach an extra plugin (compress/uncompress) (optional).
$plugins->attachPlugin(new TCrypto\Plugin\CompressPlugin());

// Available options:
// (array) 'entropy_pool'
// (int) 'max_lifetime'
// (bool) 'save_on_set'
$options = array('max_lifetime' => 6400);

// Create a new Crypto instance and inject the needed dependencies.
$tcrypto = new TCrypto\Crypto($keymanager, $storage, $plugins, $crypto, $options);

// If you create a new TCrypto instance without passing any of the dependencies,
// e.g. $tc = new TCrypto\Crypto(), TCrypto will use the following defaults:
// $keyManager = new KeyManager\Filesystem(); // Uses the default keyfile.
// $storage = new StorageHandler\Cookie(); // Requires HTTPS connection.
// $plugins = new PluginContainer(); // Default serialize/unserialize plugin.
// $crypto = null // No encryption.
// $options = array() // No options are modified.

// Value can be any serializable data type. 
$tcrypto->setValue('key', 'value');
$tcrypto->setValue('object', new stdClass());
$tcrypto->removeValue('object');

echo $tcrypto->getValue('key'); // "value"
echo $tcrypto->getValue('object'); // "NULL"

// Saves the data to a storage.
$tcrypto->save();
// If PlainString() StorageHandler is being used, $tcrypto->save() will output
// the TCrypto payload (you need to store the payload by some other means).

// Destroys the data both from memory and storage.
$tcrypto->destroy();

Acerca del cifrado simétrico

Actualmente hay cuatro opciones para un proveedor de cifrado:
Crypto\CryptoHandler\OpenSslAes128Cbc
Crypto\CryptoHandler\McryptAes128Cbc
y
Crypto\CryptoHandler\OpenSslAes256Cbc
Crypto\CryptoHandler\McryptAes256Cbc
OpenSslAes128Cbc / McryptAes128Cbc y OpenSslAes256Cbc / McryptAes256Cbc implementan AES en modo CBC utilizando un vector de inicialización aleatorio. Solo el tamaño de la clave difiere entre ellos. El tamaño de la clave de 128 bits debe ser irrompible con tecnología previsible. Pero, por otro lado, las claves de 256 bits ofrecen más margen de seguridad (contra los canales laterales, etc.). El cifrado con claves de 128 bits debe ser algo más rápido que el cifrado con claves de 256 bits. Sin embargo, en un escenario típico de uso de aplicaciones web, esta diferencia de velocidad probablemente sea insignificante.
Si te sientes paranoico (cuanto más grande, mejor fetiche), usa McryptAes256Cbc. De lo contrario, use McryptAes128Cbc.
TCrypto deriva claves de cifrado a partir de datos variables (marcas de tiempo, vector de inicialización, semillas clave y fuentes de entropía extra suministradas por el usuario). Esto garantiza que se utilizará una clave nueva y aleatoria para cada operación de cifrado. La configuración de clave combinada con el hash SHA512 (truncado) garantiza que los ataques de clave relacionada (actualmente conocidos) no se apliquen contra AES-256 (McryptAes256Cbc).
Si su sistema es compatible con OpenSSL, use cifrado basado en OpenSSL (OpenSslAes128Cbc o OpenSslAes256Cbc).

Complementos

TCrypto viene con un simple "sistema de complemento". Los complementos se ejecutan en dos lugares separados.
  • Antes de guardar los datos en un almacenamiento.
  • Después de extraer los datos de un almacenamiento (los complementos se ejecutan en orden inverso).
Es importante tener en cuenta que no puede usar complementos de compresión de datos si está utilizando el cifrado de datos.
Si configura TCrypto para utilizar la compresión de datos al mismo tiempo que los datos se cifran, el complemento PluginContainer saltará automáticamente los complementos de compresión de datos.
Esto es importante porque la compresión de datos confidenciales (cifrados) puede filtrar información sobre el texto sin formato.
Esto crea el complemento serialize / unserialize requerido:
<? php
// PluginContainer () adjunta automáticamente DefaultPlugin (), que maneja 
// serialización y deserialización. 
$ plugins  =  new  TCrypto \ PluginContainer ();
También puede adjuntar más complementos:
<? php
// NOTE: CompressPlugin will not be run if data encryption is being used.
// This is because data compression leaks information about the plain text.
$plugins->attachPlugin(new TCrypto\Plugin\CompressPlugin());
Ahora los datos se serializarán primero y luego se comprimirán (al guardarlos). Al extraer los datos de un almacenamiento, los datos primero se descomprimen y luego se deserializan.
NOTA: $ plugins-> attach () ya no es compatible. Use $ plugins-> attachPlugin () en lugar de $ plugins-> attach ().
Etiquetas:

Comentarios

Publicar un comentario

Entradas más populares de este blog

Descargar vídeos y audios de YouTube con Python y Pafy

Introducción: YouTube es una plataforma que nos permite disfrutar de vídeos informativos, películas, música y mucho, mucho más. Siempre que escuchamos una canción queremos descargarla, si vemos un vídeo también queremos descargarlo, de esta manera podríamos verlos desde donde queramos sin necesidad de una conexión a Internet. Hoy te enseñare a descargar vídeos y audios de el sitio web conocido como YoutTube, esto lo lograremos haciendo uso de una librería llamada Pafy, si aun no tienes la librería Pafy, puedes descargarla ingresando al siguiente enlace:  Librería Pafy . Usando Pafy: Pafy una biblioteca de Python para descargar contenido de YouTube y recuperar metadatos. Antes de descargar contenido, usaremos a Pafy para obtener información de un vídeo especifico. A continuación te mostrare un ejemplo para obtener el titulo de un vídeo. import pafy url_video = " https://www.youtube.com/watch?v=JkK8g6FMEXE " video = pafy.new(url_video) pr
1 comentario
Leer más

Calculando el factorial de un número (ejemplo de función recursiva).

Hola, mi nombre es Antonio Alfonso Martínez y en el presente artículo me dispongo a explicar un sencillo método para calcular el factorial de un número haciendo uso del concepto de recursividad. Para empezar, diremos que el factorial de un número natural "n" es el resultado del producto de todos los números desde 1 hasta dicho número "n". Así, para efectuar el calculo del factorial de un número, vamos a emplear una sencilla función a la que daremos el nombre de "factorial". De modo, que, partiendo del hecho de que el factorial de 1 y 0 es 1, construiremos nuestra función (a la que daremos el nombre de "factorial") para realizar el calculo del factorial de 5: Lo que hace esta función, es tomar como argumento un número "n". de modo que si este es 0 o 1 ("if n==0 or n==1:") la función devolverá directamente como resultado el número 1 ("resultado=1"). Sin embargo si dicho número "n" es mayor que
Publicar un comentario
Leer más

Sistema Hexadecimal - Sistema de numeración posicional

Sistema Hexadecimal El sistema hexadecimal es un sistema numérico que tiene como base el numero 16, y es una variante de los numero binarios El sistema hexadecimal es utilizado por nuestros ordenadores con el fin de abreviar valores de datos e instrucciones de memoria. Esta es una imagen que muestra el contenido de un archivo con exención 'dll' en un editor de texto, como el editor de texto no reconoce este tipo de archivo, nos lo muestra de esta manera: Como se puede apreciar, en vez de ver una gran cantidad de 0 y 1, vemos que hay grupos de 4 dígitos, y si observamos, vemos que son grupos de dígitos hexadecimales. El archivo cuentan con más de 48 mil lineas, por ello no se me es posible mostrarlo todo. Este es uno de los usos del sistema hexadecimal para abreviar grandes cantidades de 0 y 1. Ustedes mismos pueden hacer la prueba con una imagen o con cualquier otro tipo de texto. El sistema hexadecima, esta conformado por solo 16 dígitos. A continuación te los
Publicar un comentario
Leer más