RSA演算法：

package key;
import java.math.BigInteger;
import java.util.Random;


public class RSA extends Cryption{
	 KEY ku;//公鑰
	 KEY kr;//私鑰
	
	 public RSA() {
		Random r = new Random();
		BigInteger p,q,n,nn;

		BigInteger e = BigInteger.ONE;// = new BigInteger(3+"");
		BigInteger d = BigInteger.ONE;
		//素數p,q,e,d
		while(true) {
			p = BigInteger.probablePrime(17, r);//new BigInteger(7+"");
			q = BigInteger.probablePrime(19, r);//new BigInteger(5+"");
			
			n = p.multiply(q);
			
			nn = p.subtract(BigInteger.ONE).multiply(q.subtract(BigInteger.ONE));
			if(nn.longValue() > 65535) {

				for(int i=3; i<nn.intValue(); i++) {
					if(MyMath.gcd(i, nn.intValue()) == 1) {
						e = BigInteger.valueOf(i);
						
						if(MyMath.exgcd(e, nn).longValue() == -1)
							continue;
						else
							break;
					}
				}
				d = MyMath.exgcd(e, nn).mod(nn);
				BigInteger big = d.multiply(d);big = big.multiply(big);
				if(big.compareTo(n) > 0) {
					break;
				}
				else
					continue;
			}
			
		}
		
		this.ku = new KEY(e,n);
		this.kr = new KEY(d,n);
	 }
	
	public RSA(KEY ku, KEY kr) {
		super();
		this.ku = ku;
		this.kr = kr;
	}
	class KEY {
		BigInteger x;
		BigInteger n;
		public KEY(BigInteger x, BigInteger n) {
			super();
			this.x = x;
			this.n = n;
		}
		
	}
	//加密
	public String Encryption(String s, KEY key) {
		StringBuffer sb = new StringBuffer();
		char[] cs = s.toCharArray();
		for(int i=0; i<cs.length; i++) {
			int k = cs[i];
			if(k < key.n.longValue())
			{
				BigInteger p = new BigInteger(k+"");
				int kk = Integer.parseInt(MyMath.reaminder(key.n, p,Long.parseLong(key.x.toString())).toString());
				char c =(char)kk;
				sb.append(c);
			}
			else {
				sb.append(cs[i]);
			}
		}
		return sb.toString();
	}
	//加密成16進位制字串
	public String Encryption(String s) {
		StringBuffer sb = new StringBuffer();
		char[] cs = s.toCharArray();
		for(int i=0; i<cs.length; i++) {
			int k = cs[i];
			if(k < this.ku.n.longValue())
			{
				BigInteger p = new BigInteger(k+"");
				long kk = Long.parseLong(MyMath.reaminder(this.ku.n, p,Long.parseLong(this.ku.x.toString())).toString());
				sb.append(Long.toHexString(kk));
				sb.append(" ");
			}
			else {
				sb.append(Integer.toHexString(k));
				sb.append(" ");
			}
		}
		return sb.toString();
	}
	//解密
	public String Decryption(String s, KEY key) {
		return Encryption(s,key);
	}
	public String Decryption(String s) {
		StringBuffer sb = new StringBuffer();
		String[] ss = s.split(" ");
		for(int i=0; i<ss.length; i++) {
			long k = Long.parseLong(ss[i], 16);
			BigInteger p = new BigInteger(k+"");
			int kk = Integer.parseInt(MyMath.reaminder(this.kr.n, p,Long.parseLong(this.kr.x.toString())).toString());
			sb.append(Tools.obox(Integer.toHexString(kk), 4));
		}
		return Tools.hexStr2Str(sb.toString());
	}
	
	public static void main(String[] args) {
		RSA rsa = new RSA();
		String s = "大家好abi 是低估 斯蒂芬和歐冠發 蛋糕房女生佛 ,；";
		String sa = rsa.Encryption(s);
		System.out.println("密文:    " + sa);
		System.out.println("明文:    " + rsa.Decryption(sa));
		System.out.println("e:"+rsa.kr.x + "  d:" + rsa.ku.x +"   n:" + rsa.kr.n);
	}
}
 

ECC演算法：

package key;
import java.math.BigInteger;
import java.util.Random;

public class ECC extends Cryption{
	static E e;//橢圓曲線
	Pare pare;//橢圓上的已知點
	long privatekey;//7位速度變慢            私鑰--隨機
	Pare publickey;//公鑰
	
