How to use the rsa key generted by .net with php?

<? php
/*
*fileName rsa.class.php
*author: laiyunqing<laiyunqing#gmail.com>
 * Some constants
  */
define ( " BCCOMP_LARGER " ,   1 );
class  RSA
{
  /*
  * PHP implementation of the RSA algorithm
  * (C) Copyright 2004 Edsko de Vries, Ireland
  *
  * Licensed under the GNU Public License (GPL)
  *
  * This implementation has been verified against [3]
  * (tested Java/PHP interoperability).
  *
  * References:
  * [1] "Applied Cryptography", Bruce Schneier, John Wiley & Sons, 1996
  * [2] "Prime Number Hide-and-Seek", Brian Raiter, Muppetlabs (online)
  * [3] "The Bouncy Castle Crypto Package", Legion of the Bouncy Castle,
  *      (open source cryptography library for Java, online)
  * [4] "PKCS #1: RSA Encryption Standard", RSA Laboratories Technical Note,
  *      version 1.5, revised November 1, 1993
   */

  /*
  * Functions that are meant to be used by the user of this PHP module.
  *
  * Notes:
  * - $key and $modulus should be numbers in (decimal) string format
  * - $message is expected to be binary data
  * - $keylength should be a multiple of 8, and should be in bits
  * - For rsa_encrypt/rsa_sign, the length of $message should not exceed
  *   ($keylength / 8) - 11 (as mandated by [4]).
  * - rsa_encrypt and rsa_sign will automatically add padding to the message.
  *   For rsa_encrypt, this padding will consist of random values; for rsa_sign,
  *   padding will consist of the appropriate number of 0xFF values (see [4])
  * - rsa_decrypt and rsa_verify will automatically remove message padding.
  * - Blocks for decoding (rsa_decrypt, rsa_verify) should be exactly
  *   ($keylength / 8) bytes long.
  * - rsa_encrypt and rsa_verify expect a public key; rsa_decrypt and rsa_sign
  *   expect a private key.
   */

  /* *
  * rsa encrypt data
  *
  * @param binary string $message
  * @param unknown_type $public_key
  * @param numbers $modulus
  * @param numbers $keylength
  * @return binary data
   */
  function  rsa_encrypt( $message ,   $public_key ,   $modulus ,   $keylength )
 {
   $padded   =  RSA :: add_PKCS1_padding( $message ,   true ,   $keylength   /   8 );
   $number   =  RSA :: binary_to_number( $padded );
   $encrypted   =  RSA :: pow_mod( $number ,   $public_key ,   $modulus );
   $result   =  RSA :: number_to_binary( $encrypted ,   $keylength   /   8 );

   return   $result ;
 }

  function  rsa_decrypt( $message ,   $private_key ,   $modulus ,   $keylength )
 {
   $number   =  RSA :: binary_to_number( $message );
   $decrypted   =  RSA :: pow_mod( $number ,   $private_key ,   $modulus );
   $result   =  RSA :: number_to_binary( $decrypted ,   $keylength   /   8 );

   return  RSA :: remove_PKCS1_padding( $result ,   $keylength   /   8 );
 }

  function  rsa_sign( $message ,   $private_key ,   $modulus ,   $keylength )
 {
   $padded   =  RSA :: add_PKCS1_padding( $message ,   false ,   $keylength   /   8 );
   $number   =  RSA :: binary_to_number( $padded );
   $signed   =  RSA :: pow_mod( $number ,   $private_key ,   $modulus );
   $result   =  RSA :: number_to_binary( $signed ,   $keylength   /   8 );

   return   $result ;
 }

  function  rsa_verify( $message ,   $public_key ,   $modulus ,   $keylength )
 {
   return  RSA :: rsa_decrypt( $message ,   $public_key ,   $modulus ,   $keylength );
 }

  function  rsa_kyp_verify( $message ,   $public_key ,   $modulus ,   $keylength )
 {
   $number   =  RSA :: binary_to_number( $message );
   $decrypted   =  RSA :: pow_mod( $number ,   $public_key ,   $modulus );
   $result   =  RSA :: number_to_binary( $decrypted ,   $keylength   /   8 );

   return  RSA :: remove_KYP_padding( $result ,   $keylength   /   8 );
 }


