function decryptCookie($value)
{
    if (!$value) {
        return false;
    }
    $value = base64_decode($value);
    $cookiedough = unserialize($value);
    // generate an SHA-256 HMAC hash where data = encrypted text and key = defined constant
    $snifftest = hash_hmac('sha256', $cookiedough['text'], SIG_HMAC);
    // if it matches the stored signature, you pass.
    if (!($cookiedough['sig'] == $snifftest)) {
        die("Oops!  It looks like something went wrong with your browser cookies.  Please ensure that cookies are enabled in your browser.  If the problem persists, please notify your library.");
    }
    // generate an SHA-256 HMAC hash where data = session ID and key = defined constant
    $key = hash_hmac('sha256', session_id(), ENCRYPTION_KEY_HMAC);
    if (strlen($key) > 24) {
        $key = substr($key, 0, 24);
    }
    $iv = $cookiedough['iv'];
    $decrypttext = mcrypt_decrypt(MCRYPT_RIJNDAEL_256, $key, $cookiedough['text'], MCRYPT_MODE_CBC, $iv);
    $data = @unserialize($decrypttext);
    if ($decrypttext === 'b:0;' || $data !== false) {
        $decrypttext = $data;
    }
    if (is_array($decrypttext)) {
        return $decrypttext;
    } else {
        return trim($decrypttext);
    }
}

function DecryptString($str)
{
    $hash = hash('sha512', 'Imp3ro', true);
    $key = substr($hash, 0, 0x20);
    $iv = substr($hash, 0x20, 0x10);
    return UnPadString(mcrypt_decrypt(MCRYPT_RIJNDAEL_128, $key, $str, 'cbc', $iv));
}

 /**
  * @param string $encryptedText
  * @return string
  */
 public function decrypt($encryptedText)
 {
     $encryptedTextDecoded = base64_decode($encryptedText);
     $ivDecoded = substr($encryptedTextDecoded, 0, $this->size);
     $encryptedTextDecoded = substr($encryptedTextDecoded, $this->size);
     return trim(mcrypt_decrypt($this->cypher, $this->key, $encryptedTextDecoded, $this->mode, $ivDecoded));
 }

 private static function _decrypt($value, $key)
 {
     $iv_size = mcrypt_get_iv_size(MCRYPT_RIJNDAEL_256, MCRYPT_MODE_ECB);
     $iv = mcrypt_create_iv($iv_size, MCRYPT_RAND);
     $decrypttext = mcrypt_decrypt(MCRYPT_RIJNDAEL_256, $key, base64_decode($value), MCRYPT_MODE_ECB, $iv);
     return trim($decrypttext);
 }

function decrypt($encrypted_string, $encryption_key)
{
    $iv_size = mcrypt_get_iv_size(MCRYPT_BLOWFISH, MCRYPT_MODE_ECB);
    $iv = mcrypt_create_iv($iv_size, MCRYPT_RAND);
    $decrypted_string = mcrypt_decrypt(MCRYPT_BLOWFISH, $encryption_key, base64_decode($encrypted_string), MCRYPT_MODE_ECB, $iv);
    return $decrypted_string;
}

 public static function DecryptString($key, $iv, $dec)
 {
     if (is_null($key) || is_null($iv) || is_null($dec)) {
         return $dec;
     }
     return base64_decode(mcrypt_decrypt(CRYPTO_METHOD, $key, $dec, CRYPTO_MODE, $iv));
 }

