_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3 values | text stringlengths 66 10.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q18800 | Twocheckout.Option.update | train | def update(opts)
opts = opts.merge(:option_id => self.option_id)
Twocheckout::API.request(:post, 'products/update_option', opts)
response = Twocheckout::API.request(:get, 'products/detail_option', opts)
Option.new(response['option'][0])
end | ruby | {
"resource": ""
} |
q18801 | Twocheckout.Sale.comment | train | def comment(opts)
opts = opts.merge(:sale_id => self.sale_id)
Twocheckout::API.request(:post, 'sales/create_comment', opts)
end | ruby | {
"resource": ""
} |
q18802 | Twocheckout.Sale.ship | train | def ship(opts)
opts = opts.merge(:sale_id => self.sale_id)
Twocheckout::API.request(:post, 'sales/mark_shipped', opts)
end | ruby | {
"resource": ""
} |
q18803 | Twocheckout.LineItem.update_recurring! | train | def update_recurring!(opts)
opts = opts.merge(:lineitem_id => self.lineitem_id)
Twocheckout::API.request(:post, 'sales/update_lineitem_recurring', opts)
end | ruby | {
"resource": ""
} |
q18804 | Twocheckout.Product.update | train | def update(opts)
opts = opts.merge(:product_id => self.product_id)
Twocheckout::API.request(:post, 'products/update_product', opts)
response = Twocheckout::API.request(:get, 'products/detail_product', opts)
Product.new(response['product'])
end | ruby | {
"resource": ""
} |
q18805 | BrowserifyRails.BrowserifyProcessor.commonjs_module? | train | def commonjs_module?
data.to_s.include?("module.exports") || data.present? && data.to_s.match(/(require\(.*\)|import)/) && dependencies.length > 0
end | ruby | {
"resource": ""
} |
q18806 | BrowserifyRails.BrowserifyProcessor.evaluate_dependencies | train | def evaluate_dependencies(asset_paths)
return dependencies if config.evaluate_node_modules
dependencies.select do |path|
path.start_with?(*asset_paths)
end
end | ruby | {
"resource": ""
} |
q18807 | Nexpose.Connection.console_command | train | def console_command(cmd_string)
xml = make_xml('ConsoleCommandRequest', {})
cmd = REXML::Element.new('Command')
cmd.text = cmd_string
xml << cmd
r = execute(xml)
if r.success
r.res.elements.each('//Output') do |out|
return out.text.to_s
end
else
false
end
end | ruby | {
"resource": ""
} |
q18808 | Nexpose.Connection.system_information | train | def system_information
r = execute(make_xml('SystemInformationRequest', {}))
if r.success
res = {}
r.res.elements.each('//Statistic') do |stat|
res[stat.attributes['name'].to_s] = stat.text.to_s
end
res
else
false
end
end | ruby | {
"resource": ""
} |
q18809 | Nexpose.Connection.engine_versions | train | def engine_versions
info = console_command('version engines')
versions = []
engines = info.sub('VERSION INFORMATION\n', '').split(/\n\n/)
engines.each do |eng|
engdata = {}
eng.split(/\n/).each do |kv|
key, value = kv.split(/:\s*/)
key = key.sub('Local Engine ', '').sub('Remote Engine ', '')
engdata[key] = value
end
versions << engdata
end
versions
end | ruby | {
"resource": ""
} |
q18810 | Nexpose.Connection.send_log | train | def send_log(uri = 'https://support.rapid7.com')
url = REXML::Element.new('URL')
url.text = uri
tpt = REXML::Element.new('Transport')
tpt.add_attribute('protocol', 'https')
tpt << url
xml = make_xml('SendLogRequest')
xml << tpt
execute(xml).success
end | ruby | {
"resource": ""
} |
q18811 | Nexpose.Connection.scan_ips_with_schedule | train | def scan_ips_with_schedule(site_id, ip_addresses, schedules)
xml = make_xml('SiteDevicesScanRequest', 'site-id' => site_id)
hosts = REXML::Element.new('Hosts')
ip_addresses.each do |ip|
xml.add_element('range', 'from' => ip)
end
xml.add_element(hosts)
scheds = REXML::Element.new('Schedules')
schedules.each { |sched| scheds.add_element(sched.as_xml) }
xml.add_element(scheds)
_scan_ad_hoc_with_schedules(xml)
end | ruby | {
"resource": ""
} |
q18812 | Nexpose.Connection.scan_ips | train | def scan_ips(site_id, ip_addresses)
xml = make_xml('SiteDevicesScanRequest', 'site-id' => site_id)
hosts = REXML::Element.new('Hosts')
ip_addresses.each do |ip|
xml.add_element('range', 'from' => ip)
end
xml.add_element(hosts)
_scan_ad_hoc(xml)
end | ruby | {
"resource": ""
} |
q18813 | Nexpose.Connection.scan_site | train | def scan_site(site_id, blackout_override = false)
xml = make_xml('SiteScanRequest', 'site-id' => site_id)
xml.add_attributes({ 'force' => true }) if blackout_override
response = execute(xml)
Scan.parse(response.res) if response.success
end | ruby | {
"resource": ""
} |
q18814 | Nexpose.Connection.scan_assets_with_template_and_engine | train | def scan_assets_with_template_and_engine(site_id, assets, scan_template, scan_engine)
uri = "/data/site/#{site_id}/scan"
assets.size > 1 ? addresses = assets.join(',') : addresses = assets.first
params = { 'addressList' => addresses,
'template' => scan_template,
'scanEngine' => scan_engine }
scan_id = AJAX.form_post(self, uri, params)
scan_id.to_i
end | ruby | {
"resource": ""
} |
q18815 | Nexpose.Connection._append_asset! | train | def _append_asset!(xml, asset)
if asset.is_a? Nexpose::IPRange
xml.add_element('range', 'from' => asset.from, 'to' => asset.to)
else # Assume HostName
host = REXML::Element.new('host')
host.text = asset
xml.add_element(host)
end
end | ruby | {
"resource": ""
} |
q18816 | Nexpose.Connection._scan_ad_hoc | train | def _scan_ad_hoc(xml)
r = execute(xml, '1.1', timeout: 60)
Scan.parse(r.res)
end | ruby | {
"resource": ""
} |
q18817 | Nexpose.Connection.stop_scan | train | def stop_scan(scan_id, wait_sec = 0)
r = execute(make_xml('ScanStopRequest', 'scan-id' => scan_id))
if r.success
so_far = 0
while so_far < wait_sec
status = scan_status(scan_id)
return status if status == 'stopped'
sleep 5
so_far += 5
end
end
r.success
end | ruby | {
"resource": ""
} |
q18818 | Nexpose.Connection.scan_status | train | def scan_status(scan_id)
r = execute(make_xml('ScanStatusRequest', 'scan-id' => scan_id))
r.success ? r.attributes['status'] : nil
end | ruby | {
"resource": ""
} |
q18819 | Nexpose.Connection.resume_scan | train | def resume_scan(scan_id)
r = execute(make_xml('ScanResumeRequest', 'scan-id' => scan_id), '1.1', timeout: 60)
r.success ? r.attributes['success'] == '1' : false
end | ruby | {
"resource": ""
} |
q18820 | Nexpose.Connection.pause_scan | train | def pause_scan(scan_id)
r = execute(make_xml('ScanPauseRequest', 'scan-id' => scan_id))
r.success ? r.attributes['success'] == '1' : false
end | ruby | {
"resource": ""
} |
q18821 | Nexpose.Connection.activity | train | def activity
r = execute(make_xml('ScanActivityRequest'))
res = []
if r.success
r.res.elements.each('//ScanSummary') do |scan|
res << ScanData.parse(scan)
end
end
res
end | ruby | {
"resource": ""
} |
q18822 | Nexpose.Connection.scan_activity | train | def scan_activity
r = execute(make_xml('ScanActivityRequest'))
res = []
if r.success
r.res.elements.each('//ScanSummary') do |scan|
res << ScanSummary.parse(scan)
end
end
res
end | ruby | {
"resource": ""
} |
q18823 | Nexpose.Connection.scan_statistics | train | def scan_statistics(scan_id)
r = execute(make_xml('ScanStatisticsRequest', 'scan-id' => scan_id))
if r.success
ScanSummary.parse(r.res.elements['//ScanSummary'])
else
false
end
end | ruby | {
"resource": ""
} |
q18824 | Nexpose.Connection.past_scans | train | def past_scans(limit = nil)
uri = '/data/scan/global/scan-history'
rows = AJAX.row_pref_of(limit)
params = { 'sort' => 'endTime', 'dir' => 'DESC', 'startIndex' => 0 }
AJAX.preserving_preference(self, 'global-completed-scans') do
data = DataTable._get_json_table(self, uri, params, rows, limit)
data.map(&CompletedScan.method(:parse_json))
end
end | ruby | {
"resource": ""
} |
q18825 | Nexpose.Connection.paused_scans | train | def paused_scans(site_id = nil, limit = nil)
if site_id
uri = "/data/scan/site/#{site_id}?status=active"
rows = AJAX.row_pref_of(limit)
params = { 'sort' => 'endTime', 'dir' => 'DESC', 'startIndex' => 0 }
AJAX.preserving_preference(self, 'site-active-scans') do
data = DataTable._get_json_table(self, uri, params, rows, limit).select { |scan| scan['paused'] }
data.map(&ActiveScan.method(:parse_json))
end
else
uri = '/data/site/scans/dyntable.xml?printDocType=0&tableID=siteScansTable&activeOnly=true'
data = DataTable._get_dyn_table(self, uri).select { |scan| (scan['Status'].include? 'Paused') }
data.map(&ActiveScan.method(:parse_dyntable))
end
end | ruby | {
"resource": ""
} |
q18826 | Nexpose.Connection.export_scan | train | def export_scan(scan_id, zip_file = nil)
http = AJAX.https(self)
headers = { 'Cookie' => "nexposeCCSessionID=#{@session_id}", 'Accept-Encoding' => 'identity' }
resp = http.get("/data/scan/#{scan_id}/export", headers)
case resp
when Net::HTTPSuccess
if zip_file
::File.open(zip_file, 'wb') { |file| file.write(resp.body) }
else
resp.body
end
when Net::HTTPForbidden
raise Nexpose::PermissionError.new(resp)
else
raise Nexpose::APIError.new(resp, "#{resp.class}: Unrecognized response.")
end
end | ruby | {
"resource": ""
} |
q18827 | Nexpose.Connection.import_scan | train | def import_scan(site_id, zip_file)
data = Rexlite::MIME::Message.new
data.add_part(site_id.to_s, nil, nil, 'form-data; name="siteid"')
data.add_part(session_id, nil, nil, 'form-data; name="nexposeCCSessionID"')
::File.open(zip_file, 'rb') do |scan|
data.add_part(scan.read, 'application/zip', 'binary',
"form-data; name=\"scan\"; filename=\"#{zip_file}\"")
end
post = Net::HTTP::Post.new('/data/scan/import')
post.body = data.to_s
post.set_content_type('multipart/form-data', boundary: data.bound)
# Avoiding AJAX#request, because the data can cause binary dump on error.
http = AJAX.https(self)
AJAX.headers(self, post)
response = http.request(post)
case response
when Net::HTTPOK
response.body.empty? ? response.body : response.body.to_i
when Net::HTTPUnauthorized
raise Nexpose::PermissionError.new(response)
else
raise Nexpose::APIError.new(post, response.body)
end
end | ruby | {
"resource": ""
} |
q18828 | Nexpose.DataTable._get_json_table | train | def _get_json_table(console, address, parameters = {}, page_size = 500, records = nil, post = true)
parameters['dir'] = 'DESC'
parameters['startIndex'] = -1
parameters['results'] = -1
if post
request = lambda { |p| AJAX.form_post(console, address, p) }
else
request = lambda { |p| AJAX.get(console, address.dup, AJAX::CONTENT_TYPE::JSON, p) }
end
response = request.call(parameters)
data = JSON.parse(response)
# Don't attept to grab more records than there are.
total = data['totalRecords']
return [] if total.zero?
total = records.nil? ? total : [records, total].min
rows = []
parameters['results'] = page_size
while rows.length < total
parameters['startIndex'] = rows.length
data = JSON.parse(request.call(parameters))
rows.concat data['records']
end
rows
end | ruby | {
"resource": ""
} |
q18829 | Nexpose.DataTable._get_dyn_table | train | def _get_dyn_table(console, address, payload = nil)
if payload
response = AJAX.post(console, address, payload)
else
response = AJAX.get(console, address)
end
response = REXML::Document.new(response)
headers = _dyn_headers(response)
rows = _dyn_rows(response)
rows.map { |row| Hash[headers.zip(row)] }
end | ruby | {
"resource": ""
} |
q18830 | Nexpose.DataTable._dyn_headers | train | def _dyn_headers(response)
headers = []
response.elements.each('DynTable/MetaData/Column') do |header|
headers << header.attributes['name']
end
headers
end | ruby | {
"resource": ""
} |
q18831 | Nexpose.DataTable._dyn_rows | train | def _dyn_rows(response)
rows = []
response.elements.each('DynTable/Data/tr') do |row|
rows << _dyn_record(row)
end
rows
end | ruby | {
"resource": ""
} |
q18832 | Nexpose.DataTable._dyn_record | train | def _dyn_record(row)
record = []
row.elements.each('td') do |value|
record << (value.text ? value.text.to_s : '')
end
record
end | ruby | {
"resource": ""
} |
q18833 | Nexpose.Connection.list_report_templates | train | def list_report_templates
r = execute(make_xml('ReportTemplateListingRequest', {}))
templates = []
if r.success
r.res.elements.each('//ReportTemplateSummary') do |template|
templates << ReportTemplateSummary.parse(template)
end
end
templates
end | ruby | {
"resource": ""
} |
q18834 | Nexpose.ReportTemplate.save | train | def save(connection)
xml = %(<ReportTemplateSaveRequest session-id='#{connection.session_id}' scope='#{@scope}'>)
xml << to_xml
xml << '</ReportTemplateSaveRequest>'
response = connection.execute(xml)
if response.success
@id = response.attributes['template-id']
end
end | ruby | {
"resource": ""
} |
q18835 | Nexpose.APIObject.object_from_hash | train | def object_from_hash(nsc, hash)
hash.each do |k, v|
next if k == :url # Do not store self-referential URL.
# Store resource URLs separately and create lazy accessors.
if v.is_a?(Hash) && v.key?(:url)
self.class.send(:define_method, k, proc { |conn = nsc| load_resource(conn, k, v[:url].gsub(/.*\/api/, '/api')) })
else
# Convert timestamps.
if v.is_a?(String) && v.match(/^\d{8}T\d{6}\.\d{3}/)
instance_variable_set("@#{k}", ISO8601.to_time(v))
elsif v.is_a?(Array) && k == :attributes
instance_variable_set("@#{k}", v.map { |h| { h[:key] => h[:value] } })
else
instance_variable_set("@#{k}", v)
end
self.class.send(:define_method, k, proc { instance_variable_get("@#{k}") })
end
end
self
end | ruby | {
"resource": ""
} |
q18836 | Nexpose.APIObject.load_resource | train | def load_resource(nsc, k, url)
obj = class_from_string(k)
resp = AJAX.get(nsc, url, AJAX::CONTENT_TYPE::JSON)
hash = JSON.parse(resp, symbolize_names: true)
if hash.is_a?(Array)
resources = hash.map { |e| obj.method(:new).call.object_from_hash(nsc, e) }
elsif hash.key?(:resources)
resources = hash[:resources].map { |e| obj.method(:new).call.object_from_hash(nsc, e) }
else
resources = obj.method(:new).call.object_from_hash(nsc, hash)
end
instance_variable_set("@#{k}", resources)
self.class.send(:define_method, k, proc { instance_variable_get("@#{k}") })
resources
end | ruby | {
"resource": ""
} |
q18837 | Nexpose.APIObject.class_from_string | train | def class_from_string(field)
str = field.to_s.split('_').map(&:capitalize!).join
str = 'Vulnerability' if str == 'Vulnerabilities'
str.chop! if str.end_with?('s')
Object.const_get('Nexpose').const_get(str)
end | ruby | {
"resource": ""
} |
q18838 | Nexpose.DynamicAssetGroup.save | train | def save(nsc)
# load includes admin users, but save will fail if they are included.
admins = nsc.users.select { |u| u.is_admin }.map { |u| u.id }
@users.reject! { |id| admins.member? id }
params = @id ? { 'entityid' => @id, 'mode' => 'edit' } : { 'entityid' => false, 'mode' => false }
uri = AJAX.parameterize_uri('/data/assetGroup/saveAssetGroup', params)
data = JSON.parse(AJAX.post(nsc, uri, _to_entity_details, AJAX::CONTENT_TYPE::JSON))
data['response'] == 'success.'
end | ruby | {
"resource": ""
} |
q18839 | Nexpose.Connection.list_engine_pools | train | def list_engine_pools
response = execute(make_xml('EnginePoolListingRequest'), '1.2')
arr = []
if response.success
response.res.elements.each('EnginePoolListingResponse/EnginePoolSummary') do |pool|
arr << EnginePoolSummary.new(pool.attributes['id'],
pool.attributes['name'],
pool.attributes['scope'])
end
end
arr
end | ruby | {
"resource": ""
} |
q18840 | Nexpose.EnginePool.save | train | def save(connection)
request = @id > 0 ? 'EnginePoolUpdateRequest' : 'EnginePoolCreateRequest'
xml = %(<#{request} session-id="#{connection.session_id}">)
xml << '<EnginePool'
xml << %( id="#{@id}") if @id > 0
xml << %( name="#{@name}" scope="#{@scope}">)
@engines.each do |engine|
xml << %(<Engine name="#{engine.name}" />)
end
xml << '</EnginePool>'
xml << %(</#{request}>)
r = connection.execute(xml, '1.2')
if r.success
r.res.elements.each(request.gsub('Request', 'Response')) do |v|
return @id = v.attributes['id'].to_i
end
end
end | ruby | {
"resource": ""
} |
q18841 | Nexpose.Connection.list_sites | train | def list_sites
r = execute(make_xml('SiteListingRequest'))
arr = []
if r.success
r.res.elements.each('SiteListingResponse/SiteSummary') do |site|
arr << SiteSummary.new(site.attributes['id'].to_i,
site.attributes['name'],
site.attributes['description'],
site.attributes['riskfactor'].to_f,
site.attributes['riskscore'].to_f)
end
end
arr
end | ruby | {
"resource": ""
} |
q18842 | Nexpose.Connection.site_scan_history | train | def site_scan_history(site_id)
r = execute(make_xml('SiteScanHistoryRequest', { 'site-id' => site_id }))
scans = []
if r.success
r.res.elements.each('SiteScanHistoryResponse/ScanSummary') do |scan_event|
scans << ScanSummary.parse(scan_event)
end
end
scans
end | ruby | {
"resource": ""
} |
q18843 | Nexpose.Connection.completed_scans | train | def completed_scans(site_id)
table = { 'table-id' => 'site-completed-scans' }
data = DataTable._get_json_table(self, "/data/scan/site/#{site_id}", table)
data.map(&CompletedScan.method(:parse_json))
end | ruby | {
"resource": ""
} |
q18844 | Nexpose.Site.remove_included_ip_range | train | def remove_included_ip_range(from, to)
from_ip = IPAddr.new(from)
to_ip = IPAddr.new(to)
(from_ip..to_ip)
raise 'Invalid IP range specified' if (from_ip..to_ip).to_a.size.zero?
@included_scan_targets[:addresses].reject! { |t| t.eql? IPRange.new(from, to) }
rescue ArgumentError => e
raise "#{e.message} in given IP range"
end | ruby | {
"resource": ""
} |
q18845 | Nexpose.Site.exclude_ip_range | train | def exclude_ip_range(from, to)
from_ip = IPAddr.new(from)
to_ip = IPAddr.new(to)
(from_ip..to_ip)
raise 'Invalid IP range specified' if (from_ip..to_ip).to_a.size.zero?
@excluded_scan_targets[:addresses] << IPRange.new(from, to)
rescue ArgumentError => e
raise "#{e.message} in given IP range"
end | ruby | {
"resource": ""
} |
q18846 | Nexpose.Site.remove_included_asset_group | train | def remove_included_asset_group(asset_group_id)
validate_asset_group(asset_group_id)
@included_scan_targets[:asset_groups].reject! { |t| t.eql? asset_group_id.to_i }
end | ruby | {
"resource": ""
} |
q18847 | Nexpose.Site.remove_excluded_asset_group | train | def remove_excluded_asset_group(asset_group_id)
validate_asset_group(asset_group_id)
@excluded_scan_targets[:asset_groups].reject! { |t| t.eql? asset_group_id.to_i }
end | ruby | {
"resource": ""
} |
q18848 | Nexpose.Site.scan | train | def scan(connection, sync_id = nil, blackout_override = false)
xml = REXML::Element.new('SiteScanRequest')
xml.add_attributes({ 'session-id' => connection.session_id,
'site-id' => @id,
'sync-id' => sync_id })
xml.add_attributes({ 'force' => true }) if blackout_override
response = connection.execute(xml, '1.1', timeout: connection.timeout)
Scan.parse(response.res) if response.success
end | ruby | {
"resource": ""
} |
q18849 | Nexpose.SiloProfile.update | train | def update(connection)
xml = connection.make_xml('SiloProfileUpdateRequest')
xml.add_element(as_xml)
r = connection.execute(xml, '1.2')
@id = r.attributes['silo-profile-id'] if r.success
end | ruby | {
"resource": ""
} |
q18850 | Nexpose.Connection.list_reports | train | def list_reports
r = execute(make_xml('ReportListingRequest'))
reports = []
if r.success
r.res.elements.each('//ReportConfigSummary') do |report|
reports << ReportConfigSummary.parse(report)
end
end
reports
end | ruby | {
"resource": ""
} |
q18851 | Nexpose.Connection.generate_report | train | def generate_report(report_id, wait = false)
xml = make_xml('ReportGenerateRequest', { 'report-id' => report_id })
response = execute(xml)
if response.success
response.res.elements.each('//ReportSummary') do |summary|
summary = ReportSummary.parse(summary)
# If not waiting or the report is finished, return now.
return summary unless wait && summary.status == 'Started'
end
end
so_far = 0
while wait
summary = last_report(report_id)
return summary unless summary.status == 'Started'
sleep 5
so_far += 5
if (so_far % 60).zero?
puts "Still waiting. Current status: #{summary.status}"
end
end
nil
end | ruby | {
"resource": ""
} |
q18852 | Nexpose.Connection.last_report | train | def last_report(report_config_id)
history = report_history(report_config_id)
history.sort { |a, b| b.generated_on <=> a.generated_on }.first
end | ruby | {
"resource": ""
} |
q18853 | Nexpose.AdhocReportConfig.generate | train | def generate(connection, timeout = 300, raw = false)
xml = %(<ReportAdhocGenerateRequest session-id="#{connection.session_id}">)
xml << to_xml
xml << '</ReportAdhocGenerateRequest>'
response = connection.execute(xml, '1.1', timeout: timeout, raw: raw)
if response.success
content_type_response = response.raw_response.header['Content-Type']
if content_type_response =~ /multipart\/mixed;\s*boundary=([^\s]+)/
# Nexpose sends an incorrect boundary format which breaks parsing
# e.g., boundary=XXX; charset=XXX
# Fix by removing everything from the last semi-colon onward.
last_semi_colon_index = content_type_response.index(/;/, content_type_response.index(/boundary/))
content_type_response = content_type_response[0, last_semi_colon_index]
data = 'Content-Type: ' + content_type_response + "\r\n\r\n" + response.raw_response_data
doc = Rexlite::MIME::Message.new(data)
doc.parts.each do |part|
if /.*base64.*/ =~ part.header.to_s
if @format =~ /(?:ht|x)ml/
if part.header.to_s =~ %r(text/xml)
return part.content.unpack('m*')[0].to_s
elsif part.header.to_s =~ %r(text/html)
return part.content.unpack('m*')[0].to_s
end
else # text|pdf|csv|rtf
return part.content.unpack('m*')[0]
end
end
end
end
end
end | ruby | {
"resource": ""
} |
q18854 | Nexpose.ReportConfig.save | train | def save(connection, generate_now = false)
xml = %(<ReportSaveRequest session-id="#{connection.session_id}" generate-now="#{generate_now ? 1 : 0}">)
xml << to_xml
xml << '</ReportSaveRequest>'
response = connection.execute(xml)
if response.success
@id = response.attributes['reportcfg-id'].to_i
end
end | ruby | {
"resource": ""
} |
q18855 | Nexpose.Connection.list_vulns | train | def list_vulns(full = false)
xml = make_xml('VulnerabilityListingRequest')
# TODO: Add a flag to do stream parsing of the XML to improve performance.
response = execute(xml, '1.2')
vulns = []
if response.success
response.res.elements.each('VulnerabilityListingResponse/VulnerabilitySummary') do |vuln|
if full
vulns << XML::VulnerabilitySummary.parse(vuln)
else
vulns << XML::Vulnerability.new(vuln.attributes['id'],
vuln.attributes['title'],
vuln.attributes['severity'].to_i)
end
end
end
vulns
end | ruby | {
"resource": ""
} |
q18856 | Nexpose.Connection.vuln_details | train | def vuln_details(vuln_id)
xml = make_xml('VulnerabilityDetailsRequest', { 'vuln-id' => vuln_id })
response = execute(xml, '1.2')
if response.success
response.res.elements.each('VulnerabilityDetailsResponse/Vulnerability') do |vuln|
return XML::VulnerabilityDetail.parse(vuln)
end
end
end | ruby | {
"resource": ""
} |
q18857 | Nexpose.Connection.find_vuln_check | train | def find_vuln_check(search_term, partial_words = true, all_words = true)
uri = "/data/vulnerability/vulnerabilities/dyntable.xml?tableID=VulnCheckSynopsis&phrase=#{URI.encode(search_term)}&allWords=#{all_words}"
data = DataTable._get_dyn_table(self, uri)
data.map do |vuln|
XML::VulnCheck.new(vuln)
end
end | ruby | {
"resource": ""
} |
q18858 | Nexpose.Connection.find_vulns_by_date | train | def find_vulns_by_date(from, to = nil)
uri = "/data/vulnerability/synopsis/dyntable.xml?addedMin=#{from}"
uri += "&addedMax=#{to}" if to
DataTable._get_dyn_table(self, uri).map { |v| VulnSynopsis.new(v) }
end | ruby | {
"resource": ""
} |
q18859 | Nexpose.Connection.delete_tickets | train | def delete_tickets(tickets)
# TODO: Take Ticket objects, too, and pull out IDs.
xml = make_xml('TicketDeleteRequest')
tickets.each do |id|
xml.add_element('Ticket', { 'id' => id })
end
(execute xml, '1.2').success
end | ruby | {
"resource": ""
} |
q18860 | Nexpose.Ticket.save | train | def save(connection)
xml = connection.make_xml('TicketCreateRequest')
xml.add_element(to_xml)
response = connection.execute(xml, '1.2')
@id = response.attributes['id'].to_i if response.success
end | ruby | {
"resource": ""
} |
q18861 | Nexpose.Console.save | train | def save(connection)
nsc = REXML::XPath.first(@xml, 'NeXposeSecurityConsole')
nsc.attributes['scanThreadsLimit'] = @scan_threads_limit.to_i
nsc.attributes['realtimeIntegration'] = @incremental_scan_results ? '1' : '0'
web_server = REXML::XPath.first(nsc, 'WebServer')
web_server.attributes['sessionTimeout'] = @session_timeout.to_i
response = REXML::Document.new(Nexpose::AJAX.post(connection, '/data/admin/config/nsc', @xml))
saved = REXML::XPath.first(response, 'SaveConfig')
saved.attributes['success'] == '1'
end | ruby | {
"resource": ""
} |
q18862 | Nexpose.Connection.list_scan_templates | train | def list_scan_templates
templates = JSON.parse(AJAX.get(self, '/api/2.0/scan_templates'))
templates['resources'].map { |t| ScanTemplateSummary.new(t) }
end | ruby | {
"resource": ""
} |
q18863 | Nexpose.ScanTemplate.name= | train | def name=(name)
desc = REXML::XPath.first(@xml, 'ScanTemplate/templateDescription')
if desc
desc.attributes['title'] = replace_entities(name)
else
root = REXML::XPath.first(xml, 'ScanTemplate')
desc = REXML::Element.new('templateDescription')
desc.add_attribute('title', name)
root.add_element(desc)
end
end | ruby | {
"resource": ""
} |
q18864 | Nexpose.ScanTemplate.description= | train | def description=(description)
desc = REXML::XPath.first(@xml, 'ScanTemplate/templateDescription')
if desc
desc.text = replace_entities(description)
else
root = REXML::XPath.first(xml, 'ScanTemplate')
desc = REXML::Element.new('templateDescription')
desc.add_text(description)
root.add_element(desc)
end
end | ruby | {
"resource": ""
} |
q18865 | Nexpose.ScanTemplate.scan_threads= | train | def scan_threads=(threads)
scan_threads = REXML::XPath.first(@xml, 'ScanTemplate/General/scanThreads')
scan_threads.text = threads.to_s
end | ruby | {
"resource": ""
} |
q18866 | Nexpose.ScanTemplate.host_threads= | train | def host_threads=(threads)
host_threads = REXML::XPath.first(@xml, 'ScanTemplate/General/hostThreads')
host_threads.text = threads.to_s
end | ruby | {
"resource": ""
} |
q18867 | Nexpose.ScanTemplate.tcp_device_discovery_ports= | train | def tcp_device_discovery_ports=(ports)
tcp = REXML::XPath.first(@xml, 'ScanTemplate/DeviceDiscovery/CheckHosts/TCPHostCheck')
REXML::XPath.first(tcp, './portList').text = ports.join(',')
end | ruby | {
"resource": ""
} |
q18868 | Nexpose.ScanTemplate.udp_device_discovery_ports= | train | def udp_device_discovery_ports=(ports)
udp = REXML::XPath.first(@xml, 'ScanTemplate/DeviceDiscovery/CheckHosts/UDPHostCheck')
REXML::XPath.first(udp, './portList').text = ports.join(',')
end | ruby | {
"resource": ""
} |
q18869 | Nexpose.ScanTemplate.tcp_service_discovery_ports= | train | def tcp_service_discovery_ports=(ports)
service_ports = REXML::XPath.first(@xml, 'ScanTemplate/ServiceDiscovery/TCPPortScan')
service_ports.attributes['mode'] = 'custom'
service_ports.attributes['method'] = 'syn'
REXML::XPath.first(service_ports, './portList').text = ports.join(',')
end | ruby | {
"resource": ""
} |
q18870 | Nexpose.ScanTemplate.exclude_tcp_service_discovery_ports= | train | def exclude_tcp_service_discovery_ports=(ports)
service_ports = REXML::XPath.first(@xml, 'ScanTemplate/ServiceDiscovery/ExcludedTCPPortScan')
REXML::XPath.first(service_ports, './portList').text = ports.join(',')
end | ruby | {
"resource": ""
} |
q18871 | Nexpose.ScanTemplate.exclude_udp_service_discovery_ports= | train | def exclude_udp_service_discovery_ports=(ports)
service_ports = REXML::XPath.first(@xml, 'ScanTemplate/ServiceDiscovery/ExcludedUDPPortScan')
REXML::XPath.first(service_ports, './portList').text = ports.join(',')
end | ruby | {
"resource": ""
} |
q18872 | Nexpose.ScanTemplate.enabled_vuln_checks | train | def enabled_vuln_checks
checks = REXML::XPath.first(@xml, '//VulnerabilityChecks/Enabled')
checks ? checks.elements.to_a('Check').map { |c| c.attributes['id'] } : []
end | ruby | {
"resource": ""
} |
q18873 | Nexpose.ScanTemplate.enable_vuln_check | train | def enable_vuln_check(check_id)
checks = REXML::XPath.first(@xml, '//VulnerabilityChecks')
checks.elements.delete("Disabled/Check[@id='#{check_id}']")
enabled_checks = checks.elements['Enabled'] || checks.add_element('Enabled')
enabled_checks.add_element('Check', { 'id' => check_id })
end | ruby | {
"resource": ""
} |
q18874 | Nexpose.ScanTemplate.disable_vuln_check | train | def disable_vuln_check(check_id)
checks = REXML::XPath.first(@xml, '//VulnerabilityChecks')
checks.elements.delete("Enabled/Check[@id='#{check_id}']")
disabled_checks = checks.elements['Disabled'] || checks.add_element('Disabled')
disabled_checks.add_element('Check', { 'id' => check_id })
end | ruby | {
"resource": ""
} |
q18875 | Nexpose.ScanTemplate.remove_vuln_check | train | def remove_vuln_check(check_id)
checks = REXML::XPath.first(@xml, '//VulnerabilityChecks')
checks.elements.delete("Disabled/Check[@id='#{check_id}']")
checks.elements.delete("Enabled/Check[@id='#{check_id}']")
end | ruby | {
"resource": ""
} |
q18876 | Nexpose.ScanTemplate.save | train | def save(nsc)
root = REXML::XPath.first(@xml, 'ScanTemplate')
if root.attributes['id'] == '#NewScanTemplate#'
response = JSON.parse(AJAX.post(nsc, '/data/scan/templates', xml))
root.attributes['id'] = response['value']
else
response = JSON.parse(AJAX.put(nsc, "/data/scan/templates/#{URI.encode(id)}", xml))
end
response['value']
end | ruby | {
"resource": ""
} |
q18877 | Nexpose.ScanTemplate.aces_level= | train | def aces_level=(level)
return if level.nil?
return unless ['full', 'default', 'none'].include? level.downcase
logging = REXML::XPath.first(@xml, 'ScanTemplate/Logging')
if logging.nil?
logging = REXML::Element.new('Logging')
@xml.add_element(logging)
end
aces = REXML::XPath.first(logging, 'aces')
if aces.nil?
aces = REXML::Element.new('aces')
logging.add_element(aces)
end
aces.attributes['level'] = level
end | ruby | {
"resource": ""
} |
q18878 | Nexpose.ScanTemplate.enable_debug_logging= | train | def enable_debug_logging=(enable)
return if enable.nil?
logging = REXML::XPath.first(@xml, 'ScanTemplate/Logging')
if logging.nil?
logging = REXML::Element.new('Logging')
@xml.add_element(logging)
end
debug_logging = REXML::XPath.first(logging, 'debugLogging')
if debug_logging.nil?
debug_logging = REXML::Element.new('debugLogging')
logging.add_element(debug_logging)
end
debug_logging.attributes['enabled'] = (enable ? 1 : 0)
end | ruby | {
"resource": ""
} |
q18879 | Nexpose.ScanTemplate.windows_service_editor= | train | def windows_service_editor=(enable)
cifs_scanner = REXML::XPath.first(@xml, 'ScanTemplate/Plugins/Plugin[@name="java/CifsScanner"]')
param = REXML::XPath.first(cifs_scanner, './param[@name="windowsServiceEditor"]')
if param
param.text = (enable ? '1' : '0')
else
param = REXML::Element.new('param')
param.attributes['name'] = 'windowsServiceEditor'
param.text = (enable ? '1' : '0')
cifs_scanner.add_element(param)
end
param.text
end | ruby | {
"resource": ""
} |
q18880 | Nexpose.Connection.role_listing | train | def role_listing
xml = make_xml('RoleListingRequest')
r = execute(xml, '1.2')
roles = []
if r.success
r.res.elements.each('RoleListingResponse/RoleSummary') do |summary|
roles << RoleSummary.parse(summary)
end
end
roles
end | ruby | {
"resource": ""
} |
q18881 | Nexpose.Role.save | train | def save(nsc)
if @existing
xml = nsc.make_xml('RoleUpdateRequest')
else
xml = nsc.make_xml('RoleCreateRequest')
end
xml.add_element(as_xml)
response = APIRequest.execute(nsc.url, xml, '1.2', { timeout: nsc.timeout, open_timeout: nsc.open_timeout })
xml = REXML::XPath.first(response.res, 'RoleCreateResponse')
@id = xml.attributes['id'].to_i unless @existing
@existing = true
response.success
end | ruby | {
"resource": ""
} |
q18882 | Nexpose.AJAX.get | train | def get(nsc, uri, content_type = CONTENT_TYPE::XML, options = {})
parameterize_uri(uri, options)
get = Net::HTTP::Get.new(uri)
get.set_content_type(content_type)
request(nsc, get)
end | ruby | {
"resource": ""
} |
q18883 | Nexpose.AJAX.put | train | def put(nsc, uri, payload = nil, content_type = CONTENT_TYPE::XML)
put = Net::HTTP::Put.new(uri)
put.set_content_type(content_type)
put.body = payload.to_s if payload
request(nsc, put)
end | ruby | {
"resource": ""
} |
q18884 | Nexpose.AJAX.post | train | def post(nsc, uri, payload = nil, content_type = CONTENT_TYPE::XML, timeout = nil)
post = Net::HTTP::Post.new(uri)
post.set_content_type(content_type)
post.body = payload.to_s if payload
request(nsc, post, timeout)
end | ruby | {
"resource": ""
} |
q18885 | Nexpose.AJAX.patch | train | def patch(nsc, uri, payload = nil, content_type = CONTENT_TYPE::XML)
patch = Net::HTTP::Patch.new(uri)
patch.set_content_type(content_type)
patch.body = payload.to_s if payload
request(nsc, patch)
end | ruby | {
"resource": ""
} |
q18886 | Nexpose.AJAX.form_post | train | def form_post(nsc, uri, parameters, content_type = CONTENT_TYPE::FORM)
post = Net::HTTP::Post.new(uri)
post.set_content_type(content_type)
post.set_form_data(parameters)
request(nsc, post)
end | ruby | {
"resource": ""
} |
q18887 | Nexpose.AJAX.delete | train | def delete(nsc, uri, content_type = CONTENT_TYPE::XML)
delete = Net::HTTP::Delete.new(uri)
delete.set_content_type(content_type)
request(nsc, delete)
end | ruby | {
"resource": ""
} |
q18888 | Nexpose.AJAX.get_error_message | train | def get_error_message(request, response)
version = get_request_api_version(request)
data_request = use_response_error_message?(request, response)
return_response = (version >= 2.1 || data_request)
(return_response && response.body) ? "response body: #{response.body}" : "request body: #{request.body}"
end | ruby | {
"resource": ""
} |
q18889 | Nexpose.AJAX.use_response_error_message? | train | def use_response_error_message?(request, response)
if (request.path.include?('/data/') && !response.content_type.nil?)
response.content_type.include? 'text/plain'
else
false
end
end | ruby | {
"resource": ""
} |
q18890 | Nexpose.AJAX.preserving_preference | train | def preserving_preference(nsc, pref)
orig = get_rows(nsc, pref)
yield
ensure
set_rows(nsc, pref, orig)
end | ruby | {
"resource": ""
} |
q18891 | Nexpose.Connection.filter | train | def filter(field, operator, value = '')
criterion = Criterion.new(field, operator, value)
criteria = Criteria.new(criterion)
search(criteria)
end | ruby | {
"resource": ""
} |
q18892 | Nexpose.Connection.search | train | def search(criteria)
results = DataTable._get_json_table(self, '/data/asset/filterAssets', criteria._to_payload)
results.map { |a| FilteredAsset.new(a) }
end | ruby | {
"resource": ""
} |
q18893 | Nexpose.Connection.login | train | def login
login_hash = { 'sync-id' => 0, 'password' => @password, 'user-id' => @username, 'token' => @token }
login_hash['silo-id'] = @silo_id if @silo_id
r = execute(make_xml('LoginRequest', login_hash))
if r.success
@session_id = r.sid
true
end
rescue APIError
raise AuthenticationFailed.new(r)
end | ruby | {
"resource": ""
} |
q18894 | Nexpose.Connection.logout | train | def logout
r = execute(make_xml('LogoutRequest', { 'sync-id' => 0 }))
return true if r.success
raise APIError.new(r, 'Logout failed')
end | ruby | {
"resource": ""
} |
q18895 | Nexpose.Connection.execute | train | def execute(xml, version = '1.1', options = {})
options.store(:timeout, @timeout) unless options.key?(:timeout)
options.store(:open_timeout, @open_timeout)
@request_xml = xml.to_s
@api_version = version
response = APIRequest.execute(@url, @request_xml, @api_version, options, @trust_store)
@response_xml = response.raw_response_data
response
end | ruby | {
"resource": ""
} |
q18896 | Nexpose.Connection.download | train | def download(url, file_name = nil)
return nil if (url.nil? || url.empty?)
uri = URI.parse(url)
http = Net::HTTP.new(@host, @port)
http.use_ssl = true
if @trust_store.nil?
http.verify_mode = OpenSSL::SSL::VERIFY_NONE # XXX: security issue
else
http.cert_store = @trust_store
end
headers = { 'Cookie' => "nexposeCCSessionID=#{@session_id}" }
if file_name
http.request_get(uri.to_s, headers) do |resp|
::File.open(file_name, 'wb') do |file|
resp.read_body { |chunk| file.write(chunk) }
end
end
else
resp = http.get(uri.to_s, headers)
resp.body
end
end | ruby | {
"resource": ""
} |
q18897 | Nexpose.Connection.find_device_by_address | train | def find_device_by_address(address, site_id = nil)
r = execute(make_xml('SiteDeviceListingRequest', { 'site-id' => site_id }))
if r.success
device = REXML::XPath.first(r.res, "SiteDeviceListingResponse/SiteDevices/device[@address='#{address}']")
if device
return Device.new(device.attributes['id'].to_i,
device.attributes['address'],
device.parent.attributes['site-id'],
device.attributes['riskfactor'].to_f,
device.attributes['riskscore'].to_f)
end
end
nil
end | ruby | {
"resource": ""
} |
q18898 | Nexpose.Connection.list_site_devices | train | def list_site_devices(site_id = nil)
r = execute(make_xml('SiteDeviceListingRequest', { 'site-id' => site_id }))
devices = []
if r.success
r.res.elements.each('SiteDeviceListingResponse/SiteDevices') do |site|
site_id = site.attributes['site-id'].to_i
site.elements.each('device') do |device|
devices << Device.new(device.attributes['id'].to_i,
device.attributes['address'],
site_id,
device.attributes['riskfactor'].to_f,
device.attributes['riskscore'].to_f)
end
end
end
devices
end | ruby | {
"resource": ""
} |
q18899 | Nexpose.Connection.group_assets | train | def group_assets(group_id)
payload = { 'sort' => 'assetName',
'table-id' => 'group-assets',
'groupID' => group_id }
results = DataTable._get_json_table(self, '/data/asset/group', payload)
results.map { |a| FilteredAsset.new(a) }
end | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.