crypt_lmhash.c File Reference

#include <stdio.h>
#include "ntstatus.h"
#include "wine/test.h"
#include "windef.h"
#include "winbase.h"
#include "winternl.h"

Include dependency graph for crypt_lmhash.c:

Go to the source code of this file.

Classes
struct	ustring

Macros
#define	WIN32_NO_STATUS

Typedefs
typedef int(WINAPI *	descrypt) (unsigned char *, unsigned char *, unsigned char *)
typedef int(WINAPI *	memcmpfunc) (unsigned char *, unsigned char *)

Functions
static	NTSTATUS (WINAPI *pSystemFunction001)(const BYTE *
static const struct ustring struct ustring *static const struct ustring struct ustring *static	VOID (WINAPI *pSystemFunction006)(PCSTR passwd
static void	test_SystemFunction006 (void)
static void	test_SystemFunction008 (void)
static void	test_SystemFunction001 (void)
static void	test_SystemFunction002 (void)
static void	test_SystemFunction032 (void)
static void	test_SystemFunction003 (void)
static void	test_SystemFunction004 (void)
static void	test_SystemFunction005 (void)
static void	test_SystemFunction009 (void)
static void	test_SystemFunction_encrypt (descrypt func, int num)
static void	test_SystemFunction_decrypt (descrypt func, int num)
static void	test_SystemFunction_enc32 (descrypt func, int num)
static void	test_SystemFunction_dec32 (descrypt func, int num)
static void	test_memcmpfunc (memcmpfunc fn)
	START_TEST (crypt_lmhash)

Variables
static const BYTE	LPBYTE
static const struct ustring struct ustring *static const struct ustring struct ustring *static PSTR	lmhash
static const struct ustring *static descrypt	pSystemFunction012
static descrypt	pSystemFunction014
static descrypt	pSystemFunction016
static descrypt	pSystemFunction018
static descrypt	pSystemFunction020
static descrypt	pSystemFunction022
static descrypt	pSystemFunction013
static descrypt	pSystemFunction015
static descrypt	pSystemFunction017
static descrypt	pSystemFunction019
static descrypt	pSystemFunction021
static descrypt	pSystemFunction023
static descrypt	pSystemFunction024
static descrypt	pSystemFunction025
static descrypt	pSystemFunction026
static descrypt	pSystemFunction027
static memcmpfunc	pSystemFunction030
static memcmpfunc	pSystemFunction031
static unsigned char	des_key []
static unsigned char	des_plaintext []
static unsigned char	des_ciphertext []
static unsigned char	des_ciphertext32 []

Macro Definition Documentation

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 25 of file crypt_lmhash.c.

Typedef Documentation

descrypt

typedef int(WINAPI * descrypt) (unsigned char *, unsigned char *, unsigned char *)

Definition at line 37 of file crypt_lmhash.c.

memcmpfunc

typedef int(WINAPI * memcmpfunc) (unsigned char *, unsigned char *)

Definition at line 72 of file crypt_lmhash.c.

Function Documentation

NTSTATUS()

static NTSTATUS ( WINAPI *  pSystemFunction001 ) const

static

START_TEST()

START_TEST

(

crypt_lmhash

)

Definition at line 530 of file crypt_lmhash.c.

{
    HMODULE module = GetModuleHandleA("advapi32.dll");
 
    pSystemFunction001 = (void *)GetProcAddress( module, "SystemFunction001" );
    if (pSystemFunction001)
        test_SystemFunction001();
    else
        win_skip("SystemFunction001 is not available\n");
 
    pSystemFunction002 = (void *)GetProcAddress( module, "SystemFunction002" );
    if (pSystemFunction002)
        test_SystemFunction002();
    else
        win_skip("SystemFunction002 is not available\n");
 
    pSystemFunction003 = (void *)GetProcAddress( module, "SystemFunction003" );
    if (pSystemFunction003)
        test_SystemFunction003();
    else
        win_skip("SystemFunction002 is not available\n");
 
    pSystemFunction004 = (void *)GetProcAddress( module, "SystemFunction004" );
    if (pSystemFunction004)
        test_SystemFunction004();
    else
        win_skip("SystemFunction004 is not available\n");
 
    pSystemFunction005 = (void *)GetProcAddress( module, "SystemFunction005" );
    if (pSystemFunction005)
        test_SystemFunction005();
    else
        win_skip("SystemFunction005 is not available\n");
 
    pSystemFunction006 = (void *)GetProcAddress( module, "SystemFunction006" );
    if (pSystemFunction006) 
        test_SystemFunction006();
    else
        win_skip("SystemFunction006 is not available\n");
 
    pSystemFunction008 = (void *)GetProcAddress( module, "SystemFunction008" );
    if (pSystemFunction008)
        test_SystemFunction008();
    else
        win_skip("SystemFunction008 is not available\n");
 
    pSystemFunction009 = (void *)GetProcAddress( module, "SystemFunction009" );
    if (pSystemFunction009)
        test_SystemFunction009();
    else
        win_skip("SystemFunction009 is not available\n");
 
    pSystemFunction012 = (descrypt) GetProcAddress( module, "SystemFunction012");
    pSystemFunction013 = (descrypt) GetProcAddress( module, "SystemFunction013");
    pSystemFunction014 = (descrypt) GetProcAddress( module, "SystemFunction014");
    pSystemFunction015 = (descrypt) GetProcAddress( module, "SystemFunction015");
    pSystemFunction016 = (descrypt) GetProcAddress( module, "SystemFunction016");
    pSystemFunction017 = (descrypt) GetProcAddress( module, "SystemFunction017");
    pSystemFunction018 = (descrypt) GetProcAddress( module, "SystemFunction018");
    pSystemFunction019 = (descrypt) GetProcAddress( module, "SystemFunction019");
    pSystemFunction020 = (descrypt) GetProcAddress( module, "SystemFunction020");
    pSystemFunction021 = (descrypt) GetProcAddress( module, "SystemFunction021");
    pSystemFunction022 = (descrypt) GetProcAddress( module, "SystemFunction022");
    pSystemFunction023 = (descrypt) GetProcAddress( module, "SystemFunction023");
 
    /* these all encrypt two DES blocks */
    test_SystemFunction_encrypt(pSystemFunction012, 12);
    test_SystemFunction_encrypt(pSystemFunction014, 14);
    test_SystemFunction_encrypt(pSystemFunction016, 16);
    test_SystemFunction_encrypt(pSystemFunction018, 18);
    test_SystemFunction_encrypt(pSystemFunction020, 20);
    test_SystemFunction_encrypt(pSystemFunction022, 22);
 
    /* these all decrypt two DES blocks */
    test_SystemFunction_decrypt(pSystemFunction013, 13);
    test_SystemFunction_decrypt(pSystemFunction015, 15);
    test_SystemFunction_decrypt(pSystemFunction017, 17);
    test_SystemFunction_decrypt(pSystemFunction019, 19);
    test_SystemFunction_decrypt(pSystemFunction021, 21);
    test_SystemFunction_decrypt(pSystemFunction023, 23);
 
    pSystemFunction024 = (descrypt) GetProcAddress( module, "SystemFunction024");
    pSystemFunction025 = (descrypt) GetProcAddress( module, "SystemFunction025");
    pSystemFunction026 = (descrypt) GetProcAddress( module, "SystemFunction026");
    pSystemFunction027 = (descrypt) GetProcAddress( module, "SystemFunction027");
 
    /* these encrypt two DES blocks with a short key */
    test_SystemFunction_enc32(pSystemFunction024, 24);
    test_SystemFunction_enc32(pSystemFunction026, 26);
 
    /* these descrypt two DES blocks with a short key */
    test_SystemFunction_dec32(pSystemFunction025, 25);
    test_SystemFunction_dec32(pSystemFunction027, 27);
 
    pSystemFunction030 = (memcmpfunc) GetProcAddress( module, "SystemFunction030" );
    pSystemFunction031 = (memcmpfunc) GetProcAddress( module, "SystemFunction031" );
 
    test_memcmpfunc(pSystemFunction030);
    test_memcmpfunc(pSystemFunction031);
 
    pSystemFunction032 = (void *)GetProcAddress( module, "SystemFunction032" );
    if (pSystemFunction032)
        test_SystemFunction032();
    else
        win_skip("SystemFunction032 is not available\n");
}

test_memcmpfunc()

static void test_memcmpfunc ( memcmpfunc  fn )

static

Definition at line 492 of file crypt_lmhash.c.

{
    unsigned char arg1[0x20], arg2[0x20];
    int r;
 
    if (!fn)
    {
        win_skip("function is not available\n");
        return;
    }
 
    memset(arg1, 0, sizeof arg1);
    memset(arg2, 0, sizeof arg2);
    arg1[0x10] = 1;
 
    r = fn(arg1, arg2);
    ok( r == 1, "wrong error code\n");
 
    memset(arg1, 1, sizeof arg1);
    memset(arg2, 1, sizeof arg2);
    arg1[0x10] = 0;
 
    r = fn(arg1, arg2);
    ok( r == 1, "wrong error code\n");
 
    memset(arg1, 0, sizeof arg1);
    memset(arg2, 1, sizeof arg2);
 
    r = fn(arg1, arg2);
    ok( r == 0, "wrong error code\n");
 
    memset(arg1, 1, sizeof arg1);
    memset(arg2, 0, sizeof arg2);
 
    r = fn(arg1, arg2);
    ok( r == 0, "wrong error code\n");
}

Referenced by START_TEST().

test_SystemFunction001()

static void test_SystemFunction001 ( void  )

static

Definition at line 135 of file crypt_lmhash.c.

{
    unsigned char key[8] = { 0xff, 0x37, 0x50, 0xbc, 0xc2, 0xb2, 0x24, 0 };
    unsigned char data[8] = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
    unsigned char expected[8] = { 0xc3, 0x37, 0xcd, 0x5c, 0xbd, 0x44, 0xfc, 0x97 };
    unsigned char output[16];
    NTSTATUS r;
 
    r = pSystemFunction001(0,0,0);
    ok( r == STATUS_UNSUCCESSFUL, "wrong error code\n");
 
    memset(output, 0, sizeof output);
 
    r = pSystemFunction001(data,key,output);
    ok( r == STATUS_SUCCESS, "wrong error code\n");
 
    ok(!memcmp(output, expected, sizeof expected), "response wrong\n");
}

Referenced by START_TEST().

test_SystemFunction002()

static void test_SystemFunction002 ( void  )

static

Definition at line 154 of file crypt_lmhash.c.

{
    /* reverse of SystemFunction001 */
    unsigned char key[8] = { 0xff, 0x37, 0x50, 0xbc, 0xc2, 0xb2, 0x24, 0 };
    unsigned char expected[8] = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
    unsigned char data[8] = { 0xc3, 0x37, 0xcd, 0x5c, 0xbd, 0x44, 0xfc, 0x97 };
    unsigned char output[8];
    int r;
 
    memset(output, 0, sizeof output);
    r = pSystemFunction002(data, key, output);
    ok(r == STATUS_SUCCESS, "function failed\n");
    ok(!memcmp(output, expected, sizeof expected), "response wrong\n");
}

Referenced by START_TEST().

test_SystemFunction003()

static void test_SystemFunction003 ( void  )

static

Definition at line 193 of file crypt_lmhash.c.

{
    unsigned char output[8], data[8];
    unsigned char key[7] = { 0xff, 0x37, 0x50, 0xbc, 0xc2, 0xb2, 0x24 };
    unsigned char exp1[8] = { 0x9d, 0x21, 0xc8, 0x86, 0x6c, 0x21, 0xcf, 0x43 };
    char exp2[] = "KGS!@#$%";
    int r;
 
    r = pSystemFunction003(NULL, NULL);
    ok(r == STATUS_UNSUCCESSFUL, "function failed\n");
 
    r = pSystemFunction003(key, NULL);
    ok(r == STATUS_UNSUCCESSFUL, "function failed\n");
 
    memset(data, 0, sizeof data);
    r = pSystemFunction003(key, data);
    ok(r == STATUS_SUCCESS, "function failed\n");
    ok( !memcmp(exp1, data, sizeof data), "decrypted message wrong\n");
 
    memset(output, 0, sizeof output);
    r = pSystemFunction002(data, key, output);
    ok(r == STATUS_SUCCESS, "function failed\n");
 
    ok( !memcmp(exp2, output, sizeof output), "decrypted message wrong\n");
}

Referenced by START_TEST().

test_SystemFunction004()

static void test_SystemFunction004 ( void  )

static

Definition at line 219 of file crypt_lmhash.c.

{
    unsigned char inbuf[0x100], keybuf[0x100], resbuf[0x100];
    unsigned char output[8];
    int r;
    struct ustring in, key, out;
 
    /* crash 
    r = pSystemFunction004(NULL, NULL, NULL);
    ok(r == STATUS_UNSUCCESSFUL, "function failed\n");
    */
 
    memset(inbuf, 0, sizeof inbuf);
    memset(keybuf, 0, sizeof keybuf);
    memset(resbuf, 0, sizeof resbuf);
 
    in.Buffer = NULL;
    in.Length = in.MaximumLength = 0;
 
    key.Buffer = NULL;
    key.Length = key.MaximumLength = 0;
 
    out.Buffer = NULL;
    out.Length = out.MaximumLength = 0;
 
    r = pSystemFunction004(&in, &key, &out);
    ok(r == STATUS_INVALID_PARAMETER_2, "function failed\n");
 
    key.Buffer = keybuf;
    key.Length = 0x100;
    key.MaximumLength = 0x100;
 
    r = pSystemFunction004(&in, &key, &out);
    ok(r == STATUS_BUFFER_TOO_SMALL, "function failed\n");
 
    in.Buffer = inbuf;
    in.Length = 0x0c;
    in.MaximumLength = 0;
 
    /* add two identical blocks... */
    inbuf[0] = 1;
    inbuf[1] = 2;
    inbuf[2] = 3;
    inbuf[3] = 4;
 
    inbuf[8] = 1;
    inbuf[9] = 2;
    inbuf[10] = 3;
    inbuf[11] = 4;
 
    /* check that the Length field is really obeyed */
    keybuf[6] = 1;
 
    key.Buffer = keybuf;
    key.Length = 6;
    key.MaximumLength = 0;
 
    keybuf[1] = 0x33;
 
    out.Buffer = resbuf;
    out.Length = 0;
    out.MaximumLength = 0x40;
    r = pSystemFunction004(&in, &key, &out);
    ok(r == STATUS_SUCCESS, "function failed\n");
 
    keybuf[6] = 0;
 
    memset(output, 0, sizeof output);
    r = pSystemFunction002(out.Buffer, key.Buffer, output);
    ok(r == STATUS_SUCCESS, "function failed\n");
 
    ok(((unsigned int*)output)[0] == in.Length, "crypted length wrong\n");
    ok(((unsigned int*)output)[1] == 1, "crypted value wrong\n");
 
    memset(output, 0, sizeof output);
    r = pSystemFunction002(out.Buffer+8, key.Buffer, output);
    ok(r == STATUS_SUCCESS, "function failed\n");
    ok(!memcmp(output, inbuf, sizeof output), "crypted data wrong\n");
 
    memset(output, 0, sizeof output);
    r = pSystemFunction002(out.Buffer+16, key.Buffer, output);
    ok(r == STATUS_SUCCESS, "function failed\n");
    ok(!memcmp(output, inbuf, sizeof output), "crypted data wrong\n");
}

Referenced by START_TEST().

test_SystemFunction005()

static void test_SystemFunction005 ( void  )

static

Definition at line 304 of file crypt_lmhash.c.

{
    char output[0x40], result[0x40];
    int r;
    struct ustring in, key, out, res;
    static char datastr[] = "twinkle twinkle little star";
    static char keystr[]  = "byolnim";
 
    in.Buffer = (unsigned char *)datastr;
    in.Length = strlen(datastr);
    in.MaximumLength = 0;
 
    key.Buffer = (unsigned char *)keystr;
    key.Length = strlen(keystr);
    key.MaximumLength = 0;
 
    out.Buffer = (unsigned char *)output;
    out.Length = out.MaximumLength = sizeof output;
 
    r = pSystemFunction004(&in, &key, &out);
    ok(r == STATUS_SUCCESS, "function failed\n");
 
    memset(result, 0, sizeof result);
    res.Buffer = (unsigned char *)result;
    res.Length = 0;
    res.MaximumLength = sizeof result;
 
    r = pSystemFunction005(&out, &key, &res);
    ok(r == STATUS_SUCCESS, "function failed\n");
 
    r = pSystemFunction005(&out, &key, &res);
    ok(r == STATUS_SUCCESS, "function failed\n");
 
    ok(res.Length == in.Length, "Length wrong\n");
    ok(!memcmp(res.Buffer, in.Buffer, in.Length), "data wrong\n");
 
    out.Length = 0;
    out.MaximumLength = 0;
    r = pSystemFunction005(&out, &key, &res);
    ok(r == STATUS_SUCCESS ||
       r == STATUS_INVALID_PARAMETER_1, /* Vista */
       "Expected STATUS_SUCCESS or STATUS_INVALID_PARAMETER_1, got %08x\n", r);
 
    ok(res.Length == in.Length, "Length wrong\n");
    ok(!memcmp(res.Buffer, in.Buffer, in.Length), "data wrong\n");
 
    res.MaximumLength = 0;
    r = pSystemFunction005(&out, &key, &res);
    ok(r == STATUS_BUFFER_TOO_SMALL ||
       r == STATUS_INVALID_PARAMETER_1, /* Vista */
       "Expected STATUS_BUFFER_TOO_SMALL or STATUS_INVALID_PARAMETER_1, got %08x\n", r);
 
    key.Length = 1;
    r = pSystemFunction005(&out, &key, &res);
    ok(r == STATUS_UNKNOWN_REVISION ||
       r == STATUS_INVALID_PARAMETER_1, /* Vista */
       "Expected STATUS_UNKNOWN_REVISION or STATUS_INVALID_PARAMETER_1, got %08x\n", r);
 
    key.Length = 0;
    r = pSystemFunction005(&out, &key, &res);
    ok(r == STATUS_INVALID_PARAMETER_2, "function failed\n");
}

Referenced by START_TEST().

test_SystemFunction006()

static void test_SystemFunction006 ( void  )

static

Definition at line 76 of file crypt_lmhash.c.

{
    char lmhash[16 + 1];
 
    char passwd[] = { 's','e','c','r','e','t', 0, 0, 0, 0, 0, 0, 0, 0 };
    unsigned char expect[] = 
        { 0x85, 0xf5, 0x28, 0x9f, 0x09, 0xdc, 0xa7, 0xeb,
          0xaa, 0xd3, 0xb4, 0x35, 0xb5, 0x14, 0x04, 0xee };
 
    pSystemFunction006( passwd, lmhash );
 
    ok( !memcmp( lmhash, expect, sizeof(expect) ),
        "lmhash: %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n",
        lmhash[0], lmhash[1], lmhash[2], lmhash[3], lmhash[4], lmhash[5],
        lmhash[6], lmhash[7], lmhash[8], lmhash[9], lmhash[10], lmhash[11],
        lmhash[12], lmhash[13], lmhash[14], lmhash[15] );
}

Referenced by START_TEST().

test_SystemFunction008()

static void test_SystemFunction008 ( void  )

static

Definition at line 94 of file crypt_lmhash.c.

{
    /* example data from http://davenport.sourceforge.net/ntlm.html */
    unsigned char hash[0x40] = {
        0xff, 0x37, 0x50, 0xbc, 0xc2, 0xb2, 0x24, 0x12,
        0xc2, 0x26, 0x5b, 0x23, 0x73, 0x4e, 0x0d, 0xac };
    unsigned char challenge[0x40] = {
        0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
    unsigned char expected[0x18] = {
        0xc3, 0x37, 0xcd, 0x5c, 0xbd, 0x44, 0xfc, 0x97,
        0x82, 0xa6, 0x67, 0xaf, 0x6d, 0x42, 0x7c, 0x6d,
        0xe6, 0x7c, 0x20, 0xc2, 0xd3, 0xe7, 0x7c, 0x56 };
    unsigned char output[0x18];
    NTSTATUS r;
 
    r = pSystemFunction008(0,0,0);
    ok( r == STATUS_UNSUCCESSFUL, "wrong error code\n");
 
    r = pSystemFunction008(challenge,0,0);
    ok( r == STATUS_UNSUCCESSFUL, "wrong error code\n");
 
    r = pSystemFunction008(challenge, hash, 0);
    ok( r == STATUS_UNSUCCESSFUL, "wrong error code\n");
 
    /* crashes */
    if (0)
    {
        r = pSystemFunction008(challenge, 0, output);
        ok( r == STATUS_UNSUCCESSFUL, "wrong error code\n");
    }
 
    r = pSystemFunction008(0, 0, output);
    ok( r == STATUS_UNSUCCESSFUL, "wrong error code\n");
 
    memset(output, 0, sizeof output);
    r = pSystemFunction008(challenge, hash, output);
    ok( r == STATUS_SUCCESS, "wrong error code\n");
 
    ok( !memcmp(output, expected, sizeof expected), "response wrong\n");
}

Referenced by START_TEST().

test_SystemFunction009()

static void test_SystemFunction009 ( void  )

static

Definition at line 367 of file crypt_lmhash.c.

{
    unsigned char hash[0x10] = {
        0xff, 0x37, 0x50, 0xbc, 0xc2, 0xb2, 0x24, 0x12,
        0xc2, 0x26, 0x5b, 0x23, 0x73, 0x4e, 0x0d, 0xac };
    unsigned char challenge[8] = {
        0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
    unsigned char expected[0x18] = {
        0xc3, 0x37, 0xcd, 0x5c, 0xbd, 0x44, 0xfc, 0x97,
        0x82, 0xa6, 0x67, 0xaf, 0x6d, 0x42, 0x7c, 0x6d,
        0xe6, 0x7c, 0x20, 0xc2, 0xd3, 0xe7, 0x7c, 0x56 };
    unsigned char output[0x18];
    int r;
 
    memset(output, 0, sizeof output);
    r = pSystemFunction009(challenge, hash, output);
    ok( r == STATUS_SUCCESS, "wrong error code\n");
    ok(!memcmp(output, expected, sizeof expected), "response wrong\n");
}

Referenced by START_TEST().

test_SystemFunction032()

static void test_SystemFunction032 ( void  )

static

Definition at line 169 of file crypt_lmhash.c.

{
    struct ustring key, data;
    unsigned char szKey[] = { 'f','o','o',0 };
    unsigned char szData[8] = { 'b','a','r',0 };
    unsigned char expected[] = {0x28, 0xb9, 0xf8, 0xe1};
    int r;
 
    /* crashes:    pSystemFunction032(NULL,NULL); */
 
    key.Buffer = szKey;
    key.Length = sizeof szKey;
    key.MaximumLength = key.Length;
 
    data.Buffer = szData;
    data.Length = 4;
    data.MaximumLength = 8;
 
    r = pSystemFunction032(&data, &key);
    ok(r == STATUS_SUCCESS, "function failed\n");
 
    ok(!memcmp(expected, data.Buffer, data.Length), "wrong result\n");
}

Referenced by START_TEST().

test_SystemFunction_dec32()

static void test_SystemFunction_dec32 ( descrypt  func, int  num  )

static

Definition at line 470 of file crypt_lmhash.c.

{
    unsigned char key[4], output[0x11];
    int r;
 
    if (!func)
    {
        win_skip("SystemFunction%03d is not available\n", num);
        return;
    }
 
    memset(output, 0, sizeof output);
 
    /* two keys are generated using 4 bytes, repeated 4 times ... */
    memcpy(key, "foo", 4);
 
    r = func(des_ciphertext32, key, output);
    ok( r == STATUS_SUCCESS, "wrong error code (%d)\n", num);
 
    ok( !memcmp( output, des_plaintext, sizeof des_plaintext), "plaintext wrong (%d)\n", num);
}

Referenced by START_TEST().

test_SystemFunction_decrypt()

static void test_SystemFunction_decrypt ( descrypt  func, int  num  )

static

Definition at line 422 of file crypt_lmhash.c.

{
    unsigned char output[0x11];
    int r;
 
    if (!func)
    {
        win_skip("SystemFunction%03d is not available\n", num);
        return;
    }
 
    r = func(NULL, NULL, NULL);
    ok( r == STATUS_UNSUCCESSFUL, "wrong error code\n");
 
    memset(output, 0, sizeof output);
 
    r = func(des_ciphertext, des_key, output);
    ok( r == STATUS_SUCCESS, "wrong error code\n");
    ok( !memcmp(des_plaintext, output, sizeof des_plaintext), "plaintext wrong (%d)\n", num);
}

Referenced by START_TEST().

test_SystemFunction_enc32()

static void test_SystemFunction_enc32 ( descrypt  func, int  num  )

static

Definition at line 448 of file crypt_lmhash.c.

{
    unsigned char key[4], output[0x11];
    int r;
 
    if (!func)
    {
        win_skip("SystemFunction%03d is not available\n", num);
        return;
    }
 
    memset(output, 0, sizeof output);
 
    /* two keys are generated using 4 bytes, repeated 4 times ... */
    memcpy(key, "foo", 4);
 
    r = func(des_plaintext, key, output);
    ok( r == STATUS_SUCCESS, "wrong error code (%d)\n", num);
 
    ok( !memcmp( output, des_ciphertext32, sizeof des_ciphertext32), "ciphertext wrong (%d)\n", num);
}

Referenced by START_TEST().

test_SystemFunction_encrypt()

static void test_SystemFunction_encrypt ( descrypt  func, int  num  )

static

Definition at line 401 of file crypt_lmhash.c.

{
    unsigned char output[0x11];
    int r;
 
    if (!func)
    {
        win_skip("SystemFunction%03d is not available\n", num);
        return;
    }
 
    r = func(NULL, NULL, NULL);
    ok( r == STATUS_UNSUCCESSFUL, "wrong error code\n");
 
    memset(output, 0, sizeof output);
    r = func(des_plaintext, des_key, output);
    ok( r == STATUS_SUCCESS, "wrong error code\n");
    ok( !memcmp(des_ciphertext, output, sizeof des_ciphertext), "ciphertext wrong (%d)\n", num);
}

Referenced by START_TEST().

VOID()

static const struct ustring struct ustring *static const struct ustring struct ustring *static VOID ( WINAPI *  pSystemFunction006 )

static

Variable Documentation

des_ciphertext

unsigned char des_ciphertext[]

static

Initial value:

= { 
    0xc3, 0x37, 0xcd, 0x5c, 0xbd, 0x44, 0xfc, 0x97,
    0xc3, 0x37, 0xcd, 0x5c, 0xbd, 0x44, 0xfc, 0x97, 0
}

Definition at line 395 of file crypt_lmhash.c.

Referenced by test_SystemFunction_decrypt(), and test_SystemFunction_encrypt().

des_ciphertext32

unsigned char des_ciphertext32[]

static

Initial value:

= { 
    0x69, 0x51, 0x35, 0x69, 0x0d, 0x29, 0x24, 0xad,
    0x23, 0x6d, 0xfd, 0x43, 0x0d, 0xd3, 0x25, 0x81, 0
}

Definition at line 443 of file crypt_lmhash.c.

Referenced by test_SystemFunction_dec32(), and test_SystemFunction_enc32().

des_key

unsigned char des_key[]

static

Initial value:

= { 
    0xff, 0x37, 0x50, 0xbc, 0xc2, 0xb2, 0x24, 
    0xff, 0x37, 0x50, 0xbc, 0xc2, 0xb2, 0x24, 
}

Definition at line 387 of file crypt_lmhash.c.

des_plaintext

unsigned char des_plaintext[]

static

Initial value:

= { 
    0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 
    0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0 
}

Definition at line 391 of file crypt_lmhash.c.

Referenced by test_SystemFunction_dec32(), test_SystemFunction_decrypt(), test_SystemFunction_enc32(), and test_SystemFunction_encrypt().

lmhash

const struct ustring struct ustring *static const struct ustring struct ustring *static PSTR lmhash

Definition at line 43 of file crypt_lmhash.c.

Referenced by test_SystemFunction006().

LPBYTE

const BYTE LPBYTE

Definition at line 38 of file crypt_lmhash.c.

pSystemFunction012

const struct ustring* static descrypt pSystemFunction012

static

Definition at line 49 of file crypt_lmhash.c.

Referenced by START_TEST().

pSystemFunction013

descrypt pSystemFunction013

static

Definition at line 57 of file crypt_lmhash.c.

Referenced by START_TEST().

pSystemFunction014

descrypt pSystemFunction014

static

Definition at line 50 of file crypt_lmhash.c.

Referenced by START_TEST().

pSystemFunction015

descrypt pSystemFunction015

static

Definition at line 58 of file crypt_lmhash.c.

Referenced by START_TEST().

pSystemFunction016

descrypt pSystemFunction016

static

Definition at line 51 of file crypt_lmhash.c.

Referenced by START_TEST().

pSystemFunction017

descrypt pSystemFunction017

static

Definition at line 59 of file crypt_lmhash.c.

Referenced by START_TEST().

pSystemFunction018

descrypt pSystemFunction018

static

Definition at line 52 of file crypt_lmhash.c.

Referenced by START_TEST().

pSystemFunction019

descrypt pSystemFunction019

static

Definition at line 60 of file crypt_lmhash.c.

Referenced by START_TEST().

pSystemFunction020

descrypt pSystemFunction020

static

Definition at line 53 of file crypt_lmhash.c.

Referenced by START_TEST().

pSystemFunction021

descrypt pSystemFunction021

static

Definition at line 61 of file crypt_lmhash.c.

Referenced by START_TEST().

pSystemFunction022

descrypt pSystemFunction022

static

Definition at line 54 of file crypt_lmhash.c.

Referenced by START_TEST().

pSystemFunction023

descrypt pSystemFunction023

static

Definition at line 62 of file crypt_lmhash.c.

Referenced by START_TEST().

pSystemFunction024

descrypt pSystemFunction024

static

Definition at line 65 of file crypt_lmhash.c.

Referenced by START_TEST().

pSystemFunction025

descrypt pSystemFunction025

static

Definition at line 66 of file crypt_lmhash.c.

Referenced by START_TEST().

pSystemFunction026

descrypt pSystemFunction026

static

Definition at line 69 of file crypt_lmhash.c.

Referenced by START_TEST().

pSystemFunction027

descrypt pSystemFunction027

static

Definition at line 70 of file crypt_lmhash.c.

Referenced by START_TEST().

pSystemFunction030

memcmpfunc pSystemFunction030

static

Definition at line 73 of file crypt_lmhash.c.

Referenced by START_TEST().

pSystemFunction031

memcmpfunc pSystemFunction031

static

Definition at line 74 of file crypt_lmhash.c.

Referenced by START_TEST().