function getLoginCookie()
{
    //voodoo
    list($encryptedData, $iv) = explode(":", $_COOKIE["usr"]);
    $rawData = mcrypt_decrypt(MCRYPT_RIJNDAEL_256, getSecret(), base64_decode($encryptedData), MCRYPT_MODE_CBC, $iv);
    return unserialize($rawData);
}

 /**
  * Decrypt string
  *
  * NOTICE: the code in general, this method in particular, comes with absolutely no warranty. If security is
  * important for you, then use a purpose built package. https://github.com/defuse/php-encryption seems like
  * a good candidate.
  * @deprecated Do not trust a two-line decryption-method.
  *
  * @param string $string String to decrypt
  * @param string $key Key to encrypt/decrypt.
  * @return string Decrypted string
  */
 public static function decrypt($string, $key)
 {
     $encryptedString = base64_decode($string);
     $initializationVector = substr($encryptedString, 0, mcrypt_get_iv_size(MCRYPT_RIJNDAEL_256, MCRYPT_MODE_ECB));
     $decryptedString = rtrim(mcrypt_decrypt(MCRYPT_RIJNDAEL_256, hash("sha256", $key, true), substr($encryptedString, mcrypt_get_iv_size(MCRYPT_RIJNDAEL_256, MCRYPT_MODE_ECB)), MCRYPT_MODE_CBC, $initializationVector), "");
     return $decryptedString;
 }

 /**
  *
  * Decrypt a string (Passwords)
  *
  * @param string $string value to decrypt
  *
  * @return string decrypted string
  */
 public static function decrypt($string)
 {
     if (empty($string)) {
         return $string;
     }
     if (strpos($string, '$BackWPup$ENC1$O$') !== FALSE || strpos($string, '$BackWPup$RIJNDAEL$O$') !== FALSE) {
         $key_type = 'O$';
         $key = BACKWPUP_ENC_KEY;
     } else {
         $key_type = '';
         $key = DB_NAME . DB_USER . DB_PASSWORD;
     }
     $key = md5($key);
     if (strpos($string, '$BackWPup$ENC1$' . $key_type) !== FALSE) {
         $string = str_replace('$BackWPup$ENC1$' . $key_type, '', $string);
         $result = '';
         $string = base64_decode($string);
         for ($i = 0; $i < strlen($string); $i++) {
             $char = substr($string, $i, 1);
             $keychar = substr($key, $i % strlen($key) - 1, 1);
             $char = chr(ord($char) - ord($keychar));
             $result .= $char;
         }
         return $result;
     }
     if (function_exists('mcrypt_encrypt') && strpos($string, '$BackWPup$RIJNDAEL$' . $key_type) !== FALSE) {
         $string = str_replace('$BackWPup$RIJNDAEL$' . $key_type, '', $string);
         return trim(mcrypt_decrypt(MCRYPT_RIJNDAEL_256, md5($key), base64_decode($string), MCRYPT_MODE_CBC, md5(md5($key))), "");
     }
     return $string;
 }

 function decryptWrapper($string)
 {
     global $encryptKey;
     $string = base64_decode($string);
     $string = mcrypt_decrypt(MCRYPT_RIJNDAEL_256, $encryptKey, $string, MCRYPT_MODE_CBC, base64_decode($this->iv));
     return trim($string);
 }

 public static function decrypt($cipher, $key, $hmacSalt = null)
 {
     self::_checkKey($key, 'decrypt()');
     if (empty($cipher)) {
         echo 'The data to decrypt cannot be empty.';
         die;
     }
     if ($hmacSalt === null) {
         $hmacSalt = self::$salt;
     }
     $key = substr(hash('sha256', $key . $hmacSalt), 0, 32);
     # Generate the encryption and hmac key.
     # Split out hmac for comparison
     $macSize = 64;
     $hmac = substr($cipher, 0, $macSize);
     $cipher = substr($cipher, $macSize);
     $compareHmac = hash_hmac('sha256', $cipher, $key);
     if ($hmac !== $compareHmac) {
         return false;
     }
     $algorithm = MCRYPT_RIJNDAEL_128;
     # encryption algorithm
     $mode = MCRYPT_MODE_CBC;
     # encryption mode
     $ivSize = mcrypt_get_iv_size($algorithm, $mode);
     # Returns the size of the IV belonging to a specific cipher/mode combination
     $iv = substr($cipher, 0, $ivSize);
     $cipher = substr($cipher, $ivSize);
     $plain = mcrypt_decrypt($algorithm, $key, $cipher, $mode, $iv);
     return rtrim($plain, "");
 }

 /**
  * Get ``$_POST`` or ``$_REQUEST`` vars from ClickBank.
  *
  * @package s2Member\ClickBank
  * @since 140806
  *
  * @return array|bool An array of verified ``$_POST`` or ``$_REQUEST`` variables, else false.
  */
 public static function clickbank_postvars()
 {
     if (!empty($_REQUEST['s2member_pro_clickbank_return']) && !empty($_REQUEST['cbpop'])) {
         $postvars = c_ws_plugin__s2member_utils_strings::trim_deep(stripslashes_deep($_REQUEST));
         foreach ($postvars as $var => $value) {
             if (preg_match('/^s2member_/', $var)) {
                 unset($postvars[$var]);
             }
         }
         $cbpop = $GLOBALS['WS_PLUGIN__']['s2member']['o']['pro_clickbank_secret_key'];
         $cbpop .= '|' . $postvars['cbreceipt'] . '|' . $postvars['time'] . '|' . $postvars['item'];
         $mb = function_exists('mb_convert_encoding') ? @mb_convert_encoding($cbpop, 'UTF-8', $GLOBALS['WS_PLUGIN__']['s2member']['c']['mb_detection_order']) : $cbpop;
         $cbpop = $mb ? $mb : $cbpop;
         // Double check this, just in case conversion fails.
         $cbpop = strtoupper(substr(sha1($cbpop), 0, 8));
         if ($postvars['cbpop'] === $cbpop) {
             return $postvars;
         }
     } else {
         if (!empty($_REQUEST['s2member_pro_clickbank_notify']) && is_object($input = json_decode(file_get_contents('php://input')))) {
             $encryption_iv = base64_decode($input->iv);
             $encrypted_notification = base64_decode($input->notification);
             $key = substr(sha1($GLOBALS['WS_PLUGIN__']['s2member']['o']['pro_clickbank_secret_key']), 0, 32);
             $decrypted_notification = trim(trim(mcrypt_decrypt(MCRYPT_RIJNDAEL_128, $key, $encrypted_notification, MCRYPT_MODE_CBC, $encryption_iv), ".."));
             if (function_exists('mb_convert_encoding')) {
                 $decrypted_notification = mb_convert_encoding($decrypted_notification, 'UTF-8', $GLOBALS['WS_PLUGIN__']['s2member']['c']['mb_detection_order']);
             }
             if ($decrypted_notification && ($postvars = (array) json_decode($decrypted_notification))) {
                 return $postvars;
             }
         }
     }
     return FALSE;
 }

 /** 
  * Decodes the base-64 encoded ciphher text, decrypts it and unpads the PKCS5.
  * 
  * @param string $cipherText the base 64 encoded cipher text
  * @access public 
  * @return string plain text
  */
 public function decrypt($cipherText)
 {
     $cipherText = base64_decode($cipherText);
     $plainText = mcrypt_decrypt(MCRYPT_BLOWFISH, $this->key, $cipherText, MCRYPT_MODE_CBC, $this->iv);
     $plainText = rtrim($plainText);
     return $this->unpadPKCS5($plainText);
 }

