SWGDE Test Method for Skimmer Forensics – Analog Devices

				
					#!/usr/bin/env python2
import re, sys
from struct import unpack
from cc_verify import check_luhn
from track_decode import print_report_track1
from track_decode import print_report_track2
from track_carve import process_track1_data
from track_carve import process_track2_data

DEFAULT_WINDOW_SIZE = 4
DEFAULT_NOISE_THRESHOLD = 0.1
DEFAULT_TIME_THRESHOLD = 400
DEFAULT_STARTING_FRAME = 0
DEFAULT_NUMBER_OF_FRAMES = -1
DEFAULT_TRACK_NUMBER = 2
__date__ = '5-10-2011'
__version__ = '1.1'
__doc__ = "\n\
 Usage:\n\
 %s [actions] [options] wave_file_name\n\
 \n\
 Actions:\n\
 -h, --help Display this help message\n\
 -V Show version information\n\
 \n\
 Options:\n\
 -s frame_number Specify starting frame [default all]\n\
 -n number Specify number of frames to graph [default all]\n\
 -g Show a graph of the data\n\
 -l threshold Specify a noise threshold between 0 and 1 [default %f]\n\
 -r report_name Specify a file to write the report to\n\
 -t threshold Specify a time threshold [default %d]\n\
 -T track_number Specify which track format to search (1 or 2) [default %d]\n\
 -w window Specify a window size [default %d]" % (sys.argv[0],
DEFAULT_NOISE_THRESHOLD, DEFAULT_TIME_THRESHOLD, DEFAULT_TRACK_NUMBER,
DEFAULT_WINDOW_SIZE)

def extract_bits(minmax_times, window_size):
 # convert to distance between min/max
 minmax_times = [abs(minmax_times[lcv+1] - minmax_times[lcv]) for lcv in
range(len(minmax_times)-1)]
 #print minmax_times
 window = []
 bits = []
 
 skip = 0
 for lcv in range(len(minmax_times)):
 if skip:
 skip = 0
 else:
 if (len(window) < window_size):
 # fill up the window with enough samples first
 window.insert(0, minmax_times[lcv])
 bits.append(0)
 else:
 window_avg = float(sum(window))/len(window)
 #print 'Window:', window
 #print 'Window avg: ', window_avg
 #print 'Current %0.2f (%0.2f)' % (minmax_times[lcv],
 # float(minmax_times[lcv]) / window_avg)
 if minmax_times[lcv] < 4 * window_avg:
 if minmax_times[lcv] > 0.80 * window_avg:
 # strong zero
#print '======> 0'
window.insert(0, minmax_times[lcv])
 bits.append(0)
 elif minmax_times[lcv] < 0.70 * window_avg:
 # strong one
#print '======> 1'
if lcv != len(minmax_times) - 1:
 window.insert(0, minmax_times[lcv] + minmax_times[lcv+1])
 #window.insert(0, (minmax_times[lcv]+minmax_times[lcv+1])/2)
 bits.append(1)
 skip = 1
 else:
 if lcv >= len(minmax_times) - 1:
 break
 # we need to look at the next center crossing
# to help us determine this one
next_window_avg =
float(sum([minmax_times[lcv+1],]+window[:-1]))/len(window)
 if minmax_times[lcv+1] > 0.75 * next_window_avg:
 # next is whole freq, then this is a zero
#print '======> 0?'
bits.append(0)
 window.insert(0, minmax_times[lcv])
 else:
 # next is half freq... we don't really know
 # go with the best guess for this center crossing
if minmax_times[lcv] > 0.75 * window_avg:
 #print '======> 0??'
window.insert(0, minmax_times[lcv])
 bits.append(0)
 else:
 #print '======> 1??'
if lcv != len(minmax_times) - 1:

window.insert(0, minmax_times[lcv] + minmax_times[lcv+1])

bits.append(1) skip = 1
window.pop()

return bits

