機密性の高いネットワークデータを匿名化することで、保護された環境や規制された環境でMigration Evaluatorを使用する

# beginning of script
import csv
import sys
import os
from argparse import ArgumentParser

# Used to store each of the transformations that will be applied to a row in the data
class Transformation:
    def __init__(self, ix, prefix):
        self.col_index = ix
        self.prefix = prefix    

def ProcessArgs(argv):
    parser = ArgumentParser(description = """
    Script to process a CSV generated by the AWS Migration Evaluator tool and anonymise sensitive columns (e.g. system names and IPs)
    This script will generate artificial values for the anonymised columns in the output so that it can be sent to AWS without 
    exposing values. The original values are retained in the reverse mapping output file that allow the anonomysed values to be 
    converted back. If only Input File is specified, then anon and reverse map filenames are generated automatically. """)
    parser.add_argument("-if", "--input-file", dest="infile", default='Physical_Provisioning_Tab.csv',
                        help="File to use as source", metavar="FILE")
    parser.add_argument("-of", "--output-file", dest="outfile", default='',
                        help="File for output anonymised version", metavar="FILE")
    parser.add_argument("-rf", "--revmap-file", dest="revmapfile", default='',
                        help="File for output of dereference (original and anonomised) values", metavar="FILE")
    parser.add_argument('-c','--cols', nargs='+', dest="anoncols", default = ['Human Name', 'Server Name', 'Address'],
                        help='List of Column names to anonymise', metavar="COL")
    parser.add_argument('-p','--prefixes', nargs='+', dest="anonprefixes", default = ['SERVER', 'SERVER', 'IP'],
                        help='Prefix to use when generating anonymised values (IP generates anonymised IP Addresses)', metavar="COL")
    parser.add_argument('-id','--idcol', dest="idcol", default = 'Unique Identifier',
                        help='Name of Column with per system unique identifier for de-referencing', metavar="COL")
    args = parser.parse_args()    
    # Generate output filenames if empty (default)
    if (args.outfile == ''):
        args.outfile = os.path.splitext(args.infile)[0]+'_anon.csv'
    if (args.revmapfile == ''):
        args.revmapfile = os.path.splitext(args.infile)[0]+'_revmap.csv'
    return args

# Read a CSV Into a structure seperating out headers and data
def ReadCSV (filename):
    file_data = []
    file_headers = []
    with open(filename) as csv_file:
        csv_reader = csv.reader(csv_file, delimiter=',')
        line_count = 0
        for row in csv_reader:
            trans_row = row
            if line_count > 0:
                # save the first line (it's headers)
                file_data.append(row)
            else:
                #assign the transformed row to the data array
                file_headers = row
            line_count += 1
        print('Loaded row count: ' + str(line_count-1))
    
    result = {
        "headers": file_headers,
        "data": file_data
    }
    return result

# Take filename headers and a data array and create a CSV
def WriteCSV(filename, headers, rows):
    line_count = 0
    with open(filename, mode='w') as out_file:
        out_writer = csv.writer(out_file, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL)
        out_writer.writerow(headers)
        for row in rows:
            out_writer.writerow(row)
            line_count += 1
    print('Wrote row count: ' + str(line_count))

# Take a single row, the indexes and prefixes of which cols to anonymise and return a transformed version and the de-reference values
def TransformRow(row, rowidix, id, transforms):
    revmap_vals = [ row[rowidix] ]
    for tr in transforms:
        revmap_vals.append(row[tr.col_index]) # original value
        if (tr.prefix == "IP"): # special case for IP, convert count into 10.0.0.0/8 CIDR
            row[tr.col_index] = '10.' + str(int(id / 65536)) + '.' + str(int(id / 256) % 256) + '.' + str(id % 256)   
        else:
            row[tr.col_index] = tr.prefix + str(id)
        revmap_vals.append(row[tr.col_index]) # also include transformed value in same row for easy searching
    return row, revmap_vals

# Take the data, headers and apply transformation rules generating a new structure
def TransformData(filedata, anon_cols, rowid, prefixes):
    # First process headers and generate indexes for any of the columns we need to anonymise that are in the data
    rowidix = filedata['headers'].index(rowid)
    transforms = []
    revmap_headers = [rowid]
    i = 0
    for col in anon_cols:
        if (col in filedata['headers'] ):
            transforms.append(Transformation(filedata['headers'].index(col), prefixes[i]))
            revmap_headers.append(col)
            revmap_headers.append("anon_" + col)
        i = i + 1
    #Now anonymise the data 
    trans_array = []
    revmap_array = []
    line_count = 0
    for row in filedata['data']:
        trans_row = row
        trans_row, revmap_row = TransformRow(trans_row, rowidix, line_count, transforms)
        # Add to result ready for next
        trans_array.append(trans_row)
        revmap_array.append(revmap_row)
        line_count += 1
    print('Transformed row count: ' + str(line_count))
    result = {
        "headers": filedata['headers'],
        "data": trans_array,
        "revmapHeaders": revmap_headers,
        "revmap": revmap_array,
    }
    return result

# Simple Mainline. Process args, Read, Transform, then Write the two files.
args = ProcessArgs(sys.argv)
print ('Anonomysing Columns: ' + ','.join(args.anoncols))
readfile = ReadCSV(args.infile)
transfile = TransformData(readfile, args.anoncols, args.idcol, args.anonprefixes)
print ('Write anonomysed data to: ' + args.outfile)
WriteCSV(args.outfile, transfile['headers'], transfile['data'])
print ('Write reverse mapping data to: ' + args.revmapfile)
WriteCSV(args.revmapfile, transfile['revmapHeaders'], transfile['revmap'])
# end of script