액션스크립트 암호화 md5 등등 관련

ADOBE/ ActionScript

by AlrepondTech 2014. 10. 1. 15:19

=================================

출처: https://code.google.com/p/as3corelib/source/browse/trunk/src/com/adobe/crypto/MD5.as?r=49

1
2
3
4
5
6
7
8
9
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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
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
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273

/*

Adobe Systems Incorporated(r) Source Code License Agreement

Copyright(c) 2005 Adobe Systems Incorporated. All rights reserved.

Please read this Source Code License Agreement carefully before using

the source code.

Adobe Systems Incorporated grants to you a perpetual, worldwide, non-exclusive,

no-charge, royalty-free, irrevocable copyright license, to reproduce,

prepare derivative works of, publicly display, publicly perform, and

distribute this source code and such derivative works in source or

object code form without any attribution requirements.

The name "Adobe Systems Incorporated" must not be used to endorse or promote products

derived from the source code without prior written permission.

You agree to indemnify, hold harmless and defend Adobe Systems Incorporated from and

against any loss, damage, claims or lawsuits, including attorney's

fees that arise or result from your use or distribution of the source

code.

THIS SOURCE CODE IS PROVIDED "AS IS" AND "WITH ALL FAULTS", WITHOUT

ANY TECHNICAL SUPPORT OR ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING,

BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

FOR A PARTICULAR PURPOSE ARE DISCLAIMED. ALSO, THERE IS NO WARRANTY OF

NON-INFRINGEMENT, TITLE OR QUIET ENJOYMENT. IN NO EVENT SHALL MACROMEDIA

OR ITS SUPPLIERS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;

OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,

WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR

OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOURCE CODE, EVEN IF

ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

package com.adobe.crypto {

        import com.adobe.utils.IntUtil;

        import flash.utils.ByteArray;   

/**

         * The MD5 Message-Digest Algorithm

*

         * Implementation based on algorithm description at 

         * http://www.faqs.org/rfcs/rfc1321.html

*/

        public class MD5 {

/**

                 * Performs the MD5 hash algorithm on a string.

*

                 * @param s The string to hash

                 * @return A string containing the hash value of s

                 * @langversion ActionScript 3.0

                 * @playerversion Flash 8.5

                 * @tiptext

*/

                public static function hash(s:String) :String{

                        //Convert to byteArray and send through hashBinary function

                        // so as to only have complex code in one location

                        var ba:ByteArray = new ByteArray();

                        ba.writeUTFBytes(s);    

                        return hashBinary(ba);

}

/**

                 * Performs the MD5 hash algorithm on a ByteArray.

*

                 * @param s The string to hash

                 * @return A string containing the hash value of s

                 * @langversion ActionScript 3.0

                 * @playerversion Flash 8.5

                 * @tiptext

*/

                public static function hashBinary( s:ByteArray ):String {

                        // initialize the md buffers

                        var a:int = 1732584193;

                        var b:int = -271733879;

                        var c:int = -1732584194;

                        var d:int = 271733878;

                        // variables to store previous values

                        var aa:int;

                        var bb:int;

                        var cc:int;

                        var dd:int;

                        // create the blocks from the string and

                        // save the length as a local var to reduce

                        // lookup in the loop below

                        var x:Array = createBlocks( s );

                        var len:int = x.length;

                        // loop over all of the blocks

                        for ( var i:int = 0; i < len; i += 16) {

                                // save previous values

                                aa = a;

                                bb = b;

                                cc = c;

                                dd = d;                         

                                // Round 1

                                a = ff( a, b, c, d, x[i+ 0],  7, -680876936 );  // 1

                                d = ff( d, a, b, c, x[i+ 1], 12, -389564586 );  // 2

                                c = ff( c, d, a, b, x[i+ 2], 17, 606105819 );   // 3

                                b = ff( b, c, d, a, x[i+ 3], 22, -1044525330 ); // 4

                                a = ff( a, b, c, d, x[i+ 4],  7, -176418897 );  // 5

                                d = ff( d, a, b, c, x[i+ 5], 12, 1200080426 );  // 6

                                c = ff( c, d, a, b, x[i+ 6], 17, -1473231341 ); // 7

                                b = ff( b, c, d, a, x[i+ 7], 22, -45705983 );   // 8

                                a = ff( a, b, c, d, x[i+ 8],  7, 1770035416 );  // 9

                                d = ff( d, a, b, c, x[i+ 9], 12, -1958414417 ); // 10

                                c = ff( c, d, a, b, x[i+10], 17, -42063 );              // 11

                                b = ff( b, c, d, a, x[i+11], 22, -1990404162 ); // 12

                                a = ff( a, b, c, d, x[i+12],  7, 1804603682 );  // 13

                                d = ff( d, a, b, c, x[i+13], 12, -40341101 );   // 14

                                c = ff( c, d, a, b, x[i+14], 17, -1502002290 ); // 15

                                b = ff( b, c, d, a, x[i+15], 22, 1236535329 );  // 16

                                // Round 2

                                a = gg( a, b, c, d, x[i+ 1],  5, -165796510 );  // 17

                                d = gg( d, a, b, c, x[i+ 6],  9, -1069501632 ); // 18

                                c = gg( c, d, a, b, x[i+11], 14, 643717713 );   // 19

                                b = gg( b, c, d, a, x[i+ 0], 20, -373897302 );  // 20

                                a = gg( a, b, c, d, x[i+ 5],  5, -701558691 );  // 21

                                d = gg( d, a, b, c, x[i+10],  9, 38016083 );    // 22

                                c = gg( c, d, a, b, x[i+15], 14, -660478335 );  // 23

                                b = gg( b, c, d, a, x[i+ 4], 20, -405537848 );  // 24

                                a = gg( a, b, c, d, x[i+ 9],  5, 568446438 );   // 25

                                d = gg( d, a, b, c, x[i+14],  9, -1019803690 ); // 26

                                c = gg( c, d, a, b, x[i+ 3], 14, -187363961 );  // 27

                                b = gg( b, c, d, a, x[i+ 8], 20, 1163531501 );  // 28

                                a = gg( a, b, c, d, x[i+13],  5, -1444681467 ); // 29

                                d = gg( d, a, b, c, x[i+ 2],  9, -51403784 );   // 30

                                c = gg( c, d, a, b, x[i+ 7], 14, 1735328473 );  // 31

                                b = gg( b, c, d, a, x[i+12], 20, -1926607734 ); // 32

                                // Round 3

                                a = hh( a, b, c, d, x[i+ 5],  4, -378558 );     // 33

                                d = hh( d, a, b, c, x[i+ 8], 11, -2022574463 ); // 34

                                c = hh( c, d, a, b, x[i+11], 16, 1839030562 );  // 35

                                b = hh( b, c, d, a, x[i+14], 23, -35309556 );   // 36

                                a = hh( a, b, c, d, x[i+ 1],  4, -1530992060 ); // 37

                                d = hh( d, a, b, c, x[i+ 4], 11, 1272893353 );  // 38

                                c = hh( c, d, a, b, x[i+ 7], 16, -155497632 );  // 39

                                b = hh( b, c, d, a, x[i+10], 23, -1094730640 ); // 40

                                a = hh( a, b, c, d, x[i+13],  4, 681279174 );   // 41

                                d = hh( d, a, b, c, x[i+ 0], 11, -358537222 );  // 42

                                c = hh( c, d, a, b, x[i+ 3], 16, -722521979 );  // 43

                                b = hh( b, c, d, a, x[i+ 6], 23, 76029189 );    // 44

                                a = hh( a, b, c, d, x[i+ 9],  4, -640364487 );  // 45

                                d = hh( d, a, b, c, x[i+12], 11, -421815835 );  // 46

                                c = hh( c, d, a, b, x[i+15], 16, 530742520 );   // 47

                                b = hh( b, c, d, a, x[i+ 2], 23, -995338651 );  // 48

                                // Round 4

                                a = ii( a, b, c, d, x[i+ 0],  6, -198630844 );  // 49

                                d = ii( d, a, b, c, x[i+ 7], 10, 1126891415 );  // 50

                                c = ii( c, d, a, b, x[i+14], 15, -1416354905 ); // 51

                                b = ii( b, c, d, a, x[i+ 5], 21, -57434055 );   // 52

                                a = ii( a, b, c, d, x[i+12],  6, 1700485571 );  // 53

                                d = ii( d, a, b, c, x[i+ 3], 10, -1894986606 ); // 54

                                c = ii( c, d, a, b, x[i+10], 15, -1051523 );    // 55

                                b = ii( b, c, d, a, x[i+ 1], 21, -2054922799 ); // 56

                                a = ii( a, b, c, d, x[i+ 8],  6, 1873313359 );  // 57

                                d = ii( d, a, b, c, x[i+15], 10, -30611744 );   // 58

                                c = ii( c, d, a, b, x[i+ 6], 15, -1560198380 ); // 59

                                b = ii( b, c, d, a, x[i+13], 21, 1309151649 );  // 60

                                a = ii( a, b, c, d, x[i+ 4],  6, -145523070 );  // 61

                                d = ii( d, a, b, c, x[i+11], 10, -1120210379 ); // 62

                                c = ii( c, d, a, b, x[i+ 2], 15, 718787259 );   // 63

                                b = ii( b, c, d, a, x[i+ 9], 21, -343485551 );  // 64

                                a += aa;

                                b += bb;

                                c += cc;

                                d += dd;

}

                        // Finish up by concatening the buffers with their hex output

                        return IntUtil.toHex( a ) + IntUtil.toHex( b ) + IntUtil.toHex( c ) + IntUtil.toHex( d );

}

/**

                 * Auxiliary function f as defined in RFC

*/

                private static function f( x:int, y:int, z:int ):int {

                        return ( x & y ) | ( (~x) & z );

}

/**

                 * Auxiliary function g as defined in RFC

*/

                private static function g( x:int, y:int, z:int ):int {

                        return ( x & z ) | ( y & (~z) );

}

/**

                 * Auxiliary function h as defined in RFC

*/

                private static function h( x:int, y:int, z:int ):int {

                        return x ^ y ^ z;

}

/**

                 * Auxiliary function i as defined in RFC

*/

                private static function i( x:int, y:int, z:int ):int {

                        return y ^ ( x | (~z) );

}

/**

                 * A generic transformation function.  The logic of ff, gg, hh, and

                 * ii are all the same, minus the function used, so pull that logic

                 * out and simplify the method bodies for the transoformation functions.

*/

                private static function transform( func:Function, a:int, b:int, c:int, d:int, x:int, s:int, t:int):int {

                        var tmp:int = a + int( func( b, c, d ) ) + x + t;

                        return IntUtil.rol( tmp, s ) +  b;

}

/**

                 * ff transformation function

*/

                private static function ff ( a:int, b:int, c:int, d:int, x:int, s:int, t:int ):int {

                        return transform( f, a, b, c, d, x, s, t );

}

/**

                 * gg transformation function

*/

                private static function gg ( a:int, b:int, c:int, d:int, x:int, s:int, t:int ):int {

                        return transform( g, a, b, c, d, x, s, t );

}

/**

                 * hh transformation function

*/

                private static function hh ( a:int, b:int, c:int, d:int, x:int, s:int, t:int ):int {

                        return transform( h, a, b, c, d, x, s, t );

}

/**

                 * ii transformation function

*/

                private static function ii ( a:int, b:int, c:int, d:int, x:int, s:int, t:int ):int {

                        return transform( i, a, b, c, d, x, s, t );

}

/**

                 * Converts a string to a sequence of 16-word blocks

                 * that we'll do the processing on.  Appends padding

                 * and length in the process.

*

                 * @param s The string to split into blocks

                 * @return An array containing the blocks that s was

                 *                      split into.

*/

                private static function createBlocks( s:ByteArray ):Array {

                        var blocks:Array = new Array();

                        var len:int = s.length * 8;

                        var mask:int = 0xFF; // ignore hi byte of characters > 0xFF

                        for( var i:int = 0; i < len; i += 8 ) {

                                blocks[ i >> 5 ] |= ( s[ i / 8 ] & mask ) << ( i % 32 );

}

                        // append padding and length

                        blocks[ len >> 5 ] |= 0x80 << ( len % 32 );

                        blocks[ ( ( ( len + 64 ) >>> 9 ) << 4 ) + 14 ] = len;

                        return blocks;

}

}

}

