RSA加密,解密 与数字签名

package com.e

                             RSA加密算法的简单使用原理

xample.subang.advancesix;

import android.content.SharedPreferences;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Base64;
import android.util.Log;
import android.view.View;
import android.widget.TextView;

import java.security.InvalidKeyException;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.SignatureException;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.KeySpec;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;

public class MainActivity extends AppCompatActivity {
    private TextView text;
    private String data = "怒发冲冠,凭栏处,潇潇雨歇";
    private PrivateKey aPrivate;
    private PublicKey aPublic;
    private SharedPreferences sp;
    private PrivateKey privateKey1;
    private PublicKey publicKey1;
    private String s;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        text = (TextView) findViewById(R.id.text);
        sp = getSharedPreferences("config", MODE_PRIVATE);


        //从sp中获取私钥
        String privateKey = sp.getString("privateKey", null);
        byte[] decode = Base64.decode(privateKey, Base64.DEFAULT);
        KeyFactory keyFactory = null;
        try {
            keyFactory = KeyFactory.getInstance("RSA");
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        KeySpec keySpec = new PKCS8EncodedKeySpec(decode);
        try {
            privateKey1 = keyFactory.generatePrivate(keySpec);
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        }


        //从sp中获取公钥
        String publicKey = sp.getString("publicKey", null);
        byte[] decode1 = Base64.decode(publicKey, Base64.DEFAULT);
        KeyFactory keyFactory2 = null;
        try {
            keyFactory2 = KeyFactory.getInstance("RSA");
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        KeySpec keySpec2 = new X509EncodedKeySpec(decode1);
        try {
            publicKey1 = keyFactory2.generatePublic(keySpec2);
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        }

    }

    public void start(View view) throws BadPaddingException, InvalidKeyException, IllegalBlockSizeException, NoSuchAlgorithmException, InvalidKeySpecException, SignatureException {
        switch (view.getId()) {
            case R.id.btn1:
                generateRsa();
                break;

            case R.id.btn2:
                String cyrpt = cyrpt(data, privateKey1, 0);
                text.setText(cyrpt);
                break;

            case R.id.btn3:
                String trim = text.getText().toString().trim();
                String cyrpt1 = cyrpt(trim, publicKey1, 1);
                text.setText(cyrpt1);
                break;

            case  R.id.md5Rsa://数字签名,使用私钥进行
                Signature signature=Signature.getInstance("MD5withRSA");
                signature.initSign(privateKey1);
                signature.update(this.data.getBytes());
                byte[] sign = signature.sign();//签名的数据
                //将原文件和签名之后的数据一块发送给合作伙伴
                s = Base64.encodeToString(sign, Base64.DEFAULT);
                text.setText(s);
                break;

            case  R.id.md5vertify://数字验证,使用公钥
                Signature signature1=Signature.getInstance("MD5withRSA");
                signature1.initVerify(publicKey1);
                //update 将原文件上传给signature
                signature1.update(this.data.getBytes());
                //对签名进行验证 s
                boolean verify = signature1.verify(Base64.decode(s, Base64.DEFAULT));
                Log.e("flag", "--------------------->start: 验证的结果"+verify);

                break;
            default:
                break;
        }
    }

    private String cyrpt(String data, Key key, int type) throws InvalidKeyException, BadPaddingException, IllegalBlockSizeException {

        try {
            //1.加密引擎
            Cipher cipher = Cipher.getInstance("RSA");
            //2.设置密码
            switch (type) {
                case 0://加密
                    cipher.init(Cipher.ENCRYPT_MODE, key);
                    break;
                case 1://解密
                    cipher.init(Cipher.DECRYPT_MODE, key);
                    break;
                
                default:
                    break;
            }

            //3.区分加密 解密
            switch (type) {
                case 0://加密
                    byte[] bytes = cipher.doFinal(data.getBytes());
                    byte[] encode = Base64.encode(bytes, Base64.DEFAULT);
                    String result = new String(encode);
                    return result;


                case 1://解密
                    byte[] decode = Base64.decode(data, Base64.DEFAULT);
                    byte[] bytes1 = cipher.doFinal(decode);
                    String result1 = new String(bytes1);
                    return result1;


                default:
                    break;
            }
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        }

        return data;
    }


    private void generateRsa() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                //1.获取KeyPareGenerator
                try {
                    KeyPairGenerator keypairGenerator = KeyPairGenerator.getInstance("RSA");

                    //2.初始化
                    keypairGenerator.initialize(1024);
                    //3.获取密码
                    KeyPair keyPair = keypairGenerator.generateKeyPair();
                    //4.获取公钥 ,私钥
                    aPrivate = keyPair.getPrivate();
                    aPublic = keyPair.getPublic();
                    //5.展示数据
                    final byte[] aByte = aPrivate.getEncoded();
                    final byte[] pByte = aPublic.getEncoded();

                    //将公钥 , 私钥 进行保存 保存到sp中
                    SharedPreferences sp = MainActivity.this.getSharedPreferences("config", MODE_PRIVATE);
                    SharedPreferences.Editor editor = sp.edit();
                    editor.putString("privateKey", Base64.encodeToString(aByte, Base64.DEFAULT));
                    editor.putString("publicKey", Base64.encodeToString(pByte, Base64.DEFAULT));
                    editor.commit();


                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            StringBuilder builder = new StringBuilder();
                            builder.append("私钥是:" + "\n");
                            builder.append(Base64.encodeToString(aByte, Base64.DEFAULT) + "\n");
                            builder.append("公钥是:" + "\n");
                            builder.append(Base64.encodeToString(pByte, Base64.DEFAULT));
                            text.setText(builder.toString());
                        }
                    });

                } catch (NoSuchAlgorithmException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        text = null;
        data = null;
    }
}