modules/rostests/winetests/advapi32/crypt_lmhash.c

   1 /*
   2  * Unit tests for SystemFunctionXXX (LMHash?)
   3  *
   4  * Copyright 2004 Hans Leidekker
   5  * Copyright 2006 Mike McCormack
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "precomp.h"
  23
  24 struct ustring {
  25     DWORD Length;
  26     DWORD MaximumLength;
  27     unsigned char *Buffer;
  28 };
  29
  30 typedef int (WINAPI *descrypt)(unsigned char *, unsigned char *, unsigned char *);
  31 static NTSTATUS (WINAPI *pSystemFunction001)(const BYTE *, const BYTE *, LPBYTE);
  32 static NTSTATUS (WINAPI *pSystemFunction002)(const BYTE *, const BYTE *, LPBYTE);
  33 static NTSTATUS (WINAPI *pSystemFunction003)(const BYTE *, LPBYTE);
  34 static NTSTATUS (WINAPI *pSystemFunction004)(const struct ustring *, const struct ustring *, struct ustring *);
  35 static NTSTATUS (WINAPI *pSystemFunction005)(const struct ustring *, const struct ustring *, struct ustring *);
  36 static VOID (WINAPI *pSystemFunction006)( PCSTR passwd, PSTR lmhash );
  37 static NTSTATUS (WINAPI *pSystemFunction008)(const BYTE *, const BYTE *, LPBYTE);
  38 static NTSTATUS (WINAPI *pSystemFunction009)(const BYTE *, const BYTE *, LPBYTE);
  39 static NTSTATUS (WINAPI *pSystemFunction032)(struct ustring *, const struct ustring *);
  40
  41 /* encrypt two blocks */
  42 static descrypt pSystemFunction012;
  43 static descrypt pSystemFunction014;
  44 static descrypt pSystemFunction016;
  45 static descrypt pSystemFunction018;
  46 static descrypt pSystemFunction020;
  47 static descrypt pSystemFunction022;
  48
  49 /* decrypt two blocks */
  50 static descrypt pSystemFunction013;
  51 static descrypt pSystemFunction015;
  52 static descrypt pSystemFunction017;
  53 static descrypt pSystemFunction019;
  54 static descrypt pSystemFunction021;
  55 static descrypt pSystemFunction023;
  56
  57 /* encrypt two blocks with a 32bit key */
  58 static descrypt pSystemFunction024;
  59 static descrypt pSystemFunction025;
  60
  61 /* decrypt two blocks with a 32bit key */
  62 static descrypt pSystemFunction026;
  63 static descrypt pSystemFunction027;
  64
  65 typedef int (WINAPI *memcmpfunc)(unsigned char *, unsigned char *);
  66 static memcmpfunc pSystemFunction030;
  67 static memcmpfunc pSystemFunction031;
  68
  69 static void test_SystemFunction006(void)
  70 {
  71     char lmhash[16 + 1];
  72
  73     char passwd[] = { 's','e','c','r','e','t', 0, 0, 0, 0, 0, 0, 0, 0 };
  74     unsigned char expect[] =
  75         { 0x85, 0xf5, 0x28, 0x9f, 0x09, 0xdc, 0xa7, 0xeb,
  76           0xaa, 0xd3, 0xb4, 0x35, 0xb5, 0x14, 0x04, 0xee };
  77
  78     pSystemFunction006( passwd, lmhash );
  79
  80     ok( !memcmp( lmhash, expect, sizeof(expect) ),
  81         "lmhash: %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n",
  82         lmhash[0], lmhash[1], lmhash[2], lmhash[3], lmhash[4], lmhash[5],
  83         lmhash[6], lmhash[7], lmhash[8], lmhash[9], lmhash[10], lmhash[11],
  84         lmhash[12], lmhash[13], lmhash[14], lmhash[15] );
  85 }
  86
  87 static void test_SystemFunction008(void)
  88 {
  89     /* example data from http://davenport.sourceforge.net/ntlm.html */
  90     unsigned char hash[0x40] = {
  91         0xff, 0x37, 0x50, 0xbc, 0xc2, 0xb2, 0x24, 0x12,
  92         0xc2, 0x26, 0x5b, 0x23, 0x73, 0x4e, 0x0d, 0xac };
  93     unsigned char challenge[0x40] = {
  94         0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
  95     unsigned char expected[0x18] = {
  96         0xc3, 0x37, 0xcd, 0x5c, 0xbd, 0x44, 0xfc, 0x97,
  97         0x82, 0xa6, 0x67, 0xaf, 0x6d, 0x42, 0x7c, 0x6d,
  98         0xe6, 0x7c, 0x20, 0xc2, 0xd3, 0xe7, 0x7c, 0x56 };
  99     unsigned char output[0x18];
 100     NTSTATUS r;
 101
 102     r = pSystemFunction008(0,0,0);
 103     ok( r == STATUS_UNSUCCESSFUL, "wrong error code\n");
 104
 105     r = pSystemFunction008(challenge,0,0);
 106     ok( r == STATUS_UNSUCCESSFUL, "wrong error code\n");
 107
 108     r = pSystemFunction008(challenge, hash, 0);
 109     ok( r == STATUS_UNSUCCESSFUL, "wrong error code\n");
 110
 111     /* crashes */
 112     if (0)
 113     {
 114         r = pSystemFunction008(challenge, 0, output);
 115         ok( r == STATUS_UNSUCCESSFUL, "wrong error code\n");
 116     }
 117
 118     r = pSystemFunction008(0, 0, output);
 119     ok( r == STATUS_UNSUCCESSFUL, "wrong error code\n");
 120
 121     memset(output, 0, sizeof output);
 122     r = pSystemFunction008(challenge, hash, output);
 123     ok( r == STATUS_SUCCESS, "wrong error code\n");
 124
 125     ok( !memcmp(output, expected, sizeof expected), "response wrong\n");
 126 }
 127
 128 static void test_SystemFunction001(void)
 129 {
 130     unsigned char key[8] = { 0xff, 0x37, 0x50, 0xbc, 0xc2, 0xb2, 0x24, 0 };
 131     unsigned char data[8] = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
 132     unsigned char expected[8] = { 0xc3, 0x37, 0xcd, 0x5c, 0xbd, 0x44, 0xfc, 0x97 };
 133     unsigned char output[16];
 134     NTSTATUS r;
 135
 136     r = pSystemFunction001(0,0,0);
 137     ok( r == STATUS_UNSUCCESSFUL, "wrong error code\n");
 138
 139     memset(output, 0, sizeof output);
 140
 141     r = pSystemFunction001(data,key,output);
 142     ok( r == STATUS_SUCCESS, "wrong error code\n");
 143
 144     ok(!memcmp(output, expected, sizeof expected), "response wrong\n");
 145 }
 146
 147 static void test_SystemFunction002(void)
 148 {
 149     /* reverse of SystemFunction001 */
 150     unsigned char key[8] = { 0xff, 0x37, 0x50, 0xbc, 0xc2, 0xb2, 0x24, 0 };
 151     unsigned char expected[8] = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
 152     unsigned char data[8] = { 0xc3, 0x37, 0xcd, 0x5c, 0xbd, 0x44, 0xfc, 0x97 };
 153     unsigned char output[8];
 154     int r;
 155
 156     memset(output, 0, sizeof output);
 157     r = pSystemFunction002(data, key, output);
 158     ok(r == STATUS_SUCCESS, "function failed\n");
 159     ok(!memcmp(output, expected, sizeof expected), "response wrong\n");
 160 }
 161
 162 static void test_SystemFunction032(void)
 163 {
 164     struct ustring key, data;
 165     unsigned char szKey[] = { 'f','o','o',0 };
 166     unsigned char szData[8] = { 'b','a','r',0 };
 167     unsigned char expected[] = {0x28, 0xb9, 0xf8, 0xe1};
 168     int r;
 169
 170     /* crashes:    pSystemFunction032(NULL,NULL); */
 171
 172     key.Buffer = szKey;
 173     key.Length = sizeof szKey;
 174     key.MaximumLength = key.Length;
 175
 176     data.Buffer = szData;
 177     data.Length = 4;
 178     data.MaximumLength = 8;
 179
 180     r = pSystemFunction032(&data, &key);
 181     ok(r == STATUS_SUCCESS, "function failed\n");
 182
 183     ok(!memcmp(expected, data.Buffer, data.Length), "wrong result\n");
 184 }
 185
 186 static void test_SystemFunction003(void)
 187 {
 188     unsigned char output[8], data[8];
 189     unsigned char key[7] = { 0xff, 0x37, 0x50, 0xbc, 0xc2, 0xb2, 0x24 };
 190     unsigned char exp1[8] = { 0x9d, 0x21, 0xc8, 0x86, 0x6c, 0x21, 0xcf, 0x43 };
 191     char exp2[] = "KGS!@#$%";
 192     int r;
 193
 194     r = pSystemFunction003(NULL, NULL);
 195     ok(r == STATUS_UNSUCCESSFUL, "function failed\n");
 196
 197     r = pSystemFunction003(key, NULL);
 198     ok(r == STATUS_UNSUCCESSFUL, "function failed\n");
 199
 200     memset(data, 0, sizeof data);
 201     r = pSystemFunction003(key, data);
 202     ok(r == STATUS_SUCCESS, "function failed\n");
 203     ok( !memcmp(exp1, data, sizeof data), "decrypted message wrong\n");
 204
 205     memset(output, 0, sizeof output);
 206     r = pSystemFunction002(data, key, output);
 207     ok(r == STATUS_SUCCESS, "function failed\n");
 208
 209     ok( !memcmp(exp2, output, sizeof output), "decrypted message wrong\n");
 210 }
 211
 212 static void test_SystemFunction004(void)
 213 {
 214     unsigned char inbuf[0x100], keybuf[0x100], resbuf[0x100];
 215     unsigned char output[8];
 216     int r;
 217     struct ustring in, key, out;
 218
 219     /* crash
 220     r = pSystemFunction004(NULL, NULL, NULL);
 221     ok(r == STATUS_UNSUCCESSFUL, "function failed\n");
 222     */
 223
 224     memset(inbuf, 0, sizeof inbuf);
 225     memset(keybuf, 0, sizeof keybuf);
 226     memset(resbuf, 0, sizeof resbuf);
 227
 228     in.Buffer = NULL;
 229     in.Length = in.MaximumLength = 0;
 230
 231     key.Buffer = NULL;
 232     key.Length = key.MaximumLength = 0;
 233
 234     out.Buffer = NULL;
 235     out.Length = out.MaximumLength = 0;
 236
 237     r = pSystemFunction004(&in, &key, &out);
 238     ok(r == STATUS_INVALID_PARAMETER_2, "function failed\n");
 239
 240     key.Buffer = keybuf;
 241     key.Length = 0x100;
 242     key.MaximumLength = 0x100;
 243
 244     r = pSystemFunction004(&in, &key, &out);
 245     ok(r == STATUS_BUFFER_TOO_SMALL, "function failed\n");
 246
 247     in.Buffer = inbuf;
 248     in.Length = 0x0c;
 249     in.MaximumLength = 0;
 250
 251     /* add two identical blocks... */
 252     inbuf[0] = 1;
 253     inbuf[1] = 2;
 254     inbuf[2] = 3;
 255     inbuf[3] = 4;
 256
 257     inbuf[8] = 1;
 258     inbuf[9] = 2;
 259     inbuf[10] = 3;
 260     inbuf[11] = 4;
 261
 262     /* check that the Length field is really obeyed */
 263     keybuf[6] = 1;
 264
 265     key.Buffer = keybuf;
 266     key.Length = 6;
 267     key.MaximumLength = 0;
 268
 269     keybuf[1] = 0x33;
 270
 271     out.Buffer = resbuf;
 272     out.Length = 0;
 273     out.MaximumLength = 0x40;
 274     r = pSystemFunction004(&in, &key, &out);
 275     ok(r == STATUS_SUCCESS, "function failed\n");
 276
 277     keybuf[6] = 0;
 278
 279     memset(output, 0, sizeof output);
 280     r = pSystemFunction002(out.Buffer, key.Buffer, output);
 281     ok(r == STATUS_SUCCESS, "function failed\n");
 282
 283     ok(((unsigned int*)output)[0] == in.Length, "crypted length wrong\n");
 284     ok(((unsigned int*)output)[1] == 1, "crypted value wrong\n");
 285
 286     memset(output, 0, sizeof output);
 287     r = pSystemFunction002(out.Buffer+8, key.Buffer, output);
 288     ok(r == STATUS_SUCCESS, "function failed\n");
 289     ok(!memcmp(output, inbuf, sizeof output), "crypted data wrong\n");
 290
 291     memset(output, 0, sizeof output);
 292     r = pSystemFunction002(out.Buffer+16, key.Buffer, output);
 293     ok(r == STATUS_SUCCESS, "function failed\n");
 294     ok(!memcmp(output, inbuf, sizeof output), "crypted data wrong\n");
 295 }
 296
 297 static void test_SystemFunction005(void)
 298 {
 299     char output[0x40], result[0x40];
 300     int r;
 301     struct ustring in, key, out, res;
 302     static char datastr[] = "twinkle twinkle little star";
 303     static char keystr[]  = "byolnim";
 304
 305     in.Buffer = (unsigned char *)datastr;
 306     in.Length = strlen(datastr);
 307     in.MaximumLength = 0;
 308
 309     key.Buffer = (unsigned char *)keystr;
 310     key.Length = strlen(keystr);
 311     key.MaximumLength = 0;
 312
 313     out.Buffer = (unsigned char *)output;
 314     out.Length = out.MaximumLength = sizeof output;
 315
 316     r = pSystemFunction004(&in, &key, &out);
 317     ok(r == STATUS_SUCCESS, "function failed\n");
 318
 319     memset(result, 0, sizeof result);
 320     res.Buffer = (unsigned char *)result;
 321     res.Length = 0;
 322     res.MaximumLength = sizeof result;
 323
 324     r = pSystemFunction005(&out, &key, &res);
 325     ok(r == STATUS_SUCCESS, "function failed\n");
 326
 327     r = pSystemFunction005(&out, &key, &res);
 328     ok(r == STATUS_SUCCESS, "function failed\n");
 329
 330     ok(res.Length == in.Length, "Length wrong\n");
 331     ok(!memcmp(res.Buffer, in.Buffer, in.Length), "data wrong\n");
 332
 333     out.Length = 0;
 334     out.MaximumLength = 0;
 335     r = pSystemFunction005(&out, &key, &res);
 336     ok(r == STATUS_SUCCESS ||
 337        r == STATUS_INVALID_PARAMETER_1, /* Vista */
 338        "Expected STATUS_SUCCESS or STATUS_INVALID_PARAMETER_1, got %08x\n", r);
 339
 340     ok(res.Length == in.Length, "Length wrong\n");
 341     ok(!memcmp(res.Buffer, in.Buffer, in.Length), "data wrong\n");
 342
 343     res.MaximumLength = 0;
 344     r = pSystemFunction005(&out, &key, &res);
 345     ok(r == STATUS_BUFFER_TOO_SMALL ||
 346        r == STATUS_INVALID_PARAMETER_1, /* Vista */
 347        "Expected STATUS_BUFFER_TOO_SMALL or STATUS_INVALID_PARAMETER_1, got %08x\n", r);
 348
 349     key.Length = 1;
 350     r = pSystemFunction005(&out, &key, &res);
 351     ok(r == STATUS_UNKNOWN_REVISION ||
 352        r == STATUS_INVALID_PARAMETER_1, /* Vista */
 353        "Expected STATUS_UNKNOWN_REVISION or STATUS_INVALID_PARAMETER_1, got %08x\n", r);
 354
 355     key.Length = 0;
 356     r = pSystemFunction005(&out, &key, &res);
 357     ok(r == STATUS_INVALID_PARAMETER_2, "function failed\n");
 358 }
 359
 360 static void test_SystemFunction009(void)
 361 {
 362     unsigned char hash[0x10] = {
 363         0xff, 0x37, 0x50, 0xbc, 0xc2, 0xb2, 0x24, 0x12,
 364         0xc2, 0x26, 0x5b, 0x23, 0x73, 0x4e, 0x0d, 0xac };
 365     unsigned char challenge[8] = {
 366         0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
 367     unsigned char expected[0x18] = {
 368         0xc3, 0x37, 0xcd, 0x5c, 0xbd, 0x44, 0xfc, 0x97,
 369         0x82, 0xa6, 0x67, 0xaf, 0x6d, 0x42, 0x7c, 0x6d,
 370         0xe6, 0x7c, 0x20, 0xc2, 0xd3, 0xe7, 0x7c, 0x56 };
 371     unsigned char output[0x18];
 372     int r;
 373
 374     memset(output, 0, sizeof output);
 375     r = pSystemFunction009(challenge, hash, output);
 376     ok( r == STATUS_SUCCESS, "wrong error code\n");
 377     ok(!memcmp(output, expected, sizeof expected), "response wrong\n");
 378 }
 379
 380 static unsigned char des_key[] = {
 381     0xff, 0x37, 0x50, 0xbc, 0xc2, 0xb2, 0x24,
 382     0xff, 0x37, 0x50, 0xbc, 0xc2, 0xb2, 0x24,
 383 };
 384 static unsigned char des_plaintext[] = {
 385     0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
 386     0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0
 387 };
 388 static unsigned char des_ciphertext[] = {
 389     0xc3, 0x37, 0xcd, 0x5c, 0xbd, 0x44, 0xfc, 0x97,
 390     0xc3, 0x37, 0xcd, 0x5c, 0xbd, 0x44, 0xfc, 0x97, 0
 391 };
 392
 393 /* test functions that encrypt two DES blocks */
 394 static void test_SystemFunction_encrypt(descrypt func, int num)
 395 {
 396     unsigned char output[0x11];
 397     int r;
 398
 399     if (!func)
 400     {
 401         win_skip("SystemFunction%03d is not available\n", num);
 402         return;
 403     }
 404
 405     r = func(NULL, NULL, NULL);
 406     ok( r == STATUS_UNSUCCESSFUL, "wrong error code\n");
 407
 408     memset(output, 0, sizeof output);
 409     r = func(des_plaintext, des_key, output);
 410     ok( r == STATUS_SUCCESS, "wrong error code\n");
 411     ok( !memcmp(des_ciphertext, output, sizeof des_ciphertext), "ciphertext wrong (%d)\n", num);
 412 }
 413
 414 /* test functions that decrypt two DES blocks */
 415 static void test_SystemFunction_decrypt(descrypt func, int num)
 416 {
 417     unsigned char output[0x11];
 418     int r;
 419
 420     if (!func)
 421     {
 422         win_skip("SystemFunction%03d is not available\n", num);
 423         return;
 424     }
 425
 426     r = func(NULL, NULL, NULL);
 427     ok( r == STATUS_UNSUCCESSFUL, "wrong error code\n");
 428
 429     memset(output, 0, sizeof output);
 430
 431     r = func(des_ciphertext, des_key, output);
 432     ok( r == STATUS_SUCCESS, "wrong error code\n");
 433     ok( !memcmp(des_plaintext, output, sizeof des_plaintext), "plaintext wrong (%d)\n", num);
 434 }
 435
 436 static unsigned char des_ciphertext32[] = {
 437     0x69, 0x51, 0x35, 0x69, 0x0d, 0x29, 0x24, 0xad,
 438     0x23, 0x6d, 0xfd, 0x43, 0x0d, 0xd3, 0x25, 0x81, 0
 439 };
 440
 441 static void test_SystemFunction_enc32(descrypt func, int num)
 442 {
 443     unsigned char key[4], output[0x11];
 444     int r;
 445
 446     if (!func)
 447     {
 448         win_skip("SystemFunction%03d is not available\n", num);
 449         return;
 450     }
 451
 452     memset(output, 0, sizeof output);
 453
 454     /* two keys are generated using 4 bytes, repeated 4 times ... */
 455     memcpy(key, "foo", 4);
 456
 457     r = func(des_plaintext, key, output);
 458     ok( r == STATUS_SUCCESS, "wrong error code (%d)\n", num);
 459
 460     ok( !memcmp( output, des_ciphertext32, sizeof des_ciphertext32), "ciphertext wrong (%d)\n", num);
 461 }
 462
 463 static void test_SystemFunction_dec32(descrypt func, int num)
 464 {
 465     unsigned char key[4], output[0x11];
 466     int r;
 467
 468     if (!func)
 469     {
 470         win_skip("SystemFunction%03d is not available\n", num);
 471         return;
 472     }
 473
 474     memset(output, 0, sizeof output);
 475
 476     /* two keys are generated using 4 bytes, repeated 4 times ... */
 477     memcpy(key, "foo", 4);
 478
 479     r = func(des_ciphertext32, key, output);
 480     ok( r == STATUS_SUCCESS, "wrong error code (%d)\n", num);
 481
 482     ok( !memcmp( output, des_plaintext, sizeof des_plaintext), "plaintext wrong (%d)\n", num);
 483 }
 484
 485 static void test_memcmpfunc(memcmpfunc fn)
 486 {
 487     unsigned char arg1[0x20], arg2[0x20];
 488     int r;
 489
 490     if (!fn)
 491     {
 492         win_skip("function is not available\n");
 493         return;
 494     }
 495
 496     memset(arg1, 0, sizeof arg1);
 497     memset(arg2, 0, sizeof arg2);
 498     arg1[0x10] = 1;
 499
 500     r = fn(arg1, arg2);
 501     ok( r == 1, "wrong error code\n");
 502
 503     memset(arg1, 1, sizeof arg1);
 504     memset(arg2, 1, sizeof arg2);
 505     arg1[0x10] = 0;
 506
 507     r = fn(arg1, arg2);
 508     ok( r == 1, "wrong error code\n");
 509
 510     memset(arg1, 0, sizeof arg1);
 511     memset(arg2, 1, sizeof arg2);
 512
 513     r = fn(arg1, arg2);
 514     ok( r == 0, "wrong error code\n");
 515
 516     memset(arg1, 1, sizeof arg1);
 517     memset(arg2, 0, sizeof arg2);
 518
 519     r = fn(arg1, arg2);
 520     ok( r == 0, "wrong error code\n");
 521 }
 522
 523 START_TEST(crypt_lmhash)
 524 {
 525     HMODULE module = GetModuleHandleA("advapi32.dll");
 526
 527     pSystemFunction001 = (void *)GetProcAddress( module, "SystemFunction001" );
 528     if (pSystemFunction001)
 529         test_SystemFunction001();
 530     else
 531         win_skip("SystemFunction001 is not available\n");
 532
 533     pSystemFunction002 = (void *)GetProcAddress( module, "SystemFunction002" );
 534     if (pSystemFunction002)
 535         test_SystemFunction002();
 536     else
 537         win_skip("SystemFunction002 is not available\n");
 538
 539     pSystemFunction003 = (void *)GetProcAddress( module, "SystemFunction003" );
 540     if (pSystemFunction003)
 541         test_SystemFunction003();
 542     else
 543         win_skip("SystemFunction002 is not available\n");
 544
 545     pSystemFunction004 = (void *)GetProcAddress( module, "SystemFunction004" );
 546     if (pSystemFunction004)
 547         test_SystemFunction004();
 548     else
 549         win_skip("SystemFunction004 is not available\n");
 550
 551     pSystemFunction005 = (void *)GetProcAddress( module, "SystemFunction005" );
 552     if (pSystemFunction005)
 553         test_SystemFunction005();
 554     else
 555         win_skip("SystemFunction005 is not available\n");
 556
 557     pSystemFunction006 = (void *)GetProcAddress( module, "SystemFunction006" );
 558     if (pSystemFunction006)
 559         test_SystemFunction006();
 560     else
 561         win_skip("SystemFunction006 is not available\n");
 562
 563     pSystemFunction008 = (void *)GetProcAddress( module, "SystemFunction008" );
 564     if (pSystemFunction008)
 565         test_SystemFunction008();
 566     else
 567         win_skip("SystemFunction008 is not available\n");
 568
 569     pSystemFunction009 = (void *)GetProcAddress( module, "SystemFunction009" );
 570     if (pSystemFunction009)
 571         test_SystemFunction009();
 572     else
 573         win_skip("SystemFunction009 is not available\n");
 574
 575     pSystemFunction012 = (descrypt) GetProcAddress( module, "SystemFunction012");
 576     pSystemFunction013 = (descrypt) GetProcAddress( module, "SystemFunction013");
 577     pSystemFunction014 = (descrypt) GetProcAddress( module, "SystemFunction014");
 578     pSystemFunction015 = (descrypt) GetProcAddress( module, "SystemFunction015");
 579     pSystemFunction016 = (descrypt) GetProcAddress( module, "SystemFunction016");
 580     pSystemFunction017 = (descrypt) GetProcAddress( module, "SystemFunction017");
 581     pSystemFunction018 = (descrypt) GetProcAddress( module, "SystemFunction018");
 582     pSystemFunction019 = (descrypt) GetProcAddress( module, "SystemFunction019");
 583     pSystemFunction020 = (descrypt) GetProcAddress( module, "SystemFunction020");
 584     pSystemFunction021 = (descrypt) GetProcAddress( module, "SystemFunction021");
 585     pSystemFunction022 = (descrypt) GetProcAddress( module, "SystemFunction022");
 586     pSystemFunction023 = (descrypt) GetProcAddress( module, "SystemFunction023");
 587
 588     /* these all encrypt two DES blocks */
 589     test_SystemFunction_encrypt(pSystemFunction012, 12);
 590     test_SystemFunction_encrypt(pSystemFunction014, 14);
 591     test_SystemFunction_encrypt(pSystemFunction016, 16);
 592     test_SystemFunction_encrypt(pSystemFunction018, 18);
 593     test_SystemFunction_encrypt(pSystemFunction020, 20);
 594     test_SystemFunction_encrypt(pSystemFunction022, 22);
 595
 596     /* these all decrypt two DES blocks */
 597     test_SystemFunction_decrypt(pSystemFunction013, 13);
 598     test_SystemFunction_decrypt(pSystemFunction015, 15);
 599     test_SystemFunction_decrypt(pSystemFunction017, 17);
 600     test_SystemFunction_decrypt(pSystemFunction019, 19);
 601     test_SystemFunction_decrypt(pSystemFunction021, 21);
 602     test_SystemFunction_decrypt(pSystemFunction023, 23);
 603
 604     pSystemFunction024 = (descrypt) GetProcAddress( module, "SystemFunction024");
 605     pSystemFunction025 = (descrypt) GetProcAddress( module, "SystemFunction025");
 606     pSystemFunction026 = (descrypt) GetProcAddress( module, "SystemFunction026");
 607     pSystemFunction027 = (descrypt) GetProcAddress( module, "SystemFunction027");
 608
 609     /* these encrypt two DES blocks with a short key */
 610     test_SystemFunction_enc32(pSystemFunction024, 24);
 611     test_SystemFunction_enc32(pSystemFunction026, 26);
 612
 613     /* these descrypt two DES blocks with a short key */
 614     test_SystemFunction_dec32(pSystemFunction025, 25);
 615     test_SystemFunction_dec32(pSystemFunction027, 27);
 616
 617     pSystemFunction030 = (memcmpfunc) GetProcAddress( module, "SystemFunction030" );
 618     pSystemFunction031 = (memcmpfunc) GetProcAddress( module, "SystemFunction031" );
 619
 620     test_memcmpfunc(pSystemFunction030);
 621     test_memcmpfunc(pSystemFunction031);
 622
 623     pSystemFunction032 = (void *)GetProcAddress( module, "SystemFunction032" );
 624     if (pSystemFunction032)
 625         test_SystemFunction032();
 626     else
 627         win_skip("SystemFunction032 is not available\n");
 628 }