javarsa私鑰加密-九游会j9娱乐平台

1. java ibm jdk rsa 怎麼 加密

android和java webservice rsa處理的不同

1.andorid機器上生成的（密鑰對由伺服器在windows xp下生成並將公鑰發給客戶端保存）密碼無法在伺服器通過私鑰解密。

2.為了測試，在伺服器本地加解密正常，另外，在android上加解密也正常，但是在伺服器中加密（使用相同公鑰）後的密碼同樣無法在android系統解密（使用相同私鑰）。
3.由於對rsa加密演算法不了解，而且對java rsa的加密過程也不清楚、谷歌一番，才了解到可能是加密過程中的填充字元長度不同，這跟加解密時指定的rsa演算法有關系。
4. 比如，在a機中使用標准rsa通過公鑰加密，然後在b系統中使用「rsa/ecb/nopadding」使用私鑰解密，結果可以解密，但是會發現解密後的原文前面帶有很多特殊字元，這就是在加密前填充的空字元；如果在b系統中仍然使用標準的rsa演算法解密，這在相同類型的jdk虛擬機環境下當然是完全一樣的，關鍵是android系統使用的虛擬機（dalvik）跟sun標准jdk是有所區別的，其中他們默認的rsa實現就不同。
5.更形象一點，在加密的時候加密的原文「abc」，直接使用「abc」.getbytes()方法獲得的bytes長度可能只有3，但是系統卻先把它放到一個512位的byte數組里，new byte[512]，再進行加密。但是解密的時候使用的是「加密後的密碼」.getbytes()來解密，解密後的原文自然就是512長度的數據，即是在「abc」之外另外填充了500多位元組的其他空字元。

2. java rsa 加密解密中 密鑰保存並讀取，數據加密解密並保存讀取 問題

幫你完善了下代碼。

importjava.io.file;
importjava.io.fileoutputstream;
importjava.io.filereader;
importjava.io.outputstream;
importjava.io.printwriter;
importjava.io.reader;
importjava.util.map;

publicclasstest{
staticstringpublickey;
staticstringprivatekey;

publictest()throwsexception{
//todoauto-generatedconstructorstub
mapkeymap=rsautils.genkeypair();
publickey=rsautils.getpublickey(keymap);
privatekey=rsautils.getprivatekey(keymap);

//保存密鑰，名字分別為publickey。txt和privatekey。txt;
printwriterpw1=newprintwriter(newfileoutputstream(
"d:/publickey.txt"));
printwriterpw2=newprintwriter(newfileoutputstream(
"d:/privatekey.txt"));
pw1.print(publickey);
pw2.print(privatekey);
pw1.close();
pw2.close();

//從保存的目錄讀取剛才的保存的公鑰，
stringpubkey=readfile("d:/publickey.txt");//讀取的公鑰內容；
stringdata=readfile("d:/1.txt");//需要公鑰加密的文件的內容(如d:/1.txt)
byte[]encbypubkeydata=rsautils.encryptbypublickey(data.getbytes(),
pubkey);
//將加密數據base64後寫入文件
writefile("d:/encfile.txt",base64utils.encode(encbypubkeydata).getbytes("utf-8"));
//加密後的文件保存在

stringprikey=readfile("d:/privatekey.txt");//從保存的目錄讀取剛才的保存的私鑰，
stringencdata=readfile("d:/encfile.txt");//剛才加密的文件的內容;
byte[]encdata=base64utils.decode(encdata);
byte[]decbyprikeydata=rsautils.decryptbyprivatekey(encdata,prikey);
//解密後後的文件保存在d:/decfile.txt
writefile("d:/decfile.txt",decbyprikeydata);
}

privatestaticstringreadfile(stringfilepath)throwsexception{
fileinfile=newfile(filepath);
longfilelen=infile.length();
readerreader=newfilereader(infile);

char[]content=newchar[(int)filelen];
reader.read(content);
system.out.println("讀取到的內容為：" newstring(content));
returnnewstring(content);
}

privatestaticvoidwritefile(stringfilepath,byte[]content)
throwsexception{
system.out.println("待寫入文件的內容為：" newstring(content));
fileoutfile=newfile(filepath);
outputstreamout=newfileoutputstream(outfile);
out.write(content);
if(out!=null)out.close();
}

publicstaticvoidmain(string[]args)throwsexception{
//todoauto-generatedmethodstub

newtest();
}

}

