javascript對稱加密

㈠ js有幾種加密方式

首先，MD5不是加密演算法，是簽名演算法，哎，到底是有多少國人被毒害了呀。

另外，只要是可以由軟體實現的加密演算法，js都能使用，只是有效率問題，
一般的
非對稱演算法，使用的資源都很龐大，所以js很少有。
而對稱的加密演算法……，由於js是對用戶可見的，所以……就和沒加密一樣。

這也就是為什麼真正的高安全網站都不會選擇用js做加密，而是選擇用https 協議這樣的手段。

再次重申，MD5不是加密演算法，所以不再上述范圍內

㈡ 關於javascript中的非對稱加密以及中間人攻擊的疑問

你下載一個httpWatch, 打開web.qq.com 輸入帳號密碼，就能截獲到帳號密碼驗證碼。只要他是適用http通信，就都能截獲到。

㈢ javascript 提交加密用戶輸入的密碼，求教程！！！

這個……

你說的事情是可以實現啦，但是沒什麼實際意義呀。

沒有人 會自己通過js去實現一個加密的。

首先，加密就是為了不能破解。但是js又是對客戶端開放的。也就是說你的演算法中加密演算法部分和密鑰都是透明的，而明文就是用戶提交的數據，對用戶也是透明的。
如果是對稱演算法，那麼你加密和沒加密是一樣的。因為加密演算法和密鑰都給人家了，反算即可。
如果是非對稱的演算法，估計你還沒等發送數據，演算法本身就把客戶端的瀏覽器掛死了。

所以即使要加密也不應該在js 想辦法，應該在傳輸協議上想辦法。https 可以完全解決你的加密需求的。

當然，如果你說的不是加密，而是MD5的簽名演算法倒是可以實現，也有意義。

如果你不明白我說的 什麼是 加密演算法，密鑰，明文，密文，什麼的對稱非對稱，那……還是老老實實用https 吧

㈣ 網站JS分析教程，不找javascript教材， 找的是如何分析網頁的教程！

不要學習密碼學，請專注你使用的加密解密API.
MD5， JS不知道，但是Java有很多，這個請網路。
關於教程，沒教程，在應用層，這個太簡單，沒人寫。
MD5是非對稱加密方式，意思是實際應用中不存在解密。
只有要破解別人的東西時候才會涉及解密，如果沒有鹽值，或其他的輔助加密。
對於簡單的MD5使用帶關鍵字的暴力破解就可以了。

㈤ url參數加密

加密URL參數

插件在訪問 Web 程序時，可以使用 Get 方法或 Post 方法提交數據，無論是哪種方法，按照 HTTP 協議的規范，參數總是按照以下格式提交（每對參數名/參數值以「&」號分隔）：

參數名1=參數值1&參數名2=參數值2&參數名3=參數值3...

如果您沒有使用SSL，所有的參數名和參數值都將以明文的形式通過網路傳輸到 Web 伺服器，顯然這種方式是很不安全的，為了保證插件與Web 程序的通訊安全，插件在提交參數前可以對每個參數值使用 Rijndael 加密演算法進行加密處理，並使用 Base64 編碼轉換為可讀字元串形式。

Rijndael 加密演算法是一種高效的對稱加密演算法，它是 AES（Advanced Encryption Standard，高級加密演算法標准）的實現，在加密和解密時有兩個基本參數：初始向量和密鑰，Web程序在進行解密時必須使用和插件端設置相同的初始向量和密鑰。

下面分別列出了加密和不加密的例子各一個：

a. 不加密：Username=test&Password=123456&ClientIP=192.168.0.200&CurrentTime=2005-07-06+23%3a51%3a29

b. 加密：Username=ZtlBwgvwkS5YV98N9cgO%2fw%3d%3d&Password=vBSchK4dJX7Z2zfUatu9ZQ%3d%3d&CurrentTime=mpNifqRIvBV2xZi3d%2fPli6%2bZwR9BKHs4y6t%2bNS2QIr4%3d

