java C++ md5 异或加密 10进制转16进制 16进制转10进制

最新推荐文章于 2021-09-14 22:08:25 发布
最新推荐文章于 2021-09-14 22:08:25 发布
阅读量957 收藏
点赞数 1
分类专栏： C/C++/C# Java 文章标签： c语言 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dopamy_BusyMonkey/article/details/72638286
版权 
    public static String string2MD5(String inStr){  
        MessageDigest md5 = null;  
        try{  
            md5 = MessageDigest.getInstance("MD5");  
        }catch (Exception e){  
            System.out.println(e.toString());  
            e.printStackTrace();  
            return "";  
        }  
        char[] charArray = inStr.toCharArray();  
        byte[] byteArray = new byte[charArray.length];  
  
        for (int i = 0; i < charArray.length; i++)  
            byteArray[i] = (byte) charArray[i];  
        byte[] md5Bytes = md5.digest(byteArray);  
        StringBuffer hexValue = new StringBuffer();  
        for (int i = 0; i < md5Bytes.length; i++){  
            int val = ((int) md5Bytes[i]) & 0xff;  
            if (val < 16)  
                hexValue.append("0");  
            hexValue.append(Integer.toHexString(val));  
        }  
        return hexValue.toString();  
  
    }  
  
    /** 
     * 加密解密算法 执行一次加密，两次解密 
     */   
    public static String decode1(String inStr){  
    	char[] miyao={'q','w','e','r','t','y','u','i','o','p','a','s','d','f','g','h','j','k','l','z','x','c','v','b','n','m','1','2','3','4','5','6','7','8','9','0'};
        char[] a = inStr.toCharArray();  
        for (int i = 0; i < a.length; i++) {  
            a[i] = (char) (a[i] ^ miyao[i]);  
        }  
        String s = new String(a);  
        return s;    
    }  
    
    public static String decode2(String inStr){  
    	char[] miyao={'m','n','b','v','c','x','z','l','k','j','h','g','f','d','s','a','p','o','i','u','y','t','r','e','w','q','0','9','8','7','6','5','4','3','2','1'};
        char[] a = inStr.toCharArray();  
        for (int i = 0; i < a.length; i++) {  
            a[i] = (char) (a[i] ^ miyao[i]);  
        }  
        String s = new String(a);  
        return s;  
    }
    
    public static String stringToHexString(String strPart) {
		String hexString = "";
		for (int i = 0; i < strPart.length(); i++) {
			int ch = (int) strPart.charAt(i);
			if (ch < 16) {
				String strHex = '0' + Integer.toHexString(ch);
				hexString = hexString + strHex;
			} else {
				String strHex = Integer.toHexString(ch);
				hexString = hexString + strHex;
			}

		}
		return hexString;
	}

	public static String hexString2String(String src) {  
        String temp = "";  
        for (int i = 0; i < src.length() / 2; i++) {  
            temp = temp  
                    + (char) Integer.valueOf(src.substring(i * 2, i * 2 + 2),  
                            16).byteValue();  
        }  
        return temp;  
    } 



// ConsoleApplication1.cpp : 定义控制台应用程序的入口点。
//

#include   <stdio.h>    
#include   <stdlib.h>  
#include   <time.h>    
#include   <string.h>    
#include   "md5.h"  

typedef   unsigned   char   *POINTER;
typedef   unsigned   short   int   UINT2;
typedef   unsigned   long   int   UINT4;

typedef   struct
{
	UINT4   state[4];
	UINT4   count[2];
	unsigned   char   buffer[64];
}   MD5_CTX;

void   MD5Init(MD5_CTX   *);
void   MD5Update(MD5_CTX   *, unsigned   char   *, unsigned   int);
void   MD5Final(unsigned   char[16], MD5_CTX   *);

