aardwolf 0.2.7__cp39-cp39-linux_armv7l.whl

aardwolf/__init__.py

@@ -0,0 +1,10 @@
+import logging
+
+logger = logging.getLogger(__name__)
+handler = logging.StreamHandler()
+formatter = logging.Formatter(
+        '%(asctime)s %(name)-12s %(levelname)-8s %(message)s')
+handler.setFormatter(formatter)
+logger.addHandler(handler)
+logger.setLevel(logging.INFO)
+logger.propagate = False

aardwolf/_version.py

@@ -0,0 +1,7 @@
+
+__version__ = "0.2.7"
+__banner__ = \
+"""
+# aardwolf %s 
+# Author: Tamas Jos @skelsec (info@skelsecprojects.com)
+""" % __version__

aardwolf/channels.py

@@ -0,0 +1,77 @@
+
+import asyncio
+import traceback
+
+from aardwolf.protocol.T124.userdata.constants import ChannelOption
+
+class Channel:
+	def __init__(self, name:str, options:ChannelOption = ChannelOption.INITIALIZED|ChannelOption.ENCRYPT_RDP):
+		self.name = name
+		self.options = options
+		self.channel_id = None
+		self.connection = None
+
+	def get_name(self):
+		return self.name
+	
+	async def disconnect(self):
+		try:
+			_, err = await self.stop()
+			if err is not None:
+				raise err
+		except:
+			pass
+
+	async def run(self, connection):
+		try:
+			self.connection = connection
+			_, err = await self.start()
+			if err is not None:
+				raise err
+			return True, None
+		except Exception as e:
+			traceback.print_exc()
+			return None, e
+
+
+	async def start(self):
+		# Override this when implementing new channel type
+		try:
+			return True, None
+		except Exception as e:
+			return None, e
+	
+	async def stop(self):
+		# Override this when implementing new channel type
+		try:
+			return True, None
+		except Exception as e:
+			return None, e
+
+	async def process_channel_data(self, data):
+		# This function will be called when channel data is recieved from the server
+		raise NotImplementedError()
+	
+	async def process_user_data(self, data):
+		# This function will be called when the channel recieves a new user data
+		# Override this function to implement user data processing
+		raise NotImplementedError()
+	
+	async def send_channel_data(self, dataobj, sec_hdr, datacontrol_hdr, sharecontrol_hdr, is_fastpath):
+		await self.connection.handle_out_data(dataobj, sec_hdr, datacontrol_hdr, sharecontrol_hdr, self.channel_id, is_fastpath)
+
+	async def send_user_data(self, msg):
+		await self.connection.ext_out_queue.put(msg)
+
+
+class MCSChannel(Channel):
+	name = 'MCS'
+	def __init__(self, iosettings = None):
+		Channel.__init__(self, self.name, ChannelOption.INITIALIZED|ChannelOption.ENCRYPT_RDP)
+		self.out_queue = asyncio.Queue()
+	
+
+	async def process_channel_data(self, data):
+		# This function will be called when channel data is recieved from the server
+		#print('Channel data in! "%s(%s)" <- %s' % (self.name, self.channel_id, data))
+		await self.out_queue.put((data, None))

aardwolf/commons/cryptolayer.py