測試結果：

讀取到的內容為：  lxfzxznpea rhaxmeq2qi 5es9af7g6kiwjzakksa08ly 1y3dp0bnoyhf7/pj3as28fdme5piea7w36vp4e3ts f9vwidaqab
讀取到的內容為：鍩縣ahaha

3. 如何實現用javascript實現rsa加解密

1. 服務端生成公鑰與私鑰，保存。

2. 客戶端在請求到登錄頁面後，隨機生成一字元串。

3. 後此隨機字元串作為密鑰加密密碼，再用從服務端獲取到的公鑰加密生成的隨機字元串

4. 將此兩段密文傳入服務端，服務端用私鑰解出隨機字元串，再用此私鑰解出加密的密文。這其中有一個關鍵是解決服務端的公鑰，傳入客戶端，客戶端用此公鑰加密字元串後，後又能在服務端用私鑰解出。

步驟：

1. 服務端的rsajava實現：

   /**
   *
   */
   packagecom.sunsoft.struts.util;
   
   importjava.io.bytearrayoutputstream;
   importjava.io.fileinputstream;
   importjava.io.fileoutputstream;
   importjava.io.objectinputstream;
   importjava.io.objectoutputstream;
   importjava.math.biginteger;
   importjava.security.keyfactory;
   importjava.security.keypair;
   importjava.security.keypairgenerator;
   importjava.security.nosuchalgorithmexception;
   importjava.security.privatekey;
   importjava.security.publickey;
   importjava.security.securerandom;
   importjava.security.interfaces.rsaprivatekey;
   importjava.security.interfaces.rsapublickey;
   importjava.security.spec.invalidkeyspecexception;
   importjava.security.spec.rsaprivatekeyspec;
   importjava.security.spec.rsapublickeyspec;
   
   importjavax.crypto.cipher;/**
   *rsa工具類。提供加密，解密，生成密鑰對等方法。
   *需要到
   下載bcprov-jdk14-123.jar。
   *
   */
   publicclassrsautil{
   /**
   **生成密鑰對*
   *
   *@returnkeypair*
   *@throwsencryptexception
   */
   ()throwsexception{
   try{
   keypairgeneratorkeypairgen=keypairgenerator.getinstance("rsa",
   neworg.bouncycastle.jce.provider.bouncycastleprovider());
   finalintkey_size=1024;//沒什麼好說的了，這個值關繫到塊加密的大小，可以更改，但是不要太大，否則效率會低
   keypairgen.initialize(key_size,newsecurerandom());
   keypairkeypair=keypairgen.generatekeypair();
   savekeypair(keypair);
   returnkeypair;
   }catch(exceptione){
   thrownewexception(e.getmessage());
   }
   }
   
   publicstatickeypairgetkeypair()throwsexception{
   fileinputstreamfis=newfileinputstream("c:/rsakey.txt");
   objectinputstreamoos=newobjectinputstream(fis);
   keypairkp=(keypair)oos.readobject();
   oos.close();
   fis.close();
   returnkp;
   }
   
   publicstaticvoidsavekeypair(keypairkp)throwsexception{
   
   fileoutputstreamfos=newfileoutputstream("c:/rsakey.txt");
   objectoutputstreamoos=newobjectoutputstream(fos);
   //生成密鑰
   oos.writeobject(kp);
   oos.close();
   fos.close();
   }
   
   /**
   **生成公鑰*
   *
   *@parammolus*
   *@parampublicexponent*
   *@returnrsapublickey*
   *@throwsexception
   */
   (byte[]molus,
   byte[]publicexponent)throwsexception{
   keyfactorykeyfac=null;
   try{
   keyfac=keyfactory.getinstance("rsa",
   neworg.bouncycastle.jce.provider.bouncycastleprovider());
   }catch(nosuchalgorithmexceptionex){
   thrownewexception(ex.getmessage());
   }
   
   rsapublickeyspecpubkeyspec=newrsapublickeyspec(newbiginteger(
   molus),newbiginteger(publicexponent));
   try{
   return(rsapublickey)keyfac.generatepublic(pubkeyspec);
   }catch(invalidkeyspecexceptionex){
   thrownewexception(ex.getmessage());
   }
   }
   
   /**
   **生成私鑰*
   *
   *@parammolus*
   *@paramprivateexponent*
   *@returnrsaprivatekey*
   *@throwsexception
   */
   (byte[]molus,
   byte[]privateexponent)throwsexception{
   keyfactorykeyfac=null;
   try{
   keyfac=keyfactory.getinstance("rsa",
   neworg.bouncycastle.jce.provider.bouncycastleprovider());
   }catch(nosuchalgorithmexceptionex){
   thrownewexception(ex.getmessage());
   }
   
   rsaprivatekeyspecprikeyspec=newrsaprivatekeyspec(newbiginteger(
   molus),newbiginteger(privateexponent));
   try{
   return(rsaprivatekey)keyfac.generateprivate(prikeyspec);
   }catch(invalidkeyspecexceptionex){
   thrownewexception(ex.getmessage());
   }
   }
   
   /**
   **加密*
   *
   *@paramkey
   *加密的密鑰*
   *@paramdata
   *待加密的明文數據*
   *@return加密後的數據*
   *@throwsexception
   */
   publicstaticbyte[]encrypt(publickeypk,byte[]data)throwsexception{
   try{
   ciphercipher=cipher.getinstance("rsa",
   neworg.bouncycastle.jce.provider.bouncycastleprovider());
   cipher.init(cipher.encrypt_mode,pk);
   intblocksize=cipher.getblocksize();//獲得加密塊大小，如：加密前數據為128個byte，而key_size=1024
   //加密塊大小為127
   //byte,加密後為128個byte;因此共有2個加密塊，第一個127
   //byte第二個為1個byte
   intoutputsize=cipher.getoutputsize(data.length);//獲得加密塊加密後塊大小
   intleavedsize=data.length%blocksize;
   intblockssize=leavedsize!=0?data.length/blocksize 1
   :data.length/blocksize;
   byte[]raw=newbyte[outputsize*blockssize];
   inti=0;
   while(data.length-i*blocksize>0){
   if(data.length-i*blocksize>blocksize)
   cipher.dofinal(data,i*blocksize,blocksize,raw,i
   *outputsize);
   else
   cipher.dofinal(data,i*blocksize,data.length-i
   *blocksize,raw,i*outputsize);
   //這裡面doupdate方法不可用，查看源代碼後發現每次doupdate後並沒有什麼實際動作除了把byte[]放到
   //bytearrayoutputstream中，而最後dofinal的時候才將所有的byte[]進行加密，可是到了此時加密塊大小很可能已經超出了
   //outputsize所以只好用dofinal方法。
   
   i  ;
   }
   returnraw;
   }catch(exceptione){
   thrownewexception(e.getmessage());
   }
   }
   
   /**
   **解密*
   *
   *@paramkey
   *解密的密鑰*
   *@paramraw
   *已經加密的數據*
   *@return解密後的明文*
   *@throwsexception
   */
   publicstaticbyte[]decrypt(privatekeypk,byte[]raw)throwsexception{
   try{
   ciphercipher=cipher.getinstance("rsa",
   neworg.bouncycastle.jce.provider.bouncycastleprovider());
   cipher.init(cipher.decrypt_mode,pk);
   intblocksize=cipher.getblocksize();
   bytearrayoutputstreambout=newbytearrayoutputstream(64);
   intj=0;
   
   while(raw.length-j*blocksize>0){
   bout.write(cipher.dofinal(raw,j*blocksize,blocksize));
   j  ;
   }
   returnbout.tobytearray();
   }catch(exceptione){
   thrownewexception(e.getmessage());
   }
   }
   
   /**
   ***
   *
   *@paramargs*
   *@throwsexception
   */
   publicstaticvoidmain(string[]args)throwsexception{
   rsapublickeyrsap=(rsapublickey)rsautil.generatekeypair().getpublic();
   stringtest="helloworld";
   byte[]en_test=encrypt(getkeypair().getpublic(),test.getbytes());
   byte[]de_test=decrypt(getkeypair().getprivate(),en_test);
   system.out.println(newstring(de_test));
   }
   }

