APIERR MNetGroupGetUsers(
const TCHAR FAR * pszServer,
const TCHAR FAR * pszGroupName,
UINT Level,
BYTE FAR ** ppbBuffer,
UINT FAR * pcEntriesRead )
{
APIERR err;
USHORT cbTotalAvail;
// get a 4K buffer
*ppbBuffer = MNetApiBufferAlloc(BIG_BUFFER_SIZE);
if (*ppbBuffer == NULL)
{
return(ERROR_NOT_ENOUGH_MEMORY);
}
err = NetGroupGetUsers(pszServer, pszGroupName, Level, *ppbBuffer,
BIG_BUFFER_SIZE, pcEntriesRead, & cbTotalAvail);
// is there more data? if so, allocate a big enough buffer to get it
if(err == ERROR_MORE_DATA || err == NERR_BufTooSmall)
{
MNetApiBufferFree(ppbBuffer);
*ppbBuffer = MNetApiBufferAlloc( FULL_SEG_BUFFER_SIZE );
if( *ppbBuffer == NULL )
{
return(ERROR_NOT_ENOUGH_MEMORY);
}
err = NetGroupGetUsers(pszServer, pszGroupName, Level,
*ppbBuffer, FULL_SEG_BUFFER_SIZE, pcEntriesRead, & cbTotalAvail);
}
// If we're returning an error that's not moredata, or there are no
// entries to return, free the buffer first
if ((err && err != ERROR_MORE_DATA &&
err != NERR_BufTooSmall) || *pcEntriesRead == 0) {
MNetApiBufferFree(ppbBuffer);
}
return (err);
} // MNetGroupGetUsers
USHORT MNetGroupGetUsers (
const CHAR FAR * pszServer,
const CHAR FAR * pszGroupName,
SHORT Level,
CHAR FAR ** ppBuffer,
USHORT FAR * pcEntriesRead ) {
USHORT usReturnCode,
cbTotalAvail;
SEL sel;
// get a 4K buffer
*ppBuffer = MGetBuffer(BIG_BUFFER_SIZE);
if (*ppBuffer == NULL)
{
return(ERROR_NOT_ENOUGH_MEMORY);
}
usReturnCode = NetGroupGetUsers(pszServer, pszGroupName, Level, *ppBuffer,
BIG_BUFFER_SIZE, pcEntriesRead, & cbTotalAvail);
// is there more data? if so, allocate a big enough buffer to get it
if(usReturnCode == ERROR_MORE_DATA || usReturnCode == NERR_BufTooSmall)
{
NetApiBufferFree(*ppBuffer);
if (DEBUGALLOC(FULL_SEG_BUFFER_SIZE, & sel, SEG_NONSHARED)) {
return(ERROR_NOT_ENOUGH_MEMORY);
}
*ppBuffer = MAKEP(sel, 0);
usReturnCode = NetGroupGetUsers(pszServer, pszGroupName, Level,
*ppBuffer, FULL_SEG_BUFFER_SIZE, pcEntriesRead, & cbTotalAvail);
}
// If we're returning an error that's not moredata, or there are no
// entries to return, free the buffer first
if ((usReturnCode && usReturnCode != ERROR_MORE_DATA &&
usReturnCode != NERR_BufTooSmall) || *pcEntriesRead == 0) {
NetApiBufferFree(*ppBuffer);
}
return (usReturnCode);
}
bool CWfpNET::GroupMembers_get(LPWSTR Group) // Enumerate Group Memberships
{
NET_API_STATUS nStatus = NULL;
LPGROUP_USERS_INFO_0 pBuf = NULL,
pTmpBuf = NULL;
DWORD i = 0,
entriesread = 0,
totalentries = 0;
CString tmp;
do
{
nStatus = NetGroupGetUsers(node.szComputerW,Group,0,(LPBYTE *) &pBuf,
MAX_PREFERRED_LENGTH, &entriesread, &totalentries, NULL);
if(nStatus == NERR_Success || nStatus == ERROR_MORE_DATA)
{
if((pTmpBuf = pBuf) != NULL)
{
for(i = 0; i < entriesread; i++)
{
assert(pTmpBuf != NULL);
if (pTmpBuf == NULL)
break;
tmp.Format(_T("Member: %S"),pTmpBuf->grui0_name);
Groups.Add(tmp);
pTmpBuf++;
}
}
if(pBuf != NULL)
{
NetApiBufferFree(pBuf);
pBuf = NULL;
}
}
else
{
// Disable for now
// NetErrorHandler("NetGroupGetUsers", nStatus);
return false;
}
} while (nStatus==ERROR_MORE_DATA);
return true;
}
static int get_global_group_members(WCHAR *group_name, struct oscap_list *list)
{
NET_API_STATUS status;
GROUP_USERS_INFO_0 *buffer = NULL;
DWORD preffered_max_len = MAX_PREFERRED_LENGTH;
DWORD entries_read = 0;
DWORD total_entries = 0;
DWORD resume_handle = 0;
status = NetGroupGetUsers(NULL, group_name, 0, (LPBYTE *)&buffer, preffered_max_len, &entries_read, &total_entries, &resume_handle);
if (status != NERR_Success) {
dD("NetGroupGetUsers failed: %d", status);
return 1;
}
for (DWORD i = 0; i < entries_read; i++) {
WCHAR *member_name = buffer[i].grui0_name;
oscap_list_add(list, wcsdup(member_name));
}
NetApiBufferFree(buffer);
return 0;
}
static NET_API_STATUS test_netgroupgetusers(const char *hostname,
uint32_t level,
const char *groupname,
const char *username)
{
NET_API_STATUS status;
uint32_t entries_read = 0;
uint32_t total_entries = 0;
uint32_t resume_handle = 0;
int found_user = 0;
const char *current_name = NULL;
uint8_t *buffer = NULL;
int i;
struct GROUP_USERS_INFO_0 *info0 = NULL;
struct GROUP_USERS_INFO_1 *info1 = NULL;
printf("testing NetGroupGetUsers level %d\n", level);
do {
status = NetGroupGetUsers(hostname,
groupname,
level,
&buffer,
(uint32_t)-1,
&entries_read,
&total_entries,
&resume_handle);
if (status == 0 || status == ERROR_MORE_DATA) {
switch (level) {
case 0:
info0 = (struct GROUP_USERS_INFO_0 *)buffer;
break;
case 1:
info1 = (struct GROUP_USERS_INFO_1 *)buffer;
break;
default:
break;
}
for (i=0; i<entries_read; i++) {
switch (level) {
case 0:
current_name = info0->grui0_name;
break;
case 1:
current_name = info1->grui1_name;
break;
default:
break;
}
if (username && strcasecmp(current_name, username) == 0) {
found_user = 1;
}
switch (level) {
case 0:
info0++;
break;
case 1:
info1++;
break;
}
}
NetApiBufferFree(buffer);
}
} while (status == ERROR_MORE_DATA);
if (status) {
return status;
}
if (username && !found_user) {
printf("failed to get user\n");
return -1;
}
return 0;
}
//
// Determines if user is a member of the global group group_name on domain group_domain
//
// 1 = yes, 0 = no, -1 = error
//
int perm::userInGlobalGroup( const char *account, const char *domain, const char* group_name, const char* group_domain ) {
dprintf(D_FULLDEBUG,"in perm::processGlobalGroupTrustee() looking at group '%s\\%s'\n",
(group_domain) ? group_domain : "NULL", (group_name) ? group_name : "NULL" );
unsigned char* BufPtr; // buffer pointer
wchar_t group_domain_unicode[MAX_DOMAIN_LENGTH+1]; // computer names restricted to 254 chars
wchar_t group_name_unicode[MAX_GROUP_LENGTH+1]; // groups limited to 256 chars
_snwprintf(group_domain_unicode, MAX_DOMAIN_LENGTH+1, L"%S", group_domain);
_snwprintf(group_name_unicode, MAX_GROUP_LENGTH+1, L"%S", group_name);
GROUP_USERS_INFO_0 *group_members;
unsigned long entries_read, total_entries;
NET_API_STATUS status;
// get domain controller name for the domain in question
status = NetGetDCName( NULL, // servername
group_domain_unicode, // domain to lookup
&BufPtr // pointer to buffer containing the name (Unicode string) of the Domain Controller
);
if (status == NERR_DCNotFound ) {
dprintf(D_ALWAYS, "perm::NetGetDCName() failed: DCNotFound (domain looked up: %s)\n", group_domain);
NetApiBufferFree( BufPtr );
return -1;
} else if ( status == ERROR_INVALID_NAME ) {
dprintf(D_ALWAYS, "perm::NetGetDCName() failed: Error Invalid Name (domain looked up: %s)", group_domain);
NetApiBufferFree( BufPtr );
return -1;
}
wchar_t* DomainController = (wchar_t*) BufPtr;
do {
status = NetGroupGetUsers( DomainController, // domain controller name
group_name_unicode, // domain to query
0, // level of info
&BufPtr, // pointer to buffer containing group members
16384, // preferred size of buffer
&entries_read, // # entries read
&total_entries, // total # of entries
NULL // resume pointer
);
group_members = (GROUP_USERS_INFO_0*) BufPtr;
switch ( status ) {
case NERR_Success:
case ERROR_MORE_DATA:
break;
case ERROR_ACCESS_DENIED:
case NERR_InvalidComputer:
case NERR_GroupNotFound:
char* DCname = new char[ wcslen( DomainController )+1 ];
wsprintf(DCname, "%ws", DomainController);
dprintf(D_ALWAYS, "perm::NetGroupGetUsers failed: (domain: %s, domain controller: %s, total entries: %d, entries read: %d, err=%d)",
group_domain, DCname, total_entries, entries_read, GetLastError());
delete[] DCname;
NetApiBufferFree( BufPtr );
NetApiBufferFree( DomainController );
return -1;
}
DWORD i;
for ( i = 0; i < entries_read; i++ ) {
char t_name[MAX_ACCOUNT_LENGTH+1]; // account names are restricted to 20 chars, but I'm
// gonna be safe and say 256.
snprintf(t_name, MAX_ACCOUNT_LENGTH+1, "%S", group_members[i].grui0_name);
dprintf(D_FULLDEBUG, "GlobalGroupMember: %s\n", t_name);
//getDomainAndName( t_str, t_domain, t_name);
if ( domainAndNameMatch( account, t_name, domain, group_domain ) )
{
//delete[] t_str;
NetApiBufferFree( BufPtr );
NetApiBufferFree( DomainController );
return 1;
}
}
}while ( status == ERROR_MORE_DATA ); // loop if there's more group members to look at
// exiting the for loop means we didn't find anything
NetApiBufferFree( BufPtr );
NetApiBufferFree( DomainController );
return 0;
}
