gener.rb

   1 #!/usr/bin/ruby
   2
   3 @public_repo='./public/'
   4
   5 @private_repo_base='./private/'
   6
   7 @bin_dir='./bins/'
   8
   9 @names=%w[cercei tyrion jaime tywin ned aria bran]
  10
  11 @security_level=4
  12
  13
  14 def reinit_dir (dir)
  15   system('rm', '-rf', "./#{dir}")
  16   Dir.mkdir dir
  17   File.chmod(0700, dir)
  18 end
  19
  20
  21
  22 def regenerate_keys
  23   def spawn_publ_importer(gpg_publ_cmd)
  24     r, w = IO.pipe
  25
  26     spawn(gpg_publ_cmd, :in => r)
  27     r.close
  28
  29     w
  30   end
  31
  32   def gen_key (gpg_user_cmd_base, name)
  33     r,w = IO.pipe
  34
  35     pid = spawn(gpg_user_cmd_base + " --gen-key -", :in => r)
  36     r.close
  37
  38     w.puts "%echo Generating #{name}"
  39     w.puts "Key-Type: RSA"
  40     w.puts "Key-Length: 2048"
  41     w.puts "Name-Real: #{name}"
  42     w.puts "Name-Email: #{name}@westeros.com"
  43     w.puts "%commit"
  44
  45     w.close
  46
  47     Process.wait pid
  48   end
  49
  50   def export_key (gpg_user_cmd_base, sink_pipe)
  51     system(gpg_user_cmd_base + " --export", :out => sink_pipe)
  52   end
  53
  54
  55   reinit_dir @public_repo
  56
  57   reinit_dir @private_repo_base
  58
  59   sink_pipe = spawn_publ_importer "gpg --batch --homedir #{@public_repo} --import"
  60
  61   @names.each do |name|
  62     private_repo = @private_repo_base + name
  63
  64     reinit_dir private_repo
  65
  66     gpg_user_cmd_base = "gpg --batch --homedir ./#{private_repo}"
  67
  68     gen_key gpg_user_cmd_base, name
  69
  70     export_key gpg_user_cmd_base, sink_pipe
  71   end
  72
  73   sink_pipe.close
  74
  75   Process.waitall
  76 end
  77
  78 # returns an array of key IDs
  79 def list_keys
  80   r,w = IO.pipe
  81
  82   pid = spawn("gpg --batch --with-colons -k --homedir #{@public_repo}", :out => w)
  83   w.close
  84
  85   key_list = []
  86
  87   while r.gets
  88     line_data = $_.split(":")
  89     if line_data[0] == 'pub'
  90       key_list << line_data[4]
  91     end
  92   end
  93
  94   r.close
  95
  96   Process.wait pid
  97
  98   key_list
  99 end
 100
 101 def spawn_sha_sink
 102   r, w = IO.pipe
 103
 104   spawn('sha256sum -b', :in => r)
 105   r.close
 106
 107   w
 108 end
 109
 110 def generate_bins (key_sink)
 111   def generate_key_chunk
 112     IO.read('/dev/urandom', 512)
 113   end
 114
 115   def write_bin (number, chunk, keys)
 116     bin_name = @bin_dir + '%02X' % number
 117     receivers = keys.map { |k| "-r #{k}"}.join(' ')
 118
 119     r,w = IO.pipe
 120
 121     gpg_call = "gpg --batch --always-trust --homedir #{@public_repo} #{receivers} -o #{bin_name} -e"
 122
 123     pid = spawn(gpg_call, :in => r)
 124     r.close
 125
 126     w.write(chunk)
 127
 128     w.close
 129
 130     Process.wait pid
 131   end
 132
 133   def combine_keys (&block)
 134     gap_target_count = @security_level - 1
 135     key_list = list_keys
 136
 137     raise "Invlid security level" unless gap_target_count > 0
 138     raise "Security level is too high" unless gap_target_count < key_list.size
 139
 140     list_keys.combination(key_list.size - gap_target_count, &block)
 141   end
 142
 143   reinit_dir @bin_dir
 144
 145   num = 0
 146
 147   combine_keys do |c|
 148     chunk = generate_key_chunk
 149     key_sink.write(chunk)
 150     write_bin(num, chunk, c)
 151     num += 1
 152   end
 153
 154
 155   key_sink.close
 156   Process.waitall
 157 end
 158
 159 def decrypt_key (rings)
 160   def list_bins
 161     # enumerate all bins in alphabetical order
 162     (Dir.entries(@bin_dir) - ['.', '..']).sort.map do |x|
 163       @bin_dir + x
 164     end
 165   end
 166
 167   bin_list = list_bins
 168
 169   chunks = bin_list.clone
 170
 171   todo_count = bin_list.size
 172
 173   for ring in rings
 174     break if todo_count <= 0
 175
 176     bin_list.each_index do |bi|
 177       next if bin_list[bi] == nil
 178
 179       r,w = IO.pipe
 180
 181       pid = spawn("gpg --batch --homedir #{ring} -d #{bin_list[bi]}", :out => w, :err => '/dev/null')
 182       w.close
 183
 184       ch = r.read
 185
 186       r.close
 187       Process.wait pid
 188       if $?.exitstatus == 0
 189         bin_list[bi] = nil
 190         chunks[bi] = ch
 191         todo_count -= 1
 192       end
 193     end
 194   end
 195
 196   raise "Cannot decrypt some of the bins: #{bin_list.inspect}" if todo_count > 0
 197
 198   yield chunks.join
 199 end
 200
 201 #regenerate_keys
 202
 203 #generate_bins (spawn_sha_sink)
 204
 205 decrypt_key %w{
 206   ./private/aria
 207   ./private/jaime
 208   ./private/cercei
 209   ./private/tywin
 210 } do |key|
 211   sink = spawn_sha_sink
 212   sink.write key
 213   sink.close
 214
 215   Process.waitall
 216 end