2. 測試頁面indexaction.java：

   /*
   *generatedbymyeclipsestruts
   *templatepath:templates/java/javaclass.vtl
   */
   packagecom.sunsoft.struts.action;
   
   importjava.security.interfaces.rsaprivatekey;
   importjava.security.interfaces.rsapublickey;
   
   importjavax.servlet.http.httpservletrequest;
   importjavax.servlet.http.httpservletresponse;
   
   importorg.apache.struts.action.action;
   importorg.apache.struts.action.actionform;
   importorg.apache.struts.action.actionforward;
   importorg.apache.struts.action.actionmapping;
   
   importcom.sunsoft.struts.util.rsautil;
   
   /**
   *myeclipsestruts
   *creationdate:06-28-2008
   *
   *xdocletdefinition:
   *@struts.actionvalidate="true"
   */
   {
   /*
   *generatedmethods
   */
   
   /**
   *methodexecute
   *@parammapping
   *@paramform
   *@paramrequest
   *@paramresponse
   *@returnactionforward
   */
   publicactionforwardexecute(actionmappingmapping,actionformform,
   httpservletrequestrequest,httpservletresponseresponse)throwsexception{
   
   rsapublickeyrsap=(rsapublickey)rsautil.getkeypair().getpublic();
   stringmole=rsap.getmolus().tostring(16);
   stringempoent=rsap.getpublicexponent().tostring(16);
   system.out.println("mole");
   system.out.println(mole);
   system.out.println("empoent");
   system.out.println(empoent);
   request.setattribute("m",mole);
   request.setattribute("e",empoent);
   returnmapping.findforward("login");
   }
   }

   通過此action進入登錄頁面，並傳入公鑰的molus 與publicexponent的hex編碼形式。