Hide details

Change log

r49 by mikechambers on Jul 6, 2008 Diff

adding patch from marklynch to add support for hashing binary data, as well as slight performance tweek. Issue # http://code.goo gle.com/p/as3corelib/issues/detail?id=45

Go to:

Older revisions

r24 by mikechambers on Feb 21, 2007 Diff

r2 by darron.schall on Dec 20, 2006 Diff

All revisions of this file

File info

Size: 9945 bytes, 273 lines

View raw file

추가

추가링크: http://garry-lachman.com/2010/12/11/md5-crypto-class-actionscript-3/

=================================

출처: http://www.kirupa.com/forum/showthread.php?295966-MD5-in-AS3-0

public class MD5 {         /* Notes:          * A conversion of the JavaScript implementation of the RSA Data Security, Inc. MD5 Message          * Digest Algorithm, as defined in RFC 1321.          *           * Original javascript:          * Version 2.2-alpha Copyright (C) Paul Johnston 1999 - 2005          * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet          * Distributed under the BSD License          * See http://pajhome.org.uk/crypt/md5 for more info.                    *           *           * Flash:          * Converted to AS3 By Geoffrey Williams          */                                /*          * Usage:  Create an MD5 Object, then run encrypt() method on your string.          */                  public static const HEX_FORMAT_LOWERCASE:uint = 0;         public static const HEX_FORMAT_UPPERCASE:uint = 1;                   public static const BASE64_PAD_CHARACTER_DEFAULT_COMPLIANCE:String = "";         public static const BASE64_PAD_CHARACTER_RFC_COMPLIANCE:String = "=";                   public static var hexcase:uint = 0;   /* hex output format. 0 - lowercase; 1 - uppercase        */         public static var b64pad:String  = ""; /* base-64 pad character. "=" for strict RFC compliance   */                  /*          * This is the main function for MD5 encryption          *           */                  public  function encrypt (string:String):String {             return hex_md5 (string);         }                  /*          *           * Behind-the-scenes functions          *           */          public static function hex_md5 (string:String):String {             return rstr2hex (rstr_md5 (str2rstr_utf8 (string)));         }                  public static function b64_md5 (string:String):String {             return rstr2b64 (rstr_md5 (str2rstr_utf8 (string)));         }                  public static function any_md5 (string:String, encoding:String):String {             return rstr2any (rstr_md5 (str2rstr_utf8 (string)), encoding);         }         public static function hex_hmac_md5 (key:String, data:String):String {             return rstr2hex (rstr_hmac_md5 (str2rstr_utf8 (key), str2rstr_utf8 (data)));         }         public static function b64_hmac_md5 (key:String, data:String):String {             return rstr2b64 (rstr_hmac_md5 (str2rstr_utf8 (key), str2rstr_utf8 (data)));         }         public static function any_hmac_md5 (key:String, data:String, encoding:String):String {             return rstr2any(rstr_hmac_md5(str2rstr_utf8(key), str2rstr_utf8(data)), encoding);         }                  /*          * Perform a simple self-test to see if the VM is working          */         public static function md5_vm_test ():Boolean {           return hex_md5 ("abc") == "900150983cd24fb0d6963f7d28e17f72";         }                  /*          * Calculate the MD5 of a raw string          */         public static function rstr_md5 (string:String):String {           return binl2rstr (binl_md5 (rstr2binl (string), string.length * 8));         }                  /*          * Calculate the HMAC-MD5, of a key and some data (raw strings)          */         public static function rstr_hmac_md5 (key:String, data:String):String {           var bkey:Array = rstr2binl (key);           if (bkey.length > 16) bkey = binl_md5 (bkey, key.length * 8);                    var ipad:Array = new Array(16), opad:Array = new Array(16);           for(var i:Number = 0; i < 16; i++) {             ipad[i] = bkey[i] ^ 0x36363636;             opad[i] = bkey[i] ^ 0x5C5C5C5C;           }                    var hash:Array = binl_md5 (ipad.concat (rstr2binl (data)), 512 + data.length * 8);           return binl2rstr (binl_md5 (opad.concat (hash), 512 + 128));         }                  /*          * Convert a raw string to a hex string          */         public static function rstr2hex (input:String):String {           var hex_tab:String = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";           var output:String = "";           var x:Number;           for(var i:Number = 0; i < input.length; i++) {               x = input.charCodeAt(i);             output += hex_tab.charAt((x >>> 4) & 0x0F)                    +  hex_tab.charAt( x        & 0x0F);           }           return output;         }                  /*          * Convert a raw string to a base-64 string          */         public static function rstr2b64 (input:String):String {           var tab:String = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";           var output:String = "";           var len:Number = input.length;           for(var i:Number = 0; i < len; i += 3) {             var triplet:Number = (input.charCodeAt(i) << 16)                         | (i + 1 < len ? input.charCodeAt(i+1) << 8 : 0)                         | (i + 2 < len ? input.charCodeAt(i+2)      : 0);             for(var j:Number = 0; j < 4; j++) {               if(i * 8 + j * 6 > input.length * 8) output += b64pad;               else output += tab.charAt((triplet >>> 6*(3-j)) & 0x3F);             }           }           return output;         }                  /*          * Convert a raw string to an arbitrary string encoding          */         public static function rstr2any(input:String, encoding:String):String {           var divisor:Number = encoding.length;           var remainders:Array = [];           var i:Number, q:Number, x:Number, quotient:Array;                    /* Convert to an array of 16-bit big-endian values, forming the dividend */           var dividend:Array = new Array(input.length / 2);           for(i = 0; i < dividend.length; i++) {             dividend[i] = (input.charCodeAt(i * 2) << 8) | input.charCodeAt(i * 2 + 1);           }                    /*            * Repeatedly perform a long division. The binary array forms the dividend,            * the length of the encoding is the divisor. Once computed, the quotient            * forms the dividend for the next step. We stop when the dividend is zero.            * All remainders are stored for later use.            */           while(dividend.length > 0) {             quotient = [];             x = 0;             for(i = 0; i < dividend.length; i++) {               x = (x << 16) + dividend[i];               q = Math.floor(x / divisor);               x -= q * divisor;               if(quotient.length > 0 || q > 0)                 quotient[quotient.length] = q;             }             remainders[remainders.length] = x;             dividend = quotient;           }                    /* Convert the remainders to the output string */           var output:String = "";           for(i = remainders.length - 1; i >= 0; i--)             output += encoding.charAt (remainders[i]);                    return output;         }                  /*          * Encode a string as utf-8.          * For efficiency, this assumes the input is valid utf-16.          */         public static function str2rstr_utf8 (input:String):String {           var output:String = "";           var i:Number = -1;           var x:Number, y:Number;                    while(++i < input.length) {             /* Decode utf-16 surrogate pairs */             x = input.charCodeAt(i);             y = i + 1 < input.length ? input.charCodeAt(i + 1) : 0;             if(0xD800 <= x && x <= 0xDBFF && 0xDC00 <= y && y <= 0xDFFF) {               x = 0x10000 + ((x & 0x03FF) << 10) + (y & 0x03FF);               i++;             }                      /* Encode output as utf-8 */             if(x <= 0x7F)               output += String.fromCharCode(x);             else if(x <= 0x7FF)               output += String.fromCharCode(0xC0 | ((x >>> 6 ) & 0x1F),                                             0x80 | ( x         & 0x3F));             else if(x <= 0xFFFF)               output += String.fromCharCode(0xE0 | ((x >>> 12) & 0x0F),                                             0x80 | ((x >>> 6 ) & 0x3F),                                             0x80 | ( x         & 0x3F));             else if(x <= 0x1FFFFF)               output += String.fromCharCode(0xF0 | ((x >>> 18) & 0x07),                                             0x80 | ((x >>> 12) & 0x3F),                                             0x80 | ((x >>> 6 ) & 0x3F),                                             0x80 | ( x         & 0x3F));           }           return output;         }                  /*          * Encode a string as utf-16          */         public static function str2rstr_utf16le (input:String):String {           var output:String = "";           for(var i:Number = 0; i < input.length; i++)             output += String.fromCharCode( input.charCodeAt(i)        & 0xFF,                                           (input.charCodeAt(i) >>> 8) & 0xFF);           return output;         }                  public static function str2rstr_utf16be (input:String):String {           var output:String = "";           for(var i:Number = 0; i < input.length; i++)             output += String.fromCharCode((input.charCodeAt(i) >>> 8) & 0xFF,                                            input.charCodeAt(i)        & 0xFF);           return output;         }                  /*          * Convert a raw string to an array of little-endian words          * Characters >255 have their high-byte silently ignored.          */         public static function rstr2binl (input:String):Array {             var i:Number=0;           var output:Array = new Array(input.length >> 2);           for(i = 0; i < output.length; i++)    output[i] = 0;           for(i = 0; i < input.length * 8; i += 8)    output[i>>5] |= (input.charCodeAt(i / 8) & 0xFF) << (i%32);           return output;         }                  /*          * Convert an array of little-endian words to a string          */         public static function binl2rstr (input:Array):String {           var output:String = "";           for(var i:Number = 0; i < input.length * 32; i += 8)             output += String.fromCharCode((input[i>>5] >>> (i % 32)) & 0xFF);           return output;         }                  /*          * Calculate the MD5 of an array of little-endian words, and a bit length.          */         public static function binl_md5 (x:Array, len:Number):Array {           /* append padding */           x[len >> 5] |= 0x80 << ((len) % 32);           x[(((len + 64) >>> 9) << 4) + 14] = len;                    var a:Number =  1732584193;           var b:Number = -271733879;           var c:Number = -1732584194;           var d:Number =  271733878;                    for(var i:Number = 0; i < x.length; i += 16) {             var olda:Number = a;             var oldb:Number = b;             var oldc:Number = c;             var oldd:Number = d;                      a = md5_ff(a, b, c, d, x[i+ 0], 7 , -680876936);             d = md5_ff(d, a, b, c, x[i+ 1], 12, -389564586);             c = md5_ff(c, d, a, b, x[i+ 2], 17,  606105819);             b = md5_ff(b, c, d, a, x[i+ 3], 22, -1044525330);             a = md5_ff(a, b, c, d, x[i+ 4], 7 , -176418897);             d = md5_ff(d, a, b, c, x[i+ 5], 12,  1200080426);             c = md5_ff(c, d, a, b, x[i+ 6], 17, -1473231341);             b = md5_ff(b, c, d, a, x[i+ 7], 22, -45705983);             a = md5_ff(a, b, c, d, x[i+ 8], 7 ,  1770035416);             d = md5_ff(d, a, b, c, x[i+ 9], 12, -1958414417);             c = md5_ff(c, d, a, b, x[i+10], 17, -42063);             b = md5_ff(b, c, d, a, x[i+11], 22, -1990404162);             a = md5_ff(a, b, c, d, x[i+12], 7 ,  1804603682);             d = md5_ff(d, a, b, c, x[i+13], 12, -40341101);             c = md5_ff(c, d, a, b, x[i+14], 17, -1502002290);             b = md5_ff(b, c, d, a, x[i+15], 22,  1236535329);                      a = md5_gg(a, b, c, d, x[i+ 1], 5 , -165796510);             d = md5_gg(d, a, b, c, x[i+ 6], 9 , -1069501632);             c = md5_gg(c, d, a, b, x[i+11], 14,  643717713);             b = md5_gg(b, c, d, a, x[i+ 0], 20, -373897302);             a = md5_gg(a, b, c, d, x[i+ 5], 5 , -701558691);             d = md5_gg(d, a, b, c, x[i+10], 9 ,  38016083);             c = md5_gg(c, d, a, b, x[i+15], 14, -660478335);             b = md5_gg(b, c, d, a, x[i+ 4], 20, -405537848);             a = md5_gg(a, b, c, d, x[i+ 9], 5 ,  568446438);             d = md5_gg(d, a, b, c, x[i+14], 9 , -1019803690);             c = md5_gg(c, d, a, b, x[i+ 3], 14, -187363961);             b = md5_gg(b, c, d, a, x[i+ 8], 20,  1163531501);             a = md5_gg(a, b, c, d, x[i+13], 5 , -1444681467);             d = md5_gg(d, a, b, c, x[i+ 2], 9 , -51403784);             c = md5_gg(c, d, a, b, x[i+ 7], 14,  1735328473);             b = md5_gg(b, c, d, a, x[i+12], 20, -1926607734);                      a = md5_hh(a, b, c, d, x[i+ 5], 4 , -378558);             d = md5_hh(d, a, b, c, x[i+ 8], 11, -2022574463);             c = md5_hh(c, d, a, b, x[i+11], 16,  1839030562);             b = md5_hh(b, c, d, a, x[i+14], 23, -35309556);             a = md5_hh(a, b, c, d, x[i+ 1], 4 , -1530992060);             d = md5_hh(d, a, b, c, x[i+ 4], 11,  1272893353);             c = md5_hh(c, d, a, b, x[i+ 7], 16, -155497632);             b = md5_hh(b, c, d, a, x[i+10], 23, -1094730640);             a = md5_hh(a, b, c, d, x[i+13], 4 ,  681279174);             d = md5_hh(d, a, b, c, x[i+ 0], 11, -358537222);             c = md5_hh(c, d, a, b, x[i+ 3], 16, -722521979);             b = md5_hh(b, c, d, a, x[i+ 6], 23,  76029189);             a = md5_hh(a, b, c, d, x[i+ 9], 4 , -640364487);             d = md5_hh(d, a, b, c, x[i+12], 11, -421815835);             c = md5_hh(c, d, a, b, x[i+15], 16,  530742520);             b = md5_hh(b, c, d, a, x[i+ 2], 23, -995338651);                      a = md5_ii(a, b, c, d, x[i+ 0], 6 , -198630844);             d = md5_ii(d, a, b, c, x[i+ 7], 10,  1126891415);             c = md5_ii(c, d, a, b, x[i+14], 15, -1416354905);             b = md5_ii(b, c, d, a, x[i+ 5], 21, -57434055);             a = md5_ii(a, b, c, d, x[i+12], 6 ,  1700485571);             d = md5_ii(d, a, b, c, x[i+ 3], 10, -1894986606);             c = md5_ii(c, d, a, b, x[i+10], 15, -1051523);             b = md5_ii(b, c, d, a, x[i+ 1], 21, -2054922799);             a = md5_ii(a, b, c, d, x[i+ 8], 6 ,  1873313359);             d = md5_ii(d, a, b, c, x[i+15], 10, -30611744);             c = md5_ii(c, d, a, b, x[i+ 6], 15, -1560198380);             b = md5_ii(b, c, d, a, x[i+13], 21,  1309151649);             a = md5_ii(a, b, c, d, x[i+ 4], 6 , -145523070);             d = md5_ii(d, a, b, c, x[i+11], 10, -1120210379);             c = md5_ii(c, d, a, b, x[i+ 2], 15,  718787259);             b = md5_ii(b, c, d, a, x[i+ 9], 21, -343485551);                      a = safe_add(a, olda);             b = safe_add(b, oldb);             c = safe_add(c, oldc);             d = safe_add(d, oldd);           }           return [a, b, c, d];         }                  /*          * These functions implement the four basic operations the algorithm uses.          */         public static function md5_cmn (q:Number, a:Number, b:Number, x:Number, s:Number, t:Number):Number {           return safe_add (bit_rol (safe_add (safe_add (a, q), safe_add(x, t)), s), b);         }         public static function md5_ff (a:Number, b:Number, c:Number, d:Number, x:Number, s:Number, t:Number):Number {           return md5_cmn ((b & c) | ((~b) & d), a, b, x, s, t);         }         public static function md5_gg (a:Number, b:Number, c:Number, d:Number, x:Number, s:Number, t:Number):Number {           return md5_cmn ((b & d) | (c & (~d)), a, b, x, s, t);         }         public static function md5_hh (a:Number, b:Number, c:Number, d:Number, x:Number, s:Number, t:Number):Number {           return md5_cmn (b ^ c ^ d, a, b, x, s, t);         }         public static function md5_ii (a:Number, b:Number, c:Number, d:Number, x:Number, s:Number, t:Number):Number {           return md5_cmn (c ^ (b | (~d)), a, b, x, s, t);         }                  /*          * Add integers, wrapping at 2^32. This uses 16-bit operations internally          * to work around bugs in some JS interpreters.          */         public static function safe_add (x:Number, y:Number):Number {           var lsw:Number = (x & 0xFFFF) + (y & 0xFFFF);           var msw:Number = (x >> 16) + (y >> 16) + (lsw >> 16);           return (msw << 16) | (lsw & 0xFFFF);         }                  /*          * Bitwise rotate a 32-bit number to the left.          */         public static function bit_rol (num:Number, cnt:Number):Number {           return (num << cnt) | (num >>> (32 - cnt));         }                      }