#define   S11   7    
#define   S12   12    
#define   S13   17    
#define   S14   22    
#define   S21   5    
#define   S22   9    
#define   S23   14    
#define   S24   20    
#define   S31   4    
#define   S32   11    
#define   S33   16    
#define   S34   23    
#define   S41   6    
#define   S42   10    
#define   S43   15    
#define   S44   21    

static   unsigned   char   PADDING[64] = {
	0x80, 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
};

#define   F(x,   y,   z)   (((x)   &   (y))   |   ((~x)   &   (z)))    
#define   G(x,   y,   z)   (((x)   &   (z))   |   ((y)   &   (~z)))    
#define   H(x,   y,   z)   ((x)   ^   (y)   ^   (z))    
#define   I(x,   y,   z)   ((y)   ^   ((x)   |   (~z)))    

#define   ROTATE_LEFT(x,   n)   (((x)   <<   (n))   |   ((x)   >>   (32-(n))))    

#define   FF(a,   b,   c,   d,   x,   s,   ac)   {     (a)   +=   F   ((b),   (c),   (d))   +   (x)   +   (UINT4)(ac);     (a)   =   ROTATE_LEFT   ((a),   (s));     (a)   +=   (b);       }    
#define   GG(a,   b,   c,   d,   x,   s,   ac)   {     (a)   +=   G   ((b),   (c),   (d))   +   (x)   +   (UINT4)(ac);     (a)   =   ROTATE_LEFT   ((a),   (s));     (a)   +=   (b);       }    
#define   HH(a,   b,   c,   d,   x,   s,   ac)   {     (a)   +=   H   ((b),   (c),   (d))   +   (x)   +   (UINT4)(ac);     (a)   =   ROTATE_LEFT   ((a),   (s));     (a)   +=   (b);       }    
#define   II(a,   b,   c,   d,   x,   s,   ac)   {     (a)   +=   I   ((b),   (c),   (d))   +   (x)   +   (UINT4)(ac);     (a)   =   ROTATE_LEFT   ((a),   (s));     (a)   +=   (b);   }    


