Exemplo n.º 1
0
def shot(conn, directory, png, rotation, *res):
    (w, h, depth) = res

    set_resolution(conn, *res)
    start_server(conn, rotation)
    sleep(0.2)

    if depth != 8:
        conn.sudo("killall qmlscene", warn=True)
        conn.sudo("qmlscene -platform linuxfb  &> /dev/null &", pty=False)
        sleep(0.2)
        with api.connect("localhost:0") as client:
            client.timeout = 5
            client.captureScreen(directory + "qmlscene_" + png)
        conn.sudo("killall qmlscene", warn=True)

    if depth > 1:
        conn.sudo("fb-test")
        with api.connect("localhost:0") as client:
            client.timeout = 5
            client.captureScreen(directory + "fbtest_" + png)

        conn.sudo(
            f"python3 /vagrant/gradient.py --width {w} --height {h} --colorbit {depth}"
        )
        with api.connect("localhost:0") as client:
            client.timeout = 5
            client.captureScreen(directory + "gradient_" + png)
Exemplo n.º 2
0
def test():
    global vm
    global default_mode
#    default_mode = conf_ops.get_global_config_value('kvm', 'videoType')
    default_mode = conf_ops.change_global_config('vm', 'videoType', 'qxl')
    vm = test_stub.create_sg_vm()
    console = test_lib.lib_get_vm_console_address(vm.get_vm().uuid)
    test_util.test_logger('[vm:] %s console is on %s:%s' % (vm.get_vm().uuid, console.hostIp, console.port))
    display = str(int(console.port)-5900)
    vm.check()
    vm_mode = test_lib.lib_get_vm_video_type(vm.get_vm())
    if vm_mode != 'qxl':
        test_util.test_fail('VM is expected to work in qxl mode instead of %s' % (vm_mode))
    client = api.connect(console.hostIp+":"+display)
    client.captureScreen('tmp.png')
    image = Image.open('tmp.png')
    if image.width != 720 or image.height != 400:
        test_util.test_fail("VM is expected to work in 720x400 while its %sx%s" % (image.width, image.height))
    box = image.getbbox()
    if box != (0, 18, 403, 79) and box != (0, 18, 403, 80):
        test_util.test_fail("VM is expected to display text in area (0, 18, 403, 79) while it's actually: (%s, %s, %s, %s)" % (box[0], box[1], box[2], box[3]))

    test_util.test_logger('[vm:] change vga mode to vga=794 which is 1280x1024')
    cmd = 'sed -i "s/115200$/115200 vga=794/g" /boot/grub2/grub.cfg'
    test_lib.lib_execute_command_in_vm(vm.get_vm(), cmd)
    vm.reboot()
    vm.check()
    client = api.connect(console.hostIp+":"+display)
    client.captureScreen('tmp.png')
    image = Image.open('tmp.png')
    if image.width != 1280 or image.height != 1024:
        test_util.test_fail("VM is expected to work in 1280x1024 while its %sx%s" % (image.width, image.height))
    box = image.getbbox()
    if box != (0, 18, 359, 79) and box != (0, 18, 359, 80):
        test_util.test_fail("VM is expected to display text in area (0, 18, 359, 79) while it's actually: (%s, %s, %s, %s)" % (box[0], box[1], box[2], box[3]))

    test_util.test_logger('[vm:] change vga mode to vga=907 which is 2560x1600')
    cmd = 'sed -i "s/vga=794/vga=907/g" /boot/grub2/grub.cfg'
    test_lib.lib_execute_command_in_vm(vm.get_vm(), cmd)
    vm.reboot()
    vm.check()
    client = api.connect(console.hostIp+":"+display)
    client.captureScreen('tmp.png')
    image = Image.open('tmp.png')
    if image.width != 2560 or image.height != 1600:
        test_util.test_fail("VM is expected to work in 2560x1600 while its %sx%s" % (image.width, image.height))
    box = image.getbbox()
    if box != (0, 18, 359, 79) and box != (0, 18, 359, 80):
        test_util.test_fail("VM is expected to display text in area (0, 18, 359, 79) while it's actually: (%s, %s, %s, %s)" % (box[0], box[1], box[2], box[3]))

    vm.destroy()
    vm.check()
    conf_ops.change_global_config('vm', 'videoType', default_mode)
    test_util.test_pass('Create VM Test Success')
