UBOOT下命令行密码植入哈希算法加密

转载地址:https://blog.csdn.net/chris__x/article/details/7495982

哈希算法,常称MD5是一种单向散列函数,单向散列函数的作用是将任何长度的一段数据散列成固定长度。常用于生成消息认证码等等,可以与非对称算法一起用于数字签名。
MD5据说已经被国内一名教授破解,不知真假,即便真的如此,但足以满足UBOOT的可靠性需求了。

UBOOT命令行加密是比较简单的问题(main_loop()),但是如何确保看到的代码的人及LINUX系统管理员无法通过环境变量获取密码呢,加入哈希加密算法,也叫MD5算法,大大提高了UBOOT命令行的可靠性:

 

头文件md5.h

01

02

03

04

05

06

07

08

09

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

#ifndef MD5_H

#define MD5_H

  

typedefstruct

{

    unsignedintcount[2];

    unsignedintstate[4];

    unsignedcharbuffer[64];   

}MD5_CTX;

  

                          

#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 + ac; \

          a = ROTATE_LEFT(a,s); \

          a += b; \

          }

#define GG(a,b,c,d,x,s,ac) \

          { \

          a += G(b,c,d) + x + ac; \

          a = ROTATE_LEFT(a,s); \

          a += b; \

          }

#define HH(a,b,c,d,x,s,ac) \

          { \

          a += H(b,c,d) + x + ac; \

          a = ROTATE_LEFT(a,s); \

          a += b; \

          }

#define II(a,b,c,d,x,s,ac) \

          { \

          a += I(b,c,d) + x + ac; \

          a = ROTATE_LEFT(a,s); \

          a += b; \

          }                                            

voidMD5Init(MD5_CTX *context);

voidMD5Update(MD5_CTX *context,unsigned char*input,unsigned intinputlen);

voidMD5Final(MD5_CTX *context,unsigned chardigest[16]);

voidMD5Transform(unsigned intstate[4],unsigned charblock[64]);

voidMD5Encode(unsigned char*output,unsigned int*input,unsigned intlen);

voidMD5Decode(unsigned int*output,unsigned char*input,unsigned intlen);

  

#endif

 

C语言文件md5.c

001

002

003

004

005

006

007

008

009

010

011

012

013

014

015

016

017

018

019

020

021

022

023

024

025

026

027

028

029

030

031

032

033

034

035

036

037

038

039

040

041

042

043

044

045

046

047

048

049

050

051

052

053

054

055

056

057

058

059

060

061

062

063

064

065

066

067

068

069

070

071

072

073

074

075

076

077

078

079

080

081

082

083

084

085

086

087

088

089

090

091

092

093

094

095

096

097

098

099

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

#include <memory.h>

#include "md5.h"

  

unsigned charPADDING[]={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};

                          

voidMD5Init(MD5_CTX *context)

{

     context->count[0] = 0;

     context->count[1] = 0;

     context->state[0] = 0x67452301;

     context->state[1] = 0xEFCDAB89;

     context->state[2] = 0x98BADCFE;

     context->state[3] = 0x10325476;

}

voidMD5Update(MD5_CTX *context,unsigned char*input,unsigned intinputlen)

{

    unsignedinti = 0,index = 0,partlen = 0;

    index = (context->count[0] >> 3) & 0x3F;

    partlen = 64 - index;

    context->count[0] += inputlen << 3;

    if(context->count[0] < (inputlen << 3))

       context->count[1]++;

    context->count[1] += inputlen >> 29;

     

    if(inputlen >= partlen)

    {

       memcpy(&context->buffer[index],input,partlen);

       MD5Transform(context->state,context->buffer);

       for(i = partlen;i+64 <= inputlen;i+=64)

           MD5Transform(context->state,&input[i]);

       index = 0;        

    }  

    else

    {

        i = 0;

    }

    memcpy(&context->buffer[index],&input[i],inputlen-i);

}

voidMD5Final(MD5_CTX *context,unsigned chardigest[16])

{

    unsignedintindex = 0,padlen = 0;

    unsignedcharbits[8];

    index = (context->count[0] >> 3) & 0x3F;

    padlen = (index < 56)?(56-index):(120-index);

    MD5Encode(bits,context->count,8);

    MD5Update(context,PADDING,padlen);

    MD5Update(context,bits,8);

    MD5Encode(digest,context->state,16);

}

voidMD5Encode(unsigned char*output,unsigned int*input,unsigned intlen)

