inc/encryption-functions.php

   1 <?php
   2 /************************************************************************
   3  * Mailer v0.2.1-FINAL                                Start: 04/04/2015 *
   4  * ===================                          Last change: 04/04/2015 *
   5  *                                                                      *
   6  * -------------------------------------------------------------------- *
   7  * File              : encryption-functions.php                         *
   8  * -------------------------------------------------------------------- *
   9  * Short description : Functions for encryption                         *
  10  * -------------------------------------------------------------------- *
  11  * Kurzbeschreibung  : Funktionen fuer Verschluesselung                 *
  12  * -------------------------------------------------------------------- *
  13  * Copyright (c) 2003 - 2009 by Roland Haeder                           *
  14  * Copyright (c) 2009 - 2016 by Mailer Developer Team                   *
  15  * For more information visit: http://mxchange.org                      *
  16  *                                                                      *
  17  * This program is free software; you can redistribute it and/or modify *
  18  * it under the terms of the GNU General Public License as published by *
  19  * the Free Software Foundation; either version 2 of the License, or    *
  20  * (at your option) any later version.                                  *
  21  *                                                                      *
  22  * This program is distributed in the hope that it will be useful,      *
  23  * but WITHOUT ANY WARRANTY; without even the implied warranty of       *
  24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        *
  25  * GNU General Public License for more details.                         *
  26  *                                                                      *
  27  * You should have received a copy of the GNU General Public License    *
  28  * along with this program; if not, write to the Free Software          *
  29  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,               *
  30  * MA  02110-1301  USA                                                  *
  31  ************************************************************************/
  32
  33 if (!defined('__SECURITY')) {
  34         exit();
  35 } // END - if
  36
  37 // Generate salt if not set
  38 function generateSalt ($salt = '', $hashLength = 48) {
  39         // The length should not be shorter than 48 to have 8 byte as salt
  40         assert(($hashLength >= 48) && ($hashLength <= 80));
  41
  42         // Is the salt set?
  43         if (empty($salt)) {
  44                 // Then generate it from various data
  45                 $salt = hashSha256($hashLength . ':' . mt_rand(100000, 999999) . ':' . getSiteKey());
  46         } // END - if
  47
  48         // Shorten salt ...
  49         $salt = substr($salt, 0, $hashLength - 64);
  50
  51         // Return salt
  52         return $salt;
  53 }
  54
  55 // Hashes a string with SHA256, salts it and returns it hexdecimal-encoded
  56 function hashString ($str, $salt = '') {
  57         // Generate salt
  58         $salt = generateSalt($salt, 64);
  59
  60         // Generate salt
  61         $hash = hashSha256($salt . $str);
  62
  63         // Return it
  64         return $salt . $hash;
  65 }
  66
  67 // Hash string with SHA256 and encode it to hex
  68 function hashSha256 ($str) {
  69         /// Hash string
  70         $hash = mhash(MHASH_SHA256, $str);
  71
  72         // Encode it to hexadecimal
  73         $hex = '';
  74         for ($i = 0; $i < strlen($hash); $i++) {
  75                 // Encode char to decimal, pad it with zero, add it
  76                 $hex .= padLeftZero(dechex(ord(substr($hash, $i, 1))), 2);
  77         } // END - if
  78
  79         // Make sure 'length modulo 2' = 0
  80         assert((strlen($hex) % 2) == 0);
  81
  82         // Return it
  83         return $hex;
  84 }
  85
  86 // "Calculates" password strength
  87 function calculatePasswordStrength ($password, $configEntry = 'min_password_length') {
  88         // Default score
  89         $score = 1;
  90
  91         if ((strlen($password) < 1) || (strlen($password) < getConfig($configEntry))) {
  92                 // Is to weak
  93                 return 0;
  94         } // END - if
  95
  96         // At least 8 chars long?
  97         if (strlen($password) >= 8) {
  98                 // Add score
  99                 $score++;
 100         } // END - if
 101
 102         // At least 10 chars long?
 103         if (strlen($password) >= 10) {
 104                 // Add score
 105                 $score++;
 106         } // END - if
 107
 108         // Lower and upper cases?
 109         if ((preg_match('/[a-z]/', $password)) && (preg_match('/[A-Z]/', $password))) {
 110                 // Add score
 111                 $score++;
 112         } // END - if
 113
 114         // Also numbers?
 115         if (preg_match('/[0-9]/', $password))  {
 116                 // Add score
 117                 $score++;
 118         } // END - if
 119
 120         // Special characters?
 121         if (preg_match('/.[!,@,#,$,%,^,&,*,?,\/,_,~,+,-,(,)]/', $password)) {
 122                 // Add score
 123                 $score++;
 124         } // END - if
 125
 126         // Return password score
 127         return $score;
 128 }
 129
 130 // "Translates" password strength/score
 131 function translatePasswordStrength ($strength) {
 132         // Return it translated
 133         return '{--PASSWORD_SCORE_' . bigintval($strength) . '--}';
 134 }
 135
 136 // Checks whether given password is strong enough
 137 function isStrongPassword ($password) {
 138         // Determine it
 139         return (calculatePasswordStrength($password) >= getConfig('min_password_score'));
 140 }
 141
 142 // "Translates" encryption algorithm
 143 function translateEncryptionAlgorithm ($algo) {
 144         // Default is 'NONE'
 145         $translated = '{--SELECT_NONE--}';
 146
 147         // Is a valid number? Also '0' is valid.
 148         if ((isValidNumber($algo)) || ($algo === '0')) {
 149                 // Get array
 150                 $algos = getSupportedEncryptionAlgorithms();
 151
 152                 // Is it there?
 153                 if (isset($algos[$algo])) {
 154                         // "Translate" it
 155                         $translated = strtoupper($algos[$algo]);
 156                 } else {
 157                         // Unknown/unsupported
 158                         $translated = '{--UNSUPPORTED_ENCRYPTION_ALGO--}';
 159                 }
 160         } // END - if
 161
 162         // Return it
 163         return $translated;
 164 }
 165
 166 // "Translates" encryption mode
 167 function translateEncryptionMode ($mode) {
 168         // Default is 'NONE'
 169         $translated = '{--SELECT_NONE--}';
 170
 171         // Is a valid number?
 172         if ((isValidNumber($mode)) || (is_numeric($mode))) {
 173                 // Get array
 174                 $modes = getSupportedEncryptionModes();
 175
 176                 // Is it there?
 177                 if (isset($modes[$mode])) {
 178                         // "Translate" it
 179                         $translated = strtoupper($modes[$mode]);
 180                 } else {
 181                         // Unknown/unsupported
 182                         $translated = '{--UNSUPPORTED_ENCRYPTION_MODE--}';
 183                 }
 184         } // END - if
 185
 186         // Return it
 187         return $translated;
 188 }
 189
 190 // "Getter" for an array of supported ("safe") encryption algorithms
 191 function getSupportedEncryptionAlgorithms () {
 192         // Get full list
 193         $algos = mcrypt_list_algorithms();
 194
 195         // Remove any unsecure (e.g. DES/3DES)
 196         foreach (array('des', 'tripledes') as $unsecure) {
 197                 // Search for it
 198                 $id = array_search($unsecure, $algos, TRUE);
 199
 200                 // Is it found?
 201                 if (isValidNumber($id)) {
 202                         // Remove it
 203                         unset($algos[$id]);
 204                 } // END - if
 205         } // END - foreach
 206
 207         // Return it
 208         return $algos;
 209 }
 210
 211 // "Getter" for an array of supported encryption modes
 212 function getSupportedEncryptionModes () {
 213         // Get full list
 214         $modes = mcrypt_list_modes();
 215
 216         // Return it
 217         return $modes;
 218 }
 219
 220 // Determines whether given encryption algorithm number is valid
 221 function isValidEncryptionAlgorithm ($algo) {
 222         // Default is not valid
 223         $isValid = FALSE;
 224
 225         // Is valid number?
 226         if (isValidNumber($algo)) {
 227                 // Get supported algorithms
 228                 $algos = getSupportedEncryptionAlgorithms();
 229
 230                 // Is it there?
 231                 $isValid = (isset($algos[$algo]));
 232         } // END - if
 233
 234         // Return status
 235         return $isValid;
 236 }
 237
 238 // Determines whether given encryption mode number is valid
 239 function isValidEncryptionMode ($mode) {
 240         // Default is not valid
 241         $isValid = FALSE;
 242
 243         // Is valid number?
 244         if ((isValidNumber($mode)) || (is_numeric($mode))) {
 245                 // Get supported algorithms
 246                 $modes = getSupportedEncryptionModes();
 247
 248                 // Is it there?
 249                 $isValid = (isset($modes[$mode]));
 250         } // END - if
 251
 252         // Return status
 253         return $isValid;
 254 }
 255
 256 // Encrypts a string by given algorithm and key
 257 function encrytStringByCipher ($str, $algo, $mode, $key) {
 258         // Init encryption
 259         $cipher = initEncryption($algo, $mode, $key);
 260
 261         // Encrypt it
 262         $encrypted = mcrypt_generic($cipher, $str);
 263
 264         // Deinit/close cipher
 265         deinitEncryption($cipher);
 266
 267         // Return encrypted
 268         return $encrypted;
 269 }
 270
 271 // Decrypts a string by given algorithm and key
 272 function decrytStringByCipher ($str, $algo, $mode, $key, $iv) {
 273         // Init encryption
 274         $cipher = initEncryption($algo, $mode, $key, $iv);
 275
 276         // Decrypt it
 277         $encrypted = mdecrypt_generic($cipher, $str);
 278
 279         // Deinit/close cipher
 280         deinitEncryption($cipher);
 281
 282         // Return encrypted
 283         return $encrypted;
 284 }
 285
 286 // Initializes encryption/decryption
 287 function initEncryption ($algo, $mode, $key, $iv = NULL) {
 288         // Must be valid algo/mode
 289         assert((isValidEncryptionAlgorithm($algo)) && (isValidEncryptionMode($mode)));
 290
 291         // Get algorithms/modes
 292         $algos = getSupportedEncryptionAlgorithms();
 293         $modes = getSupportedEncryptionModes();
 294
 295         // Open encryption module
 296         $cipher = mcrypt_module_open($algos[$algo], '', $modes[$mode], '');
 297
 298         // Ist not a resource?
 299         assert(is_resource($cipher));
 300
 301         // Is iv set?
 302         if (is_null($iv)) {
 303                 // Create IV
 304                 $iv = mcrypt_create_iv(mcrypt_enc_get_iv_size($cipher), MCRYPT_DEV_RANDOM);
 305         } // END - if
 306
 307         // Generate key size
 308         $keySize = mcrypt_enc_get_key_size($cipher);
 309
 310         // Key size must be smaller/equal key's size
 311         assert($keySize <= strlen($key));
 312
 313         // Initialize encryption
 314         mcrypt_generic_init($cipher, substr($key, 0, $keySize), $iv);
 315
 316         // Return prepared cipher
 317         return $cipher;
 318 }
 319
 320 // Deinitializes encryption cipher
 321 function deinitEncryption ($cipher) {
 322         // Ist not a resource?
 323         assert(is_resource($cipher));
 324
 325         // Deinit/close cipher
 326         mcrypt_generic_deinit($cipher);
 327         mcrypt_module_close($cipher);
 328 }
 329
 330 // [EOF]
 331 ?>