• Phalcon\Security
• Phalcon\Security\Exception
• Phalcon\Security\JWT\Builder
• Phalcon\Security\JWT\Exceptions\UnsupportedAlgorithmException
• Phalcon\Security\JWT\Exceptions\ValidatorException
• Phalcon\Security\JWT\Signer\AbstractSigner
• Phalcon\Security\JWT\Signer\Hmac
• Phalcon\Security\JWT\Signer\None
• Phalcon\Security\JWT\Signer\SignerInterface
• Phalcon\Security\JWT\Token\AbstractItem
• Phalcon\Security\JWT\Token\Enum
• Phalcon\Security\JWT\Token\Item
• Phalcon\Security\JWT\Token\Parser
• Phalcon\Security\JWT\Token\Signature
• Phalcon\Security\JWT\Token\Token
• Phalcon\Security\JWT\Validator
• Phalcon\Security\Random

Class Phalcon\Security

Código fuente en GitHub

Este componente provee un conjunto de funciones para mejorar la seguridad en aplicaciones Phalcon

$login    = $this->request->getPost("login");
$password = $this->request->getPost("password");

$user = Users::findFirstByLogin($login);

if ($user) {
    if ($this->security->checkHash($password, $user->password)) {
        // The password is valid
    }
}

Constantes

const CRYPT_BLOWFISH = 4;
const CRYPT_BLOWFISH_A = 5;
const CRYPT_BLOWFISH_X = 6;
const CRYPT_BLOWFISH_Y = 7;
const CRYPT_DEFAULT = 0;
const CRYPT_EXT_DES = 2;
const CRYPT_MD5 = 3;
const CRYPT_SHA256 = 8;
const CRYPT_SHA512 = 9;
const CRYPT_STD_DES = 1;

Propiedades

/**
 * @var int|null
 */
protected defaultHash;

/**
 * @var int
 */
protected numberBytes = 16;

/**
 * @var Random
 */
protected random;

/**
 * @var string}null
 */
protected requestToken;

/**
 * @var string|null
 */
protected token;

/**
 * @var string|null
 */
protected tokenKey;

/**
 * @var string
 */
protected tokenKeySessionId = $PHALCON/CSRF/KEY$;

/**
 * @var string
 */
protected tokenValueSessionId = $PHALCON/CSRF$;

/**
 * @var int
 */
protected workFactor = 10;

/**
 * @var SessionInterface|null
 */
private localSession;

/**
 * @var RequestInterface|null
 */
private localRequest;

Métodos

public function __construct( SessionInterface $session = null, RequestInterface $request = null );

Constructor Phalcon\Security

public function checkHash( string $password, string $passwordHash, int $maxPassLength = int ): bool;

Comprueba si una contraseña de texto plano y su versión hash coinciden

public function checkToken( mixed $tokenKey = null, mixed $tokenValue = null, bool $destroyIfValid = bool ): bool;

Comprueba si el token CSRF enviado en la consulta es el mismo que el almacenado en la sesión actual

public function computeHmac( string $data, string $key, string $algo, bool $raw = bool ): string;

Calcula un HMAC

public function destroyToken(): Security;

Elimina el valor y clave del token CSRF de la sesión

public function getDefaultHash(): int | null;

Devuelve el hash predeterminado

public function getRandom(): Random;

Devuelve una instancia del generador seguro de números aleatorio

public function getRandomBytes(): int;

Devuelve un número de bytes a ser generados por el generador pseudoaleatorio de openssl

public function getRequestToken(): string | null;

Devuelve el valor del token CSRF para la petición actual.

public function getSaltBytes( int $numberBytes = int ): string;

Generate a >22-length pseudo random string to be used as salt for passwords

public function getSessionToken(): string | null;

Devuelve el valor del token CSRF en sesión

public function getToken(): string;

Genera un token pseudo aleatorio para ser usado como valor en inputs en el chequeo de CSRF