def test():
    from vncdotool import api
    global vm1
    global vm2

    vm1 = test_stub.create_vm()
    vm1.check()
    console = test_lib.lib_get_vm_console_address(vm1.get_vm().uuid)
    test_util.test_logger('[vm:] %s console is on %s:%s' % (vm1.get_vm().uuid, console.hostIp, console.port))
    display = str(int(console.port)-5900)

    test_lib.lib_set_vm_console_password(vm1.get_vm().uuid, password1)
    test_util.test_logger('set [vm:] %s console with password %s' % (vm1.get_vm().uuid, password1))
    vm1.reboot()

    test_lib.lib_delete_vm_console_password(vm1.get_vm().uuid)
    test_util.test_logger('delete [vm:] %s console password after reboot' % (vm1.get_vm().uuid))
    vm1.reboot()
    if not test_lib.lib_wait_target_up(console.hostIp, console.port, timeout=60):
        test_util.test_fail('[vm:] %s console on %s:%s is not connectable' % (vm1.get_vm().uuid, console.hostIp, console.port))

    try:
        client = api.connect(console.hostIp+":"+display)
        client.keyPress('k')
        test_util.test_logger('[vm:] %s console on %s:%s is connectable without password' % (vm1.get_vm().uuid, console.hostIp, console.port))
    except:
        test_util.test_fail('[vm:] %s console on %s:%s is not connectable without password' % (vm1.get_vm().uuid, console.hostIp, console.port))

    vm2 = test_stub.create_vm()
    vm2.check()
    console = test_lib.lib_get_vm_console_address(vm2.get_vm().uuid)
    test_util.test_logger('[vm:] %s console is on %s:%s' % (vm2.get_vm().uuid, console.hostIp, console.port))
    display = str(int(console.port)-5900)

    test_lib.lib_set_vm_console_password(vm2.get_vm().uuid, password1)
    test_util.test_logger('set [vm:] %s console with password %s' % (vm2.get_vm().uuid, password1))
    test_lib.lib_delete_vm_console_password(vm2.get_vm().uuid)
    test_util.test_logger('delete [vm:] %s console password without reboot' % (vm2.get_vm().uuid))
    vm1.reboot()
    if not test_lib.lib_wait_target_up(console.hostIp, console.port, timeout=60):
        test_util.test_fail('[vm:] %s console on %s:%s is not connectable' % (vm2.get_vm().uuid, console.hostIp, console.port))

    try:
        client = api.connect(console.hostIp+":"+display)
        client.keyPress('k')
        test_util.test_logger('[vm:] %s console on %s:%s is connectable without password' % (vm2.get_vm().uuid, console.hostIp, console.port))
    except:
        test_util.test_fail('[vm:] %s console on %s:%s is not connectable without password' % (vm2.get_vm().uuid, console.hostIp, console.port))

    vm1.destroy()
    vm2.destroy()

    test_util.test_pass('Delete VM Console Password Test Success')
Exemplo n.º 4
0
def test():
    global vm
    global default_mode
    #    default_mode = conf_ops.get_global_config_value('kvm', 'videoType')
    default_mode = conf_ops.change_global_config('vm', 'videoType', 'cirrus')
    vm = test_stub.create_sg_vm()
    console = test_lib.lib_get_vm_console_address(vm.get_vm().uuid)
    test_util.test_logger('[vm:] %s console is on %s:%s' %
                          (vm.get_vm().uuid, console.hostIp, console.port))
    display = str(int(console.port) - 5900)
    vm.check()
    vm_mode = test_lib.lib_get_vm_video_type(vm.get_vm())
    if vm_mode != 'cirrus':
        test_util.test_fail(
            'VM is expected to work in cirrus mode instead of %s' % (vm_mode))
    client = api.connect(console.hostIp + ":" + display)
    client.captureScreen('tmp.png')
    image = Image.open('tmp.png')
    if image.width != 720 or image.height != 400:
        test_util.test_fail(
            "VM is expected to work in 720x400 while its %sx%s" %
            (image.width, image.height))
    box = image.getbbox()
    if box != (0, 18, 403, 79):
        test_util.test_fail(
            "VM is expected to display text in area (0, 18, 403, 79) while it's actually: (%s, %s, %s, %s)"
            % (box[0], box[1], box[2], box[3]))

    cmd = 'sed -i "s/115200$/115200 vga=794/g" /boot/grub2/grub.cfg'
    test_lib.lib_execute_command_in_vm(vm.get_vm(), cmd)
    vm.reboot()
    vm.check()
    client = api.connect(console.hostIp + ":" + display)
    client.captureScreen('tmp.png')
    image = Image.open('tmp.png')
    if image.width != 1280 or image.height != 1024:
        test_util.test_fail(
            "VM is expected to work in 1280x1024 while its %sx%s" %
            (image.width, image.height))
    box = image.getbbox()
    if box != (0, 18, 359, 80):
        test_util.test_fail(
            "VM is expected to display text in area (0, 18, 359, 80) while it's actually: (%s, %s, %s, %s)"
            % (box[0], box[1], box[2], box[3]))

    vm.destroy()
    vm.check()
    conf_ops.change_global_config('vm', 'videoType', default_mode)
    test_util.test_pass('Create VM Test Success')
Exemplo n.º 5
0
 def restart(self):
     # start menu, right for shutdown, right for context menu, up one for restart
     logger.debug("Selecting reboot option from start menu")
     self.singleKey("lsuper")
     self.client.pause(self.randomTime(1))
     self.singleKey("right")
     self.client.pause(self.randomTime(1))
     self.singleKey("right")
     self.client.pause(self.randomTime(1))
     self.singleKey("up")
     self.client.pause(self.randomTime(1))
     self.singleKey("enter")
     # reboot takes approx 25 seconds - disconnect first or Twisted throws a hissy fit
     logger.debug(
         "Reboot key sequence complete, disconnecting and sleeping 45 seconds..."
     )
     self.disconnect()
     time.sleep(45)
     logger.info("Sleep finished, reconnecting and entering password")
     self.client = api.connect(self.address)
     # position for password box on 1650x1080 screen
     self.clickPos(797, 636)
     self.typestring(self.password)
     self.singleKey("enter")
     self.client.pause(self.randomTime(10))
Exemplo n.º 6
0
 def __init__(self):
     with open('config.json') as file:
         self.credentials = json.load(file)
     self.client = api.connect('192.168.8.102',
                               self.credentials['system_password'])
     self.cursor_pos = (0, 0)
     self.client.mouseMove(*self.cursor_pos)