	public ECC() {
		super();
		Random rand = new Random();
		this.e = new E(BigInteger.probablePrime(30, rand).intValue(),rand.nextInt(1024),rand.nextInt(1024));
		this.privatekey = rand.nextInt(1024);//7位速度變慢            私鑰--隨機
		this.pare = new Pare(rand.nextInt(10000000),rand.nextInt(10000000));
		this.publickey = this.pare.multiply(privatekey);//new Pare();
	}
	class E {// 表示橢圓曲線方程
		Long p;//模p的橢圓群
		Long a;
		Long b;
		public E(long p, long a, long b) {
			super();
			this.p = p;
			this.a = a;
			this.b = b;
		}
		
	}
	class Message {//傳送訊息的最小單元
		Pare pa;
		Pare pb;
		public Message(Pare pa, Pare pb) {
			super();
			this.pa = pa;
			this.pb = pb;
		}
		public String toString() {
			return this.pa.toString() +" "+ this.pb.toString();
		}
	}
	class Pare {//橢圓曲線上的點(x,y)
		long x;
		long y;
		public Pare() {
			super();
		}
		public Pare(long x, long y) {
			super();

			this.x = x;
			this.y = y;
		}
		//加法
		public Pare add(Pare pare) {
			if(this.x == Integer.MAX_VALUE) {//為無窮大時O+P=P
				return pare;
			}
			Pare res = new Pare();
			if(this.y==pare.y && this.x==pare.x) {//相等時
				long d = moddivision(3*this.x*this.x + ECC.e.a,ECC.e.p,2*this.y);
				
				res.x = d*d - 2*this.x;
				res.x = mod(res.x, ECC.e.p);
				
				res.y = d*(this.x - res.x) - this.y;
				res.y = mod(res.y, ECC.e.p);
			}
			else if(pare.x - this.x != 0) {
				long d = moddivision(pare.y - this.y,ECC.e.p,pare.x - this.x);
				res.x = d*d - this.x - pare.x;
				res.x = mod(res.x, ECC.e.p);
				
				res.y = d*(this.x - res.x) - this.y;
				res.y = mod(res.y, ECC.e.p);
			}
			else {//P Q互逆,返回無窮大
				res.x = Integer.MAX_VALUE;
				res.y = Integer.MAX_VALUE;
			}
			
			return res;
		}
		//減法
		public Pare less(Pare p) {
			p.y *= -1;
			return add(p);
		}
		//乘法
		public Pare multiply(long num) {
			Pare p = new Pare(this.x,this.y);
			for(long i=1; i<num; i++) {
				p = p.add(this);
			}
			return p;
		}
		//求餘,解決負號問題
		public long mod(long a, long b) {
			a = a%b;
			while(a<0) {
				a += b;
			}
			return a;
		}
		//求餘取商(a mod b)/c
		/*public long moddivision(long a, long b, long c) {
			a = mod(a,b);
			while(a%c != 0) {
				a += b;
			}
			a = a/c;
			return a;
		}*/
		public long moddivision(long a, long b, long c) {
			a = mod(a,b);
			c = mod(c,b);
			a = a*MyMath.exgcd(c,b);
			return mod(a,b);
		}
		public String toString() {
			return Tools.obox(Tools.long2hexStr(this.x), 4) + " " + Tools.obox(Tools.long2hexStr(this.y), 4);
		}
	}
	
	//加密
	public Message encryption(Pare g,Pare pbk,Pare word) {
		pbk = g.multiply(privatekey);//公鑰
		int d = new Random().nextInt(1024);//隨機數
		Pare dg = g.multiply(d);
		Pare dp = pbk.multiply(d);
		Pare send = word.add(dp);
		return new Message(dg,send);
	}
	public String encryption(Pare g, Pare pbk, String word) {
		StringBuffer sb = new StringBuffer();
		Pare[] words = Str2Pares(word);
		for(int i=0; i<words.length; i++) {
			sb.append(encryption(g,pbk,words[i]).toString());
			sb.append(" ");
		}
		return sb.toString();
	}
	public String encryption(String word) {
		StringBuffer sb = new StringBuffer();
		Pare[] words = Str2Pares(word);
		for(int i=0; i<words.length; i++) {
			sb.append(encryption(this.pare,this.publickey,words[i]).toString());
			sb.append(" ");
		}
		return sb.toString();
	}
	
	//解密
	public Pare decryption(Message m) {
		Pare pab = m.pa.multiply(this.privatekey);
		Pare result = m.pb.less(pab);
		return result;
	}
	public String decryption(String s) {
		StringBuffer sb = new StringBuffer();
		Message[] mes = hexStr2Messages(s);
		for(int i=0; i<mes.length; i++) {
			sb.append(decryption(mes[i]).toString());
		}
		return Tools.hexStr2Str(sb.toString().replace(" ", ""));
	}
	
