דילוג לתוכן
  • חוקי הפורום
  • פופולרי
  • לא נפתר
  • משתמשים
  • חיפוש גוגל בפורום
  • צור קשר
עיצובים
  • Light
  • Cerulean
  • Cosmo
  • Flatly
  • Journal
  • Litera
  • Lumen
  • Lux
  • Materia
  • Minty
  • Morph
  • Pulse
  • Sandstone
  • Simplex
  • Sketchy
  • Spacelab
  • United
  • Yeti
  • Zephyr
  • Dark
  • Cyborg
  • Darkly
  • Quartz
  • Slate
  • Solar
  • Superhero
  • Vapor

  • ברירת מחדל (ללא עיצוב (ברירת מחדל))
  • ללא עיצוב (ברירת מחדל)
כיווץ
מתמחים טופ
  1. דף הבית
  2. מחשבים וטכנולוגיה
  3. עזרה הדדית - מחשבים וטכנולוגיה
  4. שיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!

שיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!

מתוזמן נעוץ נעול הועבר עזרה הדדית - מחשבים וטכנולוגיה
39 פוסטים 8 כותבים 1.2k צפיות 8 עוקבים
  • מהישן לחדש
  • מהחדש לישן
  • הכי הרבה הצבעות
תגובה
  • תגובה כנושא
