C# RSA Python

[angelipin]

C#里面用using System.Security.Cryptography; RSACryptoServiceProvider加密过的消息
用Python Crypto中RSA的方法 能直接 解吗？
RSA加密方式不是统一的吗？需要注意些什么？

using System;
using System.Collections.Generic;
using System.Text;
using System.Security.Cryptography;
using System.IO;

namespace Cryptography
{
    class Program
    {
        static void Main(string[] args)
        {
            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
            RSAParameters keys = rsa.ExportParameters(true);
            String pkxml = "<root>\n<Modulus>" + Convert.ToBase64String(keys.Modulus) + "</Modulus>";
            pkxml += "\n<Exponent>" + Convert.ToBase64String(keys.Exponent) + "</Exponent>\n</root>";

            String psxml = "<root>\n<Modulus>" + Convert.ToBase64String(keys.Modulus) + "</Modulus>";
            psxml += "\n<Exponent>" + Convert.ToBase64String(keys.Exponent) + "</Exponent>";
            psxml += "\n<D>" + Convert.ToBase64String(keys.D) + "</D>";
            psxml += "\n<DP>" + Convert.ToBase64String(keys.DP) + "</DP>";
            psxml += "\n<P>" + Convert.ToBase64String(keys.P) + "</P>";
            psxml += "\n<Q>" + Convert.ToBase64String(keys.Q) + "</Q>";
            psxml += "\n<DQ>" + Convert.ToBase64String(keys.DQ) + "</DQ>";
            psxml += "\n<InverseQ>" + Convert.ToBase64String(keys.InverseQ) + "</InverseQ>\n</root>";
            
            Console.WriteLine(rsa.ToXmlString(true));

            BigInteger bign = new BigInteger(keys.Modulus);
            Console.WriteLine("N   :" + bign);

            BigInteger bige = new BigInteger(keys.Exponent);
            Console.WriteLine("E   :" + bige);

            BigInteger bigd = new BigInteger(keys.D);
            Console.WriteLine("D   :" + bigd);
            SaveToFile("publickey.xml", pkxml);
            SaveToFile("privatekey.xml", psxml);
            Console.WriteLine("RSA Key保存成功！");

            Console.WriteLine("PublicKey:\n" + pkxml);
            Console.WriteLine("\nPrivateKey:\n" + psxml);
            CheckEncrypt();
            Console.WriteLine("Press [Enter] to exit.");
            Console.ReadLine();
        }

        //保存文件
        static void SaveToFile(String filename, String data)
        {
            System.IO.StreamWriter sw = System.IO.File.CreateText(filename);
            sw.WriteLine(data);
            sw.Close();
        }
        //演示数字签名算法
        static void CheckSign()
        {
            Console.WriteLine("\nVerify Signature TEST:\n===========================");
            RSAHandler rsahd = new RSAHandler();
            RSAPKCS1SignatureDeformatter deformat = rsahd.CreateRSADeformatter("publickey.xml");
            RSAPKCS1SignatureFormatter format = rsahd.CreateRSAFormatter("privatekey.xml");
            //读入一个文件
            String filename = "samplefile.jpg";
            Stream sm = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read);
            byte[] hashsm = rsahd.GetHashData(sm);
            Console.WriteLine("1.HashData:\n" + Convert.ToBase64String(hashsm));
            byte[] signdata = format.CreateSignature(hashsm);
            Console.WriteLine("\n2.Signature:\n" + Convert.ToBase64String(signdata));
            if (deformat.VerifySignature(hashsm, signdata))
            {
                Console.WriteLine("\n3.Signature is OK!");
            }
        }
        //演示加密解密处理
        static void CheckEncrypt()
        {
            Console.WriteLine("\n加密解密测试:\n===========================");
            RSAHandler rsahd = new RSAHandler();
            RSACryptoServiceProvider rsaprd = rsahd.CreateRSAProvider("privatekey.xml");
            RSACryptoServiceProvider rsaprd1 = rsahd.CreateRSAEncryptProvider("publickey.xml");
            String text = "Hello World!";
            Console.WriteLine("1.明文:\n" + text);
            byte[] data = new UnicodeEncoding().GetBytes(text);
            byte[] endata = rsaprd1.Encrypt(data, true);
            Console.WriteLine("2.publicKey加密后的数据:\n" + Convert.ToBase64String(endata));
            SaveToFile("encode.txt", Convert.ToBase64String(endata));
            System.IO.File.WriteAllBytes("cry", endata);
            byte[] dedata = rsaprd.Decrypt(endata, true);
            Console.WriteLine("3.privateKey解密后的数据:\n" + (new UnicodeEncoding()).GetString(dedata));

        }


    }
}

import Crypto
import Crypto.PublicKey
from Crypto.PublicKey.RSA import generate

from cPickle import dumps, loads
import base64
import math
import os
import random
import sys
import types
import zlib

