android加密算法

最新推荐文章于 2021-05-29 02:40:28 发布
最新推荐文章于 2021-05-29 02:40:28 发布
阅读量531 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/flying_fish_wj/article/details/52927643 
/**
 * 常用的加密算法
 */
public final class CryptUtil {

    private CryptUtil(){}

    ///////////////////////////////////////////////////////////////////////////
    // DES
    ///////////////////////////////////////////////////////////////////////////

    /**
     * DES 加密算法
     * @param data 原始数据
     * @param key 密码，必须是8个字节
     * @return byte[] 经过加密之后的内容
     */
    public static byte[] desEncrypt(byte[] data, byte[] key){
        byte[] ret = null;
        if (data != null && key != null) {
            if(data.length > 0 && key.length == 8){
                // 1. 使用 Cipher 引擎 来初始化 加密，并且设置密码
                try {
                    Cipher cipher = Cipher.getInstance("DES");

                    // 1.1 DESKeySpec 用于描述DES的密码
                    DESKeySpec spec = new DESKeySpec(key);
                    // 1.2 使用 SecretKeyFactory 生成 Key对象
                    SecretKeyFactory factory = SecretKeyFactory.getInstance("DES");
                    SecretKey sk = factory.generateSecret(spec);

                    // 1.3 初始化 Cipher 为加密操作，并且指定密钥
                    cipher.init(Cipher.ENCRYPT_MODE, sk);

                    // 2. 加密数据
                    ret = cipher.doFinal(data);

                } catch (NoSuchAlgorithmException e) {
                    e.printStackTrace();
                } catch (NoSuchPaddingException e) {
                    e.printStackTrace();
                } catch (InvalidKeyException e) {
                    e.printStackTrace();
                } catch (InvalidKeySpecException e) {
                    e.printStackTrace();
                } catch (BadPaddingException e) {
                    e.printStackTrace();
                } catch (IllegalBlockSizeException e) {
                    e.printStackTrace();
                }
            }
        }
        return ret;
    }

    /**
     * DES 解密算法
     * @param data 原始数据
     * @param key 密码，必须是8个字节
     * @return byte[] 经过解密之后的内容
     */
    public static byte[] desDecrypt(byte[] data, byte[] key){
        byte[] ret = null;
        if (data != null && key != null) {
            if(data.length > 0 && key.length == 8){
                // 1. 使用 Cipher 引擎 来初始化 解密，并且设置密码
                try {
                    Cipher cipher = Cipher.getInstance("DES");

                    // 1.1 DESKeySpec 用于描述DES的密码
                    DESKeySpec spec = new DESKeySpec(key);
                    // 1.2 使用 SecretKeyFactory 生成 Key对象
                    SecretKeyFactory factory = SecretKeyFactory.getInstance("DES");
                    SecretKey sk = factory.generateSecret(spec);

                    // 1.3 初始化 Cipher 为解密操作，并且指定密钥
                    cipher.init(Cipher.DECRYPT_MODE, sk);

                    // 2. 解密数据
                    ret = cipher.doFinal(data);

                } catch (NoSuchAlgorithmException e) {
                    e.printStackTrace();
                } catch (NoSuchPaddingException e) {
                    e.printStackTrace();
                } catch (InvalidKeyException e) {
                    e.printStackTrace();
                } catch (InvalidKeySpecException e) {
                    e.printStackTrace();
                } catch (BadPaddingException e) {
                    e.printStackTrace();
                } catch (IllegalBlockSizeException e) {
                    e.printStackTrace();
                }
            }
        }
        return ret;
    }

    ///////////////////////////////////////////////////////////////////////////
    // AES 方式1
    ///////////////////////////////////////////////////////////////////////////