	public static void print(Object o) {
		System.out.println(o);
	}
	//將字串轉換為   值對
	public Pare[] Str2Pares(String string) {
		
		Pare[] pares ;
		if(string.length()%2 != 0) 
			pares = new Pare[string.length()/2+1];
		else
			pares = new Pare[string.length()/2];
		char[] chars = string.toCharArray();
		int i=0;
		for(i=0; i<string.length()/2; i++) {
			pares[i] = new Pare(chars[i*2],chars[i*2+1]);
		}
		if(string.length()%2 != 0) 
			pares[i] = new Pare(chars[i*2],0);
		return pares;
	}
	//將值對轉換成16進位制字串
	public String Pares2hexStr(Pare[] pares) {		
		StringBuffer s = new StringBuffer();
		for(int i=0; i<pares.length; i++) {
			s.append(pares[i].toString());
		}
		return s.toString();
	}
	//將16進位制字串轉為     訊息串
	public Message[] hexStr2Messages(String s) {
		String[] ss = s.split(" ");
		Message[] mes = new Message[ss.length/4];
		for(int i=0; i<mes.length; i++) {
			long pax = Tools.hexStr2long(ss[i*4]);
			long pay = Tools.hexStr2long(ss[i*4+1]);
			long pbx = Tools.hexStr2long(ss[i*4+2]);
			long pby = Tools.hexStr2long(ss[i*4+3]);
			mes[i] = new Message(new Pare(pax,pay),new Pare(pbx,pby));
		}
		return mes;
	}
	//將訊息串轉為16進位制字串
	public String Messages2hexStr(Message[] mes) {
		StringBuffer sb = new StringBuffer();
		for(int i=0; i<mes.length; i++) {
			sb.append(mes[i].toString());
			sb.append(" ");
		}
		return sb.toString();
	}
	public static void main(String[] args) {
		ECC ecc = new ECC();
		print("私鑰:" + ecc.privatekey);
		print("公鑰:" + ecc.publickey);
		print("基點:" + ecc.pare);
		print("");
		String s = "大家好啊abc123aaaaa sadfasdfe asf";
		
		String jm = ecc.encryption(s);
		//System.out.print("密文:  " +jm);
		print("密文:   " + jm);
		String mw = ecc.decryption(jm);
		System.out.print("明文:  ");
		print("明文:   " +mw);
		
	}
}
 

AES演算法：

package key;
import java.util.Random;

public class AES extends Cryption{
	String key;//金鑰
	int round;//加密輪數
	
	public AES() {
		super();
		this.key = key();
		this.round = new Random().nextInt(100);
	}
	
	public AES(String key, int round) {
		super();
		this.key = key;
		this.round = round;
	}

