def load_zones(app):
"""Read favourite zones
"""
app.zones = []
favZonesDir = File(File.separator.join([app.SCRIPTDIR,
"configuration",
"favourite_zones"]))
for zoneFile in sorted(favZonesDir.listFiles()):
name = zoneFile.getName()[:-4]
fileName = zoneFile.getPath()
zoneFile = open(fileName)
fileContent = zoneFile.read()
if len(fileContent.split("|")) == 2:
geomString, country = fileContent.split("|")
country = country.upper()
else:
geomString = fileContent
country = ""
zoneFile.close()
zType = "rectangle"
try:
Integer.parseInt(geomString[0])
except NumberFormatException:
zType = "polygon"
zone = Zone(app, name, zType, geomString, country)
app.zones.append(zone)
if name == app.favZoneName:
app.favZone = zone
#Fav zone is active but its data is missing
if app.favouriteZoneStatus and app.favZone is None:
app.favouriteZoneStatus = False
def retrieve_an_archive(cust_id, archive_name, user_id, chunk_hint, file_name, output_ids):
print "\nretrieve_a_chunk routine:: output file_name is :", file_name
try:
outfile_stream = FileOutputStream(file_name)
except:
print "retrieve_a_chunk routine:: Failed to open output stream on file : ", file_name, "..returning"
return None
# retrieve data
mc = ManagementContainer.getInstance()
rm = mc.getRecoveryManager()
l_cust_id = Integer.parseInt(cust_id);
l_user_id = Integer.parseInt(user_id);
sosw = IRecoveryManager.SimpleOutputStreamWrapper(outfile_stream)
try:
rm.createPerUserActiveRecoveryArchiveFile(l_cust_id, archive_name, l_user_id, sosw, chunk_hint)
except:
print "retrieve_a_chunk routine:: `Exception while creating active recovery archive..returning"
sys.exc_info()[1].printStackTrace()
print("*** print_exc:")
traceback.print_exc(file=sys.stdout)
outfile_stream.close()
raise
outfile_stream.close()
return get_chunk_hint(file_name, output_ids)
def test_number_format(self):
try:
Integer.parseInt('asdf')
except Exception as ex:
if jep.USE_MAPPED_EXCEPTIONS:
self.assertTrue(isinstance(ex, jep.NumberFormatException))
else:
self.assertEquals(ex.java_name, 'java.lang.NumberFormatException')
def warn(self, e):
errorNumber = self.textfield.getText()
if errorNumber == "":
self.textfield.setBorder(self.defaultborder)
return
try:
Integer.parseInt(errorNumber)
except NumberFormatException:
self.textfield.setBorder(BorderFactory.createLineBorder(Color.RED, 1))
return
self.textfield.setBorder(BorderFactory.createLineBorder(Color.GREEN, 1))
def initializeServices(self):
self.updateUtilizationInfo = 1
self.discoverDependLinks = Boolean.parseBoolean(self.getParameterValue('discoverDependLinks'))
self.onlyHostDependLinks = 0
self.ignoreUnackedTcpConn = 0
self.shouldCountClients = 1
self.discoverIP = self.Framework.getDestinationAttribute('ip_address')
self.hostId = self.Framework.getDestinationAttribute('hostId')
self.minimalClients = Integer.parseInt(self.Framework.getParameter('minClients'))
self.minimalOctets = Integer.parseInt(self.Framework.getParameter('minOctets'))
self.minimalPackets = Integer.parseInt(self.Framework.getParameter('minPackets'))
self.protocols = self.Framework.getParameter('protocols')
self.disregardListenPorts = Boolean.parseBoolean(self.getParameterValue('disregardListenPorts'))
def servicesPorts(self, onlyKnownPorts = 1):
services = self.Framework.getParameter('services')
if logger.isDebugEnabled():
logger.debug('Requested services:', services)
if (services == None) or (len(services) == 0) or (services == '*'):
if onlyKnownPorts:
portsInfo = self.knownPortsConfigFile.getTcpPorts()
services = ''
delimiter = ''
for info in portsInfo:
services = services + delimiter + str(info.getPortNumber())
delimiter = ','
if len(services) == 0:
return services
else:
return ''
names = services.split(',')
ports = ''
delimiter = ''
for name in names:
portNums = self.knownPortsConfigFile.getPortByName(name)
if (portNums == None) or (len(portNums) == 0):
try:
portNums = [Integer.parseInt(name)]
except:
logger.debug('Failed to resolve service port number:', name)
continue
for portNum in portNums:
ports = ports + delimiter + str(portNum)
delimiter = ','
if logger.isDebugEnabled():
logger.debug('Requested services ports:', ports)
return ports
def convertToIp(self, encodedIp):
#TODO: Make it Python
ipParts = []
for i in range(4):
ipParts.append(encodedIp[:2])
encodedIp = encodedIp[2:]
ip = ''
for ipPart in ipParts:
ip += str(Integer.parseInt(ipPart, 16)) + '.'
ip = ip[:len(ip)-1]
return ip
def updateWithPrePostScriptCmd(Framework, commandLine):
isPrePostScriptAllowed = Boolean.parseBoolean(Framework.getParameter('IsPrePostScriptAllowed'))
prePostScriptExecTimeout = Integer.parseInt(Framework.getParameter('PrePostScriptExecTimeout'))
logger.debug("isPrePostScriptAllowed:", isPrePostScriptAllowed)
if isPrePostScriptAllowed:
deltaParams = ' -scripts:. '
scriptTimeoutParam = ''
if prePostScriptExecTimeout > 0:
scriptTimeoutParam = ' -scriptstimeout:' + str(prePostScriptExecTimeout) + ' '
index = String(commandLine).indexOf(ENTERPRISE_MODE) + String(ENTERPRISE_MODE).length()
commandLine = commandLine[0:index] + deltaParams + scriptTimeoutParam + commandLine[index + 1:]
logger.debug('After apply pre/post scripts, scanner execution command updated to ', commandLine)
return commandLine
def parseMappingString(mappingString):
bitPositions = TreeSet()
bytesNumber = len(mappingString) / SYMBOLS_PER_BYTE
for i in range(bytesNumber):
currentPosition = i * SYMBOLS_PER_BYTE
currentByteString = mappingString[currentPosition : currentPosition + SYMBOLS_PER_BYTE]
currentByte = Integer.parseInt(currentByteString, 16)
for j in range(BITS_IN_SYMBOL):
if (currentByte & 1) == 1:
bitPositions.add(i * BITS_IN_SYMBOL + BITS_IN_SYMBOL - j)
currentByte = currentByte >> 1
return list(ArrayList(bitPositions))
def read_gui(self):
"""Read preferences from gui
"""
username = self.userTextField.getText()
level = self.levelsCombo.getSelectedItem()
limit = self.limitTextField.getText()
try:
limit = Integer.parseInt(limit)
if limit > 500:
limit = 500
limit = str(limit)
except NumberFormatException:
limit = ""
preferences = {"username": username.strip(),
"level": level,
"limit": limit}
return preferences
def getRequestedPortsSet(self):
services = self.Framework.getParameter('P2PServerPorts')
if logger.isDebugEnabled():
logger.debug('Requested services:', services)
if (services == None) or (len(services) == 0) or (services == '*'):
return None
names = services.split(',')
portsSet = HashSet()
for name in names:
portNums = self.knownPortsConfigFile.getPortByName(name)
if portNums == None:
try:
portNums = [Integer.parseInt(name)]
except:
logger.debug('Failed to resolve service port number:', name)
continue
for portNum in portNums:
portsSet.add(portNum)
return portsSet
def getKnownListeningPortsSet(self):
ports = self.Framework.getParameter('knownListeningPorts')
portsSet = HashSet()
if logger.isDebugEnabled():
logger.debug('Known Listening Ports:', ports)
if (ports == None) or (len(ports) == 0):
return None
if (ports == '*'):
portsSet.add('*')
return portsSet
names = ports.split(',')
for name in names:
portNums = self.knownPortsConfigFile.getPortByName(name)
if portNums == None:
try:
portNums = [Integer.parseInt(name)]
except:
logger.debug('Failed to resolve service port number:', name)
continue
for portNum in portNums:
portsSet.add(portNum)
return portsSet
from java.net import InetSocketAddress
from java.lang import String
from java.util.concurrent import TimeUnit, Future
from java.util import ArrayList
from java.lang import System, Integer
log = grinder.logger.info
random = Random()
# Warm up parameters
warmUpOpCount = 1000
warmUpSizeValue = 1
# Test parameters
opCount = Integer.parseInt(System.getProperty("grinder.numOpsPerThread", "10000"))
writePercentage = 20
numberOfKeys = 1000
pooledKeys = ArrayList()
sizeOfValue = 1000
test1 = Test(1, "Warmup (%i ops)" % warmUpOpCount)
test2 = Test(2, "Read (%i ops per thread)" % opCount)
test3 = Test(3, "Put (%i ops per thread)" % opCount)
class TestRunner:
def __init__(self):
self.doInit()
log("Warm up operation count is %i" % warmUpOpCount)
log("Test operation count is %i" % opCount)
def indirect_parse(self, s):
return Integer.parseInt(s)
def get_port(self):
return Integer.parseInt(
self.get("rabbitmq", "port")
)
def test_number_format(self):
try:
Integer.parseInt('asdf')
except Exception as ex:
self.assertIn('java.lang.NumberFormatException', str(ex.message))
def run():
from java.lang import Integer
Integer.parseInt(
"Expected Java exception (this is not a test failure)")
def logButtonActionPerformed(
self, evt): #GEN-FIRST:event_logButtonActionPerformed
stdout = PrintWriter(self.callbacks.getStdout(), True)
stderr = PrintWriter(self.callbacks.getStderr(), True)
try:
#Connect to the database and create the collections
mongo = MongoClient(self.mongohost.getText(),
Integer.parseInt(self.mongoport.getText()))
db = mongo.getDB("sitelogger")
siteUrl = URL(self.website.getText())
tableSite = db.getCollection(
siteUrl.getHost().replace("\\.", "_") + "_site")
tableVuln = db.getCollection(
siteUrl.getHost().replace("\\.", "_") + "_vuln")
#Retrieve SiteMap HTTP Requests and Responses and save to the database
allReqRes = self.callbacks.getSiteMap(self.website.getText())
for rc in xrange(0, len(allReqRes)):
document = BasicDBObject()
document.put("host", allReqRes[rc].getHost())
document.put("port", allReqRes[rc].getPort())
document.put("protocol", allReqRes[rc].getProtocol())
document.put("URL", allReqRes[rc].getUrl().toString())
document.put("status_code", allReqRes[rc].getStatusCode())
if (allReqRes[rc].getRequest() != None):
document.put(
"request",
self.helpers.base64Encode(allReqRes[rc].getRequest()))
if (allReqRes[rc].getResponse() != None):
document.put(
"response",
self.helpers.base64Encode(allReqRes[rc].getResponse()))
tableSite.insert(document)
#Retrieve Scan findings and save to the database
allVulns = self.callbacks.getScanIssues(self.website.getText())
for vc in xrange(0, len(allVulns)):
document = BasicDBObject()
document.put("type", allVulns[vc].getIssueType())
document.put("name", allVulns[vc].getIssueName())
document.put("detail", allVulns[vc].getIssueDetail())
document.put("severity", allVulns[vc].getSeverity())
document.put("confidence", allVulns[vc].getConfidence())
document.put("host", allVulns[vc].getHost())
document.put("port", allVulns[vc].getPort())
document.put("protocol", allVulns[vc].getProtocol())
document.put("URL", allVulns[vc].getUrl().toString())
if (len(allVulns[vc].getHttpMessages()) > 1):
if (allVulns[vc].getHttpMessages()[0].getRequest() !=
None):
document.put(
"request",
self.helpers.base64Encode(
allVulns[vc].getHttpMessages()
[0].getRequest()))
if (allVulns[vc].getHttpMessages()[0].getResponse() !=
None):
document.put(
"response",
self.helpers.base64Encode(
allVulns[vc].getHttpMessages()
[0].getResponse()))
tableVuln.insert(document)
self.callbacks.issueAlert("Data Saved!")
except UnknownHostException as ex:
stderr.println("Mongo DB Connection Error:" + ex.toString())
except MalformedURLException as ex:
stderr.println("Malformed URL:" + ex.toString())
def parameterScan():
global scan_device_server_name
global scan_1d_front
global scan_2d_front
global path
global data_file
global file_extension
global actuators
global sensors
global n_steps
global integration_time
global start_position_actuators_1D
global end_position_actuators_1D
global n_steps2
global start_position_actuators_2D
global end_position_actuators_2D
global timebase
global scan_number
global scan_type
global has_trajectory
global file_path
global actuators2D
#open the file in read only mode
#file = DataInputStream(FileInputStream("D:\eclipse\workspace\passerelle-soleil\sample-models\paramscan.txt"))
file = open(file_path,'r')
parameters = {}
for line in file.readlines():
#print "line ",line
tokens = line.split('=')
#print "tokens ",tokens
if(len(tokens) == 2):
tok0 = String(tokens[0])
tok1 = String(tokens[1])
tok0 = tok0.trim()
tok1 = tok1.trim()
parameters[tok0] = tok1
print tok0,":",tok1
if(parameters.has_key("scan_device_server_name")):
scan_device_server_name = parameters["scan_device_server_name"]
if(parameters.has_key("scan_1d_front")):
scan_1d_front = parameters["scan_1d_front"]
if(parameters.has_key("scan_2d_front")):
scan_2d_front = parameters["scan_2d_front"]
if(parameters.has_key("path")):
path = parameters["path"]
if(parameters.has_key("data_file")):
data_file = parameters["data_file"]
if(parameters.has_key("file_extension")):
file_extension = parameters["file_extension"]
if(parameters.has_key("actuators")):
actuators = parameters["actuators"].split(",")
#print "parameterScan actuators ",parameters["actuators"].split(",")
if(parameters.has_key("sensors")):
sensors = parameters["sensors"].split(",")
#if(parameters.has_key("n_steps")):
#n_steps = Integer.parseInt(parameters["n_steps"])
#if(parameters.has_key("integration_time")):
#integration_time = Double.parseDouble(parameters["integration_time"])
#if(parameters.has_key("start_position_actuators_1D")):
# stringTable = parameters["start_position_actuators_1D"].split(",")
# start_position_actuators_1D = []
# for i in stringTable:
# start_position_actuators_1D.append(Double.parseDouble(i))
if(parameters.has_key("end_position_actuators_1D")):
stringTable = parameters["end_position_actuators_1D"].split(",")
end_position_actuators_1D = []
for i in stringTable:
end_position_actuators_1D.append(Double.parseDouble(i))
if(parameters.has_key("actuators2D")):
actuators2D = parameters["actuators2D"].split(",")
#print "parameterScan actuators ",parameters["actuators"].split(",")
if(parameters.has_key("n_steps2")):
n_steps2 = Integer.parseInt(parameters["n_steps2"])
if(parameters.has_key("start_position_actuators_2D")):
stringTable = parameters["start_position_actuators_2D"].split(",")
start_position_actuators_2D = []
for i in stringTable:
start_position_actuators_2D.append(Double.parseDouble(i))
if(parameters.has_key("end_position_actuators_2D")):
stringTable = parameters["end_position_actuators_2D"].split(",")
end_position_actuators_2D = []
for i in stringTable:
end_position_actuators_2D.append(Double.parseDouble(i))
if(parameters.has_key("timebase")):
timebase = parameters["timebase"]
if(parameters.has_key("scan_number")):
scan_number = Integer.parseInt(parameters["scan_number"])
if(parameters.has_key("scan_type")):
scan_type = Integer.parseInt(parameters["scan_type"])
if(parameters.has_key("has_trajectory")):
has_trajectory = Integer.parseInt(parameters["has_trajectory"])
def on_saveBtn_clicked(self, event):
"""Read preferences from gui and save them to config.properties
file
"""
#print "\n- saving preferences to config file"
onOff = {True: "on", False: "off"}
#1 Tab
#check for update
self.app.properties.setProperty("check_for_update",
onOff[self.updateCBtn.isSelected()])
#tools status
for toolIndex, tool in enumerate(self.app.realTools):
prop = "tool.%s" % tool.name
toolCBtn = self.toolsCBtns[toolIndex]
self.app.properties.setProperty(prop,
onOff[toolCBtn.isSelected()])
#layers preferences
for mode, button in self.layersRBtns.iteritems():
if button.isSelected():
self.app.properties.setProperty("layers_mode", mode)
break
#max errors number
try:
num = Integer.parseInt(self.maxErrorsNumberTextField.getText())
except NumberFormatException:
num = ""
self.app.properties.setProperty("max_errors_number", str(num))
#2 Tab
#Favourite zones
changes = {"new": [z for z in self.app.tempZones if not z in self.app.zones],
"deleted": [z for z in self.app.zones if not z in self.app.tempZones]}
#delete files of removed favourite zones
for zone in changes["deleted"]:
f = File(File.separator.join([self.app.SCRIPTDIR,
"configuration",
"favourite_zones",
"%s.txt" % zone.name]))
f.delete()
#create files for new favourite zones
for zone in changes["new"]:
print "\nsave new zone", zone.name
fileName = File.separator.join([self.app.SCRIPTDIR,
"configuration",
"favourite_zones",
"%s.txt" % zone.name])
f = open(fileName, "w")
zoneData = zone.geomString
if zone.country != "":
zoneData += "|" + zone.country
f.write(zoneData.encode("utf-8"))
f.close()
self.app.zones = self.app.tempZones
if len(self.app.zones) == 0:
self.app.favZone = None
self.app.properties.setProperty("favourite_area.name",
"")
self.favZoneStatusCBtn.setSelected(False)
else:
if len(self.zonesTable.getSelectedRows()) == 0:
self.app.favZone = self.app.zones[0]
else:
self.app.favZone = self.app.zones[self.zonesTable.getSelectedRows()[0]]
self.app.properties.setProperty("favourite_area.name",
self.app.favZone.name)
favZoneStatus = self.favZoneStatusCBtn.isSelected()
self.app.properties.setProperty("favourite_area.status", onOff[favZoneStatus])
self.app.favouriteZoneStatus = favZoneStatus
#stats panel
self.app.dlg.update_favourite_zone_indicator()
self.app.dlg.update_statsPanel_status()
#3 Tab
#tools preferences
for tool in self.app.allTools:
if hasattr(tool, 'prefs') and tool.prefsGui is not None:
for pref, value in tool.prefsGui.read_gui().iteritems():
prefKey = "tool.%s.%s" % (tool.name, pref)
self.app.properties.setProperty(prefKey, value)
self.app.save_config()
self.dispose()
def test_number_format(self):
try:
Integer.parseInt('asdf')
except Exception as ex:
self.assertIn('java.lang.NumberFormatException', str(ex))
def initParameters(Framework):
try:
parameter = Framework.getParameter(PARAM_INACTIVE_TIMEOUT)
logger.debug("Parameter for InactiveTimeout:", parameter)
global inactiveTimeout
inactiveTimeout = Integer.parseInt(parameter) * DAY
except:
pass
logger.debug("InactiveTimeout value(ms):", inactiveTimeout)
try:
parameter = Framework.getParameter(PARAM_DELETE_TIMEOUT)
logger.debug("Parameter for deleteTimeout:", parameter)
global deleteTimeout
deleteTimeout = Integer.parseInt(parameter) * DAY
except:
pass
logger.debug("DeleteTimeout value(ms):", deleteTimeout)
try:
parameter = Framework.getParameter(PARAM_CLEANUP_TIMEOUT)
logger.debug("Parameter for CleanupTimeout:", parameter)
global cleanupTimeout
cleanupTimeout = Integer.parseInt(parameter) * DAY
except:
pass
logger.debug("CleanupTimeout value:(ms):", cleanupTimeout)
#make sure the clean up timeout is not shorter than the sum of inactive timeout and delete timeout
minCleanupTimeout = inactiveTimeout + deleteTimeout
if cleanupTimeout < minCleanupTimeout:
cleanupTimeout = minCleanupTimeout
try:
parameter = Framework.getParameter(PARAM_MOONWALK_SLEEP)
logger.debug("Parameter for moonwalkSleep:", parameter)
global moonwalkSleep
moonwalkSleep = Integer.parseInt(parameter)
except:
pass
try:
parameter = Framework.getParameter(PARAM_IS_COLLECT_DATA_CENTER_IP)
logger.debug("Parameter for isCollectDataCenterIP:", parameter)
global isCollectDataCenterIP
isCollectDataCenterIP = Boolean.parseBoolean(parameter)
except:
pass
try:
parameter = Framework.getParameter(PARAM_IS_REPORT_DELETE_IP)
logger.debug("Parameter for isReportDeleteIP:", parameter)
global isReportDeleteIP
isReportDeleteIP = Boolean.parseBoolean(parameter)
except:
pass
logger.debug("Final value for parameters:")
logger.debug("inactiveTimeout:", inactiveTimeout)
logger.debug("deleteTimeout:", deleteTimeout)
logger.debug("cleanupTimeout:", cleanupTimeout)
logger.debug("moonwalkSleep:", moonwalkSleep)
logger.debug("isCollectDataCenterIP:", isCollectDataCenterIP)
logger.debug("isReportDeleteIP:", isReportDeleteIP)
def discover_private(self):
maxPorts = Integer.parseInt(self.getParameterValue('maxPorts'))
tcpOnly = Boolean.parseBoolean(self.getParameterValue('tcpOnly'))
#WE ALWAYS CHECK ONLY ONE DIRECTION SINCE WE ALWAYS REPORT FLOWS IN BOTH DIRECTION SO
#WE CAN COUNT CLIENTS ONLY ON ONE SIDE
#WE ASSUME THAT NETFLOW ALWAYS REPORTS CONNECTIONS IN BOTH DIRECTIONS SO WE WILL GET
#OCTETS AND PACKETS COUNT ALWAYS
query = ' select SrcAddr ,DstAddr ,DstPort ,count(*) cnt, sum(dPkts) dPkts, sum(dOctets) dOctets, Prot,'
query = query + ' case when Port is NULL then 0 else 1 end ListenPort '
query = query + ' from Agg_V5 left join Port_Process on DstAddr=ipaddress and DstPort=port and Prot = Protocol and listen '
if tcpOnly:
query = query + ' where Prot=6 '
query = query + ' group by SrcAddr, DstAddr, DstPort '
#for each ip -> ip traffic we first wnat get ports that are listen, than which have more clients
#after all ports which have more traffic
query = query + ' order by SrcAddr, DstAddr, ListenPort desc, cnt desc, dOctets desc, dPkts desc'
#here Prot is asc since TCP ports have higher priority on UDP ports
query = query + ', Prot asc '
conn = self.Framework.getProbeDatabaseConnection('TCPDISCOVERY')
st = None
result = None
try:
st = conn.createStatement()
result = st.executeQuery(query)
currSrcAddr = None
portsSet = StringVector()
currDstAddr = None
currLinkID = None
octets = 0
packets = 0
dataFound = 0
while result.next():
dataFound = 1
srcAddr = str(result.getString('SrcAddr'))
dstAddr = str(result.getString('DstAddr'))
dstPort = result.getString('DstPort')
cnt = result.getString('cnt')
listenPort = result.getInt('ListenPort')
if not self.isServerPort(cnt, listenPort, dstPort):
continue
if not self.shouldInclude(srcAddr, 0):
continue
if not self.shouldInclude(dstAddr, 1):
continue
linkID = self.createLinkID(srcAddr, dstAddr)
if currLinkID == linkID:
octets = octets + result.getInt('dOctets')
packets = packets + result.getInt('dPkts')
if portsSet.size() < maxPorts:
portsSet.add(dstPort)
continue
elif currLinkID != None:
self.addTraffic(currSrcAddr, currDstAddr, portsSet, octets, packets)
currLinkID = linkID
currSrcAddr = srcAddr
currDstAddr = dstAddr
portsSet = StringVector()
portsSet.add(dstPort)
octets = result.getInt('dOctets')
packets = result.getInt('dPkts')
if not dataFound:
self.Framework.reportWarning("No data to process, please check if Host Resources jobs had already run")
if currLinkID != None:
self.addTraffic(currSrcAddr, currDstAddr, portsSet, octets, packets)
finally:
if result != None:
try:
result.close
except:
pass
conn.close(st)
conn.close()
import sys
from java.lang import Integer
from com.m1.ems.mgmt import ManagementContainer
container = ManagementContainer.getInstance()
cm = container.getClientManager()
custID = Integer.parseInt(sys.argv[1])
name = "Fake"
address = "fake"
version = "1.0.0.0"
# Generate a registration key for this customer, this display name and this address
regKey = cm.registerClient(custID, name, "VaultBox", address, 0)
print regKey
cm.setClientVersion(regKey, version);
rcm = container.getReplicationConfigManager()
vb = rcm.createVaultBox(address, name, regKey, custID);
if not vb:
print "Error!"
else:
repInfo = rcm.getReplicationInformation(custID)
if not repInfo.getSftpPassword():
repInfo.setSftpPassword( vb.getRegistrationKey() )
if not rcm.saveReplicationInformation( repInfo ):
print "Unable to update replication info"