Marco Zecchini
/
Example_RTOS
Rtos API example
Embed:
(wiki syntax)
Show/hide line numbers
lwip_md5.c
00001 /* 00002 * RFC 1321 compliant MD5 implementation 00003 * 00004 * Based on XySSL: Copyright (C) 2006-2008 Christophe Devine 00005 * 00006 * Copyright (C) 2009 Paul Bakker <polarssl_maintainer at polarssl dot org> 00007 * 00008 * All rights reserved. 00009 * 00010 * Redistribution and use in source and binary forms, with or without 00011 * modification, are permitted provided that the following conditions 00012 * are met: 00013 * 00014 * * Redistributions of source code must retain the above copyright 00015 * notice, this list of conditions and the following disclaimer. 00016 * * Redistributions in binary form must reproduce the above copyright 00017 * notice, this list of conditions and the following disclaimer in the 00018 * documentation and/or other materials provided with the distribution. 00019 * * Neither the names of PolarSSL or XySSL nor the names of its contributors 00020 * may be used to endorse or promote products derived from this software 00021 * without specific prior written permission. 00022 * 00023 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 00024 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 00025 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 00026 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 00027 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 00028 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED 00029 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 00030 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 00031 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 00032 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 00033 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 00034 */ 00035 /* 00036 * The MD5 algorithm was designed by Ron Rivest in 1991. 00037 * 00038 * http://www.ietf.org/rfc/rfc1321.txt 00039 */ 00040 00041 #include "netif/ppp/ppp_opts.h" 00042 #if PPP_SUPPORT && LWIP_INCLUDED_POLARSSL_MD5 00043 00044 #include "netif/ppp/polarssl/md5.h" 00045 00046 #include <string.h> 00047 00048 /* 00049 * 32-bit integer manipulation macros (little endian) 00050 */ 00051 #ifndef GET_ULONG_LE 00052 #define GET_ULONG_LE(n,b,i) \ 00053 { \ 00054 (n) = ( (unsigned long) (b)[(i) ] ) \ 00055 | ( (unsigned long) (b)[(i) + 1] << 8 ) \ 00056 | ( (unsigned long) (b)[(i) + 2] << 16 ) \ 00057 | ( (unsigned long) (b)[(i) + 3] << 24 ); \ 00058 } 00059 #endif 00060 00061 #ifndef PUT_ULONG_LE 00062 #define PUT_ULONG_LE(n,b,i) \ 00063 { \ 00064 (b)[(i) ] = (unsigned char) ( (n) ); \ 00065 (b)[(i) + 1] = (unsigned char) ( (n) >> 8 ); \ 00066 (b)[(i) + 2] = (unsigned char) ( (n) >> 16 ); \ 00067 (b)[(i) + 3] = (unsigned char) ( (n) >> 24 ); \ 00068 } 00069 #endif 00070 00071 /* 00072 * MD5 context setup 00073 */ 00074 void md5_starts( md5_context *ctx ) 00075 { 00076 ctx->total [0] = 0; 00077 ctx->total [1] = 0; 00078 00079 ctx->state [0] = 0x67452301; 00080 ctx->state [1] = 0xEFCDAB89; 00081 ctx->state [2] = 0x98BADCFE; 00082 ctx->state [3] = 0x10325476; 00083 } 00084 00085 static void md5_process( md5_context *ctx, const unsigned char data[64] ) 00086 { 00087 unsigned long X[16], A, B, C, D; 00088 00089 GET_ULONG_LE( X[ 0], data, 0 ); 00090 GET_ULONG_LE( X[ 1], data, 4 ); 00091 GET_ULONG_LE( X[ 2], data, 8 ); 00092 GET_ULONG_LE( X[ 3], data, 12 ); 00093 GET_ULONG_LE( X[ 4], data, 16 ); 00094 GET_ULONG_LE( X[ 5], data, 20 ); 00095 GET_ULONG_LE( X[ 6], data, 24 ); 00096 GET_ULONG_LE( X[ 7], data, 28 ); 00097 GET_ULONG_LE( X[ 8], data, 32 ); 00098 GET_ULONG_LE( X[ 9], data, 36 ); 00099 GET_ULONG_LE( X[10], data, 40 ); 00100 GET_ULONG_LE( X[11], data, 44 ); 00101 GET_ULONG_LE( X[12], data, 48 ); 00102 GET_ULONG_LE( X[13], data, 52 ); 00103 GET_ULONG_LE( X[14], data, 56 ); 00104 GET_ULONG_LE( X[15], data, 60 ); 00105 00106 #define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n))) 00107 00108 #define P(a,b,c,d,k,s,t) \ 00109 { \ 00110 a += F(b,c,d) + X[k] + t; a = S(a,s) + b; \ 00111 } 00112 00113 A = ctx->state [0]; 00114 B = ctx->state [1]; 00115 C = ctx->state [2]; 00116 D = ctx->state [3]; 00117 00118 #define F(x,y,z) (z ^ (x & (y ^ z))) 00119 00120 P( A, B, C, D, 0, 7, 0xD76AA478 ); 00121 P( D, A, B, C, 1, 12, 0xE8C7B756 ); 00122 P( C, D, A, B, 2, 17, 0x242070DB ); 00123 P( B, C, D, A, 3, 22, 0xC1BDCEEE ); 00124 P( A, B, C, D, 4, 7, 0xF57C0FAF ); 00125 P( D, A, B, C, 5, 12, 0x4787C62A ); 00126 P( C, D, A, B, 6, 17, 0xA8304613 ); 00127 P( B, C, D, A, 7, 22, 0xFD469501 ); 00128 P( A, B, C, D, 8, 7, 0x698098D8 ); 00129 P( D, A, B, C, 9, 12, 0x8B44F7AF ); 00130 P( C, D, A, B, 10, 17, 0xFFFF5BB1 ); 00131 P( B, C, D, A, 11, 22, 0x895CD7BE ); 00132 P( A, B, C, D, 12, 7, 0x6B901122 ); 00133 P( D, A, B, C, 13, 12, 0xFD987193 ); 00134 P( C, D, A, B, 14, 17, 0xA679438E ); 00135 P( B, C, D, A, 15, 22, 0x49B40821 ); 00136 00137 #undef F 00138 00139 #define F(x,y,z) (y ^ (z & (x ^ y))) 00140 00141 P( A, B, C, D, 1, 5, 0xF61E2562 ); 00142 P( D, A, B, C, 6, 9, 0xC040B340 ); 00143 P( C, D, A, B, 11, 14, 0x265E5A51 ); 00144 P( B, C, D, A, 0, 20, 0xE9B6C7AA ); 00145 P( A, B, C, D, 5, 5, 0xD62F105D ); 00146 P( D, A, B, C, 10, 9, 0x02441453 ); 00147 P( C, D, A, B, 15, 14, 0xD8A1E681 ); 00148 P( B, C, D, A, 4, 20, 0xE7D3FBC8 ); 00149 P( A, B, C, D, 9, 5, 0x21E1CDE6 ); 00150 P( D, A, B, C, 14, 9, 0xC33707D6 ); 00151 P( C, D, A, B, 3, 14, 0xF4D50D87 ); 00152 P( B, C, D, A, 8, 20, 0x455A14ED ); 00153 P( A, B, C, D, 13, 5, 0xA9E3E905 ); 00154 P( D, A, B, C, 2, 9, 0xFCEFA3F8 ); 00155 P( C, D, A, B, 7, 14, 0x676F02D9 ); 00156 P( B, C, D, A, 12, 20, 0x8D2A4C8A ); 00157 00158 #undef F 00159 00160 #define F(x,y,z) (x ^ y ^ z) 00161 00162 P( A, B, C, D, 5, 4, 0xFFFA3942 ); 00163 P( D, A, B, C, 8, 11, 0x8771F681 ); 00164 P( C, D, A, B, 11, 16, 0x6D9D6122 ); 00165 P( B, C, D, A, 14, 23, 0xFDE5380C ); 00166 P( A, B, C, D, 1, 4, 0xA4BEEA44 ); 00167 P( D, A, B, C, 4, 11, 0x4BDECFA9 ); 00168 P( C, D, A, B, 7, 16, 0xF6BB4B60 ); 00169 P( B, C, D, A, 10, 23, 0xBEBFBC70 ); 00170 P( A, B, C, D, 13, 4, 0x289B7EC6 ); 00171 P( D, A, B, C, 0, 11, 0xEAA127FA ); 00172 P( C, D, A, B, 3, 16, 0xD4EF3085 ); 00173 P( B, C, D, A, 6, 23, 0x04881D05 ); 00174 P( A, B, C, D, 9, 4, 0xD9D4D039 ); 00175 P( D, A, B, C, 12, 11, 0xE6DB99E5 ); 00176 P( C, D, A, B, 15, 16, 0x1FA27CF8 ); 00177 P( B, C, D, A, 2, 23, 0xC4AC5665 ); 00178 00179 #undef F 00180 00181 #define F(x,y,z) (y ^ (x | ~z)) 00182 00183 P( A, B, C, D, 0, 6, 0xF4292244 ); 00184 P( D, A, B, C, 7, 10, 0x432AFF97 ); 00185 P( C, D, A, B, 14, 15, 0xAB9423A7 ); 00186 P( B, C, D, A, 5, 21, 0xFC93A039 ); 00187 P( A, B, C, D, 12, 6, 0x655B59C3 ); 00188 P( D, A, B, C, 3, 10, 0x8F0CCC92 ); 00189 P( C, D, A, B, 10, 15, 0xFFEFF47D ); 00190 P( B, C, D, A, 1, 21, 0x85845DD1 ); 00191 P( A, B, C, D, 8, 6, 0x6FA87E4F ); 00192 P( D, A, B, C, 15, 10, 0xFE2CE6E0 ); 00193 P( C, D, A, B, 6, 15, 0xA3014314 ); 00194 P( B, C, D, A, 13, 21, 0x4E0811A1 ); 00195 P( A, B, C, D, 4, 6, 0xF7537E82 ); 00196 P( D, A, B, C, 11, 10, 0xBD3AF235 ); 00197 P( C, D, A, B, 2, 15, 0x2AD7D2BB ); 00198 P( B, C, D, A, 9, 21, 0xEB86D391 ); 00199 00200 #undef F 00201 00202 ctx->state [0] += A; 00203 ctx->state [1] += B; 00204 ctx->state [2] += C; 00205 ctx->state [3] += D; 00206 } 00207 00208 /* 00209 * MD5 process buffer 00210 */ 00211 void md5_update( md5_context *ctx, const unsigned char *input, int ilen ) 00212 { 00213 int fill; 00214 unsigned long left; 00215 00216 if( ilen <= 0 ) 00217 return; 00218 00219 left = ctx->total [0] & 0x3F; 00220 fill = 64 - left; 00221 00222 ctx->total [0] += ilen; 00223 ctx->total [0] &= 0xFFFFFFFF; 00224 00225 if( ctx->total [0] < (unsigned long) ilen ) 00226 ctx->total [1]++; 00227 00228 if( left && ilen >= fill ) 00229 { 00230 MEMCPY( (void *) (ctx->buffer + left), 00231 input, fill ); 00232 md5_process( ctx, ctx->buffer ); 00233 input += fill; 00234 ilen -= fill; 00235 left = 0; 00236 } 00237 00238 while( ilen >= 64 ) 00239 { 00240 md5_process( ctx, input ); 00241 input += 64; 00242 ilen -= 64; 00243 } 00244 00245 if( ilen > 0 ) 00246 { 00247 MEMCPY( (void *) (ctx->buffer + left), 00248 input, ilen ); 00249 } 00250 } 00251 00252 static const unsigned char md5_padding[64] = 00253 { 00254 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 00255 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 00256 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 00257 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 00258 }; 00259 00260 /* 00261 * MD5 final digest 00262 */ 00263 void md5_finish( md5_context *ctx, unsigned char output[16] ) 00264 { 00265 unsigned long last, padn; 00266 unsigned long high, low; 00267 unsigned char msglen[8]; 00268 00269 high = ( ctx->total [0] >> 29 ) 00270 | ( ctx->total [1] << 3 ); 00271 low = ( ctx->total [0] << 3 ); 00272 00273 PUT_ULONG_LE( low, msglen, 0 ); 00274 PUT_ULONG_LE( high, msglen, 4 ); 00275 00276 last = ctx->total [0] & 0x3F; 00277 padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last ); 00278 00279 md5_update( ctx, md5_padding, padn ); 00280 md5_update( ctx, msglen, 8 ); 00281 00282 PUT_ULONG_LE( ctx->state [0], output, 0 ); 00283 PUT_ULONG_LE( ctx->state [1], output, 4 ); 00284 PUT_ULONG_LE( ctx->state [2], output, 8 ); 00285 PUT_ULONG_LE( ctx->state [3], output, 12 ); 00286 } 00287 00288 /* 00289 * output = MD5( input buffer ) 00290 */ 00291 void md5( unsigned char *input, int ilen, unsigned char output[16] ) 00292 { 00293 md5_context ctx; 00294 00295 md5_starts( &ctx ); 00296 md5_update( &ctx, input, ilen ); 00297 md5_finish( &ctx, output ); 00298 } 00299 00300 #endif /* PPP_SUPPORT && LWIP_INCLUDED_POLARSSL_MD5 */
Generated on Sun Jul 17 2022 08:25:24 by 1.7.2