If you aren’t familiar with GNU screen, you really should stop right now and familiarize yourself with it. This is a very powerful utility which allows you to run terminal based programs on a system, disconnect from that session and re-connect later from the same or a different location. You can also start multiple terminals within a given screen session. Whenever I ssh into a system, I almost always launch screen first. If my ssh session gets disconnected unexpectedly, I can simply re-connect and pick up where I left off by re-attaching to the screen session.
I was recently working with a client on a process that was going to take quite some time to complete. The command we were running would give a progress indicator, so we could monitor the progress off and on over time. I assumed, since we both had the ability to utilize sudo to change user privileges that he would be able to sudo su – myusername followed by screen -r to take over the screen session I had started which contained this command. When he tried this, however, he was greeted with the following error:
Cannot open your terminal '/dev/pts/1' - please check.
Searching around on Google comes up with a couple of different solutions. One of these solutions suggests that the second user should change the permissions on his tty to allow everyone access to it. While this works, it is definitely a Bad Idea for security as any user on the system could then snoop that tty.
The other solution suggests that the second user should issue script /dev/null after escalating themselves to the first user’s account. This works and does not appear to have the same security implications as the method above because everyone retains access to their own tty’s.
But Why Does This Work?
What I found was that none of the posts I ran across which presented the second, preferred solution explained why this works. They merely said, “use this method,” and left it at that. Being naturally curious, and harboring a concern as to whether this also opened up a tty to others’ snooping, I had to investigate.
Of course, this all assumes that at least the second user has the ability to sudo su – and escalate their privileges. That is all. Let’s move on.
Stepping Through The Process
Here’s how I went about discovering what exactly script /dev/null does and why it allows the second user to access what appeared to be an inaccessible tty.
First, usera logs in via ssh, checks which tty was assigned, checks the permissions on that tty and launches screen:
usera@localhost ~ $ ssh usera@remotehost usera@remotehost ~ $ tty /dev/pts/1 usera@remotehost ~ $ ls -l /dev/pts/1 crw--w---- 1 usera tty 136, 1 2011-01-09 20:14 /dev/pts/1 usera@remotehost ~ $ screen
As you can see, usera has RW permissions, group members have W permissions and others have no access at all to this tty. Next, userb logs in to the same system via ssh, checks which tty was assigned and checks the permissions on that tty:
userb@localhost ~ $ ssh userb@remotehost userb@remotehost ~ $ tty /dev/pts/2 userb@remotehost ~ $ ls -l /dev/pts/2 crw--w---- 1 userb tty 136, 2 2011-01-09 20:20 /dev/pts/2
Again, the same permissions are present on the tty assigned to userb. So neither user can snoop on the other’s tty at this point. Here’s where it gets interesting, though. Let’s have userb escalate to usera and check the tty assignment and permissions again:
userb@remotehost ~ $ sudo su - usera [sudo] password for userb: usera@remotehost ~ $ tty /dev/pts/2 usera@remotehost ~ $ ls -l /dev/pts/2 crw--w---- 1 userb tty 136, 2 2011-01-09 20:20 /dev/pts/2
This is where I had my “aha moment.” Although userb has changed to usera, the same tty (with the same permissions) is in use. Therefore, all commands issued are now under usera but any command which tries to manipulate the tty (like screen does) will fail because the tty remains under control of userb.
So now let’s take a look at what script /dev/null does to the tty:
usera@remotehost ~ $ script /dev/null Script started, file is /dev/null usera@remotehost ~ $ tty /dev/pts/3 usera@remotehost ~ $ ls -l /dev/pts/3 crw--w---- 1 usera tty 136, 3 2011-01-09 20:36 /dev/pts/3
Ahh, we now have a new tty assigned to this user. Therefore, when screen -r is issued, the currently assigned tty, /dev/pts/3 is accessible to usera and the command succeeds! Also note that this new tty has the same permissions as the original usera tty, so it should be just as secure from snooping.
If you need to share a screen session with another (admin-rights holding) user, then the script /dev/null method is much preferred over mucking around with tty permissions. It appears that the script /dev/null method is just as secure as the original user’s tty because the permissions on the new tty are exactly the same.
On a more general note, be aware that solutions you find on the Internet might work, but they may not always be the best solution for the task at hand. Be sure you understand the implications of what you are doing instead of blindly copying and pasting commands you found on someone’s blog. If you are not sure what a particular solution does, I encourage you to test as I did (on a non-production system, of course) to make sure you understand it before you put it to use.