Exemplo n.º 7
0
Arquivo: test.py Projeto: 1tgr/rust-os
def main():
    parser = ArgumentParser()
    parser.add_argument('--screenshot', action='store_true', default=False)
    parser.add_argument('qemu_cmd', nargs=REMAINDER)
    args = parser.parse_args()
    fifo_name = os.path.join(tempfile.mkdtemp(), 'fifo')
    os.mkfifo(fifo_name)

    try:
        child_args = args.qemu_cmd + ['-serial', 'pipe:' + fifo_name, '-vnc', ':0']
        print('> %s' % subprocess.list2cmdline(child_args))
        with Popen(child_args) as child_proc:
            print('[test.py] Started process %d' % child_proc.pid)
            try:

                with open(fifo_name, 'rb') as fifo:
                    child = fdpexpect.fdspawn(fifo, encoding='utf8', logfile=sys.stdout, timeout=10)
                    result = child.expect([r'\[kernel\] end kmain|System ready', r'\[kernel::unwind\] (.*)', pexpect.TIMEOUT])
                    if result == 0:
                        print('[test.py] Success')
                    elif result == 1:
                        (message,) = child.match.groups()
                        print('[test.py] Failed: %s' % message)
                    elif result == 2:
                        print('[test.py] Timed out')

            finally:
                if args.screenshot:
                    client = api.connect('localhost:0', password=None)
                    filename = 'screenshot.png'
                    print('[test.py] Saving screenshot to %s' % filename)

                    prev_screenshot_bytes = None

                    if result == 0:
                        try:
                            with open(filename, 'rb') as f:
                                prev_screenshot_bytes = f.read()
                        except:
                            pass

                    client.captureScreen(filename)

                    if prev_screenshot_bytes is not None:
                        with open(filename, 'rb') as f:
                            screenshot_bytes = f.read()

                        if prev_screenshot_bytes != screenshot_bytes:
                            result = 3

                print('[test.py] Stopping process %d' % child_proc.pid)
                child_proc.kill()
                print('[test.py] Waiting for process %d to exit... ' % child_proc.pid, end='', flush=True)
                child_proc.wait()
                print('done')

    finally:
        os.unlink(fifo_name)

    return result
def test():
    global vm
 
    import signal
    def handler(signum, frame):
        raise Exception()
    signal.signal(signal.SIGALRM, handler)
    signal.alarm(30)
    boot_option_picture = os.environ.get('bootOptionPicture')
    
    vm = test_stub.create_vm()
    console = test_lib.lib_get_vm_console_address(vm.get_vm().uuid)
    test_util.test_logger('[vm:] %s console is on %s:%s' % (vm.get_vm().uuid, console.hostIp, console.port))
    display = str(int(console.port)-5900)

    client = api.connect(console.hostIp+":"+display)
    time.sleep(2)
    client.keyPress('esc')
    #client.captureRegion('/root/boot.png',0,100,600,600)
    client.expectRegion(boot_option_picture,0,100)
    test_util.test_logger('[vm:] %s support boot option' % (vm.get_vm().uuid))
#    except:
#        test_util.test_fail('[vm:] %s is expected to support boot option' % (vm.get_vm().uuid))

    vm.destroy()

    test_util.test_pass('Support VM Boot Option Test Success')
def test():
    global vm

    import signal

    def handler(signum, frame):
        raise Exception()

    signal.signal(signal.SIGALRM, handler)
    signal.alarm(30)
    boot_option_picture = os.environ.get('bootOptionPicture')

    vm = test_stub.create_vm()
    console = test_lib.lib_get_vm_console_address(vm.get_vm().uuid)
    test_util.test_logger('[vm:] %s console is on %s:%s' %
                          (vm.get_vm().uuid, console.hostIp, console.port))
    display = str(int(console.port) - 5900)

    client = api.connect(console.hostIp + ":" + display)
    time.sleep(2)
    client.keyPress('esc')
    #client.captureRegion('/root/boot.png',0,100,600,600)
    client.expectRegion(boot_option_picture, 0, 100)
    test_util.test_logger('[vm:] %s support boot option' % (vm.get_vm().uuid))
    #    except:
    #        test_util.test_fail('[vm:] %s is expected to support boot option' % (vm.get_vm().uuid))

    vm.destroy()

    test_util.test_pass('Support VM Boot Option Test Success')
Exemplo n.º 10
0
def test_vnc(host, password):
    print("Testing VNC")
    try:
        client = vncapi.connect(host, password=password)
        client.timeout = 5
        client.keyPress('enter')
    except Exception as e:
        pass
Exemplo n.º 11
0
 def check_config(self):
     if 'server' in self.serverinfo.keys():
         self.client = api.connect(self.serverinfo['server'] + ':0')
         self.state = True
         filename = 'gvnc-tmp-' + str(time.time()) + '.png'
         self.client.captureScreen(filename)
         self.write_img(filename)
         os.remove(filename)
Exemplo n.º 12
0
 def __init__(self, address, password, resolution):
     self.address = address
     self.client = api.connect(address)
     self.client.timeout = 10
     self.x = resolution[0]
     self.y = resolution[1]
     self.pointer = (0, 0)
     self.password = password
Exemplo n.º 13
0
 def check_config(self):
     if 'server' in self.serverinfo.keys():
         self.client = api.connect(self.serverinfo['server'] + ':0')
         self.state = True
         filename = 'gvnc-tmp-' + str(time.time()) + '.png'
         self.client.captureScreen(filename)
         self.write_img(filename)
         os.remove(filename)
Exemplo n.º 14
0
def connect(host, display, password):
    """
    Connects to the server.

    """
    global CLIENT
    host = str(host) + ':' + str(display)
    CLIENT = api.connect(host, password)
