|
|
/*++
mkkey.c
routines to create the key in the keytab.
3/27/1997 - Created from routines in munge.c, DavidCHR
CONTENTS: CreateUnicodeStringFromAnsiString
--*/
#include "master.h"
#include "defs.h"
#include "keytab.h"
#include "keytypes.h"
/******************************************************************
* hack to preserve our debugging macro because asn1code.h * * will redefine it... egads, I thought everyone used DEBUG * * only for debugging... (it still ends up redefined...) * ******************************************************************/#ifdef DEBUG
#define OLDDEBUG DEBUG
#endif
#include <kerbcon.h>
#undef _KERBCOMM_H_ /* WASBUG 73905 */
#include "kerbcomm.h"
#undef DEBUG
#ifdef OLDDEBUG
#define DEBUG OLDDEBUG
#endif
/******************************************************************/BOOL KtDumpSalt = (#if DBG
TRUE#else
FALSE#endif
);
/* This is the character we separate principal components with */
#define COMPONENT_SEPARATOR '/'
/*++**************************************************************
NAME: CreateUnicodeStringFromAnsiString
allocates a unicode string from an ANSI string.
MODIFIES: ppUnicodeString -- returned unicode string TAKES: AnsiString -- ansi string to convert
RETURNS: TRUE when the function succeeds. FALSE otherwise. LASTERROR: not set
LOGGING: fprintf on failure CREATED: Feb 8, 1999 LOCKING: none CALLED BY: anyone FREE WITH: free()
**************************************************************--*/
BOOLCreateUnicodeStringFromAnsiString( IN PCHAR AnsiString, OUT PUNICODE_STRING *ppUnicodeString ) {
USHORT StringLength; LPBYTE pbString; PUNICODE_STRING pu;
StringLength = (USHORT)lstrlen( AnsiString ); // does not include null byte
pbString = (PBYTE) malloc( ( ( ( StringLength ) +1 ) * sizeof( WCHAR ) ) + sizeof( UNICODE_STRING ) );
if ( pbString ) {
pu = (PUNICODE_STRING) pbString; pbString += sizeof( *pu ); pu->Buffer = (LPWSTR) pbString; pu->Length = StringLength * sizeof( WCHAR ); pu->MaximumLength = pu->Length + sizeof( WCHAR );
wsprintfW( pu->Buffer, L"%hs", AnsiString );
*ppUnicodeString = pu;
return TRUE;
} else {
fprintf( stderr, "Failed to make unicode string from \"%hs\".\n", AnsiString );
}
return FALSE;
}
/* KtCreateKey:
create a keytab entry from the given data. returns TRUE on success, FALSE on failure.
*ppKeyEntry must be freed with FreeKeyEntry when you're done with it.
*/
LPWSTR RawHash = NULL;
BOOLKtCreateKey( PKTENT *ppKeyEntry, PCHAR principal, PCHAR password, PCHAR realmname, K5_OCTET keyVersionNumber, ULONG principalType, ULONG keyType, ULONG cryptosystem ) {
PKTENT pEntry = NULL; PCHAR ioBuffer = NULL; ULONG i; ULONG compCounter = 0; USHORT buffCounter = 0; BOOL ret = FALSE; BOOL FreeUnicodeSalt = FALSE;
UNICODE_STRING UnicodePassword = { 0 }; UNICODE_STRING UnicodePrincipal = { 0 }; UNICODE_STRING UnicodeSalt = { 0 }; PWCHAR tmpUnicodeBuffer = NULL; KERB_ENCRYPTION_KEY KerbKey = { 0 }; WCHAR wSaltBuffer [BUFFER_SIZE];
#ifdef BUILD_SALT
LONG32 saltCounter = 0; CHAR saltBuffer [BUFFER_SIZE];#endif
/* you must actually provide these parameters */
ASSERT( ppKeyEntry != NULL ); ASSERT( principal != NULL ); ASSERT( realmname != NULL ); ASSERT( password != NULL );
ASSERT( strlen( password ) < BUFFER_SIZE ); ASSERT( strlen( principal ) < BUFFER_SIZE ); ASSERT( strlen( realmname ) < BUFFER_SIZE );
#ifdef BUILD_SALT
/* if we're building the salt ourselves, initialize the keysalt */ sprintf( saltBuffer, "%s", realmname ); saltCounter = strlen( realmname );#endif
BREAK_IF( !ONEALLOC( pEntry, KTENT, KEYTAB_ALLOC), "Failed to allocate base keytab element", cleanup );
/* zero out the structure, so we know what we have and
haven't allocated if the function fails */
memset( pEntry, 0, sizeof( KTENT ) );
/* first, count the principal components */
for( i = 0 ; principal[i] != '\0' ; i++ ) { if (principal[i] == COMPONENT_SEPARATOR) { pEntry->cEntries++; } }
pEntry->cEntries++; /* don't forget the final component, which is not
bounded by the separator, but by the NULL */
BREAK_IF( !MYALLOC( pEntry->Components, KTCOMPONENT, pEntry->cEntries, KEYTAB_ALLOC ), "Failed to allocate keytab component vector", cleanup );
/* allocate the buffer for the principal components.
We allocate it the same size as the principal, because that's the maximum size any single component could be-- the principal could be a one component princ. */
BREAK_IF( !MYALLOC( ioBuffer, CHAR, strlen(principal)+1, KEYTAB_ALLOC ), "Failed to allocate local buffer for storage", cleanup );
/* now, we copy the components themselves, using the iobuffer to
marshall the individual data elements--
basically, add a char to the iobuffer for every char in the principal until you hit a / (component separator) or the trailing null.
in those cases, we now know the size of the component and we have the text in a local buffer. allocate a buffer for it, save the size and strcpy the data itself. */
i = 0;
do {
debug( "%c", principal[i] );
if( (principal[i] == COMPONENT_SEPARATOR) || (principal[i] == '\0' /* delimit final component */ ) ) { /* this component is done. Save and reset the buffer. */
pEntry->Components[compCounter].szComponentData = buffCounter; #if 0
debug( " --> component boundary for component %d.\n" " size = %d, value = %*s\n",
compCounter, buffCounter, buffCounter, ioBuffer );#endif
BREAK_IF( !MYALLOC( pEntry->Components[compCounter].Component, CHAR, buffCounter+1, KEYTAB_ALLOC ), "Failed to allocate marshalled component data", cleanup );
memcpy( pEntry->Components[compCounter].Component, ioBuffer, buffCounter );
pEntry->Components[compCounter].Component[buffCounter] = '\0'; buffCounter = 0; compCounter ++;
} else {
ioBuffer[buffCounter] = principal[i]; buffCounter++;
#ifdef BUILD_SALT
/* also send the principal characters WITHOUT SLASHES
to the salt initializer.
WASBUG 73909: the %wc doesn't look right here. Sure enough, it wasn't. So we removed it. */ sprintf( saltBuffer+saltCounter, "%c", principal[i] ); ASSERT( saltCounter < BUFFER_SIZE ); /* not a very strong assert,
but useful */ saltCounter ++; ASSERT( saltBuffer[saltCounter] == '\0' ); /* assert that it stays
null terminated at the saltCounter */ #endif
}
i++;
} while ( principal[i-1] != '\0' );
/* there's still a component in the buffer. Save that component
by assigning the pointer, rather than allocating more memory.
WASBUG 73911: may waste large amounts of memory if the principal is really big. However, it probably won't be-- we're talking about strings that humans would generally have to type, so the waste is going to be in bytes. Also, most of the time, the last component is the biggest; of the form:
sample/<hostname> or host/<hostname>
...hostname is generally going to be much larger than sample or host.
*/
pEntry->Components[compCounter].szComponentData = buffCounter; pEntry->Components[compCounter].Component = ioBuffer; ioBuffer[buffCounter] = '\0'; ioBuffer = NULL; /* keep from
deallocating */ pEntry->Version = keyVersionNumber; pEntry->szRealm = (K5_INT16) strlen(realmname); pEntry->KeyType = (unsigned short)keyType; pEntry->PrincType = principalType;
/* copy the realm name */
BREAK_IF( !MYALLOC( pEntry->Realm, CHAR, pEntry->szRealm+1, KEYTAB_ALLOC), "Failed to allocate destination realm data", cleanup );
memcpy( pEntry->Realm, realmname, pEntry->szRealm+1 ); /* copy the null */
/***********************************************************************/ /*** ***/ /*** Windows NT Key Creation Side ***/ /*** ***/ /***********************************************************************/
/* create unicode variants of the input parameters */
BREAK_IF( !MYALLOC( tmpUnicodeBuffer, WCHAR, strlen( password )+1, KEYTAB_ALLOC ), "Failed to alloc buffer for password", cleanup );
wsprintfW( tmpUnicodeBuffer, L"%hs", password ); RtlInitUnicodeString( &UnicodePassword, tmpUnicodeBuffer );
BREAK_IF( !MYALLOC( tmpUnicodeBuffer, WCHAR, strlen( principal )+1, KEYTAB_ALLOC ), "Failed to alloc buffer for principal", cleanup );
wsprintfW( tmpUnicodeBuffer, L"%hs", principal ); RtlInitUnicodeString( &UnicodePrincipal, tmpUnicodeBuffer );
wsprintfW( wSaltBuffer, L"%hs", realmname );
RtlInitUnicodeString( &UnicodeSalt, wSaltBuffer );
{ KERB_ACCOUNT_TYPE acctType;
acctType = UnknownAccount;
if ( RawHash ) {
if ( KtDumpSalt ) {
fprintf( stderr, "Using supplied salt.\n" );
}
RtlInitUnicodeString( &UnicodeSalt, RawHash );
} else {
PUNICODE_STRING pRealmString;
if ( CreateUnicodeStringFromAnsiString( realmname, &pRealmString ) ) {
KERBERR kerberr;
if ( KtDumpSalt ) {
fprintf( stderr, "Building salt with principalname %wZ" " and domain %wZ...\n", &UnicodePrincipal, pRealmString );
}
debug( "KerbBuildKeySalt( Realm = %wZ\n" " Princ = %wZ\n" " acctType = %d.\n", pRealmString, &UnicodePrincipal, acctType );
kerberr = KerbBuildKeySalt( pRealmString, &UnicodePrincipal, acctType, &UnicodeSalt );
free( pRealmString );
BREAK_IF( kerberr, "Failed to KerbBuildKeySalt", cleanup );
FreeUnicodeSalt = TRUE;
} } } // scope block.
if ( KtDumpSalt ) {
fprintf( stderr, "Hashing password with salt \"%wZ\".\n", &UnicodeSalt );
}
debug( "KerbHashPasswordEx( UnicodePassword = %wZ \n" " UnicodeSalt = %wZ \n" " cryptosystem = 0x%x\n" " &KerbKey = 0x%p )...\n",
&UnicodePassword, &UnicodeSalt, cryptosystem, &KerbKey );
BREAK_IF( KerbHashPasswordEx( &UnicodePassword, &UnicodeSalt, cryptosystem, &KerbKey ), "KerbHashPasswordEx failed.", cleanup );
pEntry->KeyLength = (USHORT)KerbKey.keyvalue.length;
BREAK_IF( !MYALLOC( pEntry->KeyData, K5_OCTET, pEntry->KeyLength, KEYTAB_ALLOC ), "Failed to allocate keydata", cleanup );
memcpy( pEntry->KeyData, KerbKey.keyvalue.value, pEntry->KeyLength );
/* NOTE: no keyentry changes beyond this line.
we must compute the key size LAST! */
pEntry->keySize = ComputeKeytabLength( pEntry );
*ppKeyEntry = pEntry; /* save this */ pEntry = NULL; /* save us from freeing it */
ret = TRUE;
cleanup:#define FREE_IF_NOT_NULL( element ) { if ( element != NULL ) { KEYTAB_FREE( element ); } }
if ( pEntry ) { FreeKeyEntry (pEntry ); }
WINNT_ONLY( FREE_IF_NOT_NULL( UnicodePassword.Buffer ) ); WINNT_ONLY( FREE_IF_NOT_NULL( UnicodePrincipal.Buffer ) );
#ifndef BUILD_KEYSALT
/* WASBUG 73915: how to free UnicodeSalt?
...with KerbFreeString. */
ASSERT( FreeUnicodeSalt ); KerbFreeString( &UnicodeSalt );
#else
/* Check my logic. */
ASSERT( !FreeUnicodeSalt );
#endif
/* WASBUG 73918: how do I get rid of the data in KerbKey?
...with KerbFreeKey. */
KerbFreeKey( &KerbKey );
return ret;
}
|
