v98

raw
v98                     1 #!/usr/bin/env python
v99                     2 
v99                     3 ##############################################################################
v99                     4 # Quick Intro:
v99                     5 # 1) Create '.wot' in your home directory. Fill it with public keys from 'wot'.
v99                     6 # 2) Create '.seals' in your home directory. Place all signatures there from 'sigs'.
v99                     7 # 3) Create a 'patches' directory somewhere where 'v' can find it. Or use this one.
v99                     8 # 4) ./v.py patches command
v99                     9 # e.g.,
v99                    10 # ./v.py patches w
v99                    11 #                  ^^ displays WoT
v99                    12 #  ./v.py patches p patches/asciilifeform_add_verifyall_option.vpatch asciis_bleedingedge
v99                    13 #                  ^^ this 'presses' (creates the actual tree)
v99                    14 #                  ^^ approximately like a 'checkout' in your vanilla flavoured shithub.
v99                    15 
v99                    16 ##############################################################################
v99                    17 
v98                    18 import os, sys, shutil, argparse, re, tempfile, gnupg, subprocess
v99                    19 
v99                    20 ##############################################################################
v98                    21 vver = 98 # This program's Kelvin version.
v99                    22 
v99                    23 ## HOW YOU CAN HELP: ##
v99                    24 
v99                    25 # * TESTS plox, ty!
v99                    26 #
v99                    27 # Report findings in #bitcoin-assets on Freenode.
v99                    28 
v99                    29 ##############################################################################
v99                    30 
v99                    31 prolog =  '''\
v99                    32 (C) 2015 NoSuchlAbs.
v99                    33 You do not have, nor can you ever acquire the right to use, copy or distribute
v99                    34 this software ; Should you use this software for any purpose, or copy and
v99                    35 distribute it to anyone or in any manner, you are breaking the laws of whatever
v99                    36 soi-disant jurisdiction, and you promise to continue doing so for the indefinite
v99                    37 future. In any case, please always : read and understand any software ;
v99                    38 verify any PGP signatures that you use - for any purpose.
v99                    39 '''
v99                    40 
v99                    41 intro = "V (ver. {0}K)\n".format(vver)
v99                    42 
v99                    43 ##############################################################################
v99                    44 def toposort(unsorted):
v99                    45     sorted = []
v99                    46     unsorted = dict(unsorted)
v99                    47     while unsorted:
v99                    48         acyclic = False
v99                    49         for node, edges in unsorted.items():
v99                    50             for edge in edges:
v99                    51                 if edge in unsorted:
v99                    52                     break
v99                    53             else:
v99                    54                 acyclic = True
v99                    55                 del unsorted[node]
v99                    56                 sorted.append((node, edges))
v99                    57         if not acyclic:
v99                    58             fatal("Cyclic graph!")
v99                    59     return sorted
v99                    60 ##############################################################################
v99                    61 
v98                    62 vpatch_path = "vpatch"
v99                    63 verbose = False
v99                    64 
v99                    65 def fatal(msg):
v99                    66     sys.stderr.write(msg + "\n")
v99                    67     exit(1)
v99                    68 
v99                    69 def spew(msg):
v99                    70     if verbose:
v99                    71         print msg
v99                    72 
v99                    73 # List of files in a directory, in lexical order.
v99                    74 def dir_files(dir):
v99                    75     return sorted([os.path.join(dir, fn) for fn in next(os.walk(dir))[2]])
v99                    76 
v99                    77 # GPG is retarded and insists on 'keychain.'
v99                    78 # This will be a temp dir, because we don't do any crypto.
v99                    79 gpgtmp = tempfile.mkdtemp()
v99                    80 gpg = gnupg.GPG(gnupghome=gpgtmp)
v99                    81 gpg.encoding = 'utf-8'
v99                    82 
v99                    83 # Known WoT public keys.
v99                    84 pubkeys = {}
v99                    85 
v99                    86 # The subset of vpatches that are considered valid.
v99                    87 patches = []
v99                    88 
v99                    89 # Banners (i.e. vpatches mapped to their guarantors)
v99                    90 banners = {}
v99                    91 
v99                    92 # Roots (i.e. vpatches parented by thin air)
v99                    93 roots = []
v99                    94 
v99                    95 # Table mapping file hash to originating vpatch
v99                    96 desc = {}
v99                    97 desc['false'] = 'false'
v99                    98 
v99                    99 
v99                   100 # Grep for diff magics, and memoize
v99                   101 def vpdata(path, exp, cache):
v99                   102     l = cache.get(path)
v99                   103     if not l:
v99                   104         l = []
v99                   105         patch = open(path, 'r').read()
v99                   106         for m in re.findall(exp, patch, re.MULTILINE):
v99                   107             l += [{'p':m[0], 'h':m[1]}]
v99                   108         cache[path] = l
v99                   109     return l
v99                   110 
v99                   111 # Get parents of a vpatch
v99                   112 pcache = {}
v99                   113 def parents(vpatch):
v99                   114     parents = vpdata(vpatch, r'^--- (\S+) (\S+)$', pcache)
v99                   115     if not parents:
v99                   116         fatal("{0} is INVALID, check whether it IS a vpatch!".format(vpatch))
v99                   117     return parents
v99                   118 
v99                   119 # Get children of a vpatch
v99                   120 ccache = {}
v99                   121 def children(vpatch):
v99                   122     children = vpdata(vpatch, r'^\+\+\+ (\S+) (\S+)$', ccache)
v99                   123     if not children:
v99                   124         fatal("{0} is INVALID, check whether it IS a vpatch!".format(vpatch))
v99                   125     # Record descendents:
v99                   126     for child in children:
v99                   127         h = child['h']
v99                   128         if h != 'false':
v99                   129             desc[h] = vpatch
v99                   130     return children
v99                   131 
v99                   132 # It is entirely possible to have more than one root!
v99                   133 # ... exactly how, is left as an exercise for readers.
v99                   134 def find_roots(patchset):
v99                   135     rset = []
v99                   136     # Walk, find roots
v99                   137     for p in patchset:
v99                   138         if all(p['h'] == 'false' for p in parents(p)):
v99                   139             rset += [p]
v99                   140             spew("Found a Root: '{0}'".format(p))
v99                   141     return rset
v99                   142 
v99                   143 # Get antecedents.
v99                   144 def get_ante(vpatch):
v99                   145     ante = {}
v99                   146     for p in parents(vpatch):
v99                   147         pp = desc.get(p['h']) # Patch where this appears
v99                   148         if not ante.get(pp):
v99                   149             ante[pp] = []
v99                   150         ante[pp] += [p['p']]
v99                   151     return ante
v99                   152 
v99                   153 # Get descendants.
v99                   154 def get_desc(vpatch):
v99                   155     des = {}
v99                   156     for p in patches:
v99                   157         ante = get_ante(p)
v99                   158         if vpatch in ante.keys():
v99                   159             des[p] = ante[vpatch]
v99                   160     return des
v99                   161 
v99                   162 ##############################################################################
v99                   163 
v99                   164 # Print name of patch and its guarantors, or 'WILD' if none known.
v99                   165 def disp_vp(vpatch):
v99                   166     seals = ', '.join(map(str, banners[vpatch]))
v99                   167     if seals == '':
v99                   168         seals = 'WILD'
v99                   169     return "{0} ({1})".format(vpatch, seals)
v99                   170 
v99                   171 ##############################################################################
v99                   172 
v99                   173 # Command: WoT
v99                   174 def c_wot(args):
v99                   175     for k in pubkeys.values():
v99                   176         print "{0}:{1} ({2})".format(k['handle'], k['fp'], k['id'])
v99                   177 
v99                   178 # Command: Flow
v99                   179 def c_flow(args):
v99                   180     for p in patches:
v99                   181         print disp_vp(p)
v99                   182 
v99                   183 # Command: Roots.
v99                   184 def c_roots(args):
v99                   185     for r in roots:
v99                   186         print "Root: " + disp_vp(r)
v99                   187 
v99                   188 # Command: Antecedents.
v99                   189 def c_ante(args):
v99                   190     ante = get_ante(args.query)
v99                   191     for p in ante.keys():
v99                   192         if p != 'false':
v99                   193             print "{0} [{1}]".format(disp_vp(p), '; '.join(map(str, ante[p])))
v99                   194 
v99                   195 # Command: Descendants
v99                   196 def c_desc(args):
v99                   197     des = get_desc(args.query)
v99                   198     for d in des.keys():
v99                   199         print "Descendant: {0} [{1}]".format(disp_vp(d), '; '.join(map(str, des[d])))
v99                   200 
v99                   201 # Command: Press.
v99                   202 def c_press(args):
v99                   203     print "Pressing using head: {0} to path: '{1}'".format(args.head, args.dest)
v99                   204     headpos = patches.index(args.head)
v99                   205     seq = patches[:headpos + 1]
v98                   206     if os.path.exists(args.dest):
v98                   207         print "Warning: target {0} already exists".format(args.dest)
v98                   208     else:
v98                   209         os.mkdir(args.dest)
v99                   210     for p in seq:
v99                   211         print "Using: {0}".format(disp_vp(p))
v98                   212         out = subprocess.Popen([vpatch_path], cwd=args.dest, stdin=subprocess.PIPE,
v98                   213                                stdout=subprocess.PIPE, stderr=subprocess.PIPE)
v98                   214         with open(p, "r") as inp:
v98                   215             body = inp.read()
v98                   216         stdout, stderr = out.communicate(body)
v98                   217         print stdout,
v98                   218         if out.returncode != 0:
v98                   219             fatal(("-----------------------------------\n" +
v98                   220                    "There was an error while pressing:\n" +
v98                   221                    "{0}\n" +
v98                   222                    "Result in {1} might be in an invalid state!\n" +
v98                   223                    "-----------------------------------").format(stderr.strip(), args.dest))
v99                   224     print "Completed Pressing using head: {0} to path: '{1}'".format(args.head, args.dest)
v99                   225 
v99                   226 # Command: Origin.
v99                   227 def c_origin(args):
v99                   228     o = desc.get(args.query)
v99                   229     if o:
v99                   230         print disp_vp(o)
v99                   231     else:
v99                   232         print "No origin known."
v99                   233 
v99                   234 ##############################################################################
v99                   235 
v99                   236 ##############################################################################
v99                   237 # Command line parameter processor.
v99                   238 parser = argparse.ArgumentParser(description=intro, epilog=prolog)
v99                   239 
v99                   240 # Print paths, etc
v99                   241 parser.add_argument('-v', dest='verbose', default=False,
v99                   242                     action="store_true", help='Verbose.')
v99                   243 
v99                   244 # Permit the use of patches no one has yet sealed. Use this ONLY for own dev work!
v99                   245 parser.add_argument('-wild', dest='wild', default=False,
v99                   246                     action="store_true", help='Permit wild (UNSEALED!) vpatches.')
v99                   247 
v99                   248 # Glom keyid (short fingerprint) onto every WoT handle.
v99                   249 parser.add_argument('-fingers', dest='fingers', default=False,
v99                   250                     action="store_true", help='Prefix keyid to all WoT handles.')
v99                   251 
v99                   252 # Default path of WoT public keys is /home/yourusername/.wot
v99                   253 # This dir must exist. Alternatively, you may specify another.
v99                   254 parser.add_argument('--wot', dest='wot', default=os.path.join(os.path.expanduser('~'), '.wot'),
v99                   255                     action="store", help='Use WoT in given directory. (Default: ~/.wot)')
v99                   256 
v99                   257 # Default path of the seals (PGP signatures) is /home/yourusername/.seals
v99                   258 # This dir must exist. Alternatively, you may specify another.
v99                   259 parser.add_argument('--seals', dest='seals', default=os.path.join(os.path.expanduser('~'), '.seals'),
v99                   260                     action="store", help='Use Seals in given directory. (Default: ~/.seals)')
v99                   261 
v99                   262 # REQUIRED: Path of directory with vpatches.
v99                   263 parser.add_argument('vpatches', help='Vpatch directory to operate on. [REQUIRED]')
v99                   264 
v99                   265 # REQUIRED: Command.
v99                   266 subparsers = parser.add_subparsers(help='Command [REQUIRED]')
v99                   267 
v99                   268 parser_w = subparsers.add_parser('w', help='Display WoT.')
v99                   269 parser_w.set_defaults(f=c_wot)
v99                   270 
v99                   271 parser_r = subparsers.add_parser('r', help='Display Roots.')
v99                   272 parser_r.set_defaults(f=c_roots)
v99                   273 
v99                   274 parser_a = subparsers.add_parser('a', help='Display Antecedents [PATCH]')
v99                   275 parser_a.set_defaults(f=c_ante)
v99                   276 parser_a.add_argument('query', action="store", help='Patch.')
v99                   277 
v99                   278 parser_d = subparsers.add_parser('d', help='Display Descendants [PATCH]')
v99                   279 parser_d.set_defaults(f=c_desc)
v99                   280 parser_d.add_argument('query', action="store", help='Patch.')
v99                   281 
v99                   282 parser_l = subparsers.add_parser('f', help='Compute Flow.')
v99                   283 parser_l.set_defaults(f=c_flow)
v99                   284 
v99                   285 parser_p = subparsers.add_parser('p', help='Press [HEADPATCH AND DESTINATION]')
v99                   286 parser_p.set_defaults(f=c_press)
v99                   287 parser_p.add_argument('head', action="store", help='Head patch.')
v99                   288 parser_p.add_argument('dest', action="store", help='Destionation directory.')
v99                   289 
v99                   290 parser_o = subparsers.add_parser('o', help='Find Origin [SHA512]')
v99                   291 parser_o.set_defaults(f=c_origin)
v99                   292 parser_o.add_argument('query', action="store", help='SHA512 to search for.')
v99                   293 
v99                   294 
v99                   295 ##############################################################################
v99                   296 
v99                   297 # V cannot operate without vpatches, WoT, and Seals datasets.
v99                   298 def reqdir(path):
v99                   299     if (not (os.path.isdir(path))):
v99                   300         fatal("Directory '{0}' does not exist!".format(path))
v99                   301     return path
v99                   302 
v99                   303 
v99                   304 def main():
v99                   305     global verbose, pubkeys, patches, roots, banners
v99                   306 
v99                   307     args = parser.parse_args()
v99                   308     verbose = args.verbose
v99                   309 
v99                   310     # Patch and Sigs dirs
v99                   311     pdir = reqdir(args.vpatches)
v99                   312     sdir = reqdir(args.seals)
v99                   313     wdir = reqdir(args.wot)
v99                   314 
v99                   315     spew("Using patches from:" + pdir)
v99                   316     spew("Using signatures from:" + sdir)
v99                   317     spew("Using wot from:" + wdir)
v99                   318 
v99                   319     pfiles = dir_files(pdir)
v99                   320     sfiles = dir_files(sdir)
v99                   321     wfiles = dir_files(wdir)
v99                   322 
v99                   323     # Build WoT from pubkeys
v99                   324     handle = {}
v99                   325     for w in wfiles:
v99                   326         pubkey = open(w, 'r').read()
v99                   327         impkey = gpg.import_keys(pubkey)
v99                   328         for fp in impkey.fingerprints:
v99                   329             handle[fp] = os.path.splitext(os.path.basename(w))[0]
v99                   330 
v99                   331     for k in gpg.list_keys():
v99                   332         name = handle[k['fingerprint']]
v99                   333         if args.fingers:
v99                   334             name += '-' + k['keyid']
v98                   335         uids = ', '.join(map(str, k['uids']))
v99                   336         pubkeys[k['keyid']] = {'fp':k['fingerprint'],
v98                   337                                'id':uids,
v99                   338                                'handle':name}
v98                   339         for subkey in k.get('subkeys', []):
v98                   340             keyid, fingerprint = subkey[0], subkey[2]
v98                   341             pubkeys[keyid] = {'fp':fingerprint,
v98                   342                               'id':uids,
v98                   343                               'handle':name}
v99                   344 
v99                   345     # Validate seals
v99                   346     for p in pfiles:
v99                   347         pt = os.path.basename(p)
v99                   348         banners[p] = []
v99                   349         for s in sfiles:
v99                   350             sig = os.path.basename(s)
v99                   351             # All seals must take the form patchtitle.vpatch.yourname.sig
v99                   352             if sig.find(pt) == 0: # substring of sig filename up through '.vpatch'
v99                   353                 v = gpg.verify_file(open(s, 'r'), data_filename=p)
v99                   354                 if v.valid:
v99                   355                     banners[p] += [pubkeys[v.key_id]['handle']]
v99                   356                 else:
v99                   357                     fatal("---------------------------------------------------------------------\n" +
v99                   358                           "WARNING: {0} is an INVALID seal for {1} !\n".format(sig, pt) +
v99                   359                           "Check that this user is in your WoT, and that this key has not expired.\n" +
v99                   360                           "Otherwise remove the invalid seal from your SEALS directory.\n" +
v99                   361                           "---------------------------------------------------------------------")
v99                   362 
v99                   363     # Select the subset of vpatches currently in use.
v99                   364     for p in pfiles:
v99                   365         if banners.get(p) or args.wild:
v99                   366             patches += [p]
v99                   367             children(p) # Memoize.
v99                   368             parents(p) # Memoize.
v99                   369 
v99                   370     roots = find_roots(patches)
v99                   371     if not roots:
v99                   372         fatal('No roots found!')
v99                   373 
v99                   374     # Topological ordering of flow graph
v99                   375     l = []
v99                   376     for p in patches:
v99                   377         l += [(p, get_desc(p).keys())]
v99                   378     s = map(lambda x:x[0], toposort(l))
v99                   379     patches = s[::-1]
v99                   380 
v99                   381     # Run command
v99                   382     args.f(args)
v99                   383 
v99                   384     # Remove temporary keychain
v99                   385     shutil.rmtree(gpgtmp)
v99                   386 
v99                   387 ##############################################################################
v99                   388 
v99                   389 if __name__ == '__main__' :
v99                   390     main()
v99                   391 
v99                   392 ##############################################################################