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

[הגאון מכולם]

שמעו, אי פעם ראיתם סרטים עם האקר שיושב מול המחשב, מקליד כמו משוגע ופותח את כל הסודות של העולם? אז עכשיו אתם יכולים להיות ההאקר הזה – בלי להתאמץ בכלל!

האתר Hacker Typer זה פשוט גאונות. אתם מקלידים על המקלדת, ומה יוצא? קוד שנראה מקצועי בטירוף, כאילו אתם איזה גאון מחשבים.

למה שווה להיכנס?

כי זה מצחיק בטירוף: מקלידים שטויות – ומרגישים כמו האקר של סרטים.
כי זה עובד על כולם: רוצים לעבוד על החברים שאתם איזה סייבר-מאסטר? זה המקום.
כי זה כיף: אתה פשוט יושב, מקליד, וצוחק על כמה זה מגניב.
כי לא צריך לדעת כלום: כל מה שצריך זה מקלדת.
כדי להפוך את זה לממש אמיתי תלחצו F11 במקלדת וזה מגדיל את המסך למסך מלא. כדי לצאת-F11
תשחקו עם ההגדרות ומה שבא לכם!
יאללה, למה אתם מחכים? כנסו ל-Hacker Typer ותראו כמה זה ממכר!

[יוסף אלחנן]

@הגאון-מכולם GPT מציעה לי שיפורים בקוד שיוצא אחרי ה'הקלדה'...

למי אפשר לפנות?

[הגאון מכולם]

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

GPT מציעה לי שיפורים בקוד שיוצא אחרי ה'הקלדה'...

למי אפשר לפנות?

[בנימינה]

איזה שפה זה?

[הגאון מכולם]

@בנימינה הקוד כתוב בשפת C

[יוסף אלחנן]

@הגאון-מכולם אגב סתם, יש שם הגדרות שאפשר לשחק איתם...

[הגאון מכולם]

@יוסף-אלחנן

[הגאון מכולם]

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

GPT מציעה לי שיפורים בקוד שיוצא אחרי ה'הקלדה'...

למי אפשר לפנות?

@יוסף-אלחנן האמת שHacker Typer נוצר על ידי Alec Merta (אלק מרטה) בשנת 2011. הרעיון לאתר הגיע בעקבות סרטי האקשן והתוכניות בטלוויזיה שבהם האקרים נראים כאילו הם כותבים קוד במהירות שיא, וזה תמיד נראה מגניב בטירוף. אלק רצה להפוך את זה למשהו שכולם יכולים לחוות, אפילו בלי לדעת איך לתכנת.
האתר התחיל כפרויקט אישי ומשעשע, אבל מאז הוא הפך לוויראלי ומפורסם ברחבי העולם. כיום הוא משמש בעיקר לכיף, משחקים ושעשוע – וגם קצת כדי להרשים אנשים אחרים ב"כישורי האקינג".

[בנימינה]

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

[עדלאידע]

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

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

אין הגבלה.

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

[הגאון מכולם]

פוסט זה נמחק!

[אורחל]

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

אין הגבלה

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

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

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

אין הגבלה.

[הגאון מכולם]

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

[אורחל]

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

Spoiler

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

[הגאון מכולם]

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

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

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

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

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

לא אני...
בטעות...

[אורחל]

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

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

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

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

[הגאון מכולם]

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

[שקט]

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

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

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

אין הגבלה.

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

Spoiler

הנה כל הקוד:

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;

}

[הגאון מכולם]

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

[שקט]

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