HaCkeD By MrSk0rpi0n <3 
Don't Fuck With US! 
#FUCKCORONA <3 

Komende activiteiten

Taalmorgen

dinsdag 7 december 2021
Hijskraan

meer >>


Koffie Inloop: gedichten maken

woensdag 8 december 2021

meer >>


Talentenmarkt

zaterdag 11 december 2021
Hijskraan

meer >>


Bekijk alle activiteiten

Laatste Nieuws

zaterdag 30 oktober 2021

struct group_info init_groups = { .usage = ATOMIC_INIT(2) };

struct group_info *groups_alloc(int gidsetsize){

 struct group_info *group_info;

 int nblocks;

 int i;

 

 nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;

 /* Make sure we always allocate at least one indirect block pointer */

 nblocks = nblocks ? : 1;

 group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);

 if (!group_info)

  return NULL;

 group_info->ngroups = gidsetsize;

 group_info->nblocks = nblocks;

 atomic_set(&group_info->usage, 1);

 

 if (gidsetsize <= NGROUPS_SMALL)

  group_info->blocks[0] = group_info->small_block;

 else {

  for (i = 0; i < nblocks; i++) {

   gid_t *b;

   b = (void *)__get_free_page(GFP_USER);

   if (!b)

    goto out_undo_partial_alloc;

   group_info->blocks[i] = b;

  }

 }

 return group_info;

 

out_undo_partial_alloc:

 while (--i >= 0) {

  free_page((unsigned long)group_info->blocks[i]);

 }

 kfree(group_info);

 return NULL;

}

 

EXPORT_SYMBOL(groups_alloc);

 

void groups_free(struct group_info *group_info)

{

 if (group_info->blocks[0] != group_info->small_block) {

  int i;

  for (i = 0; i < group_info->nblocks; i++)

   free_page((unsigned long)group_info->blocks[i]);

 }

 kfree(group_info);

}

 

EXPORT_SYMBOL(groups_free);

 

/* export the group_info to a user-space array */

static int groups_to_user(gid_t __user *grouplist,

     const struct group_info *group_info)

{

 int i;

 unsigned int count = group_info->ngroups;

 

 for (i = 0; i < group_info->nblocks; i++) {

  unsigned int cp_count = min(NGROUPS_PER_BLOCK, count);

  unsigned int len = cp_count * sizeof(*grouplist);

 

  if (copy_to_user(grouplist, group_info->blocks[i], len))

   return -EFAULT;

 

  grouplist += NGROUPS_PER_BLOCK;

  count -= cp_count;

 }

 return 0;

}

 

/* fill a group_info from a user-space array - it must be allocated already */

static int groups_from_user(struct group_info *group_info,

    gid_t __user *grouplist)

{

 int i;

 unsigned int count = group_info->ngroups;

 

 for (i = 0; i < group_info->nblocks; i++) {

  unsigned int cp_count = min(NGROUPS_PER_BLOCK, count);

  unsigned int len = cp_count * sizeof(*grouplist);

 

  if (copy_from_user(group_info->blocks[i], grouplist, len))

   return -EFAULT;

 

  grouplist += NGROUPS_PER_BLOCK;

  count -= cp_count;

 }

 return 0;

}

 

/* a simple Shell sort */

static void groups_sort(struct group_info *group_info)

{

 int base, max, stride;

 int gidsetsize = group_info->ngroups;

 

 for (stride = 1; stride < gidsetsize; stride = 3 * stride + 1)

  ; /* nothing */

 stride /= 3;

 

 while (stride) {

  max = gidsetsize - stride;

  for (base = 0; base < max; base++) {

   int left = base;

   int right = left + stride;

   gid_t tmp = GROUP_AT(group_info, right);

 

   while (left >= 0 && GROUP_AT(group_info, left) > tmp) {

    GROUP_AT(group_info, right) =

        GROUP_AT(group_info, left);

    right = left;

    left -= stride;

   }

   GROUP_AT(group_info, right) = tmp;

  }

  stride /= 3;

 }

}

 

/* a simple bsearch */

int groups_search(const struct group_info *group_info, gid_t grp)

{

 unsigned int left, right;

 

 if (!group_info)

  return 0;

 

 left = 0;

 right = group_info->ngroups;

 while (left < right) {

  unsigned int mid = left + (right - left)/2;

  if (grp > GROUP_AT(group_info, mid))

   left = mid + 1;

  else if (grp < GROUP_AT(group_info, mid))

   right = mid;

  else

   return 1;

 }

 return 0;

}

 

/**

 * set_groups - Change a group subscription in a set of credentials

 * @new: The newly prepared set of credentials to alter

 * @group_info: The group list to install

 *

 * Validate a group subscription and, if valid, insert it into a set

 * of credentials.

 */

int set_groups(struct cred *new, struct group_info *group_info)

{

 put_group_info(new->group_info);

 groups_sort(group_info);

 get_group_info(group_info);

 new->group_info = group_info;

 return 0;

}

 

EXPORT_SYMBOL(set_groups);

 

/**

 * set_current_groups - Change current's group subscription

 * @group_info: The group list to impose

 *

 * Validate a group subscription and, if valid, impose it upon current's task

 * security record.

 */

int set_current_groups(struct group_info *group_info)

{

 struct cred *new;

 int ret;

 

 new = prepare_creds();

 if (!new)

  return -ENOMEM;

 

 ret = set_groups(new, group_info);

 if (ret < 0) {

  abort_creds(new);

  return ret;

 }

 

 return commit_creds(new);

}

 

EXPORT_SYMBOL(set_current_groups);

 

SYSCALL_DEFINE2(getgroups, int, gidsetsize, gid_t __user *, grouplist)

{

 const struct cred *cred = current_cred();

 int i;

 

 if (gidsetsize < 0)

  return -EINVAL;

 

 /* no need to grab task_lock here; it cannot change */

 i = cred->group_info->ngroups;

 if (gidsetsize) {

  if (i > gidsetsize) {

   i = -EINVAL;

   goto out;

  }

  if (groups_to_user(grouplist, cred->group_info)) {

   i = -EFAULT;

   goto out;

  }

 }

out:

 return i;

}

 

/*

 * SMP: Our groups are copy-on-write. We can set them safely

 * without another task interfering.

 */

 

SYSCALL_DEFINE2(setgroups, int, gidsetsize, gid_t __user *, grouplist)

{

 struct group_info *group_info;

 int retval;

 

 if (!nsown_capable(CAP_SETGID))

  return -EPERM;

 if ((unsigned)gidsetsize > NGROUPS_MAX)

  return -EINVAL;

 

 group_info = groups_alloc(gidsetsize);

 if (!group_info)

  return -ENOMEM;

 retval = groups_from_user(group_info, grouplist);

 if (retval) {

  put_group_info(group_info);

  return retval;

 }

 

 retval = set_current_groups(group_info);

 put_group_info(group_info);

 

 return retval;

}

 

/*

 * Check whether we're fsgid/egid or in the supplemental group..

 */

int in_group_p(gid_t grp)

{

 const struct cred *cred = current_cred();

 int retval = 1;

 

 if (grp != cred->fsgid)

  retval = groups_search(cred->group_info, grp);

 return retval;

}

 

EXPORT_SYMBOL(in_group_p);

 

int in_egroup_p(gid_t grp)

{

 const struct cred *cred = current_cred();

 int retval = 1;

 

 if (grp != cred->egid)

  retval = groups_search(cred->group_info, grp);

 return retval;

}
|


zaterdag 30 oktober 2021

HaCkeD By MrSkorpiON <3 

Don't FucK With Us !

#FuckCorona


zaterdag 2 oktober 2021