@@ -0,0 +1,259 @@
+import os
+from hashlib import md5, sha1
+from arc4 import ARC4 as RC4
+
+class RDPCryptoLayer:
+	def __init__(self, ServerRandom, keysize = 128, is_FIPS = False):
+		self.keysize = keysize
+		self.ClientRandom:bytes = os.urandom(32) #os.urandom(keysize//8)
+		self.ServerRandom:bytes = ServerRandom
+		self.PacketCount:int = 0
+		self.PacketCountServer:int = 0
+		self.PreMasterSecret:bytes = self.First192Bits(self.ClientRandom) + self.First192Bits(self.ServerRandom)
+		self.MasterSecret:bytes = None
+		self.SessionKeyBlob:bytes = None
+		self.MACKey128:bytes = None
+		self.InitialServerEncryptKey128:bytes = None
+		self.InitialServerDecryptKey128:bytes = None
+		self.InitialClientDecryptKey128:bytes = None
+		self.InitialClientEncryptKey128:bytes = None
+		self.CurrentClientDecryptKey128:bytes = None
+		self.CurrentClientEncryptKey128:bytes = None
+
+		self.MACKey40:bytes = None
+		self.InitialServerEncryptKey40:bytes = None
+		self.InitialServerDecryptKey40:bytes = None
+		self.InitialClientEncryptKey40:bytes = None
+		self.InitialClientDecryptKey40:bytes = None
+		self.CurrentClientDecryptKey40:bytes = None
+		self.CurrentClientEncryptKey40:bytes = None
+
+		self.MACKey56:bytes = None
+		self.InitialServerEncryptKey56:bytes = None
+		self.InitialServerDecryptKey56:bytes = None
+		self.InitialClientEncryptKey56:bytes = None
+		self.InitialClientDecryptKey56:bytes = None
+		self.CurrentClientDecryptKey56:bytes = None
+		self.CurrentClientEncryptKey56:bytes = None
+
+
+
+		self.client_crypto_enc = None
+		self.client_crypto_dec = None
+		self.server_crypto_enc = None
+		self.server_crypto_dec = None
+		self.current_mac = None
+		self.use_encrypted_mac = False #initial
+
+		self.setup()
+
+	def client_enc(self, data:bytes):
+		"""Use this if you are a client and wanna send data to server"""
+		#print('PacketCount %s' % self.PacketCount)
+		if self.PacketCount != 0 and self.PacketCount % 4096 == 0:
+			#print('Updating keys!')
+			self.UpdateKeys(False)
+		self.PacketCount += 1
+		return self.client_crypto_enc.encrypt(data)
+	
+	def client_dec(self, data:bytes):
+		"""Use this if you are a client and just got data from the server"""
+		#print('PacketCountServer %s' % self.PacketCountServer)
+		if self.PacketCountServer != 0 and self.PacketCountServer % 4096 == 0:
+			#print('Updating keys!')
+			self.UpdateKeys(True)
+		self.PacketCountServer += 1
+		return self.client_crypto_dec.encrypt(data)
+	
+	def server_enc(self, data:bytes):
+		return self.server_crypto_enc.encrypt(data)
+	
+	def server_dec(self, data:bytes):
+		return self.server_crypto_dec.encrypt(data)
+	
+	def calc_mac(self, data:bytes):
+		# https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpbcgr/7c61b54e-f6cd-4819-a59a-daf200f6bf94
+		Pad1 = b'\x36'*40 # repeated 40 times to give 320 bits
+		Pad2 = b'\x5C'*48 # repeated 48 times to give 384 bits
+
+		DataLength = len(data).to_bytes(4, byteorder='little', signed=False)
+		
+		SHAComponent = sha1(self.current_mac + Pad1 + DataLength + data).digest()
+		return self.First64Bits(md5(self.current_mac + Pad2 + SHAComponent).digest())
+
+	def calc_salted_mac(self, data:bytes, is_server:bool = False):
+		# https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpbcgr/f390586a-3fdd-4a96-bbe0-a31575e92056
+		Pad1 = b'\x36'*40 # repeated 40 times to give 320 bits
+		Pad2 = b'\x5C'*48 # repeated 48 times to give 384 bits
+
+		DataLength = len(data).to_bytes(4, byteorder='little', signed=False)
+		
+		if is_server is True:
+			EncryptionCount = (self.PacketCountServer-1).to_bytes(4, byteorder='little', signed=False)
+		else:
+			EncryptionCount = self.PacketCount.to_bytes(4, byteorder='little', signed=False)
+
+		SHAComponent = sha1(self.current_mac + Pad1 + DataLength + data + EncryptionCount).digest()
+		return self.First64Bits(md5(self.current_mac + Pad2 + SHAComponent).digest())
+
+
+	def setup(self):
+		self.MasterSecret = self.PreMasterHash(b'\x41') + self.PreMasterHash(b'\x42\x42') + self.PreMasterHash(b'\x43\x43\x43')
+		self.SessionKeyBlob = self.MasterHash(b'\x58') + self.MasterHash(b'\x59\x59') + self.MasterHash(b'\x5A\x5A\x5A')
+		self.MACKey128 = self.First128Bits(self.SessionKeyBlob)
+
+		self.InitialServerEncryptKey128 = self.FinalHash(self.Second128Bits(self.SessionKeyBlob))
+		self.InitialServerDecryptKey128 = self.FinalHash(self.Third128Bits(self.SessionKeyBlob))
+		self.InitialClientDecryptKey128 = self.FinalHash(self.Second128Bits(self.SessionKeyBlob))
+		self.InitialClientEncryptKey128 = self.FinalHash(self.Third128Bits(self.SessionKeyBlob))
+
+		self.MACKey40 = b'\xD1\x26\x9E' + self.Last40Bits(self.First64Bits(self.MACKey128))
+  
+		self.InitialServerEncryptKey40 = b'\xD1\x26\x9E' + self.Last40Bits(self.First64Bits(self.InitialServerEncryptKey128))
+		self.InitialServerDecryptKey40 = b'\xD1\x26\x9E' + self.Last40Bits(self.First64Bits(self.InitialServerDecryptKey128))
+		
+		self.InitialClientEncryptKey40 = b'\xD1\x26\x9E' + self.Last40Bits(self.First64Bits(self.InitialClientEncryptKey128))
+		self.InitialClientDecryptKey40 = b'\xD1\x26\x9E' + self.Last40Bits(self.First64Bits(self.InitialClientDecryptKey128))
+
+		self.MACKey56 = b'\xD1' + self.Last56Bits(self.First64Bits(self.MACKey128))
+  
+		self.InitialServerEncryptKey56 = b'\xD1' + self.Last56Bits(self.First64Bits(self.InitialServerEncryptKey128))
+		self.InitialServerDecryptKey56 = b'\xD1' + self.Last56Bits(self.First64Bits(self.InitialServerDecryptKey128))
+		
+		self.InitialClientEncryptKey56 = b'\xD1' + self.Last56Bits(self.First64Bits(self.InitialClientEncryptKey128))
+		self.InitialClientDecryptKey56 = b'\xD1' + self.Last56Bits(self.First64Bits(self.InitialClientDecryptKey128))
+
+		if self.keysize == 128:
+			self.current_mac = self.MACKey128
+			self.server_crypto_enc = RC4(self.InitialServerEncryptKey128)
+			self.server_crypto_dec = RC4(self.InitialServerDecryptKey128)
+			self.client_crypto_dec = RC4(self.InitialClientDecryptKey128)
+			self.client_crypto_enc = RC4(self.InitialClientEncryptKey128)
+
+			self.CurrentClientDecryptKey128 = self.InitialClientDecryptKey128
+			self.CurrentClientEncryptKey128 = self.InitialClientEncryptKey128
+		
+		if self.keysize == 56:
+			self.current_mac = self.MACKey56
+			self.server_crypto_enc = RC4(self.InitialServerEncryptKey56)
+			self.server_crypto_dec = RC4(self.InitialServerDecryptKey56)
+			self.client_crypto_dec = RC4(self.InitialClientDecryptKey56)
+			self.client_crypto_enc = RC4(self.InitialClientEncryptKey56)
+
+			self.CurrentClientDecryptKey56 = self.InitialClientDecryptKey56
+			self.CurrentClientEncryptKey56 = self.InitialClientEncryptKey56
+			
+		
+		if self.keysize == 40:
+			self.current_mac = self.MACKey40
+			self.server_crypto_enc = RC4(self.InitialServerEncryptKey40)
+			self.server_crypto_dec = RC4(self.InitialServerDecryptKey40)
+			self.client_crypto_dec = RC4(self.InitialClientDecryptKey40)
+			self.client_crypto_enc = RC4(self.InitialClientEncryptKey40)
+
+			self.CurrentClientDecryptKey40 = self.InitialClientDecryptKey40
+			self.CurrentClientEncryptKey40 = self.InitialClientEncryptKey40
+
+			
+
+	def UpdateKeys(self, is_server:bool = False):
+		# https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpbcgr/a4551a30-db5c-437a-a170-a3934cf8770e
+		# The encryption and the decryption keys are updated after 4,096 packets have been sent or received.
+
+		Pad1 = b'\x36' * 40 #repeated 40 times to give 320 bits
+		Pad2 = b'\x5C' * 48 #repeated 48 times to give 384 bits
+
+		if self.keysize == 128:
+			if is_server is True:
+				InitialEncryptKey = self.InitialClientDecryptKey128
+				CurrentEncryptKey = self.CurrentClientDecryptKey128
+			else:
+				InitialEncryptKey = self.InitialClientEncryptKey128
+				CurrentEncryptKey = self.CurrentClientEncryptKey128
+
+		if self.keysize == 56:
+			if is_server is True:
+				InitialEncryptKey = self.First64Bits(self.InitialClientDecryptKey56)
+				CurrentEncryptKey = self.First64Bits(self.CurrentClientDecryptKey56)
+			else:
+				InitialEncryptKey = self.First64Bits(self.InitialClientEncryptKey56)
+				CurrentEncryptKey = self.First64Bits(self.CurrentClientEncryptKey56)
+		
+		if self.keysize == 40:
+			if is_server is True:
+				InitialEncryptKey = self.First64Bits(self.InitialClientDecryptKey40)
+				CurrentEncryptKey = self.First64Bits(self.CurrentClientDecryptKey40)
+			else:
+				InitialEncryptKey = self.First64Bits(self.InitialClientEncryptKey40)
+				CurrentEncryptKey = self.First64Bits(self.CurrentClientEncryptKey40)
+		
+		SHAComponent = sha1(InitialEncryptKey + Pad1 + CurrentEncryptKey).digest()
+		TempKey128 = md5(InitialEncryptKey + Pad2 + SHAComponent).digest()
+		TempKey64 = self.First64Bits(TempKey128)
+		
+		if self.keysize == 128:
+			ctx = RC4(TempKey128)
+			if is_server is True:
+				self.CurrentClientDecryptKey128 = ctx.encrypt(TempKey128)
+				self.client_crypto_dec = RC4(self.CurrentClientDecryptKey128)
+			else:
+				self.CurrentClientEncryptKey128 = ctx.encrypt(TempKey128)
+				self.client_crypto_enc = RC4(self.CurrentClientEncryptKey128)
+		else:
+			ctx = RC4(TempKey64)
+			PreSaltKey = ctx.encrypt(TempKey64)
+			NewEncryptKey40 = 0xD1269E + self.Last40Bits(PreSaltKey)
+			NewEncryptKey56 = 0xD1 + self.Last56Bits(PreSaltKey)
+
+			if self.keysize == 56:
+				if is_server is True:
+					self.CurrentClientDecryptKey56 = ctx.encrypt(NewEncryptKey56)
+					self.client_crypto_dec = RC4(self.CurrentClientDecryptKey56)
+				else:
+					self.CurrentClientEncryptKey56 = ctx.encrypt(NewEncryptKey56)
+					self.client_crypto_enc = RC4(self.CurrentClientEncryptKey56)
+			
+			if self.keysize == 40:
+				if is_server is True:
+					self.CurrentClientDecryptKey40 = ctx.encrypt(NewEncryptKey40)
+					self.client_crypto_dec = RC4(self.CurrentClientDecryptKey40)
+				else:
+					self.CurrentClientEncryptKey40 = ctx.encrypt(NewEncryptKey40)
+					self.client_crypto_enc = RC4(self.CurrentClientEncryptKey40)
+
+
+	def Last56Bits(self, x:bytes):
+		return x[-7:]
+
+	def First64Bits(self, x:bytes):
+		return x[:8]
+
+	def Last40Bits(self, x:bytes):
+		return x[-5:]
+
+	def Second128Bits(self, x:bytes):
+		return x[16:32]
+	
+	def Third128Bits(self, x:bytes):
+		return x[32:48]
+
+	def First192Bits(self, x:bytes):
+		return x[:24]
+	
+	def First128Bits(self, x:bytes):
+		return x[:16]
+	
+	def SaltedHash(self, S:bytes, I:bytes):
+		return md5(S + sha1(I + S + self.ClientRandom + self.ServerRandom).digest()).digest()
+	
+	def MasterHash(self, I:bytes):
+		return self.SaltedHash(self.MasterSecret, I)
+
+	def FinalHash(self, K:bytes):
+		return md5(K + self.ClientRandom + self.ServerRandom).digest()
+	
+	def PreMasterHash(self, x:bytes):
+		return self.SaltedHash(self.PreMasterSecret, x)
+	
+
+	