def five_bits_to_ascii(bits):
if bits == '00001': return '0' # (0H) Data
if bits == '10000': return '1' # (1H)
if bits == '01000': return '2' # (2H)
if bits == '11001': return '3' # (3H)
if bits == '00100': return '4' # (4H)
if bits == '10101': return '5' # (5H)
if bits == '01101': return '6' # (6H)
if bits == '11100': return '7' # (7H)
if bits == '00010': return '8' # (8H)
if bits == '10011': return '9' # (9H)
if bits == '01011': return ':' # (AH) Control
if bits == '11010': return ';' # (BH) Start Sentinel
if bits == '00111': return '<' # (CH) Control
if bits == '10110': return '=' # (DH) Field Separator
if bits == '01110': return '>' # (EH) Control
if bits == '11111': return '?' # (FH) End Sentinel<>
return ''

def decode_bits(bits):
""" Returns a list of possible decoded track 2 data """
bits = ''.join(['%d'%x for x in bits]) 
data = ''
start = bits.find('11010') datas = []
while start != -1:
data = ''
for lcv in range(start, len(bits), 5):
char = five_bits_to_ascii(bits[lcv:lcv+5]) if char == '':
datas.append(data) break
data += char
start = bits.find('11010', start + 1) return datas
def force_decode_bits(bits):
""" Returns a list of decoded track 2 data with '?' as invalid characters """
bits = ''.join(['%d'%x for x in bits]) 
data = ''
for lcv in range(0, len(bits), 5):
char = five_bits_to_ascii(bits[lcv:lcv+5]) 
if char == '': char = '?'
data += char
 return data
def carve_cc(wave_stream,
 starting_frame = DEFAULT_STARTING_FRAME,
 number_of_frames = DEFAULT_NUMBER_OF_FRAMES,
 noise_threshold = DEFAULT_NOISE_THRESHOLD,
 time_threshold = DEFAULT_TIME_THRESHOLD,
 window_size = DEFAULT_WINDOW_SIZE,
 track_number = DEFAULT_TRACK_NUMBER,
 graph = None,
 report_stream = None):
 samples = []
 minmax_times = []
 wave_stream.rewind()
 if (number_of_frames == -1) or (number_of_frames > wave_stream.getnframes() - starting_frame):
 number_of_frames = wave_stream.getnframes()
 wave_stream.setpos(starting_frame)
 # extract the times between mininums and maximums (or maximums and minimums)
 if wave_stream.getsampwidth() == 1:
 center = 128
 maximum = 127
 elif wave_stream.getsampwidth() == 2:
 center = 0
 maximum = 32767
 prev_data = center + 1
 # while we have unread wave data
 while wave_stream.tell() != (number_of_frames + starting_frame):
 # search for crossing of center
 data = center
 while abs(data - center) < noise_threshold * maximum and