{

    unsignedinti = 0,j = 0;

    while(j < len)

    {

         output[j] = input[i] & 0xFF;  

         output[j+1] = (input[i] >> 8) & 0xFF;

         output[j+2] = (input[i] >> 16) & 0xFF;

         output[j+3] = (input[i] >> 24) & 0xFF;

         i++;

         j+=4;

    }

}

voidMD5Decode(unsigned int*output,unsigned char*input,unsigned intlen)

{

     unsignedinti = 0,j = 0;

     while(j < len)

     {

           output[i] = (input[j]) |

                       (input[j+1] << 8) |

                       (input[j+2] << 16) |

                       (input[j+3] << 24);

           i++;

           j+=4; 

     }

}

voidMD5Transform(unsigned intstate[4],unsigned charblock[64])

{

     unsignedinta = state[0];

     unsignedintb = state[1];

     unsignedintc = state[2];

     unsignedintd = state[3];

     unsignedintx[64];

     MD5Decode(x,block,64);

     FF(a, b, c, d, x[ 0], 7, 0xd76aa478);/* 1 */

 FF(d, a, b, c, x[ 1], 12, 0xe8c7b756);/* 2 */

 FF(c, d, a, b, x[ 2], 17, 0x242070db);/* 3 */

 FF(b, c, d, a, x[ 3], 22, 0xc1bdceee);/* 4 */

 FF(a, b, c, d, x[ 4], 7, 0xf57c0faf);/* 5 */

 FF(d, a, b, c, x[ 5], 12, 0x4787c62a);/* 6 */

 FF(c, d, a, b, x[ 6], 17, 0xa8304613);/* 7 */

 FF(b, c, d, a, x[ 7], 22, 0xfd469501);/* 8 */

 FF(a, b, c, d, x[ 8], 7, 0x698098d8);/* 9 */

 FF(d, a, b, c, x[ 9], 12, 0x8b44f7af);/* 10 */

 FF(c, d, a, b, x[10], 17, 0xffff5bb1);/* 11 */

 FF(b, c, d, a, x[11], 22, 0x895cd7be);/* 12 */

 FF(a, b, c, d, x[12], 7, 0x6b901122);/* 13 */

 FF(d, a, b, c, x[13], 12, 0xfd987193);/* 14 */

 FF(c, d, a, b, x[14], 17, 0xa679438e);/* 15 */

 FF(b, c, d, a, x[15], 22, 0x49b40821);/* 16 */

  

 /* Round 2 */

 GG(a, b, c, d, x[ 1], 5, 0xf61e2562);/* 17 */

 GG(d, a, b, c, x[ 6], 9, 0xc040b340);/* 18 */

 GG(c, d, a, b, x[11], 14, 0x265e5a51);/* 19 */

 GG(b, c, d, a, x[ 0], 20, 0xe9b6c7aa);/* 20 */

 GG(a, b, c, d, x[ 5], 5, 0xd62f105d);/* 21 */

 GG(d, a, b, c, x[10], 9,  0x2441453);/* 22 */

 GG(c, d, a, b, x[15], 14, 0xd8a1e681);/* 23 */

 GG(b, c, d, a, x[ 4], 20, 0xe7d3fbc8);/* 24 */

 GG(a, b, c, d, x[ 9], 5, 0x21e1cde6);/* 25 */

 GG(d, a, b, c, x[14], 9, 0xc33707d6);/* 26 */

 GG(c, d, a, b, x[ 3], 14, 0xf4d50d87);/* 27 */

 GG(b, c, d, a, x[ 8], 20, 0x455a14ed);/* 28 */

 GG(a, b, c, d, x[13], 5, 0xa9e3e905);/* 29 */

 GG(d, a, b, c, x[ 2], 9, 0xfcefa3f8);/* 30 */

 GG(c, d, a, b, x[ 7], 14, 0x676f02d9);/* 31 */

 GG(b, c, d, a, x[12], 20, 0x8d2a4c8a);/* 32 */

  

 /* Round 3 */

 HH(a, b, c, d, x[ 5], 4, 0xfffa3942);/* 33 */

 HH(d, a, b, c, x[ 8], 11, 0x8771f681);/* 34 */

 HH(c, d, a, b, x[11], 16, 0x6d9d6122);/* 35 */

 HH(b, c, d, a, x[14], 23, 0xfde5380c);/* 36 */

 HH(a, b, c, d, x[ 1], 4, 0xa4beea44);/* 37 */

 HH(d, a, b, c, x[ 4], 11, 0x4bdecfa9);/* 38 */

 HH(c, d, a, b, x[ 7], 16, 0xf6bb4b60);/* 39 */

 HH(b, c, d, a, x[10], 23, 0xbebfbc70);/* 40 */

 HH(a, b, c, d, x[13], 4, 0x289b7ec6);/* 41 */

 HH(d, a, b, c, x[ 0], 11, 0xeaa127fa);/* 42 */

 HH(c, d, a, b, x[ 3], 16, 0xd4ef3085);/* 43 */

 HH(b, c, d, a, x[ 6], 23,  0x4881d05);/* 44 */

 HH(a, b, c, d, x[ 9], 4, 0xd9d4d039);/* 45 */

 HH(d, a, b, c, x[12], 11, 0xe6db99e5);/* 46 */

 HH(c, d, a, b, x[15], 16, 0x1fa27cf8);/* 47 */

 HH(b, c, d, a, x[ 2], 23, 0xc4ac5665);/* 48 */

  

 /* Round 4 */

 II(a, b, c, d, x[ 0], 6, 0xf4292244);/* 49 */

 II(d, a, b, c, x[ 7], 10, 0x432aff97);/* 50 */

 II(c, d, a, b, x[14], 15, 0xab9423a7);/* 51 */

 II(b, c, d, a, x[ 5], 21, 0xfc93a039);/* 52 */

 II(a, b, c, d, x[12], 6, 0x655b59c3);/* 53 */

 II(d, a, b, c, x[ 3], 10, 0x8f0ccc92);/* 54 */

 II(c, d, a, b, x[10], 15, 0xffeff47d);/* 55 */

 II(b, c, d, a, x[ 1], 21, 0x85845dd1);/* 56 */

 II(a, b, c, d, x[ 8], 6, 0x6fa87e4f);/* 57 */

 II(d, a, b, c, x[15], 10, 0xfe2ce6e0);/* 58 */

 II(c, d, a, b, x[ 6], 15, 0xa3014314);/* 59 */

 II(b, c, d, a, x[13], 21, 0x4e0811a1);/* 60 */

 II(a, b, c, d, x[ 4], 6, 0xf7537e82);/* 61 */

 II(d, a, b, c, x[11], 10, 0xbd3af235);/* 62 */

 II(c, d, a, b, x[ 2], 15, 0x2ad7d2bb);/* 63 */

 II(b, c, d, a, x[ 9], 21, 0xeb86d391);/* 64 */

     state[0] += a;

     state[1] += b;

     state[2] += c;

     state[3] += d;

}