class RSA():
    def genkey(self,bits = 1024):
        Key = generate(bits)
        #['n', 'e', 'd', 'p', 'q', 'u']
        #print 'n ',Key.n
        #print 'e ',Key.e
        #print 'd ',Key.d
        #print 'p ',Key.p
        #print 'q ',Key.q
        #print 'u ',Key.u
        #print '  ',Key.p * Key.q
        return {'public':{'k':Key.e,'n':Key.n},'private':{'k':Key.d,'n':Key.n}}
    
    def encrypt(self,message,key):
        print 'here!'
        return self.chopstring(message, key['k'],key['n'],self.encrypt_int)
    
    def decrypt(self,cypher, key):
        """Decrypts a cypher with the private key 'key'"""
    
        return self.gluechops(cypher, key['k'], key['n'], self.decrypt_int)
    
    def sign(self,message, key):
        """Signs a string 'message' with the private key 'key'"""
        
        return self.chopstring(message, key['k'], key['n'], self.decrypt_int)

    def verify(self,cypher, key):
        """Verifies a cypher with the public key 'key'"""
    
        return self.gluechops(cypher, key['k'], key['n'], self.encrypt_int)   
    
    def decrypt_int(self,cyphertext, dkey, n):
        """Decrypts a cypher text using the decryption key 'dkey', working
        modulo n"""
    
        return self.encrypt_int(cyphertext, dkey, n)

    def gluechops(self,chops, key, n, funcref):
        """Glues chops back together into a string.  calls
        funcref(integer, key, n) for each chop.
    
        Used by 'decrypt' and 'verify'.
        """
        message = ""
    
        chops = self.unpicklechops(chops)
        
        for cpart in chops:
            mpart = funcref(cpart, key, n)
            message += self.int2bytes(mpart)
        
        return message
    def unpicklechops(self,string):
        """base64decodes and unpickes it's argument string into chops"""
    
        return loads(zlib.decompress(base64.decodestring(string)))

    def int2bytes(self,number):
        """Converts a number to a string of bytes
        
        >>> bytes2int(int2bytes(123456789))
        123456789
        """
    
        if not (type(number) is types.LongType or type(number) is types.IntType):
            raise TypeError("You must pass a long or an int")
    
        string = ""
    
        while number > 0:
            string = "%s%s" % (chr(number & 0xFF), string)
            number /= 256
        
        return string

    def encrypt_int(self,message, ekey, n):
        """Encrypts a message using encryption key 'ekey', working modulo
        n"""
    
        if type(message) is types.IntType:
            return self.encrypt_int(long(message), ekey, n)
    
        if not type(message) is types.LongType:
            raise TypeError("You must pass a long or an int")
    
        if message > 0 and \
                math.floor(math.log(message, 2)) > math.floor(math.log(n, 2)):
            raise OverflowError("The message is too long")
    
        return self.fast_exponentiation(message, ekey, n)

    def fast_exponentiation(self,a, p, n):
        """Calculates r = a^p mod n
        """
        result = a % n
        remainders = []
        while p != 1:
            remainders.append(p & 1)
            p = p >> 1
        while remainders:
            rem = remainders.pop()
            result = ((a ** rem) * result ** 2) % n
        return result
    
    def chopstring(self,message, key, n, funcref):
        """Splits 'message' into chops that are at most as long as n,
        converts these into integers, and calls funcref(integer, key, n)
        for each chop.
    
        Used by 'encrypt' and 'sign'.
        """
    
        msglen = len(message)
        mbits = msglen * 8
        nbits = int(math.floor(math.log(n, 2)))
        nbytes = nbits / 8
        blocks = msglen / nbytes
    
        if msglen % nbytes > 0:
            blocks += 1
    
        cypher = []
        
        for bindex in range(blocks):
            offset = bindex * nbytes
            block = message[offset:offset+nbytes]
            value = self.bytes2int(block)
            cypher.append(funcref(value, key, n))
    
        return self.picklechops(cypher)
    
    def bytes2int(self,bytes):
        """Converts a list of bytes or a string to an integer
    
        >>> (128*256 + 64)*256 + + 15
        8405007
        >>> l = [128, 64, 15]
        >>> bytes2int(l)
        8405007
        """
    
        if not (type(bytes) is types.ListType or type(bytes) is types.StringType):
            raise TypeError("You must pass a string or a list")
    
        # Convert byte stream to integer
        integer = 0
        for byte in bytes:
            integer *= 256
            if type(byte) is types.StringType: byte = ord(byte)
            integer += byte
    
        return integer
    
    def picklechops(self,chops):
        """Pickles and base64encodes it's argument chops"""
    
        value = zlib.compress(dumps(chops))
        encoded = base64.encodestring(value)
        return encoded.strip()

[thy38]

加解密算法都是标准的，当然可以