def executeCommand(self,command,args=[],elevate=False,runAs=None):
try:
if runAs:
if runAs == "user":
smbclient.register_session(self.host, username=self.username, password=self.password, connection_timeout=30)
if args:
command = "{0}\nrm c:\\windows\\temp\\jimiRunAsUser.ps1".format(powershellRunAsLoggedInUser.replace("<CMD>",command))
else:
command = "{0}\nrm c:\\windows\\temp\\jimiRunAsUser.ps1".format(powershellRunAsLoggedInUser.replace("<CMD>",command))
with smbclient.open_file("\\{0}\{1}".format(self.host,"c$\\windows\\temp\\jimiRunAsUser.ps1"), mode="wb") as remoteFile:
for line in command.split("\n"):
remoteFile.write("{0}\n".format(line).encode())
clientShell = self.client.open_shell()
commandId = self.client.run_command(clientShell,"powershell.exe -noProfile -ExecutionPolicy Bypass -File c:\\windows\\temp\\jimiRunAsUser.ps1")
stdout, stderr, exitCode = self.client.get_command_output(clientShell, commandId)
self.client.cleanup_command(clientShell, commandId)
self.client.close_shell(clientShell)
response = stdout.decode().strip()
errors = stderr.decode().strip()
return (exitCode, response, errors)
else:
clientShell = self.client.open_shell()
commandId = self.client.run_command(clientShell,command, args)
stdout, stderr, exitCode = self.client.get_command_output(clientShell, commandId)
self.client.cleanup_command(clientShell, commandId)
self.client.close_shell(clientShell)
response = stdout.decode().strip()
errors = stderr.decode().strip()
return (exitCode, response, errors)
except Exception as e:
self.error = str(e)
return (None, None, None)
def download(self, remoteFile, localPath, createMissingFolders):
try:
smbclient.register_session(self.host,
username=self.username,
password=self.password,
connection_timeout=30)
except Exception as e:
self.error = str(e)
return False
try:
if createMissingFolders:
splitChar = "\\"
if splitChar not in localPath:
splitChar = "/"
if not os.path.isdir(localPath.rsplit(splitChar, 1)[0]):
os.makedirs(localPath.rsplit(splitChar, 1)[0])
with open(localPath, mode="wb") as f:
with smbclient.open_file("\\{0}\{1}".format(
self.host, remoteFile),
mode="rb") as remoteFile:
while True:
part = remoteFile.read(4096)
if not part:
break
f.write(part)
smbclient.delete_session(self.host)
return True
except Exception as e:
self.error = str(e)
smbclient.delete_session(self.host)
return False
def __enter__(self):
# This immediately connects to the host (which can be
# perceived as a benefit), but also help work around an issue:
#
# https://github.com/jborean93/smbprotocol/issues/109.
smbclient.register_session(self._host, **self._conn_kwargs)
return self
def connect(self,host,username,password):
client = Protocol(endpoint="http://{0}:5985/wsman".format(host),transport="ntlm",username=username,password=password,read_timeout_sec=30)
try:
smbclient.register_session(self.host, username=self.username, password=self.password, connection_timeout=30)
except Exception as e:
self.error = str(e)
return None
return client
def _connect(self):
smbclient.register_session(
self.host,
username=self.username,
password=self.password,
port=self.port,
encrypt=self.encrypt,
connection_timeout=self.timeout,
)
def upload(self,localFile,remotePath):
try:
smbclient.register_session(self.host, username=self.username, password=self.password, connection_timeout=30)
except Exception as e:
self.error = str(e)
return False
# single file
if not os.path.isdir(localFile):
try:
with open(localFile, mode="rb") as f:
with smbclient.open_file("\\{0}\{1}".format(self.host,remotePath), mode="wb") as remoteFile:
while True:
part = f.read(4096)
if not part:
break
remoteFile.write(part)
except Exception as e:
self.error = str(e)
smbclient.delete_session(self.host)
return False
smbclient.delete_session(self.host)
return True
# Directory
else:
try:
smbclient.mkdir("\\{0}\{1}".format(self.host,remotePath))
except OSError as e:
if e.errno != errno.EEXIST:
return False
for root, dirs, files in os.walk(localFile):
for dir in dirs:
fullPath = os.path.join(root,dir)
fullPath=fullPath.replace("/","\\")
try:
smbclient.mkdir("\\{0}\{1}\{2}".format(self.host,remotePath,fullPath[len(localFile)+1:]))
except OSError as e:
if e.errno != errno.EEXIST:
return False
for _file in files:
try:
fullPath = os.path.join(root,_file)
with open(fullPath, mode="rb")as f:
fullPath=fullPath.replace("/","\\")
with smbclient.open_file("\\{0}\{1}\{2}".format(self.host,remotePath,fullPath[len(localFile)+1:]), mode="wb") as remoteFile:
while True:
part = f.read(4096)
if not part:
break
remoteFile.write(part)
except Exception as e:
self.error = str(e)
smbclient.delete_session(self.host)
return False
smbclient.delete_session(self.host)
return True
return False
def connect(self, parsedUri: ParseResult, config: ConfigHandler) -> None:
self.schemeAndLocation = '%s://%s' % (parsedUri.scheme,
parsedUri.netloc)
self.basePath = parsedUri.path
smbclient.register_session(
server=moduleConfiguration['server'],
username=moduleConfiguration['username'],
password=moduleConfiguration['password'],
port=moduleConfiguration['port'],
connection_timeout=moduleConfiguration['connection_timeout'])
def create_session(self,
hostname: str = None,
user: str = None,
password: str = None,
encrypt: bool = False,
port: int = None):
register_session(server=hostname or self.hostname,
username=user or self._user,
password=password or self._password,
port=port or self._port,
encrypt=encrypt or self._encrypt)
def read_directory():
#movie_titles = []
register_session("Server", username=USER, password=PASSWORD)
for file in scandir(MOVIES_PATH):
if fnmatch.fnmatch(file.name, '*.dvdmedia'):
title = file.name.replace('_', ' ').replace('.dvdmedia',
'').title()
#movie_titles.append(title)
insert_movie(title, file.name)
def copy_test_two(source_file: str, target_file: str) -> None:
# Register credentials
smbclient.register_session(server, username=user, password=password)
# Absolut file path to the target file
destination = r"\\{server}\FAKEWINDOWS\repository\client-files\{file}".format(
server=server, file=target_file)
# Read source file
file_object = open(source_file, "r").read()
# Write target file
with smbclient.open_file(destination, mode="w") as remote_file:
remote_file.write(file_object)
def __init__(self, smbhost, smbuser, smbpw):
"""
param:smbhost --> SMB主机地址
smbuser --> 登录SMB账号
smbpw --> 登录SMB密码
fun:初始化连接SMB的配置。
"""
if not os.path.exists('./smbtemporaryfile'):
os.makedirs('./smbtemporaryfile')
try:
register_session(smbhost, smbuser, smbpw)
except Exception as inst:
print('Fail To Connect SMB !')
print(inst)
logging.error('Fail To Connect SMB !')
logging.error(inst)
def smbprobe(ip, user, passw):
ip = str(ip)
try:
smbclient.register_session(ip, username=user, password=passw)
print(
f"[{Fore.RED}{Style.BRIGHT}SMB{Style.RESET_ALL}][{ip}] {green}{Style.BRIGHT}PWNED!{Style.RESET_ALL}\nUser: {user}\nPassword: {passw}"
)
except smbprotocol.exceptions.LogonFailure:
print(
f"[{Fore.RED}{Style.BRIGHT}SMB{Style.RESET_ALL}][{ip}] {Fore.RED}{Style.BRIGHT}X{Style.RESET_ALL}"
)
except smbprotocol.exceptions.SMBException:
print(
f"[{Fore.RED}{Style.BRIGHT}SMB{Style.RESET_ALL}][{ip}] {Fore.RED}{Style.BRIGHT}X{Style.RESET_ALL}"
)
except ValueError:
pass
def _open_file_smbprotocol(url, mode="rb", **kwargs):
_domain, host, port, user, passwd, server_path = _parse_smb_url(url)
import smbclient
try:
# register the server with explicit credentials
if user:
smbclient.register_session(host,
username=user,
password=passwd,
port=port)
# Read an existing file as bytes
mode2 = mode[:1] + r"b"
filehandle = smbclient.open_file(server_path, mode=mode2, **kwargs)
return filehandle
except Exception as ex:
raise ConnectionError("SMB error: %s" % ex).with_traceback(
sys.exc_info()[2])
def __init__(self):
self.config = configparser.RawConfigParser()
self.config.read('./config.cfg')
if not os.path.exists('./Log'):
os.makedirs('./Log')
if not os.path.exists('./temporaryfile'):
os.makedirs('./temporaryfile')
self.smbhost=self.config.get('P3DLA_SMB','smbhost')
self.smbuser=self.config.get('P3DLA_SMB','smbuser')
self.smbpw=self.config.get('P3DLA_SMB','smbpw')
"""建立与SMB共享盘连接的客户端"""
try :
register_session(self.smbhost,self.smbuser,self.smbpw)
except Exception as inst:
print('SMB Connection Fail')
print(inst)
logging.error('SMB Connection Fail')
logging.error(inst)
logging.basicConfig(filename='./Log/'+datetime.datetime.today().strftime("%Y%m%d")+'.log'
, level=logging.INFO
, format='%(asctime)s %(message)s'
, datefmt='%Y/%m/%d %I:%M:%S %p')
import dotenv
import os
import smbclient
import sys
from smbclient import path
dotenv.load_dotenv()
smb_password = os.getenv('SMB_PASSWORD')
smb_server = os.getenv('SMB_SERVER')
smb_user = os.getenv('SMB_USER')
if smb_password is None:
print('No password specified, using default...')
smb_password = os.getenv('DEFAULT_PASSWORD')
print("smb_password={}".format(smb_password))
if smb_server is None:
print('No server specified, using default...')
smb_server = os.getenv('DEFAULT_SERVER')
print("smb_server={}".format(smb_server))
if smb_user is None:
print('No user specified, using default...')
smb_user = os.getenv('DEFAULT_USER')
print("smb_user={}".format(smb_user))
smbclient.register_session(smb_server,
username=smb_username,
password=smb_password)
#!/usr/bin/env python3
from smbclient import (
link,
open_file,
remove,
register_session,
stat,
symlink,
)
import sys
if len(sys.argv) < 4:
print("usage: ./CVE-2020-0796.py servername username password")
register_session(sys.argv[1], username=sys.argv[2],
password=sys.argv[3], encrypt=False) # encryption must be disabled
with open_file("\\\{}\IPC$".format(sys.argv[1]), username=sys.argv[2], password=sys.argv[3]) as fd:
file_contents = fd.read()
#!/usr/bin/env python3
from smbclient import (
link,
open_file,
remove,
register_session,
stat,
symlink,
)
import sys
if len(sys.argv) < 2:
print("usage: ./CVE-2020-0796.py servername")
sys.exit(1)
register_session(sys.argv[1],
username="******",
password="******",
encrypt=False) # encryption must be disabled
TARGET_SAVEDCLIPS_PATH = '/182.222.81.199/pi/TeslaCam2/SavedCLips'
SENTRYCLIPS_CHECKPOINT = '/home/james/project/tesla/SentryClips_Checkpoint'
SAVEDCLIPS_CHECKPOINT = '/home/james/project/tesla/SavedClips_Checkpoint'
SENTRYCLIPS_PATH = '/home/james/project/tesla/SentryClips'
SAVEDCLIPS_PATH = '/home/james/project/tesla/SavedClips'
UPLOAD_METHOD = 'smb' # sftp or smb
host = '182.222.81.199'
username = '******'
password = '******'
smb_port = 2445
ssh_port = '2222'
ssh = ''
if UPLOAD_METHOD == 'smb':
smbclient.register_session(host, username=username, password=password, port=smb_port)
else:
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
def is_new_date(path, checkpoint):
f = open(checkpoint, 'r')
checkpoint_time = f.readline()
if get_timestamp(path) > get_timestamp(checkpoint_time):
return True
else:
return False
def make_checkpoint(paths, checkpoint):
temp = 0.0
str_temp = ''
from smbclient import (
listdir,
mkdir,
register_session,
rmdir,
scandir,
)
# Optional - register the server with explicit credentials
register_session("server", username="******", password="******")
# Create a directory (only the first request needs credentials)
mkdir(r"\\server\share\directory", username="******", password="******")
# Remove a directory
rmdir(r"\\server\share\directory")
# List the files/directories inside a dir
for filename in listdir(r"\\server\share\directory"):
print(filename)
# Use scandir as a more efficient directory listing as it already contains info like stat and attributes.
for file_info in scandir(r"\\server\share\directory"):
file_inode = file_info.inode()
if file_info.is_file():
print("File: %s %d" % (file_info.name, file_inode))
elif file_info.is_dir():
print("Dir: %s %d" % (file_info.name, file_inode))
else:
print("Symlink: %s %d" % (file_info.name, file_inode))