Exemplo n.º 15
0
 def __init__(self, server):
     self.server = server
     self.address = server.vnc_address + ":" + server.vnc_port
     self.passwd = server.vnc_passwd
     self.connection = vncapi.connect(self.address, password=self.passwd)
     self.connection.keyPress('enter')
     print("Waiting for the installation ISO to boot...")
     self.connection.expectScreen('booted_install_ISO.png')
Exemplo n.º 16
0
 def getConnection(self):
     try:
         client = api.connect(self.vnc_server, self.passwd)
         print("Successully established the connection with vnc server.")
     except ValueError as e:
         print("Error While logging in to VNC Server")
     except Exception as e:
         print("Check the VNC Server Details")
     return client
def swiper(ips, display):
	passlist = [ None,
			'FELDTECH_VNC',
			'vnc_pcci',
			'elux',
			'Passwort',
			'visam',
			'password',
			'Amx1234!',
			'1988',
			'admin',
			'Vision2',
			'ADMIN',
			'TOUCHLON',
			'EltakoFVS',
			'Wyse#123',
			'muster',
			'passwd11',
			'qwasyx21',
			'Administrator',
			'ripnas',
			'eyevis',
			'fidel123',
			'Admin#1',
			'default',
			'sigmatek',
			'hapero',
			'1234',
			'pass',
			'raspberry',
			'user',
			'solarfocus',
			'AVStumpfl',
			'm9ff.QW',
			'maryland-dstar',
			'pass1',
			'pass2',
			'instrument',
			'beijer',
			'vnc',
			'yesco',
			'protech'] 
	for ip in ips:
		print('For ip {0}'.format(ip))
		for passwd in passlist:
			try:
				print('\tAttempting {0}'.format(passwd))
				client = api.connect('{0}:{1}'.format(ip,display), password=passwd)
				client.timeout = 2
				client.keyPress('enter')
				print(passwd)
				quit()
			except:
				continue
			print("Password not found for {0}".format(ip))
Exemplo n.º 18
0
	def test_server(self,ip=None,port=None,username=None,password=None):
		try:
			ip or self.ip
			port or self.port 
			username or self.username
			password or self.password
			client = vncapi.connect("{}::{}".format(self.ip,self.port),password=password)
			client.captureScreen('screenshot.png')
			client.disconnect()
		except:
			pass
Exemplo n.º 19
0
 def __init__(self,
              host_ip,
              host_user,
              host_password,
              vnc_password='******'):
     self.host_ip = host_ip
     self.host_user = host_user
     self.host_password = host_password
     self.vnc_password = vnc_password
     self._set_vnc_pass()
     self.cli = api.connect(self.host_ip, password=self.vnc_password)
Exemplo n.º 20
0
def test_color_xvnc():
    with tempfile.NamedTemporaryFile(prefix="vnc_", suffix=".png") as png:

        with Display(backend="xvnc", rfbport=5900 + 9876):
            with api.connect("localhost:9876") as client:
                client.timeout = 1
                client.captureScreen(png.name)

        with tempfile.NamedTemporaryFile(prefix="passwd_",
                                         delete=False) as passwd_file:
            password = "******"
            vncpasswd_generated = b"\x49\x40\x15\xf9\xa3\x5e\x8b\x22"
            passwd_file.write(vncpasswd_generated)
            passwd_file.close()
            with Display(backend="xvnc",
                         rfbport=5900 + 1234,
                         rfbauth=passwd_file.name):
                with api.connect("localhost:1234",
                                 password=password) as client:
                    client.timeout = 1
                    client.captureScreen(png.name)
Exemplo n.º 21
0
    def test_color_xvnc():
        with tempfile.TemporaryDirectory() as temp_dir:
            vnc_png = Path(temp_dir) / "vnc.png"
            password = "******"
            passwd_file = Path(temp_dir) / "pwd.txt"
            vncpasswd_generated = b"\x49\x40\x15\xf9\xa3\x5e\x8b\x22"
            passwd_file.write_bytes(vncpasswd_generated)

            with Display(backend="xvnc"):
                with api.connect("localhost:0") as client:
                    client.timeout = 1
                    client.captureScreen(vnc_png)
            with XvncDisplay():
                with api.connect("localhost:0") as client:
                    client.timeout = 1
                    client.captureScreen(vnc_png)

            with Display(backend="xvnc", rfbport=5900 + 9876):
                with api.connect("localhost:9876") as client:
                    client.timeout = 1
                    client.captureScreen(vnc_png)
            with XvncDisplay(rfbport=5900 + 9876):
                with api.connect("localhost:9876") as client:
                    client.timeout = 1
                    client.captureScreen(vnc_png)

            with Display(backend="xvnc", rfbauth=passwd_file):
                with api.connect("localhost:0", password=password) as client:
                    client.timeout = 1
                    client.captureScreen(vnc_png)
            with XvncDisplay(rfbauth=passwd_file):
                with api.connect("localhost:0", password=password) as client:
                    client.timeout = 1
                    client.captureScreen(vnc_png)
Exemplo n.º 22
0
def parseLine(line,number):
    parsedLine = line.split(" ")
    if parsedLine[0] == "open" and not os.path.isfile('screenshot_IP_{ip}.png'.format(ip=parsedLine[3])):
    #print "open at {ip}".format(ip=parsedLine[3])
        try:
            client = api.connect('{ip}:0'.format(ip=parsedLine[3]))
            #print "connected"
            client.captureScreen('screenshot_IP_{ip}.png'.format(ip=parsedLine[3]))
            print "screenshot taken"
            with FileLock("vulnerableIPs.txt"):
                with open('vulnerableIPs.txt', 'a') as file:
                    file.write(parsedLine[3])
        except:
            pass
