md5加盐加密在线工具（jmeter函数助手（一）一行代码实现MD5加密）

本文目录

• jmeter函数助手（一）一行代码实现MD5加密
• md5文件用什么打开
• 可变MD5加密（Java实现）
• ASP.NET实现对输入的密码用MD5+盐，并加密

jmeter函数助手（一）一行代码实现MD5加密

1、Tools - Function Helper Dialog:

2、生成可供使用的函数语句：
（1）选择函数
（2）设置参数：（参数对应依次为：加密形式、加密内容、盐、是否大写、16/32位（源码没有，需要自己加）、加密后赋值参数名称）
（3）生成可使用的函数语句，如图中步骤4展示

3、使用：
添加beanShell Sampler,，将生成的函数语句直接拷贝过来（熟练使用后可以直接在这里写，只需要修改对应位置的参数）

4、引用加密后的内容：
步骤2中提到：最后一个参数为加密后的赋值参数名，即：将加密后的值赋给了description，后面请求中直接引用description即可：

5、查看一下运行结果：

在线工具加密结果：

md5文件用什么打开

什么是MD5文件？
MD5文件是一种哈希算法生成的文件，它的全称是“Message-DigestAlgorithm5”，常用于校验文件的完整性和安全性。MD5文件通常以32个字符的十六进制字符串形式呈现，可以用于验证文件是否被篡改或损坏。
用什么打开MD5文件？
MD5文件本身并不是一种可执行的文件格式，因此不能直接打开。通常，我们需要使用MD5校验工具来验证文件的MD5值是否与给定的MD5值相同。常见的MD5校验工具包括WinMD5、MD5Checker、MD5summer等。这些工具通常提供了简单易用的图形界面，用户只需要将需要校验的文件拖拽到工具窗口中，即可自动计算出文件的MD5值，并与给定的MD5值进行比对，从而判断文件的完整性和安全性。
如何生成MD5文件？
如果需要生成MD5文件，我们可以使用MD5加密工具来实现。常见的MD5加密工具包括MD5加密器、MD5在线加密等。这些工具通常提供了简单易用的界面，用户只需要将需要加密的文件或文本输入到工具中，即可自动计算出对应的MD5值，并以32个字符的十六进制字符串形式呈现。需要注意的是，MD5加密算法并不是绝对安全的，因此在重要的信息加密中，我们应该选择更加安全可靠的加密算法。

可变MD5加密（Java实现）

　　可变在这里含义很简单 就是最终的加密结果是可变的 而非必需按标准MD 加密实现 Java类库security中的MessageDigest类就提供了MD 加密的支持 实现起来非常方便 为了实现更多效果 我们可以如下设计MD 工具类

　　Java代码

　　package ** ** util;

　　import java security MessageDigest;

　　/**

　　* 标准MD 加密方法 使用java类库的security包的MessageDigest类处理

　　* @author Sarin

　　*/

　　public class MD {

　　/**

　　* 获得MD 加密密码的方法

　　*/

　　public static String getMD ofStr(String origString) {

　　String origMD = null;

　　try {

　　MessageDigest md = MessageDigest getInstance( MD );

　　byte result = md digest(origString getBytes());

　　origMD = byteArray HexStr(result);

　　} catch (Exception e) {

　　e printStackTrace();

　　}

　　return origMD ;

　　}

　　/**

　　* 处理字节数组得到MD 密码的方法

　　*/

　　private static String byteArray HexStr(byte bs) {

　　StringBuffer *** = new StringBuffer();

　　for (byte b : bs) {

　　 *** append(byte HexStr(b));

　　}

　　return *** toString();

　　}

　　/**

　　* 字节标准移位转十六进制方法

　　*/

　　private static String byte HexStr(byte b) {

　　String hexStr = null;

　　int n = b;

　　if (n 《 ) {

　　//若需要自定义加密 请修改这个移位算法即可

　　n = b & x F + ;

　　}

　　hexStr = Integer toHexString(n / ) + Integer toHexString(n % );

　　return hexStr toUpperCase();

　　}

　　/**

　　* 提供一个MD 多次加密方法

　　*/

　　public static String getMD ofStr(String origString int times) {

　　String md = getMD ofStr(origString);

　　for (int i = ; i 《 times ; i++) {

　　md = getMD ofStr(md );

　　}

　　return getMD ofStr(md );

　　}

　　/**

　　* 密码验证方法

　　*/

　　public static boolean verifyPassword(String inputStr String MD Code) {

　　return getMD ofStr(inputStr) equals(MD Code);

　　}

　　/**

　　* 重载一个多次加密时的密码验证方法

　　*/

　　public static boolean verifyPassword(String inputStr String MD Code int times) {

　　return getMD ofStr(inputStr times) equals(MD Code);

　　}

　　/**

　　* 提供一个测试的主函数

　　*/

　　public static void main(String args) {

　　System out println( : + getMD ofStr( ));

　　System out println( : + getMD ofStr( ));

　　System out println( sarin: + getMD ofStr( sarin ));

　　System out println( : + getMD ofStr( ));

　　}

　　}

