现在的位置: 首页 > 综合 > 正文

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

2013年12月05日 ⁄ 综合 ⁄ 共 7799字 ⁄ 字号 小 中 大 ⁄ 评论关闭

哈希算法，常称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大写加密) 

 

 

返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