  /*
  * The actual implementation.
  * Requires BCMath support in PHP (compile with --enable-bcmath)
   */

  // --
 // Calculate (p ^ q) mod r
 //
 // We need some trickery to [2]:
 //   (a) Avoid calculating (p ^ q) before (p ^ q) mod r, because for typical RSA
 //       applications, (p ^ q) is going to be _WAY_ too large.
 //       (I mean, __WAY__ too large - won't fit in your computer's memory.)
 //   (b) Still be reasonably efficient.
 //
 // We assume p, q and r are all positive, and that r is non-zero.
 //
 // Note that the more simple algorithm of multiplying $p by itself $q times, and
 // applying "mod $r" at every step is also valid, but is O($q), whereas this
 // algorithm is O(log $q). Big difference.
 //
 // As far as I can see, the algorithm I use is optimal; there is no redundancy
 // in the calculation of the partial results.
 //--
  function  pow_mod( $p ,   $q ,   $r )
 {
   //  Extract powers of 2 from $q
   $factors   =   array ();
   $div   =   $q ;
   $power_of_two   =   0 ;
   while ( bccomp ( $div ,   " 0 " )  ==  BCCOMP_LARGER)
  {
    $rem   =   bcmod ( $div ,   2 );
    $div   =   bcdiv ( $div ,   2 );

    if ( $rem )  array_push ( $factors ,   $power_of_two );
    $power_of_two ++ ;
  }

   //  Calculate partial results for each factor, using each partial result as a
  // starting point for the next. This depends of the factors of two being
  // generated in increasing order.
   $partial_results   =   array ();
   $part_res   =   $p ;
   $idx   =   0 ;
   foreach ( $factors   as   $factor )
  {
    while ( $idx   <   $factor )
   {
     $part_res   =   bcpow ( $part_res ,   " 2 " );
     $part_res   =   bcmod ( $part_res ,   $r );

     $idx ++ ;
   }

    array_push ( $partial_results ,   $part_res );
  }

   //  Calculate final result
   $result   =   " 1 " ;
   foreach ( $partial_results   as   $part_res )
  {
    $result   =   bcmul ( $result ,   $part_res );
    $result   =   bcmod ( $result ,   $r );
  }

   return   $result ;
 }

  // --
 // Function to add padding to a decrypted string
 // We need to know if this is a private or a public key operation [4]
 //--
  function  add_PKCS1_padding( $data ,   $isPublicKey ,   $blocksize )
 {
   $pad_length   =   $blocksize   -   3   -   strlen ( $data );

   if ( $isPublicKey )
  {
    $block_type   =   " " ;

    $padding   =   "" ;
    for ( $i   =   0 ;  $i   <   $pad_length ;  $i ++ )
   {
     $rnd   =   mt_rand ( 1 ,   255 );
     $padding   .=   chr ( $rnd );
   }
  }
   else
  {
    $block_type   =   " " ;
    $padding   =   str_repeat ( " ÿ " ,   $pad_length );
  }

   return   " "   .   $block_type   .   $padding   .   " "   .   $data ;
 }

  // --
 // Remove padding from a decrypted string
 // See [4] for more details.
 //--
  function  remove_PKCS1_padding( $data ,   $blocksize )
 {
   assert ( strlen ( $data )  ==   $blocksize );
   $data   =   substr ( $data ,   1 );

   //  We cannot deal with block type 0
   if ( $data { 0 }  ==   ' ' )
   die ( " Block type 0 not implemented. " );

   //  Then the block type must be 1 or 2
   assert (( $data { 0 }  ==   " " )  ||  ( $data { 0 }  ==   " " ));
   //  Remove the padding
   $offset   =   strpos ( $data ,   " " ,   1 );
   return   substr ( $data ,   $offset   +   1 );
 }

  // --
 // Remove "kyp" padding
 // (Non standard)
 //--
  function  remove_KYP_padding( $data ,   $blocksize )
 {
   assert ( strlen ( $data )  ==   $blocksize );

   $offset   =   strpos ( $data ,   " " );
   return   substr ( $data ,   0 ,   $offset );
 }