public function getTokenKey(): string;

Genera un token pseudo aleatorio para ser usando como nombre en inputs en el chequeo de CSRF

public function getWorkFactor(): int

public function hash( string $password, int $workFactor = int ): string;

Crea un hash de contraseña utilizando bcrypt con una sal pseudo aleatoria

public function isLegacyHash( string $passwordHash ): bool;

Comprueba si una contraseña hash es un hash bcrypt válido

public function setDefaultHash( int $defaultHash ): Security;

Establece el hash por defecto

public function setRandomBytes( int $randomBytes ): Security;

Establece un número de bytes a ser generados por el generador pseudo aleatorio de openssl

public function setWorkFactor( int $workFactor ): Security;

Establece el factor de trabajo

Class Phalcon\Security\Exception

Código fuente en GitHub

Phalcon\Security\Exception

Las excepciones lanzadas en Phalcon\Security usarán esta clase

Class Phalcon\Security\JWT\Builder

Código fuente en GitHub

Class Builder

@property CollectionInterface $claims @property CollectionInterface $jose @property string $passphrase @property SignerInterface $signer

@link https://tools.ietf.org/html/rfc7519

Propiedades

/**
 * @var CollectionInterface
 */
private claims;

/**
 * @var CollectionInterface
 */
private jose;

/**
 * @var string
 */
private passphrase;

/**
 * @var SignerInterface
 */
private signer;

Métodos

public function __construct( SignerInterface $signer );

Constructor.

public function getAudience();

public function getClaims(): array;

public function getContentType(): string | null;

public function getExpirationTime(): int | null;

public function getHeaders(): array;

public function getId(): string | null;

public function getIssuedAt(): int | null;

public function getIssuer(): string | null;

public function getNotBefore(): int | null;

public function getPassphrase(): string;

public function getSubject(): string | null;

public function getToken(): Token;

public function init(): Builder;

public function setAudience( mixed $audience ): Builder;

El reclamo “aud” (audiencia) identifica a los destinatarios para los que el JWT está destinado. Cada uno de los principales destinados a procesar el JWT DEBE se identifica con un valor en el reclamo de audiencia. Si el procesamiento principal del reclamo no se identifica con un valor en el reclamo “aud” cuando esta reclamación está presente, entonces el JWT DEBE ser rechazado. En el caso general, el valor “aud” es un vector de cadenas sensibles a mayúsculas y minúsculas, cada una contiene un valor StringOrURI. En el caso especial cuando el JWT tiene una audiencia, el valor “aud” PUEDE ser una cadena única sensible a mayúsculas y minúsculas que contiene un valor StringOrURI. La interpretación de los valores de la audiencia es generalmente específica de la aplicación. El uso de este reclamo es OPCIONAL.

public function setContentType( string $contentType ): Builder;

Establece el encabezado de tipo de contenido ‘cty’

public function setExpirationTime( int $timestamp ): Builder;

El reclamo “exp” (tiempo de caducidad) identifica el tiempo de expiración durante o después del cual el JWT NO DEBE ser aceptado para su procesamiento. El procesamiento del reclamo “exp” requiere que la fecha/hora actual DEBE ser anterior a la fecha/hora de vencimiento listada en el reclamo “exp”. Los implementadores PUEDEN proporcionar un pequeño margen de maniobra, por lo general no mayor de de unos pocos minutos, para tener en cuenta la desviación del reloj. Su valor DEBE ser un número que contenga un valor NumericDate. El uso de este reclamo es OPCIONAL.

public function setId( string $id ): Builder;

El reclamo “jti” (JWT ID) proporciona un identificador único para el JWT. El valor del identificador DEBE ser asignado de una manera que asegure que hay una probabilidad despreciable de que el mismo valor será asignado accidentalmente a un objeto de datos diferente; si la aplicación utiliza múltiples emisores, las colisiones DEBEN ser prevenidas entre los valores producidos por diferentes emisores también. El reclamo “jti” se puede usar para prevenir que el JWT se vuelva a reproducir. El valor “jti” es una cadena sensible a mayúsculas y minúsculas. El uso de este reclamo es OPCIONAL.