　　可以看出实现的过程非常简单 因为由java类库提供了处理支持 但是要清楚的是这种方式产生的密码不是标准的MD 码 它需要进行移位处理才能得到标准MD 码 这个程序的关键之处也在这了 怎么可变？调整移位算法不就可变了么！不进行移位 也能够得到 位的密码 这就不是标准加密了 只要加密和验证过程使用相同的算法就可以了

　　MD 加密还是很安全的 像CMD 那些穷举破解的只是针对标准MD 加密的结果进行的 如果自定义移位算法后 它还有效么？可以说是无解的了 所以MD 非常安全可靠

　　为了更可变 还提供了多次加密的方法 可以在MD 基础之上继续MD 就是对 位的第一次加密结果再MD 恩 这样去破解？没有任何意义

　　这样在MIS系统中使用 安全可靠 欢迎交流 希望对使用者有用

　　我们最后看看由MD 加密算法实现的类 那是非常庞大的

　　Java代码

　　import java lang reflect *;

　　/**

　　* **********************************************

　　* md 类实现了RSA Data Security Inc 在提交给IETF

　　* 的RFC 中的MD message digest 算法

　　* ***********************************************

　　*/

　　public class MD {

　　/* 下面这些S S 实际上是一个 * 的矩阵 在原始的C实现中是用#define 实现的

　　这里把它们实现成为static final是表示了只读 切能在同一个进程空间内的多个

　　Instance间共享*/

　　static final int S = ;

　　static final int S = ;

　　static final int S = ;

　　static final int S = ;

　　static final int S = ;

　　static final int S = ;

　　static final int S = ;

　　static final int S = ;

　　static final int S = ;

　　static final int S = ;

　　static final int S = ;

　　static final int S = ;

　　static final int S = ;

　　static final int S = ;

　　static final int S = ;

　　static final int S = ;

　　static final byte PADDING = {

　　 };

　　/* 下面的三个成员是MD 计算过程中用到的 个核心数据 在原始的C实现中

　　被定义到MD _CTX结构中

　　*/

　　private long; // state (ABCD)

　　private long; // number of bits modulo ^ (l *** first)

　　private byte; // input buffer

　　/* digestHexStr是MD 的唯一一个公共成员 是最新一次计算结果的

　　 进制ASCII表示

　　*/

　　public String digestHexStr;

　　/* digest 是最新一次计算结果的 进制内部表示 表示 bit的MD 值

　　*/

　　private byte;

　　/*

　　getMD ofStr是类MD 最主要的公共方法 入口参数是你想要进行MD 变换的字符串

　　返回的是变换完的结果 这个结果是从公共成员digestHexStr取得的．

　　*/

　　public String getMD ofStr(String inbuf) {

　　md Init();

　　md Update(inbuf getBytes() inbuf length());

　　md Final();

　　digestHexStr = ;

　　for (int i = ; i 《 ; i++) {

　　digestHexStr += byteHEX(digest);

　　}

　　return digestHexStr;

　　}

　　// 这是MD 这个类的标准构造函数 JavaBean要求有一个public的并且没有参数的构造函数

　　public MD () {

　　md Init();

　　return;

　　}

　　/* md Init是一个初始化函数 初始化核心变量 装入标准的幻数 */

　　private void md Init() {

　　count = L;

　　count = L;

　　///* Load magic initialization constants

　　state = x L;

　　state = xefcdab L;

　　state = x badcfeL;

　　state = x L;

　　return;

　　}

　　/* F G H I 是 个基本的MD 函数 在原始的MD 的C实现中 由于它们是

　　简单的位运算 可能出于效率的考虑把它们实现成了宏 在java中 我们把它们

　　实现成了private方法 名字保持了原来C中的 */

　　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));

　　}

