Welcome to Software Development on Codidact!
Will you help us build our independent community of developers helping developers? We're small and trying to grow. We welcome questions about all aspects of software development, from design to code to QA and more. Got questions? Got answers? Got code you'd like someone to review? Please join us.
Post History
Generallly (assuming no exploit is found) it's not possible to escalate the privileges of an already running process, except via code that itself has kernel level access (running in ring 0 - this i...
Answer
#2: Post edited
Generallly (assuming no exploit is found) it's not possible to escalate the privileges of an already running process, except via code that itself has kernel level access (running in ring 0). This is presumably how `systemd` is able to do it. But from your own Python program running in user-land (as a script being interpreted by the `python` executable`), you can only do this by starting a new process.- Fortunately, it's easy enough in Python to start new processes using the `subprocess` standard library. We can also use `os.geteuid` to determine Python's "effective user id" - i.e., `0` when the script is running as root, and nonzero otherwise. This allows us to create a script that spawns itself via `sudo` when not already running as root, and proceeds normally when it is. Something like:
- ```python
- #!/usr/bin/env python
- # (or whatever other shebang is appropriate)
- import os, sys, subprocess
- # actual code to run as root, when this file is run as a script
- def main():
- ...
- if __name__ == '__main__':
- if os.geteuid() == 0:
- sys.exit(main())
- else:
- # assuming our script has chmod+x
- sys.exit(subprocess.call(['sudo', *sys.argv]))
- ```
- Of course, the sudoers file can also be modified to allow running the script as root without a password. But for the use case of a script that only occasionally expects escalated privileges, it might be better to ask each time (the user likely wants a warning!) - and to defer the subprocess logic until it's actually necessary. This is tricky to set up; it may be easier to put the root-requiring logic in a separate script file (and perhaps use the standard output and/or error code of the root process to communicate back to the main program).
- ----
- References:
- * [Elevate privileges of running process](https://stackoverflow.com/questions/60074468) on Stack Overflow
- * [Write to a file with sudo privileges in Python](https://stackoverflow.com/questions/39499233) on Stack Overflow
- * [How do I sudo a command in a script without being asked for a password?](https://askubuntu.com/questions/155791) on Ask Ubuntu
- Generallly (assuming no exploit is found) it's not possible to escalate the privileges of an already running process, except via code that itself has kernel level access (running in ring 0 - this is presumably how `systemd` is able to do it). But from your own Python program running in user-land (as a script being interpreted by the `python` executable), you can only do this by starting a new process.
- Fortunately, it's easy enough in Python to start new processes using the `subprocess` standard library. We can also use `os.geteuid` to determine Python's "effective user id" - i.e., `0` when the script is running as root, and nonzero otherwise. This allows us to create a script that spawns itself via `sudo` when not already running as root, and proceeds normally when it is. Something like:
- ```python
- #!/usr/bin/env python
- # (or whatever other shebang is appropriate)
- import os, sys, subprocess
- # actual code to run as root, when this file is run as a script
- def main():
- ...
- if __name__ == '__main__':
- if os.geteuid() == 0:
- sys.exit(main())
- else:
- # assuming our script has chmod+x
- sys.exit(subprocess.call(['sudo', *sys.argv]))
- ```
- Of course, the sudoers file can also be modified to allow running the script as root without a password. But for the use case of a script that only occasionally expects escalated privileges, it might be better to ask each time (the user likely wants a warning!) - and to defer the subprocess logic until it's actually necessary. This is tricky to set up; it may be easier to put the root-requiring logic in a separate script file (and perhaps use the standard output and/or error code of the root process to communicate back to the main program).
- ----
- References:
- * [Elevate privileges of running process](https://stackoverflow.com/questions/60074468) on Stack Overflow
- * [Write to a file with sudo privileges in Python](https://stackoverflow.com/questions/39499233) on Stack Overflow
- * [How do I sudo a command in a script without being asked for a password?](https://askubuntu.com/questions/155791) on Ask Ubuntu
#1: Initial revision
Generallly (assuming no exploit is found) it's not possible to escalate the privileges of an already running process, except via code that itself has kernel level access (running in ring 0). This is presumably how `systemd` is able to do it. But from your own Python program running in user-land (as a script being interpreted by the `python` executable`), you can only do this by starting a new process. Fortunately, it's easy enough in Python to start new processes using the `subprocess` standard library. We can also use `os.geteuid` to determine Python's "effective user id" - i.e., `0` when the script is running as root, and nonzero otherwise. This allows us to create a script that spawns itself via `sudo` when not already running as root, and proceeds normally when it is. Something like: ```python #!/usr/bin/env python # (or whatever other shebang is appropriate) import os, sys, subprocess # actual code to run as root, when this file is run as a script def main(): ... if __name__ == '__main__': if os.geteuid() == 0: sys.exit(main()) else: # assuming our script has chmod+x sys.exit(subprocess.call(['sudo', *sys.argv])) ``` Of course, the sudoers file can also be modified to allow running the script as root without a password. But for the use case of a script that only occasionally expects escalated privileges, it might be better to ask each time (the user likely wants a warning!) - and to defer the subprocess logic until it's actually necessary. This is tricky to set up; it may be easier to put the root-requiring logic in a separate script file (and perhaps use the standard output and/or error code of the root process to communicate back to the main program). ---- References: * [Elevate privileges of running process](https://stackoverflow.com/questions/60074468) on Stack Overflow * [Write to a file with sudo privileges in Python](https://stackoverflow.com/questions/39499233) on Stack Overflow * [How do I sudo a command in a script without being asked for a password?](https://askubuntu.com/questions/155791) on Ask Ubuntu