inline   void   Encode(unsigned   char   *output, UINT4   *input, unsigned   int   len)
{
	unsigned   int   i, j;

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

inline   void   Decode(UINT4   *output, unsigned   char   *input, unsigned   int   len)
{
	unsigned   int   i, j;

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

inline   void   MD5Transform(UINT4   state[4], unsigned   char   block[64])
{
	UINT4   a = state[0], b = state[1], c = state[2], d = state[3], x[16];
	Decode(x, block, 64);
	FF(a, b, c, d, x[0], S11, 0xd76aa478);
	FF(d, a, b, c, x[1], S12, 0xe8c7b756);
	FF(c, d, a, b, x[2], S13, 0x242070db);
	FF(b, c, d, a, x[3], S14, 0xc1bdceee);
	FF(a, b, c, d, x[4], S11, 0xf57c0faf);
	FF(d, a, b, c, x[5], S12, 0x4787c62a);
	FF(c, d, a, b, x[6], S13, 0xa8304613);
	FF(b, c, d, a, x[7], S14, 0xfd469501);
	FF(a, b, c, d, x[8], S11, 0x698098d8);
	FF(d, a, b, c, x[9], S12, 0x8b44f7af);
	FF(c, d, a, b, x[10], S13, 0xffff5bb1);
	FF(b, c, d, a, x[11], S14, 0x895cd7be);
	FF(a, b, c, d, x[12], S11, 0x6b901122);
	FF(d, a, b, c, x[13], S12, 0xfd987193);
	FF(c, d, a, b, x[14], S13, 0xa679438e);
	FF(b, c, d, a, x[15], S14, 0x49b40821);
	GG(a, b, c, d, x[1], S21, 0xf61e2562);
	GG(d, a, b, c, x[6], S22, 0xc040b340);
	GG(c, d, a, b, x[11], S23, 0x265e5a51);
	GG(b, c, d, a, x[0], S24, 0xe9b6c7aa);
	GG(a, b, c, d, x[5], S21, 0xd62f105d);
	GG(d, a, b, c, x[10], S22, 0x2441453);
	GG(c, d, a, b, x[15], S23, 0xd8a1e681);
	GG(b, c, d, a, x[4], S24, 0xe7d3fbc8);
	GG(a, b, c, d, x[9], S21, 0x21e1cde6);
	GG(d, a, b, c, x[14], S22, 0xc33707d6);
	GG(c, d, a, b, x[3], S23, 0xf4d50d87);
	GG(b, c, d, a, x[8], S24, 0x455a14ed);
	GG(a, b, c, d, x[13], S21, 0xa9e3e905);
	GG(d, a, b, c, x[2], S22, 0xfcefa3f8);
	GG(c, d, a, b, x[7], S23, 0x676f02d9);
	GG(b, c, d, a, x[12], S24, 0x8d2a4c8a);
	HH(a, b, c, d, x[5], S31, 0xfffa3942);
	HH(d, a, b, c, x[8], S32, 0x8771f681);
	HH(c, d, a, b, x[11], S33, 0x6d9d6122);
	HH(b, c, d, a, x[14], S34, 0xfde5380c);
	HH(a, b, c, d, x[1], S31, 0xa4beea44);
	HH(d, a, b, c, x[4], S32, 0x4bdecfa9);
	HH(c, d, a, b, x[7], S33, 0xf6bb4b60);
	HH(b, c, d, a, x[10], S34, 0xbebfbc70);
	HH(a, b, c, d, x[13], S31, 0x289b7ec6);
	HH(d, a, b, c, x[0], S32, 0xeaa127fa);
	HH(c, d, a, b, x[3], S33, 0xd4ef3085);
	HH(b, c, d, a, x[6], S34, 0x4881d05);
	HH(a, b, c, d, x[9], S31, 0xd9d4d039);
	HH(d, a, b, c, x[12], S32, 0xe6db99e5);
	HH(c, d, a, b, x[15], S33, 0x1fa27cf8);
	HH(b, c, d, a, x[2], S34, 0xc4ac5665);
	II(a, b, c, d, x[0], S41, 0xf4292244);
	II(d, a, b, c, x[7], S42, 0x432aff97);
	II(c, d, a, b, x[14], S43, 0xab9423a7);
	II(b, c, d, a, x[5], S44, 0xfc93a039);
	II(a, b, c, d, x[12], S41, 0x655b59c3);
	II(d, a, b, c, x[3], S42, 0x8f0ccc92);
	II(c, d, a, b, x[10], S43, 0xffeff47d);
	II(b, c, d, a, x[1], S44, 0x85845dd1);
	II(a, b, c, d, x[8], S41, 0x6fa87e4f);
	II(d, a, b, c, x[15], S42, 0xfe2ce6e0);
	II(c, d, a, b, x[6], S43, 0xa3014314);
	II(b, c, d, a, x[13], S44, 0x4e0811a1);
	II(a, b, c, d, x[4], S41, 0xf7537e82);
	II(d, a, b, c, x[11], S42, 0xbd3af235);
	II(c, d, a, b, x[2], S43, 0x2ad7d2bb);
	II(b, c, d, a, x[9], S44, 0xeb86d391);
	state[0] += a;
	state[1] += b;
	state[2] += c;
	state[3] += d;
	memset((POINTER)x, 0, sizeof   (x));
}

inline   void   MD5Init(MD5_CTX   *context)
{
	context->count[0] = context->count[1] = 0;
	context->state[0] = 0x67452301;
	context->state[1] = 0xefcdab89;
	context->state[2] = 0x98badcfe;
	context->state[3] = 0x10325476;
}

inline   void   MD5Update(MD5_CTX   *context, unsigned   char   *input, unsigned   int   inputLen)
{
	unsigned   int   i, index, partLen;

	index = (unsigned   int)((context->count[0] >> 3) & 0x3F);
	if ((context->count[0] += ((UINT4)inputLen << 3))
		<   ((UINT4)inputLen << 3))
		context->count[1]++;
	context->count[1] += ((UINT4)inputLen >> 29);

	partLen = 64 - index;

	if (inputLen >= partLen)   {
		memcpy((POINTER)&context->buffer[index], (POINTER)input, partLen);
		MD5Transform(context->state, context->buffer);

		for (i = partLen; i + 63 < inputLen; i += 64)
			MD5Transform(context->state, &input[i]);
		index = 0;
	}
	else
		i = 0;

	memcpy((POINTER)&context->buffer[index], (POINTER)&input[i], inputLen - i);
}

inline   void   MD5Final(unsigned   char   digest[16], MD5_CTX   *context)
{
	unsigned   char   bits[8];
	unsigned   int   index, padLen;

	Encode(bits, context->count, 8);
	index = (unsigned   int)((context->count[0] >> 3) & 0x3f);
	padLen = (index   <   56) ? (56 - index) : (120 - index);
	MD5Update(context, PADDING, padLen);
	MD5Update(context, bits, 8);
	Encode(digest, context->state, 16);
	memset((POINTER)context, 0, sizeof   (*context));
}

void   MD5Digest(char   *pszInput, unsigned   long   nInputSize, char   *pszOutPut)
{
	MD5_CTX   context;
	unsigned   int   len = strlen(pszInput);

	MD5Init(&context);
	MD5Update(&context, (unsigned   char   *)pszInput, len);
	MD5Final((unsigned   char   *)pszOutPut, &context);
}

int main()
{
	char szDigest[16];
	char encrypt[200];
	printf("请输入要计算MD5值的字符串:");
	gets_s(encrypt);
	printf("\n加密结果:");
	MD5Digest(encrypt, strlen(encrypt), szDigest);
	int i;
	for (i = 0; i<16; i++) printf("%02X", (unsigned char)szDigest[i]);
	getchar();
	return 0;
}


#include   <stdio.h>    
#include   <stdlib.h>  
#include   <time.h>    
#include   <string.h>    
void   MD5Digest(char   *pszInput, unsigned   long   nInputSize, char   *pszOutPut);


md5 C++源代码 Writen by Robert Hubley,我只是加入了把加密结果转为10进制和16进制的几行代码
03-10 1299
/****************************************************************************** *  Copyright (C) 2000 by Robert Hubley.                                      * *  All rights reserved.                  
十进制，十六进制字符串加密工具
03-05
可以实现对字符串的各种十进制，十六进制，二进制, UNICODE, DELPHI 等加密
JAVA中MD5的转换
java的涟漪
08-29 1846
import java.io.UnsupportedEncodingException; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.security.SecureRandom; import java.util.Arrays; import
十六进制解密,10进制和16进制之间的加密解密
05-16
软件没什么说明。。大家都是明白人。。 例子： 原始数据：00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 加密后数据：BC 2B 87 75 CF 2B BB 7C 91 55 B6 71 89 6B D6 A2
java md5 二进制_java md5加密,加密后为何一般用 0-9 a-f??
weixin_34613462的博客
02-13 372
比如下面的变量 hexDigits/*** 对字符串md5加密(大写+数字)** @param str 传入要加密的字符串* @return MD5加密后的字符串*/public static String MD5(String s) {char hexDigits[]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','...
python md5转十进制数字
看清这个世界
09-14 2383
C/C++十六进制异或运算
05-06
在IT领域，尤其是在编程中，十六进制（Hexadecimal）是一种常见的数字表示方式，它以16个符号来表示数值，这些符号包括0-9的阿拉伯数字和A-F的字母（A代表10，B代表11，以此类推，直到F代表15）。异或（XOR）运算是...
AES.rar_AES_AES-CBC_C语言aes 128_aes 16进制_c++ AES
09-22
C语言中处理16进制字符串需要用到字符串转换函数，例如将十六进制字符串转化为二进制数据，再进行加密。 **C++实现AES** C++作为C语言的超集，可以利用C++的面向对象特性，创建类来封装AES加密和解密的功能，提供...
MD5.zip_c++md5加密解密
09-23
4. **编码与解码**：MD5计算得到的是128位的二进制数据，为了方便展示和比较，通常会将其转换为16进制的字符串。在C++中，可以使用`std::stringstream`和`std::hex`进行这种转换。解码则通常指的是将16进制字符串...
des加密算法-显示16进制
01-04
在本实验中，我们关注的是如何使用DES算法进行加密，并将结果以16进制的形式展示出来。以下是关于DES加密算法及其在16进制显示中的相关知识。 首先，DES算法基于Feistel网络结构，它将原始明文分为左半部分（L0）和...
C++ 计算字符串md5_16和md5_32
01-14
标题"**C++ 计算字符串md5_16和md5_32**"指的可能是在C++编程环境中实现计算字符串的MD5值，通常MD5值为32位的十六进制数，但有时为了简洁，可能会只取前16位。这两种形式都是MD5的简化表示，不过16位的形式可能会...
java md5 加密后转为16进制
07-26
java md5 加密后转为16进制
c++写的简单的异或加密
09-08
对文件进行简单的加密,输入密码后打开需要加密的或者需要解密的文件
网狐32位MD5加密和20位异或加密解密库
07-13
1.不依赖于Window平台库的C++库源代码 2.针对Windows平台跨语言变成的VC6编译的标准DLL
MD5加密与byte数组与16进制相互转换
04-15
包含MD5加密，同时拥有多种方式进行byte或者byte[]与16进制相互转换 三种方式： 方式一：Integer.toHexString(int) 对应的是： Integer.parseInt(String, int)或者Integer.valueOf(String, int) 方式二：位运算（& 与 |） 方式三：算术运算
10进制转化为16进制
weixin_44964349的博客
05-06 1560
10进制转化为16进制 public static String to16(int n) { if(n<10) { return n+""; } else if(n<16) { return (char)(‘A’+(n-10))+""; } return to16(n/16)+to16(n%16);//递归的方法 } 这里输入的是67，输出的结果为： ...
十进制转十六进制
qq_39536716的博客
09-25 272
package LQB; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Scanner; public class Basic9 { //十进制转化为十六进制 public static void ...
php 字符 hash_PHP如何把字符串hash成10进制数字
weixin_35692838的博客
03-09 761
我刚刚正在想这个问题就是MD5的随机性。于是就要对其计算。看到这篇文章我就用其中算法做计算，发现散列特性丢失，最后证明是Sunyanzi的算法存在错误base_convert函数仍然存在错误，导致低位丢失，由于位运算拼接法适用的计算机的位数不同，所以我用的是bc数学拓展法。实现方法是把MD5的字符串分割后转10进制后用数学函数加权。具体代码如下$z = md5('something');$a=su...
java des 16进制_Java 10进制byte数组与16进制byte数组互转 及 在DES加解密中的使用
weixin_39984201的博客
02-25 734
一、10进制byte数组与16进制byte数组互转1. 10进制byte数组转成16进制byte数组Java中10进制byte用二进制表示占用8位，16进制的每个字符需要用4位二进制位来表示，则将每一个10进制字节的高4位、低4位分别进行处理，对应到16进制字符(通过与0xf0或0x0f进行&位运算将4位转成0~15范围内的一个数,与这个数对应的有一个16进制字符)，取该字符对应的字节，最...
C++实现MD5加密算法及其应用领域分析
MD5加密算法是一种广泛使用的加密哈希函数，可以产生出一个128位的哈希值，通常表现为32位十六进制数字。虽然MD5在安全领域中不再被认为是安全的加密算法（主要因为其抗碰撞性较差），但在一些不需要高度安全要求的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值