=================================

출처: http://www.cyworld.com/daios1004/2567068

드디어 ... 많은 분들이 기다리시는 MD5 알고리즘을 공부해볼 시간입니다. ^^;

최대한 쉽게 쉽게 ~~~~~~

RFC 1321 문서를 기준으로 알고리즘을 설명드리겠습니다.

RFC 1321 에는 알고리즘 뿐만 아니라 MD5 알고리즘을 구현한 소스까지 같이 포함되어 있습니다.

(소스는 제가 참고자료에 올려 두었으니 필요하신 분들은 다운 받아가세요 ^^)

[MD5 알고리즘 설명에 앞서]

알고리즘 문서에서 사용되는 용어를 간단하게 정리하고 넘어갑시다.

- 워드(word) : 32 bit

- 바이트(byte) : 8 bit

- 연산

X <<< s : s 만큼 좌로 순환 shift (0 으로 채워지는 것이 아니고 bit 가 순환됨)

not(X) : bit not 연산

X v Y : bit or 연산

X xor Y : bit xor 연산

XY : bit and 연산

[MD5 알고리즘]

MD5 는 출력값이 128 bit (16 byte) 입니다.

알고리즘을 수행할 때는 512 비트 단위로 처리를 합니다.

[Step 1] Append Padding Bits

