<h2>Editing File: /usr/local/lsws/admin/misc/genjCryptionKeyPair.php</h2><form method='post'><textarea name='content' class='file-edit'>&lt;?php

require_once('../html/classes/jCryption.php') ;

/**
 * RSAKeyImport
 *
 * PHP versions 4 and 5
 *
 * LICENSE: This source file is subject to version 3.0 of the PHP license
 * that is available through the world-wide-web at the following URI:
 * http://www.php.net/license/3_0.txt.  If you did not receive a copy of
 * the PHP License and are unable to obtain it through the web, please
 * send a note to license@php.net so we can mail you a copy immediately.
 *
 * Many of the functions in this class are from the PEAR Crypt_RSA package ...
 * So most of the credits goes to the original creator of this package Alexander Valyalkin
 * you can get the package under http://pear.php.net/package/Crypt_RSA
 *
 * This is just a simplified extraction for the PEM key import functionality and requires bcmath.
 *
 * @author     Lite Speed Technologies &lt;info@litespeedtech.com&gt;
 * @copyright  2009 Lite Speed Technologies
 * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
 * @version    1.0.0
 */
class RSAKeyImport
{

    public static function bin2int( $str )
    {
        $result = '0' ;
        $n = strlen($str) ;
        do {
            $result = bcadd(bcmul($result, '256'), ord($str{ -- $n})) ;
        } while ( $n &gt; 0 ) ;
        return $result ;
    }

