【框架】加密解密

共四种:

1.base64(大小写英文字母、10个基本阿拉伯数字、+、/)

2.MD5(任意长度的数据,算出的MD5值长度都是固定的,哪怕只修改1个字节,所得到的MD5值都有很大区别)

3.对称密钥加密(加密解密的密钥一样)

4.非对称加密(加密解密的密钥不一样,分为公钥和私钥)

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        NavigationView navigationView = (NavigationView) findViewById(R.id.navigation_view);
        final DrawerLayout drawerLayout = (DrawerLayout) findViewById(R.id.drawer_layout);
        navigationView.setNavigationItemSelectedListener(new NavigationView.OnNavigationItemSelectedListener() {
            @Override
            public boolean onNavigationItemSelected(MenuItem item) {
                FragmentTransaction transaction = getSupportFragmentManager().beginTransaction();
                switch (item.getItemId()) {
                    case R.id.base64:
//                        fragment = new Base64Fragment();
                        transaction.replace(R.id.content, new Base64Fragment());
                        break;
                    case R.id.md5:
                        transaction.replace(R.id.content, new MD5Fragment());
                        break;
                    case R.id.des:
                        transaction.replace(R.id.content, new DESFragment());
                        break;
                    case R.id.rsa:
                        transaction.replace(R.id.content, new RSAFragment());
                        break;
                }
//                transaction.replace(R.id.content, fragment).commit();
                transaction.commit();
                drawerLayout.closeDrawer(Gravity.LEFT);
                return true;
            }
        });
    }
}

Base64加密解密

public class Base64Fragment extends Fragment {
    @Bind(R.id.encode_et)
    EditText encodeEt;
    @Bind(R.id.decode_et)
    EditText decodeEt;
    @Bind(R.id.result)
    TextView result;

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.base64_layout,null);
        ButterKnife.bind(this, view);
        return view;
    }

    @OnClick(R.id.encode)
    public void encode() {
        String srcStr = encodeEt.getText().toString();
        //编码
        String s = Base64.encodeToString(srcStr.getBytes(), Base64.DEFAULT);
        decodeEt.setText(s);
    }

    @OnClick(R.id.decode)
    public void decode() {
        String srcStr = decodeEt.getText().toString();
        byte[] decode = Base64.decode(srcStr.getBytes(), Base64.DEFAULT);
        String s = new String(decode, 0, decode.length);
        result.setText(s);
    }
}

MD5加密解密

public class MD5Fragment extends Fragment {
    @Bind(R.id.encode_et)
    EditText encodeEt;
    @Bind(R.id.result)
    TextView result;

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.md5_layout, null);
        ButterKnife.bind(this, view);
        return view;
    }

    @OnClick(R.id.encode)
    public void encode() {
        try {
            //获取一个消息摘要生成实例
            MessageDigest messageDigest = MessageDigest.getInstance("MD5");
            byte[] digest = messageDigest.digest(encodeEt.getText().toString().getBytes());
            StringBuffer stringBuffer = new StringBuffer();
            for (byte b : digest) {
                //使用十六进制输出消息摘要,不足两位的用0补齐
                stringBuffer.append(String.format("%02x", b));
            }
            result.setText(stringBuffer.toString());
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
    }
}

对称密钥加密