	//S盒
	static final String[][] Sbox = {
		{"63","7c","77","7b","f2","6b","6f","c5","30","01","67","2b","fe","d7","ab","76"},
		{"ca","82","c9","7d","fa","59","47","f0","ad","d4","a2","af","9c","a4","72","c0"},
		{"b7","fd","93","26","36","3f","f7","cc","34","a5","e5","f1","71","d8","31","15"},
		{"04","c7","23","c3","18","96","05","9a","07","12","80","e2","eb","27","b2","75"},
		{"09","83","2c","1a","1b","6e","5a","a0","52","3b","d6","b3","29","e3","2f","84"},
		{"53","d1","00","ed","20","fc","b1","5b","6a","cb","be","39","4a","4c","58","cf"},
		{"d0","ef","aa","fb","43","4d","33","85","45","f9","02","7f","50","3c","9f","a8"},
		{"51","a3","40","8f","92","9d","38","f5","bc","b6","da","21","10","ff","f3","d2"},
		{"cd","0c","13","ec","5f","97","44","17","c4","a7","7e","3d","64","5d","19","73"},
		{"60","81","4f","dc","22","2a","90","88","46","ee","b8","14","de","5e","0b","db"},
		{"e0","32","3a","0a","49","06","24","5c","c2","d3","ac","62","91","95","e4","79"},
		{"e7","c8","37","6d","8d","d5","4e","a9","6c","56","f4","ea","65","7a","ae","08"},
		{"ba","78","25","2e","1c","a6","b4","c6","e8","dd","74","1f","4b","bd","8b","8a"},
		{"70","3e","b5","66","48","03","f6","0e","61","35","57","b9","86","c1","1d","9e"},
		{"e1","f8","98","11","69","d9","8e","94","9b","1e","87","e9","ce","55","28","df"},
		{"8c","a1","89","0d","bf","e6","42","68","41","99","2d","0f","b0","54","bb","16"}
	};
	//逆S盒
	static final String[][] InvSbox = {
		{"52","09","6a","d5","30","36","a5","38","bf","40","a3","9e","81","f3","d7","fb"},
		{"7c","e3","39","82","9b","2f","ff","87","34","8e","43","44","c4","de","e9","cb"},
		{"54","7b","94","32","a6","c2","23","3d","ee","4c","95","0b","42","fa","c3","4e"},
		{"08","2e","a1","66","28","d9","24","b2","76","5b","a2","49","6d","8b","d1","25"},
		{"72","f8","f6","64","86","68","98","16","d4","a4","5c","cc","5d","65","b6","92"},
		{"6c","70","48","50","fd","ed","b9","da","5e","15","46","57","a7","8d","9d","84"},
		{"90","d8","ab","00","8c","bc","d3","0a","f7","e4","58","05","b8","b3","45","06"},
		{"d0","2c","1e","8f","ca","3f","0f","02","c1","af","bd","03","01","13","8a","6b"},
		{"3a","91","11","41","4f","67","dc","ea","97","f2","cf","ce","f0","b4","e6","73"},
		{"96","ac","74","22","e7","ad","35","85","e2","f9","37","e8","1c","75","df","6e"},
		{"47","f1","1a","71","1d","29","c5","89","6f","b7","62","0e","aa","18","be","1b"},
		{"fc","56","3e","4b","c6","d2","79","20","9a","db","c0","fe","78","cd","5a","f4"},
		{"1f","dd","a8","33","88","07","c7","31","b1","12","10","59","27","80","ec","5f"},
		{"60","51","7f","a9","19","b5","4a","0d","2d","e5","7a","9f","93","c9","9c","ef"},
		{"a0","e0","3b","4d","ae","2a","f5","b0","c8","eb","bb","3c","83","53","99","61"},
		{"17","2b","04","7e","ba","77","d6","26","e1","69","14","63","55","21","0c","7d"}
		
	};
	//位元組代替
	public char[] subBytes(char[] state) {
		char[] result = new char[state.length];
		for(int i=0; i<state.length; i++) {
			String s = Integer.toHexString(state[i]);
			if(s.length() < 2) {
				s = "0" + s;
			}
			String rs = Sbox[s.charAt(0) < 97 ?s.charAt(0)-48 : s.charAt(0)-87][s.charAt(1) < 97 ?s.charAt(1)-48 : s.charAt(1)-87];
			result[i] = (char) Integer.parseInt(rs, 16);
		}
		return result;
	}
	//逆位元組代替
	public char[] invSubBytes(char[] state) {
		char[] result = new char[16];
		for(int i=0; i<state.length; i++) {
			String s = Integer.toHexString(state[i]);
			if(s.length() < 2) {
				s = "0" + s;
			}
			String rs = InvSbox[s.charAt(0) < 97 ?s.charAt(0)-48 : s.charAt(0)-87][s.charAt(1) < 97 ?s.charAt(1)-48 : s.charAt(1)-87];
			result[i] = (char) Integer.parseInt(rs, 16);
		}
		return result;
	}
	//列混淆
	public char[] mixColumns(char[] state) {
		char[] lisa = {2,3,1,1};
		char[] result = new char[16];
		for(int col=0; col<4; col++) {
			char[] lisb = new char[4];
			int flagc = col;
			for(int m=0; m<4; m++){
				lisb[m] = state[flagc];
				flagc += 4;
			}
			for(int row=0; row<4; row++) {
				int k = ffmul(lisb[0],lisa[(4-row)%4])^ffmul(lisb[1],lisa[(5-row)%4])^ffmul(lisb[2],lisa[(6-row)%4])^ffmul(lisb[3],lisa[(7-row)%4]);
				result[row*4+col] = (char)k;
			}
		}
		return result;
	}
	//逆列混淆
	public char[] invMixColumns(char[] state) {
		char[] lisa = {14,11,13,9};
		char[] result = new char[16];
		for(int col=0; col<4; col++) {
			char[] lisb = new char[4];
			int flagc = col;
			for(int m=0; m<4; m++){
				lisb[m] = state[flagc];
				flagc += 4;
			}
			for(int row=0; row<4; row++) {
				int k = ffmul(lisb[0],lisa[(4-row)%4])^ffmul(lisb[1],lisa[(5-row)%4])^ffmul(lisb[2],lisa[(6-row)%4])^ffmul(lisb[3],lisa[(7-row)%4]);
				result[row*4+col] = (char)k;
			}
		}
		return result;
	}
	//位元組乘法
	public int ffmul(int a, int b) {
		String ba = Integer.toBinaryString(a);
		int[] stor = new int[8];
		while(ba.length()<8) {
			ba = "0" + ba;
		}
		stor[0] = b;
		for(int i=1; i<8; i++) {
			String bb = Integer.toBinaryString(stor[i-1]);
			if(bb.length() < 8) {
				stor[i] = leftshift(stor[i-1],1);
			}
			else
				stor[i] = leftshift(stor[i-1],1) ^ 27;
		}
		int result = 0;
		for(int i=7; i>=0; i--) {
			if(ba.charAt(i) == '1') {
				if(result == 0) {
					result = stor[7-i];
				}
				else
					result = result ^stor[7-i]; 
			}
		}
		return result;
	}
	//二進位制數左移
	public int leftshift(int num, int step) {
		String ba = Integer.toBinaryString(num);
		while(ba.length()<8) {
			ba = "0" + ba;
		}
		for(int i=0; i<step; i++) {
			ba += "0";
		}
		return Integer.parseInt(ba.substring(step), 2);
	}
	//行移位
	public char[] shiftRows(char[] state) {
		char[][] in = new char[4][4];
		for(int i=0; i<4; i++) {
			for(int j=0; j<4; j++) {
				in[i][j] = state[i*4+j];
			}
		}
		char[] result = new char[16];
		for(int i=0; i<4; i++) {
			for(int j=0; j<4; j++) {
				result[i*4+j] = in[i][(j+i)%4];
			}
		}
		return result;
	}
	//逆行移位
	public char[] invShiftRows(char[] state) {
		char[][] in = new char[4][4];
		for(int i=0; i<4; i++) {
			for(int j=0; j<4; j++) {
				in[i][j] = state[i*4+j];
			}
		}
		char[] result = new char[16];
		for(int i=0; i<4; i++) {
			for(int j=0; j<4; j++) {
				int col = (j-i)>0?(j-i):(j-i)+4;
				result[i*4+j] = in[i][col%4];
			}
		}
		return result;
	}
	//輪金鑰加
	public char[] addRoundKey(char[] state, char[] key) {
		char[] result = new char[16];
		for(int col=0; col<4; col++) {
			for(int row=0; row<4; row++) {
				result[row*4+col] =(char) (state[row*4+col] ^ key[row*4+col]);
			}
		}
		return result;
	}