4. 非對稱加密解密rsa的實現例子

最近有接觸到加密相關的內容，本期以非對稱加密為例子，做個簡單的總結和記錄。首先了解下非對稱加密，簡單來說非對稱指的是加密和解密用不同的秘鑰，典型的rsa，這個演算法名稱是基於三個發明人的名字首字母取的；辯含碧而對稱加密必須要在加解密使用相同的秘鑰攜舉，典型的aes。這里細節不多展開闡述，涉及到很多數學原理，如大數的質因數分解等，感興趣的可以找找李永樂等網上比較優秀的科普。這篇文章只是java原生實現的加解密例子。至於其他的如md5,hash等，如果從主觀可讀的角度來說，也可以稱為加密。

如下的示例是使用java原生實現rsa的加密解密，包括用公鑰加密，然後私鑰解密；或者使用私鑰加密，然後公鑰解密。注意不同key大小，限制的解密內容大小也不一樣，感老備興趣的同學可以試試修改key大小和加密內容長度來試試。還有要注意的是rsa加密有一定的性能損耗。

想了解原理相關的內容可以看如下的參考內容。
[1]. rsa原理

5. 高分求java的rsa 和idea 加密解密演算法

rsa演算法非常簡單，概述如下：
找兩素數p和q
取n=p*q
取t=(p-1)*(q-1)
取任何一個數e,要求滿足e取d*e%t==1

這樣最終得到三個數： n d e