  // --
 // Convert binary data to a decimal number
 //--
  function  binary_to_number( $data )
 {
   $base   =   " 256 " ;
   $radix   =   " 1 " ;
   $result   =   " 0 " ;

   for ( $i   =   strlen ( $data )  -   1 ;  $i   >=   0 ;  $i -- )
  {
    $digit   =   ord ( $data { $i });
    $part_res   =   bcmul ( $digit ,   $radix );
    $result   =   bcadd ( $result ,   $part_res );
    $radix   =   bcmul ( $radix ,   $base );
  }

   return   $result ;
 }

  // --
 // Convert a number back into binary form
 //--
  function  number_to_binary( $number ,   $blocksize )
 {
   $base   =   " 256 " ;
   $result   =   "" ;

   $div   =   $number ;
   while ( $div   >   0 )
  {
    $mod   =   bcmod ( $div ,   $base );
    $div   =   bcdiv ( $div ,   $base );

    $result   =   chr ( $mod )  .   $result ;
  }

   return   str_pad ( $result ,   $blocksize ,   " " ,  STR_PAD_LEFT);
 }
}
?>

<? php
/**
*fileName RSAProcessor.class.php
*author: laiyunqing<laiyunqing#gmail.com>
*/
require_once ( " rsa.class.php " );

class  RSAProcessor
{
 
  private   $public_key   =   null ;
 
  private   $private_key   =   null ;
 
  private   $modulus   =   null ;
 
  private   $key_length   =   " 1024 " ;
 
 
  public   function  __construct( $xmlRsakey = null , $type = null )
 {
          $xmlObj   =   null ;
 
    if ( $xmlRsakey == null )
          {
            $xmlObj   =   simplexml_load_file ( " xmlfile/RSAKey.xml " );
          }
           elseif ( $type == RSAKeyType :: XMLFile)
          {
            $xmlObj   =   simplexml_load_file ( $xmlRsakey );
          }
           else
          {
            $xmlObj   =   simplexml_load_string ( $xmlRsakey );
          }
          $this -> modulus  =  RSA :: binary_to_number( base64_decode ( $xmlObj -> Modulus));
    $this -> public_key  =  RSA :: binary_to_number( base64_decode ( $xmlObj -> Exponent));
    $this -> key_length  =   strlen ( base64_decode ( $xmlObj -> Modulus)) * 8 ;
 }
  /* *
  * get public key
  *
  * @return string public key
   */
  public   function  getPublicKey()
 {
   // return base64_encode(RSA::number_to_binary($this->public_key,($this->key_length)/8));
   return   $this -> public_key;
 }
  public   function  getPrivateKey()
 {
   // return base64_encode(RSA::number_to_binary($this->private_key,($this->key_length)/8));
   return   $this -> private_key;
 }
  public   function  getKeyLength()
 {
   return   $this -> key_length;
 }
  public   function  getModulus()
 {
   return   $this -> modulus;
 }
  /* *
  * encrypt data
  *
  * @param string $data
  * @return base64 encoded  binary string
   */
  public   function  encrypt( $data )
 {
   return   base64_encode (RSA :: rsa_encrypt( $data , $this -> public_key , $this -> modulus , $this -> key_length));
 }
 
  public   function  dencrypt( $data )
 {
   return  RSA :: rsa_decrypt( $data , $this -> private_key , $this -> modulus , $this -> key_length);
 }
 
  public   function  sign( $data )
 {
   return  RSA :: rsa_sign( $data , $this -> private_key , $this -> modulus , $this -> key_length);
 }
 
  public   function  verify( $data )
 {
   return  RSA :: rsa_verify( $data , $this -> public_key , $this -> modulus , $this -> key_length);
 }
}

class  RSAKeyType
{
  const  XMLFile  =   0 ;
  const  XMLString  =   1 ;
}
?>

<? php
/**
*fileName testrsa.php
*author: laiyunqing<laiyunqing#gmail.com>
*/
require_once ( " RSAProcessor.class.php " );
$processor   =   new  RSAProcessor