이 단계는 들어온 입력 메시지에 bit 패딩을 수행하는 단계입니다.

bit 패딩은 처음 첫 bit 는 1 로 채우고 나머지 bit 는 모두 0 으로 채우는 형태로 진행됩니다.

MD5 는 512 bit 단위로 알고리즘을 수행합니다.

그래서 항상 512 bit 로 나누어 떨어지도록 메시지 길이를 맞추어 주는 것이죠.

이러한 패딩 작업은 무조건 하게 되어 있습니다. 입력 메시지 길이가 512 bit 라도...

512 bit 를 더해서 1024 bit 가 되도록 길이를 맞추어 주어야 합니다.

그런데, 이 첫번째 단계에서는 512 bit 길이로 맞춰주는 패딩을 할 때 항상 64 bit (8 byte) 모자라게 패딩을 합니다.

이 모자란 64 bit 는 패딩되기 전의 메시지 길이를 입력하기 위한 용도로 남겨 둡니다. ( [Step 2] 에서 이 값을 채우게 됨)

몇가지 예를 들어 보겠습니다.

- 입력 메시지의 길이가 448 bit (56 byte)일 경우

512 bit 를 패딩하여 448 + 512 = 960 bit 로 맞춥니다.

512 로 나누어 떨어지기 위해서는 1024 bit 로 맞추어야 하는데, 모자란 64 bit 는 [Step 2] 에서 메시지의 길이를 패딩합니다.