在 Web 程序端必須使用相同的演算法來解密各個參數值，具體如何實現取決與您所使用的 Web 程序語言，這就需要您找到特定語言的演算法實現。解密一個參數值的過程包括下面三個步驟：

1. 使用 Base64 演算法將參數值轉換為位元組數組；

2. 使用 Rijndael 演算法將 1 中得到的位元組數組解密得到另一位元組數組；

3. 將 2 中得到位元組數組用特定的字元集轉換成字元串，即得到原始的數據。

插件安裝目錄下的「GVODClassLib.dll」文件包含了加密和解密的演算法實現類 CryptoUtility，它的 Decrypt 方法可以直接將 Base64 編碼後的密文解密為原文字元串，如果您的 Web 程序使用的是 asp.net 編寫的，可以將該文件拷貝到您 Web 站點的「/bin」目錄下，然後按照下面的例子完成解密：

<%@ page language="C#" %>
<%@ import namespace="Com.GVOD" %>
<%
//定義密鑰，請改成你加密時使用的密鑰
string key = "OEtxF/yyALd2NflVW4KSMspQIozPkSRL+mEdvlBAzUQ=";

//定義初始向量，請改成你加密時使用的初始向量
string iv = "Cz3EXGTEMeIN8PXKFLiZWg==";

//定義密鑰長度，請改成你加密時使用的密鑰的長度
int keyLength = 256;

//生成 CryptoUtility 類的實例
CryptoUtility util = new CryptoUtility(key, iv, keyLength);

//解密用戶名
string username = util.Decrypt(Request["Username"]);

//解密密碼
string password = util.Decrypt(Request["Password"]);

//解密其它參數
...
%>

㈥ 關於nodejs 怎麼實現 crypto des加密

就是加密和解密使用同一個密鑰，通常稱之為「Session Key 」這種加密技術在當今被廣泛採用，如美國政府所採用的DES加密標准就是一種典型的「對稱式」加密法，它的Session Key長度為56bits。
非對稱式加密：
就是加密和解密所使用的不是同一個密鑰，通常有兩個密鑰，稱為「公鑰」和「私鑰」，它們兩個必需配對使用，否則不能打開加密文件。
加密為系統中經常使用的功能，node自帶強大的加密功能Crypto，下面通過簡單的例子進行練習。
1、加密模塊的引用：
var crypto=require('crypto');
var $=require('underscore');var DEFAULTS = {
encoding: {
input: 'utf8',
output: 'hex'
},
algorithms: ['bf', 'blowfish', 'aes-128-cbc']
};

默認加密演算法配置項：
輸入數據格式為utf8，輸出格式為hex，
演算法使用bf,blowfish,aes-128-abc三種加密演算法;
2、配置項初始化：
function MixCrypto(options) {
if (typeof options == 'string')
options = { key: options };

options = $.extend({}, DEFAULTS, options);
this.key = options.key;
this.inputEncoding = options.encoding.input;
this.outputEncoding = options.encoding.output;
this.algorithms = options.algorithms;
}

加密演算法可以進行配置，通過配置option進行不同加密演算法及編碼的使用。
3、加密方法代碼如下：
MixCrypto.prototype.encrypt = function (plaintext) {
return $.rece(this.algorithms, function (memo, a) {
var cipher = crypto.createCipher(a, this.key);
return cipher.update(memo, this.inputEncoding, this.outputEncoding)
+ cipher.final(this.outputEncoding)
}, plaintext, this);
};

使用crypto進行數據的加密處理。
4、解密方法代碼如下：
MixCrypto.prototype.decrypt = function (crypted) {
try {
return $.receRight(this.algorithms, function (memo, a) {
var decipher = crypto.createDecipher(a, this.key);
return decipher.update(memo, this.outputEncoding, this.inputEncoding)
+ decipher.final(this.inputEncoding);
}, crypted, this);
} catch (e) {
return;
}
};