public function setIssuedAt( int $timestamp ): Builder;

El reclamo “iat” (emitida en) identifica el tiempo en el que el JWT fue emitido. Este reclamo se puede utilizar para determinar la edad del JWT. Su valor DEBE ser un número que contenga un valor NumericDate. El uso de este reclamo es OPCIONAL.

public function setIssuer( string $issuer ): Builder;

El reclamo “iss” (emisor) identifica al principal que emite el JWT. La tramitación de este reclamo es generalmente específica para la aplicación. El valor “iss” es una cadena sensible a mayúsculas y minúsculas que contiene un valor StringOrURI. El uso de este reclamo es OPCIONAL.

public function setNotBefore( int $timestamp ): Builder;

El reclamo “nbf” (no antes) identifica el tiempo anterior al cual el JWT NO DEBE ser aceptado para su procesamiento. El procesamiento del reclamo “nbf” requiere que la fecha/hora actual DEBE ser posterior o igual a la fecha/hora no anterior listada en el reclamo “nbf”. Los implementadores PUEDEN proporcionar un pequeño margen de maniobra, por lo general no mayor de de unos pocos minutos, para tener en cuenta la desviación del reloj. Su valor DEBE ser un número que contenga un valor NumericDate. El uso de este reclamo es OPCIONAL.

public function setPassphrase( string $passphrase ): Builder;

public function setSubject( string $subject ): Builder;

El reclamo “sub” (asunto) identifica el principal que es el sujeto del JWT. Los reclamos en un JWT son normalmente sentencias sobre el asunto. El valor del asunto DEBE ser localmente único en el contexto del emisor o ser único globalmente. La tramitación de este reclamo es generalmente específica para la aplicación. El valor “sub” es una cadena sensible a mayúsculas y minúsculas que contiene un valor StringOrURI. El uso de este reclamo es OPCIONAL.

Class Phalcon\Security\JWT\Exceptions\UnsupportedAlgorithmException

Código fuente en GitHub

Este fichero es parte del Framework Phalcon.

(c) Phalcon Team [email protected]

Para obtener toda la información sobre derechos de autor y licencias, por favor vea el archivo LICENSE.txt que se distribuyó con este código fuente.

Class Phalcon\Security\JWT\Exceptions\ValidatorException

Código fuente en GitHub

Este fichero es parte del Framework Phalcon.

(c) Phalcon Team [email protected]

Para obtener toda la información sobre derechos de autor y licencias, por favor vea el archivo LICENSE.txt que se distribuyó con este código fuente.

Abstract Class Phalcon\Security\JWT\Signer\AbstractSigner

Código fuente en GitHub

Class AbstractSigner

@property string $algo

Propiedades

/**
 * @var string
 */
protected algorithm;

Métodos

public function getAlgorithm(): string

Class Phalcon\Security\JWT\Signer\Hmac

Código fuente en GitHub

Class Hmac

Métodos

public function __construct( string $algo = string );

Constructor Hmac.

public function getAlgHeader(): string;

Devuelve el valor que se utiliza para la cabecera “alg”

public function sign( string $payload, string $passphrase ): string;

Firma una carga útil usando la contraseña

public function verify( string $source, string $payload, string $passphrase ): bool;

Verificar una fuente pasada con una carga útil y una contraseña

Class Phalcon\Security\JWT\Signer\None

Código fuente en GitHub

Class None

Métodos

public function getAlgHeader(): string;

Devuelve el valor que se utiliza para la cabecera “alg”

public function getAlgorithm(): string;

Devuelve el algoritmo usado

public function sign( string $payload, string $passphrase ): string;