	//金鑰擴充套件
	public char[][] keyExpansion(char[] key,int round) {
		char[] RC = new char[round];
		for(int i=0; i<round; i++) {
			if(i==0) {
				RC[i] = 1;
			}
			else {
				RC[i] =(char) ffmul(2, RC[i-1]);
			}
		}
		
		char[][] newkey = new char[round][16];
		char[] start = {key[12],key[13],key[14],key[15]};
		for(int r=0; r<round; r++) {
			for(int i=3; i<7; i++) {
				if(i==3) {
					char ot = start[0];
					start[0] = start[1];start[1] = start[2];
					start[2] = start[3];start[3] = ot;//RotWord()
					start = subBytes(start);
					start = XOR(start,new char[]{RC[r],0,0,0});
				}
				char[] last = {key[(i-3)*4],key[(i-3)*4+1],key[(i-3)*4+2],key[(i-3)*4+3]};
				start = XOR(start,last);
				for(int k=0; k<4; k++) {
					key[(i-3)*4 + k] = start[k];
				}
				for(int j=0; j<4; j++) {
					newkey[r][(i+1)%4 + j*4] = start[j];
				}
			}
		}
		return newkey;
	}
	//異或
	public char[] XOR(char[] a, char[] b) {
		char[] result = new char[a.length];
 		for(int i=0; i<a.length; i++) {
			result[i] = (char)(((int)a[i])^((int) b[i]));
		}
		return result;
	}
	//位元組加密
	public char[] cipher(char[] in,char[] key,int round) {
		char[] out = new char[16];
		char[] newword = new char[16];
		for(int i=0; i<16; i++) {
			newword[i] = key[i];
		}
		char[][] keys = keyExpansion(newword, round); 
		in = exchange(in);key = exchange(key);
		in = addRoundKey(in, key);
		
		for(int i=0; i<round-1; i++) {
			out = subBytes(in);
			out = shiftRows(out);
			out = mixColumns(out);
			in = addRoundKey(out, keys[i]);
		}
		out = subBytes(in);
		out = shiftRows(out);
		out = addRoundKey(out, keys[round-1]);
		return exchange(out);
	}
	//字串加密
	public String cipher(String in,String key,int round) {
		StringBuffer sb = new StringBuffer();
		char[] keys = Tools.hexStr2Cs(key);
		String hexStr = Tools.Str2hexStr(in);
		while(hexStr.length()>=32) {
			String sin = hexStr.substring(0, 32);
			hexStr = hexStr.substring(32);
			sb.append(Tools.Cs2hexStr(cipher(Tools.hexStr2Cs(sin),keys,round)));
		}
		if(hexStr.length()>0) {
			while(hexStr.length()<32) {
				hexStr += "0";
			}
			sb.append(Tools.Cs2hexStr(cipher(Tools.hexStr2Cs(hexStr),keys,round)));
		}
		return sb.toString();
	}
	public String cipher(String in) {
		return cipher(in,this.key,this.round);
	}
	//位元組解密
	public char[] inCipher(char[] in, char[] key, int round) {
		char[] out = new char[16];
		char[] newword = new char[16];
		for(int i=0; i<16; i++) {
			newword[i] = key[i];
		}
		char[][] keys = keyExpansion(newword, round); 
		in = exchange(in);key = exchange(key);
		in = addRoundKey(in, keys[round-1] );
		
		for(int i=0; i<round-1; i++) {
			out = invShiftRows(in);
			out = invSubBytes(out);
			out = addRoundKey(out, keys[round-2-i]);
			in = invMixColumns(out);
			
		}
		out = invShiftRows(in);
		out = invSubBytes(out);
		out = addRoundKey(out,key);
		return exchange(out);
	}
	//字串解密
	public String inCipher(String in, String key, int round) {
		StringBuffer sb = new StringBuffer();
		char[] keys = Tools.hexStr2Cs(key);
		String hexStr = in;//Str2hexStr(in);
		while(hexStr.length()>=32) {
			String sin = hexStr.substring(0, 32);
			hexStr = hexStr.substring(32);
			sb.append(Tools.hexStr2Str(Tools.Cs2hexStr(inCipher(Tools.hexStr2Cs(sin),keys,round))));
		}
		if(hexStr.length()>0) {
			while(hexStr.length()<32) {
				hexStr += "0";
			}
			sb.append(Tools.hexStr2Str(Tools.Cs2hexStr(inCipher(Tools.hexStr2Cs(hexStr),keys,round))));
		}
		while(sb.charAt(sb.length()-1) == 0) {
			sb = sb.deleteCharAt(sb.length()-1);
		}
		return sb.toString();
	}
	public String inCipher(String in) {
		return inCipher(in,this.key,this.round);
	}
	//行列變換
	public char[] exchange(char[] chars) {
		char[] nchars = new char[chars.length];
		for(int i=0; i<4; i++) {
			for(int j=0; j<4; j++) {
				nchars[i*4 + j] = chars[j*4+i];
			}
		}
		return nchars;
	}
	public static void print(String s,char[] chars) {
		System.out.println(s+" ");
		String[] sts = Tools.Cs2Ss(chars);
		for(int i=0; i<sts.length; i++) {
			System.out.print(sts[i]+" ");
			if(i%4 == 3) {
				System.out.println();
			}
		}
		System.out.println();
	}
	//金鑰生成器
	public String key() {
		StringBuffer sb = new StringBuffer();
		Random r = new Random();
		for(int i=0; i<8; i++) {
			sb.append((char)r.nextInt(65535));
		}
		return Tools.Str2hexStr(sb.toString());
	}
	public static void main(String[] args) {
		AES aes = new AES();
		String cstring = "大家,， 愛上對方";
		//String cword = "2b7e151628aed2a6abf7158809cf4f3c";
		String cword= aes.key();
		String mw = aes.cipher(cstring);
		System.out.println("密文:    "+mw);
		String result1 = aes.inCipher(mw);
		System.out.println(result1);
		System.out.println("金鑰:    "+cword);
	}
}
 

