This idea was inspired by the recent discussion on the "talk" mailing list about the (in)security of the German ID card. The Chaos Computer Club and other researchers claim that the ID card is insecure. Actual attacks that have been demonstrated are based on keyloggers.

Keyloggers might be the biggest security threat for Linux users at this time. Keyloggers are trivial to write for Linux and readily installable, and a keylogger with normal user rights may read root's password. One might ask "Why are we caring about local root exploits at all as long as users run stuff like sudo in X terminals"? Keyloggers can even read the input from devices like the Yubikey.

Various techniques exist. The simplest way is just to read xinput events. More sophistcated attacks (usually requiring root) would read from /dev/input or ttys.

My idea is to explore possibilities for a "secure" keyboard mode. This is all totally crude, not thought-through brainstorm material. I'm thinking of an ioctl that would put an input device in a special mode in which events would be forwarded only to a single process (the process that made the ioctl). Care would need to be taken that this functionality couldn't be abused for locking the input device completely. The ability to use this ioctl could be bound to capabilities and/or further restricted e.g. by SELinux, so that not even root would be able to spy on keyboard input easily.

This "secure" mode would than be available for critical operations such as reading pass phrases. In a second step, we might consider doing the password hashing in the kernel, so that user space would never need to read the clear text password at all; I'm not sure what problems with keyboard mapping we'd encounter in such a setup though.

I'd like to understand if this is total bogus, and if not, discuss implementation steps and perhaps create a PoC.

Looking for hackers with the skills:

kernel c

This project is part of:

Hack Week 15

Activity

  • over 8 years ago: slahl liked this project.
  • over 8 years ago: hennevogel liked this project.
  • over 8 years ago: mwilck added keyword "kernel" to this project.
  • over 8 years ago: mwilck added keyword "c" to this project.
  • over 8 years ago: mwilck liked this project.
  • over 8 years ago: mwilck originated this project.

  • Comments

    Be the first to comment!

    Similar Projects

    early stage kdump support by mbrugger

    Project Description

    When we experience a early boot crash, we are not able to analyze the kernel dump, as user-space wasn't able to load the crash system. The idea is to make the crash system compiled into the host kernel (think of initramfs) so that we can create a kernel dump really early in the boot process.

    Goal for the Hackweeks

    1. Investigate if this is possible and the implications it would have (done in HW21)
    2. Hack up a PoC (done in HW22 and HW23)
    3. Prepare RFC series (giving it's only one week, we are entering wishful thinking territory here).

    update HW23

    • I was able to include the crash kernel into the kernel Image.
    • I'll need to find a way to load that from init/main.c:start_kernel() probably after kcsan_init()
    • I workaround for a smoke test was to hack kexec_file_load() systemcall which has two problems:
      1. My initramfs in the porduction kernel does not have a new enough kexec version, that's not a blocker but where the week ended
      2. As the crash kernel is part of init.data it will be already stale once I can call kexec_file_load() from user-space.

    The solution is probably to rewrite the POC so that the invocation can be done from init.text (that's my theory) but I'm not sure if I can reuse the kexec infrastructure in the kernel from there, which I rely on heavily.

    update HW24

    • Day1
      • rebased on v6.12 with no problems others then me breaking the config
      • setting up a new compilation and qemu/virtme env
      • getting desperate as nothing works that used to work
    • Day 2
      • getting to call the invocation of loading the early kernel from __init after kcsan_init()
    • Day 3

      • fix problem of memdup not being able to alloc so much memory... use 64K page sizes for now
      • code refactoring
      • I'm now able to load the crash kernel
      • When using virtme I can boot into the crash kernel, also it doesn't boot completely (major milestone!), crash in elfcorehdr_read_notes()
    • Day 4

      • crash systems crashes (no pun intended) in copy_old_mempage() link; will need to understand elfcorehdr...
      • call path vmcore_init() -> parse_crash_elf_headers() -> elfcorehdr_read() -> read_from_oldmem() -> copy_oldmem_page() -> copy_to_iter()
    • Day 5

      • hacking arch/arm64/kernel/crash_dump.c:copy_old_mempage() to see if crash system really starts. It does.
      • fun fact: retested with more reserved memory and with UEFI FW, host kernel crashes in init but directly starts the crash kernel, so it works (somehow) \o/
    • TODOs

      • fix elfcorehdr so that we actually can make use of all this...
      • test where in the boot __init() chain we can/should call kexec_early_dump()