simple-gnupg-keyserver 1.0.0

data/.gitignore

@@ -0,0 +1,6 @@
+Manifest.txt
+*.gem
+/pkg/
+/tmp/
+/rdoc/
+

data/History.txt

@@ -0,0 +1,7 @@
+=== 1.0.0 / 2015-03-08
+
+* 1 major enhancement
+
+  * Birthday!
+
+

data/README.rdoc

@@ -0,0 +1,129 @@
+= rGem-simple-gnupg-keyserver
+
+home :: https://github.com/stephengaito/rGem-simple-gnupg-keyserver
+
+== DESCRIPTION:
+
+SimpleHKP is a simple Ruby/rack based GnuPG HKP key server.
+
+Its sole task is to supply a limited number of GnuPG _public_ keys 
+to/from MonkeySphere on a limited number of machines/servers. It is 
+_not_ meant to server hundreds of keys, so it is not meant as a truely 
+public key server.
+
+If you need to run your own _large_ scale production Key Sever then use 
+{SKS}[https://bitbucket.org/skskeyserver/sks-keyserver/wiki/Home]. You 
+might want to read Paul Bauer's {How To Setup A Free PGP Key Server in 
+Ubuntu}[http://www.bauer-power.net/2010/05/how-to-setup-free-pgp-key-server-in.html].
+
+=== Key storage
+
+Since this is a _simple_ key server, all keys are stored as flat 
+ASCII armored files in the "keys" directory.
+
+=== Key search
+
+For each uploaded key, the key's "gpg2 --with-fingerprint --with-colon" 
+output (key data) is stored in an internal ruby Hash using the key's 
+file name as hash key. All searches become Ruby regular expressions 
+which are matched against each key's key data.
+
+=== Security:
+
+_ALL_ uploaded key data is passed through the external gpg2 command. 
+Any security weaknesses of gpg2 are weaknesses of this SimpleHKP rack 
+application.
+
+This rack application is written in Ruby, so any security weaknesses of 
+Ruby and/or the Ruby web-server you are using are also weaknesses of 
+this SimpleHKP rack application.
+
+By default all files associated with the normal running of the 
+SimpleHKP rack application are stored in the "simpleHKP" directory of 
+the current working directory. This "simpleHKP" directory _SHOULD_
+_NOT_ be accessible from any other web-server (such as NGinx).
+
+This rack application is intentionally as self contained and simple as 
+possible.  If you have any security concerns, this rack application is 
+easily readable.
+
+== SYNOPSIS:
+
+A typical rackup.ru file might be:
+
+  require 'simpleHKP'
+
+  simpleHKPoptions = {
+    ... some options ...
+  }
+
+  run SimpleHKP.new(simpleHKPoptions)
+
+Your webserver should be configured to bind to ports 11371 (for use as 
+an HKP keyserver) and 80 (for use by standard browsers).
+
+Options can be set by creating a SimpleHKP instance with a hash of 
+key/value pairs.
+
+The current default options are:
+
+  defaultOptions = {
+    'debug'        => false,       # should debug output to logged?
+    'simpleHKPdir' => 'simpleHKP', # base disk path to simpleHKP disk space
+    'keyDir'       => 'keys',      # subdir to key storage directory
+    'mediaDir'     => 'media',     # subdir to any css, js, images etc
+    'htmlDir'      => 'html',      # subdir to html partials
+    'mimeMap'      => {            # a file ext to mime mapping
+      'css'  => 'text/css',
+      'html' => 'text/html',
+      'js'   => 'text/javascript'
+    }
+  }
+
+The following HTML partials can be used to over-ride the web pages for 
+the use of humans:
+
+* header.html
+* defaultBody.html
+* lookupForm.html
+* uploadForm.html
+* footer.html
+
+== REQUIREMENTS:
+
+There are explicitly no external Ruby requirements other than Ruby and 
+a Ruby webserver (such as puma)
+
+The webserver *requires* GnuPG2 installed.
+
+== INSTALL:
+
+To install the simple-gnupg-keyserver gem:
+
+  $ gem install simple-gnupg-keyserver
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2015 Stephen Gaito
+
+Permission is hereby granted, free of charge, to any person obtaining a 
+copy of this software and associated documentation files (the 
+'Software'), to deal in the Software without restriction, including 
+without limitation the rights to use, copy, modify, merge, publish, 
+distribute, sublicense, and/or sell copies of the Software, and to 
+permit persons to whom the Software is furnished to do so, subject to 
+the following conditions:
+
+The above copyright notice and this permission notice shall be included 
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS 
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/Rakefile

@@ -0,0 +1,39 @@
+# -*- ruby -*-
+
+# To release this ruby gem type:
+#  rake release VERSION=x.y.z
+# where x.y.z is the appropriate version number of this gem.
+
+require 'rubygems'
+require 'hoe'
+
+# Hoe.plugin :compiler
+# Hoe.plugin :gem_prelude_sucks
+# Hoe.plugin :inline
+# Hoe.plugin :minitest
+# Hoe.plugin :racc
+# Hoe.plugin :rubyforge
+
+# generate the Manifest.txt file (before we invoke Hoe.spec)
+manifest = FileList[
+  '.gitignore', 
+  'History.*', 
+  'README.*', 
+  'Rakefile',
+  'lib/**/*.rb',
+  'test/**/*.rb',
+];
+File.open('Manifest.txt', 'w') do | manifestFile |
+  manifestFile.puts("Manifest.txt");
+  manifestFile.write(manifest.to_a.join("\n"));
+end
+
+# For dependency documentation see:
+#   http://guides.rubygems.org/patterns/
+
+Hoe.spec 'simple-gnupg-keyserver' do
+  developer('Stephen Gaito', 'stephen@perceptisys.co.uk')
+  license 'MIT'
+end
+
+# vim: syntax=ruby

data/lib/simpleHKP.rb

@@ -0,0 +1,504 @@
+require 'uri'
+require 'pp'
+#require 'yaml'
+require 'fileutils'
+
+# This code was inspired by:
+#   Sebi2020's Informatikonline Easy-HKP
+#     https://github.com/Sebi2020/easy-hkp
+
+# It conforms to:
+# The OpenPGP HTTP Keyserver Protocol (HKP)
+#   draft-shaw-openpgp-hkp-00.txt
+#     http://tools.ietf.org/html/draft-shaw-openpgp-hkp-00
+
+# See also the doc/DETAILS file in the gnupg2 source code
+
+# Copyright (C) 2015 Stephen Gaito
+#
+# (The MIT License)
+#
+# Copyright (c) 2015 Stephen Gaito
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# 'Software'), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+class SimpleHKP
+
+  VERSION = "1.0.0"
+
+  def loadKeys
+    @keyLookupData = Hash.new
+    puts "SimpleHKP: loading keys" if @debug
+    Dir.glob(@keyDir+'/**/*.asc') do | aFile |
+      puts aFile if @debug
+      @keyLookupData[aFile] = `gpg2 --with-fingerprint --with-colons #{aFile}`
+      puts @keyLookupData[aFile] if @debug
+    end
+    puts "SimpleHKP: finished loading keys" if @debug
+  end
+
+  def loadHtml
+    puts "SimpleHKP: loading html partials" if @debug
+    Dir.chdir(@htmlDir) do
+      @headerHtml = "<html><head></head><body class=\"simpleHKP-body\">\n"
+      @headerHtml << "<p><a href=\"/\">SimpleHKP</a></p>"
+      @headerHtml = File.open('header.html','r').read if
+        File.exists?('header.html')
+      puts @headerHtml if @debug
+
+      @defaultBody = ""
+      @defaultBody << "<h1 class=\"simpleHKP-welcome\">Welcome to SimpleHKP</h1>\n"
+      @defaultBody << "<ul class=\"simpleHKP-tasksList\">\n"
+      @defaultBody << "  <li class=\"simpleHKP-taskItem\"><a href=\"lookup?op=form\">Search</a></li>\n"
+      @defaultBody << "  <li class=\"simpleHKP-taskItem\"><a href=\"add\">Upload new key</a></li>\n"
+      @defaultBody << "  <li class=\"simpleHKP-taskItem\"><a href=\"reload\">Reload existing keys</a></li>\n"
+      @defaultBody << "</ul>\n"
+      @defaultBody = File.open('defaultBody.html','r').read if
+        File.exists?('defaultBody.html')
+      puts @defaultBody if @debug
+
+      @lookupForm = ""
+      @lookupForm << "<div class=\"simpleHKP-lookupFormDiv\">\n"
+      @lookupForm << "  <h1 class=\"simpleHKP-lookupFormTitle\">Search GnuPG keys</h1>\n"
+      @lookupForm << "  <form action=\"lookup\" method=\"get\" id=\"simpleHKP-lookupForm\">\n"
+      @lookupForm << "    <input type=\"text\" name=\"search\" size=\"80\" />\n"
+      @lookupForm << "    <input type=\"hidden\" name=\"op\" value=\"index\" />\n"
+      @lookupForm << "    <input type=\"submit\" value=\"Search\" />\n"
+      @lookupForm << "  </form>\n"
+      @lookupForm << "</div>\n"
+      @lookupForm = File.open('lookupForm.html','r').read if
+        File.exists?('lookupForm.html')
+      puts @lookupForm if @debug
+
+      @uploadForm = ""
+      @uploadForm << "<div class=\"simpleHKP-uploadFormDiv\">\n"
+      @uploadForm << "  <h1 class=\"simpleHKP-uploadFormTitle\">Paste GnuPG key to be uploaded below</h1>\n"
+      @uploadForm << "  <form action=\"add\" method=\"post\" id=\"simpleHKP-uploadForm\">\n"
+      @uploadForm << "    <textarea name=\"keytext\" form=\"simpleHKP-uploadForm\" rows = \"30\" cols=\"70\" ></textarea>\n"
+      @uploadForm << "    <input type=\"submit\" value=\"Upload\" />\n"
+      @uploadForm << "  </form>\n"
+      @uploadForm << "</div>\n"
+      @uploadForm = File.open('uploadForm.html','r').read if
+        File.exists?('uploadForm.html')
+      puts @uploadForm if @debug
+
+      @footer = "</body></html>\n"
+      @footer = File.open('footer.html','r').read if
+        File.exists?('footer.html')
+      puts @footer if @debug
+    end
+    puts "SimpleHKP: finished loading html partials" if @debug
+  end
+
+  def initialize(options = {})
+    #
+    # setup the default options
+    #
+    defaultOptions = {
+      'debug'        => false,
+      'simpleHKPdir' => 'simpleHKP',
+      'keyDir'       => 'keys',
+      'mediaDir'     => 'media',
+      'htmlDir'      => 'html',
+      'mimeMap'      => {
+        'css'  => 'text/css',
+        'html' => 'text/html',
+        'js'   => 'text/javascript'
+      }
+    }
+    #
+    # merge the options mimeMap into the default options mimeMap
+    #
+    defaultOptions['mimeMap'].merge!(delete(options['mimeMap'])) if
+      options.has_key?('mimeMap')
+    #
+    # merge in the rest of the options into the default options
+    #
+    @options  = defaultOptions.merge(options)
+    #
+    # setup the required variables
+    #
+    @debug    = @options['debug']
+    @baseDir  = @options['simpleHKPdir']
+    @keyDir   = @baseDir+'/'+@options['keyDir']
+    @mediaDir = @baseDir+'/'+@options['mediaDir']
+    @htmlDir  = @baseDir+'/'+@options['htmlDir']
+    @mimeMap  = @options['mimeMap']
+    if @debug then
+      puts "SimpleHKP options:"
+      pp @options
+    end
+    #
+    # ensure the required directories all exist
+    #
+    FileUtils.mkdir_p(@keyDir)
+    FileUtils.mkdir_p(@mediaDir)
+    FileUtils.mkdir_p(@htmlDir)
+    #
+    # load the existing keys and the html partials
+    loadKeys
+    loadHtml
+  end
+
+  def ppEnv(env)
+    Dir.pwd+' '+
+#    '['+URI.decode_www_form(env["rack.input"].rewind.read).pretty_inspect+']'+
+    env.pretty_inspect
+  end
+
+  def replyInternalError(env, exception)
+    @statusCode = 500
+    @body << @headerHtml
+    @body << "<p>Internal server error!</p>\n"
+    @body << "<pre>#{exception}</pre>\n" if @debug
+    @body << @footer
+    if @debug then
+      puts "\n\n-------------------------------------------------------------"
+      puts exception
+      puts "-------------------------------------------------------------"
+      puts ppEnv(env)
+      puts "-------------------------------------------------------------\n\n"
+    end
+  end
+
+  def replyNotImplemented
+    @statusCode = 501
+    @body << @headerHtml
+    @body << '<p>Not implemented!<p>'
+    @body << @footer
+  end
+
+  def replyBadRequest(message)
+    @statusCode = 400
+    @body << @headerHtml
+    @body << '<p>Bad request!</p>'
+    @body << "<p>#{message}</p>"
+    @body << @footer
+  end
+
+  def replyNotFound
+    @statusCode = 404
+    @body << @headerHtml
+    @body << '<p>Not found!</p>'
+    @body << @footer
+  end
+
+  def replyDefaultBody
+    @body << @headerHtml
+    @body << @defaultBody
+    @body << @footer
+  end
+
+  def replyLookupForm
+    @body << @headerHtml
+    @body << @lookupForm
+    @body << @footer
+  end
+
+  def replyUploadForm
+    @body << @headerHtml
+    @body << @uploadForm
+    @body << @footer
+  end
+
+  def replyFile(env)
+    fileName = env['REQUEST_PATH'].sub(/^.*\/media\//,'')
+    if File.exists?(fileName) then
+      fileExt = File.extname(fileName).sub(/^\./,'')
+      @header['Content-Type'] = @mimeMap[fileExt] if
+        @mimeMap.has_key?(fileExt)
+      @body << File.open(fileName,'r').read
+    end
+  end
+
+  def storeKey(env)
+    #
+    # decode the post data
+    #
+    keys = URI.decode_www_form(env['rack.input'].read)
+    #
+    # ensure we are being sent a key
+    #
+    return replyBadRequest("No keytext field in post data") unless
+      keys[0][0] =~ /keytext/
+    pp keys[0][1] if @debug
+    #
+    # send the key data through gpg2 to extract the keyID
+    #
+    gpgKeyData = ""
+    IO.popen('gpg2 --with-fingerprint --with-colons -', 'r+') do | pipe |
+      puts 'gpg2 --with-fingerprint --with-colons -' if @debug
+      pipe.write(keys[0][1])
+      pipe.close_write
+      gpgKeyData = pipe.read
+    end
+    puts gpgKeyData if @debug
+    #
+    # look for the keyID of the public key
+    #
+    keyID   = nil
+    gpgKeyData.each_line do | aLine |
+      keyData = aLine.split(/:/)
+      next unless keyData[0] =~ /pub/
+      keyID   = keyData[4]
+      break
+    end
+    return replyBadRequest("No keyID found in gpg2 result using uploaded keytext data") if keyID.nil?
+    #
+    # record the fact that we have stored this key for later lookup
+    #
+    keyFile = "#{@keyDir}/#{keyID}.asc"
+    @keyLookupData[keyFile] = gpgKeyData
+    pp @keyLookupData if @debug
+    #
+    # store this key as a flat file with the name of the keyID.asc
+    #
+    File.open(keyFile,'w') do | keyFile |
+      keyFile.write(keys[0][1])
+    end
+    #
+    # return OK
+    #
+    @statusCode = 200
+    @body << @headerHtml
+    @body << "<h1 class=\"simpleHKP-storedKey\">Stored key: [#{keyID}]</h1>"
+    @body << "<h2 class=\"simpleHKP-keyDataKeyID\">Key data for key: [#{keyID}]</h2>"
+    @body << '<pre class="simpleHKP-keyData">'+gpgKeyData+"</pre>\n"
+    @body << @footer
+  end
+
+  def lookUpKey(queryString)
+    return replyBadRequest("No search field in queryString") unless
+      queryString.has_key?('search')
+    #
+    # normalize the search string
+    #
+    searchString = queryString['search']
+    searchString.gsub!(/0x/,'')
+    searchRegexp = Regexp.new(searchString, 
+                              Regexp::IGNORECASE | Regexp::MULTILINE)
+    puts searchRegexp if @debug
+    #
+    # (linearly) look through the hash of known keys
+    # looking for the FIRST match
+    #
+    keyFile = nil
+    @keyLookupData.each_pair do | aKeyFile, keyData |
+      next unless keyData =~ searchRegexp
+      puts "FOUND #{aKeyFile} (#{keyData})" if @debug
+      keyFile = aKeyFile
+      break
+    end
+    return replyNotFound if keyFile.nil?
+
+    if queryString.has_key?('options') &&
+      queryString['options'] == 'mr' then
+      #
+      # return the key data in machine readable format
+      #
+      @header = {
+        'Content-Type' => 'application/pgp-keys; charset=utf-8',
+        'Content-Disposition' =>
+          'attachment; filename=' + keyFile
+      }
+      puts @header if @debug
+      @body << File.open(keyFile,'r').read
+    else
+      #
+      # return the key data for a human to read
+      #
+      keyID = File.basename(keyFile, '.*')
+      @body << @headerHtml
+      @body << @lookupForm
+      @body << '<h1 class="simpleHKP-keyAsckeyId">Key: '+keyID+'</h1>'
+      @body << '<h2 class="simpleHKP-keyDataTitle">Key data:</h2>'
+      @body << '<pre class="simpleHKP-keyData">'
+      @body << @keyLookupData[keyFile]
+      @body << '</pre>'
+      @body << '<h2 class="simpleHKP-keyAscTitle">Key contents:</h2>'
+      @body << '<pre class="simpleHKP-keyAsc">'
+      @body << File.open(keyFile,'r').read
+      @body << '</pre>'
+      @body << @footer
+    end
+  end
+
+  def extractKeyInfo(keyFile)
+    keyInfo = Array.new
+    return keyInfo unless @keyLookupData.has_key?(keyFile)
+    # 
+    # extract the detailed key information from the PUBLIC key
+    # see the doc/DETAILS file in the gnupg2 source code
+    #
+    @keyLookupData[keyFile].each_line do | aLine |
+      next unless aLine =~ /^pub/
+      keyData = aLine.split(/:/)
+      keyInfo.push(keyData[9]) # -1 = user ID
+      keyInfo.push(keyData[4]) #  0 = key ID
+      keyInfo.push(keyData[3]) #  1 = key type (algorithm)
+      keyInfo.push(keyData[2]) #  2 = key length
+      keyInfo.push(keyData[5]) #  3 = creation date
+      keyInfo.push(keyData[6]) #  4 = expiration date
+      keyInfo.push(keyData[1]) #  5 = flags
+    end
+
+    keyInfo
+  end
+
+  def indexKeys(queryString)
+    return replyBadRequest("No search field in queryString") unless
+      queryString.has_key?('search')
+    #
+    # normalize the search string
+    #
+    searchString = queryString['search']
+    searchString.gsub!(/0x/,'')
+    searchRegexp = Regexp.new(searchString, 
+                              Regexp::IGNORECASE | Regexp::MULTILINE)
+    puts searchRegexp if @debug
+    #
+    # accumulate the keyFiles of any keys that match the serach
+    #
+    keys = Array.new
+    @keyLookupData.each_pair do | aKeyFile, keyData |
+      next unless keyData =~ searchRegexp
+      puts "FOUND #{aKeyFile} (#{keyData})" if @debug
+      keys.push(aKeyFile)
+    end
+
+    if queryString.has_key?('options') &&
+      queryString['options'] == 'mr' then
+      #
+      # return a machine readable list of the keys found
+      #
+      @header = { 'Content-Type' => 'text/plain' }
+      @body << "info:1:#{keys.size}\n"
+      keys.each do | aKeyFile |
+        keyInfo = extractKeyInfo(aKeyFile)
+        next if keyInfo.empty?
+        userID    = keyInfo.shift
+        @body << "pub:#{keyInfo.join(':')}\n"
+        keyID     = keyInfo.shift
+        keyType   = keyInfo.shift
+        keyLength = keyInfo.shift
+        @body << "uid:#{userID}:#{keyInfo.join(':')}\n"
+        @body << "\n"
+      end
+    else
+      #
+      # return a (simple) human readable list of the keys found
+      #
+      @body << @headerHtml
+      @body << @lookupForm
+      @body << '<h1 class="simpleHKP-searchString">Keys matching: ['+searchString+']</h1><ul class="simpleHKP-searchList">'
+      keys.each do | aKeyFile |
+        keyInfo   = extractKeyInfo(aKeyFile)
+        userID    = keyInfo.shift
+        keyID     = keyInfo.shift
+        keyType   = keyInfo.shift
+        keyLength = keyInfo.shift
+        created   = keyInfo.shift
+        expires   = keyInfo.shift
+        flags     = keyInfo.shift
+        keyStr = "  <li class=\"simpleHKP-searchItem\"><a href=\"lookup?op=get&search=#{keyID}\">#{keyID}:&nbsp;"
+        keyStr << userID
+        keyStr <<  "</a></li>\n"
+        @body << keyStr
+      end
+      @body << '</ul>'
+      @body << @footer
+    end
+    pp @body if @debug
+  end
+
+  def decodeQueryString(env)
+    queryHash = Hash.new
+    URI.decode_www_form(env['QUERY_STRING']).each do | aKeyValue |
+      queryHash[aKeyValue[0]] = aKeyValue[1]
+    end
+    queryHash
+  end
+
+  def call(env)
+    #
+    # initialize the response parts
+    #
+    @statusCode = 200
+    @header     = {"Content-Type" => "text/html; charset=utf-8"}
+    @body       = Array.new
+    #
+    # decode the request
+    #
+    begin
+      puts ppEnv(env) if @debug
+      case env['REQUEST_METHOD']
+      when 'POST'
+        case env['REQUEST_PATH'] 
+        when /add$/i
+          storeKey(env)
+        else 
+          replyNotImplemented
+        end
+      when 'GET'
+        case env['REQUEST_PATH'] 
+        when /add$/i
+          replyUploadForm
+        when /lookup$/i
+          queryString = decodeQueryString(env)
+          if queryString.has_key?('op') then
+            case queryString['op']
+            when /get/i
+              lookUpKey(queryString)
+            when /index/i
+              indexKeys(queryString)
+            else
+              replyLookupForm
+            end
+          else
+            replyBadRequest("No op field in queryString")
+          end
+        when /media\//i
+          replyFile(env)
+        when /reload$/i
+          loadKeys
+          loadHtml
+          replyDefaultBody
+        else
+          replyDefaultBody
+        end
+      else
+        replyBadRequest("Unknown request method")
+      end
+    rescue Exception => exception
+      replyInternalError(env, exception)
+    end
+    #
+    # send the response
+    #
+    if @debug then
+      puts "SimpleHKP reply:"
+      pp @statusCode
+      pp @header
+      puts @body.join("\n")
+    end
+    [ @statusCode, @header, @body.flatten ]
+  end
+
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: simple-gnupg-keyserver
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Stephen Gaito
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.13'
+description: ! "SimpleHKP is a simple Ruby/rack based GnuPG HKP key server.\n\nIts
+  sole task is to supply a limited number of GnuPG _public_ keys \nto/from MonkeySphere
+  on a limited number of machines/servers. It is \n_not_ meant to server hundreds
+  of keys, so it is not meant as a truely \npublic key server.\n\nIf you need to run
+  your own _large_ scale production Key Sever then use \n{SKS}[https://bitbucket.org/skskeyserver/sks-keyserver/wiki/Home].
+  You \nmight want to read Paul Bauer's {How To Setup A Free PGP Key Server in \nUbuntu}[http://www.bauer-power.net/2010/05/how-to-setup-free-pgp-key-server-in.html]."
+email:
+- stephen@perceptisys.co.uk
+executables: []
+extensions: []
+extra_rdoc_files:
+- Manifest.txt
+- History.txt
+- README.rdoc
+files:
+- Manifest.txt
+- .gitignore
+- History.txt
+- README.rdoc
+- Rakefile
+- lib/simpleHKP.rb
+homepage: https://github.com/stephengaito/rGem-simple-gnupg-keyserver
+licenses:
+- MIT
+post_install_message: 
+rdoc_options:
+- --main
+- README.rdoc
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: SimpleHKP is a simple Ruby/rack based GnuPG HKP key server
+test_files: []