md5函数测试代码文件

01

02

03

04

05

06

07

08

09

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

#include <stdio.h>

#include <stdlib.h>

#include "md5.h"

  

intmain(intargc, char*argv[])

{

 MD5_CTX md5;

 MD5Init(&md5);         

 inti;

 unsignedcharencrypt[] ="admin";//21232f297a57a5a743894a0e4a801fc3

 unsignedchardecrypt[16];    

 MD5Update(&md5,encrypt,strlen((char*)encrypt));

 MD5Final(&md5,decrypt);        

 printf("加密前:%s\n加密后:",encrypt);

 for(i=0;i<16;i++)

 {

  printf("%02x",decrypt[i]);

 }

  

 getchar();

  

 return0;

}

 

MD5加密常用字符

7a57a5a743894a0e admin(16位MD5小写加密)
972130B75066C825 ADMIN(16位MD5大写加密)
21232f297a57a5a743894a0e4a801fc3 admin(32位MD5小写加密)
73ACD9A5972130B75066C82595A1FAE3 ADMIN(32位MD5大写加密)
49ba59abbe56e057 123456(16位MD5小写加密)
e10adc3949ba59abbe56e057f20f883e 123456(32位MD5小写加密)
469e80d32c0559f8 admin888(16位MD5小写加密)
2299413865C28A35 ADMIN888(16位MD5大写加密)
7fef6171469e80d32c0559f88b377245 admin888(32位MD5小写加密)
A1F63A962299413865C28A3593D359B0 ADMIN888(32位MD5大写加密) 

——————— 本文来自 chris_xi 的CSDN 博客 ,全文地址请点击:https://blog.csdn.net/chris__x/article/details/7495982?utm_source=copy

    原文作者:哈希算法
    原文地址: https://blog.csdn.net/kunkliu/article/details/82860747
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