工具類： MyMath

package key;
import java.math.BigInteger;


public class MyMath {
	//此方法求餘數。prime:素數，primitive：本原元，random：隨機數。
	public static long reaminder(long prime, long primitive, long random) {
		long reamin = primitive%prime;
		long currentreamin = reamin;
		String binary = Long.toBinaryString(random);
		System.out.println(binary);
		for(int i=0; i<binary.length()-1; i++) {
			if(binary.charAt(i+1) == '0') {
				currentreamin = (currentreamin * currentreamin) % prime;
			}
			else {
				currentreamin = (currentreamin * currentreamin * reamin) % prime;
			}
			
		}
		//
		/*if(random == 1) {
			return reamin;
		}
		
		for(long i=2; i<=random; i++) {
			currentreamin = currentreamin * reamin % prime;
		}*/
		return currentreamin;
	}
	public static BigInteger reaminder(BigInteger prime, BigInteger primitive, long random) {
		BigInteger reamin = primitive.mod(prime);//primitive%prime;
		BigInteger currentreamin = reamin;
		String binary = Long.toBinaryString(random);
		for(int i=0; i<binary.length()-1; i++) {
			if(binary.charAt(i+1) == '0') {
				currentreamin = currentreamin.multiply(currentreamin).mod(prime);//(currentreamin * currentreamin) % prime;
			}
			else {
				currentreamin = currentreamin.multiply(currentreamin).multiply(reamin).mod(prime);//(currentreamin * currentreamin * reamin) % prime;
			}
			
		}
		return currentreamin;
	}
	public static BigInteger reaminder(String prim, String primitiv, String rand) {
		BigInteger prime = new BigInteger(prim);
		BigInteger primitive = new BigInteger(primitiv);
		Long random = new Long(rand);
		BigInteger reamin = primitive.mod(prime);//primitive%prime;
		BigInteger currentreamin = reamin;
		String binary = Long.toBinaryString(random);
		for(int i=0; i<binary.length()-1; i++) {
			if(binary.charAt(i+1) == '0') {
				currentreamin = currentreamin.multiply(currentreamin).mod(prime);//(currentreamin * currentreamin) % prime;
			}
			else {
				currentreamin = currentreamin.multiply(currentreamin).multiply(reamin).mod(prime);//(currentreamin * currentreamin * reamin) % prime;
			}
			
		}
		return currentreamin;
	}
	
