nexpose 0.0.9 → 0.0.91

data/lib/nexpose/scan.rb

@@ -0,0 +1,280 @@
+module Nexpose
+	module NexposeAPI
+		include XMLUtils
+
+		def scan_stop(param)
+			r = execute(make_xml('ScanStopRequest', {'scan-id' => param}))
+			r.success
+		end
+
+		def scan_status(param)
+			r = execute(make_xml('ScanStatusRequest', {'scan-id' => param}))
+			r.success ? r.attributes['status'] : nil
+		end
+
+		def scan_activity
+			r = execute(make_xml('ScanActivityRequest', {}))
+			if (r.success)
+				res = []
+				r.res.elements.each("//ScanSummary") do |scan|
+					res << {
+						:scan_id => scan.attributes['scan-id'].to_i,
+						:site_id => scan.attributes['site-id'].to_i,
+						:engine_id => scan.attributes['engine-id'].to_i,
+						:status => scan.attributes['status'].to_s,
+						:start_time => Date.parse(scan.attributes['startTime'].to_s).to_time
+					}
+				end
+				res
+			else
+				false
+			end
+		end
+
+		def scan_statistics(param)
+			r = execute(make_xml('ScanStatisticsRequest', {'scan-id' => param}))
+			if (r.success)
+				res = {}
+				r.res.elements.each("//ScanSummary/nodes") do |node|
+					res[:nodes] = {}
+					node.attributes.keys.each do |k|
+						res[:nodes][k] = node.attributes[k].to_i
+					end
+				end
+				r.res.elements.each("//ScanSummary/tasks") do |task|
+					res[:task] = {}
+					task.attributes.keys.each do |k|
+						res[:task][k] = task.attributes[k].to_i
+					end
+				end
+				r.res.elements.each("//ScanSummary/vulnerabilities") do |vuln|
+					res[:vulns] ||= {}
+					k = vuln.attributes['status'] + (vuln.attributes['severity'] ? ("-" + vuln.attributes['severity']) : '')
+					res[:vulns][k] = vuln.attributes['count'].to_i
+				end
+				r.res.elements.each("//ScanSummary") do |summ|
+					res[:summary] = {}
+					summ.attributes.keys.each do |k|
+						res[:summary][k] = summ.attributes[k]
+						if (res[:summary][k] =~ /^\d+$/)
+							res[:summary][k] = res[:summary][k].to_i
+						end
+					end
+				end
+				r.res.elements.each("//ScanSummary/message") do |message|
+					res[:message] = message.text
+				end
+				res
+			else
+				false
+			end
+		end
+	end
+
+	# === Description
+	# Object that represents a summary of a scan.
+	#
+	class ScanSummary
+		# The Scan ID of the Scan
+		attr_reader :scan_id
+		# The Engine ID used to perform the scan
+		attr_reader :engine_id
+		# TODO: add description
+		attr_reader :name
+		# The scan start time
+		attr_reader :startTime
+		# The scan finish time
+		attr_reader :endTime
+		# The scan status (running|finished|stopped|error| dispatched|paused|aborted|uknown)
+		attr_reader :status
+		# The number of pending tasks
+		attr_reader :tasks_pending
+		# The number of active tasks
+		attr_reader :tasks_active
+		# The number of completed tasks
+		attr_reader :tasks_completed
+		# The number of "live" nodes
+		attr_reader :nodes_live
+		# The number of "dead" nodes
+		attr_reader :nodes_dead
+		# The number of filtered nodes
+		attr_reader :nodes_filtered
+		# The number of unresolved nodes
+		attr_reader :nodes_unresolved
+		# The number of "other" nodes
+		attr_reader :nodes_other
+		# Confirmed vulnerabilities found (indexed by severity)
+		# Associative array, indexed by severity
+		attr_reader :vuln_exploit
+		# Unconfirmed vulnerabilities found (indexed by severity)
+		# Associative array, indexed by severity
+		attr_reader :vuln_version
+		# Not vulnerable checks run (confirmed)
+		attr_reader :not_vuln_exploit
+		# Not vulnerable checks run (unconfirmed)
+		attr_reader :not_vuln_version
+		# Vulnerability check errors
+		attr_reader :vuln_error
+		# Vulnerability checks disabled
+		attr_reader :vuln_disabled
+		# Vulnerability checks other
+		attr_reader :vuln_other
+
+		# Constructor
+		# ScanSummary(can_id, $engine_id, $name, tartTime, $endTime, tatus)
+		def initialize(scan_id, engine_id, name, startTime, endTime, status)
+
+			@scan_id = scan_id
+			@engine_id = engine_id
+			@name = name
+			@startTime = startTime
+			@endTime = endTime
+			@status = status
+
+		end
+
+	end
+
+	# TODO
+	# === Description
+	# Object that represents the overview statistics for a particular scan.
+	#
+	# === Examples
+	#
+	#   # Create a new Nexpose Connection on the default port and Login
+	#   nsc = Connection.new("10.1.40.10","nxadmin","password")
+	#   nsc.login()
+	#
+	#   # Get a Site (Site ID = 12) from the NSC
+	#   site = new Site(nsc,12)
+	#
+	#   # Start a Scan of this site and pause for 1 minute
+	#   scan1 = site.scanSite()
+	#   sleep(60)
+	#
+	#   # Get the Scan Statistics for this scan
+	#   scanStatistics = new ScanStatistics(nsc,scan1["scan_id"])
+	#
+	#   # Print out number of confirmed vulnerabilities with a 10 severity
+	#   puts scanStatistics.scansummary.vuln_exploit[10]
+	#
+	#   # Print out the number of pending tasks left in the scan
+	#   puts scanStatistics.scan_summary.tasks_pending
+	#
+	class ScanStatistics
+		# true if an error condition exists; false otherwise
+		attr_reader :error
+		# Error message string
+		attr_reader :error_msg
+		# The last XML request sent by this object
+		attr_reader :request_xml
+		# The last XML response received by this object
+		attr_reader :reseponse_xml
+		# The Scan ID
+		attr_reader :scan_id
+		# The ScanSummary of the scan
+		attr_reader :scan_summary
+		# The NSC Connection associated with this object
+		attr_reader :connection
+
+		# Vulnerability checks other
+		attr_reader :vuln_other
+
+		def initialize(connection, scan_id)
+			@error = false
+			@connection = connection
+			@scan_id = scan_id
+		end
+	end
+
+	# TODO add engineID
+	# === Description
+	# Object that represents the scanning configuration for a Site.
+	#
+	class ScanConfig
+		# A unique ID for this scan configuration
+		attr_reader :configID
+		# The name of the scan template
+		attr_reader :name
+		# The ID of the scan template used full-audit, exhaustive-audit, web-audit, dos-audit, internet-audit, network-audit
+		attr_reader :templateID
+		# The configuration version (default is 2)
+		attr_reader :configVersion
+		# Array of (Schedule)*
+		attr_reader :schedules
+		# Array of (ScanTrigger)*
+		attr_reader :scanTriggers
+
+		def initialize(configID, name, templateID, configVersion = 2)
+
+			@configID = configID
+			@name = name
+			@templateID = templateID
+			@configVersion = configVersion
+			@schedules = Array.new()
+			@scanTriggers = Array.new()
+
+		end
+
+		# Adds a new Schedule for this ScanConfig
+		def addSchedule(schedule)
+			@schedules.push(schedule)
+		end
+
+		# Adds a new ScanTrigger to the scanTriggers array
+		def addScanTrigger(scanTrigger)
+			@scanTriggers.push(scanTrigger)
+		end
+
+		def _set_configID(configID)
+			@configID = configID
+		end
+
+		def _set_name(name)
+			@name = name
+		end
+
+	end
+
+	# TODO: review
+	# <scanFilter scanStop='0' scanFailed='0' scanStart='1'/>
+	# === Description
+	#
+	class ScanFilter
+
+		attr_reader :scanStop
+		attr_reader :scanFailed
+		attr_reader :scanStart
+
+		def initialize(scanstop, scanFailed, scanStart)
+
+			@scanStop = scanStop
+			@scanFailed = scanFailed
+			@scanStart = scanStart
+
+		end
+
+	end
+
+
+	# === Description
+	# Object that holds an event that triggers the start of a scan.
+	#
+	class ScanTrigger
+		# Type of Trigger (AutoUpdate)
+		attr_reader :type
+		# Enable or disable this scan trigger
+		attr_reader :enabled
+		# Sets the trigger to start an incremental scan or a full scan
+		attr_reader :incremental
+
+		def initialize(type, incremental, enabled = 1)
+
+			@type = type
+			@incremental = incremental
+			@enabled = enabled
+
+		end
+	end
+
+end