Firma una carga útil usando la contraseña

public function verify( string $source, string $payload, string $passphrase ): bool;

Verificar una fuente pasada con una carga útil y una contraseña

Interface Phalcon\Security\JWT\Signer\SignerInterface

Código fuente en GitHub

Este fichero es parte del Framework Phalcon.

(c) Phalcon Team [email protected]

Para obtener toda la información sobre derechos de autor y licencias, por favor vea el archivo LICENSE.txt que se distribuyó con este código fuente.

Métodos

public function getAlgHeader(): string;

Devuelve el valor que se utiliza para la cabecera “alg”

public function getAlgorithm(): string;

Devuelve el algoritmo usado

public function sign( string $payload, string $passphrase ): string;

Firma una carga útil usando la contraseña

public function verify( string $source, string $payload, string $passphrase ): bool;

Verificar una fuente pasada con una carga útil y una contraseña

Abstract Class Phalcon\Security\JWT\Token\AbstractItem

Código fuente en GitHub

Class AbstractItem

@property array $data

Propiedades

/**
 * @var array
 */
protected data;

Métodos

public function getEncoded(): string;

Class Phalcon\Security\JWT\Token\Enum

Código fuente en GitHub

Class Enum

@link https://tools.ietf.org/html/rfc7519

Constantes

const ALGO            = 'alg';
const AUDIENCE        = 'aud';
const CONTENT_TYPE    = 'cty';
const EXPIRATION_TIME = 'exp';
const ID              = 'jti';
const ISSUED_AT       = 'iat';
const ISSUER          = 'iss';
const NOT_BEFORE      = 'nbf';
const SUBJECT         = 'sub';
const TYPE            = 'typ';

Class Phalcon\Security\JWT\Token\Item

Código fuente en GitHub

Class Item

Métodos

public function __construct( array $payload, string $encoded );

Constructor Item.

public function get( string $name, mixed $defaultValue = null ): mixed | null;

public function getPayload(): array;

public function has( string $name ): bool;

Class Phalcon\Security\JWT\Token\Parser

Código fuente en GitHub

Class Parser

Métodos

public function parse( string $token ): Token;

Analiza un token y lo devuelve

Class Phalcon\Security\JWT\Token\Signature

Código fuente en GitHub

Class Item

Métodos

public function __construct( string $hash = string, string $encoded = string );

Constructor Signature.

public function getHash(): string;

Class Phalcon\Security\JWT\Token\Token

Código fuente en GitHub

Class Token

@property Item $claims @property Item $headers @property Signature $signature

@link https://tools.ietf.org/html/rfc7519

Propiedades

/**
 * @var Item
 */
private claims;

/**
 * @var Item
 */
private headers;

/**
 * @var Signature
 */
private signature;

Métodos

public function __construct( Item $headers, Item $claims, Signature $signature );

Constructor Token.

public function getClaims(): Item

public function getHeaders(): Item

public function getPayload(): string;

public function getSignature(): Signature

public function getToken(): string;

Class Phalcon\Security\JWT\Validator

Código fuente en GitHub

Class Validator

@property int $timeShift @property Token $token

Propiedades

/**
 * @var int
 */
private timeShift = 0;

/**
 * @var Token
 */
private token;

Métodos

public function __construct( Token $token, int $timeShift = int );

Constructor Validator.

public function setToken( Token $token ): Validator;

public function validateAudience( string $audience ): Validator;

public function validateExpiration( int $timestamp ): Validator;

public function validateId( string $id ): Validator;

public function validateIssuedAt( int $timestamp ): Validator;

public function validateIssuer( string $issuer ): Validator;

public function validateNotBefore( int $timestamp ): Validator;

public function validateSignature( SignerInterface $signer, string $passphrase ): Validator;

Class Phalcon\Security\Random

Código fuente en GitHub

Phalcon\Security\Random

Clase generadora segura de números aleatorios.