	//此方法判斷素數
	public static boolean isPrime(long num) {
		boolean flag = true;
		for(long i=2; i<num/2; i++) {
			if(num == 2) break;
			if(num%i == 0) {
				flag = false;
				break;
			}
		}
		return flag;
	}
	
	//求最大公約數:歐幾里得演算法，輾轉相除法
	public static long gcd(long a, long b) {
		 long reamin = a % b;
		 if(reamin==0) {
			 return b;
		 }
		 else {
			 return gcd(b,reamin);
		 }
	}
	
	//擴充套件的歐幾里得演算法求逆元，如果有返回值，沒有返回-1
	public static long exgcd(long a, long b) {
		long x1=1,x2=0,x3=b,
			 y1=0,y2=1,y3=a;
		while(true) {
			if(y3 == 0) {
				return -1;
			}
			if(y3 == 1) {
				return y2>0?y2:y2+b;
			}
			long t1,t2,t3;
			long q = x3/y3;
			t1 = x1-q*y1; t2 = x2 - q*y2; t3 = x3 - q*y3;
			x1 = y1; x2 = y2; x3 = y3;
			y1 = t1; y2 = t2; y3 = t3;
		}
	}
	public static BigInteger exgcd(BigInteger a, BigInteger b) {
		BigInteger x1=BigInteger.ONE,x2=BigInteger.ZERO,x3=b,
			 y1=BigInteger.ZERO,y2=BigInteger.ONE,y3=a;
		while(true) {
			if(y3.equals(BigInteger.ZERO)) {
				return BigInteger.ZERO.subtract(BigInteger.ONE);
			}
			if(y3.equals(BigInteger.ONE)) {
				return y2;
			}
			BigInteger t1,t2,t3;
			BigInteger q = x3.divide(y3);//x3/y3;
			t1 = x1.subtract(q.multiply(y1));//x1-q*y1; 
			t2 = x2.subtract(q.multiply(y2));//x2 - q*y2; 
			t3 = x3.subtract(q.multiply(y3));//x3 - q*y3;
			x1 = y1; x2 = y2; x3 = y3;
			y1 = t1; y2 = t2; y3 = t3;
		}
	}
	public static void main(String[] args) {
		//System.out.println(exgcd(new BigInteger(5+""),new BigInteger(96+"")));
		//System.out.println((int)'，');
		//System.out.println((char)(34382));
		//System.out.println(-19 % 96);
		//System.out.println(Character.getNumericValue('虎'));
		//System.out.println(reaminder("561","7","560"));
		//System.out.println(reaminder(561,7,560));
		//System.out.println(new BigInteger(7+"").modPow(new BigInteger("560"), new BigInteger("561")));
		//System.out.println(exgcd(-2,3));
		String a = "你好  好啊";
		//System.out.println((int)' ');
		char[] chars = a.toCharArray();
		for(int i=0; i<chars.length; i++) {
			String s = Integer.toHexString(chars[i]);
			s = Tools.obox(s, 4);
			System.out.println(s);
		}
	}
}