data/lib/nexpose/scan_engine.rb

@@ -0,0 +1,147 @@
+module Nexpose
+
+	# ==== Description
+	# Object that represents a listing of all of the scan engines available on to an NSC.
+	#
+	class EngineListing
+		# true if an error condition exists; false otherwise
+		attr_reader :error
+		# Error message string
+		attr_reader :error_msg
+		# The last XML request sent by this object
+		attr_reader :request_xml
+		# The last XML response received by this object
+		attr_reader :response_xml
+		# The NSC Connection associated with this object
+		attr_reader :connection
+		# Array containing (EngineSummary*)
+		attr_reader :engines
+		# The number of scan engines
+		attr_reader :engine_count
+
+		# Constructor
+		# EngineListing (connection)
+		def initialize(connection)
+			@connection = connection
+			@engines = []
+			@engine_count = 0
+			@error = false
+			r = @connection.execute('<EngineListingRequest session-id="' + @connection.session_id + '"/>', '1.2')
+
+			if (r.success)
+				r.res.elements.each('EngineListingResponse/EngineSummary') do |v|
+					@engines.push(EngineSummary.new(v.attributes['id'], v.attributes['name'], v.attributes['address'],
+													v.attributes['port'], v.attributes['status']))
+				end
+			else
+				@error = true
+				@error_msg = 'EngineListingRequest Parse Error'
+			end
+			@engine_count = @engines.length
+		end
+	end
+
+	# TODO
+	class EngineActivity
+		# true if an error condition exists; false otherwise
+		attr_reader :error
+		# Error message string
+		attr_reader :error_msg
+		# The last XML request sent by this object
+		attr_reader :request_xml
+		# The last XML response received by this object
+		attr_reader :response_xml
+		# The NSC Connection associated with this object
+		attr_reader :connection
+		# The Engine ID
+		attr_reader :engine_id
+		# Array containing (ScanSummary*)
+		attr_reader :scan_summaries
+	end
+
+	# ==== Description
+	# Object that represents the summary of a scan engine.
+	#
+	# ==== Examples
+	#
+	#   # Create a new Nexpose Connection on the default port and Login
+	#   nsc = Connection.new("10.1.40.10","nxadmin","password")
+	#   nsc.login()
+	#
+	#   # Get the engine listing for the connection
+	#   enginelisting = EngineListing.new(nsc)
+	#
+	#   # Print out the status of the first scan engine
+	#   puts enginelisting.engines[0].status
+	#
+	class EngineSummary
+		# A unique ID that identifies this scan engine
+		attr_reader :id
+		# The name of this scan engine
+		attr_reader :name
+		# The hostname or IP address of the engine
+		attr_reader :address
+		# The port there the engine is listening
+		attr_reader :port
+		# The engine status (active|pending-auth| incompatible|not-responding|unknown)
+		attr_reader :status
+
+		# Constructor
+		# EngineSummary(id, name, address, port, status)
+		def initialize(id, name, address, port, status)
+			@id = id
+			@name = name
+			@address = address
+			@port = port
+			@status = status
+		end
+
+	end
+
+	#-------------------------------------------------------------------------------------------------------------------
+	#
+	#-------------------------------------------------------------------------------------------------------------------
+	class EngineConfig
+		attr_accessor :id
+		attr_accessor :address
+		attr_accessor :name
+		attr_accessor :port
+		attr_accessor :scope
+		attr_accessor :sites
+		attr_accessor :priority
+
+		def initialize(connection, engine_id)
+			@connection = connection
+			@id = nil
+			@address = nil
+			@name = nil
+			@port = nil
+			@scope = nil
+			@priority = 'global'
+			@sites = []
+
+			r = @connection.execute('<EngineConfigRequest session-id="' + @connection.session_id + '" engine-id="' + engine_id + '"/>', '1.2')
+
+			if (r.success)
+				r.res.elements.each('EngineConfigResponse/EngineConfig') do |v|
+					@id = v.attributes['id']
+					@address = v.attributes['address']
+					@name = v.attributes['name']
+					@port = v.attributes['port']
+					@scope = v.attributes['scope']
+					v.elements.each('Site') do |s|
+						@sites << s.attributes['id']
+					end
+				end
+			else
+				@error = true
+				@error_msg = 'EngineConfigRequest Parse Error'
+			end
+		end
+
+		def save
+
+		end
+	end
+
+end