設消息為數m (m 設c=(m**d)%n就得到了加密後的消息c
設m=(c**e)%n則 m == m，從而完成對c的解密。
註：**表示次方,上面兩式中的d和e可以互換。

在對稱加密中：
n d兩個數構成公鑰，可以告訴別人；
n e兩個數構成私鑰，e自己保留，不讓任何人知道。
給別人發送的信息使用e加密，只要別人能用d解開就證明信息是由你發送的，構成了簽名機制。
別人給你發送信息時使用d加密，這樣只有擁有e的你能夠對其解密。

rsa的安全性在於對於一個大數n，沒有有效的方法能夠將其分解
從而在已知n d的情況下無法獲得e；同樣在已知n e的情況下無法
求得d。

<二>實踐

接下來我們來一個實踐，看看實際的操作：
找兩個素數：
p=47
q=59
這樣
n=p*q=2773
t=(p-1)*(q-1)=2668
取e=63，滿足e用perl簡單窮舉可以獲得滿主 e*d%t ==1的數d：
c:\temp>perl -e "foreach $i (1..9999){ print($i),last if $i*63&68==1 }"
847
即d＝847

最終我們獲得關鍵的
n=2773
d=847
e=63

取消息m=244我們看看

加密：

c=m**d%n = 244**847'73
用perl的大數計算來算一下：
c:\temp>perl -mbigint -e "print 244**847'73"
465
即用d對m加密後獲得加密信息c＝465

解密：

我們可以用e來對加密後的c進行解密，還原m：
m=c**e%n=465**63'73 ：
c:\temp>perl -mbigint -e "print 465**63'73"
244
即用e對c解密後獲得m=244 , 該值和原始信息m相等。

<三>字元串加密

把上面的過程集成一下我們就能實現一個對字元串加密解密的示例了。
每次取字元串中的一個字元的ascii值作為m進行計算，其輸出為加密後16進制
的數的字元串形式，按3位元組表示，如01f

代碼如下：

#!/usr/bin/perl -w
#rsa 計算過程學習程序編寫的測試程序
#watercloud 2003-8-12
#
use strict;
use math::bigint;

my %rsa_core = (n=>2773,e=>63,d=>847); #p=47,q=59

my $n=new math::bigint($rsa_core{n});
my $e=new math::bigint($rsa_core{e});
my $d=new math::bigint($rsa_core{d});

print "n=$n d=$d e=$e\n";

sub rsa_encrypt
{
my $r_mess = shift @_;
my ($c,$i,$m,$c,$cmess);

for($i=0;$i < length($$r_mess);$i )
{
$c=ord(substr($$r_mess,$i,1));
$m=math::bigint->new($c);
$c=$m->(); $c->bmodpow($d,$n);
$c=sprintf "x",$c;
$cmess.=$c;
}
return \$cmess;
}

sub rsa_decrypt
{
my $r_mess = shift @_;
my ($c,$i,$m,$c,$dmess);

for($i=0;$i < length($$r_mess);$i =3)
{
$c=substr($$r_mess,$i,3);
$c=hex($c);
$m=math::bigint->new($c);
$c=$m->(); $c->bmodpow($e,$n);
$c=chr($c);
$dmess.=$c;
}
return \$dmess;
}

my $mess="rsa 娃哈哈哈～～～";
$mess=$argv[0] if @argv >= 1;
print "原始串：",$mess,"\n";

my $r_cmess = rsa_encrypt(\$mess);
print "加密串：",$$r_cmess,"\n";

my $r_dmess = rsa_decrypt($r_cmess);
print "解密串：",$$r_dmess,"\n";

#eof

測試一下：
c:\temp>perl rsa-test.pl
n=2773 d=847 e=63
原始串：rsa 娃哈哈哈～～～
加密串：
解密串：rsa 娃哈哈哈～～～

c:\temp>perl rsa-test.pl 安全焦點（xfocus）
n=2773 d=847 e=63
原始串：安全焦點（xfocus）
加密串：
解密串：安全焦點（xfocus）

<四>提高

前面已經提到，rsa的安全來源於n足夠大，我們測試中使用的n是非常小的，根本不能保障安全性，
我們可以通過rsakit、rsatool之類的工具獲得足夠大的n 及d e。
通過工具，我們獲得1024位的n及d e來測試一下：

n=ec3a85f5005d
4c2013433b383b
a50e114705d7e2
bc511951

d=0x10001

e=dd28c523c2995
47b77324e66aff2
789bd782a592d2b
1965

設原始信息
m=

完成這么大數字的計算依賴於大數運算庫，用perl來運算非常簡單：

a) 用d對m進行加密如下：
c=m**d%n :
c:\temp>perl -mbigint -e " $x=math::bigint->bmodpow(0x11111111111122222222222233
333333333, 0x10001,
d55edbc4f0
6e37108dd6
);print $x->as_hex"
b73d2576bd
47715caa6b
d59ea89b91
f1834580c3f6d90898