Proporciona un generador seguro de números aleatorios que es adecuado para generar clave de sesión en cookies HTTP, etc.

Phalcon\Security\Random podría ser útil principalmente para:

• Generación de claves (por ejemplo, generación de claves complicadas)
• Generando contraseñas aleatorias para nuevas cuentas de usuario
• Sistemas de cifrado

$random = new \Phalcon\Security\Random();

// Random binary string
$bytes = $random->bytes();

// Random hex string
echo $random->hex(10); // a29f470508d5ccb8e289
echo $random->hex(10); // 533c2f08d5eee750e64a
echo $random->hex(11); // f362ef96cb9ffef150c9cd
echo $random->hex(12); // 95469d667475125208be45c4
echo $random->hex(13); // 05475e8af4a34f8f743ab48761

// Random base62 string
echo $random->base62(); // z0RkwHfh8ErDM1xw

// Random base64 string
echo $random->base64(12); // XfIN81jGGuKkcE1E
echo $random->base64(12); // 3rcq39QzGK9fUqh8
echo $random->base64();   // DRcfbngL/iOo9hGGvy1TcQ==
echo $random->base64(16); // SvdhPcIHDZFad838Bb0Swg==

// Random URL-safe base64 string
echo $random->base64Safe();           // PcV6jGbJ6vfVw7hfKIFDGA
echo $random->base64Safe();           // GD8JojhzSTrqX7Q8J6uug
echo $random->base64Safe(8);          // mGyy0evy3ok
echo $random->base64Safe(null, true); // DRrAgOFkS4rvRiVHFefcQ==

// Random UUID
echo $random->uuid(); // db082997-2572-4e2c-a046-5eefe97b1235
echo $random->uuid(); // da2aa0e2-b4d0-4e3c-99f5-f5ef62c57fe2
echo $random->uuid(); // 75e6b628-c562-4117-bb76-61c4153455a9
echo $random->uuid(); // dc446df1-0848-4d05-b501-4af3c220c13d

// Random number between 0 and $len
echo $random->number(256); // 84
echo $random->number(256); // 79
echo $random->number(100); // 29
echo $random->number(300); // 40

// Random base58 string
echo $random->base58();   // 4kUgL2pdQMSCQtjE
echo $random->base58();   // Umjxqf7ZPwh765yR
echo $random->base58(24); // qoXcgmw4A9dys26HaNEdCRj9
echo $random->base58(7);  // 774SJD3vgP

Esta clase toma prestada parcialmente la librería SecureRandom de Ruby

@link http://ruby-doc.org/stdlib-2.2.2/libdoc/securerandom/rdoc/SecureRandom.html

Métodos

public function base58( int $len = null ): string;

Genera una cadena base58 aleatoria

Si $len no se especifica, se asume 16. Puede ser más grande en el futuro. El resultado puede contener caracteres alfanuméricos excepto 0, O, I y l.

Es similar a Phalcon\Security\Random:base64() pero se ha modificado para evitar tanto los caracteres no alfanuméricos como letras que pueden parecer ambiguas cuando se imprimen.

$random = new \Phalcon\Security\Random();

echo $random->base58(); // 4kUgL2pdQMSCQtjE

@see \Phalcon\Security\Random:base64 @link https://en.wikipedia.org/wiki/Base58 @throws Exception If secure random number generator is not available or unexpected partial read

public function base62( int $len = null ): string;

Genera una cadena base62 aleatoria

Si $len no se especifica, se asume 16. Puede ser más grande en el futuro.

Es similar a Phalcon\Security\Random:base58() pero se ha modificado para proporcionar el mayor valor que se puede utilizar de forma segura en las URLs sin necesidad de tener en cuenta los caracteres adicionales porque es [A-Za-z0-9].

$random = new \Phalcon\Security\Random();

echo $random->base62(); // z0RkwHfh8ErDM1xw