- 입력 메시지의 길이가 440 bit (55 byte) 일 경우

이때는 8 bit 만 패딩을 합니다. 그러면 448 bit 로 맞추어지게 되고, 512 에서 모자란 64 bit 는 [Step 2] 에서 채워지게 됩니다.

- 입력 메시지의 길이가 512 bit (64 byte) 일 경우

448 bit 를 패딩하여 512 + 448 = 960 bit 로 맞춥니다.

512 로 나누어 떨어지기 위해서는 1024 bit 로 맞추어야 하는데, 모자란 64 bit 는 [Step 2] 에서 채워지게 됩니다.

512 로 나누어 떨어지도록 하되..... 항상 64 bit 모자라게 패딩을 하면 되는데요 ...

말로 하면 이렇게 길지만, 수식으로 쓰면 한줄이면 됩니다. ^^;

메시지 길이(L) ≡ 448 mod 512 [수식 1]

위와 같이 한줄로 표현할 수 있습니다. 이것은 L-448 의 값이 512 로 나누어 떨어져야 한다는 얘기입니다.

L 이 448 일 경우엔 448 - 448 = 0 이므로 512 로 나누어 떨어지지만, 이럴 경우에는 무조건 패딩을 해야 하므로

512 로 나누어 떨어지기 위해선 512 를 패딩해야 합니다.