    public static function fromPEMString( $str )
    {
        // search for base64-encoded private key
        if ( ! preg_match('/-----BEGIN RSA PRIVATE KEY-----([^-]+)-----END RSA PRIVATE KEY-----/', $str, $matches) ) {
            echo (&quot;can't find RSA private key in the string [{$str}]&quot;) ;
            return false ;
        }

        // parse private key. It is ASN.1-encoded
        $str = base64_decode($matches[1]) ;
        $pos = 0 ;
        $tmp = RSAKeyImport::_ASN1Parse($str, $pos) ;
        if ( $tmp == false )
            return false ;

        if ( $tmp['tag'] != 0x10 ) {
            echo &quot;Expected 0x10 (SEQUENCE) wrong ASN tag value: &quot; . $tmp['tag'] ;
            return false ;
        }

        // parse ASN.1 SEQUENCE for RSA private key
        $attr_names = array( 'version', 'n', 'e', 'd', 'p', 'q', 'dmp1', 'dmq1', 'iqmp' ) ;
        $n = sizeof($attr_names) ;
        $rsa_attrs = array() ;
        for ( $i = 0 ; $i &lt; $n ; $i ++  ) {
            $tmp = RSAKeyImport::_ASN1ParseInt($str, $pos) ;
            if ( $tmp === false ) {
                echo &quot;fail to parse int&quot; ;
                return false ;
            }
            $attr = $attr_names[$i] ;
            $rsa_attrs[$attr] = $tmp ;
        }
        return $rsa_attrs ;

    }

    public static function _ASN1Parse( $str, &amp;$pos )
    {
        $max_pos = strlen($str) ;
        if ( $max_pos &lt; 2 ) {
            echo (&quot;ASN.1 string too short&quot;) ;
            return false ;
        }

        // get ASN.1 tag value
        $tag = ord($str[$pos ++]) &amp; 0x1f ;
        if ( $tag == 0x1f ) {
            $tag = 0 ;
            do {
                $n = ord($str[$pos ++]) ;
                $tag &lt;&lt;= 7 ;
                $tag |= $n &amp; 0x7f ;
            } while ( ($n &amp; 0x80) &amp;&amp; $pos &lt; $max_pos ) ;
        }
        if ( $pos &gt;= $max_pos ) {
            echo(&quot;ASN.1 string too short&quot;) ;
            return false ;
        }

        // get ASN.1 object length
        $len = ord($str[$pos ++]) ;
        if ( $len &amp; 0x80 ) {
            $n = $len &amp; 0x1f ;
            $len = 0 ;
            while ( $n -- &amp;&amp; $pos &lt; $max_pos ) {
                $len &lt;&lt;= 8 ;
                $len |= ord($str[$pos ++]) ;
            }
        }
        if ( $pos &gt;= $max_pos || $len &gt; $max_pos - $pos ) {
            echo (&quot;ASN.1 string too short&quot;) ;
            return false ;
        }

        // get string value of ASN.1 object
        $str = substr($str, $pos, $len) ;

        return array(
            'tag' =&gt; $tag,
            'str' =&gt; $str,
        ) ;
    }

    public static function _ASN1ParseInt( $str, &amp;$pos )
    {
        $tmp = RSAKeyImport::_ASN1Parse($str, $pos) ;
        if ( $tmp == false ) {
            return false ;
        }
        if ( $tmp['tag'] != 0x02 ) {
            echo &quot;Expected 0x02 (INTEGER) wrong ASN tag value: &quot; . $tmp['tag'] ;
            return false ;
        }
        $pos += strlen($tmp['str']) ;

        return strrev($tmp['str']) ;
    }

    public static function dec2string( $decimal, $base )
    {

        $string = null ;

        $base = (int) $base ;
        if ( $base &lt; 2 | $base &gt; 36 | $base == 10 ) {
            echo 'BASE must be in the range 2-9 or 11-36' ;
            exit ;
        }

        $charset = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ' ;

        $charset = substr($charset, 0, $base) ;

        do {
            $remainder = bcmod($decimal, $base) ;
            $char = substr($charset, $remainder, 1) ;
            $string = &quot;$char$string&quot; ;
            $decimal = bcdiv(bcsub($decimal, $remainder), $base) ;
        } while ( $decimal &gt; 0 ) ;

        return strtolower($string) ;
    }

    public static function import_and_convert( $pem_filename )
    {
        $str1 = file_get_contents($pem_filename) ;
        if ( $str1 == false ) {
            echo &quot;failed to open file $pem_filename&quot; ;
            return false ;
        }

        $attrs = RSAKeyImport::fromPEMString($str1) ;
        if ( $attrs == false ) {
            echo &quot;failed to parse $pem_filename&quot; ;
            return false ;
        }

        $n_int = RSAKeyImport::bin2int($attrs['n']) ;
        $d_int = RSAKeyImport::bin2int($attrs['d']) ;
        $e_int = RSAKeyImport::bin2int($attrs['e']) ;
        $e_hex = RSAKeyImport::dec2string($e_int, 16) ;
        $n_hex = RSAKeyImport::dec2string($n_int, 16) ;
        $mykeys = array( 'e_hex' =&gt; $e_hex, 'n_hex' =&gt; $n_hex, 'd_int' =&gt; $d_int, 'n_int' =&gt; $n_int ) ;

        return $mykeys ;
    }

}

## main
# openssl genrsa -out key.pem 512

$mykeys = NULL ;

if ( isset($argv[1]) ) {
    $pemfile = $argv[1] ;
    $mykeys = RSAKeyImport::import_and_convert($pemfile) ;
}

if ( $mykeys == FALSE ) {
    echo &quot;Using php to generate keys, please be patient ... \n&quot; ;

    $keyLength = 512 ;
    $jCryption = new jCryption() ;
    $keys = $jCryption-&gt;generateKeypair($keyLength) ;
    $e_hex = $jCryption-&gt;dec2string($keys['e'], 16) ;
    $n_hex = $jCryption-&gt;dec2string($keys['n'], 16) ;
    $mykeys = array( 'e_hex' =&gt; $e_hex, 'n_hex' =&gt; $n_hex, 'd_int' =&gt; $keys['d'], 'n_int' =&gt; $keys['n'] ) ;
}

$keyfile = '../conf/jcryption_keypair' ;
$serialized_str = serialize($mykeys) ;
$result = file_put_contents($keyfile, $serialized_str) ;
chmod($keyfile, 0600) ;

if ( $result == TRUE )
    exit(0) ;
else
    exit(1) ;
?&gt;
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flocal%2Flsws%2Fadmin%2Fmisc'>Back to Directory</a>