Android md5加密

最新推荐文章于 2020-10-21 17:49:40 发布
最新推荐文章于 2020-10-21 17:49:40 发布
阅读量319 收藏
点赞数
分类专栏： 原创 文章标签： android 加密 md5
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/public_calss/article/details/48974631
版权


  MD5加密是不可逆的，小菜们就别想着破解了，大牛也不会来看这篇文章滴

/**
 * MD5加密  不可逆，后台比对加密后的数据，终端用SharedPreferences保存。
 * @author Administrator
 *
 */
public class MainActivity extends Activity implements OnClickListener{


private Button but ,but_;
private EditText eText; 
private TextView textView;
private MD5Util md5Util;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

md5Util = new MD5Util();

eText = (EditText) findViewById(R.id.edit);
textView = (TextView) findViewById(R.id.txt);
but = (Button) findViewById(R.id.but_save);
but.setOnClickListener(this);
}

@Override
public void onClick(View v) {
// TODO Auto-generated method stub
switch (v.getId()) {
case R.id.but_save:
textView.setText(md5Util.getMD5ofStr(eText.getText().toString()));
break;
default:
break;
}
}

}


/**
 * MD5算法
 * @author admin
 *
 */
public class MD5Util {
    static final int S11 = 7;
    static final int S12 = 12;
    static final int S13 = 17;
    static final int S14 = 22;


    static final int S21 = 5;
    static final int S22 = 9;
    static final int S23 = 14;
    static final int S24 = 20;


    static final int S31 = 4;
    static final int S32 = 11;
    static final int S33 = 16;
    static final int S34 = 23;


    static final int S41 = 6;
    static final int S42 = 10;
    static final int S43 = 15;
    static final int S44 = 21;