    public static byte[] aesEncryptSimple(byte[] data, byte[] key){
        byte[] ret = null;
        if (data != null && key != null) {
            if(data.length > 0 && key.length == 16){
                // AES 128bit = 16bytes
                try {
                    Cipher cipher = Cipher.getInstance("AES");
                    SecretKeySpec keySpec = new SecretKeySpec(key, "AES");
                    cipher.init(Cipher.ENCRYPT_MODE, keySpec);
                    ret = cipher.doFinal(data);
                } 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 ret;
    }
    public static byte[] aesDecryptSimple(byte[] data, byte[] key){
        byte[] ret = null;
        if (data != null && key != null) {
            if(data.length > 0 && key.length == 16){
                // AES 128bit = 16bytes
                try {
                    Cipher cipher = Cipher.getInstance("AES");
                    SecretKeySpec keySpec = new SecretKeySpec(key, "AES");
                    cipher.init(Cipher.DECRYPT_MODE, keySpec);
                    ret = cipher.doFinal(data);
                } 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 ret;
    }

    ///////////////////////////////////////////////////////////////////////////
    // AES 方式2 使用两套密码
    ///////////////////////////////////////////////////////////////////////////

    /**
     * 使用两套密码的加密，强度更高
     * @param data 数据
     * @param key 第一个密码
     * @param ivData 第二个密码
     * @return byte[]
     */
    public static byte[] aesEncryptWithIv(byte[] data, byte[] key, byte[] ivData){
        byte[] ret = null;
        if (data != null && key != null && ivData != null) {
            if(data.length > 0 && key.length == 16 && ivData.length == 16){
                // 使用两套密码的，算法需要写成 AES/算法模式/填充模式
                try {
                    Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
                    // 准备第一套密码
                    SecretKeySpec keySpec = new SecretKeySpec(key, "AES");
                    // 准备第二套密码
                    IvParameterSpec iv = new IvParameterSpec(ivData);
                    // 设置两套密码的初始化
                    cipher.init(Cipher.ENCRYPT_MODE, keySpec, iv);
                    cipher.update(data);
                    ret = cipher.doFinal();
                } catch (NoSuchAlgorithmException e) {
                    e.printStackTrace();
                } catch (NoSuchPaddingException e) {
                    e.printStackTrace();
                } catch (InvalidAlgorithmParameterException e) {
                    e.printStackTrace();
                } catch (InvalidKeyException e) {
                    e.printStackTrace();
                } catch (BadPaddingException e) {
                    e.printStackTrace();
                } catch (IllegalBlockSizeException e) {
                    e.printStackTrace();
                }
            }
        }
        return ret;
    }

    public static byte[] aesDecryptWithIv(byte[] data, byte[] key, byte[] ivData){
        byte[] ret = null;
        if (data != null && key != null && ivData != null) {
            if(data.length > 0 && key.length == 16 && ivData.length == 16){
                // 使用两套密码的，算法需要写成 AES/算法模式/填充模式
                try {
                    Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
                    // 准备第一套密码
                    SecretKeySpec keySpec = new SecretKeySpec(key, "AES");
                    // 准备第二套密码
                    IvParameterSpec iv = new IvParameterSpec(ivData);
                    // 设置两套密码的初始化
                    cipher.init(Cipher.DECRYPT_MODE, keySpec, iv);
                    cipher.update(data);
                    ret = cipher.doFinal();
                } catch (NoSuchAlgorithmException e) {
                    e.printStackTrace();
                } catch (NoSuchPaddingException e) {
                    e.printStackTrace();
                } catch (InvalidAlgorithmParameterException e) {
                    e.printStackTrace();
                } catch (InvalidKeyException e) {
                    e.printStackTrace();
                } catch (BadPaddingException e) {
                    e.printStackTrace();
                } catch (IllegalBlockSizeException e) {
                    e.printStackTrace();
                }
            }
        }
        return ret;
    }

    ///////////////////////////////////////////////////////////////////////////
    // RSA
    ///////////////////////////////////////////////////////////////////////////

    // 1. 生成密钥对 公钥和私钥

    /**
     *
     * @param bits 必须在 1024，2048
     * @return
     */
    public static KeyPair generateRsaKey(int bits){
        KeyPair ret = null;
        try {
            KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");

            kpg.initialize(bits);

            ret = kpg.generateKeyPair();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return ret;
    }

    /**
     * RSA加密，使用公钥加密，那么必须使用私钥解密
     *         使用私钥机密，那么必须使用公钥解密
     * @param data
     * @param key
     * @return
     */
    public static byte[] rsaEncrypt(byte[] data, Key key){
        byte[] ret = null;
        if (data != null && data.length > 0 && key != null) {
            try {
                Cipher cipher = Cipher.getInstance("RSA");
                cipher.init(Cipher.ENCRYPT_MODE, key);
                ret = cipher.doFinal(data);
            } 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 ret;
    }

    public static byte[] rsaDecrypt(byte[] data, Key key){
        byte[] ret = null;
        if (data != null && data.length > 0 && key != null) {
            try {
                Cipher cipher = Cipher.getInstance("RSA");
                cipher.init(Cipher.DECRYPT_MODE, key);
                ret = cipher.doFinal(data);
            } 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 ret;
    }

}

2.MainActivity

public class MainActivity extends AppCompatActivity {

    private EditText mTextContent;
    private TextView mTextResult;
    private EditText mTextPassword;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mTextContent = (EditText) findViewById(R.id.txt_content);
        mTextResult = (TextView) findViewById(R.id.txt_result);
        mTextPassword = (EditText) findViewById(R.id.txt_password);
    }

    public void btnBase64Encode(View view) {
        String str = mTextContent.getText().toString().trim();
        // Base64 编码，NO_WRAP 代表编码的结果没有任何换行
        String encoded = Base64.encodeToString(str.getBytes(), Base64.NO_WRAP);
        mTextResult.setText(encoded);

        // Base64 解码，
        String es = "5pKS5Zyw5pa55Y+r6ICD5ouJ5rC05reA57KJ5Y2z5Y+v5ouJ5rC05reA57KJ5Y2z5Y+v55qE6aOO5pmv5Y2h5omL5py65Y+R55qE5Y2h5ouJ55qE";
        byte[] decode = Base64.decode(es, Base64.NO_WRAP);
        String ss = null;
        try {
            ss = new String(decode, "UTF-8");
            Log.d("Base64", "ss = " + ss);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }

    public void btnUrlEncoding(View view) {


        String str = "%B1%E4%D0%CE%BD%F0%B8%D5";
        try {
            String decode = URLDecoder.decode(str, "GBK");
            Log.d("UE", "btnUrlEncoding: " + decode);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

        // URLEncoder 编码内容为可以在网址上拼接的字符串
        try {
            String ss = URLEncoder.encode("张哥Very很帅", "UTF-8");
            Log.d("UE", "btnUrlEncoding: ss = " + ss);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

    }

    /**
     * GZIP 压缩、解压缩
     *
     * @param view
     */
    public void btnGzipTest(View view) {
        String str = mTextContent.getText().toString().trim();

        // 1. 压缩GZIP, GZIPOutputStream
        ByteArrayOutputStream bout = new ByteArrayOutputStream();
        try {
            GZIPOutputStream gzOut = new GZIPOutputStream(bout);
            gzOut.write(str.getBytes()); // 利用GZIPOutputStream 压缩，并且输出结果
            gzOut.finish(); // 必须调用，在结束的时候，生成实际的压缩数据
            gzOut.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

        byte[] data = bout.toByteArray();
        mTextResult.setText("内容长度:" + str.length() + "\n压缩大小: " + data.length);

        String s = Arrays.toString(data);
        Log.d("GZIP", "btnGzipTest: " + s);

        // 解压缩 GZIPInputStream
        ByteArrayInputStream bin = new ByteArrayInputStream(data);
        try {
            GZIPInputStream gzIn = new GZIPInputStream(bin);
            ByteArrayOutputStream bo = new ByteArrayOutputStream();

            byte[] buf = new byte[128];
            int len;

            while (true) {
                len = gzIn.read(buf);
                if (len == -1) {
                    break;
                }
                bo.write(buf, 0, len);
            }

            byte[] bytes = bo.toByteArray();
            String ss = new String(bytes);
            Log.d("GZIP", "btnGzipTest: gzip ss = " + ss);

        } catch (IOException e) {
            e.printStackTrace();
        }


    }

    public void btnDesTest(View view) {
        // DES test

        String str = mTextContent.getText().toString().trim();
        String pwd = mTextPassword.getText().toString().trim();
//        byte[] encrypt = CryptUtil.desEncrypt(str.getBytes(), pwd.getBytes());
        byte[] iv = {23, 33, 2, 3, 3, 4, 6, 7, 1, 3, 3, 4, 4, 3, 4, 4};
        byte[] encrypt = CryptUtil.aesEncryptWithIv(str.getBytes(), pwd.getBytes(), iv);
        String s = Base64.encodeToString(encrypt, Base64.NO_WRAP);
        mTextResult.setText(s);

        // 解密，把Base64 字符串 还原并且解密
        byte[] ed = Base64.decode(s, Base64.NO_WRAP);
//        byte[] data = CryptUtil.desDecrypt(ed, pwd.getBytes());
        byte[] data = CryptUtil.aesDecryptWithIv(ed, pwd.getBytes(), iv);
        String ss = new String(data);
        Log.d("DES", "btnDesTest: " + ss);
    }

    public void btnRsaTest(View view) {
        // 1. 加载／生成 密钥对
        KeyPair keyPair = CryptUtil.generateRsaKey(1024);
        // 私钥
        PrivateKey aPrivate = keyPair.getPrivate();
        // 公钥
        PublicKey aPublic = keyPair.getPublic();

        // TODO: 把公钥、私钥 使用 Base64编码，保存到文件中；下一次启动的时候，需要先加载，没有才创建

        // 私钥的数据格式
        byte[] privEncoded = aPrivate.getEncoded();
        // 公钥的数据格式
        byte[] pubEncoded = aPublic.getEncoded();

        String str = mTextContent.getText().toString().trim();
        byte[] encrypt = CryptUtil.rsaEncrypt(str.getBytes(), aPublic);

        String es = Base64.encodeToString(encrypt, Base64.NO_WRAP);
        mTextResult.setText(es);


        byte[] dd = Base64.decode(es, Base64.NO_WRAP);
        byte[] data = CryptUtil.rsaDecrypt(dd, aPrivate);

        String s = new String(data);
        Log.d("RSA", "btnRsaTest: " + s);

    }
}


Android常用的加密算法
ridgepole_king的博客
10-10 675
DES DES-Data Encryption Standard,即数据加密算法。是IBM公司于1975年研究成功并公开发表的。DES算法的入口参数有三个:Key、Data、Mode。其中Key为8个字节共64位,是DES算法的工作密钥;Data也为8个字节64位,是要被加密或被解密的数据;Mode为DES的工作方式,有两种:加密或解密。 DES算法把64位的明文输入块变为64位的密文输出块,它所...
Android经典实战之常见的移动端加密算法和用kotlin进行AES-256加密和解密
最新发布
AntDream的程序世界
08-28 1517
本文首发于公众号“AntDream”，欢迎微信搜索“AntDream”或扫描文章底部二维码关注，和我一起每天进步一点点在移动端开发中，数据加密是确保数据传输和存储安全的重要手段。常见的加密算法包括对称加密算法（如 AES）、非对称加密算法（如 RSA）、散列算法（如 SHA-256），以及消息认证码（如 HMAC）。
安卓加密算法
weixin_42446445的博客
03-16 494
加密方式的分类： 对称加密算法： 加密和解密密钥相同，例如，DES、3DES、AES AES: 高级加密标准（英语：Advanced Encryption Standard，缩写：AES），在密码学中又称 Rijndael 加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的 DES，已经被多方分析且广为全世界所使用。经过五年的甄选流程，高级加密标准由美国国家标准与技术研究院（NI...
android中的加密算法,Android中加密算法
weixin_39703773的博客
05-29 444
Android中的加密算法可以分为两类：对称加密 和 非对称加密对称加密(DES、3DES、AES)概念对称加密算法中，发送方将明文和加密密匙经过特殊加密算法处理后，使其形成变成复杂的密文后发送出去。接受方用同样的密匙、同样加密算法的逆算法对密文进行解密。传统的DES加密算法只有56位密匙，最新AES技术拥有128位密匙。大大提高了安全性。优点：算法公开、计算量小、加密速度快、加密效率高缺点：发送...
Android常用加密算法
walk的博客
03-21 516
欢迎使用Markdown编辑器写博客 本Markdown编辑器使用StackEdit修改而来，用它写博客，将会带来全新的体验哦： Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 快捷键 加粗 Ctrl + B 斜体 Ctrl + I...
Frida快速定位Android加密算法方法整理
2. Android加密算法识别： - Android应用程序常常使用各种加密算法来保护数据安全，常见的算法包括消息摘要算法（如MD5、SHA系列），对称加密算法（如AES）和非对称加密算法（如RSA）。 - 通过Frida Hook技术可以...
Android加密算法实践：AES、RSA、3DES及代码反破解示例
本文将详细介绍Android平台上使用各种数据加密算法的代码示例，包括URL编码、BASE64编码、AES加密、RSA加密、3DES加密等，同时也会涉及一些反破解的代码防护技术。 1. URL编码 URL编码是一种编码方式，用于将非...
android中Sha256加密算法
01-03
import java.io.UnsupportedEncodingException; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; public class Sha256 { public static String getSHA256(String str){ ...
ANDROID加密算法AES
08-02
自己参考网络资源写的一个AES加密算法128位的实现，开发环境是Eclipse,语言是java，主要部件还是jdk提供的算法接口，可直接打开工程运行。
android 各种加密算法
06-17
base64,MD5,等各种加密算法汇总
安卓各种加密算法的实现 工具类
08-01
安卓各种加密算法的实现 工具类 能直接拿来调用
cryptutil:加密算法包装器，易于使用RSA，AES，DES等
04-06
加密工具 crypt算法包装器，可轻松使用RSA，AES，DES等。 基本用法 安装 要获取软件包，请执行： go get github.com/leaker/cryptutil
加密解密工具类 EncryptUtil
04-21
NULL 博文链接：https://uule.iteye.com/blog/1925046
Android 常用加密算法
hesheng1024的博客
04-13 645
title: Android 常用加密算法 date: 2020-03-02 tag: Android category: Android 文章目录Android 常用加密算法对称加密非对称加密其他散列算法对比参考 Android 常用加密算法 数字签名： 简单来说就是提供可鉴别的数字信息验证自身身份的一种方式。一套数字签名通常定义两种互补的运算，一个用于签名，另一个用于验证。分别又发送者持有...
【仙女】Android加密算法
weixin_41410541的博客
06-13 487
EncryptionInfo Android加密库 Table of Contents 使用说明 Hash算法实现 Hmac算法实现 对称加密算法实现 非对称加密算法实现 依赖 implementation 'fairy.easy:encryptioninformation:{latest_version}' 使用说明 Hash算法实现 代码示例 HashHelpe...
Android算法知识-常用加密算法
笨鸟的专栏
11-18 486
https://blog.youkuaiyun.com/u013718120/article/details/56486408 https://github.com/songxiaoliang/EncryptionLib 一、对称加密算法 对称密码算法的加密密钥和解密密钥相同， 对于大多数对称密码算法，加解密过程互逆 AES对DES提高了安全性 1.DES，3DES DES使用【56位密钥】以及附加的【8位...
Android最常用八种加密算法
gaiyindexingqiu的博客
05-02 2193
Android最常用八种加密算法： DES、3DES、AES、XOR、SHA、Base64、MD5、RAS
Android常用加解密算法
笔沫拾光
09-07 3573
数据安全，不管是对于企业还是个人都是十分重要。而作为一个移动开发者，我们更需要去考虑数据传输的安全性，去保护企业及个人信息安全。在Java,Android语言中，有许多的常用加解密算法，例如：对称加密算法AES,DES,3DES，非对称加密算法RSA,经典哈希算法MD5,SHA. 对称加密算法：加密秘钥和解密秘钥相同 例：AES,DES,3DES 非对称加密算法：有公钥和秘钥，公钥加密
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值