即用d對m加密後信息為：
c=b73d2576bd
47715caa6b
d59ea89b91
f1834580c3f6d90898

b) 用e對c進行解密如下：

m=c**e%n ：
c:\temp>perl -mbigint -e " $x=math::bigint->bmodpow(0x17b287be418c69ecd7c39227ab
5aa1d99ef3
0cb4764414
, 0xe760a
3c29954c5d
7324e66aff
2789bd782a
592d2b1965, cd15f90
4f017f9ccf
dd60438941
);print $x->as_hex"

(我的p4 1.6g的機器上計算了約5秒鍾）

得到用e解密後的m= == m

c) rsa通常的實現
rsa簡潔幽雅，但計算速度比較慢，通常加密中並不是直接使用rsa 來對所有的信息進行加密，
最常見的情況是隨機產生一個對稱加密的密鑰，然後使用對稱加密演算法對信息加密，之後用
rsa對剛才的加密密鑰進行加密。

最後需要說明的是，當前小於1024位的n已經被證明是不安全的
自己使用中不要使用小於1024位的rsa，最好使用2048位的。

----------------------------------------------------------

一個簡單的rsa演算法實現java源代碼：

filename:rsa.java

/*
* created on mar 3, 2005
*
* todo to change the template for this generated file go to
* window - preferences - java - code style - code templates
*/

import java.math.biginteger;
import java.io.inputstream;
import java.io.outputstream;
import java.io.fileinputstream;
import java.io.fileoutputstream;
import java.io.filenotfoundexception;
import java.io.ioexception;
import java.io.filewriter;
import java.io.filereader;
import java.io.bufferedreader;
import java.util.stringtokenizer;

