Android中 MD5、RC4、DES、DESede （3DES）、RSA、AES、自定义填充方式的 AES加密/解密算法

最新推荐文章于 2022-08-25 09:47:26 发布
最新推荐文章于 2022-08-25 09:47:26 发布
阅读量1.1k 收藏 1
点赞数 2
分类专栏： 工具类 文章标签： rc4加密 md5加密 android 对称加密 非对称加密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34947883/article/details/79103019
版权 
     /**
     * 字符串进行加密
     */
    public static String useMD5(String passWord) {
        try {
            MessageDigest digest = MessageDigest.getInstance("MD5");
            digest.update(passWord.getBytes());
            return getHashString(digest);

        } catch (NoSuchAlgorithmException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;

    }

    private static String getHashString(MessageDigest digest) {
        StringBuilder builder = new StringBuilder();
        for (byte b : digest.digest()) {
            builder.append(Integer.toHexString((b >> 4) & 0xf));
            builder.append(Integer.toHexString(b & 0xf));
        }
        return builder.toString().toLowerCase();
    }

    /**
     * MD5 消息摘要，对输入的内容，进行唯一表示的计算
     *
     * @param data 原数据
     * @return byte[] 计算后的 MD5 值
     */

    public static byte[] md5(byte[] data) {
        byte[] ret = null;
        if (data != null) {
            try {
                // 创建 消息摘要对象
                MessageDigest messageDigest = MessageDigest.getInstance("MD5");
                ret = messageDigest.digest(data);
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            }
        }
        return ret;
    }

    /**
     * SHA1 消息摘要，对输入的内容，进行唯一表示的计算
     *
     * @param data 原数据
     * @return byte[] 计算后的 SHA1 值
     */

    public static byte[] sha1(byte[] data) {
        byte[] ret = null;
        if (data != null) {
            try {
                // 创建 消息摘要对象
                MessageDigest messageDigest = MessageDigest.getInstance("SHA-1");
                ret = messageDigest.digest(data);
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            }
        }
        return ret;
    }

    /**
    * RC4对称加密
    */

    public static byte[] HloveyRC4(byte[] aInput, byte[] aKey) {
        int[] iS = new int[256];
        byte[] iK = new byte[256];
        for (int i = 0; i < 256; i++) {
            iS[i] = i;
        }
        int j = 1;
        for (short i = 0; i < 256; i++) {
            iK[i] = aKey[(i % aKey.length)];
        }
        j = 0;
        for (int i = 0; i < 256; i++) {
            j = (j + iS[i] & 0xff + iK[i] & 0xff) % 256;
            int temp = iS[i];
            iS[i] = iS[j];
            iS[j] = temp;
        }
        int i = 0;
        j = 0;
        byte[] iOutputChar = new byte[aInput.length];
        for (int x = 0; x < iOutputChar.length; x++) {
            i = (i + 1) % 256;
            j = (j + iS[i] & 0xff) % 256;
            int temp = iS[i] & 0xff;
            iS[i] = iS[j];
            iS[j] = temp;
            int t = (iS[i] + (iS[j] & 0xff % 256)) % 256;
            int iY = iS[t] & 0xff;
            byte iCY = (byte) iY;
            iOutputChar[x] = (byte) (aInput[x] ^ iCY);
        }
        return iOutputChar;
    }


     /**
     * DES 的加密方法
     *
     * @param data 原始的数据
     * @param pwd  密码 8 个字节
     * @return byte[] 加密后的数据
     */
    public static byte[] desEncrypt(byte[] data, byte[] pwd) {
        byte[] ret = null;
        if (data != null && pwd != null && pwd.length == 8) {
            try {
                Cipher cipher = Cipher.getInstance("DES");
                SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DES");
                SecretKey secretKey = secretKeyFactory.generateSecret(new DESKeySpec(pwd));
                // 代表当前是解密状态
                cipher.init(Cipher.DECRYPT_MODE, secretKey);

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

     /**
     * DES 的解密方法
     * 
     * @param enData 经过加密之后的数据
     * @param pwd    密码 8 个字节
     * @return byte[] 解密后的原数据
     */
    public static byte[] desDecrypt(byte[] enData, byte[] pwd) {
        byte[] ret = null;
        if (enData != null && pwd != null && pwd.length == 8) {
            try {
                Cipher cipher = Cipher.getInstance("DES");
                SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DES");
                SecretKey secretKey = secretKeyFactory.generateSecret(new DESKeySpec(pwd));
                // 代表当前是解密状态
                cipher.init(Cipher.DECRYPT_MODE, secretKey);

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



    /**
     * DESede （3DES）加密方法
     *
     * @param data 原始数据
     * @param pwd  密码，长度 <= 24 个字节
     * @return byte[] 加密后的数据
     */
    public static byte[] desedeEncrypt(byte[] data, byte[] pwd) {
        byte[] ret = null;
        if (data != null && pwd != null) {
            int plen = pwd.length;
            // 确保密码是24 个字节
            if (plen < 24) {
                byte[] fully = new byte[24];
                System.arraycopy(pwd, 0, fully, 0, plen);
                pwd = fully;
            }
            try {
                Cipher cipher = Cipher.getInstance("DESede");
                SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DESede");
                SecretKey secretKey = secretKeyFactory.generateSecret(new DESedeKeySpec(pwd));
                // 代表当前是解密状态
                cipher.init(Cipher.ENCRYPT_MODE, secretKey);

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

    /**
     * DESede （3DES）解密方法
     *
     * @param data 加密后数据
     * @param pwd  密码，长度 <= 24 个字节
     * @return byte[] 解密后的数据
     */
    public static byte[] desedeDecrypt(byte[] data, byte[] pwd) {
        byte[] ret = null;
        if (data != null && pwd != null) {
            int plen = pwd.length;
            // 确保密码是24 个字节
            if (plen < 24) {
                byte[] fully = new byte[24];
                System.arraycopy(pwd, 0, fully, 0, plen);
                pwd = fully;
            }
            try {
                Cipher cipher = Cipher.getInstance("DESede");
                SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DESede");
                SecretKey secretKey = secretKeyFactory.generateSecret(new DESedeKeySpec(pwd));
                // 代表当前是解密状态
                cipher.init(Cipher.DECRYPT_MODE, secretKey);

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


/**
     * 非对称加密
     * RSA 加密部分，加密的部分支持 PrivateKey 加密，同时也支持 Publickey 加密
     * 因为 Privatekey 实现 Key 接口，同时 Publickey 也实现了 Key 接口
     *
     * @param data 要加密的数据
     * @param key  秘钥
     * @return byte[] 加密后的字节数组
     */
    public static byte[] rsaEncrypt(byte[] data, Key key) {
        byte[] ret = null;
        if (data != null && key != null) {
            if (key instanceof PublicKey || key instanceof PrivateKey) {
                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;
    }

    /**
     * 非对称加密
     * RSA 解密部分，解密的部分支持 PrivateKey 解密，同时也支持 Publickey 解密
     * 因为 Privatekey 实现 Key 接口，同时 Publickey 也实现了 Key 接口
     *
     * @param data RSA 加密后的数据
     * @param key  秘钥
     * @return byte[] 解密后的原数据
     */
    public static byte[] rsaDecrypt(byte[] data, Key key) {
        byte[] ret = null;
        if (data != null && key != null) {
            if (key instanceof PublicKey || key instanceof PrivateKey) {
                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;
    }

/**
     * AES 加密
     * 采用 Cipher.getInstance("AES") 方式，并且直接指定密码的加密
     *
     * @param data 数据
     * @param pwd  密码，密码长度建议 16 个字节
     * @return byte[] 加密后的数据
     */
    public static byte[] aesEncrypt(byte[] data, byte[] pwd) {
        byte[] ret = null;
        if (data != null && pwd != null) {
// 检测密码长度,进行补充操作
            int plen = pwd.length;
            if (plen < 16) { // 128 bit
                byte[] fully = new byte[16];
                System.arraycopy(pwd, 0, fully, 0, plen);
                pwd = fully;
            }
            try {
// !!! AES 的加密，算法部分是支持多种形式的
// 如果写的是 AES，那么对应的解密方法，使用的算法必须是 AES
                // !!! AES 的加密，还可以使用 AES/CBC/PKCS5Padding 这个算法
// 对应的解密算法 必须使用 "AES/CBC/PKCS5Padding" 才可以解密
                Cipher cipher = Cipher.getInstance("AES");
                SecretKeySpec key = new SecretKeySpec(pwd, "AES");
                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;
    }

    /**
     * AES 解密
     * 采用 Cipher.getInstance("AES") 方式，并且直接指定密码的加密
     *
     * @param data 需要解密的数据
     * @param pwd  密码,长度建议 16 个字节
     * @return byte[] 解密后的数据
     */
    public static byte[] aesDecrypt(byte[] data, byte[] pwd) {
        byte[] ret = null;
        if (data != null && pwd != null) {
// 检测密码长度,进行补充操作
            int plen = pwd.length;
            if (plen < 16) { // 128 bit
                byte[] fully = new byte[16];
                System.arraycopy(pwd, 0, fully, 0, plen);
                pwd = fully;
            }
            try {
// !!! AES 的加密，算法部分是支持多种形式的
// 如果写的是 AES，那么对应的解密方法，使用的算法必须是 AES
                // !!! AES 的加密，还可以使用 AES/CBC/PKCS5Padding 这个算法
// 对应的解密算法 必须使用 "AES/CBC/PKCS5Padding" 才可以解密
                Cipher cipher = Cipher.getInstance("AES");
                SecretKeySpec key = new SecretKeySpec(pwd, "AES");
                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;
    }



     /**
     * 使用密码和Iv两个参数来进行加密，可以理解为用两个密码进行加密
     * Iv 可以看做另外一个密码，对于解密而言，密码和Iv 同样要一致
     * 自定义填充方式的 AES 加密
     * 使加密的内容，强度更高
     *
     * @param data   要加密的数据
     * @param pwd    密码,长度 <= 16 个字节
     * @param ivData IvParameter
     * @return byte[] 加密后的数据
     */
    public static byte[] aesIvEncrypt(byte[] data, byte[] pwd, byte[] ivData) {
        byte[] ret = null;
        if (data != null && pwd != null && ivData != null) {
            int plen = pwd.length;
            if (plen < 16) { // 128 bit
                byte[] fully = new byte[16];
                System.arraycopy(pwd, 0, fully, 0, plen);
                pwd = fully;
            }
            plen = ivData.length;
            if (plen < 16) { // 128 bit
                byte[] fully = new byte[16];
                System.arraycopy(ivData, 0, fully, 0, plen);
                ivData = fully;
            }
            try {
                // 支持的算法
                // AES/CBC/PKCS5Padding
                // AES/ECB/PKCS5Padding
                // AES/CBC/NoPadding
                // AES/ECB/NoPadding
                Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
                SecretKeySpec keySpec = new SecretKeySpec(pwd, "AES");
                // 使用 Iv 增加 AES 的加密强度，参数必须是 16 个字节
                IvParameterSpec ivParameterSpec = new IvParameterSpec(ivData);
                // Iv 就是AES 中，另一套密码
                cipher.init(Cipher.ENCRYPT_MODE, keySpec, ivParameterSpec);
                ret = cipher.doFinal(data);
            } 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;
    }

    /**
     * 使用密码和Iv两个参数来进行解密，可以理解为用两个密码进行加密
     * Iv 可以看做另外一个密码，对于解密而言，密码和Iv 同样要一致
     * 自定义填充方式的 AES 加密
     * 使加密的内容，强度更高
     *
     * @param data   需要进行解密的数据
     * @param pwd    密码,长度 <= 16 个字节
     * @param ivData IvParameter
     * @return byte[] 解密后的原数据
     */
    public static byte[] aesIvDecrypt(byte[] data, byte[] pwd, byte[] ivData) {
        byte[] ret = null;
        if (data != null && pwd != null && ivData != null) {
            int plen = pwd.length;
            if (plen < 16) { // 128 bit
                byte[] fully = new byte[16];
                System.arraycopy(pwd, 0, fully, 0, plen);
                pwd = fully;
            }
            plen = ivData.length;
            if (plen < 16) { // 128 bit
                byte[] fully = new byte[16];
                System.arraycopy(ivData, 0, fully, 0, plen);
                ivData = fully;
            }
            try {
                // 支持的算法
                // AES/CBC/PKCS5Padding
                // AES/ECB/PKCS5Padding
                // AES/CBC/NoPadding
                // AES/ECB/NoPadding
                Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
                SecretKeySpec keySpec = new SecretKeySpec(pwd, "AES");
                // 使用 Iv 增加 AES 的加密强度，参数必须是 16 个字节
                IvParameterSpec ivParameterSpec = new IvParameterSpec(ivData);
                // Iv 就是AES 中，另一套密码
                cipher.init(Cipher.DECRYPT_MODE, keySpec, ivParameterSpec);
                ret = cipher.doFinal(data);
            } 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;
    }
王小二1204
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 实现RC4加密、解密
OneN的博客
08-21 1045
// private static byte[] initKey(String aKey) { private static byte[] initKey(byte[] b_key) { // byte[] b_key = aKey.getBytes(); byte state[] = new byte[256]; for (int...
RC4加密解密source code(C code)
64M便当的专栏
08-31 4947
#include#include#include#include #define buf_size 1024 typedef struct rc4_key{         unsigned char state[256];          unsigned char x;           unsigned char y;} rc4_key; #define swap_byte(x,y) t
android 算法,安卓逆向中常见校验与加密算法特征总结
weixin_42400619的博客
05-29 283
初学安卓逆向，学习了常见的几种校验与算法，做出一些总结，希望也能带给同为初学的同学一些参考~~so库加密算法分析步骤：绝大部分情况下，so下面的加密算法，都是调用openssl里面的加密函数区分算法的步骤：1，先区分是哪种类型的算法2，再识别出是哪种加密算法算法的类别：取数据摘要的算法(MD5, SHA*)对称加密的算法(AES,DES) (核心算法就是各种复杂的位异或)非对称加密算法(RSA)(...
android rc4 加密,Android支持哪些加密算法？
weixin_39840733的博客
05-27 265
试试这个列出所有安全提供程序：Provider[] providers = Security.getProviders();for (Provider provider : providers) {Log.i("CRYPTO","provider: "+provider.getName());Set services = provider.getServices();for (Provider.S...
密码学 | 对称加密算法RC4
爬虫进击之路
08-25 2499
在密码学中，RC4是一种流加密算法，密钥长度可变。它加解密使用相同的密钥，因此也属于对称加密算法。所谓对称加密，就是加密和解密的过程是一样的。RC4是有线等效加密（WEP）中采用的加密算法，也曾经是TLS可采用的算法之一。RC4已经成为一些常用的协议和标准的一部分，如1997年的WEP和2003/2004年无线卡的WPA;和1995年的SSL，以及后来1999年的TLS。让它如此广泛分布和使用的主要因素是它不可思议的简单和速度，不管是软件还是硬件，实现起来都十分容易。
简书android des,Des
weixin_29981095的博客
06-04 121
常用加密算法的Java实现总结算法原理DES算法把64位的明文输入块变为64位的密文输出块，它所使用的密钥也是64位，其算法主要分为两步：(a) 初始置换其功能是把输入的64位数据块按位重新组合,并把输出分为L0、R0两部分，每部分各长32位。L0、R0则是换位输出后的两部分，L0是输出的左32位，R0是右32位。其置换规则为将输入的第58位换到第一位，第50位换到第2位……依此类推,最后一位是原...
RC4 加密解密
一品大帅的专栏
05-25 4676
一般服务器端会进行Base64处理下，所以客户端也要先Base64解密后，再使用RC4解密。 如：服务器端先RC4加密，然后对其加密后的byte[]做Base64加密处理，所以客户端就需要先Base64解密，然后RC4解密，顺序不可颠倒。 RC4加解密方法引用其他博客。 public class RC4Encrypt { private final byte[] S = n...
PHP对称加密算法（DES/AES）类的实现代码
10-18
本篇文章主要介绍了PHP对称加密算法（DES/AES）类的实现代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
MD5算法，URLEncoding，Base64编码，AES,DES,DESede，RSA加密解密工具类和使用实例
03-22
MD5算法，URLEncoding，Base64编码，AES,DES,DESede，RSA加密解密工具类和使用实例
java/javascript/iOS的AES加解密（AES/CBC/PKCS5Padding）
11-29
AES/CBC/PKCS5Padding，加密解决 支持javascript、java、iOS
常见的AES、DES、3DES(DESede)的108种JS加密
06-06
网上常用的对称加密一般就这三种吧，与APP中常用的那些也基本能对上。调用修改的是 CryptoJS, https://github.com/brix/crypto-js/。连同mode和padding一共108种。@镇坛道德标杆。
Java实现AES/CBC/PKCS7Padding加解密的方法
08-18
主要介绍了Java实现AES/CBC/PKCS7Padding加解密的方法，本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
Des加密 （Ecb模式，PKCS5Padding的填充方式），Base64编码数据
Janskid的博客
12-23 3889
http在数据通信的时候，因为不像https自带链路加密，所有为了安全性，使用http协议的时候，需要给请求包进行数据加密，为了配合服务器端的解密算法，我发送端使用了Des加密。（需要跟其他平台或者语言做交换的话，各个平台/语言间的加密模式需要一致，填充方式也需要一致。不得不说的一点是DES已经被破译过，当然这种破译的代价并不低，而且并不是那么简单。如果要求更高的数据安全级别，可以选择使用3DES...
ios+android+rc4加密,密码学基础之RC4加密
weixin_36180068的博客
05-29 371
RC4是比较容易理解的对称加密算法，又叫ARC4算法。原理初始化秘钥：根据输入的秘钥key，使用密钥调度算法(KSA)生成一个256字节的sbox。再通过伪随机数生成算法(PRGA)得到密钥流(keystream)加密：密钥流与明文进行异或运算得到密文解密：秘文与密钥流进行异或运算得到明文你只需要知道异或运算加密的原理就能理解RC4算法。实现RC4非常好实现，不用费心的去找库，按照[维基百科RC4...
ios+android+rc4加密,关于加密：iOS的RC4算法
weixin_34342446的博客
05-29 180
我有使用rc4算法的密钥和加密值，我需要解密该密钥。请您帮我解决这个问题。 使用本机ios。 请给我任何解决方案。 我已经引用了一些对我没有帮助的链接。我已经从服务器收到了一些加密值，并且已经生成了密钥。 使用该加密值和密钥，我需要使用RC4算法解密。Apple CommonCrypto支持RC4。 编写一些代码以使用它，如果遇到问题，请发布该代码。I have referred some lin...
DES, RC4, RC5, AES, RSA, MD5, SHA1 安全算法分析
热门推荐
我的专栏
03-11 2万+
1. 基于对称密钥的加密算法主要有DES、RC4、RC5, AES     对称加密(也叫私钥加密)指加密和解密使用相同密钥的加密算法。有时又叫传统密码算法，就是加密密钥能够从解密密钥中推算出来，同时解密密钥也可以从加密密钥中推算出来。而在大多数的对称算法中，加密密钥和解密密钥是相同的，所以也称这种加密算法为秘密密钥算法或单密钥算法。它要求发送方和接收方在安全通信之前，商定一个密钥。对称算法
ios+android+rc4加密,iOS版的RC4-Base64加密解密
weixin_35861265的博客
05-29 306
在网上找到不少RC4加解密的，oc写的加密的主要都是http://www.cocoachina.com/bbs/read.php?tid-77608.html这一篇。我用了之后，和我们的PHP不能对应起来，他加密后我解密不对，我加密他解密也不对。所以，我自己重新又写了一个。1.首先，先下载一个openssl库，把库放到桌面上2.新建项目，导入lib-ios里的两个库：libcrypto.a和lib...
RC4加密解密算法123
cloud 的学习时代
11-15 9035
RC4是一种对称密码算法，它属于对称密码算法中的序列密码(streamcipher,也称为流密码)，它是可变密钥长度，面向字节操作的流密码。 RC4是流密码streamcipher中的一种，为序列密码。RC4加密算法是Ron Rivest在1987年设计出的密钥长度可变的加密算法簇。起初该算法是商业机密，直到1994年，它才公诸于众。由于RC4具有算法简单，运算速度快，软硬件实现都十分容易等优点
Android-RC4的加密解密代码
dibe49481448的博客
08-12 690
static String RC4(String keys, String encrypt) { char[] keyBytes = new char[256]; char[] cypherBytes = new char[256]; for (int i = 0; i < 256; ++i) { ...
php 3des加密解密和 java 3des互通
最新发布
06-09
PHP和Java都有支持3DES加密和解密的库，可以通过这些库来实现互通。以下是一个简单的PHP和Java之间3DES加密和解密的例子： PHP代码： ```php $key = "123456789012345678901234"; // 24位密钥 $data = "Hello, ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值