Exemplo n.º 23
0
 def __init__(self):
     self.docker_client = docker.from_env()
     try:
         self.container = self.docker_client.containers.run(
             "breandan/ubuntuvnc",
             ports={
                 '8000/tcp': 8000,
                 '6080/tcp': 80,
                 '5900/tcp': 5900
             },
             remove=True,
             detach=True)
     except:
         pass  # Ignore error if container is already running
     self.vnc_client = api.connect('127.0.0.1', password=None)
Exemplo n.º 24
0
def verify_password(username, ip):
    ip = request.args.getlist('ip').pop(0)
    port = request.args.getlist('port').pop(0)
    username = request.args.getlist('username').pop(0)
    auths.ip_filter(ip)
    auths.port_filter(port)
    client = api.connect('{}::{}'.format(ip, port))
    user_path = app.config['MYSTATIC'].format(username)
    if not os.path.exists(user_path):
        os.makedirs(user_path)
    g.username = username
    g.ip = ip
    g.port = port
    g.userpath = user_path
    g.client = client
    return True
Exemplo n.º 25
0
def parseLine(line, number):
    parsedLine = line.split(" ")
    if parsedLine[0] == "open" and not os.path.isfile(
            'screenshot_IP_{ip}.png'.format(ip=parsedLine[3])):
        #print "open at {ip}".format(ip=parsedLine[3])
        try:
            client = api.connect('{ip}:0'.format(ip=parsedLine[3]))
            #print "connected"
            client.captureScreen(
                'screenshot_IP_{ip}.png'.format(ip=parsedLine[3]))
            print "screenshot taken"
            with FileLock("vulnerableIPs.txt"):
                with open('vulnerableIPs.txt', 'a') as file:
                    file.write(parsedLine[3])
        except:
            pass
def test_ip(args):
    print(f"# Testing {args.ip}")
    try:
        with api.connect(args.ip, password=args.password) as client:
            client.timeout = args.timeout
            try:
                client.refreshScreen()
                screenshot_file = os.path.join(args.screendir,
                                               args.ip + '.png')
                client.captureScreen(screenshot_file)
                print(f"Successfully captured screenshot: {screenshot_file}")
            except Exception as e:
                print(e)
            client.disconnect()
    except Exception as e:
        print(e)
Exemplo n.º 27
0
    def __synchronize_backend(self,
                              backend=None,
                              category="vncdotool",
                              reset=False):
        if category != "vncdotool":
            raise UnsupportedBackendError(
                "Backend category '%s' is not supported" % category)
        if reset:
            super(VNCDoToolController, self).synchronize_backend("vncdotool",
                                                                 reset=True)
        if backend is not None and self.params[category]["backend"] != backend:
            raise UninitializedBackendError(
                "Backend '%s' has not been configured yet" % backend)

        from vncdotool import api
        if self._backend_obj:
            # api.connect() gives us a threaded client, so we need to clean up resources
            # to avoid dangling connections and deadlocks if synchronizing more than once
            self._backend_obj.disconnect()
        self._backend_obj = api.connect(
            '%s:%i' % (self.params[category]["vnc_hostname"],
                       self.params[category]["vnc_port"]),
            self.params[category]["vnc_password"])
        # for special characters preprocessing for the vncdotool
        self._backend_obj.factory.force_caps = True

        # additional logging for vncdotool available so let's make use of it
        logging.getLogger('vncdotool.client').setLevel(10)
        logging.getLogger('vncdotool').setLevel(logging.ERROR)
        logging.getLogger('twisted').setLevel(logging.ERROR)

        # screen size
        with NamedTemporaryFile(prefix='guibot', suffix='.png') as f:
            filename = f.name
        screen = self._backend_obj.captureScreen(filename)
        os.unlink(filename)
        self._width = screen.width
        self._height = screen.height

        # sync pointer
        self.mouse_move(Location(self._width, self._height), smooth=False)
        self.mouse_move(Location(0, 0), smooth=False)
        self._pointer = Location(0, 0)

        self._keymap = inputmap.VNCDoToolKey()
        self._modmap = inputmap.VNCDoToolKeyModifier()
        self._mousemap = inputmap.VNCDoToolMouseButton()
Exemplo n.º 28
0
def test():
    global test_obj_dict
    global vm
    import signal

    def handler(signum, frame):
        raise Exception()

    signal.signal(signal.SIGALRM, handler)
    signal.alarm(300)
    test_util.test_dsc('Create test clone windows vm boot option')

    image_name = os.environ.get('imageName_windows')
    vm = test_stub.create_vm(image_name=image_name)
    test_obj_dict.add_vm(vm)

    backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm.vm)
    for bs in backup_storage_list:
        if bs.type in [
                inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE,
                inventory.CEPH_BACKUP_STORAGE_TYPE
        ]:
            break
    else:
        vm.destroy()
        test_util.test_skip(
            'Not find image store or ceph type backup storage.')

    new_vm = vm.clone(vm_name)[0]
    test_obj_dict.add_vm(new_vm)
    console = test_lib.lib_get_vm_console_address(new_vm.get_vm().uuid)
    test_util.test_logger('[vm:] %s console is on %s:%s' %
                          (new_vm.get_vm().uuid, console.hostIp, console.port))
    display = str(int(console.port) - 5900)

    client = api.connect(console.hostIp + ":" + display)
    client.keyPress('esc')
    time.sleep(2)
    client.expectRegion(boot_option_picture, 0, 100)

    vm.destroy()
    new_vm.destroy()

    test_util.test_pass('VM With Volumes Boot Option Test Success')