㈦ JAVA程序加密，怎麼做才安全

程序加密？你說的是代碼加密還是數據加密。我都說一下吧。

Java代碼加密：

這點因為Java是開源的，想達到完全加密，基本是不可能的，因為在反編譯的時候，雖然反編譯回來的時候可能不是您原來的代碼，但是意思是接近的，所以是不行的。

那麼怎麼增加反編譯的難度（閱讀難度），那麼可以採用多層繼承（實現）方式來解決，這樣即使反編譯出來的代碼，可讀性太差，復用性太差了。

Java數據加密：

我們一般用校驗性加密，常用的是MD5，優點是速度快，數據佔用空間小。缺點是不可逆，所以我們一般用來校驗數據有沒有被改動等。

需要可逆，可以選用base64，Unicode，缺點是沒有密鑰，安全性不高。

而我們需要可逆而且採用安全的方式是：對稱加密和非堆成加密，我們常用的有AES、DES等單密鑰和雙密鑰的方式。而且是各種語言通用的。

全部手動敲字，望採納，下面是我用Javascript方式做的一系列在線加密/解密工具：

http://www.sojson.com/encrypt.html

㈧ 請高人指點一段javascript加密演算法的思想...急!!!!

這個加碼程序是利用隨機碼進行加密的，從我初步的判斷就是利用了一個隨機數而已，然後將這個隨機數又用8位16進行在密文的最後累上的。所以很容易找到這個隨機的干擾碼的，對於加密的過程，寫的還不錯，但加密的粒度太低，也就是只是對密匙位數進行加密，不過想逆它一般還是很難的，但好在粒度低，就算是用暴破的方法也是很快可以解密的。前提是密匙的不安全性。反算可以通過255次+8421505次就可計算出你的密碼。還是由於粒度低，密文碰撞性比較大。好像沒有很好的處理。str就是這時原密匙，而pwd則是密碼，待加密字元。而生成出來的就是明文可以在網上任何傳播的。

這個程序基本上實現了加密的幾個要素。思想不錯，便由於粒度低，再加上本身JS的不安全性，所以還是比較脆弱的。至於說演算法，在密碼學上加密的演算法本身就是公開的。一樓的，JS暴出來又如何？

這個加密方法也有它自身的好處，SHA1和MD5都是固定位數的加密，而這個是一個動態的長度不固定的加密，如果你願意，把你的密匙設為8位，則加密的內容是16+8位，當然，如果是設20位時加密的過程則出現48位的。而不是像MD5的16位和32位那麼固定。

不過提到了DES和TDES，你不妨借用它們的思想，將加密過的內容，再以同樣的方式，再樣的密匙再加密一次或二次，破解難度無疑提高了。

一般加密中很少使用^運算的。可以考慮使用|或者是&運算。因為^運算有一個特點就是：A^C=B時，則B^C=A,同時A^C=B,所以降低的破解難度！

sorry,由於上次看這個東西時間短，所以說錯了點，不過這個加密還是很不錯的。str是待加密的密文，而函數的返回值是加密過的明文，PWD才是密匙，由於對這個演算法很感興趣，便下從回家時看了看，原來這個是一個對稱加密的方式。寫的很好，如果密匙不是泄露的原因，還是要過255次+8421505次的試驗才可得到正確的結果，所以說，加密的粒度低。便由於是動態的，且由於程序短小適合對於大量的文本加密，那麼破解就變得不那麼容易了。首先一次我還是說，加密演算法與解密演算法是公開的，因為生成明文的過程不依賴於演算法。而是依賴於密匙的。只在密匙不泄露就可以了。像這類的演算法本身都是公開的也用不著去暴JS代碼的。所以根據其加密演算法，我已經寫出了解密的過程。也就是說你可以將一篇文本加密後發給我，然後只要告訴我密匙，我就能知道具體的內容了。在加密學中，密匙的才是解密的，所以， 如果演算法中可以有逆過程時是錯誤的加密方式，這樣的加密過於依賴演算法。而想逆一下要多長時間才是衡量一個加密的強度的。比如這個過程要100年（要計算機運算的時間）才能逆，那麼相對目前來說是相當安全的。而這個加密卻是能對大量文件進行加密的。所以速度上還是很好的，這里我們不能以非對稱加密方式去衡量它的安全性。

