src/yaca/tools/encrypt_param_combinations.py

   1 #!/usr/bin/python
   2 import containers
   3 import os
   4
   5 def add_description(out_file, string):
   6     out_file.write(containers.separator + ' ' + string + ' ' + containers.separator +\
   7                    os.linesep + os.linesep)
   8
   9 def write_set(algo_name, bcm, key_len, iv_len, out_file, valid = None, tag_len = None):
  10     out_file.write('algo=' + algo_name + os.linesep)
  11     out_file.write('bcm=' + bcm + os.linesep)
  12     out_file.write('key_len=' + str(key_len) + os.linesep)
  13     out_file.write('iv_len=' + str(iv_len) + os.linesep)
  14     if tag_len != None:
  15         out_file.write('tag_len=' + str(tag_len) + os.linesep)
  16     if valid != None:
  17         out_file.write('valid=' + valid + os.linesep)
  18     out_file.write(os.linesep)
  19
  20 def check_bcm_for_algo(out_file):
  21     add_description(out_file, 'check bcm for algorithm')
  22
  23     for algo_name, algo in containers.valid_database.iteritems():
  24         add_description(out_file, algo_name)
  25         for bcm_name in containers.bcm_list:
  26             key_len = algo.key_len_list[0]
  27             """
  28             iv_len must be set 'manually' because it depends on algorithm and bcm
  29             If we have inaproppriate combination, is there another way to set it?
  30             """
  31             iv_len = containers.default_iv_len(algo_name, bcm_name)
  32             valid = str(int(bcm_name in algo.bcm_list.iterkeys()))
  33
  34             write_set(algo_name, bcm_name, key_len, iv_len, out_file, valid)
  35
  36 def check_key_len_for_algo(out_file):
  37     add_description(out_file, 'check key_len for algorithm')
  38     """
  39     Initialization Vector length is constant in this test,
  40     because in all cases bcm: ECB or NONE is used
  41     """
  42     iv_len = 0
  43
  44     for algo_name, algo in containers.valid_database.iteritems():
  45         add_description(out_file, algo_name)
  46         for key_len in containers.key_length_list:
  47             bcm = filter(lambda x: x == 'ECB' or x == 'NONE', algo.bcm_list)[0]
  48             valid = str(int(key_len in algo.key_len_list))
  49             write_set(algo_name, bcm, key_len, iv_len, out_file, valid)
  50
  51 def check_iv_len_for_algo_bcm(out_file):
  52     add_description(out_file, 'check iv_len for algorithm and bcm')
  53
  54     for algo_name, algo in containers.valid_database.iteritems():
  55         add_description(out_file, algo_name)
  56         for bcm_name, bcm in algo.bcm_list.iteritems():
  57             for iv_len in containers.iv_length_list:
  58                 key_len = algo.key_len_list[0]
  59                 valid = str(int(iv_len in bcm.iv_len_list))
  60                 write_set(algo_name, bcm_name, key_len, iv_len, out_file, valid)
  61
  62 def generate_valid_combs_only(out_file, bcm_list):
  63     add_description(out_file, 'Proper sets for encrypt-decrypt comparison')
  64
  65     for algo_name, algo in containers.valid_database.iteritems():
  66         add_description(out_file, algo_name)
  67         for bcm in set(algo.bcm_list).intersection(set(bcm_list)):
  68             for key_len in set(algo.key_len_list).intersection(set(containers.key_length_list)):
  69                 for iv_len in set(algo.bcm_list[bcm].iv_len_list).intersection(\
  70                 set(containers.iv_length_list)):
  71                     write_set(algo_name, bcm, key_len, iv_len, out_file)
  72
  73 def generate_combs(out_file):
  74     check_bcm_for_algo(out_file)
  75     check_key_len_for_algo(out_file)
  76     check_iv_len_for_algo_bcm(out_file)
  77
  78 def generate_tag_len_comb_for_algo_bcm(out_file, algo_name, bcm_name):
  79     add_description(out_file, 'Check tag_len for algo and bcm')
  80     algo = containers.valid_database[algo_name]
  81     bcm = algo.bcm_list[bcm_name]
  82     key_len = algo.key_len_list[0]
  83
  84     add_description(out_file, algo_name)
  85     add_description(out_file, bcm_name)
  86     iv_len = containers.default_iv_len(algo, bcm)
  87     for tag_len in containers.tag_len_list:
  88         valid = str(int(tag_len in bcm.tag_len_list))
  89         write_set(algo_name, bcm_name, key_len, iv_len, out_file, valid, tag_len)
  90
  91 def generate_combs(out_file):
  92     check_bcm_for_algo(out_file)
  93     check_key_len_for_algo(out_file)
  94     check_iv_len_for_algo_bcm(out_file)
  95
  96 def main():
  97     file_name = 'encrypt_param_comb.txt'
  98     out_file = open(file_name, 'w')
  99     generate_combs(out_file)
 100     out_file.close()
 101
 102     file_name = 'encrypt_valid_param.txt'
 103     out_file = open(file_name, 'w')
 104     exclude_gcm_ccm_wrap = filter(lambda x: x != 'GCM' and x != 'CCM' and x != 'WRAP', containers.bcm_list)
 105     generate_valid_combs_only(out_file, exclude_gcm_ccm_wrap)
 106     out_file.close()
 107
 108     file_name = 'encrypt_aes_gcm_tag_len.txt'
 109     out_file = open(file_name, 'w')
 110     generate_tag_len_comb_for_algo_bcm(out_file, 'AES', 'GCM')
 111     out_file.close()
 112
 113     file_name = 'encrypt_aes_ccm_tag_len.txt'
 114     out_file = open(file_name, 'w')
 115     generate_tag_len_comb_for_algo_bcm(out_file, 'AES', 'CCM')
 116     out_file.close()
 117
 118 if __name__ == "__main__":
 119     main()