aardwolf/commons/factory.py

@@ -0,0 +1,145 @@
+import enum
+from typing import List
+from asysocks.unicomm.common.proxy import UniProxyProto, UniProxyTarget
+from aardwolf.commons.iosettings import RDPIOSettings
+
+from aardwolf.commons.target import RDPTarget, RDPConnectionDialect
+from asyauth.common.credentials import UniCredential
+from aardwolf.connection import RDPConnection
+from aardwolf.vncconnection import VNCConnection
+import ipaddress
+import copy
+
+
+class RDPConnectionFactory:
+	def __init__(self, iosettings=None, target:RDPTarget = None, credential:UniCredential = None, proxies:List[UniProxyTarget] = None):
+		self.credential = credential
+		self.target = target
+		self.proxies = proxies
+		self.iosettings = iosettings
+
+	def get_connection(self, iosettings):
+		tio = copy.deepcopy(iosettings)
+		credential = self.get_credential()
+		target = self.get_target()
+		if target.dialect is not None:
+			if target.dialect == RDPConnectionDialect.RDP:
+				return RDPConnection(target, credential, tio)
+			elif target.dialect == RDPConnectionDialect.VNC:
+				return VNCConnection(target, credential, tio)
+			else:
+				raise Exception('Unknown dialect %s' % target.dialect)
+		raise Exception('Either target or dialect must be defined first!')
+
+	def create_connection_newtarget(self, ip_or_hostname, iosettings):
+		tio = copy.deepcopy(iosettings)
+		credential = self.get_credential()
+
+		target = self.get_target()
+		try:
+			ipaddress.ip_address(ip_or_hostname)
+			target.ip = ip_or_hostname
+			target.hostname = None
+		except:
+			target.hostname = ip_or_hostname
+			target.ip = ip_or_hostname
+
+		if target.dialect == RDPConnectionDialect.RDP:
+			return RDPConnection(target, credential, tio)
+		elif target.dialect == RDPConnectionDialect.VNC:
+			return VNCConnection(target, credential, tio)
+		else:
+			raise Exception('Unknown dialect %s' % target.dialect)
+
+	def get_proxy(self) -> List[UniProxyTarget]:
+		return copy.deepcopy(self.target.proxies)
+
+	def get_target(self) -> RDPTarget:
+		return copy.deepcopy(self.target)	
+
+	def get_credential(self) -> UniCredential:
+		return copy.deepcopy(self.credential)
+	
+	def get_settings(self) -> RDPIOSettings:
+		return copy.deepcopy(self.iosettings)
+
+	@staticmethod
+	def from_url(connection_url, iosettings):
+		target = RDPTarget.from_url(connection_url)
+		credential = UniCredential.from_url(connection_url)
+		return RDPConnectionFactory(iosettings, target, credential)
+
+
+	def __str__(self):
+		t = '==== RDPConnectionFactory ====\r\n'
+		for k in self.__dict__:
+			val = self.__dict__[k]
+			if isinstance(val, enum.IntFlag):
+				val = val
+			elif isinstance(val, enum.Enum):
+				val = val.name
+			
+			t += '%s: %s\r\n' % (k, str(val))
+			
+		return t
+
+	
+			
+if __name__ == '__main__':
+	url_tests = [
+		#'RDP://10.10.10.2',
+		#'RDP://10.10.10.2:9000',
+		#'RDP-tcp://10.10.10.2',
+		#'RDP-tcp://10.10.10.2:9000',
+		#'RDP-udp://10.10.10.2:138',
+		#'RDP+ntlm-password://domain\\user@10.10.10.2',
+		#'RDP-tcp+ntlm-password://domain\\user:password@10.10.10.2',
+		#'RDP-tcp+ntlm-password://domain\\user:password@10.10.10.2:10000',
+		#'RDP-tcp+ntlm-nt://domain\\user:alma@10.10.10.2',
+		#'RDP+ntlm-nt://domain\\user:alma@10.10.10.2',
+		#'RDP+ntlm-nt://domain\\user:alma@10.10.10.2',
+		#'RDP-tcp+kerberos-password://domain\\alma:password@10.10.10.10.2',
+		#'RDP-tcp+kerberos-aes://domain\\alma:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa@10.10.10.10.2',
+		#'RDP-tcp+kerberos-aes://domain\\alma:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa@10.10.10.10.2',
+		#'RDP-tcp+kerberos-nt://domain\\alma:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa@10.10.10.10.2',
+		#'RDP-tcp+kerberos-rc4://domain\\alma:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa@10.10.10.10.2',
+		#'RDP+sspi://10.10.10.10.2',
+		#'RDP+sspi-ntlm://10.10.10.10.2',
+		#'RDP+sspi-kerberos://10.10.10.10.2',
+		#'RDP+multiplexor://10.10.10.10.2',
+		#'RDP+multiplexor-ssl://10.10.10.10.2',
+		#'RDP+multiplexor-ssl-ntlm://10.10.10.10.2',
+		#'RDP+multiplexor-ssl-kerberos://10.10.10.10.2',
+		#'RDP://10.10.10.2/?timeout=10',
+		#'RDP://10.10.10.2/?timeout=10&dc=10.10.10.2',
+		#'RDP://10.10.10.2/?timeout=10&dc=10.10.10.2&proxytype=socks5',
+		#'RDP://10.10.10.2/?timeout=10&dc=10.10.10.2&proxytype=socks5&proxyserver=127.0.0.1',
+		#'RDP://10.10.10.2/?timeout=10&dc=10.10.10.2&proxytype=socks5&proxyserver=127.0.0.1&proxyuser=admin&proxypass=alma',
+		#'RDP://10.10.10.2/?timeout=10&dc=10.10.10.2&proxytype=socks5&proxyserver=127.0.0.1&proxyuser=admin&proxypass=alma&dc=10.10.10.2&dns=8.8.8.8',
+		#'RDP://10.10.10.2/?timeout=10&dc=10.10.10.2&proxytype=socks5-ssl&proxyserver=127.0.0.1&proxyuser=admin&proxypass=alma&dc=10.10.10.2&dns=8.8.8.8',
+		#'RDP://10.10.10.2/?timeout=10&dc=10.10.10.2&proxytype=multiplexor&proxyserver=127.0.0.1',
+		#'RDP://10.10.10.2/?timeout=10&dc=10.10.10.2&proxytype=multiplexor&proxyserver=127.0.0.1&proxyagentid=alma',
+		#'RDP://10.10.10.2/?timeout=10&dc=10.10.10.2&proxytype=multiplexor&proxyserver=127.0.0.1&proxyagentid=alma&proxytimeout=111',
+		'RDP://10.10.10.2/C$/test/tst111.dmp?timeout=10&dc=10.10.10.2&proxytype=multiplexor&proxyhost=127.0.0.1&proxyport=1&proxyagentid=alma&proxytimeout=111',
+
+	]
+	for url in url_tests:
+		print('===========================================================================')
+		print(url)
+		try:
+			dec = RDPConnectionFactory.from_url(url)
+			creds = dec.get_credential()
+			target = dec.get_target()
+			RDPfile = dec.get_file()
+			print(RDPfile)
+		except Exception as e:
+			import traceback
+			traceback.print_exc()
+			print('ERROR! Reason: %s' % e)
+			input()
+		else:
+			print(str(creds))
+			print(str(target))
+			input()
+			
+			