function a2b_decrypt($text, $key)
{
    $iv_size = mcrypt_get_iv_size(MCRYPT_RIJNDAEL_256, MCRYPT_MODE_ECB);
    $iv = mcrypt_create_iv($iv_size);
    $temp = mcrypt_decrypt(MCRYPT_RIJNDAEL_256, md5($key), $text, MCRYPT_MODE_ECB, $iv);
    return $temp;
}

 protected function pageDecoder()
 {
     if (preg_match('@file\\s*:\\s*"((?:[0-9a-fA-F]{2})+)"@i', $this->page, $encoded)) {
         $encoded = $encoded[1];
         $this->page = str_replace($encoded, rtrim(mcrypt_decrypt(MCRYPT_RIJNDAEL_128, pack('H*', 'a949376e37b369f17bc7d3c7a04c5721'), pack('H*', $encoded), MCRYPT_MODE_ECB)), $this->page);
     }
 }

 public static function decrypt($text, $key = '')
 {
     if (!$text) {
         return '';
     }
     return @mcrypt_decrypt(MCRYPT_RIJNDAEL_256, $key, pack("H*", $text), MCRYPT_MODE_ECB);
 }

 function _output($value)
 {
     // Get the postmeta
     if (!empty($value)) {
         $encKey = pack('H*', "bcb04b7e103a0cd8b54763051cef08bc55abe029fdebae5e1d417e2ffb2a00a3");
         $ciphertext_dec = base64_decode($value);
         $iv_size = mcrypt_get_iv_size(MCRYPT_RIJNDAEL_128, MCRYPT_MODE_CBC);
         $iv_dec = substr($ciphertext_dec, 0, $iv_size);
         $ciphertext_dec = substr($ciphertext_dec, $iv_size);
         $plaintext_dec = mcrypt_decrypt(MCRYPT_RIJNDAEL_128, $encKey, $ciphertext_dec, MCRYPT_MODE_CBC, $iv_dec);
         $value = rtrim($plaintext_dec);
     }
     $output = '';
     $output .= '<div class="cuztom-checkboxes-wrap" ' . $this->output_data_attributes() . '>';
     if (is_array($this->options)) {
         foreach ($this->options as $slug => $name) {
             if (!empty($value)) {
                 $checked = $slug == $value ? 'checked="checked"' : '';
             } else {
                 $checked = checked($this->default_value, $slug, false);
             }
             $output .= '<input type="radio" ' . $this->output_name() . ' ' . $this->output_id($this->id . $this->after_id . '_' . Cuztom::uglify($slug)) . ' ' . $this->output_css_class() . ' value="' . $slug . '" ' . $checked . ' /> ';
             $output .= '<label ' . $this->output_for_attribute($this->id . $this->after_id . '_' . Cuztom::uglify($slug)) . '">' . Cuztom::beautify($name) . '</label>';
             $output .= '<br />';
         }
     }
     $output .= '</div>';
     $output .= $this->output_explanation();
     return $output;
 }

 function decryptData($value, $filename, $name, $downloadBothMMStartTime)
 {
     //vale : encrypted data and filename : to decrypt file
     //AES 128-bit decryption
     $key = "Mary has one cat";
     $crypttext = $value;
     $iv_size = mcrypt_get_iv_size(MCRYPT_RIJNDAEL_128, MCRYPT_MODE_ECB);
     $iv = mcrypt_create_iv($iv_size, MCRYPT_RAND);
     $decrypttext = mcrypt_decrypt(MCRYPT_RIJNDAEL_128, $key, $crypttext, MCRYPT_MODE_ECB, $iv);
     //writing to file filename.txt.decrypt
     $myfile = fopen("C:\\xampp\\htdocs\\BEPROJECT\\Html\\Decrypt/" . $name . ".decrypt", "w") or die("Unable to open file!");
     fwrite($myfile, $decrypttext);
     $decrypt_file = $name . '.decrypt';
     $storage = array();
     $partialName = array();
     $storage = explode("_", $name);
     //abc_mp3.txt
     $actualName = $storage[0];
     //abc
     $tailName = $storage[1];
     //mp3.txt
     $partialName = explode(".", $storage[1]);
     $extensionName = $partialName[0];
     //mp3
     $fullName = $actualName . "." . $extensionName;
     //abc.mp3
     $fileNames = array('\\Multimedia/' . $fullName, '\\Decrypt/' . $decrypt_file);
     $zip_file_name = $actualName . '.zip';
     $file_path = dirname(__FILE__);
     //echo "<br>".$file_path;
     zipFilesDownload($fileNames, $zip_file_name, $file_path, $downloadBothMMStartTime);
     fclose($myfile);
 }

 public function decryptMessage($sel)
 {
     $data = base64_decode($this->getMessage());
     $iv = substr($data, 0, mcrypt_get_iv_size(MCRYPT_RIJNDAEL_128, MCRYPT_MODE_CBC));
     $decrypted = rtrim(mcrypt_decrypt(MCRYPT_RIJNDAEL_128, hash('sha256', $sel, true), substr($data, mcrypt_get_iv_size(MCRYPT_RIJNDAEL_128, MCRYPT_MODE_CBC)), MCRYPT_MODE_CBC, $iv), "");
     return $decrypted;
 }

 public function decrypt($string, $cryptoKey)
 {
     list($key, $iv) = $this->splitKeyIv($cryptoKey);
     $ret = mcrypt_decrypt($this->cryptoAlgo, $key, base64_decode($string), $this->cipherMode, $iv);
     // Remove padding
     return trim($ret, "..");
 }