Merge remote-tracking branch 'kali/bug/allow-absolute-paths2' into develop
authorTomás Touceda <chiiph@leap.se>
Tue, 28 May 2013 20:38:30 +0000 (17:38 -0300)
committerTomás Touceda <chiiph@leap.se>
Tue, 28 May 2013 20:38:30 +0000 (17:38 -0300)
1  2 
src/leap/common/crypto.py
src/leap/common/events/component.py
src/leap/common/events/server.py

  # You should have received a copy of the GNU General Public License
  # along with this program. If not, see <http://www.gnu.org/licenses/>.
  
 +import os
 +import binascii
  
  from Crypto.Cipher import AES
 -from Crypto.Random import random
  from Crypto.Util import Counter
  from leap.common.check import leap_assert, leap_assert_type
  
 -
  #
  # encryption methods
  #
@@@ -53,15 -53,15 +53,15 @@@ def encrypt_sym(data, key, method=Encry
      """
      Encrypt C{data} with C{key}, using C{method} encryption method.
  
-     @param data: The data to be encrypted.
-     @type data: str
-     @param key: The key used to encrypt C{data} (must be 256 bits long).
-     @type key: str
-     @param method: The encryption method to use.
-     @type method: str
-     @return: A tuple with the initial value and the encrypted data.
-     @rtype: (long, str)
+     :param data: The data to be encrypted.
+     :type data: str
+     :param key: The key used to encrypt C{data} (must be 256 bits long).
+     :type key: str
+     :param method: The encryption method to use.
+     :type method: str
+     :return: A tuple with the initial value and the encrypted data.
+     :rtype: (long, str)
      """
      leap_assert_type(key, str)
  
          leap_assert(
              len(key) == 32,  # 32 x 8 = 256 bits.
              'Wrong key size: %s bits (must be 256 bits long).' % (len(key)*8))
 -        iv = random.getrandbits(256)
 -        ctr = Counter.new(128, initial_value=iv)
 +        iv = os.urandom(8)
 +        ctr = Counter.new(64, prefix=iv)
          cipher = AES.new(key=key, mode=AES.MODE_CTR, counter=ctr)
 -        return iv, cipher.encrypt(data)
 +        return binascii.b2a_base64(iv), cipher.encrypt(data)
  
      # raise if method is unknown
      raise UnknownEncryptionMethod('Unkwnown method: %s' % method)
@@@ -83,17 -83,17 +83,17 @@@ def decrypt_sym(data, key, method=Encry
      """
      Decrypt C{data} with C{key} using C{method} encryption method.
  
-     @param data: The data to be decrypted.
-     @type data: str
-     @param key: The key used to decrypt C{data} (must be 256 bits long).
-     @type key: str
-     @param method: The encryption method to use.
-     @type method: str
-     @param kwargs: Other parameters specific to each encryption method.
-     @type kwargs: dict
-     @return: The decrypted data.
-     @rtype: str
+     :param data: The data to be decrypted.
+     :type data: str
+     :param key: The key used to decrypt C{data} (must be 256 bits long).
+     :type key: str
+     :param method: The encryption method to use.
+     :type method: str
+     :param kwargs: Other parameters specific to each encryption method.
+     :type kwargs: dict
+     :return: The decrypted data.
+     :rtype: str
      """
      leap_assert_type(key, str)
  
          leap_assert(
              'iv' in kwargs,
              'AES-256-CTR needs an initial value given as.')
 -        ctr = Counter.new(128, initial_value=kwargs['iv'])
 -        cipher = AES.new(keyAES.MODE_CTR, counter=ctr)
 +        ctr = Counter.new(64, prefix=binascii.a2b_base64(kwargs['iv']))
 +        cipher = AES.new(key=key, mode=AES.MODE_CTR, counter=ctr)
          return cipher.decrypt(data)
  
      # raise if method is unknown
@@@ -63,8 -63,8 +63,8 @@@ def ensure_component_daemon()
      Ensure the component daemon is running and listening for incoming
      messages.
  
-     @return: the daemon instance
-     @rtype: EventsComponentDaemon
+     :return: the daemon instance
+     :rtype: EventsComponentDaemon
      """
      import time
      daemon = EventsComponentDaemon.ensure(0)
@@@ -91,28 -91,28 +91,28 @@@ def register(signal, callback, uid=None
      returned for a synch request but nothing will be returned for an asynch
      request.
  
-     @param signal: the signal that causes the callback to be launched
-     @type signal: int (see the `events.proto` file)
-     @param callback: the callback to be called when the signal is received
-     @type callback: function
+     :param signal: the signal that causes the callback to be launched
+     :type signal: int (see the `events.proto` file)
+     :param callback: the callback to be called when the signal is received
+     :type callback: function
          callback(leap.common.events.events_pb2.SignalRequest)
-     @param uid: a unique id for the callback
-     @type uid: int
-     @param replace: should an existent callback with same uid be replaced?
-     @type replace: bool
-     @param reqcbk: a callback to be called when a response from server is
+     :param uid: a unique id for the callback
+     :type uid: int
+     :param replace: should an existent callback with same uid be replaced?
+     :type replace: bool
+     :param reqcbk: a callback to be called when a response from server is
          received
-     @type reqcbk: function
+     :type reqcbk: function
          callback(leap.common.events.events_pb2.EventResponse)
-     @param timeout: the timeout for synch calls
-     @type timeout: int
+     :param timeout: the timeout for synch calls
+     :type timeout: int
  
      Might raise a CallbackAlreadyRegistered exception if there's already a
      callback identified by the given uid and replace is False.
  
-     @return: the response from server for synch calls or nothing for asynch
+     :return: the response from server for synch calls or nothing for asynch
          calls
-     @rtype: leap.common.events.events_pb2.EventsResponse or None
+     :rtype: leap.common.events.events_pb2.EventsResponse or None
      """
      ensure_component_daemon()  # so we can receive registered signals
      # register callback locally
      logger.info(
          "Sending registration request to server on port %s: %s",
          server.SERVER_PORT,
 -        str(request))
 +        str(request)[:40])
      return service.register(request, callback=reqcbk, timeout=timeout)
  
  
@@@ -152,24 -152,24 +152,24 @@@ def signal(signal, content="", mac_meth
      returned for a synch request but nothing will be returned for an asynch
      request.
  
-     @param signal: the signal that causes the callback to be launched
-     @type signal: int (see the `events.proto` file)
-     @param content: the contents of the event signal
-     @type content: str
-     @param mac_method: the method used for auth mac
-     @type mac_method: str
-     @param mac: the content of the auth mac
-     @type mac: str
-     @param reqcbk: a callback to be called when a response from server is
+     :param signal: the signal that causes the callback to be launched
+     :type signal: int (see the `events.proto` file)
+     :param content: the contents of the event signal
+     :type content: str
+     :param mac_method: the method used for auth mac
+     :type mac_method: str
+     :param mac: the content of the auth mac
+     :type mac: str
+     :param reqcbk: a callback to be called when a response from server is
          received
-     @type reqcbk: function
+     :type reqcbk: function
          callback(leap.common.events.events_pb2.EventResponse)
-     @param timeout: the timeout for synch calls
-     @type timeout: int
+     :param timeout: the timeout for synch calls
+     :type timeout: int
  
-     @return: the response from server for synch calls or nothing for asynch
+     :return: the response from server for synch calls or nothing for asynch
          calls
-     @rtype: leap.common.events.events_pb2.EventsResponse or None
+     :rtype: leap.common.events.events_pb2.EventsResponse or None
      """
      request = proto.SignalRequest()
      request.event = signal
      request.mac = mac
      service = RpcService(proto.EventsServerService_Stub, server.SERVER_PORT,
                           'localhost')
 -    logger.info("Sending signal to server: %s", str(request))
 +    logger.info("Sending signal to server: %s", str(request)[:40])
      return service.signal(request, callback=reqcbk, timeout=timeout)
  
  
@@@ -197,14 -197,14 +197,14 @@@ class EventsComponentService(proto.Even
          This method is called whenever a signal request is received from
          server.
  
-         @param controller: used to mediate a single method call
-         @type controller: protobuf.socketrpc.controller.SocketRpcController
-         @param request: the request received from the component
-         @type request: leap.common.events.events_pb2.SignalRequest
-         @param done: callback to be called when done
-         @type done: protobuf.socketrpc.server.Callback
+         :param controller: used to mediate a single method call
+         :type controller: protobuf.socketrpc.controller.SocketRpcController
+         :param request: the request received from the component
+         :type request: leap.common.events.events_pb2.SignalRequest
+         :param done: callback to be called when done
+         :type done: protobuf.socketrpc.server.Callback
          """
 -        logger.info('Received signal from server: %s' % str(request))
 +        logger.info('Received signal from server: %s...' % str(request)[:40])
  
          # run registered callbacks
          # TODO: verify authentication using mac in incoming message
@@@ -230,10 -230,10 +230,10 @@@ class EventsComponentDaemon(daemon.Even
          """
          Make sure the daemon is running on the given port.
  
-         @param port: the port in which the daemon should listen
-         @type port: int
+         :param port: the port in which the daemon should listen
+         :type port: int
  
-         @return: a daemon instance
-         @rtype: EventsComponentDaemon
+         :return: a daemon instance
+         :rtype: EventsComponentDaemon
          """
          return cls.ensure_service(port, EventsComponentService())
@@@ -55,11 -55,11 +55,11 @@@ def ensure_server(port=SERVER_PORT)
      Attempt to connect to given local port. Upon success, assume that the
      events server has already been started. Upon failure, start events server.
  
-     @param port: the port in which server should be listening
-     @type port: int
+     :param port: the port in which server should be listening
+     :type port: int
  
-     @return: the daemon instance or nothing
-     @rtype: EventsServerDaemon or None
+     :return: the daemon instance or nothing
+     :rtype: EventsServerDaemon or None
      """
      try:
          s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@@@ -81,14 -81,14 +81,14 @@@ class EventsServerService(proto.EventsS
          """
          Register a component port to be signaled when specific events come in.
  
-         @param controller: used to mediate a single method call
-         @type controller: protobuf.socketrpc.controller.SocketRpcController
-         @param request: the request received from the component
-         @type request: leap.common.events.events_pb2.RegisterRequest
-         @param done: callback to be called when done
-         @type done: protobuf.socketrpc.server.Callback
+         :param controller: used to mediate a single method call
+         :type controller: protobuf.socketrpc.controller.SocketRpcController
+         :param request: the request received from the component
+         :type request: leap.common.events.events_pb2.RegisterRequest
+         :param done: callback to be called when done
+         :type done: protobuf.socketrpc.server.Callback
          """
 -        logger.info("Received registration request: %s" % str(request))
 +        logger.info("Received registration request: %s..." % str(request)[:40])
          # add component port to signal list
          if request.event not in registered_components:
              registered_components[request.event] = set([])
          Perform an RPC call to signal all components registered to receive a
          specific signal.
  
-         @param controller: used to mediate a single method call
-         @type controller: protobuf.socketrpc.controller.SocketRpcController
-         @param request: the request received from the component
-         @type request: leap.common.events.events_pb2.SignalRequest
-         @param done: callback to be called when done
-         @type done: protobuf.socketrpc.server.Callback
+         :param controller: used to mediate a single method call
+         :type controller: protobuf.socketrpc.controller.SocketRpcController
+         :param request: the request received from the component
+         :type request: leap.common.events.events_pb2.SignalRequest
+         :param done: callback to be called when done
+         :type done: protobuf.socketrpc.server.Callback
          """
 -        logger.info('Received signal from component: %s', str(request))
 +        logger.info('Received signal from component: %s...', str(request)[:40])
          # send signal to all registered components
          # TODO: verify signal auth
          if request.event in registered_components:
@@@ -140,10 -140,10 +140,10 @@@ class EventsServerDaemon(daemon.EventsS
          """
          Make sure the daemon is running on the given port.
  
-         @param port: the port in which the daemon should listen
-         @type port: int
+         :param port: the port in which the daemon should listen
+         :type port: int
  
-         @return: a daemon instance
-         @rtype: EventsServerDaemon
+         :return: a daemon instance
+         :rtype: EventsServerDaemon
          """
          return cls.ensure_service(port, EventsServerService())