aardwolf/commons/iosettings.py

@@ -0,0 +1,70 @@
+from aardwolf.extensions.RDPECLIP.channel import RDPECLIPChannel
+from aardwolf.protocol.x224.constants import SUPP_PROTOCOLS, NEG_FLAGS
+from aardwolf.commons.queuedata.constants import VIDEO_FORMAT
+from aardwolf.protocol.T125.extendedinfopacket import PERF
+from aardwolf.extensions.RDPEDYC.channel import RDPEDYCChannel
+
+from aardwolf.extensions.RDPEDYC.vchannels.echo import VchannelECHO
+#from aardwolf.extensions.RDPEDYC.vchannels.test import VchannelTEST
+
+class RDPIOSettings:
+	def __init__(self):
+		# RDP only settings
+		# Which channels should be enabled
+		self.channels = [RDPECLIPChannel, RDPEDYCChannel]
+		self.vchannels = {
+			'ECHO' : VchannelECHO(),
+			#'DATATEST1' : VchannelTEST(),
+		}
+		# Authentication protocols supported
+		self.supported_protocols = None # supported_protocols if None: it will be determined automatically. otherwise  select one or more from these SUPP_PROTOCOLS.RDP | SUPP_PROTOCOLS.SSL |SUPP_PROTOCOLS.HYBRID_EX
+
+		# Video settings used by both RDP and VNC
+		self.video_width = 1024
+		self.video_height = 768
+		self.video_out_format = VIDEO_FORMAT.QT5 # the recatngle image format which will be sent via the queue
+		
+		# Video settings used only by RDP
+		# minimum supported BPP
+		self.video_bpp_min = 16 
+		# maximum supported BPP
+		self.video_bpp_max = 16 #max supported bpp
+		# all supported BPPs
+		self.video_bpp_supported = [15, 16, 24, 32]
+
+		#Performance booster flags
+		self.performance_flags = PERF.DISABLE_WALLPAPER | PERF.DISABLE_THEMING | PERF.DISABLE_CURSORSETTINGS | PERF.DISABLE_MENUANIMATIONS | PERF.DISABLE_FULLWINDOWDRAG
+		
+		# Keyboard settings
+		# Keyborad settings used by both RDP and VNC		
+		# clinet_keyboard is used by VNC where the keyboard state must be virtualized client-side
+		self.client_keyboard = 'enus'
+
+		# Keyboard setting used only by RDP
+		# TODO: this should be cleaned up
+		self.keyboard_layout = 1033
+		self.keyboard_type = 4
+		self.keyboard_subtype = 0
+		self.keyboard_functionkey = 12
+
+		# Clipboard settings
+
+		# pyperclip is currently the only somewhat working cross-platform clipboard manager
+		# disabling it means that clipboard messages will only be dispatched via the external queue
+		# but the client's clipboard will not be updated
+		self.clipboard_use_pyperclip = True
+
+		# store all incloing clipboard data recieved from server. Text only
+		# set it to true to have a file created, or to a string with a file path
+		# 
+		self.clipboard_store_data = None
+
+		# determines how often the client polls for desktop changes
+		self.vnc_fps = 10
+
+		# determines what type of encoding the client supports.
+		# Feel free to change the order of these but not the value. 
+		# Each value corresponds to an encoding type and only these three anre implemented currently.
+		# The order signifies the preference to the server but the server can decide to ignore it
+		self.vnc_encodings = [2, 1, 0]
+		