wave_stream.tell() != (number_of_frames + starting_frame):
 if wave_stream.getsampwidth() == 1:
 data = unpack('B', wave_stream.readframes(1))[0]
 elif wave_stream.getsampwidth() == 2:
 data = unpack('h', wave_stream.readframes(1))[0]
 data = [data, data,]
 if wave_stream.tell() != (number_of_frames + starting_frame):
 while (data[-1]-center)*(data[-2]-center) > 0 and wave_stream.tell() != (number_of_frames + starting_frame):
 if wave_stream.getsampwidth() == 1:
 data.append(unpack('B', wave_stream.readframes(1))[0])
 elif wave_stream.getsampwidth() == 2:
 data.append(unpack('h', wave_stream.readframes(1))[0])
 # find the min/max
 if data[0] < center:
 # min found
 #print wave_stream.tell() - len(data) + data.index(min(data)),
 #print min(data)
 samples.append(wave_stream.tell() - len(data) + data.index(min(data)))
 else:
 # max found
 #print wave_stream.tell() - len(data) + data.index(min(data)),
 #print max(data)
 samples.append(wave_stream.tell() - len(data) + data.index(max(data)))
 # separate bit groups by threshold time
 group = []
 for sample in samples:
 if group == []:
 group = []
 group.append(sample)
 elif sample - group[-1] < time_threshold:
 group.append(sample)
 else:
 # too long between peaks, start new bit group
 if group != []:
 minmax_times.append(group)
 group = []
 group.append(sample)
 if group != []:
 minmax_times.append(group)
 # extract the bits from the minimum/maximum times
 # reverse for a reverse swipe
 bits = []
 for each in minmax_times:
 bits.append((extract_bits(each, window_size), extract_bits(each[::-1], window_size))) # original
 #bits.append((extract_bits(each, window_size), extract_bits(each, window_size)[::-1]))
 #print extract_bits(each, window_size)
 #print extract_bits(each, window_size)[::-1]
 #print ''
 # decode the information
 info = []
 for each in bits:
 if track_number == 1:
 info.extend(process_track1_data(''.join(['%d'%x for x in each[0]]), convert_to_binary=False))
 else:
 info.extend(process_track2_data(''.join(['%d'%x for x in each[0]]), convert_to_binary=False))
 if report_stream:
 print 'Generating Report...'
 if track_number == 1:
 print_report_track1(info, print_stream=report_stream)
 else:
 print_report_track2(info, print_stream=report_stream)
 #else:
 # if track_number == 1:
 # print_report_track1(info)
 # else:
 # print_report_track2(info)
 info = [x[0] for x in info]
 #print 'Peaks:'
 #print minmax_times
 #print 'Bits:'
 #print bits
 #print 'Hex:'
 #print [[''.join([chr(int(''.join([str(x) for x in (seq[8*i:8*(i+1)]) + ['0',]*(8-len(seq[8*i:8*(i+1)]))]), 2)) for i in range(len(seq)/8 + (7+len(seq)%8)/8)]) for seq in pair] for pair in bits]
 #print 'Decoded info:'
 #print info
 '''
 for shift in range(5):
 for b in bits:
 if len(b[0]) > shift:
 print 'Raw decoded forward bits (shift %d):' % shift
 print force_decode_bits(b[0][shift:])
 if len(b[1]) > shift:
 print 'Raw decoded reverse bits (shift %d):' % shift
 print force_decode_bits(b[1][shift:])
 '''

 if graph:
 print("Generating Graph...")
 from graph_wave import graph_wave, graph_minmax, graph_bits
 import pylab as p
 ax = p.subplot(111)
 #ax = p.subplot(211)
 p1 = graph_wave(wave_stream, number_of_frames = number_of_frames, starting_frame = starting_frame, noise_threshold = noise_threshold, p = ax)
 if wave_stream.getsampwidth() == 1: p1.set_yticks([0,255])
 elif wave_stream.getsampwidth() == 2: p1.set_yticks([-32768,32767])
 p1.set_yticklabels(['-1.0', '1.0'])
 p1.set_xticks([starting_frame, starting_frame+number_of_frames])
 p1.set_xticklabels([str(0), str(number_of_frames)])
 p1.set_xlim((starting_frame, starting_frame+number_of_frames))
 p1.set_title('Waveform and Demodulated Bit Stream')
 #p1.set_xlabel('Sample Number')
 p1.set_ylabel('Magnitude')
 # [y for x in bits for y in x]
 #ax = p.subplot(212)
 #p2 = ax
 for lcv in range(len(minmax_times)):
 p = graph_minmax(wave_stream, minmax_times[lcv], frames =
wave_stream.getnframes(), p = p)
 p = graph_bits(wave_stream, bits[lcv][0], minmax_times[lcv],
number_of_frames = number_of_frames, starting_frame = starting_frame, p = p)
 #p2 = graph_bits(wave_stream, bits[lcv][0], minmax_times[lcv], number_of_frames = number_of_frames, starting_frame = starting_frame, p = p2)
 #p = graph_bits(wave_stream, bits[lcv][1][::-1], minmax_times[lcv], frames = wave_stream.getnframes(), p = p)
 #if wave_stream.getsampwidth() == 1: p2.set_yticks([0,255])
 #elif wave_stream.getsampwidth() == 2: p2.set_yticks([-32768,32767])
 #p2.set_yticklabels(['0', '1'])
 #p2.set_xticks([starting_frame, starting_frame+number_of_frames])
 #p2.set_xticklabels([str(0), str(number_of_frames)])
 #p2.set_xlim((starting_frame, starting_frame+number_of_frames))
 #p2.set_title('Demodulated Waveform Bit Stream')

 #p2.set_xlabel('Sample Number')
 #p2.set_ylabel('Bit Value')

 #p.axis('tight')
 #p.legend()
 p.show()
