Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

first pass at working code

  • Loading branch information...
commit e9526e90f048db957820937d5de5fbf01cd4d222 1 parent 992c9d7
Marc Sibson authored
View
19 LICENSE.txt
@@ -0,0 +1,19 @@
+Copyright (c) 2010 Marc Sibson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
View
25 README.txt
@@ -5,3 +5,28 @@ the command line.
Currently under developement and altogether not ready for general use. One
day it might actually be useful.
+
+Quick Start
+--------------------------------
+Assuming you have a VNC server already running you can quickly try out
+vncdotool by running::
+
+ python vncdotool -h hostaddr -d displaynum click 2
+
+Which for most window managers will open a context menu at the top left
+corner of the screen.
+
+Usage
+--------------------------------
+
+Acknowledgements
+--------------------------------
+Thanks to
+
+(c) 2003 chris <cliechti@gmx.net>
+(c) 2009 techtonik <techtonik@gmail.com>
+
+
+whose python-vnc-viewer_, provided the RFB protocol implementation used by vncdotool.
+
+_python-vnc_viewer: http://code.google.com/p/python-vnc-viewer/
View
5 scripts/vncdotool
@@ -0,0 +1,5 @@
+#!/usr/bin/env python
+from vncdotool.command import main
+
+if __name__ == '__main__':
+ main()
View
41 setup.py
@@ -0,0 +1,41 @@
+#!/usr/bin/env python
+
+from distutils.core import setup
+
+setup(
+ name='vncdotool',
+ version='0.1.0dev',
+ description='Send keyboard and mouse events to a VNC server from the command line',
+ requires=[
+ 'Twisted',
+ ],
+
+ url='http://github.com/sibson/vncdotool',
+ author='Marc Sibson',
+ author_email='sibson+vncdotool@gmail.com',
+ download_url='',
+
+ scripts=['scripts/vncdotool'],
+ packages=['vncdotool'],
+
+ classifiers=[
+ 'Development Status :: 2 - Pre-Alpha',
+ 'Environment :: Console',
+ 'Framework :: Twisted',
+ 'Intended Audience :: Developers',
+ 'Intended Audience :: System Administrators',
+ 'License :: OSI Approved :: MIT License',
+ 'Operating System :: MacOS :: MacOS X',
+ 'Operating System :: Microsoft :: Windows',
+ 'Operating System :: POSIX',
+ 'Programming Language :: Python',
+ 'Programming Language :: Python :: 2.4',
+ 'Programming Language :: Python :: 2.5',
+ 'Programming Language :: Python :: 2.6',
+ 'Programming Language :: Python :: 2.7',
+ 'Topic :: Multimedia :: Graphics :: Viewers',
+ 'Topic :: Software Development :: Testing',
+ ],
+
+ long_description='',
+)
View
0  vncdotool/__init__.py
No changes.
View
62 vncdotool/client.py
@@ -0,0 +1,62 @@
+"""
+
+(c) 2010 Marc Sibson
+
+MIT License
+"""
+
+from rfb import RFBClient, RFBFactory
+from twisted.internet import reactor
+from twisted.internet.defer import Deferred
+
+
+class VNCDoToolClient(RFBClient):
+ x = 0
+ y = 0
+
+ def vncConnectionMade(self):
+ self.setPixelFormat()
+ self.factory.deferred.callback(self)
+
+ def keyPress(self, key):
+ self.keyEvent(ord(key), down=1)
+ self.keyEvent(ord(key), down=0)
+ return self
+
+ def mousePress(self, button):
+ buttons = 1 << button
+ self.pointerEvent(self.x, self.y, buttonmask=buttons)
+ self.pointerEvent(self.x, self.y, buttonmask=0)
+ return self
+
+
+ def mouseMove(self, x, y):
+ self.x, self.y = x, y
+ self.pointerEvent(x, y)
+ return self
+
+ def bell(self):
+ print 'ding'
+
+ def copy_text(self, text):
+ print 'clip', repr(text)
+
+ def paste(self, message):
+ self.clientCutText(message)
+ return self
+
+
+class VNCDoToolFactory(RFBFactory):
+ protocol = VNCDoToolClient
+ password = None
+ shared = 1
+
+ def __init__(self):
+ self.deferred = Deferred()
+
+ def clientConnectionFailed(self, connector, reason):
+ print 'connection failed', reason
+ reactor.callLater(0, self.deferred.errback, reason)
+ self.deferred = None
+
+
View
77 vncdotool/command.py
@@ -0,0 +1,77 @@
+#!/usr/bin/env python
+"""
+
+(c) 2010 Marc Sibson
+
+MIT License
+"""
+import optparse
+
+from twisted.internet import reactor
+
+from vncdotool.client import VNCDoToolFactory, VNCDoToolClient
+
+def log_connected(pcol):
+ print 'connected to', pcol.name
+ return pcol
+
+
+def log_failed(reason):
+ print 'connection failed', reason.getErrorMesssage()
+
+
+def stop(pcol):
+ pcol.transport.loseConnection()
+ reactor.callLater(0.1, reactor.stop)
+
+def main():
+ op = optparse.OptionParser(usage='%prog [options] cmd',
+ add_help_option=False)
+ op.add_option('-d', '--display', action='store', metavar='DISPLAY',
+ type='int', default=0,
+ help='connect to vnc server on DISPLAY [%default]')
+ op.add_option('--help', action='help',
+ help='show this help message')
+ op.add_option('-h', '--host', action='store', metavar='HOST',
+ default='127.0.0.1',
+ help='connect to vnc server at HOST [%default]')
+ op.add_option('-p', '--port', action='store', metavar='PORT',
+ type='int',
+ help='connect to vnc server on PORT')
+ op.add_option('-v', '--verbose', action='store_true')
+
+ opts, args = op.parse_args()
+ if opts.port is None:
+ opts.port = opts.display + 5900
+
+ if not len(args):
+ op.error('no command provided')
+
+ f = VNCDoToolFactory()
+ if opts.verbose:
+ print 'connecting to %s:%d' % (opts.host, opts.port)
+
+ if opts.verbose:
+ f.deferred.addCallbacks(log_connected, log_failed)
+
+ while args:
+ cmd = args.pop(0)
+ if cmd == 'key':
+ f.deferred.addCallback(VNCDoToolClient.keyPress, args.pop(0))
+ elif cmd == 'move':
+ x, y = int(args.pop(0)), int(args.pop(0))
+ f.deferred.addCallback(VNCDoToolClient.mouseMove, x, y)
+ elif cmd == 'click':
+ button = int(args.pop(0))
+ f.deferred.addCallback(VNCDoToolClient.mousePress, button)
+ elif cmd == 'type':
+ for key in args.pop(0):
+ f.deferred.addCallback(VNCDoToolClient.keyPress, key)
+
+ f.deferred.addCallback(stop)
+
+ reactor.connectTCP(opts.host, opts.port, f)
+ reactor.run()
+
+if __name__ == '__main__':
+ main()
View
852 vncdotool/pyDes.py
@@ -0,0 +1,852 @@
+#############################################################################
+# Documentation #
+#############################################################################
+
+# Author: Todd Whiteman
+# Date: 16th March, 2009
+# Verion: 2.0.0
+# License: Public Domain - free to do as you wish
+# Homepage: http://twhiteman.netfirms.com/des.html
+#
+# This is a pure python implementation of the DES encryption algorithm.
+# It's pure python to avoid portability issues, since most DES
+# implementations are programmed in C (for performance reasons).
+#
+# Triple DES class is also implemented, utilising the DES base. Triple DES
+# is either DES-EDE3 with a 24 byte key, or DES-EDE2 with a 16 byte key.
+#
+# See the README.txt that should come with this python module for the
+# implementation methods used.
+#
+# Thanks to:
+# * David Broadwell for ideas, comments and suggestions.
+# * Mario Wolff for pointing out and debugging some triple des CBC errors.
+# * Santiago Palladino for providing the PKCS5 padding technique.
+# * Shaya for correcting the PAD_PKCS5 triple des CBC errors.
+#
+"""A pure python implementation of the DES and TRIPLE DES encryption algorithms.
+
+Class initialization
+--------------------
+pyDes.des(key, [mode], [IV], [pad], [padmode])
+pyDes.triple_des(key, [mode], [IV], [pad], [padmode])
+
+key -> Bytes containing the encryption key. 8 bytes for DES, 16 or 24 bytes
+ for Triple DES
+mode -> Optional argument for encryption type, can be either
+ pyDes.ECB (Electronic Code Book) or pyDes.CBC (Cypher Block Chaining)
+IV -> Optional Initial Value bytes, must be supplied if using CBC mode.
+ Length must be 8 bytes.
+pad -> Optional argument, set the pad character (PAD_NORMAL) to use during
+ all encrypt/decrpt operations done with this instance.
+padmode -> Optional argument, set the padding mode (PAD_NORMAL or PAD_PKCS5)
+ to use during all encrypt/decrpt operations done with this instance.
+
+I recommend to use PAD_PKCS5 padding, as then you never need to worry about any
+padding issues, as the padding can be removed unambiguously upon decrypting
+data that was encrypted using PAD_PKCS5 padmode.
+
+Common methods
+--------------
+encrypt(data, [pad], [padmode])
+decrypt(data, [pad], [padmode])
+
+data -> Bytes to be encrypted/decrypted
+pad -> Optional argument. Only when using padmode of PAD_NORMAL. For
+ encryption, adds this characters to the end of the data block when
+ data is not a multiple of 8 bytes. For decryption, will remove the
+ trailing characters that match this pad character from the last 8
+ bytes of the unencrypted data block.
+padmode -> Optional argument, set the padding mode, must be one of PAD_NORMAL
+ or PAD_PKCS5). Defaults to PAD_NORMAL.
+
+
+Example
+-------
+from pyDes import *
+
+data = "Please encrypt my data"
+k = des("DESCRYPT", CBC, "\0\0\0\0\0\0\0\0", pad=None, padmode=PAD_PKCS5)
+# For Python3, you'll need to use bytes, i.e.:
+# data = b"Please encrypt my data"
+# k = des(b"DESCRYPT", CBC, b"\0\0\0\0\0\0\0\0", pad=None, padmode=PAD_PKCS5)
+d = k.encrypt(data)
+print "Encrypted: %r" % d
+print "Decrypted: %r" % k.decrypt(d)
+assert k.decrypt(d, padmode=PAD_PKCS5) == data
+
+
+See the module source (pyDes.py) for more examples of use.
+You can also run the pyDes.py file without and arguments to see a simple test.
+
+Note: This code was not written for high-end systems needing a fast
+ implementation, but rather a handy portable solution with small usage.
+
+"""
+
+import sys
+
+# _pythonMajorVersion is used to handle Python2 and Python3 differences.
+_pythonMajorVersion = sys.version_info[0]
+
+# Modes of crypting / cyphering
+ECB = 0
+CBC = 1
+
+# Modes of padding
+PAD_NORMAL = 1
+PAD_PKCS5 = 2
+
+# PAD_PKCS5: is a method that will unambiguously remove all padding
+# characters after decryption, when originally encrypted with
+# this padding mode.
+# For a good description of the PKCS5 padding technique, see:
+# http://www.faqs.org/rfcs/rfc1423.html
+
+# The base class shared by des and triple des.
+class _baseDes(object):
+ def __init__(self, mode=ECB, IV=None, pad=None, padmode=PAD_NORMAL):
+ if IV:
+ IV = self._guardAgainstUnicode(IV)
+ if pad:
+ pad = self._guardAgainstUnicode(pad)
+ self.block_size = 8
+ # Sanity checking of arguments.
+ if pad and padmode == PAD_PKCS5:
+ raise ValueError("Cannot use a pad character with PAD_PKCS5")
+ if IV and len(IV) != self.block_size:
+ raise ValueError("Invalid Initial Value (IV), must be a multiple of " + str(self.block_size) + " bytes")
+
+ # Set the passed in variables
+ self._mode = mode
+ self._iv = IV
+ self._padding = pad
+ self._padmode = padmode
+
+ def getKey(self):
+ """getKey() -> bytes"""
+ return self.__key
+
+ def setKey(self, key):
+ """Will set the crypting key for this object."""
+ key = self._guardAgainstUnicode(key)
+ self.__key = key
+
+ def getMode(self):
+ """getMode() -> pyDes.ECB or pyDes.CBC"""
+ return self._mode
+
+ def setMode(self, mode):
+ """Sets the type of crypting mode, pyDes.ECB or pyDes.CBC"""
+ self._mode = mode
+
+ def getPadding(self):
+ """getPadding() -> bytes of length 1. Padding character."""
+ return self._padding
+
+ def setPadding(self, pad):
+ """setPadding() -> bytes of length 1. Padding character."""
+ if pad is not None:
+ pad = self._guardAgainstUnicode(pad)
+ self._padding = pad
+
+ def getPadMode(self):
+ """getPadMode() -> pyDes.PAD_NORMAL or pyDes.PAD_PKCS5"""
+ return self._padmode
+
+ def setPadMode(self, mode):
+ """Sets the type of padding mode, pyDes.PAD_NORMAL or pyDes.PAD_PKCS5"""
+ self._padmode = mode
+
+ def getIV(self):
+ """getIV() -> bytes"""
+ return self._iv
+
+ def setIV(self, IV):
+ """Will set the Initial Value, used in conjunction with CBC mode"""
+ if not IV or len(IV) != self.block_size:
+ raise ValueError("Invalid Initial Value (IV), must be a multiple of " + str(self.block_size) + " bytes")
+ IV = self._guardAgainstUnicode(IV)
+ self._iv = IV
+
+ def _padData(self, data, pad, padmode):
+ # Pad data depending on the mode
+ if padmode is None:
+ # Get the default padding mode.
+ padmode = self.getPadMode()
+ if pad and padmode == PAD_PKCS5:
+ raise ValueError("Cannot use a pad character with PAD_PKCS5")
+
+ if padmode == PAD_NORMAL:
+ if len(data) % self.block_size == 0:
+ # No padding required.
+ return data
+
+ if not pad:
+ # Get the default padding.
+ pad = self.getPadding()
+ if not pad:
+ raise ValueError("Data must be a multiple of " + str(self.block_size) + " bytes in length. Use padmode=PAD_PKCS5 or set the pad character.")
+ data += (self.block_size - (len(data) % self.block_size)) * pad
+
+ elif padmode == PAD_PKCS5:
+ pad_len = 8 - (len(data) % self.block_size)
+ if _pythonMajorVersion < 3:
+ data += pad_len * chr(pad_len)
+ else:
+ data += bytes([pad_len] * pad_len)
+
+ return data
+
+ def _unpadData(self, data, pad, padmode):
+ # Unpad data depending on the mode.
+ if not data:
+ return data
+ if pad and padmode == PAD_PKCS5:
+ raise ValueError("Cannot use a pad character with PAD_PKCS5")
+ if padmode is None:
+ # Get the default padding mode.
+ padmode = self.getPadMode()
+
+ if padmode == PAD_NORMAL:
+ if not pad:
+ # Get the default padding.
+ pad = self.getPadding()
+ if pad:
+ data = data[:-self.block_size] + \
+ data[-self.block_size:].rstrip(pad)
+
+ elif padmode == PAD_PKCS5:
+ if _pythonMajorVersion < 3:
+ pad_len = ord(data[-1])
+ else:
+ pad_len = data[-1]
+ data = data[:-pad_len]
+
+ return data
+
+ def _guardAgainstUnicode(self, data):
+ # Only accept byte strings or ascii unicode values, otherwise
+ # there is no way to correctly decode the data into bytes.
+ if _pythonMajorVersion < 3:
+ if isinstance(data, unicode):
+ raise ValueError("pyDes can only work with bytes, not Unicode strings.")
+ else:
+ if isinstance(data, str):
+ # Only accept ascii unicode values.
+ try:
+ return data.encode('ascii')
+ except UnicodeEncodeError:
+ pass
+ raise ValueError("pyDes can only work with encoded strings, not Unicode.")
+ return data
+
+#############################################################################
+# DES #
+#############################################################################
+class des(_baseDes):
+ """DES encryption/decrytpion class
+
+ Supports ECB (Electronic Code Book) and CBC (Cypher Block Chaining) modes.
+
+ pyDes.des(key,[mode], [IV])
+
+ key -> Bytes containing the encryption key, must be exactly 8 bytes
+ mode -> Optional argument for encryption type, can be either pyDes.ECB
+ (Electronic Code Book), pyDes.CBC (Cypher Block Chaining)
+ IV -> Optional Initial Value bytes, must be supplied if using CBC mode.
+ Must be 8 bytes in length.
+ pad -> Optional argument, set the pad character (PAD_NORMAL) to use
+ during all encrypt/decrpt operations done with this instance.
+ padmode -> Optional argument, set the padding mode (PAD_NORMAL or
+ PAD_PKCS5) to use during all encrypt/decrpt operations done
+ with this instance.
+ """
+
+
+ # Permutation and translation tables for DES
+ __pc1 = [56, 48, 40, 32, 24, 16, 8,
+ 0, 57, 49, 41, 33, 25, 17,
+ 9, 1, 58, 50, 42, 34, 26,
+ 18, 10, 2, 59, 51, 43, 35,
+ 62, 54, 46, 38, 30, 22, 14,
+ 6, 61, 53, 45, 37, 29, 21,
+ 13, 5, 60, 52, 44, 36, 28,
+ 20, 12, 4, 27, 19, 11, 3
+ ]
+
+ # number left rotations of pc1
+ __left_rotations = [
+ 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
+ ]
+
+ # permuted choice key (table 2)
+ __pc2 = [
+ 13, 16, 10, 23, 0, 4,
+ 2, 27, 14, 5, 20, 9,
+ 22, 18, 11, 3, 25, 7,
+ 15, 6, 26, 19, 12, 1,
+ 40, 51, 30, 36, 46, 54,
+ 29, 39, 50, 44, 32, 47,
+ 43, 48, 38, 55, 33, 52,
+ 45, 41, 49, 35, 28, 31
+ ]
+
+ # initial permutation IP
+ __ip = [57, 49, 41, 33, 25, 17, 9, 1,
+ 59, 51, 43, 35, 27, 19, 11, 3,
+ 61, 53, 45, 37, 29, 21, 13, 5,
+ 63, 55, 47, 39, 31, 23, 15, 7,
+ 56, 48, 40, 32, 24, 16, 8, 0,
+ 58, 50, 42, 34, 26, 18, 10, 2,
+ 60, 52, 44, 36, 28, 20, 12, 4,
+ 62, 54, 46, 38, 30, 22, 14, 6
+ ]
+
+ # Expansion table for turning 32 bit blocks into 48 bits
+ __expansion_table = [
+ 31, 0, 1, 2, 3, 4,
+ 3, 4, 5, 6, 7, 8,
+ 7, 8, 9, 10, 11, 12,
+ 11, 12, 13, 14, 15, 16,
+ 15, 16, 17, 18, 19, 20,
+ 19, 20, 21, 22, 23, 24,
+ 23, 24, 25, 26, 27, 28,
+ 27, 28, 29, 30, 31, 0
+ ]
+
+ # The (in)famous S-boxes
+ __sbox = [
+ # S1
+ [14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7,
+ 0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,
+ 4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,
+ 15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13],
+
+ # S2
+ [15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,
+ 3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,
+ 0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,
+ 13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9],
+
+ # S3
+ [10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8,
+ 13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1,
+ 13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7,
+ 1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12],
+
+ # S4
+ [7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15,
+ 13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9,
+ 10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4,
+ 3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14],
+
+ # S5
+ [2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9,
+ 14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6,
+ 4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14,
+ 11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3],
+
+ # S6
+ [12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11,
+ 10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8,
+ 9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6,
+ 4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13],
+
+ # S7
+ [4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,
+ 13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,
+ 1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,
+ 6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12],
+
+ # S8
+ [13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,
+ 1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,
+ 7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,
+ 2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11],
+ ]
+
+
+ # 32-bit permutation function P used on the output of the S-boxes
+ __p = [
+ 15, 6, 19, 20, 28, 11,
+ 27, 16, 0, 14, 22, 25,
+ 4, 17, 30, 9, 1, 7,
+ 23,13, 31, 26, 2, 8,
+ 18, 12, 29, 5, 21, 10,
+ 3, 24
+ ]
+
+ # final permutation IP^-1
+ __fp = [
+ 39, 7, 47, 15, 55, 23, 63, 31,
+ 38, 6, 46, 14, 54, 22, 62, 30,
+ 37, 5, 45, 13, 53, 21, 61, 29,
+ 36, 4, 44, 12, 52, 20, 60, 28,
+ 35, 3, 43, 11, 51, 19, 59, 27,
+ 34, 2, 42, 10, 50, 18, 58, 26,
+ 33, 1, 41, 9, 49, 17, 57, 25,
+ 32, 0, 40, 8, 48, 16, 56, 24
+ ]
+
+ # Type of crypting being done
+ ENCRYPT = 0x00
+ DECRYPT = 0x01
+
+ # Initialisation
+ def __init__(self, key, mode=ECB, IV=None, pad=None, padmode=PAD_NORMAL):
+ # Sanity checking of arguments.
+ if len(key) != 8:
+ raise ValueError("Invalid DES key size. Key must be exactly 8 bytes long.")
+ _baseDes.__init__(self, mode, IV, pad, padmode)
+ self.key_size = 8
+
+ self.L = []
+ self.R = []
+ self.Kn = [ [0] * 48 ] * 16 # 16 48-bit keys (K1 - K16)
+ self.final = []
+
+ self.setKey(key)
+
+ def setKey(self, key):
+ """Will set the crypting key for this object. Must be 8 bytes."""
+ _baseDes.setKey(self, key)
+ self.__create_sub_keys()
+
+ def __String_to_BitList(self, data):
+ """Turn the string data, into a list of bits (1, 0)'s"""
+ if _pythonMajorVersion < 3:
+ # Turn the strings into integers. Python 3 uses a bytes
+ # class, which already has this behaviour.
+ data = [ord(c) for c in data]
+ l = len(data) * 8
+ result = [0] * l
+ pos = 0
+ for ch in data:
+ i = 7
+ while i >= 0:
+ if ch & (1 << i) != 0:
+ result[pos] = 1
+ else:
+ result[pos] = 0
+ pos += 1
+ i -= 1
+
+ return result
+
+ def __BitList_to_String(self, data):
+ """Turn the list of bits -> data, into a string"""
+ result = []
+ pos = 0
+ c = 0
+ while pos < len(data):
+ c += data[pos] << (7 - (pos % 8))
+ if (pos % 8) == 7:
+ result.append(c)
+ c = 0
+ pos += 1
+
+ if _pythonMajorVersion < 3:
+ return ''.join([ chr(c) for c in result ])
+ else:
+ return bytes(result)
+
+ def __permutate(self, table, block):
+ """Permutate this block with the specified table"""
+ return list(map(lambda x: block[x], table))
+
+ # Transform the secret key, so that it is ready for data processing
+ # Create the 16 subkeys, K[1] - K[16]
+ def __create_sub_keys(self):
+ """Create the 16 subkeys K[1] to K[16] from the given key"""
+ key = self.__permutate(des.__pc1, self.__String_to_BitList(self.getKey()))
+ i = 0
+ # Split into Left and Right sections
+ self.L = key[:28]
+ self.R = key[28:]
+ while i < 16:
+ j = 0
+ # Perform circular left shifts
+ while j < des.__left_rotations[i]:
+ self.L.append(self.L[0])
+ del self.L[0]
+
+ self.R.append(self.R[0])
+ del self.R[0]
+
+ j += 1
+
+ # Create one of the 16 subkeys through pc2 permutation
+ self.Kn[i] = self.__permutate(des.__pc2, self.L + self.R)
+
+ i += 1
+
+ # Main part of the encryption algorithm, the number cruncher :)
+ def __des_crypt(self, block, crypt_type):
+ """Crypt the block of data through DES bit-manipulation"""
+ block = self.__permutate(des.__ip, block)
+ self.L = block[:32]
+ self.R = block[32:]
+
+ # Encryption starts from Kn[1] through to Kn[16]
+ if crypt_type == des.ENCRYPT:
+ iteration = 0
+ iteration_adjustment = 1
+ # Decryption starts from Kn[16] down to Kn[1]
+ else:
+ iteration = 15
+ iteration_adjustment = -1
+
+ i = 0
+ while i < 16:
+ # Make a copy of R[i-1], this will later become L[i]
+ tempR = self.R[:]
+
+ # Permutate R[i - 1] to start creating R[i]
+ self.R = self.__permutate(des.__expansion_table, self.R)
+
+ # Exclusive or R[i - 1] with K[i], create B[1] to B[8] whilst here
+ self.R = list(map(lambda x, y: x ^ y, self.R, self.Kn[iteration]))
+ B = [self.R[:6], self.R[6:12], self.R[12:18], self.R[18:24], self.R[24:30], self.R[30:36], self.R[36:42], self.R[42:]]
+ # Optimization: Replaced below commented code with above
+ #j = 0
+ #B = []
+ #while j < len(self.R):
+ # self.R[j] = self.R[j] ^ self.Kn[iteration][j]
+ # j += 1
+ # if j % 6 == 0:
+ # B.append(self.R[j-6:j])
+
+ # Permutate B[1] to B[8] using the S-Boxes
+ j = 0
+ Bn = [0] * 32
+ pos = 0
+ while j < 8:
+ # Work out the offsets
+ m = (B[j][0] << 1) + B[j][5]
+ n = (B[j][1] << 3) + (B[j][2] << 2) + (B[j][3] << 1) + B[j][4]
+
+ # Find the permutation value
+ v = des.__sbox[j][(m << 4) + n]
+
+ # Turn value into bits, add it to result: Bn
+ Bn[pos] = (v & 8) >> 3
+ Bn[pos + 1] = (v & 4) >> 2
+ Bn[pos + 2] = (v & 2) >> 1
+ Bn[pos + 3] = v & 1
+
+ pos += 4
+ j += 1
+
+ # Permutate the concatination of B[1] to B[8] (Bn)
+ self.R = self.__permutate(des.__p, Bn)
+
+ # Xor with L[i - 1]
+ self.R = list(map(lambda x, y: x ^ y, self.R, self.L))
+ # Optimization: This now replaces the below commented code
+ #j = 0
+ #while j < len(self.R):
+ # self.R[j] = self.R[j] ^ self.L[j]
+ # j += 1
+
+ # L[i] becomes R[i - 1]
+ self.L = tempR
+
+ i += 1
+ iteration += iteration_adjustment
+
+ # Final permutation of R[16]L[16]
+ self.final = self.__permutate(des.__fp, self.R + self.L)
+ return self.final
+
+
+ # Data to be encrypted/decrypted
+ def crypt(self, data, crypt_type):
+ """Crypt the data in blocks, running it through des_crypt()"""
+
+ # Error check the data
+ if not data:
+ return ''
+ if len(data) % self.block_size != 0:
+ if crypt_type == des.DECRYPT: # Decryption must work on 8 byte blocks
+ raise ValueError("Invalid data length, data must be a multiple of " + str(self.block_size) + " bytes\n.")
+ if not self.getPadding():
+ raise ValueError("Invalid data length, data must be a multiple of " + str(self.block_size) + " bytes\n. Try setting the optional padding character")
+ else:
+ data += (self.block_size - (len(data) % self.block_size)) * self.getPadding()
+ # print "Len of data: %f" % (len(data) / self.block_size)
+
+ if self.getMode() == CBC:
+ if self.getIV():
+ iv = self.__String_to_BitList(self.getIV())
+ else:
+ raise ValueError("For CBC mode, you must supply the Initial Value (IV) for ciphering")
+
+ # Split the data into blocks, crypting each one seperately
+ i = 0
+ dict = {}
+ result = []
+ #cached = 0
+ #lines = 0
+ while i < len(data):
+ # Test code for caching encryption results
+ #lines += 1
+ #if dict.has_key(data[i:i+8]):
+ #print "Cached result for: %s" % data[i:i+8]
+ # cached += 1
+ # result.append(dict[data[i:i+8]])
+ # i += 8
+ # continue
+
+ block = self.__String_to_BitList(data[i:i+8])
+
+ # Xor with IV if using CBC mode
+ if self.getMode() == CBC:
+ if crypt_type == des.ENCRYPT:
+ block = list(map(lambda x, y: x ^ y, block, iv))
+ #j = 0
+ #while j < len(block):
+ # block[j] = block[j] ^ iv[j]
+ # j += 1
+
+ processed_block = self.__des_crypt(block, crypt_type)
+
+ if crypt_type == des.DECRYPT:
+ processed_block = list(map(lambda x, y: x ^ y, processed_block, iv))
+ #j = 0
+ #while j < len(processed_block):
+ # processed_block[j] = processed_block[j] ^ iv[j]
+ # j += 1
+ iv = block
+ else:
+ iv = processed_block
+ else:
+ processed_block = self.__des_crypt(block, crypt_type)
+
+
+ # Add the resulting crypted block to our list
+ #d = self.__BitList_to_String(processed_block)
+ #result.append(d)
+ result.append(self.__BitList_to_String(processed_block))
+ #dict[data[i:i+8]] = d
+ i += 8
+
+ # print "Lines: %d, cached: %d" % (lines, cached)
+
+ # Return the full crypted string
+ if _pythonMajorVersion < 3:
+ return ''.join(result)
+ else:
+ return bytes.fromhex('').join(result)
+
+ def encrypt(self, data, pad=None, padmode=None):
+ """encrypt(data, [pad], [padmode]) -> bytes
+
+ data : Bytes to be encrypted
+ pad : Optional argument for encryption padding. Must only be one byte
+ padmode : Optional argument for overriding the padding mode.
+
+ The data must be a multiple of 8 bytes and will be encrypted
+ with the already specified key. Data does not have to be a
+ multiple of 8 bytes if the padding character is supplied, or
+ the padmode is set to PAD_PKCS5, as bytes will then added to
+ ensure the be padded data is a multiple of 8 bytes.
+ """
+ data = self._guardAgainstUnicode(data)
+ if pad is not None:
+ pad = self._guardAgainstUnicode(pad)
+ data = self._padData(data, pad, padmode)
+ return self.crypt(data, des.ENCRYPT)
+
+ def decrypt(self, data, pad=None, padmode=None):
+ """decrypt(data, [pad], [padmode]) -> bytes
+
+ data : Bytes to be encrypted
+ pad : Optional argument for decryption padding. Must only be one byte
+ padmode : Optional argument for overriding the padding mode.
+
+ The data must be a multiple of 8 bytes and will be decrypted
+ with the already specified key. In PAD_NORMAL mode, if the
+ optional padding character is supplied, then the un-encrypted
+ data will have the padding characters removed from the end of
+ the bytes. This pad removal only occurs on the last 8 bytes of
+ the data (last data block). In PAD_PKCS5 mode, the special
+ padding end markers will be removed from the data after decrypting.
+ """
+ data = self._guardAgainstUnicode(data)
+ if pad is not None:
+ pad = self._guardAgainstUnicode(pad)
+ data = self.crypt(data, des.DECRYPT)
+ return self._unpadData(data, pad, padmode)
+
+
+
+#############################################################################
+# Triple DES #
+#############################################################################
+class triple_des(_baseDes):
+ """Triple DES encryption/decrytpion class
+
+ This algorithm uses the DES-EDE3 (when a 24 byte key is supplied) or
+ the DES-EDE2 (when a 16 byte key is supplied) encryption methods.
+ Supports ECB (Electronic Code Book) and CBC (Cypher Block Chaining) modes.
+
+ pyDes.des(key, [mode], [IV])
+
+ key -> Bytes containing the encryption key, must be either 16 or
+ 24 bytes long
+ mode -> Optional argument for encryption type, can be either pyDes.ECB
+ (Electronic Code Book), pyDes.CBC (Cypher Block Chaining)
+ IV -> Optional Initial Value bytes, must be supplied if using CBC mode.
+ Must be 8 bytes in length.
+ pad -> Optional argument, set the pad character (PAD_NORMAL) to use
+ during all encrypt/decrpt operations done with this instance.
+ padmode -> Optional argument, set the padding mode (PAD_NORMAL or
+ PAD_PKCS5) to use during all encrypt/decrpt operations done
+ with this instance.
+ """
+ def __init__(self, key, mode=ECB, IV=None, pad=None, padmode=PAD_NORMAL):
+ _baseDes.__init__(self, mode, IV, pad, padmode)
+ self.setKey(key)
+
+ def setKey(self, key):
+ """Will set the crypting key for this object. Either 16 or 24 bytes long."""
+ self.key_size = 24 # Use DES-EDE3 mode
+ if len(key) != self.key_size:
+ if len(key) == 16: # Use DES-EDE2 mode
+ self.key_size = 16
+ else:
+ raise ValueError("Invalid triple DES key size. Key must be either 16 or 24 bytes long")
+ if self.getMode() == CBC:
+ if not self.getIV():
+ # Use the first 8 bytes of the key
+ self._iv = key[:self.block_size]
+ if len(self.getIV()) != self.block_size:
+ raise ValueError("Invalid IV, must be 8 bytes in length")
+ self.__key1 = des(key[:8], self._mode, self._iv,
+ self._padding, self._padmode)
+ self.__key2 = des(key[8:16], self._mode, self._iv,
+ self._padding, self._padmode)
+ if self.key_size == 16:
+ self.__key3 = self.__key1
+ else:
+ self.__key3 = des(key[16:], self._mode, self._iv,
+ self._padding, self._padmode)
+ _baseDes.setKey(self, key)
+
+ # Override setter methods to work on all 3 keys.
+
+ def setMode(self, mode):
+ """Sets the type of crypting mode, pyDes.ECB or pyDes.CBC"""
+ _baseDes.setMode(self, mode)
+ for key in (self.__key1, self.__key2, self.__key3):
+ key.setMode(mode)
+
+ def setPadding(self, pad):
+ """setPadding() -> bytes of length 1. Padding character."""
+ _baseDes.setPadding(self, pad)
+ for key in (self.__key1, self.__key2, self.__key3):
+ key.setPadding(pad)
+
+ def setPadMode(self, mode):
+ """Sets the type of padding mode, pyDes.PAD_NORMAL or pyDes.PAD_PKCS5"""
+ _baseDes.setPadMode(self, mode)
+ for key in (self.__key1, self.__key2, self.__key3):
+ key.setPadMode(mode)
+
+ def setIV(self, IV):
+ """Will set the Initial Value, used in conjunction with CBC mode"""
+ _baseDes.setIV(self, IV)
+ for key in (self.__key1, self.__key2, self.__key3):
+ key.setIV(IV)
+
+ def encrypt(self, data, pad=None, padmode=None):
+ """encrypt(data, [pad], [padmode]) -> bytes
+
+ data : bytes to be encrypted
+ pad : Optional argument for encryption padding. Must only be one byte
+ padmode : Optional argument for overriding the padding mode.
+
+ The data must be a multiple of 8 bytes and will be encrypted
+ with the already specified key. Data does not have to be a
+ multiple of 8 bytes if the padding character is supplied, or
+ the padmode is set to PAD_PKCS5, as bytes will then added to
+ ensure the be padded data is a multiple of 8 bytes.
+ """
+ ENCRYPT = des.ENCRYPT
+ DECRYPT = des.DECRYPT
+ data = self._guardAgainstUnicode(data)
+ if pad is not None:
+ pad = self._guardAgainstUnicode(pad)
+ # Pad the data accordingly.
+ data = self._padData(data, pad, padmode)
+ if self.getMode() == CBC:
+ self.__key1.setIV(self.getIV())
+ self.__key2.setIV(self.getIV())
+ self.__key3.setIV(self.getIV())
+ i = 0
+ result = []
+ while i < len(data):
+ block = self.__key1.crypt(data[i:i+8], ENCRYPT)
+ block = self.__key2.crypt(block, DECRYPT)
+ block = self.__key3.crypt(block, ENCRYPT)
+ self.__key1.setIV(block)
+ self.__key2.setIV(block)
+ self.__key3.setIV(block)
+ result.append(block)
+ i += 8
+ if _pythonMajorVersion < 3:
+ return ''.join(result)
+ else:
+ return bytes.fromhex('').join(result)
+ else:
+ data = self.__key1.crypt(data, ENCRYPT)
+ data = self.__key2.crypt(data, DECRYPT)
+ return self.__key3.crypt(data, ENCRYPT)
+
+ def decrypt(self, data, pad=None, padmode=None):
+ """decrypt(data, [pad], [padmode]) -> bytes
+
+ data : bytes to be encrypted
+ pad : Optional argument for decryption padding. Must only be one byte
+ padmode : Optional argument for overriding the padding mode.
+
+ The data must be a multiple of 8 bytes and will be decrypted
+ with the already specified key. In PAD_NORMAL mode, if the
+ optional padding character is supplied, then the un-encrypted
+ data will have the padding characters removed from the end of
+ the bytes. This pad removal only occurs on the last 8 bytes of
+ the data (last data block). In PAD_PKCS5 mode, the special
+ padding end markers will be removed from the data after
+ decrypting, no pad character is required for PAD_PKCS5.
+ """
+ ENCRYPT = des.ENCRYPT
+ DECRYPT = des.DECRYPT
+ data = self._guardAgainstUnicode(data)
+ if pad is not None:
+ pad = self._guardAgainstUnicode(pad)
+ if self.getMode() == CBC:
+ self.__key1.setIV(self.getIV())
+ self.__key2.setIV(self.getIV())
+ self.__key3.setIV(self.getIV())
+ i = 0
+ result = []
+ while i < len(data):
+ iv = data[i:i+8]
+ block = self.__key3.crypt(iv, DECRYPT)
+ block = self.__key2.crypt(block, ENCRYPT)
+ block = self.__key1.crypt(block, DECRYPT)
+ self.__key1.setIV(iv)
+ self.__key2.setIV(iv)
+ self.__key3.setIV(iv)
+ result.append(block)
+ i += 8
+ if _pythonMajorVersion < 3:
+ data = ''.join(result)
+ else:
+ data = bytes.fromhex('').join(result)
+ else:
+ data = self.__key3.crypt(data, DECRYPT)
+ data = self.__key2.crypt(data, ENCRYPT)
+ data = self.__key1.crypt(data, DECRYPT)
+ return self._unpadData(data, pad, padmode)
View
661 vncdotool/rfb.py
@@ -0,0 +1,661 @@
+"""
+RFB protocol implementattion, client side.
+
+Override RFBClient and RFBFactory in your application.
+See vncviewer.py for an example.
+
+Reference:
+http://www.realvnc.com/docs/rfbproto.pdf
+
+(C) 2003 cliechti@gmx.net
+
+MIT License
+"""
+
+import sys
+from struct import pack, unpack
+import pyDes
+from twisted.python import usage, log
+from twisted.internet.protocol import Factory, Protocol
+from twisted.internet import protocol
+from twisted.application import internet, service
+
+#~ from twisted.internet import reactor
+
+
+#encoding-type
+#for SetEncodings()
+RAW_ENCODING = 0
+COPY_RECTANGLE_ENCODING = 1
+RRE_ENCODING = 2
+CORRE_ENCODING = 4
+HEXTILE_ENCODING = 5
+ZLIB_ENCODING = 6
+TIGHT_ENCODING = 7
+ZLIBHEX_ENCODING = 8
+ZRLE_ENCODING = 16
+#0xffffff00 to 0xffffffff tight options
+
+#keycodes
+#for KeyEvent()
+KEY_BackSpace = 0xff08
+KEY_Tab = 0xff09
+KEY_Return = 0xff0d
+KEY_Escape = 0xff1b
+KEY_Insert = 0xff63
+KEY_Delete = 0xffff
+KEY_Home = 0xff50
+KEY_End = 0xff57
+KEY_PageUp = 0xff55
+KEY_PageDown = 0xff56
+KEY_Left = 0xff51
+KEY_Up = 0xff52
+KEY_Right = 0xff53
+KEY_Down = 0xff54
+KEY_F1 = 0xffbe
+KEY_F2 = 0xffbf
+KEY_F3 = 0xffc0
+KEY_F4 = 0xffc1
+KEY_F5 = 0xffc2
+KEY_F6 = 0xffc3
+KEY_F7 = 0xffc4
+KEY_F8 = 0xffc5
+KEY_F9 = 0xffc6
+KEY_F10 = 0xffc7
+KEY_F11 = 0xffc8
+KEY_F12 = 0xffc9
+KEY_F13 = 0xFFCA
+KEY_F14 = 0xFFCB
+KEY_F15 = 0xFFCC
+KEY_F16 = 0xFFCD
+KEY_F17 = 0xFFCE
+KEY_F18 = 0xFFCF
+KEY_F19 = 0xFFD0
+KEY_F20 = 0xFFD1
+KEY_ShiftLeft = 0xffe1
+KEY_ShiftRight = 0xffe2
+KEY_ControlLeft = 0xffe3
+KEY_ControlRight = 0xffe4
+KEY_MetaLeft = 0xffe7
+KEY_MetaRight = 0xffe8
+KEY_AltLeft = 0xffe9
+KEY_AltRight = 0xffea
+
+KEY_Scroll_Lock = 0xFF14
+KEY_Sys_Req = 0xFF15
+KEY_Num_Lock = 0xFF7F
+KEY_Caps_Lock = 0xFFE5
+KEY_Pause = 0xFF13
+KEY_Super_L = 0xFFEB
+KEY_Super_R = 0xFFEC
+KEY_Hyper_L = 0xFFED
+KEY_Hyper_R = 0xFFEE
+
+KEY_KP_0 = 0xFFB0
+KEY_KP_1 = 0xFFB1
+KEY_KP_2 = 0xFFB2
+KEY_KP_3 = 0xFFB3
+KEY_KP_4 = 0xFFB4
+KEY_KP_5 = 0xFFB5
+KEY_KP_6 = 0xFFB6
+KEY_KP_7 = 0xFFB7
+KEY_KP_8 = 0xFFB8
+KEY_KP_9 = 0xFFB9
+KEY_KP_Enter = 0xFF8D
+
+class RFBClient(Protocol):
+
+ def __init__(self):
+ self._packet = []
+ self._packet_len = 0
+ self._handler = self._handleInitial
+ self._already_expecting = 0
+
+ #------------------------------------------------------
+ # states used on connection startup
+ #------------------------------------------------------
+
+ def _handleInitial(self):
+ buffer = ''.join(self._packet)
+ if '\n' in buffer:
+ if buffer[:3] == 'RFB':
+ #~ print "rfb"
+ maj, min = [int(x) for x in buffer[3:-1].split('.')]
+ #~ print maj, min
+ if (maj, min) not in [(3,3), (3,7), (3,8)]:
+ log.msg("wrong protocol version\n")
+ self.transport.loseConnection()
+ buffer = buffer[12:]
+ self.transport.write('RFB 003.003\n')
+ log.msg("connected\n")
+ self._packet[:] = [buffer]
+ self._packet_len = len(buffer)
+ self._handler = self._handleExpected
+ self.expect(self._handleAuth, 4)
+ else:
+ self._packet[:] = [buffer]
+ self._packet_len = len(buffer)
+
+ def _handleAuth(self, block):
+ (auth,) = unpack("!I", block)
+ #~ print "auth:", auth
+ if auth == 0:
+ self.expect(self._handleConnFailed, 4)
+ elif auth == 1:
+ self._doClientInitialization()
+ return
+ elif auth == 2:
+ self.expect(self._handleVNCAuth, 16)
+ else:
+ log.msg("unknown auth response (%d)\n" % auth)
+
+ def _handleConnFailed(self):
+ (waitfor,) = unpack("!I", block)
+ self.expect(self._handleConnMessage, waitfor)
+
+ def _handleConnMessage(self, block):
+ log.msg("Connection refused: %r\n" % block)
+
+ def _handleVNCAuth(self, block):
+ self._challenge = block
+ self.vncRequestPassword()
+ self.expect(self._handleVNCAuthResult, 4)
+
+ def sendPassword(self, password):
+ """send password"""
+ pw = (password + '\0' * 8)[:8] #make sure its 8 chars long, zero padded
+ des = RFBDes(pw)
+ response = des.encrypt(self._challenge)
+ self.transport.write(response)
+
+ def _handleVNCAuthResult(self, block):
+ (result,) = unpack("!I", block)
+ #~ print "auth:", auth
+ if result == 0: #OK
+ self._doClientInitialization()
+ return
+ elif result == 1: #failed
+ self.vncAuthFailed("autenthication failed")
+ self.transport.loseConnection()
+ elif result == 2: #too many
+ slef.vncAuthFailed("too many tries to log in")
+ self.transport.loseConnection()
+ else:
+ log.msg("unknown auth response (%d)\n" % auth)
+
+ def _doClientInitialization(self):
+ self.transport.write(pack("!B", self.factory.shared))
+ self.expect(self._handleServerInit, 24)
+
+ def _handleServerInit(self, block):
+ (self.width, self.height, pixformat, namelen) = unpack("!HH16sI", block)
+ (self.bpp, self.depth, self.bigendian, self.truecolor,
+ self.redmax, self.greenmax, self.bluemax,
+ self.redshift, self.greenshift, self.blueshift) = \
+ unpack("!BBBBHHHBBBxxx", pixformat)
+ self.bypp = self.bpp / 8 #calc bytes per pixel
+ self.expect(self._handleServerName, namelen)
+
+ def _handleServerName(self, block):
+ self.name = block
+ #callback:
+ self.vncConnectionMade()
+ self.expect(self._handleConnection, 1)
+
+ #------------------------------------------------------
+ # Server to client messages
+ #------------------------------------------------------
+ def _handleConnection(self, block):
+ (msgid,) = unpack("!B", block)
+ if msgid == 0:
+ self.expect(self._handleFramebufferUpdate, 3)
+ elif msgid == 2:
+ self.bell()
+ self.expect(self._handleConnection, 1)
+ elif msgid == 3:
+ self.expect(self._handleServerCutText, 7)
+ else:
+ log.msg("unknown message received (id %d)\n" % msgid)
+ self.expect(self._handleConnection, 1)
+
+ def _handleFramebufferUpdate(self, block):
+ (self.rectangles,) = unpack("!xH", block)
+ self.rectanglePos = []
+ self.beginUpdate()
+ self._doConnection()
+
+ def _doConnection(self):
+ if self.rectangles:
+ self.expect(self._handleRectangle, 12)
+ else:
+ self.commitUpdate(self.rectanglePos)
+ self.expect(self._handleConnection, 1)
+
+ def _handleRectangle(self, block):
+ (x, y, width, height, encoding) = unpack("!HHHHI", block)
+ if self.rectangles:
+ self.rectangles -= 1
+ self.rectanglePos.append( (x, y, width, height) )
+ if encoding == COPY_RECTANGLE_ENCODING:
+ self.expect(self._handleDecodeCopyrect, 4, x, y, width, height)
+ elif encoding == RAW_ENCODING:
+ self.expect(self._handleDecodeRAW, width*height*self.bypp, x, y, width, height)
+ elif encoding == HEXTILE_ENCODING:
+ self._doNextHextileSubrect(None, None, x, y, width, height, None, None)
+ elif encoding == CORRE_ENCODING:
+ self.expect(self._handleDecodeCORRE, 4 + self.bypp, x, y, width, height)
+ elif encoding == RRE_ENCODING:
+ self.expect(self._handleDecodeRRE, 4 + self.bypp, x, y, width, height)
+ #~ elif encoding == ZRLE_ENCODING:
+ #~ self.expect(self._handleDecodeZRLE, )
+ else:
+ log.msg("unknown encoding received (encoding %d)\n" % encoding)
+ self._doConnection()
+ else:
+ self._doConnection()
+
+ # --- RAW Encoding
+
+ def _handleDecodeRAW(self, block, x, y, width, height):
+ #TODO convert pixel format?
+ self.updateRectangle(x, y, width, height, block)
+ self._doConnection()
+
+ # --- CopyRect Encoding
+
+ def _handleDecodeCopyrect(self, block, x, y, width, height):
+ (srcx, srcy) = unpack("!HH", block)
+ self.copyRectangle(srcx, srcy, x, y, width, height)
+ self._doConnection()
+
+ # --- RRE Encoding
+
+ def _handleDecodeRRE(self, block, x, y, width, height):
+ (subrects,) = unpack("!I", block[:4])
+ color = block[4:]
+ self.fillRectangle(x, y, width, height, color)
+ if subrects:
+ self.expect(self._handleRRESubRectangles, (8 + self.bypp) * subrects, x, y)
+ else:
+ self._doConnection()
+
+ def _handleRRESubRectangles(self, block, topx, topy):
+ #~ print "_handleRRESubRectangle"
+ pos = 0
+ end = len(block)
+ sz = self.bypp + 8
+ format = "!%dsHHHH" % self.bypp
+ while pos < end:
+ (color, x, y, width, height) = unpack(format, block[pos:pos+sz])
+ self.fillRectangle(topx + x, topy + y, width, height, color)
+ pos += sz
+ self._doConnection()
+
+ # --- CoRRE Encoding
+
+ def _handleDecodeCORRE(self, block, x, y, width, height):
+ (subrects,) = unpack("!I", block[:4])
+ color = block[4:]
+ self.fillRectangle(x, y, width, height, color)
+ if subrects:
+ self.expect(self._handleDecodeCORRERectangles, (4 + self.bypp)*subrects, x, y)
+ else:
+ self._doConnection()
+
+ def _handleDecodeCORRERectangles(self, block, topx, topy):
+ #~ print "_handleDecodeCORRERectangle"
+ pos = 0
+ end = len(block)
+ sz = self.bypp + 4
+ format = "!%dsBBBB" % self.bypp
+ while pos < sz:
+ (color, x, y, width, height) = unpack(format, block[pos:pos+sz])
+ self.fillRectangle(topx + x, topy + y, width, height, color)
+ pos += sz
+ self._doConnection()
+
+ # --- Hexile Encoding
+
+ def _doNextHextileSubrect(self, bg, color, x, y, width, height, tx, ty):
+ #~ print "_doNextHextileSubrect %r" % ((color, x, y, width, height, tx, ty), )
+ #coords of next tile
+ #its line after line of tiles
+ #finished when the last line is completly received
+
+ #dont inc the first time
+ if tx is not None:
+ #calc next subrect pos
+ tx += 16
+ if tx >= x + width:
+ tx = x
+ ty += 16
+ else:
+ tx = x
+ ty = y
+ #more tiles?
+ if ty >= y + height:
+ self._doConnection()
+ else:
+ self.expect(self._handleDecodeHextile, 1, bg, color, x, y, width, height, tx, ty)
+
+ def _handleDecodeHextile(self, block, bg, color, x, y, width, height, tx, ty):
+ (subencoding,) = unpack("!B", block)
+ #calc tile size
+ tw = th = 16
+ if x + width - tx < 16: tw = x + width - tx
+ if y + height - ty < 16: th = y + height- ty
+ #decode tile
+ if subencoding & 1: #RAW
+ self.expect(self._handleDecodeHextileRAW, tw*th*self.bypp, bg, color, x, y, width, height, tx, ty, tw, th)
+ else:
+ numbytes = 0
+ if subencoding & 2: #BackgroundSpecified
+ numbytes += self.bypp
+ if subencoding & 4: #ForegroundSpecified
+ numbytes += self.bypp
+ if subencoding & 8: #AnySubrects
+ numbytes += 1
+ if numbytes:
+ self.expect(self._handleDecodeHextileSubrect, numbytes, subencoding, bg, color, x, y, width, height, tx, ty, tw, th)
+ else:
+ self.fillRectangle(tx, ty, tw, th, bg)
+ self._doNextHextileSubrect(bg, color, x, y, width, height, tx, ty)
+
+ def _handleDecodeHextileSubrect(self, block, subencoding, bg, color, x, y, width, height, tx, ty, tw, th):
+ subrects = 0
+ pos = 0
+ if subencoding & 2: #BackgroundSpecified
+ bg = block[:self.bypp]
+ pos += self.bypp
+ self.fillRectangle(tx, ty, tw, th, bg)
+ if subencoding & 4: #ForegroundSpecified
+ color = block[pos:pos+self.bypp]
+ pos += self.bypp
+ if subencoding & 8: #AnySubrects
+ #~ (subrects, ) = unpack("!B", block)
+ subrects = ord(block[pos])
+ #~ print subrects
+ if subrects:
+ if subencoding & 16: #SubrectsColoured
+ self.expect(self._handleDecodeHextileSubrectsColoured, (self.bypp + 2)*subrects, bg, color, subrects, x, y, width, height, tx, ty, tw, th)
+ else:
+ self.expect(self._handleDecodeHextileSubrectsFG, 2*subrects, bg, color, subrects, x, y, width, height, tx, ty, tw, th)
+ else:
+ self._doNextHextileSubrect(bg, color, x, y, width, height, tx, ty)
+
+
+ def _handleDecodeHextileRAW(self, block, bg, color, x, y, width, height, tx, ty, tw, th):
+ """the tile is in raw encoding"""
+ self.updateRectangle(tx, ty, tw, th, block)
+ self._doNextHextileSubrect(bg, color, x, y, width, height, tx, ty)
+
+ def _handleDecodeHextileSubrectsColoured(self, block, bg, color, subrects, x, y, width, height, tx, ty, tw, th):
+ """subrects with their own color"""
+ sz = self.bypp + 2
+ pos = 0
+ end = len(block)
+ while pos < end:
+ pos2 = pos + self.bypp
+ color = block[pos:pos2]
+ xy = ord(block[pos2])
+ wh = ord(block[pos2+1])
+ sx = xy >> 4
+ sy = xy & 0xf
+ sw = (wh >> 4) + 1
+ sh = (wh & 0xf) + 1
+ self.fillRectangle(tx + sx, ty + sy, sw, sh, color)
+ pos += sz
+ self._doNextHextileSubrect(bg, color, x, y, width, height, tx, ty)
+
+ def _handleDecodeHextileSubrectsFG(self, block, bg, color, subrects, x, y, width, height, tx, ty, tw, th):
+ """all subrect with same color"""
+ pos = 0
+ end = len(block)
+ while pos < end:
+ xy = ord(block[pos])
+ wh = ord(block[pos+1])
+ sx = xy >> 4
+ sy = xy & 0xf
+ sw = (wh >> 4) + 1
+ sh = (wh & 0xf) + 1
+ self.fillRectangle(tx + sx, ty + sy, sw, sh, color)
+ pos += 2
+ self._doNextHextileSubrect(bg, color, x, y, width, height, tx, ty)
+
+
+ # --- ZRLE Encoding
+
+ def _handleDecodeZRLE(self, block):
+ raise NotImplementedError
+
+ # --- other server messages
+
+ def _handleServerCutText(self, block):
+ (length, ) = unpack("!xxxI", block)
+ self.expect(self._handleServerCutTextValue, length)
+
+ def _handleServerCutTextValue(self, block):
+ self.copy_text(block)
+ self.expect(self._handleConnection, 1)
+
+ #------------------------------------------------------
+ # incomming data redirector
+ #------------------------------------------------------
+ def dataReceived(self, data):
+ #~ sys.stdout.write(repr(data) + '\n')
+ #~ print len(data), ", ", len(self._packet)
+ self._packet.append(data)
+ self._packet_len += len(data)
+ self._handler()
+
+ def _handleExpected(self):
+ if self._packet_len >= self._expected_len:
+ buffer = ''.join(self._packet)
+ while len(buffer) >= self._expected_len:
+ self._already_expecting = 1
+ block, buffer = buffer[:self._expected_len], buffer[self._expected_len:]
+ #~ log.msg("handle %r with %r\n" % (block, self._expected_handler.__name__))
+ self._expected_handler(block, *self._expected_args, **self._expected_kwargs)
+ self._packet[:] = [buffer]
+ self._packet_len = len(buffer)
+ self._already_expecting = 0
+
+ def expect(self, handler, size, *args, **kwargs):
+ #~ log.msg("expect(%r, %r, %r, %r)\n" % (handler.__name__, size, args, kwargs))
+ self._expected_handler = handler
+ self._expected_len = size
+ self._expected_args = args
+ self._expected_kwargs = kwargs
+ if not self._already_expecting:
+ self._handleExpected() #just in case that there is already enough data
+
+ #------------------------------------------------------
+ # client -> server messages
+ #------------------------------------------------------
+
+ def setPixelFormat(self, bpp=32, depth=24, bigendian=0, truecolor=1, redmax=255, greenmax=255, bluemax=255, redshift=0, greenshift=8, blueshift=16):
+ pixformat = pack("!BBBBHHHBBBxxx", bpp, depth, bigendian, truecolor, redmax, greenmax, bluemax, redshift, greenshift, blueshift)
+ self.transport.write(pack("!Bxxx16s", 0, pixformat))
+ #rember these settings
+ self.bpp, self.depth, self.bigendian, self.truecolor = bpp, depth, bigendian, truecolor
+ self.redmax, self.greenmax, self.bluemax = redmax, greenmax, bluemax
+ self.redshift, self.greenshift, self.blueshift = redshift, greenshift, blueshift
+ self.bypp = self.bpp / 8 #calc bytes per pixel
+ #~ print self.bypp
+
+ def setEncodings(self, list_of_encodings):
+ self.transport.write(pack("!BxH", 2, len(list_of_encodings)))
+ for encoding in list_of_encodings:
+ self.transport.write(pack("!I", encoding))
+
+ def framebufferUpdateRequest(self, x=0, y=0, width=None, height=None, incremental=0):
+ if width is None: width = self.width - x
+ if height is None: height = self.height - y
+ self.transport.write(pack("!BBHHHH", 3, incremental, x, y, width, height))
+
+ def keyEvent(self, key, down=1):
+ """For most ordinary keys, the "keysym" is the same as the corresponding ASCII value.
+ Other common keys are shown in the KEY_ constants."""
+ self.transport.write(pack("!BBxxI", 4, down, key))
+
+ def pointerEvent(self, x, y, buttonmask=0):
+ """Indicates either pointer movement or a pointer button press or release. The pointer is
+ now at (x-position, y-position), and the current state of buttons 1 to 8 are represented
+ by bits 0 to 7 of button-mask respectively, 0 meaning up, 1 meaning down (pressed).
+ """
+ self.transport.write(pack("!BBHH", 5, buttonmask, x, y))
+
+ def clientCutText(self, message):
+ """The client has new ASCII text in its cut buffer.
+ (aka clipboard)
+ """
+ self.transport.write(pack("!BxxxI", 6, len(message)) + message)
+
+ #------------------------------------------------------
+ # callbacks
+ # override these in your application
+ #------------------------------------------------------
+ def vncConnectionMade(self):
+ """connection is initialized and ready.
+ typicaly, the pixel format is set here."""
+
+ def vncRequestPassword(self):
+ """a password is needed to log on, use sendPassword() to
+ send one."""
+ if self.factory.password is None:
+ log.msg("need a password\n")
+ self.transport.loseConnection()
+ return
+ self.sendPassword(self.factory.password)
+
+ def vncAuthFailed(self, reason):
+ """called when the authentication failed.
+ the connection is closed."""
+ log.msg("Cannot connect: %s\n" % reason)
+
+ def beginUpdate(self):
+ """called before a series of updateRectangle(),
+ copyRectangle() or fillRectangle()."""
+
+ def commitUpdate(self, rectangles=None):
+ """called after a series of updateRectangle(), copyRectangle()
+ or fillRectangle() are finished.
+ typicaly, here is the place to request the next screen
+ update with FramebufferUpdateRequest(incremental=1).
+ argument is a list of tuples (x,y,w,h) with the updated
+ rectangles."""
+
+ def updateRectangle(self, x, y, width, height, data):
+ """new bitmap data. data is a string in the pixel format set
+ up earlier."""
+
+ def copyRectangle(self, srcx, srcy, x, y, width, height):
+ """used for copyrect encoding. copy the given rectangle
+ (src, srxy, width, height) to the target coords (x,y)"""
+
+ def fillRectangle(self, x, y, width, height, color):
+ """fill the area with the color. the color is a string in
+ the pixel format set up earlier"""
+ #fallback variant, use update recatngle
+ #override with specialized function for better performance
+ self.updateRectangle(x, y, width, height, color*width*height)
+
+ def bell(self):
+ """bell"""
+
+ def copy_text(self, text):
+ """The server has new ASCII text in its cut buffer.
+ (aka clipboard)"""
+
+class RFBFactory(protocol.ClientFactory):
+ """A factory for remote frame buffer connections."""
+
+ # the class of the protocol to build
+ # should be overriden by application to use a derrived class
+ protocol = RFBClient
+
+ def __init__(self, password = None, shared = 0):
+ self.password = password
+ self.shared = shared
+
+class RFBDes(pyDes.des):
+ def setKey(self, key):
+ """RFB protocol for authentication requires client to encrypt
+ challenge sent by server with password using DES method. However,
+ bits in each byte of the password are put in reverse order before
+ using it as encryption key."""
+ newkey = []
+ for ki in range(len(key)):
+ bsrc = ord(key[ki])
+ btgt = 0
+ for i in range(8):
+ if bsrc & (1 << i):
+ btgt = btgt | (1 << 7-i)
+ newkey.append(chr(btgt))
+ super(RFBDes, self).setKey(newkey)
+
+
+# --- test code only, see vncviewer.py
+
+if __name__ == '__main__':
+ class RFBTest(RFBClient):
+ """dummy client"""
+ def vncConnectionMade(self):
+ print "Screen format: depth=%d bytes_per_pixel=%r" % (self.depth, self.bpp)
+ print "Desktop name: %r" % self.name
+ self.SetEncodings([RAW_ENCODING])
+ self.FramebufferUpdateRequest()
+
+ def updateRectangle(self, x, y, width, height, data):
+ print "%s " * 5 % (x, y, width, height, repr(data[:20]))
+
+ class RFBTestFactory(protocol.ClientFactory):
+ """test factory"""
+ protocol = RFBTest
+ def clientConnectionLost(self, connector, reason):
+ print reason
+ from twisted.internet import reactor
+ reactor.stop()
+ #~ connector.connect()
+
+ def clientConnectionFailed(self, connector, reason):
+ print "connection failed:", reason
+ from twisted.internet import reactor
+ reactor.stop()
+
+ class Options(usage.Options):
+ """command line options"""
+ optParameters = [
+ ['display', 'd', '0', 'VNC display'],
+ ['host', 'h', 'localhost', 'remote hostname'],
+ ['outfile', 'o', None, 'Logfile [default: sys.stdout]'],
+ ]
+
+ o = Options()
+ try:
+ o.parseOptions()
+ except usage.UsageError, errortext:
+ print "%s: %s" % (sys.argv[0], errortext)
+ print "%s: Try --help for usage details." % (sys.argv[0])
+ raise SystemExit, 1
+
+ logFile = sys.stdout
+ if o.opts['outfile']:
+ logFile = o.opts['outfile']
+ log.startLogging(logFile)
+
+ host = o.opts['host']
+ port = int(o.opts['display']) + 5900
+
+ application = service.Application("rfb test") # create Application
+
+ # connect to this host and port, and reconnect if we get disconnected
+ vncClient = internet.TCPClient(host, port, RFBFactory()) # create the service
+ vncClient.setServiceParent(application)
+
+ # this file should be run as 'twistd -y rfb.py' but it didn't work -
+ # could't import crippled_des.py, so using this hack.
+ # now with crippled_des.py replaced with pyDes this can be no more actual
+ from twisted.internet import reactor
+ vncClient.startService()
+ reactor.run()
Please sign in to comment.
Something went wrong with that request. Please try again.