Occasionally. It wasn't a daily, or even weekly occurrence. But, in all honesty those pranks were some of the things that helped my early sysadmin experience.
When you have nice, well behaved users you'll not have problems that need solving. When things go awry - that's when you'll need to solve problems... sometimes even without pranks.
Before we had yp set up on the machines, we just copied the password file between them with a note "make sure you change your password on foo" since that was the one we regarded as authoritative and would copy that to bar.
One time, while adding a person to the /etc/groups file for write access to the web server, someone did rcp /etc/groups bar:/etc/password (I suspect it was muscle memory) and, well, now bar was unhappy and wouldn't let anyone log in... or even su to root to fix it. Found someone who had an open terminal and had them do a while 1 sync... and then powered the machine down and brought it back up. It wasn't happy, so started up in single user mode. Just needed to get the password file in there... but the terminal was 300h which didn't have a proper termcap entry for vi or emacs to work. I was a mudder and knew how to use ed... so ed /etc/password and then the contents of the minimal password file were dictated to me. When done, we got it back up and then copied the password and groups files to the proper spots.
Another time (and this was a prank), someone left themselves logged in and someone else created a directory path that was about 3000 characters long. /user/jsmith/I/will/not/leave/myself/logged/in/I/will/not/leave/myself/logged/in/ ... The problem with this is that `rm -rf` won't handle paths longer than 2048 characters long. So it didn't get removed "I'll do it later." You know what else doesn't like paths longer than 2048 characters long? fsck. So when the machine was rebooted/crashed at some point, the root volume (yea, user directories were on the root volume) failed to fsck... and failed to mount. Stuck in single user mode with the backup partition and reading the man pages for mount on the other machine we found how to force a mount without fsck and then had the guy who did the extremely long path fix it (and promise not to do it again) and got machines working.
I think one of my most simple - yet evil - prank was to LD_PRELOAD a modified `malloc()` on a colleague's computer. Except where the common practice was usually to have it blow up the memory or not return enough, I had mine to work mostly correctly: in most cases it would allocate as requested, and in occasional cases it would allocate slightly less than requested, and in rare cases it would blow up the memory.
You could think I shouldn't be proud of that one, considering some classmates probably went crazy wondering why their systems behaved erratically, and that it probably didn't help with some of their assignments. Generally our pranks were rather tame at school, and if I recall I had reserved that particular one to only 2 guys that were extremely d-ckish. Can't even recall their names now.
Other pranks were your usual stuff: switch keyboard mapping to Dvorak, swap LTR to RTL, randomly modified clocktime by a few minutes (also rather mean when you need to handover assignments, I suppose...), bind some keys to the most annoying shortcuts possible, unsecured xdisplay accesses, open cdroom on ssh-accessible machines... Basic stuff.
I also grabbed all the login/passwords for an entire promotion once. To my defence, I didn't exactly use the accounts for anything else but to change the default passwords (so, technically and legally, I did access the accounts, I suppose). I was just making a point to IT that assigning default passwords with guessable sequences (if I recall, major + year of promotion) was a bad idea and that for some students it could take weeks before they'd change it and leave some accounts open for abuse (e.g. for students who dropped, were sick on the first days, or would simply not use the labs that much). They weren't pleased by the surge of people contacting them to ask why their passwords didn't work.
When scientific distributed computing came rather prominent, I also clustered an entire classroom (didn't want to hit the whole school network, only rooms that were underutilized). That got noticed by an admin though, but he didn't know what it was and I just said this was one of my projets for graphics computing (which was indeed a real project for which distributed comp was authorized).
Mine were in the early 2000s. Back then, the computers at the lab at my uni were not very powerful, so people would do work at a Linux console, saving themselves the hassle of running a bulky X session.
Some time around 2001 I read the console_ioctl(4) manpage and found it replete with prank possibilities. I wrote little programs that would flip the console font so that all the characters were upside down; or swap capital letters with small letters, again by way of manipulating the font; or flash patterns on the keyboard LEDs; or fade to black and back by manipulating the palette.
I then added a server component so that I could leave it running at an innocuously-looking terminal, wait for a victim, fire up these effects remotely from another box in the same room, and watch what happens. Fortunately, I soon discovered that the coding part was more fun than the watching-people-slip part, so I gave up on the latter.
Another prank I used to do was simulate a successful root login on these terminals by just typing in what would be printed, including the motd, at the getty login prompt, simulating newlines with tabs/spaces (and never ever pressing RET), ending in `[root@mailhost root]# `. Then, again, step back and watch what happens. Some people would curiously type in `whoami` and be puzzled why they got a password prompt; some would step back in terror without touching anything, switch terminals and email the sysadmin.
When I was at college back in the 80's we had access as students to the college's VAX 11/750 (an 8750 Systime clone) to work on our coding projects. The student terminals were on one half of a large divided room, the other half being used by the college IT folks. Often, if there wasn't a spare terminal on the IT admin half of the room, one or two of the IT folks would use two of the nearest terminals just over the divider.
One day, bored out of my mind waiting for my COBOL project to compile, I wondered if I could capture the sys admin's username and password. I wrote a script using the CLI to perfectly simulate the login prompt complete with beeps, messages and all. All it did was clear the screen, sit there waiting for user to enter their username and password, when they did the script would mail me said username and password, display a username/password error then logout to the real login process.
After trying the script out on a couple of unsuspecting classmates and having a bit of anonymous tomfoolery I decided it was time to try this out for real with the sysadmins. I logged into both terminals the IT folks normally used and left the script running. A few hours later I returned and to my surprise and mild anxiety I found out that I'd captured the SYSTEM login password :o. For about a month or so I'd full control of that machine, and would re-run the script occasionally whenever the SYSTEM password changed. I told no-one and on my last day at college logged in and deleted the script, just in case (this was around the time the law in the UK was getting a bit heavy with regards to unauthorised computer access).
Combined with access to the huge set of manuals for that machine I spent a heap of time exploring and learning about VMS and no-one had a clue.
Very cool stories. I remember running some pranks but those are all from the early 2000s.
Best story I remember there was this arrogant guy that worked with on the Unix department. He was into FreeBSD by that time and had an attitude towards the Linux guys. One day he left his table and forgot his machine open with a root prompt. They took the chance and modified inetd.conf to map a certain port to the shutdown program. People had so much fun shutting down his computer remotely and watching his reaction.
There was also this time working for a smaller company and we would prank each other all the time. I had admin access to the Linux router so I've created a NAT rule to redirect this guy's traffic to a transparent squid proxy running a perl script that relied on imagemagik to turn the images upside down. Got the script from a Slashdot post. Poor guy even tried to reinstall the OS to no avail. He eventually found out and had his revenge by going into my computer CMOS and setting disk access to PIO instead of DMA.
I also remember scaring people through Windows' net send commands and that one where you take a screenshot of the desktop then you remove all the icons and interface bars and set the screenshot as background image. Also randomly adding 'alias ls=exit' to some server /etc/profile.
When I started at school we all got unix shell accounts mostly for email. Later years got bumped out into multiple machines but for that one year almost all of us were on the same 8 core box (and seriously clamped down quotas)
Within a few weeks, a friend of a friend of a friend had figured out how to pull pranks, and that opened the floodgates. Soon we all knew about man pages, about commands to query utmp and wtmp (to deduce who just did what to you or a friend), grep, file permissions, tty write permissions, quotas, nntp.
The most fun was when someone did something to you without figuring out how to stop it from being done right back to them. Many a kernel was cat'ed to someone else's terminal.
Even today when I'm trying to troubleshoot, half of the stuff I'm using was first used trying to seek revenge on a prankster. Once in a while I wonder if this would be a good way to teach a class on Unix.
Since I was at college in the second half of the 90s, we still had unix text consoles for reading emails so my favourite prank was to tell others in my dorm that I had worked out how to remotely log in from the dorm (we had to use a computer room back in them days!) and with my 10 line Turbo Pascal program created a fake login screen like looked identical to the normal one. After capturing a password, I would explain to each person that maybe it wasn't quite working so "sorry", so they were none the wiser that they had given me their passwords.
I didn't do anything with the passwords, it was just interesting how easy it was to get away with.
We used to play pranks on each other such as logging into the NeWS server on a colleagues machine and manually setting a small rotation in the transformation matrix for a terminal window that someone was typing in....
NeWS had an interactive PostScript shell and almost no security so this kind of mucking about was trivial...
Unfortunately none of that fun stuff lasted very long. Mostly because word would travel and enough people would know about the things they could mess with. At a certain point is was basically assured that someone would do something exceptionally stupid and get the IT guy to actually figure out how to lock that shit down.
Though they never did figure out how we got local admin access to the machines[1]. That was a fairly large security breach actually... once you have local admin, installing a keylogger that drops its logs onto a hidden network share on the machine is trivial. Personally I stayed out of that because my dad would have murdered me if I ever got caught (the friends of mine who did it did end up getting caught!) Still, I found the local admin password was useful for tweaking settings.
[1] It was simply by dropping a disc in and booting the machines into a password cracker. Was very fast since it used rainbow tables.
Speaking of interaction with the admin. Back in the days when I was in school, the computer lab ran a Honeywell mainframe with terminals. I wrote a program emulating the logon screen to intercept the username and password of the unsuspecting students logging on and to email them to me. I was going to post the list of all the usernames and passwords at the end of the semester on the wall. I dubbed it the Fishing project with my friends (yes, that's before all the phishing activities went rampant).
I collected dozens of usernames and passwords before the professor of my CS class stopped me one day after class and said, you better stop whatever you're doing. Apparently the system saved the typing of all sessions and the admin actually went through all of them.
The next semester all the terminals had a physical switch installed that had to be pressed to reset the terminal before logon. That killed any running program. I was glad to play a small part in improving the security of my school lab.
The standard ploy for a room full of terminals was to write a program that presented fake login and password prompts, collected the data, then printed whatever the standard "wrong password" message was, then exit.
At college, we had AIX Unix terminals that ran in character mode. I wrote a program to simulate the login screen. It would record your user/password to a file and then throw an 'Invalid Login' error and then actually logoff and give you the real login screen. So no one suspected anything.
After I was done with a terminal, I'd run this program and leave (knowing full well, that someone could Ctrl-C to terminate the program and get access to my account though no one ever did)
I got more than a few passwords with this. But didn't actually do anything with them. I felt bad and deleted the program and passwords after some time.
My freshman year of high school we had similar access. Mostly used it for auto-installing Doom on all the library computers at once every time the poor admin went through each computer and manually deleted it.
One friend wrote a fake login program that would immediately quit and run the real login program so we could collect credentials.
Another friend got in real trouble though, supposedly for either trying to or actually changing grades. I knew we could get in trouble. But I also never would have considered doing anything other than pranks.
Of course, even pranks can be dangerous. One of my friends found an open mail server (not that there were any shortage of those at the time) and sent some prank emails that could have gotten him in real trouble.
I once worked at a mom-and-pop ISP back in the late 1990's. The previous sysadmin overloaded the UNIX password field in /etc/shadow to be used for account suspensions, when somebody wasn't paying their internet bill, the custom "Web UI" he built would allow the business owner to lock out the account by changing the shadow password field to "*", thus denying the user dialup internet access.
At least one customer figured out that they could call the girl at reception, tell her they'd forgot their password, and she'd reset the password for him, which restored his access without paying his bill for another month. He started to do this on a monthly basis.
The punchlines:
1) the front desk girl was the girlfriend of the business owner; you'd think they'd communicate about a customer who was getting away with this, and how they were doing it
2) the sysadmin who built this system went on to become a well known project leader for an major open source encryption project that is in wide use today
My job as a student involved working in an IT office, and we had a policy of "always lock your screen". Those who didn't got creative pranks put on their computer. Only rules were no root level pranks and it had to be SFW.
Some of them I can remember
- Randomly eject CD drive. This was done in various formats like a background script running, aliased commands, etc.
- Alias 2 commands to each other (e.g. switch ls and cd)
I once wrote a memory resident keylogger back in high-school to catch the lonely sysadmin's network login. Not that I knew what to do with the login, I just wanted to prove to myself that I could.
I got plenty of logins, but not the one I wanted. Until a friend looked over the sysadmin's shoulder. I lost interest right there, but my friend went on to wreck the entire network by mistake and barely escaped paying for the whole mess.
Have to give some credit to the sysadmin for the catch. To figure out who was messing with his stuff, he put a program that emitted a high frequency tone through the PC-speaker in his login script and sat down next door to wait for my friend to take the bait.
That brings back memories, I did exactly the same too. The logins were shared with the Windows machines so after nabbing the password of our maths teacher, a few friends and I went through his account vandalising his PowerPoint slides to add subtle nonsense. Poor guy didn't know what on earth was going on during his lectures. Also found out the 'debug' login for the switches and used it to rather destructively mess with the network, much to the chagrin of the sysadmins. Good times!
At school we had a network of Acorn Archimedes machines. We all had space on the file server, which the grumpy admin would search through regularly. There was an autorun feature in RiscOS which allowed a hidden script to execute on opening a folder, eg my network folder. It just so happened that passwords were stored unhashed, so I had everyones passwords appear in my folder one day. I must have been 12 or 13, as my family relocated when I was 13.
At the new school they had the same machines, so I put my knowledge of the platform to good use. I wrote an app which played a sound sample of a loud obnoxious burp at random intervals during class.
At college they had a Novell network. The login was a simple text prompt, which I discovered called in to a novell DLL. I wrote my own substitute login command which also saved the password to local disk somewhere, and replaced the default version on a few machines.
In both cases my reaction was the same on discovering my password hacks had actually worked. I crapped my pants and covered my tracks!
By the time I had started uni, I had largely grown out of that stuff. But something triggered a latent interest I had neglected for too long... the campus accommodation was based in tower blocks, with an entry intercom system. I noticed 4 very quiet dtmf tones whenever buzzing my friends apartment. I can't remember how I did it, but I found a way to get a dial tone and to my delight, 9 for an outside line worked fine using the type of handheld dtmf dialer banks used to give out.
The best we got up to was the year we found the admin password for the default image root user in some cached Skype logs. First we would SSH into random people's systems and use Applescript to type random things etc., bonus points if they currently were presenting something. We got bored of that pretty quick and resorted to just selling the ability to do stuff as an admin like installing things.
Earlier in middle school we figured out that the MacBooks the school issued had an IR receiver and the apple remote available at the time could trigger some Fullscreen tools by hitting a button on the remote and aiming at a victims computer, again mostly to disrupt teacher presentations.
Both bits of fun came to an end when some kid figured it out and ratted us out. When they figured out I was selling root access (installed CoD4 for a friend's little brother and changed the root password for them at extra cost, when they couldn't remember what they changed it to the went to the admin) all hell broke loose and they confiscated the laptops to re-image... no fun.
When you have nice, well behaved users you'll not have problems that need solving. When things go awry - that's when you'll need to solve problems... sometimes even without pranks.
Before we had yp set up on the machines, we just copied the password file between them with a note "make sure you change your password on foo" since that was the one we regarded as authoritative and would copy that to bar.
One time, while adding a person to the /etc/groups file for write access to the web server, someone did rcp /etc/groups bar:/etc/password (I suspect it was muscle memory) and, well, now bar was unhappy and wouldn't let anyone log in... or even su to root to fix it. Found someone who had an open terminal and had them do a while 1 sync... and then powered the machine down and brought it back up. It wasn't happy, so started up in single user mode. Just needed to get the password file in there... but the terminal was 300h which didn't have a proper termcap entry for vi or emacs to work. I was a mudder and knew how to use ed... so ed /etc/password and then the contents of the minimal password file were dictated to me. When done, we got it back up and then copied the password and groups files to the proper spots.
Another time (and this was a prank), someone left themselves logged in and someone else created a directory path that was about 3000 characters long. /user/jsmith/I/will/not/leave/myself/logged/in/I/will/not/leave/myself/logged/in/ ... The problem with this is that `rm -rf` won't handle paths longer than 2048 characters long. So it didn't get removed "I'll do it later." You know what else doesn't like paths longer than 2048 characters long? fsck. So when the machine was rebooted/crashed at some point, the root volume (yea, user directories were on the root volume) failed to fsck... and failed to mount. Stuck in single user mode with the backup partition and reading the man pages for mount on the other machine we found how to force a mount without fsck and then had the guy who did the extremely long path fix it (and promise not to do it again) and got machines working.
reply