　　/*

　　FF GG HH和II将调用F G H I进行近一步变换

　　FF GG HH and II transformations for rounds and

　　Rotation is separate from addition to prevent reputation

　　*/

　　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 》》》 ( 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 》》》 ( 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 》》》 ( 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 》》》 ( s));

　　a += b;

　　return a;

　　}

　　/*

　　md Update是MD 的主计算过程 inbuf是要变换的字节串 inputlen是长度 这个

　　函数由getMD ofStr调用 调用之前需要调用md init 因此把它设计成private的

　　*/

　　private void md Update(byte inbuf int inputLen) {

　　int i index partLen;

　　byte;

　　index = (int) (count 》》》 ) & x F;

　　// /* Update number of bits */

　　if ((count += (inputLen 《《 )) 《 (inputLen 《《 ))

　　count++;

　　count += (inputLen 》》》 );

　　partLen = index;

　　// Transform as many times as possible

　　if (inputLen 》= partLen) {

　　md Memcpy(buffer inbuf index partLen);

　　md Transform(buffer);

　　for (i = partLen; i + 《 inputLen; i += ) {

　　md Memcpy(block inbuf i );

　　md Transform(block);

　　}

　　index = ;

　　} else

　　i = ;

　　///* Buffer remaining input */

　　md Memcpy(buffer inbuf index i inputLen i);

　　}

　　/*

　　md Final整理和填写输出结果

　　*/

　　private void md Final() {

　　byte;

　　int index padLen;

　　///* Save number of bits */

　　Encode(bits count );

　　///* Pad out to mod

　　index = (int) (count 》》》 ) & x f;

　　padLen = (index 《 ) ? ( index) : ( index);

　　md Update(PADDING padLen);

　　///* Append length (before padding) */

　　md Update(bits );

　　///* Store state in digest */

　　Encode(digest state );

　　}

　　/* md Memcpy是一个内部使用的byte数组的块拷贝函数 从input的inpos开始把len长度的

　　字节拷贝到output的outpos位置开始

　　*/

　　private void md Memcpy(byte input int outpos int inpos int len) {

　　int i;

　　for (i = ; i 《 len; i++)

　　output;

　　}

　　/*

　　md Transform是MD 核心变换程序 有md Update调用 block是分块的原始字节

　　*/

　　private void md Transform(byte block) {

　　long a = state;

　　long;

　　Decode(x block );

　　/* Round */

　　a = FF(a b c d x S xd aa L); /* */

　　d = FF(d a b c x S xe c b L); /* */

　　c = FF(c d a b x S x dbL); /* */

　　b = FF(b c d a x S xc bdceeeL); /* */

　　a = FF(a b c d x S xf c fafL); /* */

　　d = FF(d a b c x S x c aL); /* */

　　c = FF(c d a b x S xa L); /* */

　　b = FF(b c d a x S xfd L); /* */

　　a = FF(a b c d x S x d L); /* */

　　d = FF(d a b c x S x b f afL); /* */

　　c = FF(c d a b x S xffff bb L); /* */

　　b = FF(b c d a x S x cd beL); /* */

　　a = FF(a b c d x S x b L); /* */

　　d = FF(d a b c x S xfd L); /* */

　　c = FF(c d a b x S xa eL); /* */

　　b = FF(b c d a x S x b L); /* */

　　/* Round */

　　a = GG(a b c d x S xf e L); /* */

　　d = GG(d a b c x S xc b L); /* */

　　c = GG(c d a b x S x e a L); /* */

　　b = GG(b c d a x S xe b c aaL); /* */

　　a = GG(a b c d x S xd f dL); /* */

　　d = GG(d a b c x S x L); /* */

　　c = GG(c d a b x S xd a e L); /* */

　　b = GG(b c d a x S xe d fbc L); /* */

　　a = GG(a b c d x S x e cde L); /* */

　　d = GG(d a b c x S xc d L); /* */

　　c = GG(c d a b x S xf d d L); /* */

　　b = GG(b c d a x S x a edL); /* */

　　a = GG(a b c d x S xa e e L); /* */

　　d = GG(d a b c x S xfcefa f L); /* */

　　c = GG(c d a b x S x f d L); /* */

　　b = GG(b c d a x S x d a c aL); /* */

　　/* Round */

　　a = HH(a b c d x S xfffa L); /* */

　　d = HH(d a b c x S x f L); /* */

　　c = HH(c d a b x S x d d L); /* */

　　b = HH(b c d a x S xfde cL); /* */

　　a = HH(a b c d x S xa beea L); /* */

　　d = HH(d a b c x S x bdecfa L); /* */

　　c = HH(c d a b x S xf bb b L); /* */

　　b = HH(b c d a x S xbebfbc L); /* */

　　a = HH(a b c d x S x b ec L); /* */

　　d = HH(d a b c x S xeaa faL); /* */

　　c = HH(c d a b x S xd ef L); /* */

　　b = HH(b c d a x S x d L); /* */

　　a = HH(a b c d x S xd d d L); /* */

　　d = HH(d a b c x S xe db e L); /* */

　　c = HH(c d a b x S x fa cf L); /* */

　　b = HH(b c d a x S xc ac L); /* */

　　/* Round */

　　a = II(a b c d x S xf L); /* */

　　d = II(d a b c x S x aff L); /* */

　　c = II(c d a b x S xab a L); /* */

　　b = II(b c d a x S xfc a L); /* */

　　a = II(a b c d x S x b c L); /* */

　　d = II(d a b c x S x f ccc L); /* */

　　c = II(c d a b x S xffeff dL); /* */

　　b = II(b c d a x S x dd L); /* */

　　a = II(a b c d x S x fa e fL); /* */

　　d = II(d a b c x S xfe ce e L); /* */

　　c = II(c d a b x S xa L); /* */

　　b = II(b c d a x S x e a L); /* */

　　a = II(a b c d x S xf e L); /* */

　　d = II(d a b c x S xbd af L); /* */

　　c = II(c d a b x S x ad d bbL); /* */

　　b = II(b c d a x S xeb d L); /* */

　　state += a;

　　state += b;

　　state += c;

　　state += d;

　　}

　　/*Encode把long数组按顺序拆成byte数组 因为java的long类型是 bit的

　　只拆低 bit 以适应原始C实现的用途

　　*/

　　private void Encode(byte input int len) {

　　int i j;

　　for (i = j = ; j 《 len; i++ j += ) {

　　output & xffL);

　　output 》》》 ) & xffL);