public class DESFragment extends Fragment {
    @Bind(R.id.encode_et)
    EditText encodeEt;
    @Bind(R.id.decode_et)
    EditText decodeEt;
    @Bind(R.id.encode_et2)
    EditText encodeEt2;
    @Bind(R.id.decode_et2)
    EditText decodeEt2;
    @Bind(R.id.encode_et3)
    EditText encodeEt3;
    @Bind(R.id.decode_et3)
    EditText decodeEt3;
    @Bind(R.id.result)
    TextView result;

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.des_layout, null);
        ButterKnife.bind(this, view);
        return view;
    }

    @OnClick(R.id.encode)
    public void encode() {
        String des = EncryptionHelper.des(encodeEt.getText().toString(), "789", EncryptionHelper.ENCODE);
        decodeEt.setText(des);
    }

    @OnClick(R.id.decode)
    public void decode() {
        String des = EncryptionHelper.des(decodeEt.getText().toString(), "789", EncryptionHelper.DECODE);
        result.setText(des);
    }

    @OnClick(R.id.encode2)
    public void encode2() {
        String s = EncryptionHelper.des3(encodeEt2.getText().toString(), "123", EncryptionHelper.ENCODE);
        decodeEt2.setText(s);
    }

    @OnClick(R.id.decode2)
    public void decode2() {
        String s = EncryptionHelper.des3(decodeEt2.getText().toString(), "123", EncryptionHelper.DECODE);
        result.setText(s);
    }

    @OnClick(R.id.encode3)
    public void encode3() {
        String s = EncryptionHelper.aes(encodeEt3.getText().toString(), "abcd", EncryptionHelper.ENCODE);
        decodeEt3.setText(s);
    }

    @OnClick(R.id.decode3)
    public void decode3() {
        String abcd = EncryptionHelper.aes(decodeEt3.getText().toString(), "abcd", EncryptionHelper.DECODE);
        result.setText(abcd);
    }
}
public class EncryptionHelper {
    public static final int ENCODE = 0;
    public static final int DECODE = 1;