Exemplo n.º 29
0
def record(output, host, fps, password=None):
    print("Start Recording")
    pid = 0
    retval = 0
    cli = api.connect(host, password=password)
    cli.refreshScreen(False)
    videodims = cli.screen.size
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
    frame = int(fps)
    video = cv2.VideoWriter(output, fourcc, frame, videodims)
    p_start = time.time()
    try:

        def sigint_handler(sig, frame):
            raise KeyboardInterrupt

        signal.signal(signal.SIGINT, sigint_handler)
        try:
            while 1:
                elapse = int()
                start = time.time()
                for i in range(0, frame):
                    cli.refreshScreen(False)
                    imtemp = cli.screen.copy()
                    video.write(
                        cv2.cvtColor(np.array(imtemp), cv2.COLOR_RGB2BGR))
                stop = time.time()
                elapse = stop - start
                print("Frame Process : " + str(elapse))
                if elapse < 1:
                    time.sleep(1 - elapse)
        finally:
            p_stop = time.time()
            print(p_stop - p_start)
            video.release()
            cli.disconnect()
            print("Stop Recording")
    except KeyboardInterrupt:
        pass
    if pid:
        os.killpg(os.getpgid(pid), signal.SIGTERM)

    return retval
Exemplo n.º 30
0
def screenshotGet(datas, timeout, screenshotDir, includeBlackScreens):
    try:
        #create snapshot dir
        saveDir = os.path.join(os.path.dirname(os.path.realpath(__file__)),
                               screenshotDir)
        if os.path.isdir(saveDir):
            pass
        else:
            os.mkdir(saveDir)
    except OSError:
        print("Screenshot: Failed to create dir")
        return False
    print(f"Screenshot: Saving screenshots in {screenshotDir} directory..")
    for data in datas:
        for proto in data["protocols"]:
            protocol = re.search(portRawRe, proto).group(1)
            try:
                client = api.connect(f"{data['ip']}::{protocol}",
                                     password=None)
                client.timeout = timeout + 0.5
                client.keyPress('enter')
                sleep(0.5)  #for the enter key press to have some effect maybe
                imgDir = os.path.join(saveDir, f"{data['ip']}:{protocol}.jpg")
                client.captureScreen(imgDir)
                if not includeBlackScreens:
                    image = imread(imgDir, 0)
                    if countNonZero(image) == 0:
                        os.remove(imgDir)
                        print(
                            f"Screenshot: Black for {data['ip']}:{protocol}, removing.."
                        )
                        continue
            except TimeoutError:
                print(
                    f"Screenshot: Timeout for {data['ip']}:{protocol}, skipping.."
                )
                continue
            except:
                print(
                    f"Screenshot: Error for {data['ip']}:{protocol}, skipping.."
                )
                continue
            print(f"Screenshot: Done for {data['ip']}:{protocol}")
Exemplo n.º 31
0
 def screenShot(ipAddress, port):
     connect_string = ipAddress + '::' + port
     print(connect_string)
     filename = 'RESULTS/' + ipAddress + '_' + port + '.png'
     try:
         client = api.connect(connect_string, password=None)
         client.timeout = 30
     except:
         print('Connect Failed')
         return
     try:
         print("Attempting screen capture")
         client.captureScreen(filename)
         print("SUCCESS")
     except:
         print('Timed out')
         shutil.copy('DEFAULT.png', filename)
         client.disconnect()
     print("Disconnecting Client")
     client.disconnect()
Exemplo n.º 32
0
def Target(task):
    userpath = request.cookies.get('userpath')
    ip = request.cookies.get('ip')
    port = request.cookies.get('port')
    client = api.connect('{}::{}'.format(ip, port))
    auths.client = client
    if task == 'chongbo':
        commands = eval(request.form['data'])
        if auths.produce_vdo(commands=commands, userpath=userpath):
            vdo_path = userpath + '/command.vdo'
            try:
                auths.allocate_vncvdo(vdo_path)
            except Exception as e:
                auths.response_filter(0)
            else:
                auths.client_screen(userpath)
                return 'success'
        else:
            auths.response_filter(0)
    else:
        auths.response_filter(1)
def test():
    global test_obj_dict
    global vm
    import signal
    def handler(signum, frame):
        raise Exception()
    signal.signal(signal.SIGALRM, handler)
    signal.alarm(30)

    test_util.test_dsc('Create test vm with 2 additional data volumes boot option')
    conf_ops.change_global_config('vm', 'bootMenu', 'false')
    disk_offering = test_lib.lib_get_disk_offering_by_name(os.environ.get('smallDiskOfferingName'))
    disk_offering_uuids = [disk_offering.uuid]
    disk_offering = test_lib.lib_get_disk_offering_by_name(os.environ.get('rootDiskOfferingName'))
    disk_offering_uuids.append(disk_offering.uuid)

    vm = test_stub.create_vm_with_volume(data_volume_uuids = disk_offering_uuids)
    test_obj_dict.add_vm(vm)
    vm_inv = vm.get_vm()
    vm_ip = vm_inv.vmNics[0].ip
    console = test_lib.lib_get_vm_console_address(vm.get_vm().uuid)
    test_util.test_logger('[vm:] %s console is on %s:%s' % (vm.get_vm().uuid, console.hostIp, console.port))
    display = str(int(console.port)-5900)

    client = api.connect(console.hostIp+":"+display)
    time.sleep(2)
    client.keyPress('esc')
    try:
        client.expectRegion(boot_option_picture,0,100)
    except:
        test_util.test_logger('Success to not enable boot menu.')
    else:
        test_util.test_fail('Fail to not enable boot menu.')

    vm.destroy() 
    test_util.test_pass('VM With Volumes Boot Option Test Success')
