AES,RSA,ECC加密算法实现

 

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
                     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
             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
             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
             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
                 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
             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
             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
             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; i2; 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
             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
             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
             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
             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
             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
             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;
     }
     //轮密钥加