工具類：Tools

package key;

public class Tools {
	//字串左邊補0直到長度為i
	public static String obox(String s, int i) {
		String ss = s;  
		while(ss.length()<i) {
			ss = "0"+ss;
		}
		return ss;
	}
	//字串右邊補0直到長度為i
	public static String boxo(String s, int i) {
		String ss = s;  
		while(ss.length()<i) {
			ss += "0";
		}
		return ss;
	}
	//將字串變成16進位制字串
	public static String Str2hexStr(String s) {
		StringBuffer sb = new StringBuffer();
		for(int i=0; i<s.length(); i++) {
			sb.append(obox(Integer.toHexString(s.charAt(i)),4));
		}
		return sb.toString();
	}
	//將16進位制字串變成字串
	public static String hexStr2Str(String s) {
		StringBuffer sb = new StringBuffer();
		int index = 0;
		int length = s.length();
		while(index+4 <= length) {
			String sh = s.substring(index, index+4);
			sb.append((char) Integer.parseInt(sh, 16));
			index += 4;
		}
		if(sb.charAt(sb.length()-1) == 0) {
			sb.deleteCharAt(sb.length()-1);
		}
		return sb.toString();
	}
	//String陣列轉換為char陣列
	public static char[] Ss2Cs(String[] s) {
		char[] result = new char[s.length];
		for(int i=0; i<s.length; i++) {
			result[i] =(char) Integer.parseInt(s[i], 16);
		}
		return result;
	}
	//String轉換為char陣列
	public static char[] Str2Cs(String s) {
		char[] result = new char[s.length()/2];
		for(int i=0; i<s.length()/2; i++) {
			StringBuffer sb = new StringBuffer();//(char)s.charAt(i)+s.charAt(i+1);
			sb.append(s.charAt(i*2));sb.append(s.charAt(i*2+1));
			result[i] =(char) Integer.parseInt(sb.toString(), 16);
		}
		return result;
	}
	//hexString轉換為陣列
	public static char[] hexStr2Cs(String s) {
		//System.out.println("hexStr:" + s);
		char[] result = new char[s.length()/2];
		for(int i=0; i<s.length()/2; i++) {
			StringBuffer sb = new StringBuffer();//(char)s.charAt(i)+s.charAt(i+1);
			sb.append(s.charAt(i*2));
			sb.append(s.charAt(i*2+1));
			result[i] =(char) Integer.parseInt(sb.toString(), 16);
		}
		return result;
	}
	//char陣列轉換為String陣列
	public static String[] Cs2Ss(char[] s) {
		String[] result = new String[s.length];
		for(int i=0; i<s.length; i++) {
			result[i] = Integer.toHexString(s[i]);
		}
		return result;
	}
	//char陣列轉換為hexString
	public static String Cs2hexStr(char[] s) {
		StringBuffer sb = new StringBuffer();
		//String[] result = new String[s.length];
		for(int i=0; i<s.length; i++) {
			sb.append(obox(Integer.toHexString(s[i]),2));
		}
		return sb.toString();
	}
	//long轉換為hexString
	public static String long2hexStr(long lo) {
		//String s = Long.toHexString(lo);
		//s = 
		return Long.toHexString(lo);
	}
	//longs陣列轉換為hexString
	public static String longs2hexStr(long[] lo) {
		StringBuffer sb = new StringBuffer();
		for(int i=0; i<lo.length; i++) {
			sb.append(Long.toHexString(lo[0]));
			sb.append(" ");
		}
		return sb.toString();
	}
	//hexString轉換為long
	public static long hexStr2long(String s) {
		return Long.parseLong(s, 16);
	}
	//hexString轉換為long陣列
	public static long[] hexStr2longs(String s) {
		String[] ss = s.split(" ");
		long[] ls = new long[ss.length];
		for(int i=0; i<ls.length; i++) {
			ls[i] = Long.parseLong(ss[i], 16);
		}
		return ls;
	}
		
	public static void main(String[] args) {
		String hexs1 = long2hexStr(Long.MAX_VALUE);
		String hexs2 = long2hexStr(456);
		String s = hexs1+" " +hexs2;
		System.out.println(s);
		long[] l = hexStr2longs(s);
		for(int i=0; i<l.length; i++)
			System.out.println(l[i]);
	}
}