( " <RSAKeyValue><Modulus>m6ljoeWhmnd0oRnsVEH5iNw3B8+vKVu7v7CVfMyf6bnKEzHa62TRmT/baJiSevoI/vgm2ph/s1JrQQTaGiErHicigwSC

Aw7+i05WFbnz7tOyiiJJVMfsdd+v7Xan9Hiud05FzxoMbM8vpiMHPEIDbGJ1MiXyupTVkz2WcMHyBoJ4S189opktZ43pviUhy0PeuWkyoU7zR54akPmK

Yg+z5Zr1r7K8lUZ1a3TThfJGxTQR/uZMtZz/q8QF0AANVQ/eyahTv9icBzBoDuncS0Y5l3vqogW1C/ltJvhJpvSn/OgjbRjuixCAptOUmRd13sDWU95/

x0bMq+Lg68lj2OjJ1Q==</Modulus><Exponent>AQAB</Exponent><P>zfvdBsMLlmo+4PAUYLgSV2xyyVa7ZqFjkJaAE4EbYuH24EoZjrzeiJR++D

FUT/GUhjfZ5eZ/5e29dXwk0sKUw6nHzBdBtOPp5fr4t5SKLEcWY+J+zLUSOlhG9NUkohFf6+Miy2Y7BLpXVrcl6UwXV0ak8KkTPB2l/aIMwYj5dgc=</

P><Q>wXV0sA3nDzoSDQA/4QSu/WIlBhkA3jZ7K7G9Z9rpP1A0vH+bZeyCIyo52u8ahGuYbubaizF1XMp+Xv3Mh2KmRbt7+UptwEwbFAUiiad2a312mqm

j7IJd7gRjGkyzKEm+6fpNeY3NFLNVNhccBqzhNkRoM22xnvQcImD10XVAakM=</Q><DP>wd1HdCLEWCfc0DYE59a2pINUMXyo2foRTDbpifHcRZ+ojAY

Rsc6+nsssCQnccXVMNVqBgSgEvfGYe+eAfMBX5SN5APPuioJrVGF2DsoFlZC+WPoGH0JYSoNlHO8yEDrMDaXzzH2GFHgQ1XOAged0nFbHzB1FFjJNVL5

cxRXWu6c=</DP><DQ>QDKuCk5SwubOXqoaiJ15RHRxPNjHRPZnYVSWOgSXKn9/QJ5H/0bA2NKGaHS4JAFgkEzjcRV0kNpRnUwztymxa6qPtWZRjWK0Ca

y6jVuZHIqB9UkeMLoCWZ3zFSMmwNPYGuUJGLFJwPjR6iU5E64C/nMs8QQR0WHIhFAQwvVZ7uk=</DQ><InverseQ>JckMSlJR10VZdnp83VPjrZ/Z+63

CGu3tWHm7f4DJ8IwjJWr8FlCpbSwiP6a4e9Upv6bUn/tOj2gY6MMq5G5yTKm2SCRvpUKRu4NCmWAt7vlFv0Z6pkXlTOpzvVjv3v16+dIZOA5Zn+v7+r1

xbdYdH20KRAbiBO3MfQP7s+VJJvM=</InverseQ><D>W1xrBr2hQOj1wgxWAgoK7IHbprEFrK+TnWmGA46SGPsbmHJ9fAVbY6fwHg7Wgmk4WHXLUCeLY

/Nu0eWIISfwh60Oe3ls2WC2k4qxyeSvQDBuLNb81U7WAUT9m9E1uK4QMCP3oxs1ybM80zTh7UMNgVK0WG+fbFUomVffcWTTqW+Fu12PEIO+UR/85oq+x

qVlTzYAEzt1OE9IhkYiRzi99ePXeH2gFltzJ/fb/7jLsDTkhM2eiYTGyOTZmBnen6c6a8b9LFTY4Bc0bGpk5ezHkub6F8p2ZgL/JgIOJMyRZICjDjs+9

k9PTmMTFsCF6xzHY15Fg25xIDYzIyx1rrRUjQ==</D></RSAKeyValue> " , RSAKeyType :: XMLString);
$rs   =    $processor -> encrypt( " Hello,It's Works. " );
echo   $rs ;
?>