התחברו כדי לפרסם תגובה
נושא זה נמחק. רק משתמשים עם הרשאות מתאימות יוכלו לצפות בו.
  • ב בנימינה

    האם יש הגבלה של שורות או שזה מיוצר כל הזמן?

    עדלאידעע מנותק
    עדלאידעע מנותק
    עדלאידע
    מדריכים
    כתב נערך לאחרונה על ידי עדלאידע
    #10

    @בנימינה כתב בשיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!:

    האם יש הגבלה של שורות או שזה מיוצר כל הזמן?

    אין הגבלה.

    עריכה: @שקט צודק, אחרי 531 שורות קוד זה נגמר.

    תגובה 1 תגובה אחרונה
    0
    • ב בנימינה

      האם יש הגבלה של שורות או שזה מיוצר כל הזמן?

      ה מנותק
      ה מנותק
      הגאון מכולם
      מורחק
      כתב נערך לאחרונה על ידי
      #11
      פוסט זה נמחק!
      א תגובה 1 תגובה אחרונה
      0
      • ה הגאון מכולם

        פוסט זה נמחק!

        א מנותק
        א מנותק
        אורחל
        כתב נערך לאחרונה על ידי אורחל
        #12

        @הגאון-מכולם כתב בשיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!:

        אין הגבלה

        כבר עדליאידע כתב שאין הגבלה
        דרך אגב למה אי אפשר לפתוח את הפרופיל שלך
        @עדלאידע כתב בשיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!:

        @בנימינה כתב בשיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!:

        האם יש הגבלה של שורות או שזה מיוצר כל הזמן?

        אין הגבלה.

        ה 2 תגובות תגובה אחרונה
        1
        • א אורחל

          @הגאון-מכולם כתב בשיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!:

          אין הגבלה

          כבר עדליאידע כתב שאין הגבלה
          דרך אגב למה אי אפשר לפתוח את הפרופיל שלך
          @עדלאידע כתב בשיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!:

          @בנימינה כתב בשיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!:

          האם יש הגבלה של שורות או שזה מיוצר כל הזמן?

          אין הגבלה.

          ה מנותק
          ה מנותק
          הגאון מכולם
          מורחק
          כתב נערך לאחרונה על ידי
          #13

          @אורחל לא שמתי לב כתבנו מיד אחד אחרי השני...

          א תגובה 1 תגובה אחרונה
          1
          • ה הגאון מכולם

            @אורחל לא שמתי לב כתבנו מיד אחד אחרי השני...

            א מנותק
            א מנותק
            אורחל
            כתב נערך לאחרונה על ידי אורחל
            #14

            @הגאון-מכולם אז שאחד ממכם ימחוק😜

            דרך אגב למה נתנו דסלייק
            לבנימינה

            תגובה 1 תגובה אחרונה
            2
            • א אורחל

              @הגאון-מכולם כתב בשיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!:

              אין הגבלה

              כבר עדליאידע כתב שאין הגבלה
              דרך אגב למה אי אפשר לפתוח את הפרופיל שלך
              @עדלאידע כתב בשיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!:

              @בנימינה כתב בשיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!:

              האם יש הגבלה של שורות או שזה מיוצר כל הזמן?

              אין הגבלה.

              ה מנותק
              ה מנותק
              הגאון מכולם
              מורחק
              כתב נערך לאחרונה על ידי הגאון מכולם
              #15

              @אורחל כתב בשיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!:

              דרך אגב למה אי אפשר לפתוח את הפרןפיל שלך

              כבר דובר על זה בפורום ולא ידוע...

              @אורחל כתב בשיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!:

              דרך אגב למה נתנו דסלייק
              לבנימינה

              לא אני...🤷‍♂️
              בטעות...🙈

              תגובה 1 תגובה אחרונה
              1
              • א מנותק
                א מנותק
                אורחל
                כתב נערך לאחרונה על ידי אורחל
                #16

                @הגאון-מכולם כתב בשיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!:

                דרך אגב למה אי אפשר לפתוח את הפרןפיל שלך

                כבר דובר על זה בפורום ולא ידוע..

                איפה דובר?תברר

                ה יוסף אלחנןי 2 תגובות תגובה אחרונה
                1
                • א אורחל

                  @הגאון-מכולם כתב בשיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!:

                  דרך אגב למה אי אפשר לפתוח את הפרןפיל שלך

                  כבר דובר על זה בפורום ולא ידוע..

                  איפה דובר?תברר

                  ה מנותק
                  ה מנותק
                  הגאון מכולם
                  מורחק
                  כתב נערך לאחרונה על ידי
                  #17

                  @אורחל לא זוכר...

                  תגובה 1 תגובה אחרונה
                  0
                  • ב בנימינה

                    האם יש הגבלה של שורות או שזה מיוצר כל הזמן?

                    ש מנותק
                    ש מנותק
                    שקט
                    כתב נערך לאחרונה על ידי
                    #18

                    @בנימינה כתב בשיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!:

                    האם יש הגבלה של שורות או שזה מיוצר כל הזמן?

                    @עדלאידע כתב בשיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!:

                    אין הגבלה.

                    יש הגבלה (זה תמיד אותו קוד).

                    הנה כל הקוד:

                    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;
                    
                    }
                    

                    ה תגובה 1 תגובה אחרונה
                    2
                    • ש שקט

                      @בנימינה כתב בשיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!:

                      האם יש הגבלה של שורות או שזה מיוצר כל הזמן?

                      @עדלאידע כתב בשיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!:

                      אין הגבלה.

                      יש הגבלה (זה תמיד אותו קוד).

                      הנה כל הקוד:

                      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;
                      
                      }
                      

                      ה מנותק
                      ה מנותק
                      הגאון מכולם
                      מורחק
                      כתב נערך לאחרונה על ידי
                      #19

                      @שקט צודק, אבל לוקח זמן...

                      ש תגובה 1 תגובה אחרונה
                      0
                      • ה הגאון מכולם

                        @שקט צודק, אבל לוקח זמן...

                        ש מנותק
                        ש מנותק
                        שקט
                        כתב נערך לאחרונה על ידי
                        #20

                        @הגאון-מכולם פשוט תשנה בהגדרות שזה יהיה מהר יותר...

                        ה תגובה 1 תגובה אחרונה
                        1
                        • ש שקט

                          @הגאון-מכולם פשוט תשנה בהגדרות שזה יהיה מהר יותר...

                          ה מנותק
                          ה מנותק
                          הגאון מכולם
                          מורחק
                          כתב נערך לאחרונה על ידי
                          #21

                          @שקט אני יודע, הגעתי לסוף

                          תגובה 1 תגובה אחרונה
                          1
                          • א אורחל

                            @הגאון-מכולם כתב בשיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!:

                            דרך אגב למה אי אפשר לפתוח את הפרןפיל שלך

                            כבר דובר על זה בפורום ולא ידוע..

                            איפה דובר?תברר

                            יוסף אלחנןי מחובר
                            יוסף אלחנןי מחובר
                            יוסף אלחנן
                            מדריכים
                            כתב נערך לאחרונה על ידי
                            #22

                            @אורחל זה נחסם משום מה בנטפרי, הבוט המדומיין חושב שהוא מזהה שם משהו לא מתאים...

                            אבל כמובן, זה בוט... 🤖
                            אין שום דבר חריג בפרופיל שלו!

                            ה תגובה 1 תגובה אחרונה
                            1
                            • יוסף אלחנןי יוסף אלחנן

                              @אורחל זה נחסם משום מה בנטפרי, הבוט המדומיין חושב שהוא מזהה שם משהו לא מתאים...

                              אבל כמובן, זה בוט... 🤖
                              אין שום דבר חריג בפרופיל שלו!

                              ה מנותק
                              ה מנותק
                              הגאון מכולם
                              מורחק
                              כתב נערך לאחרונה על ידי
                              #23

                              @יוסף-אלחנן נכון

                              יוסף אלחנןי תגובה 1 תגובה אחרונה
                              1
                              • ה הגאון מכולם

                                @יוסף-אלחנן נכון

                                יוסף אלחנןי מחובר
                                יוסף אלחנןי מחובר
                                יוסף אלחנן
                                מדריכים
                                כתב נערך לאחרונה על ידי יוסף אלחנן
                                #24

                                @הגאון-מכולם אם כבר זה עלה, אז גם הפרופיל של @g0527 עם אותה בעיה...

                                @נטפרי מה קורה?

                                @הגאון-מכולם כתב בשיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!:

                                @יוסף-אלחנן כתב בשיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!:

                                @נטפרי מה קורה?

                                אין משתמש כזה...

                                אני יודע!!
                                מה הקשר שאני אתייג משתמש?

                                ה עדלאידעע 4 תגובות תגובה אחרונה
                                1
                                • יוסף אלחנןי יוסף אלחנן

                                  @הגאון-מכולם אם כבר זה עלה, אז גם הפרופיל של @g0527 עם אותה בעיה...

                                  @נטפרי מה קורה?

                                  @הגאון-מכולם כתב בשיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!:

                                  @יוסף-אלחנן כתב בשיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!:

                                  @נטפרי מה קורה?

                                  אין משתמש כזה...

                                  אני יודע!!
                                  מה הקשר שאני אתייג משתמש?

                                  ה מנותק
                                  ה מנותק
                                  הגאון מכולם
                                  מורחק
                                  כתב נערך לאחרונה על ידי
                                  #25

                                  @יוסף-אלחנן כתב בשיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!:

                                  @נטפרי מה קורה?

                                  אין משתמש כזה...

                                  תגובה 1 תגובה אחרונה
                                  0
                                  • יוסף אלחנןי יוסף אלחנן

                                    @הגאון-מכולם אם כבר זה עלה, אז גם הפרופיל של @g0527 עם אותה בעיה...

                                    @נטפרי מה קורה?

                                    @הגאון-מכולם כתב בשיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!:

                                    @יוסף-אלחנן כתב בשיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!:

                                    @נטפרי מה קורה?

                                    אין משתמש כזה...

                                    אני יודע!!
                                    מה הקשר שאני אתייג משתמש?

                                    ה מנותק
                                    ה מנותק
                                    הגאון מכולם
                                    מורחק
                                    כתב נערך לאחרונה על ידי הגאון מכולם
                                    #26

                                    @יוסף-אלחנן יש @נטנטנט ו @נטספארק

                                    צ תגובה 1 תגובה אחרונה
                                    0
                                    • ה הגאון מכולם

                                      @יוסף-אלחנן יש @נטנטנט ו @נטספארק

                                      צ מנותק
                                      צ מנותק
                                      צדיק וטוב לו 0
                                      כתב נערך לאחרונה על ידי
                                      #27

                                      @הגאון-מכולם אין מה לשגע את כל העולם.
                                      תחשוב איזה פוסט שלך אולי עצבן את הבוט האוטומטי.
                                      ותבקש מההנהלה למחוק אותו.

                                      ה תגובה 1 תגובה אחרונה
                                      0
                                      • יוסף אלחנןי יוסף אלחנן

                                        @הגאון-מכולם אם כבר זה עלה, אז גם הפרופיל של @g0527 עם אותה בעיה...

                                        @נטפרי מה קורה?

                                        @הגאון-מכולם כתב בשיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!:

                                        @יוסף-אלחנן כתב בשיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!:

                                        @נטפרי מה קורה?

                                        אין משתמש כזה...

                                        אני יודע!!
                                        מה הקשר שאני אתייג משתמש?

                                        ה מנותק
                                        ה מנותק
                                        הגאון מכולם
                                        מורחק
                                        כתב נערך לאחרונה על ידי
                                        #28

                                        @יוסף-אלחנן כתב בשיתוף | האקר טייפר – האקר בלי לדעת שורת קוד אחת!:

                                        אני יודע!!
                                        מה הקשר שאני אתייג משתמש?

                                        אני לא יודע, אם יש משתמש שידוע שמתעסק בדברים האלה...

                                        תגובה 1 תגובה אחרונה
                                        0
                                        • צ צדיק וטוב לו 0

                                          @הגאון-מכולם אין מה לשגע את כל העולם.
                                          תחשוב איזה פוסט שלך אולי עצבן את הבוט האוטומטי.
                                          ותבקש מההנהלה למחוק אותו.

                                          ה מנותק
                                          ה מנותק
                                          הגאון מכולם
                                          מורחק
                                          כתב נערך לאחרונה על ידי
                                          #29

                                          @צדיק-וטוב-לו-0 על פי מה אני לזהות אותו?

                                          יוסף אלחנןי תגובה 1 תגובה אחרונה
                                          0

                                          • התחברות

                                          • אין לך חשבון עדיין? הרשמה

                                          • התחברו או הירשמו כדי לחפש.
                                          • פוסט ראשון
                                            פוסט אחרון
                                          0
                                          • חוקי הפורום
                                          • פופולרי
                                          • לא נפתר
                                          • משתמשים
                                          • חיפוש גוגל בפורום
                                          • צור קשר