aardwolf/commons/params.py

@@ -0,0 +1,56 @@
+
+from aardwolf.commons.connection.url import RDPConnectionURL
+from aardwolf.commons.connection.credential import RDPCredentialTypes
+
+RDP_CONNECTION_PARAM_MANDATORY = ['domain','user','password','auth_type', 'timeout', 'protocol']
+
+
+class RDPConnectionParams:
+	def __init__(self):
+		pass
+	
+	@staticmethod
+	def extend_parser(parser):
+		group = parser.add_argument_group('Parameter based connection')
+		group.add_argument('-d', '--domain', default='.', help='Domainname')
+		group.add_argument('-u', '--user', help='Username')
+		group.add_argument('-p', '--password', help='Password (or other secret for authentication)')
+		group.add_argument('-a', '--auth-type', choices=[e.value for e in RDPCredentialTypes], default='ntlm-password', help='authentication type')
+		group.add_argument('-t', '--timeout', type=int, default=5, help='Connection timeout')
+		group.add_argument('--protocol', choices=['RDP', 'RDP2', 'RDP3'], default='RDP2', help='RDP protocol version')
+		group.add_argument('--dc', help='DC ip for kerberos')
+
+	@staticmethod
+	def parse_args(args):
+		for p in RDP_CONNECTION_PARAM_MANDATORY:
+			if hasattr(args, p) is False:
+				raise Exception('The parameter "%s" is mandatory for parameter based connection setup!' % p)
+			if getattr(args, p) is None:
+				raise Exception('The parameter "%s" cannot be empty!' % p)
+
+		url_template = '{protocol}+{auth_type}://{domainname}\\{username}:{password}@{host}/'
+		params = {
+			'protocol'  : args.protocol,
+			'auth_type' : args.auth_type,
+			'domainname': args.domain,
+			'username'  : args.user,
+			'password'  : args.password,
+			'host'      : args.host if hasattr(args, 'host') else None,
+		}
+
+		url = url_template.format(**params)
+		print(url)
+		return url
+
+
+if __name__ == '__main__':
+	import argparse
+	parser = argparse.ArgumentParser(prog='TEST')
+
+	RDPConnectionParams.extend_parser(parser)
+
+	print(parser)
+
+	args = parser.parse_args()
+
+	RDPConnectionParams.parse_args(args)

