323 lines
8.4 KiB
C
323 lines
8.4 KiB
C
/*++
|
||
|
||
Copyright (c) 1993 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
encrypt.c
|
||
|
||
Abstract:
|
||
|
||
This module implements the routines for the NetWare
|
||
redirector to mangle an objectid, challenge key and
|
||
password such that a NetWare server will accept the
|
||
password as valid.
|
||
|
||
This program uses information published in Byte Magazine.
|
||
|
||
Author:
|
||
|
||
Colin Watson [ColinW] 15-Mar-1993
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
#include <procs.h>
|
||
|
||
|
||
UCHAR Table[] = {
|
||
0x78, 0x08, 0x64, 0xe4, 0x5c, 0x17, 0xbf, 0xa8,
|
||
0xf8, 0xcc, 0x94, 0x1e, 0x46, 0x24, 0x0a, 0xb9,
|
||
0x2f, 0xb1, 0xd2, 0x19, 0x5e, 0x70, 0x02, 0x66,
|
||
0x07, 0x38, 0x29, 0x3f, 0x7f, 0xcf, 0x64, 0xa0,
|
||
0x23, 0xab, 0xd8, 0x3a, 0x17, 0xcf, 0x18, 0x9d,
|
||
0x91, 0x94, 0xe4, 0xc5, 0x5c, 0x8b, 0x23, 0x9e,
|
||
0x77, 0x69, 0xef, 0xc8, 0xd1, 0xa6, 0xed, 0x07,
|
||
0x7a, 0x01, 0xf5, 0x4b, 0x7b, 0xec, 0x95, 0xd1,
|
||
0xbd, 0x13, 0x5d, 0xe6, 0x30, 0xbb, 0xf3, 0x64,
|
||
0x9d, 0xa3, 0x14, 0x94, 0x83, 0xbe, 0x50, 0x52,
|
||
0xcb, 0xd5, 0xd5, 0xd2, 0xd9, 0xac, 0xa0, 0xb3,
|
||
0x53, 0x69, 0x51, 0xee, 0x0e, 0x82, 0xd2, 0x20,
|
||
0x4f, 0x85, 0x96, 0x86, 0xba, 0xbf, 0x07, 0x28,
|
||
0xc7, 0x3a, 0x14, 0x25, 0xf7, 0xac, 0xe5, 0x93,
|
||
0xe7, 0x12, 0xe1, 0xf4, 0xa6, 0xc6, 0xf4, 0x30,
|
||
0xc0, 0x36, 0xf8, 0x7b, 0x2d, 0xc6, 0xaa, 0x8d } ;
|
||
|
||
|
||
UCHAR Keys[32] =
|
||
{0x48,0x93,0x46,0x67,0x98,0x3D,0xE6,0x8D,
|
||
0xB7,0x10,0x7A,0x26,0x5A,0xB9,0xB1,0x35,
|
||
0x6B,0x0F,0xD5,0x70,0xAE,0xFB,0xAD,0x11,
|
||
0xF4,0x47,0xDC,0xA7,0xEC,0xCF,0x50,0xC0};
|
||
|
||
#define XorArray( DEST, SRC ) { \
|
||
PULONG D = (PULONG)DEST; \
|
||
PULONG S = (PULONG)SRC; \
|
||
int i; \
|
||
for ( i = 0; i <= 7 ; i++ ) { \
|
||
D[i] ^= S[i]; \
|
||
} \
|
||
}
|
||
|
||
VOID
|
||
Shuffle(
|
||
UCHAR *achObjectId,
|
||
UCHAR *szUpperPassword,
|
||
int iPasswordLen,
|
||
UCHAR *achOutputBuffer
|
||
);
|
||
|
||
int
|
||
Scramble(
|
||
int iSeed,
|
||
UCHAR achBuffer[32]
|
||
);
|
||
|
||
#ifdef ALLOC_PRAGMA
|
||
#pragma alloc_text( PAGE, RespondToChallenge )
|
||
#pragma alloc_text( PAGE, Shuffle )
|
||
#pragma alloc_text( PAGE, Scramble )
|
||
#endif
|
||
|
||
|
||
VOID
|
||
RespondToChallenge(
|
||
IN PUCHAR achObjectId,
|
||
IN POEM_STRING Password,
|
||
IN PUCHAR pChallenge,
|
||
OUT PUCHAR pResponse
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine takes the ObjectId and Challenge key from the server and
|
||
encrypts the user supplied password to develop a credential for the
|
||
server to verify.
|
||
|
||
Arguments:
|
||
IN PUCHAR achObjectId - Supplies the 4 byte user's bindery object id
|
||
IN POEM_STRING Password - Supplies the user's uppercased password
|
||
IN PUCHAR pChallenge - Supplies the 8 byte challenge key
|
||
OUT PUCHAR pResponse - Returns the 8 byte response
|
||
|
||
Return Value:
|
||
|
||
none.
|
||
|
||
--*/
|
||
|
||
{
|
||
int index;
|
||
UCHAR achK[32];
|
||
UCHAR achBuf[32];
|
||
|
||
PAGED_CODE();
|
||
|
||
Shuffle(achObjectId, Password->Buffer, Password->Length, achBuf);
|
||
Shuffle( &pChallenge[0], achBuf, 16, &achK[0] );
|
||
Shuffle( &pChallenge[4], achBuf, 16, &achK[16] );
|
||
|
||
for (index = 0; index < 16; index++)
|
||
achK[index] ^= achK[31-index];
|
||
|
||
for (index = 0; index < 8; index++)
|
||
pResponse[index] = achK[index] ^ achK[15-index];
|
||
}
|
||
|
||
|
||
VOID
|
||
Shuffle(
|
||
UCHAR *achObjectId,
|
||
UCHAR *szUpperPassword,
|
||
int iPasswordLen,
|
||
UCHAR *achOutputBuffer
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine shuffles around the object ID with the password
|
||
|
||
Arguments:
|
||
|
||
IN achObjectId - Supplies the 4 byte user's bindery object id
|
||
|
||
IN szUpperPassword - Supplies the user's uppercased password on the
|
||
first call to process the password. On the second and third calls
|
||
this parameter contains the OutputBuffer from the first call
|
||
|
||
IN iPasswordLen - length of uppercased password
|
||
|
||
OUT achOutputBuffer - Returns the 8 byte sub-calculation
|
||
|
||
Return Value:
|
||
|
||
none.
|
||
|
||
--*/
|
||
|
||
{
|
||
int iTempIndex;
|
||
int iOutputIndex;
|
||
UCHAR achTemp[32];
|
||
|
||
PAGED_CODE();
|
||
|
||
//
|
||
// Truncate all trailing zeros from the password.
|
||
//
|
||
|
||
while (iPasswordLen > 0 && szUpperPassword[iPasswordLen-1] == 0 ) {
|
||
iPasswordLen--;
|
||
}
|
||
|
||
//
|
||
// Initialize the achTemp buffer. Initialization consists of taking
|
||
// the password and dividing it up into chunks of 32. Any bytes left
|
||
// over are the remainder and do not go into the initialization.
|
||
//
|
||
// achTemp[0] = szUpperPassword[0] ^ szUpperPassword[32] ^ szUpper...
|
||
// achTemp[1] = szUpperPassword[1] ^ szUpperPassword[33] ^ szUpper...
|
||
// etc.
|
||
//
|
||
|
||
if ( iPasswordLen > 32) {
|
||
|
||
// At least one chunk of 32. Set the buffer to the first chunk.
|
||
|
||
RtlCopyMemory( achTemp, szUpperPassword, 32 );
|
||
|
||
szUpperPassword +=32; // Remove the first chunk
|
||
iPasswordLen -=32;
|
||
|
||
while ( iPasswordLen >= 32 ) {
|
||
//
|
||
// Xor this chunk with the characters already loaded into
|
||
// achTemp.
|
||
//
|
||
|
||
XorArray( achTemp, szUpperPassword);
|
||
|
||
szUpperPassword +=32; // Remove this chunk
|
||
iPasswordLen -=32;
|
||
}
|
||
|
||
} else {
|
||
|
||
// No chunks of 32 so set the buffer to zero's
|
||
|
||
RtlZeroMemory( achTemp, sizeof(achTemp));
|
||
|
||
}
|
||
|
||
//
|
||
// achTemp is now initialized. Load the remainder into achTemp.
|
||
// The remainder is repeated to fill achTemp.
|
||
//
|
||
// The corresponding character from Keys is taken to seperate
|
||
// each repitition.
|
||
//
|
||
// As an example, take the remainder "ABCDEFG". The remainder is expanded
|
||
// to "ABCDEFGwABCDEFGxABCDEFGyABCDEFGz" where w is Keys[7],
|
||
// x is Keys[15], y is Keys[23] and z is Keys[31].
|
||
//
|
||
//
|
||
|
||
if (iPasswordLen > 0) {
|
||
int iPasswordOffset = 0;
|
||
for (iTempIndex = 0; iTempIndex < 32; iTempIndex++) {
|
||
|
||
if (iPasswordLen == iPasswordOffset) {
|
||
iPasswordOffset = 0;
|
||
achTemp[iTempIndex] ^= Keys[iTempIndex];
|
||
} else {
|
||
achTemp[iTempIndex] ^= szUpperPassword[iPasswordOffset++];
|
||
}
|
||
}
|
||
}
|
||
|
||
//
|
||
// achTemp has been loaded with the users password packed into 32
|
||
// bytes. Now take the objectid that came from the server and use
|
||
// that to munge every byte in achTemp.
|
||
//
|
||
|
||
for (iTempIndex = 0; iTempIndex < 32; iTempIndex++)
|
||
achTemp[iTempIndex] ^= achObjectId[ iTempIndex & 3];
|
||
|
||
Scramble( Scramble( 0, achTemp ), achTemp );
|
||
|
||
//
|
||
// Finally take pairs of bytes in achTemp and return the two
|
||
// nibbles obtained from Table. The pairs of bytes used
|
||
// are achTemp[n] and achTemp[n+16].
|
||
//
|
||
|
||
for (iOutputIndex = 0; iOutputIndex < 16; iOutputIndex++) {
|
||
|
||
unsigned int offset = achTemp[iOutputIndex << 1],
|
||
shift = (offset & 0x1) ? 0 : 4 ;
|
||
|
||
achOutputBuffer[iOutputIndex] =
|
||
(Table[offset >> 1] >> shift) & 0xF ;
|
||
|
||
offset = achTemp[(iOutputIndex << 1)+1],
|
||
shift = (offset & 0x1) ? 4 : 0 ;
|
||
|
||
achOutputBuffer[iOutputIndex] |=
|
||
(Table[offset >> 1] << shift) & 0xF0;
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
int
|
||
Scramble(
|
||
int iSeed,
|
||
UCHAR achBuffer[32]
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine scrambles around the contents of the buffer. Each buffer
|
||
position is updated to include the contents of at least two character
|
||
positions plus an EncryptKey value. The buffer is processed left to right
|
||
and so if a character position chooses to merge with a buffer position
|
||
to its left then this buffer position will include bits derived from at
|
||
least 3 bytes of the original buffer contents.
|
||
|
||
Arguments:
|
||
|
||
IN iSeed
|
||
IN OUT achBuffer[32]
|
||
|
||
Return Value:
|
||
|
||
none.
|
||
|
||
--*/
|
||
|
||
{
|
||
int iBufferIndex;
|
||
|
||
PAGED_CODE();
|
||
|
||
for (iBufferIndex = 0; iBufferIndex < 32; iBufferIndex++) {
|
||
achBuffer[iBufferIndex] =
|
||
(UCHAR)(
|
||
((UCHAR)(achBuffer[iBufferIndex] + iSeed)) ^
|
||
((UCHAR)( achBuffer[(iBufferIndex+iSeed) & 31] -
|
||
Keys[iBufferIndex] )));
|
||
|
||
iSeed += achBuffer[iBufferIndex];
|
||
}
|
||
return iSeed;
|
||
}
|
||
|
||
|