Exemplo n.º 34
0
 def __init__(self, display, password=None, delay=.1):
     self._vnc = api.connect(display, password=password)
     self.color = 0xc  # what color our cursor is
     self.cursor_pos = (160, 100)  # where our cursor is
     self.delay = delay
Exemplo n.º 35
0
    client.pause(1)
    client.mousePress(1)
    for i in range(2):
        client.keyPress('lctrl-l')
        client.pause(0.5)

def log_in(dummy1, dummy2):
    #must wait 30-40 sec for pc to boot
    # for i in range(2):
    client.keyPress('enter')
    client.pause(1)
    for i in "1556":
        client.keyPress(i)
    #must wait at least 10 sec for pc to log in

def turn_off(dummy1, dummy2):
    
    client.pause(1)
    client.keyPress('ctrl-alt-del')
    client.pause(1)
    client.mouseMove(1860,1020)
    client.mousePress(1)
    client.pause(0.5)
    client.mouseMove(1860,960)
    client.mousePress(1)
    client.pause(1)
if __name__ == '__main__':
    client = api.connect("192.168.1.20")
    option = {"log_in":log_in, "turn_off":turn_off, "music":music}
    option[sys.argv[1]](sys.argv[2], sys.argv[3])
    sys.exit()
def test():
    from vncdotool import api
    global vm
    session_uuid = None
    instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(os.environ.get('instanceOfferingName_s')).uuid
    cond = res_ops.gen_query_conditions('mediaType', '!=', 'ISO')
    cond = res_ops.gen_query_conditions('platform', '=', 'Linux', cond)
    image_uuid = res_ops.query_resource(res_ops.IMAGE, cond, session_uuid)[0].uuid
    l3net_uuid = res_ops.get_resource(res_ops.L3_NETWORK, session_uuid)[0].uuid
    vm_creation_option = test_util.VmOption()
    vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
    vm_creation_option.set_image_uuid(image_uuid)
    vm_creation_option.set_l3_uuids([l3net_uuid])
    vm_creation_option.set_console_password(password1)

    vm = test_vm.ZstackTestVm()
    vm.set_creation_option(vm_creation_option)
    vm.create()

    vm.check()
    console = test_lib.lib_get_vm_console_address(vm.get_vm().uuid)
    test_util.test_logger('[vm:] %s console is on %s:%s' % (vm.get_vm().uuid, console.hostIp, console.port))
    display = str(int(console.port)-5900)
    try:
        client = api.connect(console.hostIp+":"+display)
        client.keyPress('k')
        test_util.test_fail('[vm:] %s console on %s:%s is connectable without password' % (vm.get_vm().uuid, console.hostIp, console.port))
    except:
        test_util.test_logger('[vm:] %s console on %s:%s is not connectable without password' % (vm.get_vm().uuid, console.hostIp, console.port))

    try:
        client = api.connect(console.hostIp+":"+display, password1)
        client.keyPress('k')
        test_util.test_logger('[vm:] %s console on %s:%s is connectable with password %s' % (vm.get_vm().uuid, console.hostIp, console.port, password1))
    except:
        test_util.test_fail('[vm:] %s console on %s:%s is not connectable with password %s' % (vm.get_vm().uuid, console.hostIp, console.port, password1))

    test_lib.lib_set_vm_console_password(vm.get_vm().uuid, password2)
    test_util.test_logger('set [vm:] %s console with password %s' % (vm.get_vm().uuid, password2))
    vm.reboot()

    try:
        client = api.connect(console.hostIp+":"+display, password2)
        client.keyPress('k')
        test_util.test_logger('[vm:] %s console on %s:%s is connectable with password %s' % (vm.get_vm().uuid, console.hostIp, console.port, password2))
    except:
        test_util.test_fail('[vm:] %s console on %s:%s is not connectable with password %s' % (vm.get_vm().uuid, console.hostIp, console.port, password2))

    import signal
    def handler(signum, frame):
        raise Exception()
    signal.signal(signal.SIGALRM, handler)
    signal.alarm(30)

    try:
        client = api.connect(console.hostIp+":"+display, password1)
        client.keyPress('k')
        test_util.test_fail('[vm:] %s console on %s:%s is connectable with password %s' % (vm.get_vm().uuid, console.hostIp, console.port, password1))
    except:
        test_util.test_logger('[vm:] %s console on %s:%s is not connectable with password %s' % (vm.get_vm().uuid, console.hostIp, console.port, password1))

    vm.destroy()

    test_util.test_pass('Set VM Console Password Test Success')
Exemplo n.º 37
0
from vncdotool import api
from reader import *
import time
from threading import Thread
from solver import *
from grid import *

client = api.connect('localhost:1', 'vnc')

f = 'working.png'
tl = get_grid(f)
b = get_box(f)[0]

