What is the most secure mcrpyt_encrypt algorithm?

Refresh

4 days ago

Views

28 time

3

I am trying to come up with a secure algorithm to encrypt and decrypt specific strings in my project I am working on. I am using the mcrypt_encrypt with the MCRYPT_RIJNDAEL_256 block cipher variation.

I have tested many and found this one to seem quite secure.

I am making the encrypt and decrypt into functions so I can call upon them for multiple instances in the future of my project. So far this is what I have come up with. My question here is if there is any way to make this more secure, harder to decrypt or if there are any newer formulas/methods that are known to be better.

function encrypt($privatekey, $stringe)
 {
     $var = mcrypt_encrypt(MCRYPT_RIJNDAEL_256, $privatekey, $stringe, 
 MCRYPT_MODE_CBC, $privatekey);
     return base64_encode($var);
 }
function decrypt($privatekey, $stringd)
{
    $stringd = str_replace("~", "+", $stringd);
    $var = mcrypt_decrypt(MCRYPT_RIJNDAEL_256, $privatekey, 
base64_decode($stringd), MCRYPT_MODE_CBC, $privatekey);
    $var = rtrim($var, "\0\4");
    return $var;
}

1 answers

0

mcrypt_encryptфункция была устаревшей, так как PHP 7.1.0 и REMOVED в РНР 7.2.0. Опираясь на эту функцию крайне не рекомендуется.

Если вы хотите сделать его более безопасным , сделать свое собственное шифрование с использованием mcrypt_encryptили AES.

Я сделаю один пример для вас.

Этот код использовать AES-128 с пользовательской функцией для дешифрования делает сложнее.

Вы можете сделать свои собственные изменения.

В этом примере мы имеем много данных, но нам не нужны все из них. они поддельные данные.

Кроме того, я сделать массив со случайной колонкой. (Данные имеют случайное расположение в массиве.)

<?php

define('private_key1', substr(md5('_Your_Key1_HERE_'),0,16));
define('private_key2', substr(md5('_Your_Key2_HERE_'),0,16));


class AesCipher
{
    const CIPHER = 'AES-128-CBC';
    const INIT_VECTOR_LENGTH = 16;
    protected $data;
    protected $initVector;
    protected $errorMessage;
    public function __construct()
    {
    }
    public static function encrypt($secretKey, $plainText)
    {
        try {
            if (!static::isKeyLengthValid($secretKey)) {
                throw new \InvalidArgumentException("Secret key's length must be 128, 192 or 256 bits");
            }
            $initVector = bin2hex(openssl_random_pseudo_bytes(static::INIT_VECTOR_LENGTH / 2));
            $raw = openssl_encrypt(
                $plainText,
                static::CIPHER,
                $secretKey,
                OPENSSL_RAW_DATA,
                $initVector
            );
            $result = base64_encode($initVector . $raw);
            if ($result === false) {
                return openssl_error_string();
            }
            return $result;
        } catch (\Exception $e) {
            return new static(isset($initVector), null, $e->getMessage());
        }
    }
    public static function decrypt($secretKey, $cipherText)
    {
        try {
            if (!static::isKeyLengthValid($secretKey)) {
                throw new \InvalidArgumentException("Secret key's length must be 128, 192 or 256 bits");
            }
            $encoded = base64_decode($cipherText);
            $initVector = substr($encoded, 0, static::INIT_VECTOR_LENGTH);
            $data = substr($encoded, static::INIT_VECTOR_LENGTH);
            $decoded = openssl_decrypt(
                $data,
                static::CIPHER,
                $secretKey,
                OPENSSL_RAW_DATA,
                $initVector
            );
            if ($decoded === false) {
                return openssl_error_string();
            }
            return $decoded;
        } catch (\Exception $e) {
            return new static(isset($initVector), null, $e->getMessage());
        }
    }
    public static function isKeyLengthValid($secretKey)
    {
        $length = strlen($secretKey);
        return $length == 16 || $length == 24 || $length == 32;
    }
    public function getData()
    {
        return $this->data;
    }
    public function getInitVector()
    {
        return $this->initVector;
    }
    public function getErrorMessage()
    {
        return $this->errorMessage;
    }
    public function hasError()
    {
        return $this->errorMessage !== null;
    }
}

function generateRandomString($length = 10) {
    $characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
    $charactersLength = strlen($characters);
    $randomString = '';
    for ($i = 0; $i < $length; $i++) {
        $randomString .= $characters[rand(0, $charactersLength - 1)];
    }
    return $randomString;
}

function custom_encrypt($string)
{
    $encrypted = base64_encode(strrev(base64_encode($string)));
    $encrypted = AesCipher::encrypt(private_key1,$encrypted);
    $array1 = array();
    $max_count = rand(5,10);
    $data_location = rand(1,$max_count);
    for($i = 1;$i <= $max_count;$i++)
    {
        if($i == $data_location)
        {
            $array1[$i] = $encrypted;
        }else{
            $array1[$i] = generateRandomString(strlen($encrypted)-1);
        }
    }
    return AesCipher::encrypt(private_key2,json_encode($array1));
}

function custom_decrypt($string)
{
    $decrypted = AesCipher::decrypt(private_key2,$string);
    $array1 = json_decode($decrypted,true);
    if(is_array($array1))
    {
        $data = "";
        foreach($array1 as $a_column)
        {
            if(strlen($data) < strlen($a_column))
            {
                $data = $a_column;
            }
        }
        $decrypted2 = AesCipher::decrypt(private_key1,$data);
        return base64_decode(strrev(base64_decode($decrypted2)));
    }
    return false;
}

$val1 = "hello world";
$enc_val = custom_encrypt($val1);
$dec_val = custom_decrypt($enc_val);

echo "Value :<br> $val1<hr>";
echo "Encrypted :<br> $enc_val<hr>";
echo "Decrypted :<br> $dec_val<hr>";
?>
Смотреть фильмы онлайн бабушка легкого поведения 2 фильм бесплатно