data/lib/nexpose/silo.rb

@@ -0,0 +1,347 @@
+module Nexpose
+	module NexposeAPI
+		include XMLUtils
+
+		###################
+		# SILO MANAGEMENT #
+		###################
+
+		#########################
+		# MULTI-TENANT USER OPS #
+		#########################
+
+		#-------------------------------------------------------------------------
+		# Creates a multi-tenant user
+		#
+		# user_config - A map of the user data.
+		#
+		# REQUIRED PARAMS
+		# user-id, authsrcid, user-name, full-name, enabled, superuser
+		#
+		# OPTIONAL PARAMS
+		# email, password
+		#
+		# silo_configs - An array of maps of silo specific data
+		#
+		# REQUIRED PARAMS
+		# silo-id, role-name, all-groups, all-sites, default-silo
+		#
+		# allowed_groups/allowed_sites - An array of ids
+		#-------------------------------------------------------------------------
+		def create_multi_tenant_user(user_config, silo_configs)
+			xml = make_xml('MultiTenantUserCreateRequest')
+			mtu_config_xml = make_xml('MultiTenantUserConfig', user_config, '', false)
+
+			# Add the silo access
+			silo_xml = make_xml('SiloAccesses', {}, '', false)
+			silo_config_xml = make_xml('SiloAccess', {}, '', false)
+			silo_configs.keys.each do |k|
+				if k.eql? 'allowed_sites'
+					allowed_sites_xml = make_xml('AllowedSites', {}, '', false)
+					silo_configs['allowed_sites'].each do |allowed_site|
+						allowed_sites_xml.add_element make_xml('AllowedSite', {'id' => allowed_site}, '', false)
+					end
+					silo_config_xml.add_element allowed_sites_xml
+				elsif k.eql? 'allowed_groups'
+					allowed_groups_xml = make_xml('AllowedGroups', {}, '', false)
+					silo_configs['allowed_groups'].each do |allowed_group|
+						allowed_groups_xml.add_element make_xml('AllowedGroup', {'id' => allowed_group}, '', false)
+					end
+					silo_config_xml.add_element allowed_groups_xml
+				else
+					silo_config_xml.attributes[k] = silo_configs[k]
+				end
+			end
+			silo_xml.add_element silo_config_xml
+			mtu_config_xml.add_element silo_xml
+			xml.add_element mtu_config_xml
+			r = execute xml, '1.2'
+			r.success
+		end
+
+
+		#-------------------------------------------------------------------------
+		# Lists all the multi-tenant users and their attributes.
+		#-------------------------------------------------------------------------
+		def list_mtu
+			xml = make_xml('MultiTenantUserListingRequest')
+			r = execute xml, '1.2'
+
+			if r.success
+				res = []
+				r.res.elements.each("//MultiTenantUserSummary") do |mtu|
+					res << {
+						:id => mtu.attributes['id'],
+						:full_name => mtu.attributes['full-name'],
+						:user_name => mtu.attributes['user-name'],
+						:email => mtu.attributes['email'],
+						:super_user => mtu.attributes['superuser'],
+						:enabled => mtu.attributes['enabled'],
+						:auth_module => mtu.attributes['auth-module'],
+						:silo_count => mtu.attributes['silo-count'],
+						:locked => mtu.attributes['locked']
+					}
+				end
+				res
+			else
+				false
+			end
+		end
+
+		#-------------------------------------------------------------------------
+		# Delete a multi-tenant user
+		#-------------------------------------------------------------------------
+		def delete_mtu user_name, user_id
+			using_user_name = (user_name and not user_name.empty?)
+			xml = make_xml('MultiTenantUserDeleteRequest', (using_user_name ? {'user-name' => user_name} : {'user-id' => user_id}))
+			r = execute xml, '1.2'
+			r.success
+		end
+
+		####################
+		# SILO PROFILE OPS #
+		####################
+
+		#-------------------------------------------------------------------------
+		# Creates a silo profile
+		#
+		# silo_config - A map of the silo data.
+		#
+		# REQUIRED PARAMS
+		# id, name, all‐licensed-modules, all‐global-engines, all-global-report-templates, all‐global-scan‐templates
+		#
+		# OPTIONAL PARAMS
+		# description
+		#
+		# permissions - A map of an array of maps of silo specific data
+		#
+		# REQUIRED PARAMS
+		# silo-id, role-name, all-groups, all-sites, default-silo
+		#
+		# allowed_groups/allowed_sites - An array of ids
+		#-------------------------------------------------------------------------
+		def create_silo_profile silo_profile_config, permissions
+			xml = make_xml 'SiloProfileCreateRequest'
+			spc_xml = make_xml('SiloProfileConfig', silo_profile_config, '', false)
+
+			# Add the permissions
+			if permissions['global_report_templates']
+				grt_xml = make_xml('GlobalReportTemplates', {}, '', false)
+				permissions['global_report_templates'].each do |name|
+					grt_xml.add_element make_xml('GlobalReportTemplate', {'name' => name}, '', false)
+				end
+				spc_xml.add_element grt_xml
+			end
+
+			if permissions['global_scan_engines']
+				gse_xml = make_xml('GlobalScanEngines', {}, '', false)
+				permissions['global_scan_engines'].each do |name|
+					gse_xml.add_element make_xml('GlobalScanEngine', {'name' => name}, '', false)
+				end
+				spc_xml.add_element gse_xml
+			end
+
+			if permissions['global_scan_templates']
+				gst_xml = make_xml('GlobalScanTemplates', {}, '', false)
+				permissions['global_scan_templates'].each do |name|
+					gst_xml.add_element make_xml('GlobalScanTemplate', {'name' => name}, '', false)
+				end
+				spc_xml.add_element gst_xml
+			end
+
+			if permissions['licensed_modules']
+				lm_xml = make_xml('LicensedModules', {}, '', false)
+				permissions['licensed_modules'].each do |name|
+					lm_xml.add_element make_xml('LicensedModule', {'name' => name}, '', false)
+				end
+				spc_xml.add_element lm_xml
+			end
+
+			if permissions['restricted_report_formats']
+				rrf_xml = make_xml('RestrictedReportFormats', {}, '', false)
+				permissions['restricted_report_formats'].each do |name|
+					rrf_xml.add_element make_xml('RestrictedReportFormat', {'name' => name}, '', false)
+				end
+				spc_xml.add_element rrf_xml
+			end
+
+			if permissions['restricted_report_sections']
+				rrs_xml = make_xml('RestrictedReportSections', {}, '', false)
+				permissions['restricted_report_sections'].each do |name|
+					rrs_xml.add_element make_xml('RestrictedReportSection', {'name' => name}, '', false)
+				end
+				spc_xml.add_element rrs_xml
+			end
+
+			xml.add_element spc_xml
+			r = execute xml, '1.2'
+			r.success
+		end
+
+		#-------------------------------------------------------------------------
+		# Lists all the silo profiles and their attributes.
+		#-------------------------------------------------------------------------
+		def list_silo_profiles
+			xml = make_xml('SiloProfileListingRequest')
+			r = execute xml, '1.2'
+
+			if r.success
+				res = []
+				r.res.elements.each("//SiloProfileSummary") do |silo_profile|
+					res << {
+						:id => silo_profile.attributes['id'],
+						:name => silo_profile.attributes['name'],
+						:description => silo_profile.attributes['description'],
+						:global_report_template_count => silo_profile.attributes['global-report-template-count'],
+						:global_scan_engine_count => silo_profile.attributes['global-scan-engine-count'],
+						:global_scan_template_count => silo_profile.attributes['global-scan-template-count'],
+						:licensed_module_count => silo_profile.attributes['licensed-module-count'],
+						:restricted_report_section_count => silo_profile.attributes['restricted-report-section-count'],
+						:all_licensed_modules => silo_profile.attributes['all-licensed-modules'],
+						:all_global_engines => silo_profile.attributes['all-global-engines'],
+						:all_global_report_templates => silo_profile.attributes['all-global-report-templates'],
+						:all_global_scan_templates => silo_profile.attributes['all-global-scan-templates']
+					}
+				end
+				res
+			else
+				false
+			end
+		end
+
+		#-------------------------------------------------------------------------
+		# Delete a silo profile
+		#-------------------------------------------------------------------------
+		def delete_silo_profile name, id
+			using_name = (name and not name.empty?)
+			xml = make_xml('SiloProfileDeleteRequest', (using_name ? {'name' => name} : {'silo-profile-id' => id}))
+			r = execute xml, '1.2'
+			r.success
+		end
+
+		####################
+		# SILO OPS #
+		####################
+
+		#-------------------------------------------------------------------------
+		# Creates a silo
+		#
+		# silo_config - A map of the silo creation data.
+		#
+		# REQUIRED PARAMS
+		# id, name, silo-profile-id, max-assets, max-hosted-assets, max-users
+		#
+		# OPTIONAL PARAMS
+		# description
+		#-------------------------------------------------------------------------
+		def create_silo silo_config
+			xml = make_xml 'SiloCreateRequest'
+			silo_config_xml = make_xml 'SiloConfig', {}, '', false
+
+			# Add the attributes
+			silo_config.keys.each do |key|
+				if not 'merchant'.eql? key and not 'organization'.eql? key
+					silo_config_xml.attributes[key] = silo_config[key]
+				end
+			end
+
+			# Add Organization info
+			if silo_config['organization']
+				org_xml = make_xml 'Organization', {}, '', false
+				silo_config['organization'].keys.each do |key|
+					if not 'address'.eql? key
+						org_xml.attributes[key] = silo_config['organization'][key]
+					end
+				end
+
+				address_xml = make_xml 'Address', silo_config['organization']['address'], '', false
+				org_xml.add_element address_xml
+				silo_config_xml.add_element org_xml
+			end
+
+			# Add Merchant info
+			if silo_config['merchant']
+				merchant_xml = make_xml 'Merchant', {}, '', false
+
+				silo_config['merchant'].keys.each do |key|
+					if not 'dba'.eql? key and not 'other_industries'.eql? key and not 'qsa'.eql? key and not 'address'.eql? key
+						merchant_xml.attributes[key] = silo_config['merchant'][key]
+					end
+				end
+
+				# Add the merchant address
+				merchant_address_xml = make_xml 'Address', silo_config['merchant']['address'], '', false
+				merchant_xml.add_element merchant_address_xml
+
+				#Now add the complex data types
+				if silo_config['merchant']['dba']
+					dba_xml = make_xml 'DBAs', {}, '', false
+					silo_config['merchant']['dba'].each do |name|
+						dba_xml.add_element make_xml('DBA', {'name' => name}, '', false)
+					end
+					merchant_xml.add_element dba_xml
+				end
+
+				if silo_config['merchant']['other_industries']
+					ois_xml = make_xml 'OtherIndustries', {}, '', false
+					silo_config['merchant']['other_industries'].each do |name|
+						ois_xml.add_element make_xml('Industry', {'name' => name}, '', false)
+					end
+					merchant_xml.add_element ois_xml
+				end
+
+				if silo_config['merchant']['qsa']
+					qsa_xml = make_xml 'QSA', {}, '', false
+					silo_config['merchant']['qsa'].keys.each do |key|
+						if not 'address'.eql? key
+							qsa_xml.attributes[key] = silo_config['merchant']['qsa'][key]
+						end
+					end
+
+					# Add the address for this QSA
+					address_xml = make_xml 'Address', silo_config['merchant']['qsa']['address'], '', false
+
+					qsa_xml.add_element address_xml
+					merchant_xml.add_element qsa_xml
+				end
+				silo_config_xml.add_element merchant_xml
+			end
+
+			xml.add_element silo_config_xml
+			r = execute xml, '1.2'
+			r.success
+		end
+
+		#-------------------------------------------------------------------------
+		# Lists all the silos and their attributes.
+		#-------------------------------------------------------------------------
+		def list_silos
+			xml = make_xml('SiloListingRequest')
+			r = execute xml, '1.2'
+
+			if r.success
+				res = []
+				r.res.elements.each("//SiloSummary") do |silo_profile|
+					res << {
+						:id => silo_profile.attributes['id'],
+						:name => silo_profile.attributes['name'],
+						:description => silo_profile.attributes['description']
+					}
+				end
+				res
+			else
+				false
+			end
+		end
+
+		#-------------------------------------------------------------------------
+		# Delete a silo
+		#-------------------------------------------------------------------------
+		def delete_silo name, id
+			using_name = (name and not name.empty?)
+			xml = make_xml('SiloDeleteRequest', (using_name ? {'silo-name' => name} : {'silo-id' => id}))
+			r = execute xml, '1.2'
+			r.success
+		end
+	end
+end