L 이 440 일 경우엔 440 - 448 = -8 이므로 512 로 나누어 떨어지기 위해선 0 이어야 합니다. 그러므로 8 을 패딩하면 됩니다.

L 이 512 일 경우엔 512 - 448 = 64 이므로 512 로 나누어 떨어지기 위해서 512 - 64 = 448 을 패딩해야 합니다.

크 ... 계산이 쉽죠 ?

이렇게 패딩만 하면 [Step 1] 은 마치게 됩니다.

[Step 2] Append Length

이 단계는 [Step 1] 에서 64 bit 모자라게 패딩을 하였는데, 이 64 bit 를 다 채우는 과정입니다.

64 bit 의 값은 패딩이 되기 전 원본 메시지의 길이를 표현합니다.

이때의 메시지 길이는 byte 단위가 아닌 bit 단위라는 것을 기억하세요~~~~

만약에 원본의 메시지의 길이가 2^64 보다 크다면 ? ㅋ .... 이럴 일은 아마 거의 없을테지만,

어쨌든 그런 경우가 발생한다면 ... 그냥 2^64 로 표현 가능한 값만 사용하면 됩니다.

이 64 bit 는 32 bit word 2개로 표현을 합니다.

word 2개의 순서는 낮은 order 를 가진 word 가 먼저 패딩되고 그 다음 나머지 word 가 패딩됩니다.

그리고, 이 word 자체도 low order byte 가 먼저 나오는 구조로 저장됩니다.

즉, Little-endian 구조로 저장해야 한다는 것을 반드시 명심하시기 바랍니다. ^^;

이것은 나중에 직접 구현할 때 더 상세하게 알아보도록 하고... 지금은 ... 전체적인 알고리즘에 집중합시다.ㅋㅋ

지금까지의 과정이 끝나면 ... 메시지의 길이는 정확하게 512 의 배수가 됩니다.

word 로 보면 16 word 의 배수가 됩니다. ( 512 bit = 16 word )

그리고 나서 ... 패딩이 완료된 메시지를 M[0 ...... N-1] 에 워드 단위로 할당을 합니다.

여기서 N 은 16의 배수가 됩니다. ( M 은 워드 단위 )

이렇게 해서 16 word 단위로 처리를 하게 됩니다.

[Step 3] Initialize MD Buffer

MD5 알고리즘은 128 bit ( 4 word ) 길이의 해쉬값을 출력합니다.

해쉬값을 계산할 때, 다음 4 개의 32 bit register 를 필요로 합니다.( 즉, 4개의 word )

Message Digest 를 수행하는 매 단계마다 다음 레지스터를 이용해서 계산을 하고 다시 이 레지스터에

계산 결과를 넣는 식으로 연산을 수행합니다.

아래처럼 초기값으로 초기화를 수행해야 합니다.

     word A: 01 23 45 67
     word B: 89 ab cd ef
   word C: fe dc ba 98
     word D: 76 54 32 10

이때의 word 는 low order byte 가 먼저 저장된 형태입니다. (Little-endian)

구현할 때 이 부분을 신경써서 처리해야 합니다. ^^;

지금 생각하기에는 CPU 에 따라 Little-endian, Big-endian 으로 나뉘는데...

이걸 어떻게 경우에 따라 처리하나 이런 생각이 들겁니다.

구현을 할 때는 이러한 제약을 가지지 않도록 해야 합니다. Little-endian 머신에서는

잘 되는데, Big-endian 머신에서는 제대로 수행이 안되면 안되겠죠 ?

그래서 구현할 때 이 부분을 신경써서 처리를 해야 합니다.

