Lista de Classes
- App\Middleware\Cors
- App\Middleware\Auth
- App\Middleware\Env
- AppMin
- Application
- Route
- Data\Database
- Data\Db2Database
- Data\OdbcDatabase
- Data\Validator
- Data\KeyValue\SqliteStorage
- Data\Log\FileLogger
- Data\Log\HtmlLogger
- Encoding\Base64Url
- Encoding\Json
- Encoding\Utf8
- Environment\DotEnv
- Environment\System
- FileSystem\Search
- FileSystem\Security
- FileSystem\Sync
- Lang\I18N
- Lang\L10N
- Lang\Time
- Media\Image
- Net\Config
- Net\Email
- Net\HttpClient
- Net\HttpResponse
- Net\IP
- Net\SmtpClient
- Security\Crypto
- Security\Password
- Security\Crypto\Encryption
- Security\Crypto\FileEncryption
- Security\Crypto\JWT
- Security\Crypto\PublicKey
- Security\Crypto\Random
- Security\Crypto\SignedData
- Security\Web\CsrfSession
- Security\Web\CsrfStateless
- Security\Web\RateLimit
- Web\Request
- Web\Response
FastSitePHP\Security\Crypto
FastSitePHP Crypto Class
This is a helper class using a Facade Software Design Pattern to simplify Secure Encryption, Data Signing, and JWT usage.
This class allows for only the default secure settings of each object and requires secure keys to be defined in either the App Config Array or as Environment Variables.
By default Signed Data and JSON Web Tokens are valid for 1 hour and expire after. The expiration time can be changed from a parameter when calling either [sign()] or [encodeJWT].
Example usage:
$app->config['ENCRYPTION_KEY'] = 'dd8daccb9e2b66321a......';
$encrypted_text = Crypto::encrypt($data);
$decrypted_data = Crypto::decrypt($encrypted_text);
[$app] Config (or Environment Variables) Settings:
ENCRYPTION_KEY
encrypt()
decrypt()
encryptFile()
decryptFile()
SIGNING_KEY
sign()
verify()
JWT_KEY
encodeJWT()
decodeJWT()
Código Fonte
Código de Exemplo
Segurança - Criptografe e Descriptografe Dados
// Gere uma Chave para Criptografia.
// A chave é uma longa string hexadecimal de bytes aleatórios seguros.
// A chave seria tipicamente salva com seu app ou nas configurações.
$crypto = new \FastSitePHP\Security\Crypto\Encryption();
$key = $crypto->generateKey();
// Criptografe e Descriptografe utilizando a classe auxiliar Cypto com
// definições de configuração.
// Dados de diferentes tipos de dados pode ser criptografados e retornados
// no mesmo formato (string, int, objeto etc).
$app->config['ENCRYPTION_KEY'] = $key;
$encrypted_text = \FastSitePHP\Security\Crypto::encrypt($data);
$decrypted_data = \FastSitePHP\Security\Crypto::decrypt($encrypted_text);
// Criptografe e Descriptografe utilizando a classe Encryption. Esta classe
// fornece muitas opções adicionais que não estão na classe auxiliar.
$encrypted_text = $crypto->encrypt($data, $key);
$decrypted_data = $crypto->decrypt($encrypted_text, $key);
Segurança - Criptografe e Descriptografe um Arquivo
// O FastSitePHP permite uma autenticação de criptografia rápida de qualquer
// tamanho de arquivo(mesmo grandes arquivos que estão nos gigabytes de
// tamanho). O código utilizado para a criptografia é compatível com comandos
// de shell e um script Bash [encrypt.sh] que funciona em Computadores
// Linux e Unix. O script Bash pode ser baixado deste site e funcionará na
// maioria dos sistemas Linux sem que nada seja instalado.
// Gere uma Chave para Criptografia
$crypto = new \FastSitePHP\Security\Crypto\FileEncryption();
$key = $crypto->generateKey();
// Construa caminhos de arquivos para salvar, baseando-se no nome original
$enc_file = $file_path . '.enc';
$output_file = $enc_file . '.decrypted';
// Criptografe e Descriptografe utilizando a classe auxiliar Crypto com
// definições de configuração. Uma classe [FileEncryption] também existe com
// opções adicionais.
$app->config['ENCRYPTION_KEY'] = $key;
\FastSitePHP\Security\Crypto::encryptFile($file_path, $enc_file);
\FastSitePHP\Security\Crypto::decryptFile($enc_file, $output_file);
Segurança - Codifique e Decodifique um Token JSON Web (JWT)
// A carga do JWT pode ser um Objeto ou um Array (Dicionário).
$payload = [
'User' => 'John Doe',
'Roles' => ['Admin', 'SQL Editor']
];
// Gere um Chave para Codificação (Assinando).
// A chave é uma longa string hexadecimal de bytes aleatórios seguros.
// A chave seria tipicamente salva com seu app ou nas configurações.
$jwt = new \FastSitePHP\Security\Crypto\JWT();
$key = $jwt->generateKey();
// Codifique e Decodifique o JWT com a Classe Auxiliar Crypto e Definições
// de Configuração.
// Ao utilizar os parâmetros padrão com ao classe auxiliar, os dados tem
// validade de uma hora.
$app->config['JWT_KEY'] = $key;
$token = \FastSitePHP\Security\Crypto::encodeJWT($payload);
$data = \FastSitePHP\Security\Crypto::decodeJWT($token);
// Codifique (Assine) e Decodifique (Verifique) utilizando a classe JWT. Ao
// utilizar as definições padrão com a classe JWT, nenhuma expiração é
// especificada, todas as reivindicações são validadas e uma chave é
// necessária.
$token = $jwt->encode($payload, $key);
$data = $jwt->decode($token, $key);
// Adicione Reivindicações à Carga Válida e utilize uma Chave Insegura para
// Compatibilidade com ouros sits (Geralmente demonstrações online de JWT
// são mostradas utilizando senhas simples para a chave). Por padrão, chaves
// necessitam ser seguras, com comprimento apropriado e no formato Base64 ou
// Hexadecimal.
$payload = $jwt->addClaim($payload, 'exp', '+10 minutes');
$payload = $jwt->addClaim($payload, 'iss', 'example.com');
$jwt
->useInsecureKey(true)
->allowedIssuers(['example.com']);
$insecure_key = 'password123';
$token = $jwt->encode($payload, $insecure_key);
$data = $jwt->decode($token, $insecure_key);
Segurança - Sign and Verify Data
// Utilizar [SignedData] tem um conceito parecido ao de utilizar JWT.
// Um cliente pode ler os dados mas não modificá-los.
// Gere uma Chave para Assinar.
// A chave é uma longa string hexadecimal de bytes aleatórios seguros.
// A chave seria tipicamente salva com seu app ou nas configurações.
$csd = new \FastSitePHP\Security\Crypto\SignedData();
$key = $csd->generateKey();
// Assine e Verifique utilizando a Classe Auxiliar Cypto com Definições de
// Configuração. Ao utilizar os parâmetros padrão com a classe auxiliar, os
// dados expiram em uma hora. Dados para diferentes tipos de dados podem
// ser assinados e verificados em seu format original (string, int, object,
// etc).
$app->config['SIGNING_KEY'] = $key;
$signed_text = \FastSitePHP\Security\Crypto::sign($data);
$verified_data = \FastSitePHP\Security\Crypto::verify($signed_text);
// Assina e Verifica utilizando a Classe SignedData Class. A Classe
// SignedData permite opções adicionais e não utiliza definições de
// configuração. O parâmetro [$expire_time] é opcional.
$expire_time = '+20 minutes';
$signed_text = $csd->sign($data, $key, $expire_time);
$verified_data = $csd->verify($signed_text, $key);
Métodos
encrypt($data)
Encrypt data (string, int, float, bool, object, or array) and return the encrypted text as a base64-url string.
Retorna: string
decrypt($encrypted_text)
Decrypt data that was encrypted using the [encrypt()] function and return the original value.
The same data type is returned so if a string was encrypted a string will be returned and if an array was encrypted then an array will be returned. Objects of type stdClass or custom classes that were encrypted are returned as an Array (Dictionary).
If decryption fails then null will be returned.
Retorna: mixed
sign($data, $expire_time = '+1 hour')
Sign data (string, int, float, bool, object, or array) and return the signed data in one of the following formats:
'base64url(data).type.base64url(signature)'
'base64url(data).type.timestamp.base64url(signature)'
The default expiration time is 1 hour; this can be changed to a different time or turned off passing [null].
Retorna: string
verify($signed_text)
Verify data that was signed using the [sign()] function and return the original value.
The same data type is returned so if a string was signed a string will be returned and if an array was signed then an array will be returned. Objects of type stdClass or custom classes that were signed are returned as an Array (Dictionary).
If verification fails then null will be returned.
Retorna: mixed
encryptFile($file_path, $enc_file)
Encrypt a file
If a file is 10 MB or smaller (or any size on Windows) then it will be processed in memory, otherwise the file will be processed using shell commands. This allows for files of any size to be encrypted.
If you need to encrypt files that are larger than 2 GB on a 32-Bit OS then you should use the [FileEncryption] class directly like this:
$crypto = new FileEncryption();
$crypto->processFilesWithCmdLine(true);
$crypto->encryptFile($file_path, $enc_file, $key);
decryptFile($enc_file, $output_file)
Decrypt a file that was created from [encryptFile()]. The same memory and OS rules apply for file processing.
This function has no return value so if decryption fails an exception is thrown.
encodeJWT($payload, $exp_time = '+1 hour')
Create a JSON Web Token (JWT) with a default expiration time of 1 hour.
Retorna: string
decodeJWT($token)
Decode and Verify a JWT. If the token is not valid null will be returned.
Retorna: array - The payload that was originally encoded.