    static final byte[] PADDING = { -128, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
    
    private long[] state = new long[4];  // state (ABCD)
    private long[] count = new long[2];  // number of bits, modulo 2^64 (lsb first)
    private byte[] buffer = new byte[64]; // input buffer
    
    public String digestHexStr;
    
    private byte[] digest = new byte[16];
    
    public String getMD5ofStr(String inbuf) {
            md5Init();
            md5Update(inbuf.getBytes(), inbuf.length());
            md5Final();
            digestHexStr = "";
            for (int i = 0; i < 16; i++) {
                    digestHexStr += byteHEX(digest[i]);
            }
            return digestHexStr;


    }


    public MD5Util() {
            md5Init();


            return;
    }
    

    private void md5Init() {
            count[0] = 0L;
            count[1] = 0L;
            ///* Load magic initialization constants.

            state[0] = 0x67452301L;
            state[1] = 0xefcdab89L;
            state[2] = 0x98badcfeL;
            state[3] = 0x10325476L;

            return;
    }


    private long F(long x, long y, long z) {
            return (x & y) | ((~x) & z);

    }
    private long G(long x, long y, long z) {
            return (x & z) | (y & (~z));

    }
    private long H(long x, long y, long z) {
            return x ^ y ^ z;
    }

    private long I(long x, long y, long z) {
            return y ^ (x | (~z));
    }

    private long FF(long a, long b, long c, long d, long x, long s,
            long ac) {
            a += F (b, c, d) + x + ac;
            a = ((int) a << s) | ((int) a >>> (32 - s));
            a += b;
            return a;
    }

    private long GG(long a, long b, long c, long d, long x, long s,
            long ac) {
            a += G (b, c, d) + x + ac;
            a = ((int) a << s) | ((int) a >>> (32 - s));
            a += b;
            return a;
    }
    private long HH(long a, long b, long c, long d, long x, long s,
            long ac) {
            a += H (b, c, d) + x + ac;
            a = ((int) a << s) | ((int) a >>> (32 - s));
            a += b;
            return a;
    }
    private long II(long a, long b, long c, long d, long x, long s,
            long ac) {
            a += I (b, c, d) + x + ac;
            a = ((int) a << s) | ((int) a >>> (32 - s));
            a += b;
            return a;
    }
    private void md5Update(byte[] inbuf, int inputLen) {


            int i, index, partLen;
            byte[] block = new byte[64];
            index = (int)(count[0] >>> 3) & 0x3F;
            // /* Update number of bits */
            if ((count[0] += (inputLen << 3)) < (inputLen << 3))
                    count[1]++;
            count[1] += (inputLen >>> 29);

            partLen = 64 - index;


            // Transform as many times as possible.
            if (inputLen >= partLen) {
                    md5Memcpy(buffer, inbuf, index, 0, partLen);
                    md5Transform(buffer);


                    for (i = partLen; i + 63 < inputLen; i += 64) {


                            md5Memcpy(block, inbuf, 0, i, 64);
                            md5Transform (block);
                    }
                    index = 0;


            } else


                    i = 0;


            ///* Buffer remaining input */
            md5Memcpy(buffer, inbuf, index, i, inputLen - i);

    }
    
    private void md5Final () {
            byte[] bits = new byte[8];
            int index, padLen;


            ///* Save number of bits */
            Encode (bits, count, 8);


            ///* Pad out to 56 mod 64.
            index = (int)(count[0] >>> 3) & 0x3f;
            padLen = (index < 56) ? (56 - index) : (120 - index);
            md5Update (PADDING, padLen);


            ///* Append length (before padding) */
            md5Update(bits, 8);


            ///* Store state in digest */
            Encode (digest, state, 16);


    }
     
    private void md5Memcpy (byte[] output, byte[] input,
            int outpos, int inpos, int len)
    {
            int i;


            for (i = 0; i < len; i++)
                    output[outpos + i] = input[inpos + i];
    }
    
    private void md5Transform (byte block[]) {
            long a = state[0], b = state[1], c = state[2], d = state[3];
            long[] x = new long[16];


            Decode (x, block, 64);


            /* Round 1 */
            a = FF (a, b, c, d, x[0], S11, 0xd76aa478L); /* 1 */
            d = FF (d, a, b, c, x[1], S12, 0xe8c7b756L); /* 2 */
            c = FF (c, d, a, b, x[2], S13, 0x242070dbL); /* 3 */
            b = FF (b, c, d, a, x[3], S14, 0xc1bdceeeL); /* 4 */
            a = FF (a, b, c, d, x[4], S11, 0xf57c0fafL); /* 5 */
            d = FF (d, a, b, c, x[5], S12, 0x4787c62aL); /* 6 */
            c = FF (c, d, a, b, x[6], S13, 0xa8304613L); /* 7 */
            b = FF (b, c, d, a, x[7], S14, 0xfd469501L); /* 8 */
            a = FF (a, b, c, d, x[8], S11, 0x698098d8L); /* 9 */
            d = FF (d, a, b, c, x[9], S12, 0x8b44f7afL); /* 10 */
            c = FF (c, d, a, b, x[10], S13, 0xffff5bb1L); /* 11 */
            b = FF (b, c, d, a, x[11], S14, 0x895cd7beL); /* 12 */
            a = FF (a, b, c, d, x[12], S11, 0x6b901122L); /* 13 */
            d = FF (d, a, b, c, x[13], S12, 0xfd987193L); /* 14 */
            c = FF (c, d, a, b, x[14], S13, 0xa679438eL); /* 15 */
            b = FF (b, c, d, a, x[15], S14, 0x49b40821L); /* 16 */


            /* Round 2 */
            a = GG (a, b, c, d, x[1], S21, 0xf61e2562L); /* 17 */
            d = GG (d, a, b, c, x[6], S22, 0xc040b340L); /* 18 */
            c = GG (c, d, a, b, x[11], S23, 0x265e5a51L); /* 19 */
            b = GG (b, c, d, a, x[0], S24, 0xe9b6c7aaL); /* 20 */
            a = GG (a, b, c, d, x[5], S21, 0xd62f105dL); /* 21 */
            d = GG (d, a, b, c, x[10], S22, 0x2441453L); /* 22 */
            c = GG (c, d, a, b, x[15], S23, 0xd8a1e681L); /* 23 */
            b = GG (b, c, d, a, x[4], S24, 0xe7d3fbc8L); /* 24 */
            a = GG (a, b, c, d, x[9], S21, 0x21e1cde6L); /* 25 */
            d = GG (d, a, b, c, x[14], S22, 0xc33707d6L); /* 26 */
            c = GG (c, d, a, b, x[3], S23, 0xf4d50d87L); /* 27 */
            b = GG (b, c, d, a, x[8], S24, 0x455a14edL); /* 28 */
            a = GG (a, b, c, d, x[13], S21, 0xa9e3e905L); /* 29 */
            d = GG (d, a, b, c, x[2], S22, 0xfcefa3f8L); /* 30 */
            c = GG (c, d, a, b, x[7], S23, 0x676f02d9L); /* 31 */
            b = GG (b, c, d, a, x[12], S24, 0x8d2a4c8aL); /* 32 */


            /* Round 3 */
            a = HH (a, b, c, d, x[5], S31, 0xfffa3942L); /* 33 */
            d = HH (d, a, b, c, x[8], S32, 0x8771f681L); /* 34 */
            c = HH (c, d, a, b, x[11], S33, 0x6d9d6122L); /* 35 */
            b = HH (b, c, d, a, x[14], S34, 0xfde5380cL); /* 36 */
            a = HH (a, b, c, d, x[1], S31, 0xa4beea44L); /* 37 */
            d = HH (d, a, b, c, x[4], S32, 0x4bdecfa9L); /* 38 */
            c = HH (c, d, a, b, x[7], S33, 0xf6bb4b60L); /* 39 */
            b = HH (b, c, d, a, x[10], S34, 0xbebfbc70L); /* 40 */
            a = HH (a, b, c, d, x[13], S31, 0x289b7ec6L); /* 41 */
            d = HH (d, a, b, c, x[0], S32, 0xeaa127faL); /* 42 */
            c = HH (c, d, a, b, x[3], S33, 0xd4ef3085L); /* 43 */
            b = HH (b, c, d, a, x[6], S34, 0x4881d05L); /* 44 */
            a = HH (a, b, c, d, x[9], S31, 0xd9d4d039L); /* 45 */
            d = HH (d, a, b, c, x[12], S32, 0xe6db99e5L); /* 46 */
            c = HH (c, d, a, b, x[15], S33, 0x1fa27cf8L); /* 47 */
            b = HH (b, c, d, a, x[2], S34, 0xc4ac5665L); /* 48 */


            /* Round 4 */
            a = II (a, b, c, d, x[0], S41, 0xf4292244L); /* 49 */
            d = II (d, a, b, c, x[7], S42, 0x432aff97L); /* 50 */
            c = II (c, d, a, b, x[14], S43, 0xab9423a7L); /* 51 */
            b = II (b, c, d, a, x[5], S44, 0xfc93a039L); /* 52 */
            a = II (a, b, c, d, x[12], S41, 0x655b59c3L); /* 53 */
            d = II (d, a, b, c, x[3], S42, 0x8f0ccc92L); /* 54 */
            c = II (c, d, a, b, x[10], S43, 0xffeff47dL); /* 55 */
            b = II (b, c, d, a, x[1], S44, 0x85845dd1L); /* 56 */
            a = II (a, b, c, d, x[8], S41, 0x6fa87e4fL); /* 57 */
            d = II (d, a, b, c, x[15], S42, 0xfe2ce6e0L); /* 58 */
            c = II (c, d, a, b, x[6], S43, 0xa3014314L); /* 59 */
            b = II (b, c, d, a, x[13], S44, 0x4e0811a1L); /* 60 */
            a = II (a, b, c, d, x[4], S41, 0xf7537e82L); /* 61 */
            d = II (d, a, b, c, x[11], S42, 0xbd3af235L); /* 62 */
            c = II (c, d, a, b, x[2], S43, 0x2ad7d2bbL); /* 63 */
            b = II (b, c, d, a, x[9], S44, 0xeb86d391L); /* 64 */


            state[0] += a;
            state[1] += b;
            state[2] += c;
            state[3] += d;


    }
    
    private void Encode (byte[] output, long[] input, int len) {
            int i, j;


            for (i = 0, j = 0; j < len; i++, j += 4) {
                    output[j] = (byte)(input[i] & 0xffL);
                    output[j + 1] = (byte)((input[i] >>> 8) & 0xffL);
                    output[j + 2] = (byte)((input[i] >>> 16) & 0xffL);
                    output[j + 3] = (byte)((input[i] >>> 24) & 0xffL);
            }
    }


    private void Decode (long[] output, byte[] input, int len) {
            int i, j;




            for (i = 0, j = 0; j < len; i++, j += 4)
                    output[i] = b2iu(input[j]) |
                            (b2iu(input[j + 1]) << 8) |
                            (b2iu(input[j + 2]) << 16) |
                            (b2iu(input[j + 3]) << 24);


            return;
    }
   
    public static long b2iu(byte b) {
            return b < 0 ? b & 0x7F + 128 : b;
    }
    
    public static String byteHEX(byte ib) {
            char[] Digit = { '0','1','2','3','4','5','6','7','8','9',
            'A','B','C','D','E','F' };
            char [] ob = new char[2];
            ob[0] = Digit[(ib >>> 4) & 0X0F];
            ob[1] = Digit[ib & 0X0F];
            String s = new String(ob);
            return s;
    }


    public static void main(String args[]) {
            MD5Util m = new MD5Util();
            String tmp =  m.getMD5ofStr("123456");
            System.out.println("tmp= "+tmp);
    }

}



程序猿小爱
关注
专栏目录
Android MD5加密
shaomingshan的博客
06-14 2万+
概述在网络中传输明文是一件非常危险的事情，所以通常将密码加密后传至服务器，由服务器保存密文在登录判定时只需比较密文是否相同即可。MD5加密是一种常用的加密算法，全称为“Message-Digest Algorithm 5”，即消息摘要算法，由MD2、MD3、MD4演变过来的，是一种单向加密算法，是一种不可逆的加密方式MD5优点：压缩性：任意长度的数据，算出的MD5值长度都是固定的。容易计算：从原数...
Android md5加密与php md5加密一致详解
01-04
在Android开发过程中加密密码常常采用md5加密方式，然而如果服务器端采用PHP开发（php采用md5加密很简单，直接md5($str)），很可能与Java的md5加密不一致。以下方法是md5加密与php一致的源码： import java.math....
Android数据加密之——MD5加密
我的博客
03-30 1037
注：本文为转载文章，原文请参考：Android数据加密之MD5加密前言：项目中无论是密码的存储或者说判断文件是否是同一文件，都会用到MD5算法，今天来总结一下MD5加密算法。什么是MD5加密？MD5英文全称“Message-Digest Algorithm 5”，翻译过来是“消息摘要算法5”，由MD2、MD3、MD4演变过来的，是一种单向加密算法，是不可逆的一种的加密方式。MD5加密有哪些特点？压...
android MD5加密
sinat_30474567的博客
12-05 209
/** * MD5加密 * * @param string * @return */ public static String MD5(String string) { if (null != string && !"".equals(string)) { StringBuffer sb = new StringBuffer(); try {
android环境下两种md5加密方式
grafx的专栏
10-29 3142
在平时开发过程中，MD5加密是一个比较常用的算法，最常见的使用场景就是在帐号注册时，用户输入的密码经md5加密后，传输至服务器保存起来。虽然md5加密经常用，但是md5的加密原理我还真说不上来，对md5的认知目前仅仅停留在会使用的水平，想搞清楚还是要花点时间的，这是md5加密算法的相关介绍。
android Md5加密
11-08
在Android开发中，数据安全是至关重要的一个环节，而MD5（Message-Digest Algorithm 5）是一种常用的哈希函数，广泛用于加密和数据校验。本文将深入探讨如何在Android中实现MD5加密，以及其在单字符串和多字符串场景...
Android编程之MD5加密算法实例分析
01-20
在Android编程中，MD5加密算法的使用与Java标准版（J2SE）平台基本一致，因为Android环境同样支持`java.security.MessageDigest`包，该包提供了对多种哈希算法的支持，包括MD5。 MD5算法的典型特征是它将任意长度的...
android md5加密
darkCloudss的博客
10-21 170
public class MD5Utils { //MD5加密不可逆 /*对密码进行加密 *参数：密码 *返回：密文 */ public static String digest(String password) { try { MessageDigest digest = MessageDigest.getInstance("MD5");
MD5加密
不精通则死
12-25 881
private static final char HEX_DIGITS[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',         'A', 'B', 'C', 'D', 'E', 'F' };         public static String toHexString(byte[] b) {  //Strin
Android MD5加密
mmdev
11-30 88
public static String md5(String string) { byte[] hash; try { hash = MessageDigest.getInstance("MD5").digest(string.getBytes("UTF-8")); } catch (NoSuchAlgorithmExcepti...
Android MD5 加密方法实现
"本文将详细介绍如何在Android...Android MD5加密是实现简单数据加密的一种方法，尤其适用于快速验证数据完整性。然而，对于密码等敏感信息的存储，应当考虑使用更安全的加密和哈希算法，以及加盐等增强安全性措施。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值