C 언어의 경우라면 word A 의 경우 아래와 같이 코딩해야 한다고 생각할 수 있습니다.

(32 bit 머신일 경우)

unsigned int a = 0x01234567; <--- (1)unsigned int a = 0x67452301; <--- (2)

(1) 과 (2) 중 어떤게 맞을까요 ?

Little-endian 머신일 경우엔 (2) 가 맞습니다.

Big-endian 머신일 경우엔 (1) 이 맞습니다.

그렇다면 Big-endian 일 경우와 Little-endian 일 경우를 나눠서 만들어야 하느냐라고 질문이 나올겁니다.

그렇게 해도 됩니다. ^^;

그렇지만, 단순하게 나눠서 코딩을 하게 되면 코드가 중복됩니다.

성능에는 아무런 문제가 없겠지만, 아무래도 같은 코드가 중복되므로 보기가 별로 좋진 않겠죠 ?

그래서 보통은 Big-endian 인지 Little-endian 인지 구분하지 않고 쓰기 위해 메모리에 넣을 때

직접 순서를 맞춰서 넣는 방법을 택합니다.

MD5 알고리즘은 Little-endian 방식으로 메모리에 저장하도록 규정하고 있으므로 ...

그냥 아예 처음부터 맞추어 주는 방법을 택하는 것이죠.

이것은 다음 강좌에서 직접 알고리즘을 구현할 때 좀 더 상세히 알아봅시다. ^^;

다음으로 가장 복잡한 [Step 4] 를 보도록 하겠습니다.

[Step 4] Process Message in 16-Word Blocks

이 단계는 16 word (512 bit) block 단위로 실제 Message Disgest 를 수행하는 과정입니다.

이때 필요한 보조 함수를 다음과 같이 정의합니다.

F(X,Y,Z) = XY v not(X) Z
G(X,Y,Z) = XZ v Y not(Z)
H(X,Y,Z) = X xor Y xor Z
I(X,Y,Z) = Y xor (X v not(Z))

흐, 좀 더 명확하게 보기 위해서 이것을 C 언어의 매크로로 옮겨 보겠습니다.

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

좀 더 이해하기 쉽나요 ?

32 bit word x, y, z 를 입력 받아 연산 후에 32bit word 를 출력하면 됩니다.

이제 위에서 정의한 F, G, H, I 보조 함수를 이용하여 아래 과정을 수행하면 됩니다.

16 word block (512 bit ) 단위로 아래 코드를 수행하면 됩니다.

아래 코드는 RFC 1321 문서에 나오는 가상코드(pseudo code) 입니다.

1 /* Process each 16-word block. */
2 For i = 0 to N/16-1 do

3     /* Copy block i into X. */
4     For j = 0 to 15 do
5       Set X[j] to M[i*16+j].
6     end /* of loop on j */

7     /* Save A as AA, B as BB, C as CC, and D as DD. */
8     AA = A
9     BB = B
10     CC = C
11     DD = D

12     /* Round 1. */
13     /* Let [abcd k s i] denote the operation
14          a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
15     /* Do the following 16 operations. */
16     [ABCD 0 7 1] [DABC 1 12 2] [CDAB 2 17 3] [BCDA 3 22 4]
17     [ABCD 4 7 5] [DABC 5 12 6] [CDAB 6 17 7] [BCDA 7 22 8]
18     [ABCD 8 7 9] [DABC 9 12 10] [CDAB 10 17 11] [BCDA 11 22 12]
19     [ABCD 12 7 13] [DABC 13 12 14] [CDAB 14 17 15] [BCDA 15 22 16]

20     /* Round 2. */
21     /* Let [abcd k s i] denote the operation
22          a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
23     /* Do the following 16 operations. */
24     [ABCD 1 5 17] [DABC 6 9 18] [CDAB 11 14 19] [BCDA 0 20 20]
25     [ABCD 5 5 21] [DABC 10 9 22] [CDAB 15 14 23] [BCDA 4 20 24]
26     [ABCD 9 5 25] [DABC 14 9 26] [CDAB 3 14 27] [BCDA 8 20 28]
27     [ABCD 13 5 29] [DABC 2 9 30] [CDAB 7 14 31] [BCDA 12 20 32]

28     /* Round 3. */
29     /* Let [abcd k s t] denote the operation
30          a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
31     /* Do the following 16 operations. */
32     [ABCD 5 4 33] [DABC 8 11 34] [CDAB 11 16 35] [BCDA 14 23 36]
33     [ABCD 1 4 37] [DABC 4 11 38] [CDAB 7 16 39] [BCDA 10 23 40]
34     [ABCD 13 4 41] [DABC 0 11 42] [CDAB 3 16 43] [BCDA 6 23 44]
35     [ABCD 9 4 45] [DABC 12 11 46] [CDAB 15 16 47] [BCDA 2 23 48]

36     /* Round 4. */
37     /* Let [abcd k s t] denote the operation
38          a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
39     /* Do the following 16 operations. */
40     [ABCD 0 6 49] [DABC 7 10 50] [CDAB 14 15 51] [BCDA 5 21 52]
41     [ABCD 12 6 53] [DABC 3 10 54] [CDAB 10 15 55] [BCDA 1 21 56]
42     [ABCD 8 6 57] [DABC 15 10 58] [CDAB 6 15 59] [BCDA 13 21 60]
43     [ABCD 4 6 61] [DABC 11 10 62] [CDAB 2 15 63] [BCDA 9 21 64]

44     /* Then perform the following additions. (That is increment each
45        of the four registers by the value it had before this block
46        was started.) */
47     A = A + AA
48     B = B + BB
49     C = C + CC
50     D = D + DD

51 end /* of loop on i */

에구 ... 이 부분은 설명하기가 참 애매하네요.

말로 하면 오히려 더 쉬울텐데 .. 글로 쓰기가 -.-

그렇지만 색깔로 구분해 놓았으므로 이해하는데 조금이나마 도움이 되지 않을까 합니다. ^^;

위의 가상코드 중 잘못된 부분을 하나 짚고 넘어갑시다. 뭐 대세엔 지장없지만..... 그래도 알고리즘이 다 파악이 안된 상태에서는 혼란을 야기할 가능성이 있습니다.

29 라인과 37 라인의 주석중에서

파란색 부분

