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]);
}
}
转载自:http://blog.csdn.net/feiying_soft/article/details/6454828