    /**
     * 使用DES算法进行对称加/解密
     *
     * @param srcStr 明文
     * @param key    密钥
     * @param mode   模式(加密/解密)
     * @return
     */
    public static String des(String srcStr, String key, int mode) {
        String charsetName = "UTF-8";
        try {
            //获得key的byte数组
            byte[] keyBytes = key.getBytes(charsetName);
            //des算法中key的长度为8
            byte[] temp = new byte[8];
            //数组拷贝
            //1.源数组
            //2.开始复制的位置
            //3.目标数组
            //4.目标数组的位置
            //5.复制的长度
            System.arraycopy(keyBytes, 0, temp, 0, Math.min(keyBytes.length, temp.length));
            //生成密钥
            //1.密钥数组
            //2.生成密钥的算法名称
            SecretKey secretKey = new SecretKeySpec(temp, "des");
            //获取一个密文生成器
            Cipher cipher = Cipher.getInstance("des");
            //如果要进行加密
            if (mode == ENCODE) {
                //初始化密文生成器
                cipher.init(Cipher.ENCRYPT_MODE, secretKey);
                //执行加密
                byte[] bytes = cipher.doFinal(srcStr.getBytes(charsetName));
                //使用Base64对加密结果进行编码
                String s = Base64.encodeToString(bytes, Base64.DEFAULT);
                return s;
                //如果要解密
            } else {
                //初始化密文生成器
                cipher.init(Cipher.DECRYPT_MODE, secretKey);
                //由于传进来的srcStr是对密文进行加密后的字符串,所以在解密之前先要解码
                byte[] bytes = cipher.doFinal(Base64.decode(srcStr, Base64.DEFAULT));
                //返回明文
                return new String(bytes, 0, bytes.length);
            }
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static String des3(String srcStr, String key, int mode) {
        String charsetName = "UTF-8";
        try {
            byte[] keyBytes = key.getBytes(charsetName);
            //注意和des算法key的长度不同
            byte[] temp = new byte[24];
            System.arraycopy(keyBytes, 0, temp, 0, Math.min(keyBytes.length, temp.length));
            SecretKey secretKey = new SecretKeySpec(temp, "desede");
            Cipher cipher = Cipher.getInstance("desede");
            if (mode == ENCODE) {
                cipher.init(Cipher.ENCRYPT_MODE, secretKey);
                byte[] bytes = cipher.doFinal(srcStr.getBytes(charsetName));
                return Base64.encodeToString(bytes, Base64.DEFAULT);
            } else {
                cipher.init(Cipher.DECRYPT_MODE, secretKey);
                byte[] bytes = cipher.doFinal(Base64.decode(srcStr, Base64.DEFAULT));
                return new String(bytes, 0, bytes.length);
            }
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static String aes(String srcStr, String key, int mode) {
        String charsetName = "UTF-8";
        try {
            byte[] keyBytes = key.getBytes(charsetName);
            byte[] temp = new byte[32];
            System.arraycopy(keyBytes, 0, temp, 0, Math.min(keyBytes.length, temp.length));
            SecretKey secretKey = new SecretKeySpec(temp, "aes");
            Cipher cipher = Cipher.getInstance("aes");
            if (mode == ENCODE) {
                cipher.init(Cipher.ENCRYPT_MODE, secretKey);
                byte[] bytes = cipher.doFinal(srcStr.getBytes(charsetName));
                return Base64.encodeToString(bytes, Base64.DEFAULT);
            } else {
                cipher.init(Cipher.DECRYPT_MODE, secretKey);
                byte[] bytes = cipher.doFinal(Base64.decode(srcStr, Base64.DEFAULT));
                return new String(bytes, 0, bytes.length);
            }
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        }
        return null;
    }
}

非对称密钥加密

public class RSAFragment extends Fragment {
    //两个大素数的乘积
    private static final String MODULUS = "100631058000714094813874361191853577129731636346684218206605779824931626830750623070803100189781211343851763275329364056640619755337779928985272486091431384128027213365372009648233171894708338213168824861061809490615593530405056055952622249066180336803996949444124622212096805545953751253607916170340397933039";
    //公钥
    private static final String PUB_KEY = "65537";
    //私钥
    private static final String PRI_KEY = "26900155715313643087786516528374548998821559381075740707715132776187148793016466508650068087107695523642202737697714709374658856733792614490943874205956727606674634563665154616758939576547663715234643273055658829482813503959459653708062875625210008961239643775661357655599312857249418610810177817213648575161";

    @Bind(R.id.encode_et)
    EditText encodeEt;
    @Bind(R.id.decode_et)
    EditText decodeEt;
    @Bind(R.id.result)
    TextView result;

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.rsa_layout, null);
        ButterKnife.bind(this, view);
        return view;
    }

    @OnClick(R.id.encode)
    public void encode() {
        String srcStr = encodeEt.getText().toString();
        try {
            //获取一个公钥/私钥生成工厂
            KeyFactory keyFactory = KeyFactory.getInstance("rsa");
            //1.大素数的乘积
            //2.公钥
            RSAPublicKeySpec rsaPublicKey = new RSAPublicKeySpec(new BigInteger(MODULUS), new BigInteger(PUB_KEY));
            //生成公钥
            PublicKey publicKey = keyFactory.generatePublic(rsaPublicKey);
            //获取一个密码生成器
            Cipher cipher = Cipher.getInstance("rsa");
            //初始化密码生成器
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            //加密
            byte[] bytes = cipher.doFinal(srcStr.getBytes("UTF-8"));
            String s = Base64.encodeToString(bytes, Base64.DEFAULT);
            decodeEt.setText(s);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        }
    }

    @OnClick(R.id.decode)
    public void decode() {
        try {
            KeyFactory keyFactory = KeyFactory.getInstance("rsa");
            RSAPrivateKeySpec rsaPrivateKeySpec = new RSAPrivateKeySpec(new BigInteger(MODULUS), new BigInteger(PRI_KEY));
            PrivateKey privateKey = keyFactory.generatePrivate(rsaPrivateKeySpec);
            Cipher cipher = Cipher.getInstance("rsa");
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            byte[] bytes = cipher.doFinal(Base64.decode(decodeEt.getText().toString(), Base64.DEFAULT));
            String s = new String(bytes, 0, bytes.length);
            result.setText(s);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        }
    }
}
时间: 2024-10-25 03:23:42

【框架】加密解密的相关文章

laravel cookie加密解密原理

通过控制台的 cookie 信息我们会发现,每次请求之后,关键的 cookie,如PHPSESSID.XSRF-TOKEN 都会发生变化,并且都是很长的一串字符串. 其实这是一个 json 数组,其中包含了 iv,value,mac 三个字段: 这些字段都是在框架加密解密的时候使用的,加密方法是 openssl_encrypt: 对 openssl 不太了解的可以看下下面的例子: $data = 'laravel'; $iv = random_bytes(16); $key = 'this is

AJAX+REA实现前后台数据交互的加密解密

AJAX+REA实现前后台数据交互的加密解密 1.创建js文件Encryption.js /**  * 加密解密  */ /** RSA加密用 生成key */ function bodyRSA(){ /** 1024位的key参数写130,2014位的key参数写260 */ setMaxDigits(130); /** ajax 调用后台方法,取回公钥 */ var keyR ;     $.ajax({      url: "/GHGL/Key/pk",//请求后台的url,本例

非对称技术栈实现AES加密解密

非对称技术栈实现AES加密解密 正如前面的一篇文章所述,https协议的SSL层是实现在传输层之上,应用层之下,也就是说在应用层上看到的请求还是明码的,对于某些场景下要求这些http请求参数是非可读的,这就要求在前端和后端不同的技术栈上完成信息的加密解密.当然我们通常完成这样专业的功能都会考虑使用相应的框架或者程序库来完成功能,前端或者NodeJS平台通常是JavaScript语言,JavaScript主流的加密解密库分别是SjclJS和CryptoJS, 本文以CryptoJS为例进行讨论.另

加密 解密过程详解及openssl自建CA  

            加密 解密过程详解及openssl自建CA 为了数据信息能够安全的传输要求数据要有一定的安全性那么数据的安全性包含哪些方面的特性呢?    NIST(美国信息安全署)做了如下的定义:    保密性:       1,数据的保密性 指的是数据或隐私不向非授权者泄漏                   2,隐私性  信息不被随意的收集    完整性:       1,数据的的完整性:信息或程序只能被指定或授权的方式改变不能被随意的             修改        

php加密解密功能类

这两天突发奇想想要用php写一个对日常项目加密以及解密的功能,经过努力简单的封装了一个对php代码进行加密解密的类,一些思想也是来自于网络,初步测试用着还行,可以实现对指定项目的加密以及解密(只针对本类中加密的解密)过程,在这里分享给大家,水平比较有限那里有错误还希望指出,共同提高,一下会给大家列出来实现的思想以及源码. 加密过程:读取源文件,base64_encode进行加密,利用混排得到的52个大小写字母作为秘钥进行替换$c=strtr(密文,对应待替换的字母,要替换成的字母);将两个秘钥和

加密–RSA前端与后台的加密&解密

C# 加密–RSA前端与后台的加密&解密 1. 前言 本问是根据网上很多文章的总结得到的. 2. 介绍 RSA加密算法是一种非对称加密算法. 对极大整数做因数分解的难度决定了RSA算法的可靠性.换言之,对一极大整数做因数分解愈困难,RSA算法愈可靠.假如有人找到一种快速因数分解的算法的话,那么用RSA加密的信息的可靠性就肯定会极度下降.但找到这样的算法的可能性是非常小的.今天只有短的RSA钥匙才可能被强力方式解破.到2016年为止,世界上还没有任何可靠的攻击RSA算法的方式.只要其钥匙的长度足够

自定义类加载器+加密+解密 实验

自定义类加载器+加密+解密 的这个程序需要的实验步骤如下,所用的类如下: ClassLoaderTest 类:用来做“解密实验”的类,将Test类的加密后的.class文件加载内存,并解密后,用ClassLoader.defineClass()得到Class对象,利用反射使用Test类 MyClassLoader 类:定义自己的类加载器,重写其中的findClass方法,在该方法中定义查找.class文件的默认目录,并调用EncodeDecodeClass类的解密方法,解密Test.class,

php 实现php代码的加密解密

php 代码加密类,大家可以根据自己的需求进行修改,原类如下,是对之前的加密解密类的有一次修改,希望能分享给大家.本次在ubuntu下测试没有问题,与之前的版本的区别在于,这次的版本更加的通用性. <?php /* * @auther:wangyaofeng * @time:2014.11.6 * @action:对php项目进行加密处理,注意如果项目中存在框架目录或没有必要加密的目录,请提前移出 * */ class Encryption{ private $c='';//存储密文 priva

linux CA 加密解密技术

一.基础知识 对称加密: 加密和解密方使用同一个密钥,用来解决数据机密性,但是密钥通过何种方式传递给对方不容易实现: 公钥加密: 密钥是成对出现的,分别为Secret key(密钥)和Public key(公钥)公钥加密必须使用与其相对应的 私钥进行解密并且公钥是从私钥中提取出来的,有私钥可以知道公钥是什么,但是知道公钥是不能知 道私钥的,公钥是公开的,而私钥是不公开的,但是公钥加密比对称加密慢3个数量级(1000倍), 加密速度相当的慢,所以单独用此加密方式也比较困难:公钥加密功能: 单向加密