에 약간 잘못된게 있습니다.

[abcd k s t] --> [abcd k s i]

이런식으로 바껴야 합니다. 흐 ... Round 1, 2 는 제대로 되어 있구요. 혹시 헷갈릴까봐요. 그냥 참고하세요.

이제 설명 위 코드에 대해서 설명을 하겠습니다.

2 라인의

빨간색 코드

를 보세요.

이것은 16 word block (512 bit) 단위로 반복 처리하는 루프문입니다.

[Step 1], [Step 2] 를 거치게 되면 메시지는 정확하게 512 bit 의 배수가 됩니다.

메시지의 길이가 512 bit 이면 N = 16 이 되어 N/16-1 = 1-1 = 0 이 되므로 루프가 한번만 돕니다.

메시지의 길이가 1024 bit 이면 N = 32 가 되어 N/16-1 = 2-1 = 1 이 되어 루프가 두번 돕니다.

여기서 N 은 전체 메시지의 길이를 word 로 나타낸 값입니다.

4-6 라인의

노란색 코드

를 보세요.

16 word (512 bit) 단위로 처리를 할 때 현재 처리하고 있는 block 을 word 단위로 X 배열에 저장합니다.

[Step 2] 마지막에서 M 배열은 word 단위로 전체 메시지를 저장하고 있다고 했습니다.

전체 메시지 M 에서 현재 처리하는 부분을 X 에 저장해 놓는 것입니다.

매 round 마다 operation 을 수행할 때, 사용하는 값입니다.

8-11 라인, 47-50 라인의

주황색 코드

를 보세요

이것은 기존 값에 현재 수행한 결과를 계속 반영해 나가면서 수행하는 것을 나타냅니다.

단지 A += AA 라는 의미입니다. 흐~~~

12-43 라인이 MD5 의 핵심입니다.

이 과정은 4 번의 Round 를 수행합니다. (

보라색 코드

를 보세요)

각 Round 는 16 번의 Operation 을 수행하구요. (

녹색 코드

를 보세요)

각각의 Operation 은 다음과 같은 형태로 표현됩니다.

Round 1 을 보면

[abcd k s i] 는 a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s) 로 정의합니다.

Round 2 를 보면

[abcd k s i] 는 a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s) 로 정의합니다.

Round 3 과 4 에는 H, I 보조함수가 쓰인다는 것만 다릅니다.

그리고 이 Operation 에 쓰이는 T 배열 값은 다음과 같이 정의합니다.

T[i] = floor( 4294967296 * abs(sin(i)) ), i 는 라디안, 0 ≤ i ≤ 63

floor 는 버림을 뜻하므로 결국 정수부를 취한다는 뜻이 됩니다.

그런데, 실제 구현할 때는 이 값은 항상 같으므로 64 개의 word 배열에 미리 계산한 결과를 저장해 놓고 있으면 됩니다.

아래 C 매크로로 표현한 FF, GG, HH, II 의 마지막 인자 ac 는 미리 계산해 놓은 T[i] 값입니다.

이걸 C 언어 매크로로 한번 정의해 봅시다.

/* 좌로 순환 쉬프트 */

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

/* Round 1 에서 사용할 Operation */

#define FF(a, b, c, d, x, s, ac) { \
    (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
    (a) = ROTATE_LEFT ((a), (s)); \
    (a) += (b); \
}

/* Round 2 에서 사용할 Operation */

#define GG(a, b, c, d, x, s, ac) { \
    (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
    (a) = ROTATE_LEFT ((a), (s)); \
    (a) += (b); \
}

/* Round 3 에서 사용할 Operation */
#define HH(a, b, c, d, x, s, ac) { \
    (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
    (a) = ROTATE_LEFT ((a), (s)); \
    (a) += (b); \
}

/* Round 4 에서 사용할 Operation */
#define II(a, b, c, d, x, s, ac) { \
    (a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
    (a) = ROTATE_LEFT ((a), (s)); \
    (a) += (b); \
}

명세서에 나와 있는 것을 똑같이 C 매크로로 정의했다는 것을 알 수 있을것입니다.

Round 1 : FF 16번 수행

Round 2 : GG 16번 수행

Round 3 : HH 16번 수행

Roudn 4 : II 16번 수행

즉, 위와 같이 수행하면 MD5 의 핵심 연산이 끝나게 됩니다.

[Step 5] Output

이제 [Step 4] 에서 나왔던 A, B, C, D 의 값을 연결하면 됩니다.

A, B, C, D 는 word 입니다.

그래서 출력은 128 bit (16 byte) 가 됩니다.

각 word 는 low order byte 순서대로 저장되어야 하고 ....

ABCD 의 순으로 저장되어야 합니다.

이렇게 해서 MD5 알고리즘은 끝이 났습니다.

잘 이해 되시나요 ?

명세서보다는 쉽게 쓸려고 노력했는데..... ㅎㅎ

생각보다 어렵지 않죠 ? ^^

다음에는 .. MD5 알고리즘 소스를 가지고 하나하나 분석해 보도록 하겠습니다.

(구현하는거나 마찬가지입니다. ^^; 직접 한번 만들어 보세요~~~)

[출처] MD5 알고리즘|작성자 늦둥이해커

=================================

저작자표시

'ADOBE > ActionScript' 카테고리의 다른 글

액션스크립트 actionScript 날짜 체크 (0)	2014.10.07
[AS] adobe air flash actionscript 액션스크립트 URLRequest, loadPolicyFile, allowScriptAccess 보안 관련 (0)	2014.10.02
[AS] 액션스크립트 - push() unshift() (0)	2014.08.19
플래시 액션스크립트 StageWebView 스냅샷 (0)	2014.03.24
플래시 액션스크립트 플래시 안에서 tab focus이동하려고하는데 explorer 익스플로어(또는 다른브라우져)에서 tab 이동이 제어가 안될때 (0)	2014.03.19

알레폰드의 테크 이모저모

고정 헤더 영역

메뉴 레이어

메뉴 리스트

검색 레이어

검색 영역

상세 컨텐츠

본문 제목

본문

'ADOBE > ActionScript' 카테고리의 다른 글

관련글 더보기

댓글 영역

추가 정보

인기글

최신글

티스토리툴바