@see \Phalcon\Security\Random:base58 @throws Exception If secure random number generator is not available or unexpected partial read

public function base64( int $len = null ): string;

Genera una cadena base64 aleatoria

Si $len no se especifica, se asume 16. Puede ser más grande en el futuro. La longitud de la cadena resultante suele ser mayor de $len. Fórmula del tamaño: 4 * ($len / 3) y redondeado a un múltiplo de 4.

$random = new \Phalcon\Security\Random();

echo $random->base64(12); // 3rcq39QzGK9fUqh8

@throws Exception If secure random number generator is not available or unexpected partial read

public function base64Safe( int $len = null, bool $padding = bool ): string;

Genera una cadena base64 de URL segura aleatoria

Si $len no se especifica, se asume 16. Puede ser más grande en el futuro. La longitud de la cadena resultante suele ser mayor de $len.

Por defecto, el relleno no se genera porque “=” se puede usar como un delimitador de URL. El resultado puede contener A-Z, a-z, 0-9, “-“ y “_”. “=” también se usa si $padding es verdadero. Consulte RFC 3548 para la definición de base64 segura para URL.

$random = new \Phalcon\Security\Random();

echo $random->base64Safe(); // GD8JojhzSTrqX7Q8J6uug

@link https://www.ietf.org/rfc/rfc3548.txt @throws Exception If secure random number generator is not available or unexpected partial read

public function bytes( int $len = int ): string;

Genera una cadena binaria aleatoria

El método Random::bytes devuelve una cadena y acepta como entrada un entero representando la longitud en bytes a devolver.

Si $len no se especifica, se asume 16. Puede ser más grande en el futuro. El resultado puede contener cualquier byte: “x00” - “xFF”.

$random = new \Phalcon\Security\Random();

$bytes = $random->bytes();
var_dump(bin2hex($bytes));
// Possible output: string(32) "00f6c04b144b41fad6a59111c126e1ee"

@throws Exception If secure random number generator is not available or unexpected partial read

public function hex( int $len = null ): string;

Genera una cadena hexadecimal aleatoria

Si $len no se especifica, se asume 16. Puede ser más grande en el futuro. La longitud de la cadena resultante suele ser mayor de $len.

$random = new \Phalcon\Security\Random();

echo $random->hex(10); // a29f470508d5ccb8e289

@throws Exception If secure random number generator is not available or unexpected partial read

public function number( int $len ): int;

Genera un número aleatorio entre 0 y $len

Returns an integer: 0 <= result <= $len.

$random = new \Phalcon\Security\Random();

echo $random->number(16); // 8

@throws Exception If secure random number generator is not available, unexpected partial read or $len <= 0

public function uuid(): string;

Genera un UUID aleatorio v4 (IDentificador Único Universal)

La versión 4 de UUID es puramente aleatoria (excepto la versión). No contiene información significativa como dirección MAC, hora, etc. Ver RFC 4122 para detalles del UUID.

Este algoritmo establece el número de versión (4 bits) así como dos bits reservados. Todos los demás bits (los 122 bits restantes) se establecen usando una fuente de datos aleatoria o pseudoaleatoria. Los UUID de versión 4 tienen la forma xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx donde x es cualquier dígito hexadecimal e y es uno de 8, 9, A o B (p. ej., f47ac10b-58cc-4372-a567-0e02b2c3d479).

$random = new \Phalcon\Security\Random();

echo $random->uuid(); // 1378c906-64bb-4f81-a8d6-4ae1bfcdec22

@link https://www.ietf.org/rfc/rfc4122.txt @throws Exception If secure random number generator is not available or unexpected partial read

protected function base( string $alphabet, int $base, mixed $n = null ): string;

Genera una cadena aleatoria basada en el número ($base) de caracteres ($alphabet).

Si $n no se especifica, se asume 16. Puede ser más grande en el futuro.

@throws Exception If secure random number generator is not available or unexpected partial read