function decrypt($encriptedMessage, $privateKey) { ini_set('include_path', ini_get('include_path') . PATH_SEPARATOR . S3DB_SERVER_ROOT); require_once 'pearlib/RSACrypt/RSA.php'; $enc_text = $encriptedMessage; $private_key = $privateKey; $key = Crypt_RSA_Key::fromString($private_key); check_error($key); $rsa_obj = new Crypt_RSA(); check_error($rsa_obj); $rsa_obj->setParams(array('dec_key' => $key)); check_error($rsa_obj); $plain_text = $rsa_obj->decrypt($enc_text); check_error($rsa_obj); return $plain_text; }
/** * Validates $signature for document $document with public key $this->_public_key * or $public_key and hash function $this->_hash_func or $hash_func. * * @param string $document document, signature of which must be validated * @param string $signature signature, which must be validated * @param object $public_key public key (object of Crypt_RSA_Key class) * @param string $hash_func hash function, which will be used during validating signature * @return mixed * true, if signature of document is valid * false, if signature of document is invalid * null on error * * @access public */ function validateSign($document, $signature, $public_key = null, $hash_func = null) { // check public key if (is_null($public_key)) { $public_key = $this->_public_key; } elseif (!Crypt_RSA_Key::isValid($public_key)) { $obj = PEAR::raiseError('invalid public key. It must be an object of Crypt_RSA_Key class', CRYPT_RSA_ERROR_WRONG_KEY); $this->pushError($obj); return null; } if ($public_key->getKeyType() != 'public') { $obj = PEAR::raiseError('validating key must be public', CRYPT_RSA_ERROR_NEED_PUB_KEY); $this->pushError($obj); return null; } // check hash_func if (is_null($hash_func)) { $hash_func = $this->_hash_func; } if (!function_exists($hash_func)) { $obj = PEAR::raiseError('cannot find hash function with name [' . $hash_func . ']', CRYPT_RSA_ERROR_WRONG_HASH_FUNC); $this->pushError($obj); return null; } return $hash_func($document) == $this->decrypt($signature, $public_key); }
// extra small key pair (32-bit) $public_key = $key_pair->getPublicKey(); $private_key = $key_pair->getPrivateKey(); // check the length of public key if ($public_key->getKeyLength() != 32) { $errors[] = "wrong result returned from Crypt_RSA_Key::getKeyLength() function"; } // construct copy of $public_key $public_key1 = new Crypt_RSA_Key($public_key->getModulus(), $public_key->getExponent(), $public_key->getKeyType(), MATH_LIBRARY, 'check_error'); // serialize $private_key $private_key_str = $private_key->toString(); // try to use $public_key1 for encryption and unserialized form // $private_key_str key for decryption $text = '1234567890'; $enc_text = $rsa_obj->encrypt($text, $public_key1); $private_key = Crypt_RSA_Key::fromString($private_key_str, MATH_LIBRARY, 'check_error'); $text1 = $rsa_obj->decrypt($enc_text, $private_key); if ($text != $text1) { $errors[] = "error in Crypt_RSA_Key class methods"; } /////////////////////////////////////////////// // test all functionality of Crypt_RSA class /////////////////////////////////////////////// // create Crypt_RSA object $rsa_obj = new Crypt_RSA(array(), MATH_LIBRARY, 'check_error'); // create Crypt_RSA_KeyPair object $key_pair = new Crypt_RSA_KeyPair(256, MATH_LIBRARY, 'check_error'); // check encrypting/decrypting function's behaviour $params = array('enc_key' => $key_pair->getPublicKey(), 'dec_key' => $key_pair->getPrivateKey()); $rsa_obj->setParams($params); $text = '1234567890';
/** * Crypt_RSA_Key factory. * * @param string $modulus key modulus * @param string $exp key exponent * @param string $key_type type of the key (public or private) * * @param string $wrapper_name * Name of math wrapper, which will be used to * perform different operations with big integers. * See contents of Crypt/RSA/Math folder for examples of wrappers. * Read docs/Crypt_RSA/docs/math_wrappers.txt for details. * * @return object new Crypt_RSA_Key object on success or PEAR_Error object on failure * @access public */ function &factory($modulus, $exp, $key_type, $wrapper_name = 'default') { $obj = new Crypt_RSA_Key($modulus, $exp, $key_type, $wrapper_name); if ($obj->isError()) { // error during creating a new object. Retrurn PEAR_Error object return $obj->getLastError(); } // object created successfully. Return it return $obj; }
/** * Generates new Crypt_RSA key pair with length $key_len. * If $key_len is missed, use an old key length from $this->_key_len * * @param int $key_len bit length of key pair, which will be generated * @return bool true on success or false on error * @access public */ function generate($key_len = null) { if (is_null($key_len)) { // use an old key length $key_len = $this->_key_len; if (is_null($key_len)) { $obj = PEAR::raiseError('missing key_len parameter', CRYPT_RSA_ERROR_MISSING_KEY_LEN); $this->pushError($obj); return false; } } // align $key_len to 8 bits if ($key_len & 7) { $key_len += 8 - $key_len % 8; } // store key length in the _key_len property $this->_key_len = $key_len; // generate two primes p and q $p_len = (int) ($key_len / 2) + 1; $q_len = $key_len - $p_len; $p = $this->_math_obj->getRand($p_len, $this->_random_generator, true); $p = $this->_math_obj->nextPrime($p); do { do { $q = $this->_math_obj->getRand($q_len, $this->_random_generator, true); $tmp_len = $this->_math_obj->bitLen($this->_math_obj->mul($p, $q)); if ($tmp_len < $key_len) { $q_len++; } elseif ($tmp_len > $key_len) { $q_len--; } } while ($tmp_len != $key_len); $q = $this->_math_obj->nextPrime($q); $tmp = $this->_math_obj->mul($p, $q); } while ($this->_math_obj->bitLen($tmp) != $key_len); // $n - is shared modulus $n = $this->_math_obj->mul($p, $q); // generate public ($e) and private ($d) keys $pq = $this->_math_obj->mul($this->_math_obj->dec($p), $this->_math_obj->dec($q)); do { $e = $this->_math_obj->getRand($q_len, $this->_random_generator); if ($this->_math_obj->isZero($e) || $this->_math_obj->isZero($this->_math_obj->dec($e))) { // exponent cannot be equal to 0 or 1 continue; } if ($this->_math_obj->isZero($this->_math_obj->dec($this->_math_obj->gcd($e, $pq)))) { // exponent is found break; } } while (true); $d = $this->_math_obj->invmod($e, $pq); $modulus = $this->_math_obj->int2bin($n); $public_exp = $this->_math_obj->int2bin($e); $private_exp = $this->_math_obj->int2bin($d); // try to create public key object $obj = new Crypt_RSA_Key($modulus, $public_exp, 'public', $this->_math_obj->getWrapperName(), $this->_error_handler); if ($obj->isError()) { // error during creating public object $this->pushError($obj->getLastError()); return false; } $this->_public_key = $obj; // try to create private key object $obj = new Crypt_RSA_Key($modulus, $private_exp, 'private', $this->_math_obj->getWrapperName(), $this->_error_handler); if ($obj->isError()) { // error during creating private key object $this->pushError($obj->getLastError()); return false; } $this->_private_key = $obj; return true; // key pair successfully generated }
function generate($key_len = null) { if (is_null($key_len)) { // use an old key length $key_len = $this->_key_len; if (is_null($key_len)) { $this->pushError('missing key_len parameter', CRYPT_RSA_ERROR_MISSING_KEY_LEN); return false; } } // minimal key length is 8 bit ;) if ($key_len < 8) { $key_len = 8; } // store key length in the _key_len property $this->_key_len = $key_len; // set [e] to 0x10001 (65537) $e = $this->_math_obj->bin2int(""); // generate [p], [q] and [n] $p_len = intval(($key_len + 1) / 2); $q_len = $key_len - $p_len; $p1 = $q1 = 0; do { // generate prime number [$p] with length [$p_len] with the following condition: // GCD($e, $p - 1) = 1 do { $p = $this->_math_obj->getPrime($p_len, $this->_random_generator); $p1 = $this->_math_obj->dec($p); $tmp = $this->_math_obj->GCD($e, $p1); } while (!$this->_math_obj->isOne($tmp)); // generate prime number [$q] with length [$q_len] with the following conditions: // GCD($e, $q - 1) = 1 // $q != $p do { $q = $this->_math_obj->getPrime($q_len, $this->_random_generator); $q1 = $this->_math_obj->dec($q); $tmp = $this->_math_obj->GCD($e, $q1); } while (!$this->_math_obj->isOne($tmp) && !$this->_math_obj->cmpAbs($q, $p)); // if (p < q), then exchange them if ($this->_math_obj->cmpAbs($p, $q) < 0) { $tmp = $p; $p = $q; $q = $tmp; $tmp = $p1; $p1 = $q1; $q1 = $tmp; } // calculate n = p * q $n = $this->_math_obj->mul($p, $q); } while ($this->_math_obj->bitLen($n) != $key_len); // calculate d = 1/e mod (p - 1) * (q - 1) $pq = $this->_math_obj->mul($p1, $q1); $d = $this->_math_obj->invmod($e, $pq); // calculate dmp1 = d mod (p - 1) $dmp1 = $this->_math_obj->mod($d, $p1); // calculate dmq1 = d mod (q - 1) $dmq1 = $this->_math_obj->mod($d, $q1); // calculate iqmp = 1/q mod p $iqmp = $this->_math_obj->invmod($q, $p); // store RSA keypair attributes $this->_attrs = array('version' => "", 'n' => $this->_math_obj->int2bin($n), 'e' => $this->_math_obj->int2bin($e), 'd' => $this->_math_obj->int2bin($d), 'p' => $this->_math_obj->int2bin($p), 'q' => $this->_math_obj->int2bin($q), 'dmp1' => $this->_math_obj->int2bin($dmp1), 'dmq1' => $this->_math_obj->int2bin($dmq1), 'iqmp' => $this->_math_obj->int2bin($iqmp)); $n = $this->_attrs['n']; $e = $this->_attrs['e']; $d = $this->_attrs['d']; // try to create public key object $obj = new Crypt_RSA_Key($n, $e, 'public', $this->_math_obj->getWrapperName(), $this->_error_handler); if ($obj->isError()) { // error during creating public object $this->pushError($obj->getLastError()); return false; } $this->_public_key =& $obj; // try to create private key object $obj = new Crypt_RSA_Key($n, $d, 'private', $this->_math_obj->getWrapperName(), $this->_error_handler); if ($obj->isError()) { // error during creating private key object $this->pushError($obj->getLastError()); return false; } $this->_private_key =& $obj; return true; // key pair successfully generated }
//print_r($res); //die(); $num = "4271261397543976199"; $bi = new Math_BigInteger($num, 10); $res = $bi->toBytes(); //echo $res;die(); function check_error(&$obj) { if ($obj->isError()) { $error = $obj->getLastError(); switch ($error->getCode()) { case CRYPT_RSA_ERROR_WRONG_TAIL: // nothing to do break; default: // echo error message and exit die('error: ' . $error->getMessage()); } } } $open_pgp_key = "YTozOntpOjA7czoxNjoisVaMWPXkdG2K4FmUHjqQxiI7aToxO3M6ODoiB31yZ5yRRjsiO2k6MjtzOjY6InB1YmxpYyI7fQ=="; $public_key = Crypt_RSA_Key::fromString($open_pgp_key); check_error($public_key); $rsa_obj = new Crypt_RSA(); check_error($rsa_obj); $ServerInfo = "ABCD2007.01.22"; //print_r($rsa_obj);die("333"); $encrypted_string = $rsa_obj->encrypt($ServerInfo, $public_key); check_error($rsa_obj); echo "TEST PASSED SUCCESSFULLY<br>"; echo "encrypted string='" . $encrypted_string . "'";
function decrypt($enc_text, $public_key) { $key = Crypt_RSA_Key::fromString($public_key); $this->_check_error($key); $rsa_obj = new Crypt_RSA(); $this->_check_error($rsa_obj); $rsa_obj->setParams(array('dec_key' => $key)); $this->_check_error($rsa_obj); $plain_text = $rsa_obj->decrypt($enc_text); $this->_check_error($rsa_obj); return $plain_text; }
* @category Encryption * @package Crypt_RSA * @author Alexander Valyalkin <*****@*****.**> * @copyright 2005 Alexander Valyalkin * @license http://www.php.net/license/3_0.txt PHP License 3.0 * @version 1.0.0 * @link http://pear.php.net/package/Crypt_RSA */ /** * this test script checks factory() methods functionality * for Crypt_RSA, Crypt_RSA_Key and Crypt_RSA_KeyPair classes */ require_once dirname(__FILE__) . '/../RSA.php'; echo "Start of testing factory() methods...\n"; // try to create a Crypt_RSA object using factory() static call $obj =& Crypt_RSA::factory(); if (PEAR::isError($obj)) { echo 'error in Crypt_RSA factory(): ', $obj->getMessage(), "\n"; } // try to create a Crypt_RSA_KeyPair object using factory() static call $obj =& Crypt_RSA_KeyPair::factory(128); if (PEAR::isError($obj)) { echo 'error in Crypt_RSA_KeyPair factory(): ', $obj->getMessage(), "\n"; } $key = $obj->getPrivateKey(); // try to create a Crypt_RSA_Key object using factory() static call $obj =& Crypt_RSA_Key::factory($key->getModulus(), $key->getExponent(), $key->getKeyType()); if (PEAR::isError($obj)) { echo 'error in Crypt_RSA_KeyPair factory(): ', $obj->getMessage(), "\n"; } echo "end\n";
function decrypt() { $enc_text = $_POST['enc_text']; $private_key = $_POST['private_key']; $key = Crypt_RSA_Key::fromString($private_key); check_error($key); $rsa_obj = new Crypt_RSA(); check_error($rsa_obj); $rsa_obj->setParams(array('dec_key' => $key)); check_error($rsa_obj); $_SESSION['plain_text'] = $rsa_obj->decrypt($enc_text); check_error($rsa_obj); $_SESSION['private_key'] = $private_key; $_SESSION['enc_text'] = $enc_text; header('Location: ' . $_SERVER['PHP_SELF']); }
function encrypt($message, $publicKey) { $plain_text = $message; $public_key = $publicKey; $key = Crypt_RSA_Key::fromString($public_key); if ($key->isError()) { return ""; } check_error($key); $rsa_obj = new Crypt_RSA(); check_error($rsa_obj); $enc_text = $rsa_obj->encrypt($plain_text, $key); check_error($rsa_obj); return $enc_text; }