㈨ 求助前端JS都是用什麼加密的

1. 壓縮

這一操作的目的，是讓最終代碼傳輸量 （不代表代碼量, 也不代表文件體積）盡可能小。壓縮js的工具，常見的有：YUI Compressor、UglifyJS、Google Closure Compiler 等。

通常在代碼壓縮的過程中，只改變代碼的語法，代碼的語義和控制流不會有太大改變。

常見做法是把局部變數縮短化，把一些運算進行等價替換等。代碼壓縮對於代碼保護有一些幫助，但由於語義和控制流基本沒變，起不了太大作用。

在壓縮層面上，代碼不可讀只是一種附帶傷害，不是最終目的。

2. 混淆

這一操作的目的，是讓代碼盡可能地不可讀，主要用作代碼保護。

讓代碼不可讀，增加分析的難度，這是唯一目的。混淆過後文件體積變大一倍也沒關系，代碼量變多也沒關系，運算慢50% 也沒關系。

常見的做法有：分離常量、打亂控制流、增加無義代碼、檢查運行環境如果不對就罷工，等等。

在混淆層面上，代碼不可讀是最終目的。

值得一提的是，Google Closure Compiler 的 Advance Level Compression 會壓縮類和對象的成員，其壓縮結果很難分析，也可以認為是一種混淆，但兼容性不太好。

廣告時間：我寫的 js混淆器，中文名叫 「看起來很厲害的 JS 編譯器」， 英文名叫做 The Impressive JS.Segment.Compiler ， 看起來很厲害的 JS 編譯器 。

3. 加密

說實話我很難對加密做一個定義，因為加密在Web界有太多歧義了。

有加密就有解密，意味著加密操作可逆，密文可以明文化。

就這樣看來，在Web界，可以稱之為加密的東西包括：HTTPS傳輸、JavaScript實現對稱加密或者不對稱加密等等。

這樣看來，不可逆的代碼壓縮和混淆就不能列入加密這個范疇了。

非要找一個可以稱之為加密，又經常被人誤解為壓縮和混淆的東西，Dean Edwards 的 Dean Packer/Unpacker 可以拿來做個例子。

㈩ 高分求java的RSA 和IDEA 加密解密演算法

RSA演算法非常簡單，概述如下：
找兩素數p和q
取n=p*q
取t=(p-1)*(q-1)
取任何一個數e,要求滿足e<t並且e與t互素（就是最大公因數為1）
取d*e%t==1

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

設消息為數M (M <n)
設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<t並且e和t互素
用perl簡單窮舉可以獲得滿主 e*d%t ==1的數d：
C:\Temp>perl -e "foreach $i (1..9999){ print($i),last if $i*63%2668==1 }"
847
即d＝847

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

取消息M=244我們看看

加密：

c=M**d%n = 244**847%2773
用perl的大數計算來算一下：
C:\Temp>perl -Mbigint -e "print 244**847%2773"
465
即用d對M加密後獲得加密信息c＝465

解密：

我們可以用e來對加密後的c進行解密，還原M：
m=c**e%n=465**63%2773 ：
C:\Temp>perl -Mbigint -e "print 465**63%2773"
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 "%03X",$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 <tt>base</tt>^^<tt>pow</tt> within the molar
* domain of <tt>mod</tt>.
*
* @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 <tt>base</tt>^^<tt>pow</tt> within the molar
* domain of <tt>mod</tt>.
*/
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/