/**
* @author steve
*
* todo to change the template for this generated type comment go to
* window - preferences - java - code style - code templates
*/
public class rsa {

/**
* biginteger.zero
*/
private static final biginteger zero = biginteger.zero;

/**
* biginteger.one
*/
private static final biginteger one = biginteger.one;

/**
* pseudo biginteger.two
*/
private static final biginteger two = new biginteger("2");

private biginteger mykey;

private biginteger mymod;

private int blocksize;

public rsa (biginteger key, biginteger n, int b) {
mykey = key;
mymod = n;
blocksize = b;
}

public void encodefile (string filename) {
byte[] bytes = new byte[blocksize / 8 1];
byte[] temp;
int templen;
inputstream is = null;
filewriter writer = null;
try {
is = new fileinputstream(filename);
writer = new filewriter(filename ".enc");
}
catch (filenotfoundexception e1){
system.out.println("file not found: " filename);
}
catch (ioexception e1){
system.out.println("file not found: " filename ".enc");
}

/**
* write encoded message to 'filename'.enc
*/
try {
while ((templen = is.read(bytes, 1, blocksize / 8)) > 0) {
for (int i = templen 1; i < bytes.length; i) {
bytes[i] = 0;
}
writer.write(encodedecode(new biginteger(bytes)) " ");
}
}
catch (ioexception e1) {
system.out.println("error writing to file");
}

/**
* close input stream and file writer
*/
try {
is.close();
writer.close();
}
catch (ioexception e1) {
system.out.println("error closing file.");
}
}

public void decodefile (string filename) {

filereader reader = null;
outputstream os = null;
try {
reader = new filereader(filename);
os = new fileoutputstream(filename.replaceall(".enc", ".dec"));
}
catch (filenotfoundexception e1) {
if (reader == null)
system.out.println("file not found: " filename);
else
system.out.println("file not found: " filename.replaceall(".enc", "dec"));
}

bufferedreader br = new bufferedreader(reader);
int offset;
byte[] temp, tofile;
stringtokenizer st = null;
try {
while (br.ready()) {
st = new stringtokenizer(br.readline());
while (st.hasmoretokens()){
tofile = encodedecode(new biginteger(st.nexttoken())).tobytearray();
system.out.println(tofile.length " x " (blocksize / 8));

if (tofile[0] == 0 && tofile.length != (blocksize / 8)) {
temp = new byte[blocksize / 8];
offset = temp.length - tofile.length;
for (int i = tofile.length - 1; (i <= 0) && ((i offset) <= 0); --i) {
temp[i offset] = tofile[i];
}
tofile = temp;
}

/*if (tofile.length != ((blocksize / 8) 1)){
temp = new byte[(blocksize / 8) 1];
system.out.println(tofile.length " x " temp.length);
for (int i = 1; i < temp.length; i ) {
temp[i] = tofile[i - 1];
}
tofile = temp;
}
else
system.out.println(tofile.length " " ((blocksize / 8) 1));*/
os.write(tofile);
}
}
}
catch (ioexception e1) {
system.out.println("something went wrong");
}

/**
* close data streams
*/
try {
os.close();
reader.close();
}
catch (ioexception e1) {
system.out.println("error closing file.");
}
}

/**
* performs base^^pow within the molar
* domain of mod.
*
* @param base the base to be raised
* @param pow the power to which the base will be raisded
* @param mod the molar domain over which to perform this operation
* @return base^^pow within the molar
* domain of mod.
*/
public biginteger encodedecode(biginteger base) {
biginteger a = one;
biginteger s = base;
biginteger n = mykey;

while (!n.equals(zero)) {
if(!n.mod(two).equals(zero))
a = a.multiply(s).mod(mymod);

s = s.pow(2).mod(mymod);
n = n.divide(two);
}

return a;
}

}

在這里提供兩個版本的rsa演算法java實現的代碼下載：

1. 來自於 http://www.javafr.com/code.aspx?id=27020 的rsa演算法實現源代碼包:
http://zeal.newmenbase.net/attachment/javafr_rsa_source.rar

2. 來自於 http://www.ferrara.linux.it/members/lucabariani/rsa/implementazionersa/ 的實現:
http://zeal.newmenbase.net/attachment/sorgentijava.tar.gz - 源代碼包
http://zeal.newmenbase.net/attachment/algoritmorsa.jar - 編譯好的jar包

另外關於rsa演算法的php實現請參見文章:
php下的rsa演算法實現

關於使用vb實現rsa演算法的源代碼下載(此程序採用了psc1演算法來實現快速的rsa加密):
http://zeal.newmenbase.net/attachment/vb_psc1_rsa.rar

rsa加密的javascript實現: http://www.ohdave.com/rsa/

6. java寫rsa加密，公鑰私鑰都是一樣的，為什麼每次加密的結果不一樣

因為rsa是非對稱加密，它使用的是隨機大素數的抽取，每次隨機生成的，所以每次加密的結果不可能一樣

7. 關於java中rsa的問題

【實例下載】本文介紹rsa2加密與解密，rsa2是rsa的加強版本，在密鑰長度上採用2048, rsa2比rsa更安全，更可靠, 本人的另一篇文章rsa已經發表，有想了解的可以點開下面的rsa文章