tactual tomber sourcecode inclusion - tomb - the crypto undertaker
(HTM) git clone git://parazyd.org/tomb.git
(DIR) Log
(DIR) Files
(DIR) Refs
(DIR) README
(DIR) LICENSE
---
(DIR) commit 09b9bcb469097fd42996695cf65a1ed5a981582c
(DIR) parent 02e72893c2db9a182b9e82c5b02fd2a150ca43e0
(HTM) Author: Jaromil <jaromil@dyne.org>
Date: Sun, 16 Nov 2014 16:45:28 +0100
actual tomber sourcecode inclusion
Diffstat:
A extras/tomber/tomber/__init__.py | 3 +++
A extras/tomber/tomber/test.jpg | 0
A extras/tomber/tomber/test.py | 105 +++++++++++++++++++++++++++++++
A extras/tomber/tomber/tomber.py | 214 +++++++++++++++++++++++++++++++
A extras/tomber/tomber/tools/__init_… | 0
A extras/tomber/tomber/tools/parser.… | 33 +++++++++++++++++++++++++++++++
6 files changed, 355 insertions(+), 0 deletions(-)
---
(DIR) diff --git a/extras/tomber/tomber/__init__.py b/extras/tomber/tomber/__init__.py
t@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+from tomber import *
+\ No newline at end of file
(DIR) diff --git a/extras/tomber/tomber/test.jpg b/extras/tomber/tomber/test.jpg
Binary files differ.
(DIR) diff --git a/extras/tomber/tomber/test.py b/extras/tomber/tomber/test.py
t@@ -0,0 +1,104 @@
+import os
+import unittest
+from tomber import *
+from random import randrange
+from shutil import rmtree, copyfile
+
+
+class tomberTester(unittest.TestCase):
+
+ @classmethod
+ def setUpClass(self):
+ self.pid = str(os.getpid())
+ self.tombfile = '.'.join([self.pid, 'tomb'])
+ self.keyfile = '.'.join([self.pid, 'key'])
+ self.keyfile2 = '.'.join([self.pid, '2ndkey'])
+ self.exhumedkey = '.'.join([self.pid, 'exhumed'])
+ self.mountpath = './tmptomb'
+ # generate a passphrase with spaces
+ self.passphrase = str(randrange(2 ** 64)).replace("", " ")[1:-1]
+ self.passphrase2 = str(randrange(2 ** 64))
+ self.imagefile = '.'.join([self.pid, 'jpg'])
+ copyfile(
+ '/'.join([os.path.dirname(__file__), 'test.jpg']),
+ self.imagefile)
+
+ @classmethod
+ def tearDownClass(self):
+ os.unlink(self.tombfile)
+ os.unlink(self.keyfile)
+ os.unlink(self.keyfile2)
+ os.unlink(self.imagefile)
+ os.unlink(self.exhumedkey)
+ rmtree(self.mountpath)
+
+ def test_01_dig(self):
+ """ Dig a tomb of 10mb"""
+ self.assertTrue(tdig(self.tombfile, 10)[0])
+
+ def test_02_forge(self):
+ """ Forge a keyfile and set a passphrase """
+ self.assertTrue(tforge(self.keyfile, self.passphrase)[0])
+
+ def test_03_lock(self):
+ """ Lock created tomb with forged keyfile """
+ self.assertTrue(tlock(self.tombfile, self.keyfile, self.passphrase)[0])
+
+ def test_04_open(self):
+ """ Open the created tomb with forged keyfile and passhrase """
+ self.assertTrue(topen(
+ self.tombfile, self.keyfile, self.passphrase, self.mountpath
+ )[0]
+ )
+
+ def test_05_close(self):
+ """ Close the created tomb """
+ self.assertTrue(tclose(self.tombfile.split('.')[0])[0])
+
+ def test_06_resize(self):
+ """ Resize created tomb to 12mb """
+ self.assertTrue(tresize(
+ self.tombfile, self.keyfile, self.passphrase, 12
+ )[0]
+ )
+
+ def test_07_passwd(self):
+ """ Change password in keyfile """
+ self.assertTrue(tpasswd(
+ self.keyfile, self.passphrase2, self.passphrase
+ )[0]
+ )
+
+ def test_08_bury(self):
+ """ Bury keyfile in a image file """
+ self.assertTrue(tbury(
+ self.keyfile, self.passphrase2, self.imagefile
+ )[0]
+ )
+
+ def test_09_exhume(self):
+ """ Exhume a key from an image """
+ self.assertTrue(texhume(
+ self.exhumedkey, self.passphrase2, self.imagefile
+ )[0]
+ )
+
+ def test_10_setkey(self):
+ """ Forge a new key and and set different keyfile to created tomb """
+ tforge(self.keyfile2, self.passphrase)
+ self.assertTrue(tsetkey(
+ self.keyfile,
+ self.tombfile,
+ self.keyfile2,
+ self.passphrase,
+ self.passphrase2
+ )[0]
+ )
+
+ def test_11_slam(self):
+ """ Slam open tombs """
+ topen(self.tombfile, self.keyfile, self.passphrase2, self.mountpath)
+ self.assertTrue(tslam()[0])
+
+if __name__ == '__main__':
+ unittest.main()
+\ No newline at end of file
(DIR) diff --git a/extras/tomber/tomber/tomber.py b/extras/tomber/tomber/tomber.py
t@@ -0,0 +1,214 @@
+# -*- coding: utf8 -*-
+
+"""
+
+tomber - a python Tomb (the Crypto Undertaker) wrapper
+To use tomber you need to install Tomb (https://github.com/dyne/Tomb)
+Copyright © 2014, Federico reiven <reiven_at_gmail.com>
+Licensed under BSD License.
+See also LICENSE file
+
+"""
+
+
+from subprocess import Popen, PIPE
+from tools import parser
+
+
+def get_message(stderr, type):
+ """
+ Helper to return exit messages from command execution
+ """
+ response = []
+ for line in stderr.split('\n'):
+ ret = parser.parse_line(line)
+ if ret and ret['type'] == type:
+ if not 'swaps' in ret['content']:
+ response.append(ret['content'])
+ return response
+
+
+def execute(cmd):
+ """
+ Execute given cmd. return boolean based on exit status and error string
+ """
+ p = Popen(cmd, stdout=PIPE, stderr=PIPE, shell=True)
+ stdout, stderr = p.communicate()
+ p_status = p.wait()
+ if p_status == 0:
+ return True, get_message(stderr, 'success')
+ else:
+ return False, get_message(stderr, 'error')
+
+
+def sanitize_passphrase(passphrase):
+ """
+ Used to avoid errors with passphrases which include spaces
+ """
+ return ''.join(['"', passphrase, '"'])
+
+
+def tdig(tombfile, size, force=False):
+ """
+ Dig a tomb of given size
+ """
+ cmd = ' '.join(['tomb', 'dig', tombfile, '-s', str(size), '--no-color'])
+ if force:
+ cmd += " -f"
+ return execute(cmd)
+
+
+def tforge(keyfile, passphrase, force=False):
+ """
+ Forge a key with given passphrase
+ """
+ cmd = ' '.join(['tomb',
+ 'forge',
+ keyfile,
+ '--unsecure-dev-mode',
+ '--tomb-pwd',
+ sanitize_passphrase(passphrase),
+ '--no-color'])
+ if force:
+ cmd += " -f"
+ return execute(cmd)
+
+
+def tlock(tombfile, keyfile, passphrase):
+ """
+ Lock a tomb file with given key and passphrase.
+ """
+ cmd = ' '.join(['tomb',
+ 'lock',
+ tombfile,
+ '-k',
+ keyfile,
+ '--unsecure-dev-mode',
+ '--tomb-pwd',
+ sanitize_passphrase(passphrase),
+ '--no-color'])
+ return execute(cmd)
+
+
+def topen(tombfile, keyfile, passphrase, mountpath=False):
+ """
+ Open (mount) a tomb.
+ Keyfile and passphrase are needed, mountpoint is optional
+ """
+ if not mountpath:
+ mountpath = ''
+ cmd = ' '.join(['tomb',
+ 'open',
+ tombfile,
+ '-k',
+ keyfile,
+ '--unsecure-dev-mode',
+ '--tomb-pwd',
+ sanitize_passphrase(passphrase),
+ '--no-color',
+ mountpath])
+ return execute(cmd)
+
+
+def tclose(tombfile):
+ """
+ Close (umount) a tomb
+ """
+ cmd = ' '.join(['tomb', 'close', tombfile, '--no-color'])
+ return execute(cmd)
+
+
+def tresize(tombfile, keyfile, passphrase, newsize):
+ """
+ Resize a tomb.
+ Keyfile, passphrase and new size are needed.
+ """
+ cmd = ' '.join(['tomb',
+ 'resize',
+ tombfile,
+ '-k',
+ keyfile,
+ '--unsecure-dev-mode',
+ '--tomb-pwd',
+ sanitize_passphrase(passphrase),
+ '-s',
+ str(newsize),
+ '--no-color'])
+ return execute(cmd)
+
+
+def tbury(keyfile, passphrase, imagefile):
+ """
+ Bury a key inside a jpg file
+ """
+ cmd = ' '.join(['tomb',
+ 'bury',
+ '-k',
+ keyfile,
+ '--unsecure-dev-mode',
+ '--tomb-pwd',
+ sanitize_passphrase(passphrase),
+ imagefile,
+ '--no-color'])
+ return execute(cmd)
+
+
+def texhume(keyfile, passphrase, imagefile):
+ """
+ Exhume (recover) key from jpg file. Passphrase for key is needed
+ """
+ cmd = ' '.join(['tomb',
+ 'exhume',
+ '-k',
+ keyfile,
+ '--unsecure-dev-mode',
+ '--tomb-pwd',
+ sanitize_passphrase(passphrase),
+ imagefile,
+ '--no-color'])
+ return execute(cmd)
+
+
+def tpasswd(keyfile, newpassphrase, oldpassphrase):
+ """
+ Change current passphrase from keyfile
+ """
+ cmd = ' '.join(['tomb',
+ 'passwd',
+ '-k',
+ keyfile,
+ '--unsecure-dev-mode',
+ '--tomb-pwd',
+ sanitize_passphrase(newpassphrase),
+ '--tomb-old-pwd',
+ sanitize_passphrase(oldpassphrase),
+ '--no-color'])
+ return execute(cmd)
+
+
+def tsetkey(oldkeyfile, tombfile, newkeyfile, newpassphrase, oldpassphrase):
+ """
+ Change lock key for a tomb
+ The old key+passphrase and new key+passphrase are needed
+ """
+ cmd = ' '.join(['tomb',
+ 'setkey',
+ oldkeyfile,
+ tombfile,
+ '-k',
+ newkeyfile,
+ '--unsecure-dev-mode',
+ '--tomb-pwd',
+ sanitize_passphrase(newpassphrase),
+ '--tomb-old-pwd',
+ sanitize_passphrase(oldpassphrase),
+ '--no-color'])
+ return execute(cmd)
+
+
+def tslam():
+ """
+ Slam tombs, killing all programs using it
+ """
+ cmd = ' '.join(['tomb', 'slam'])
+ return execute(cmd)
(DIR) diff --git a/extras/tomber/tomber/tools/__init__.py b/extras/tomber/tomber/tools/__init__.py
(DIR) diff --git a/extras/tomber/tomber/tools/parser.py b/extras/tomber/tomber/tools/parser.py
t@@ -0,0 +1,33 @@
+'''
+Utilities to analyze tomb output
+'''
+import re
+
+#found: [m] followed by some ID (usually "found") inside square brackets, then
+#something else, then a space, then the content
+_found_regex = re.compile(r'^\[m\]\[([^]]+)\] +(([^:]+)://(.+))$')
+#generic: programname, then some identifiers in square (or round) brackets,
+#then maybe something else, then a space, then the context
+_generic_regex = re.compile(r'^[a-z-]+ [[(]([^]]+)[\])] +(.+)$')
+types = {'E': 'error', 'W': 'warning', 'D': 'debug', '*': 'success'}
+
+
+def parse_line(line):
+ '''Analyze a single line.
+ Return None if no standard format is detected, a dict otherwise.
+ The fields 'type' and 'content' are always in the dict; 'content' may be
+ empty
+ 'type' can be 'error', 'progress'
+ '''
+
+ match = _found_regex.match(line)
+ if match:
+ return {'type': types.get(match.group(1)) or match.group(1),
+ 'content': match.group(2), 'scheme': match.group(3),
+ 'path': match.group(4)}
+ match = _generic_regex.search(line)
+ if match:
+ return {'type': types.get(match.group(1)) or match.group(1),
+ 'content': match.group(2)}
+
+ return None