Gecko [ primetaxinc.net ]

Name	Size	Permission
admpass.sh	1.17 KB	-r-xr-xr-x
ap_lsws.sh	1.82 KB	-rwxr-xr-x
ap_lsws.sh.in	1.82 KB	-r-xr-xr-x
awstats_install.sh	2.06 KB	-r-xr-xr-x
build_ap_wrapper.sh	624 B	-r-xr-xr-x
chroot.sh	7.31 KB	-r-xr-xr-x
cleancache.sh	1.46 KB	-r-xr-xr-x
cleanlitemage.sh	2.4 KB	-r-xr-xr-x
cp_switch_ws.sh	22.41 KB	-r-xr-xr-x
cpanel_restart_httpd.in	732 B	-r-xr-xr-x
create_admin_keypair.sh	336 B	-r-xr-xr-x
enable_ruby_python_selector.sh	2.68 KB	-r-xr-xr-x
fix_cagefs.sh	766 B	-r-xr-xr-x
fp_install.sh	1.65 KB	-r-xr-xr-x
gdb-bt	25 B	-rw-r--r--
genjCryptionKeyPair.php	6.43 KB	-rw-r--r--
gzipStatic.sh	272 B	-r-xr-xr-x
htpasswd.php	103 B	-rw-r--r--
lscmctl	15.3 KB	-rwxrwxr-x
lshttpd.service	660 B	-r-xr-xr-x
lsup.sh	5.65 KB	-r-xr-xr-x
lsup6.sh	5.65 KB	-r-xr-xr-x
lsws.rc	1.78 KB	-r-xr-xr-x
lsws.rc.gentoo	441 B	-r-xr-xr-x
mgr_ver.sh	1.93 KB	-r-xr-xr-x
php.ini	37.11 KB	-rw-r--r--
purge_cache_by_url	3.23 KB	-r-xr-xr-x
rc-inst.sh	6.24 KB	-r-xr-xr-x
rc-uninst.sh	4.61 KB	-r-xr-xr-x
uninstall.sh	2.9 KB	-r-xr-xr-x
update.sh	1.85 KB	-r-xr-xr-x

Code Editor : genjCryptionKeyPair.php

<?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 <info@litespeedtech.com>
 * @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 > 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 ("can't find RSA private key in the string [{$str}]") ;
            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 "Expected 0x10 (SEQUENCE) wrong ASN tag value: " . $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 < $n ; $i ++  ) {
            $tmp = RSAKeyImport::_ASN1ParseInt($str, $pos) ;
            if ( $tmp === false ) {
                echo "fail to parse int" ;
                return false ;
            }
            $attr = $attr_names[$i] ;
            $rsa_attrs[$attr] = $tmp ;
        }
        return $rsa_attrs ;

}

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

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

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

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

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

public static function _ASN1ParseInt( $str, &$pos )
    {
        $tmp = RSAKeyImport::_ASN1Parse($str, $pos) ;
        if ( $tmp == false ) {
            return false ;
        }
        if ( $tmp['tag'] != 0x02 ) {
            echo "Expected 0x02 (INTEGER) wrong ASN tag value: " . $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 < 2 | $base > 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 = "$char$string" ;
            $decimal = bcdiv(bcsub($decimal, $remainder), $base) ;
        } while ( $decimal > 0 ) ;

return strtolower($string) ;
    }

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

$attrs = RSAKeyImport::fromPEMString($str1) ;
        if ( $attrs == false ) {
            echo "failed to parse $pem_filename" ;
            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' => $e_hex, 'n_hex' => $n_hex, 'd_int' => $d_int, 'n_int' => $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 "Using php to generate keys, please be patient ... \n" ;

$keyLength = 512 ;
    $jCryption = new jCryption() ;
    $keys = $jCryption->generateKeypair($keyLength) ;
    $e_hex = $jCryption->dec2string($keys['e'], 16) ;
    $n_hex = $jCryption->dec2string($keys['n'], 16) ;
    $mykeys = array( 'e_hex' => $e_hex, 'n_hex' => $n_hex, 'd_int' => $keys['d'], 'n_int' => $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) ;
?>

${this.title}

Code Editor : genjCryptionKeyPair.php