#!/usr/bin/python

 import subprocess

 import web

 import netifaces

 import os

 import sys

 import base64

 #import logging

 opensecurity_urls = (

     '/password',                'os_password',

     '/init',                    'os_init'

 )

 #__LOG = logging.getLogger("passwordreceiver")

 class os_password:

     # delete the key file in a secure way (will not working on ssd's :/ ,but ram only vm -> should be ok)

     def deleteKeyfile(self, keyfilepath):

         filesize = os.path.getsize(keyfilepath)

         keyfile = open (keyfilepath, "w+")

         for i in range (0, 10):

             keyfile.seek(0)

             keyfile.write(os.urandom(filesize))

             keyfile.flush()

         keyfile.close()

         os.remove(keyfilepath)

     def GET(self, settings):

         return self.POST(settings)

     def POST(self, settings):

         # pick the arguments

         args = web.input()

         if not "password" in args:

             raise web.badrequest()

         if "keyfile" in args:

             keyfile = open (settings["keyfilepath"], "w+")

             keyfile.write(base64.b64decode(args["keyfile"]))

             keyfile.close()

             command = [settings["script"], settings["device"], settings["mountpoint"], args["password"], settings["keyfilepath"]]

         else:

             command = [settings["script"], settings["device"], settings["mountpoint"], args["password"]]

         process = subprocess.Popen( command, stdout=subprocess.PIPE, stderr=subprocess.PIPE )

         retval = process.wait()

         ( stdout, stderr ) = process.communicate()

         if "keyfile" in args:

             self.deleteKeyfile(settings["keyfilepath"])

         if (retval != 0):

             raise web.badrequest(stderr)

         return "Success: Encrypted Stick is mounted"

 class os_init:

     # delete the key file in a secure way (will not working on ssd's :/ ,but ram only vm -> should be ok)

     def deleteKeyfile(self, keyfilepath):

         filesize = os.path.getsize(keyfilepath)

         keyfile = open (keyfilepath, "w+")

         for i in range (0, 10):

             keyfile.seek(0)

             keyfile.write(os.urandom(filesize))

             keyfile.flush()

         keyfile.close()

         os.remove(keyfilepath)

     def runPreInitScript(self, preinitscript, device):

         #__LOG.debug("Start preinit Script")

         command = [preinitscript, device]

         process = subprocess.Popen( command, stdout=subprocess.PIPE, stderr=subprocess.PIPE )

         retval = process.wait()

         ( stdout, stderr ) = process.communicate()

         #__LOG.debug("preinit done result: %s" %(retval,))

         if (retval != 0):

             raise web.badrequest(stderr)

     def runPostInitScript(self, postinitscript):

         #__LOG.debug("Start postinit Script")

         command = [postinitscript]

         process = subprocess.Popen( command, stdout=subprocess.PIPE, stderr=subprocess.PIPE )

         retval = process.wait()

         ( stdout, stderr ) = process.communicate()

         #__LOG.debug("postinit done result: %s" %(retval,))

         if (retval != 0):

             raise web.badrequest(stderr)

     def GET(self, settings):

         return self.POST(settings)

     def POST(self, settings):

         # pick the arguments

         args = web.input()

         if not "password" in args:

             raise web.badrequest()

         # Do the preinit stuff

         self.runPreInitScript(settings["preinitscript"], settings["device"])

         if "keyfile" in args:

             keyfile = open (settings["keyfilepath"], "w+")

             keyfile.write(base64.b64decode(args["keyfile"]))

             keyfile.close()

             command = [settings["script"], settings["device"], settings["mountpoint"], args["password"], settings["keyfilepath"]]

         else:

             command = [settings["script"], settings["device"], settings["mountpoint"], args["password"]]

         #__LOG.debug("Start init script")

         process = subprocess.Popen( command, stdout=subprocess.PIPE, stderr=subprocess.PIPE )

         retval = process.wait()

         ( stdout, stderr ) = process.communicate()

         if "keyfile" in args:

             self.deleteKeyfile(settings["keyfilepath"])

         #__LOG.debug("init done result: %s" %(retval,))

         if (retval != 0):

             raise web.badrequest(stderr)

         # Do the postinit stuff

         self.runPostInitScript(settings["postinitscript"])

         return "Success: Stick is initialized and mounted"

 class MyRestListener(web.application):

     def __init__(self, mapping=(), fvars={}, autoreload=None, script=None, device=None, mountpoint=None, tries=None, keyfilepath=None, preinitscript=None, postinitscript=None):

         web.application.__init__(self, mapping, fvars, autoreload)

         self.device = device

         self.mountpoint = mountpoint

         self.script = script

         self.tries = tries

         self.keyfilepath = keyfilepath

         self.preinitscript = preinitscript

         self.postinitscript = postinitscript

     def run(self, interface, port, *middleware):

         func = self.wsgifunc(*middleware)

         ifaceip = netifaces.ifaddresses(interface)[2][0]["addr"]

         return web.httpserver.runsimple(func, (ifaceip, port))

     def handle(self):

         fn, args = self._match(self.mapping, web.ctx.path)

         args.append({"script": self.script, "device": self.device, "mountpoint": self.mountpoint, "tries": self.tries, "keyfilepath": self.keyfilepath, "preinitscript": self.preinitscript, "postinitscript": self.postinitscript})

         return self._delegate(fn, self.fvars, args)