def main(args):
 import getopt
 try:
 wave_file_name = args[-1]
 # note: args[1:] is not typical because first arg is always a file_name
 opts, args = getopt.getopt(args[0:], 'ghl:n:o:r:s:t:T:Vw:', ['help',])
 except getopt.GetoptError, ex:
 print >> sys.stderr, 'Invalid argument: ' + str(ex)
 print >> sys.stderr, __doc__
 sys.exit(1)
 except IndexError:
 print >> sys.stderr, 'Please specify an image file to analyze...'
 print >> sys.stderr, __doc__
 sys.exit(1)
 def badArguments():
 # print out usage if bad arguments are supplied
 print >> sys.stderr, 'Bad command line argument formation'
 print >> sys.stderr, __doc__
 sys.exit(1)
 window_size = DEFAULT_WINDOW_SIZE
 starting_frame = DEFAULT_STARTING_FRAME
 number_of_frames = DEFAULT_NUMBER_OF_FRAMES
 noise_threshold = DEFAULT_NOISE_THRESHOLD
 time_threshold = DEFAULT_TIME_THRESHOLD
 track_number = DEFAULT_TRACK_NUMBER
 graph = None
 report_stream = None
 # action parsing
 for opt, arg in opts:
 # Short options
 if opt in ['-h', '--help']:
 print __doc__
 sys.exit(1)
 elif opt == '-V':
 print sys.argv[0] + ', Version ' + __version__
 sys.exit(1)
 # option parsing
 for opt, arg in opts:
 if opt == '-g':
 graph = True
 elif opt == '-l':
 try:
 noise_threshold = float(arg)
 assert 0. < noise_threshold < 1.
 except:
 print >> sys.stderr, 'Noise threshold must be a floating point number between 0 and 1 (got "%s")...' % arg
 print >> sys.stderr, __doc__
 sys.exit(1)
 elif opt == '-n':
 try:
 number_of_frames = int(arg)
 except:
 print >> sys.stderr, 'Number of frames must be an integer (got "%s")...' % arg
 print >> sys.stderr, __doc__
 sys.exit(1)
 elif opt == '-r':
 try:
 report_stream = open(arg, 'w')
 except:
 print >> sys.stderr, 'Could not open report output file "%s"...' % arg
 print >> sys.stderr, __doc__
 sys.exit(1)
 elif opt == '-s':
 try:
 starting_frame = int(arg)
 except:
 print >> sys.stderr, 'Starting frame number must be an integer (got "%s")...' % arg
 print >> sys.stderr, __doc__
 sys.exit(1)
 elif opt == '-t':
 try:
 time_threshold = int(arg)
 except:
 print >> sys.stderr, 'Time threshold must be an integer (got "%s")...' % arg
 print >> sys.stderr, __doc__
 sys.exit(1)
 elif opt == '-T':
 try:
 track_number = int(arg)
 if not(track_number == 1 or track_number == 2):
 print >> sys.stderr, 'Track number must be equal to either 1 or 2 (got "%s")...' % arg
 print >> sys.stderr, __doc__
 sys.exit(1)
 except SystemExit: # needed due to how sys.exit() works
 sys.exit(1)
 except:
 print >> sys.stderr, 'Track number must be an integer (got "%s")...' % arg
 print >> sys.stderr, __doc__
 sys.exit(1)
 elif opt == '-w':
 try:
 window_size = int(arg)
 assert window_size > 0
 except:
 print >> sys.stderr, 'Window size must be a positive integer (got "%s")...' % arg
 print >> sys.stderr, __doc__
 sys.exit(1)
 try:
 import wave
 wave_stream = wave.open(wave_file_name, 'rb')
 except IOError:
 print >> sys.stderr, 'Could not open wave file "%s"...' % wave_file_name
 print >> sys.stderr, __doc__
 sys.exit(1)
 # let's do it
 carve_cc(wave_stream,
 starting_frame = starting_frame,
 number_of_frames = number_of_frames,
 noise_threshold = noise_threshold,
 time_threshold = time_threshold,
 window_size = window_size,
 track_number = track_number,
 graph = graph,
 report_stream = report_stream)
 if report_stream:
 report_stream.close()
 if __name__ == '__main__':
 try:
 import psyco
 psyco.full()
 except ImportError:
 pass
 #print 'Psyco not installed, the program will just run slower...'
 main(sys.argv[1:])