aardwolf/commons/queuedata/__init__.py

@@ -0,0 +1,19 @@
+import enum
+
+class RDPDATATYPE(enum.Enum):
+	VIDEO = "VIDEO"
+	KEYSCAN = 'KEYSCAN'
+	KEYUNICODE = 'KEYUNICODE'
+	MOUSE = 'MOUSE'
+	CLIPBOARD_READY = 'CLIPBOARD_READY'
+	CLIPBOARD_DATA_TXT = 'CLIPBOARD_DATA_TXT'
+	CLIPBOARD_CONSUMED = 'CLIPBOARD_CONSUMED'
+	CLIPBOARD_NEW_DATA_AVAILABLE = 'CLIPBOARD_NEW_DATA_AVAILABLE'
+	BEEP = 'BEEP'
+
+from aardwolf.commons.queuedata.video import RDP_VIDEO
+from aardwolf.commons.queuedata.keyboard import RDP_KEYBOARD_SCANCODE, RDP_KEYBOARD_UNICODE
+from aardwolf.commons.queuedata.mouse import RDP_MOUSE
+from aardwolf.commons.queuedata.clipboard import RDP_CLIPBOARD_READY, RDP_CLIPBOARD_DATA_TXT, RDP_CLIPBOARD_CONSUMED, RDP_CLIPBOARD_NEW_DATA_AVAILABLE
+from aardwolf.commons.queuedata.beep import RDP_BEEP
+

aardwolf/commons/queuedata/beep.py

@@ -0,0 +1,21 @@
+import enum
+from aardwolf.commons.queuedata import RDPDATATYPE
+
+class RDP_BEEP:
+	"""
+	This object will be dispatched on the external queue 
+	when the server sends a Beep or Bell notification
+	"""
+	def __init__(self):
+		self.type = RDPDATATYPE.BEEP
+	def __repr__(self):
+		t = '==== RDP_BEEP ====\r\n'
+		for k in self.__dict__:
+			if isinstance(self.__dict__[k], enum.IntFlag):
+				value = self.__dict__[k]
+			elif isinstance(self.__dict__[k], enum.Enum):
+				value = self.__dict__[k].name
+			else:
+				value = self.__dict__[k]
+			t += '%s: %s\r\n' % (k, value)
+		return t