Alexei Podtelezhnikov pushed to branch master at FreeType / FreeType Demo Programs
Commits:
-
d8db386c
by Sarthak Bhardwaj at 2021-06-12T23:56:39-04:00
6 changed files:
Changes:
1 |
+2021-06-13 Sarthak Bhardwaj <1sarthakbhardwaj@gmail.com>
|
|
2 |
+ Anurag Thakur <devanuragthakur@gmail.com>
|
|
3 |
+ |
|
4 |
+ [ftlint] Render and calculate MD5 checksum.
|
|
5 |
+ |
|
6 |
+ * src/ftlint.c (main): Handle the load flags and the render mode from
|
|
7 |
+ the command line.
|
|
8 |
+ (Checksum): Calculate MD5 sum.
|
|
9 |
+ * src/md5.c, src/md5.h: MD5 source code.
|
|
10 |
+ * Makefile, messon.build: Update the build systems.
|
|
11 |
+ |
|
1 | 12 |
2021-06-06 Anuj Verma <anujv@iitbhilai.ac.in>
|
2 | 13 |
|
3 | 14 |
[ftsdf] Synchronize with the change made in the `sdf` renderer.
|
... | ... | @@ -345,10 +345,12 @@ else |
345 | 345 |
$(OBJ_DIR_2)/common.$(SO): $(SRC_DIR)/common.c
|
346 | 346 |
$(OBJ_DIR_2)/strbuf.$(SO): $(SRC_DIR)/strbuf.c
|
347 | 347 |
$(OBJ_DIR_2)/output.$(SO): $(SRC_DIR)/output.c
|
348 |
+ $(OBJ_DIR_2)/md5.$(SO): $(SRC_DIR)/md5.c
|
|
348 | 349 |
$(OBJ_DIR_2)/mlgetopt.$(SO): $(SRC_DIR)/mlgetopt.c
|
349 | 350 |
COMMON_OBJ := $(OBJ_DIR_2)/common.$(SO) \
|
350 | 351 |
$(OBJ_DIR_2)/strbuf.$(SO) \
|
351 | 352 |
$(OBJ_DIR_2)/output.$(SO) \
|
353 |
+ $(OBJ_DIR_2)/md5.$(SO) \
|
|
352 | 354 |
$(OBJ_DIR_2)/mlgetopt.$(SO)
|
353 | 355 |
|
354 | 356 |
$(OBJ_DIR_2)/ftcommon.$(SO): $(SRC_DIR)/ftcommon.c $(SRC_DIR)/ftcommon.h
|
... | ... | @@ -41,6 +41,8 @@ common_files = files([ |
41 | 41 |
'src/common.h',
|
42 | 42 |
'src/strbuf.c',
|
43 | 43 |
'src/strbuf.h',
|
44 |
+ 'src/md5.c',
|
|
45 |
+ 'src/md5.h',
|
|
44 | 46 |
])
|
45 | 47 |
|
46 | 48 |
# Use `mlgetopt.h` on non-Unix platforms.
|
... | ... | @@ -6,7 +6,7 @@ |
6 | 6 |
/* D. Turner, R.Wilhelm, and W. Lemberg */
|
7 | 7 |
/* */
|
8 | 8 |
/* ftlint: a simple font tester. This program tries to load all the */
|
9 |
-/* glyphs of a given font. */
|
|
9 |
+/* glyphs of a given font, render them, and calculate MD5. */
|
|
10 | 10 |
/* */
|
11 | 11 |
/* NOTE: This is just a test program that is used to show off and */
|
12 | 12 |
/* debug the current engine. */
|
... | ... | @@ -14,20 +14,30 @@ |
14 | 14 |
/****************************************************************************/
|
15 | 15 |
|
16 | 16 |
#include <ft2build.h>
|
17 |
-#include FT_FREETYPE_H
|
|
17 |
+#include <freetype/freetype.h>
|
|
18 |
+#include <freetype/ftbitmap.h>
|
|
19 |
+ |
|
18 | 20 |
|
19 | 21 |
#include <stdio.h>
|
20 | 22 |
#include <stdlib.h>
|
21 | 23 |
#include <string.h>
|
22 | 24 |
|
25 |
+#include "md5.h"
|
|
23 | 26 |
|
24 |
-#define xxTEST_PSNAMES
|
|
27 |
+#ifdef UNIX
|
|
28 |
+#include <unistd.h>
|
|
29 |
+#else
|
|
30 |
+#include "mlgetopt.h"
|
|
31 |
+#endif
|
|
25 | 32 |
|
26 | 33 |
|
27 |
- static FT_Error error;
|
|
34 |
+#define xxTEST_PSNAMES
|
|
28 | 35 |
|
29 |
- static FT_Library library;
|
|
30 |
- static FT_Face face;
|
|
36 |
+ static FT_Error error;
|
|
37 |
+ static FT_Library library;
|
|
38 |
+ static FT_Face face;
|
|
39 |
+ static FT_Render_Mode render_mode = FT_RENDER_MODE_NORMAL;
|
|
40 |
+ static FT_Int32 load_flags = FT_LOAD_DEFAULT;
|
|
31 | 41 |
|
32 | 42 |
static unsigned int num_glyphs;
|
33 | 43 |
static int ptsize;
|
... | ... | @@ -41,8 +51,11 @@ |
41 | 51 |
printf( "ftlint: simple font tester -- part of the FreeType project\n" );
|
42 | 52 |
printf( "----------------------------------------------------------\n" );
|
43 | 53 |
printf( "\n" );
|
44 |
- printf( "Usage: %s ppem fontname[.ttf|.ttc] [fontname2..]\n", name );
|
|
54 |
+ printf( "Usage: %s [options] ppem fontname[.ttf|.ttc] [fontname2..]\n",
|
|
55 |
+ name );
|
|
45 | 56 |
printf( "\n" );
|
57 |
+ printf( " -f L Use hex number L as load flags (see `FT_LOAD_XXX').\n" );
|
|
58 |
+ printf( " -r N Set render mode to N\n" );
|
|
46 | 59 |
|
47 | 60 |
exit( 1 );
|
48 | 61 |
}
|
... | ... | @@ -55,6 +68,43 @@ |
55 | 68 |
exit(1);
|
56 | 69 |
}
|
57 | 70 |
|
71 |
+ static void
|
|
72 |
+ Checksum( FT_GlyphSlot glyph )
|
|
73 |
+ {
|
|
74 |
+ FT_Bitmap bitmap;
|
|
75 |
+ FT_Error err;
|
|
76 |
+ FT_Bitmap_Init( &bitmap );
|
|
77 |
+ |
|
78 |
+ |
|
79 |
+ printf( "#%u ", glyph->glyph_index );
|
|
80 |
+ |
|
81 |
+ err = FT_Bitmap_Convert( library, &glyph->bitmap, &bitmap, 1 );
|
|
82 |
+ if ( !err )
|
|
83 |
+ {
|
|
84 |
+ MD5_CTX ctx;
|
|
85 |
+ unsigned char md5[16];
|
|
86 |
+ int i;
|
|
87 |
+ int rows = (int)bitmap.rows;
|
|
88 |
+ int pitch = bitmap.pitch;
|
|
89 |
+ |
|
90 |
+ MD5_Init( &ctx );
|
|
91 |
+ if ( bitmap.buffer )
|
|
92 |
+ MD5_Update( &ctx, bitmap.buffer,
|
|
93 |
+ (unsigned long)rows * (unsigned long)pitch );
|
|
94 |
+ MD5_Final( md5, &ctx );
|
|
95 |
+ |
|
96 |
+ for ( i = 0; i < 16; i++ )
|
|
97 |
+ {
|
|
98 |
+ printf( "%02X", md5[i] );
|
|
99 |
+ }
|
|
100 |
+ printf( "\n" );
|
|
101 |
+ }
|
|
102 |
+ else
|
|
103 |
+ printf("Error generating checksums\n");
|
|
104 |
+ |
|
105 |
+ FT_Bitmap_Done( library, &bitmap );
|
|
106 |
+ }
|
|
107 |
+ |
|
58 | 108 |
|
59 | 109 |
int
|
60 | 110 |
main( int argc,
|
... | ... | @@ -65,6 +115,7 @@ |
65 | 115 |
char filename[1024];
|
66 | 116 |
char* execname;
|
67 | 117 |
char* fname;
|
118 |
+ int opt;
|
|
68 | 119 |
|
69 | 120 |
|
70 | 121 |
execname = argv[0];
|
... | ... | @@ -72,22 +123,56 @@ |
72 | 123 |
if ( argc < 3 )
|
73 | 124 |
Usage( execname );
|
74 | 125 |
|
75 |
- if ( sscanf( argv[1], "%d", &ptsize ) != 1 )
|
|
126 |
+ while ( ( opt = getopt( argc, argv, "f:r:") ) != -1)
|
|
127 |
+ {
|
|
128 |
+ |
|
129 |
+ switch ( opt )
|
|
130 |
+ {
|
|
131 |
+ |
|
132 |
+ case 'f':
|
|
133 |
+ load_flags = strtol( optarg, NULL, 16 );
|
|
134 |
+ break;
|
|
135 |
+ |
|
136 |
+ case 'r':
|
|
137 |
+ {
|
|
138 |
+ int rm = atoi( optarg );
|
|
139 |
+ |
|
140 |
+ |
|
141 |
+ if ( rm < 0 || rm >= FT_RENDER_MODE_MAX )
|
|
142 |
+ render_mode = FT_RENDER_MODE_NORMAL;
|
|
143 |
+ else
|
|
144 |
+ render_mode = (FT_Render_Mode)rm;
|
|
145 |
+ }
|
|
146 |
+ break;
|
|
147 |
+ |
|
148 |
+ default:
|
|
149 |
+ Usage( execname );
|
|
150 |
+ break;
|
|
151 |
+ }
|
|
152 |
+ }
|
|
153 |
+ |
|
154 |
+ argc -= optind;
|
|
155 |
+ argv += optind;
|
|
156 |
+ |
|
157 |
+ |
|
158 |
+ if( sscanf( argv[0], "%d", &ptsize) != 1)
|
|
76 | 159 |
Usage( execname );
|
77 | 160 |
|
78 | 161 |
error = FT_Init_FreeType( &library );
|
79 |
- if (error) Panic( "Could not create library object" );
|
|
162 |
+ if ( error )
|
|
163 |
+ Panic( "Could not create library object" );
|
|
164 |
+ |
|
80 | 165 |
|
81 | 166 |
/* Now check all files */
|
82 |
- for ( file_index = 2; file_index < argc; file_index++ )
|
|
167 |
+ for ( file_index = 1; file_index < argc; file_index++ )
|
|
83 | 168 |
{
|
84 | 169 |
fname = argv[file_index];
|
85 | 170 |
|
86 | 171 |
/* try to open the file with no extra extension first */
|
87 | 172 |
error = FT_New_Face( library, fname, 0, &face );
|
88 |
- if (!error)
|
|
173 |
+ if ( !error )
|
|
89 | 174 |
{
|
90 |
- printf( "%s: ", fname );
|
|
175 |
+ printf( "%s: \n", fname );
|
|
91 | 176 |
goto Success;
|
92 | 177 |
}
|
93 | 178 |
|
... | ... | @@ -132,7 +217,7 @@ |
132 | 217 |
else
|
133 | 218 |
i--;
|
134 | 219 |
|
135 |
- printf( "%s: ", fname );
|
|
220 |
+ printf( "%s: \n", fname );
|
|
136 | 221 |
|
137 | 222 |
/* Load face */
|
138 | 223 |
error = FT_New_Face( library, filename, 0, &face );
|
... | ... | @@ -158,29 +243,33 @@ |
158 | 243 |
#endif
|
159 | 244 |
|
160 | 245 |
error = FT_Set_Char_Size( face, ptsize << 6, ptsize << 6, 72, 72 );
|
161 |
- if (error) Panic( "Could not set character size" );
|
|
246 |
+ if ( error )
|
|
247 |
+ Panic( "Could not set character size" );
|
|
162 | 248 |
|
163 | 249 |
Fail = 0;
|
164 | 250 |
{
|
165 | 251 |
for ( id = 0; id < num_glyphs; id++ )
|
166 | 252 |
{
|
167 |
- error = FT_Load_Glyph( face, id, FT_LOAD_DEFAULT );
|
|
168 |
- if (error)
|
|
253 |
+ error = FT_Load_Glyph( face, id, load_flags );
|
|
254 |
+ if ( error )
|
|
169 | 255 |
{
|
170 | 256 |
if ( Fail < 10 )
|
171 | 257 |
printf( "glyph %4u: 0x%04x\n" , id, error );
|
172 | 258 |
Fail++;
|
259 |
+ continue;
|
|
173 | 260 |
}
|
261 |
+ |
|
262 |
+ FT_Render_Glyph( face->glyph, render_mode );
|
|
263 |
+ Checksum( face->glyph );
|
|
174 | 264 |
}
|
175 | 265 |
}
|
176 | 266 |
|
177 | 267 |
if ( Fail == 0 )
|
178 | 268 |
printf( "OK.\n" );
|
269 |
+ else if ( Fail == 1 )
|
|
270 |
+ printf( "1 fail.\n" );
|
|
179 | 271 |
else
|
180 |
- if ( Fail == 1 )
|
|
181 |
- printf( "1 fail.\n" );
|
|
182 |
- else
|
|
183 |
- printf( "%d fails.\n", Fail );
|
|
272 |
+ printf( "%d fails.\n", Fail );
|
|
184 | 273 |
|
185 | 274 |
FT_Done_Face( face );
|
186 | 275 |
}
|
1 |
+/*
|
|
2 |
+ * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc.
|
|
3 |
+ * MD5 Message-Digest Algorithm (RFC 1321).
|
|
4 |
+ *
|
|
5 |
+ * Homepage:
|
|
6 |
+ * http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5
|
|
7 |
+ *
|
|
8 |
+ * Author:
|
|
9 |
+ * Alexander Peslyak, better known as Solar Designer <solar at openwall.com>
|
|
10 |
+ *
|
|
11 |
+ * This software was written by Alexander Peslyak in 2001. No copyright is
|
|
12 |
+ * claimed, and the software is hereby placed in the public domain.
|
|
13 |
+ * In case this attempt to disclaim copyright and place the software in the
|
|
14 |
+ * public domain is deemed null and void, then the software is
|
|
15 |
+ * Copyright (c) 2001 Alexander Peslyak and it is hereby released to the
|
|
16 |
+ * general public under the following terms:
|
|
17 |
+ *
|
|
18 |
+ * Redistribution and use in source and binary forms, with or without
|
|
19 |
+ * modification, are permitted.
|
|
20 |
+ *
|
|
21 |
+ * There's ABSOLUTELY NO WARRANTY, express or implied.
|
|
22 |
+ *
|
|
23 |
+ * (This is a heavily cut-down "BSD license".)
|
|
24 |
+ *
|
|
25 |
+ * This differs from Colin Plumb's older public domain implementation in that
|
|
26 |
+ * no exactly 32-bit integer data type is required (any 32-bit or wider
|
|
27 |
+ * unsigned integer data type will do), there's no compile-time endianness
|
|
28 |
+ * configuration, and the function prototypes match OpenSSL's. No code from
|
|
29 |
+ * Colin Plumb's implementation has been reused; this comment merely compares
|
|
30 |
+ * the properties of the two independent implementations.
|
|
31 |
+ *
|
|
32 |
+ * The primary goals of this implementation are portability and ease of use.
|
|
33 |
+ * It is meant to be fast, but not as fast as possible. Some known
|
|
34 |
+ * optimizations are not included to reduce source code size and avoid
|
|
35 |
+ * compile-time configuration.
|
|
36 |
+ */
|
|
37 |
+ |
|
38 |
+#ifndef HAVE_OPENSSL
|
|
39 |
+ |
|
40 |
+#include <string.h>
|
|
41 |
+ |
|
42 |
+#include "md5.h"
|
|
43 |
+ |
|
44 |
+/*
|
|
45 |
+ * The basic MD5 functions.
|
|
46 |
+ *
|
|
47 |
+ * F and G are optimized compared to their RFC 1321 definitions for
|
|
48 |
+ * architectures that lack an AND-NOT instruction, just like in Colin Plumb's
|
|
49 |
+ * implementation.
|
|
50 |
+ */
|
|
51 |
+#define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
|
|
52 |
+#define G(x, y, z) ((y) ^ ((z) & ((x) ^ (y))))
|
|
53 |
+#define H(x, y, z) (((x) ^ (y)) ^ (z))
|
|
54 |
+#define H2(x, y, z) ((x) ^ ((y) ^ (z)))
|
|
55 |
+#define I(x, y, z) ((y) ^ ((x) | ~(z)))
|
|
56 |
+ |
|
57 |
+/*
|
|
58 |
+ * The MD5 transformation for all four rounds.
|
|
59 |
+ */
|
|
60 |
+#define STEP(f, a, b, c, d, x, t, s) \
|
|
61 |
+ (a) += f((b), (c), (d)) + (x) + (t); \
|
|
62 |
+ (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \
|
|
63 |
+ (a) += (b);
|
|
64 |
+ |
|
65 |
+/*
|
|
66 |
+ * SET reads 4 input bytes in little-endian byte order and stores them in a
|
|
67 |
+ * properly aligned word in host byte order.
|
|
68 |
+ *
|
|
69 |
+ * The check for little-endian architectures that tolerate unaligned memory
|
|
70 |
+ * accesses is just an optimization. Nothing will break if it fails to detect
|
|
71 |
+ * a suitable architecture.
|
|
72 |
+ *
|
|
73 |
+ * Unfortunately, this optimization may be a C strict aliasing rules violation
|
|
74 |
+ * if the caller's data buffer has effective type that cannot be aliased by
|
|
75 |
+ * MD5_u32plus. In practice, this problem may occur if these MD5 routines are
|
|
76 |
+ * inlined into a calling function, or with future and dangerously advanced
|
|
77 |
+ * link-time optimizations. For the time being, keeping these MD5 routines in
|
|
78 |
+ * their own translation unit avoids the problem.
|
|
79 |
+ */
|
|
80 |
+#if defined(__i386__) || defined(__x86_64__) || defined(__vax__)
|
|
81 |
+#define SET(n) \
|
|
82 |
+ (*(MD5_u32plus *)&ptr[(n) * 4])
|
|
83 |
+#define GET(n) \
|
|
84 |
+ SET(n)
|
|
85 |
+#else
|
|
86 |
+#define SET(n) \
|
|
87 |
+ (ctx->block[(n)] = \
|
|
88 |
+ (MD5_u32plus)ptr[(n) * 4] | \
|
|
89 |
+ ((MD5_u32plus)ptr[(n) * 4 + 1] << 8) | \
|
|
90 |
+ ((MD5_u32plus)ptr[(n) * 4 + 2] << 16) | \
|
|
91 |
+ ((MD5_u32plus)ptr[(n) * 4 + 3] << 24))
|
|
92 |
+#define GET(n) \
|
|
93 |
+ (ctx->block[(n)])
|
|
94 |
+#endif
|
|
95 |
+ |
|
96 |
+/*
|
|
97 |
+ * This processes one or more 64-byte data blocks, but does NOT update the bit
|
|
98 |
+ * counters. There are no alignment requirements.
|
|
99 |
+ */
|
|
100 |
+static const void *body(MD5_CTX *ctx, const void *data, unsigned long size)
|
|
101 |
+{
|
|
102 |
+ const unsigned char *ptr;
|
|
103 |
+ MD5_u32plus a, b, c, d;
|
|
104 |
+ MD5_u32plus saved_a, saved_b, saved_c, saved_d;
|
|
105 |
+ |
|
106 |
+ ptr = (const unsigned char *)data;
|
|
107 |
+ |
|
108 |
+ a = ctx->a;
|
|
109 |
+ b = ctx->b;
|
|
110 |
+ c = ctx->c;
|
|
111 |
+ d = ctx->d;
|
|
112 |
+ |
|
113 |
+ do {
|
|
114 |
+ saved_a = a;
|
|
115 |
+ saved_b = b;
|
|
116 |
+ saved_c = c;
|
|
117 |
+ saved_d = d;
|
|
118 |
+ |
|
119 |
+/* Round 1 */
|
|
120 |
+ STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7)
|
|
121 |
+ STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12)
|
|
122 |
+ STEP(F, c, d, a, b, SET(2), 0x242070db, 17)
|
|
123 |
+ STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22)
|
|
124 |
+ STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7)
|
|
125 |
+ STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12)
|
|
126 |
+ STEP(F, c, d, a, b, SET(6), 0xa8304613, 17)
|
|
127 |
+ STEP(F, b, c, d, a, SET(7), 0xfd469501, 22)
|
|
128 |
+ STEP(F, a, b, c, d, SET(8), 0x698098d8, 7)
|
|
129 |
+ STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12)
|
|
130 |
+ STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17)
|
|
131 |
+ STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22)
|
|
132 |
+ STEP(F, a, b, c, d, SET(12), 0x6b901122, 7)
|
|
133 |
+ STEP(F, d, a, b, c, SET(13), 0xfd987193, 12)
|
|
134 |
+ STEP(F, c, d, a, b, SET(14), 0xa679438e, 17)
|
|
135 |
+ STEP(F, b, c, d, a, SET(15), 0x49b40821, 22)
|
|
136 |
+ |
|
137 |
+/* Round 2 */
|
|
138 |
+ STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5)
|
|
139 |
+ STEP(G, d, a, b, c, GET(6), 0xc040b340, 9)
|
|
140 |
+ STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14)
|
|
141 |
+ STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20)
|
|
142 |
+ STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5)
|
|
143 |
+ STEP(G, d, a, b, c, GET(10), 0x02441453, 9)
|
|
144 |
+ STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14)
|
|
145 |
+ STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20)
|
|
146 |
+ STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5)
|
|
147 |
+ STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9)
|
|
148 |
+ STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14)
|
|
149 |
+ STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20)
|
|
150 |
+ STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5)
|
|
151 |
+ STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9)
|
|
152 |
+ STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14)
|
|
153 |
+ STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20)
|
|
154 |
+ |
|
155 |
+/* Round 3 */
|
|
156 |
+ STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4)
|
|
157 |
+ STEP(H2, d, a, b, c, GET(8), 0x8771f681, 11)
|
|
158 |
+ STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16)
|
|
159 |
+ STEP(H2, b, c, d, a, GET(14), 0xfde5380c, 23)
|
|
160 |
+ STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4)
|
|
161 |
+ STEP(H2, d, a, b, c, GET(4), 0x4bdecfa9, 11)
|
|
162 |
+ STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16)
|
|
163 |
+ STEP(H2, b, c, d, a, GET(10), 0xbebfbc70, 23)
|
|
164 |
+ STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4)
|
|
165 |
+ STEP(H2, d, a, b, c, GET(0), 0xeaa127fa, 11)
|
|
166 |
+ STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16)
|
|
167 |
+ STEP(H2, b, c, d, a, GET(6), 0x04881d05, 23)
|
|
168 |
+ STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4)
|
|
169 |
+ STEP(H2, d, a, b, c, GET(12), 0xe6db99e5, 11)
|
|
170 |
+ STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16)
|
|
171 |
+ STEP(H2, b, c, d, a, GET(2), 0xc4ac5665, 23)
|
|
172 |
+ |
|
173 |
+/* Round 4 */
|
|
174 |
+ STEP(I, a, b, c, d, GET(0), 0xf4292244, 6)
|
|
175 |
+ STEP(I, d, a, b, c, GET(7), 0x432aff97, 10)
|
|
176 |
+ STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15)
|
|
177 |
+ STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21)
|
|
178 |
+ STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6)
|
|
179 |
+ STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10)
|
|
180 |
+ STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15)
|
|
181 |
+ STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21)
|
|
182 |
+ STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6)
|
|
183 |
+ STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10)
|
|
184 |
+ STEP(I, c, d, a, b, GET(6), 0xa3014314, 15)
|
|
185 |
+ STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21)
|
|
186 |
+ STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6)
|
|
187 |
+ STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10)
|
|
188 |
+ STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15)
|
|
189 |
+ STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21)
|
|
190 |
+ |
|
191 |
+ a += saved_a;
|
|
192 |
+ b += saved_b;
|
|
193 |
+ c += saved_c;
|
|
194 |
+ d += saved_d;
|
|
195 |
+ |
|
196 |
+ ptr += 64;
|
|
197 |
+ } while (size -= 64);
|
|
198 |
+ |
|
199 |
+ ctx->a = a;
|
|
200 |
+ ctx->b = b;
|
|
201 |
+ ctx->c = c;
|
|
202 |
+ ctx->d = d;
|
|
203 |
+ |
|
204 |
+ return ptr;
|
|
205 |
+}
|
|
206 |
+ |
|
207 |
+void MD5_Init(MD5_CTX *ctx)
|
|
208 |
+{
|
|
209 |
+ ctx->a = 0x67452301;
|
|
210 |
+ ctx->b = 0xefcdab89;
|
|
211 |
+ ctx->c = 0x98badcfe;
|
|
212 |
+ ctx->d = 0x10325476;
|
|
213 |
+ |
|
214 |
+ ctx->lo = 0;
|
|
215 |
+ ctx->hi = 0;
|
|
216 |
+}
|
|
217 |
+ |
|
218 |
+void MD5_Update(MD5_CTX *ctx, const void *data, unsigned long size)
|
|
219 |
+{
|
|
220 |
+ MD5_u32plus saved_lo;
|
|
221 |
+ unsigned long used, available;
|
|
222 |
+ |
|
223 |
+ saved_lo = ctx->lo;
|
|
224 |
+ if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo)
|
|
225 |
+ ctx->hi++;
|
|
226 |
+ ctx->hi += size >> 29;
|
|
227 |
+ |
|
228 |
+ used = saved_lo & 0x3f;
|
|
229 |
+ |
|
230 |
+ if (used) {
|
|
231 |
+ available = 64 - used;
|
|
232 |
+ |
|
233 |
+ if (size < available) {
|
|
234 |
+ memcpy(&ctx->buffer[used], data, size);
|
|
235 |
+ return;
|
|
236 |
+ }
|
|
237 |
+ |
|
238 |
+ memcpy(&ctx->buffer[used], data, available);
|
|
239 |
+ data = (const unsigned char *)data + available;
|
|
240 |
+ size -= available;
|
|
241 |
+ body(ctx, ctx->buffer, 64);
|
|
242 |
+ }
|
|
243 |
+ |
|
244 |
+ if (size >= 64) {
|
|
245 |
+ data = body(ctx, data, size & ~(unsigned long)0x3f);
|
|
246 |
+ size &= 0x3f;
|
|
247 |
+ }
|
|
248 |
+ |
|
249 |
+ memcpy(ctx->buffer, data, size);
|
|
250 |
+}
|
|
251 |
+ |
|
252 |
+#define OUT(dst, src) \
|
|
253 |
+ (dst)[0] = (unsigned char)(src); \
|
|
254 |
+ (dst)[1] = (unsigned char)((src) >> 8); \
|
|
255 |
+ (dst)[2] = (unsigned char)((src) >> 16); \
|
|
256 |
+ (dst)[3] = (unsigned char)((src) >> 24);
|
|
257 |
+ |
|
258 |
+void MD5_Final(unsigned char *result, MD5_CTX *ctx)
|
|
259 |
+{
|
|
260 |
+ unsigned long used, available;
|
|
261 |
+ |
|
262 |
+ used = ctx->lo & 0x3f;
|
|
263 |
+ |
|
264 |
+ ctx->buffer[used++] = 0x80;
|
|
265 |
+ |
|
266 |
+ available = 64 - used;
|
|
267 |
+ |
|
268 |
+ if (available < 8) {
|
|
269 |
+ memset(&ctx->buffer[used], 0, available);
|
|
270 |
+ body(ctx, ctx->buffer, 64);
|
|
271 |
+ used = 0;
|
|
272 |
+ available = 64;
|
|
273 |
+ }
|
|
274 |
+ |
|
275 |
+ memset(&ctx->buffer[used], 0, available - 8);
|
|
276 |
+ |
|
277 |
+ ctx->lo <<= 3;
|
|
278 |
+ OUT(&ctx->buffer[56], ctx->lo)
|
|
279 |
+ OUT(&ctx->buffer[60], ctx->hi)
|
|
280 |
+ |
|
281 |
+ body(ctx, ctx->buffer, 64);
|
|
282 |
+ |
|
283 |
+ OUT(&result[0], ctx->a)
|
|
284 |
+ OUT(&result[4], ctx->b)
|
|
285 |
+ OUT(&result[8], ctx->c)
|
|
286 |
+ OUT(&result[12], ctx->d)
|
|
287 |
+ |
|
288 |
+ memset(ctx, 0, sizeof(*ctx));
|
|
289 |
+}
|
|
290 |
+ |
|
291 |
+#endif
|
1 |
+/*
|
|
2 |
+ * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc.
|
|
3 |
+ * MD5 Message-Digest Algorithm (RFC 1321).
|
|
4 |
+ *
|
|
5 |
+ * Homepage:
|
|
6 |
+ * http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5
|
|
7 |
+ *
|
|
8 |
+ * Author:
|
|
9 |
+ * Alexander Peslyak, better known as Solar Designer <solar at openwall.com>
|
|
10 |
+ *
|
|
11 |
+ * This software was written by Alexander Peslyak in 2001. No copyright is
|
|
12 |
+ * claimed, and the software is hereby placed in the public domain.
|
|
13 |
+ * In case this attempt to disclaim copyright and place the software in the
|
|
14 |
+ * public domain is deemed null and void, then the software is
|
|
15 |
+ * Copyright (c) 2001 Alexander Peslyak and it is hereby released to the
|
|
16 |
+ * general public under the following terms:
|
|
17 |
+ *
|
|
18 |
+ * Redistribution and use in source and binary forms, with or without
|
|
19 |
+ * modification, are permitted.
|
|
20 |
+ *
|
|
21 |
+ * There's ABSOLUTELY NO WARRANTY, express or implied.
|
|
22 |
+ *
|
|
23 |
+ * See md5.c for more information.
|
|
24 |
+ */
|
|
25 |
+ |
|
26 |
+#ifdef HAVE_OPENSSL
|
|
27 |
+#include <openssl/md5.h>
|
|
28 |
+#elif !defined(_MD5_H)
|
|
29 |
+#define _MD5_H
|
|
30 |
+ |
|
31 |
+/* Any 32-bit or wider unsigned integer data type will do */
|
|
32 |
+typedef unsigned int MD5_u32plus;
|
|
33 |
+ |
|
34 |
+typedef struct {
|
|
35 |
+ MD5_u32plus lo, hi;
|
|
36 |
+ MD5_u32plus a, b, c, d;
|
|
37 |
+ unsigned char buffer[64];
|
|
38 |
+ MD5_u32plus block[16];
|
|
39 |
+} MD5_CTX;
|
|
40 |
+ |
|
41 |
+extern void MD5_Init(MD5_CTX *ctx);
|
|
42 |
+extern void MD5_Update(MD5_CTX *ctx, const void *data, unsigned long size);
|
|
43 |
+extern void MD5_Final(unsigned char *result, MD5_CTX *ctx);
|
|
44 |
+ |
|
45 |
+#endif
|