　　output 》》》 ) & xffL);

　　output 》》》 ) & xffL);

　　}

　　}

　　/*Decode把byte数组按顺序合成成long数组 因为java的long类型是 bit的

　　只合成低 bit 高 bit清零 以适应原始C实现的用途

　　*/

　　private void Decode(long input int len) {

　　int i j;

　　for (i = j = ; j 《 len; i++ j += )

　　output) 《《 )

　　| (b iu(input) 《《 );

　　return;

　　}

　　/*

　　b iu是我写的一个把byte按照不考虑正负号的原则的＂升位＂程序 因为java没有unsigned运算

　　*/

　　public static long b iu(byte b) {

　　return b 《 ? b & x F + : b;

　　}

　　/*byteHEX() 用来把一个byte类型的数转换成十六进制的ASCII表示

　　因为java中的byte的toString无法实现这一点 我们又没有C语言中的

　　sprintf(outbuf % X ib)

　　*/

　　public static String byteHEX(byte ib) {

　　char Digit = { A B C D E F };

　　char;

　　ob;

　　ob;

　　String s = new String(ob);

　　return s;

　　}

　　public static void main(String args) {

　　MD m = new MD ();

　　if (Array getLength(args) == ) { //如果没有参数 执行标准的Test Suite

　　System out println( MD Test suite: );

　　System out println( MD (\ \ ): + m getMD ofStr( ));

　　System out println( MD (\ a\ ): + m getMD ofStr( a ));

　　System out println( MD (\ abc\ ): + m getMD ofStr( abc ));

　　System out println( MD (\ \ ): + m getMD ofStr( ));

　　System out println( MD (\ \ ): + m getMD ofStr( ));

　　System out println( MD (\ message digest\ ): + m getMD ofStr( message digest ));

　　System out println( MD (\ abcdefghijklmnopqrstuvwxyz\ ): + m getMD ofStr( abcdefghijklmnopqrstuvwxyz ));

　　System out println( MD (\ ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz \ ):

　　+ m getMD ofStr( ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz ));

　　} else

　　System out println( MD ( + args));

　　}

ASP.NET实现对输入的密码用MD5+盐，并加密

public partial class _Default : System.Web.UI.Page
{
public bool IsMd5
{
get
{
//添加命名空间 using System.Configuration;
return ConfigurationManager.AppSettings == "1";
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (IsMd5)
{
//添加命名空间 using System.Web.Security;
string MD5 = FormsAuthentication.HashPasswordForStoringInConfigFile("被加密的字段", "MD5"); // SHA1 MD5
}
}
}
---------------------web.config----------------------------------
《appSettings》
《!--加密, 1:代表是; 0:代表不是--》
《add key="Md5" value="1"/》
《/appSettings》