def translate(x, y):
    x = (b//2) + (b * x)
    y = (b//2) + (b * y)
    x = x + tl[0]
    y = y + tl[1]
    return x, y

def mouseDrag2(client, start, dest, step):
    """ Move the mouse point to position (x, y) in increments of step
    """
    sx, sy = start
    x, y = dest
    if x < sx:
        xsteps = [sx - i for i in xrange(step, sx - x + 1, step)]
    else:
        xsteps = xrange(sx, x, step)

    if y < sy:
Exemplo n.º 38
0
 def connect_to_vnc_server(self, server, port=5900):
     self._client = api.connect('{0}::{1}'.format(server, port))
     self._server = server
     self._port = port
Exemplo n.º 39
0
 def showvnc(self,
             host,
             display,
             password=None,
             rotate=None,
             invert=False,
             sleep=1,
             full_interval=100):
     with api.connect(':'.join([host, display]),
                      password=password) as client:
         previous_vnc_image = None
         diff_bbox = None
         # number of updates; when it's 0, do a full refresh
         updates = 0
         client.timeout = 30
         while True:
             try:
                 client.refreshScreen()
             except TimeoutError:
                 print("Timeout to server {}:{}".format(host, display))
                 client.disconnect()
                 sys.exit(1)
             new_vnc_image = client.screen
             # apply rotation if any
             if rotate:
                 new_vnc_image = new_vnc_image.rotate(rotate, expand=True)
             # apply invert
             if invert:
                 new_vnc_image = ImageOps.invert(new_vnc_image)
             # rescale image if needed
             if new_vnc_image.size != (self.driver.width,
                                       self.driver.height):
                 new_vnc_image = new_vnc_image.resize(
                     (self.driver.width, self.driver.height))
             # if at least two frames have been processed, get a bounding box of their difference region
             if new_vnc_image and previous_vnc_image:
                 diff_bbox = self.band(
                     self.img_diff(new_vnc_image, previous_vnc_image))
             # frames differ, so we should update the display
             if diff_bbox:
                 # increment update counter
                 updates = (updates + 1) % full_interval
                 # if partial update is supported and it's not time for a full refresh,
                 # draw just the different region
                 if updates > 0 and (self.driver.supports_partial
                                     and self.partial):
                     print("partial ({}): {}".format(updates, diff_bbox))
                     self.driver.draw(diff_bbox[0], diff_bbox[1],
                                      new_vnc_image.crop(diff_bbox))
                 # if partial update is not possible or desired, do a full refresh
                 else:
                     print("full ({}): {}".format(updates,
                                                  new_vnc_image.size))
                     self.driver.draw(0, 0, new_vnc_image)
             # otherwise this is the first frame, so run a full refresh to get things going
             else:
                 if updates == 0:
                     updates = (updates + 1) % full_interval
                     print("initial ({}): {}".format(
                         updates, new_vnc_image.size))
                     self.driver.draw(0, 0, new_vnc_image)
             previous_vnc_image = new_vnc_image.copy()
             time.sleep(float(sleep))
def test():
    from vncdotool import api
    global vm
    vm = test_stub.create_vm()
    vm.check()
    console = test_lib.lib_get_vm_console_address(vm.get_vm().uuid)
    test_util.test_logger('[vm:] %s console is on %s:%s' % (vm.get_vm().uuid, console.hostIp, console.port))
    display = str(int(console.port)-5900)

    try:
        client = api.connect(console.hostIp+":"+display)
        client.keyPress('k')
        test_util.test_logger('[vm:] %s console on %s:%s is connectable without password' % (vm.get_vm().uuid, console.hostIp, console.port))
    except:
        test_util.test_fail('[vm:] %s console on %s:%s is not connectable without password' % (vm.get_vm().uuid, console.hostIp, console.port))

    test_lib.lib_set_vm_console_password(vm.get_vm().uuid, password1)
    test_util.test_logger('set [vm:] %s console with password %s' % (vm.get_vm().uuid, password1))
    vm.reboot()

    try:
        client = api.connect(console.hostIp+":"+display)
        client.keyPress('k')
        test_util.test_fail('[vm:] %s console on %s:%s is connectable without password' % (vm.get_vm().uuid, console.hostIp, console.port))
    except:
        test_util.test_logger('[vm:] %s console on %s:%s is not connectable without password' % (vm.get_vm().uuid, console.hostIp, console.port))

    try:
        client = api.connect(console.hostIp+":"+display, password1)
        client.keyPress('k')
        test_util.test_logger('[vm:] %s console on %s:%s is connectable with password %s' % (vm.get_vm().uuid, console.hostIp, console.port, password1))
    except:
        test_util.test_fail('[vm:] %s console on %s:%s is not connectable with password %s' % (vm.get_vm().uuid, console.hostIp, console.port, password1))

    test_lib.lib_set_vm_console_password(vm.get_vm().uuid, password2)
    test_util.test_logger('set [vm:] %s console with password %s' % (vm.get_vm().uuid, password2))
    vm.reboot()


    try:
        client = api.connect(console.hostIp+":"+display, password2)
        client.keyPress('k')
        test_util.test_logger('[vm:] %s console on %s:%s is connectable with password %s' % (vm.get_vm().uuid, console.hostIp, console.port, password2))
    except:
        test_util.test_fail('[vm:] %s console on %s:%s is not connectable with password %s' % (vm.get_vm().uuid, console.hostIp, console.port, password2))

    import signal
    def handler(signum, frame):
        raise Exception()
    signal.signal(signal.SIGALRM, handler)
    signal.alarm(30)
    
    try:
        client = api.connect(console.hostIp+":"+display, password1)
        client.keyPress('k')
        test_util.test_fail('[vm:] %s console on %s:%s is connectable with password %s' % (vm.get_vm().uuid, console.hostIp, console.port, password1))
    except:
        test_util.test_logger('[vm:] %s console on %s:%s is not connectable with password %s' % (vm.get_vm().uuid, console.hostIp, console.port, password1))

    vm.destroy()
    test_util.test_pass('Set VM Console Password Test Success')