rnp 0.1.0 → 0.2.0

data/examples/highlevel/decrypt_mem.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require 'io/console'
+
+require_relative '../../lib/rnp'
+
+options = {armored: false, keys_armored: false}
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: #{$0} [options] <seckey> <passphrase>"
+  opts.on('-k', '--keys-armored', 'Keys are ASCII armored') do
+    options[:keys_armored] = true
+  end
+  opts.on('-a', '--armored', 'Input is ASCII armored') do
+    options[:armored] = true
+  end
+  opts.on('-h', '--help', 'Print this help') do
+    puts opts
+    exit
+  end
+end
+parser.parse!
+
+if ARGV.length != 2
+  parser.display
+  exit
+end
+
+seckey_filename = ARGV.shift
+passphrase = ARGV.shift + "\n"
+
+secring = RNP::load_keyring(File.binread(seckey_filename), options[:keys_armored])
+
+$stdin.binmode
+data = $stdin.read
+
+seckey = secring[0]
+decrypted_data = seckey.decrypt(data, passphrase, options[:armored])
+if decrypted_data
+  $stderr.puts 'Decryption succeeded'
+  $stdout.puts decrypted_data
+else
+  $stderr.puts 'Decryption failed!'
+end
+

data/examples/highlevel/encrypt_mem.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+require 'optparse'
+
+require_relative '../../lib/rnp'
+
+options = {armored: false, keys_armored: false}
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: #{$0} [options] <pubkey>"
+  opts.on('-k', '--keys-armored', 'Seckey is ASCII armored') do
+    options[:keys_armored] = true
+  end
+  opts.on('-a', '--armored', 'Output will be ASCII armored') do
+    options[:armored] = true
+  end
+  opts.on('-h', '--help', 'Print this help') do
+    puts opts
+    exit
+  end
+end
+parser.parse!
+
+if ARGV.length != 1
+  parser.display
+  exit
+end
+
+pubkey_filename = ARGV.shift
+
+keyring = RNP::load_keyring(File.binread(pubkey_filename), options[:keys_armored])
+
+pubkey = keyring[0]
+
+$stdin.binmode
+data = $stdin.read
+
+encrypted_data = pubkey.encrypt(data, options[:armored])
+
+$stdout.binmode
+$stdout.puts encrypted_data
+
+if encrypted_data != nil
+  $stderr.puts 'Encryption succeeded'
+else
+  $stderr.puts 'Encryption failed!'
+end
+

data/examples/lowlevel/decrypt_file.rb

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require 'io/console'
+
+require_relative '../../lib/rnp'
+
+options = {armored: false, keys_armored: false}
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: #{$0} [options] <pubkey> <seckey> <input-file> <output-file>"
+  opts.on('-k', '--keys-armored', 'Keys are ASCII armored') do
+    options[:keys_armored] = true
+  end
+  opts.on('-a', '--armored', 'Input file is ASCII armored') do
+    options[:armored] = true
+  end
+  opts.on('-h', '--help', 'Print this help') do
+    puts opts
+    exit
+  end
+end
+parser.parse!
+
+if ARGV.length != 4
+  parser.display
+  exit
+end
+
+pubkey_filename = ARGV.shift
+seckey_filename = ARGV.shift
+input_filename = ARGV.shift
+output_filename = ARGV.shift
+
+# Load pubkey/keyring
+pubkeyring_mem = LibC::calloc(1, LibRNP::PGPKeyring.size)
+pubkeyring = LibRNP::PGPKeyring.new(pubkeyring_mem)
+if 1 != LibRNP::pgp_keyring_fileread(pubkeyring, options[:keys_armored] ? 1 : 0, pubkey_filename)
+  puts 'Errors encountered while loading public keyring.'
+  exit 1
+end
+# Load seckey/keyring
+seckeyring_mem = LibC::calloc(1, LibRNP::PGPKeyring.size)
+seckeyring = LibRNP::PGPKeyring.new(seckeyring_mem)
+if 1 != LibRNP::pgp_keyring_fileread(seckeyring, options[:keys_armored] ? 1 : 0, seckey_filename)
+  puts 'Errors encountered while loading secret keyring.'
+  exit 1
+end
+
+pgpio = LibRNP::PGPIO.new
+stdout_fp = LibC::fdopen($stdout.to_i, 'w')
+stderr_fp = LibC::fdopen($stderr.to_i, 'w')
+pgpio[:outs] = stdout_fp
+pgpio[:errs] = stderr_fp
+pgpio[:res] = stdout_fp
+
+rd, wr = IO.pipe
+print 'Enter passphrase: '
+passphrase = $stdin.noecho(&:gets)
+puts ''
+wr.write passphrase
+wr.close
+passfp = LibC::fdopen(rd.to_i, 'r')
+
+armored = options[:armored] ? 1 : 0
+overwrite = 1
+sshkeys = 0
+numtries = 1
+
+ret = LibRNP::pgp_decrypt_file(pgpio, input_filename, output_filename, seckeyring, pubkeyring, armored, overwrite, sshkeys, passfp, numtries, nil)
+rd.close
+LibC::fclose(passfp)
+if ret == 1
+  puts 'Success'
+else
+  puts 'Failed!'
+end
+

data/examples/lowlevel/decrypt_mem.rb

@@ -0,0 +1,80 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require 'io/console'
+
+require_relative '../../lib/rnp'
+
+options = {armored: false, keys_armored: false}
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: #{$0} [options] <pubkey> <seckey> <passphrase>"
+  opts.on('-k', '--keys-armored', 'Keys are ASCII armored') do
+    options[:keys_armored] = true
+  end
+  opts.on('-a', '--armored', 'Input is ASCII armored') do
+    options[:armored] = true
+  end
+  opts.on('-h', '--help', 'Print this help') do
+    puts opts
+    exit
+  end
+end
+parser.parse!
+
+if ARGV.length != 3
+  parser.display
+  exit
+end
+
+pubkey_filename = ARGV.shift
+seckey_filename = ARGV.shift
+passphrase = ARGV.shift + "\n"
+
+# Load pubkey/keyring
+pubkeyring_mem = LibC::calloc(1, LibRNP::PGPKeyring.size)
+pubkeyring = LibRNP::PGPKeyring.new(pubkeyring_mem)
+if 1 != LibRNP::pgp_keyring_fileread(pubkeyring, options[:keys_armored] ? 1 : 0, pubkey_filename)
+  puts 'Errors encountered while loading public keyring.'
+  exit 1
+end
+# Load seckey/keyring
+seckeyring_mem = LibC::calloc(1, LibRNP::PGPKeyring.size)
+seckeyring = LibRNP::PGPKeyring.new(seckeyring_mem)
+if 1 != LibRNP::pgp_keyring_fileread(seckeyring, options[:keys_armored] ? 1 : 0, seckey_filename)
+  puts 'Errors encountered while loading secret keyring.'
+  exit 1
+end
+
+pgpio = LibRNP::PGPIO.new
+stderr_fp = LibC::fdopen($stderr.to_i, 'w')
+# send all to stderr
+pgpio[:outs] = stderr_fp
+pgpio[:errs] = stderr_fp
+pgpio[:res] = stderr_fp
+
+rd, wr = IO.pipe
+wr.write passphrase
+wr.close
+passfp = LibC::fdopen(rd.to_i, 'r')
+
+armored = options[:armored] ? 1 : 0
+sshkeys = 0
+numtries = 1
+
+$stdin.binmode
+data = $stdin.read
+data_buf = FFI::MemoryPointer.new(:uint8, data.bytesize)
+data_buf.put_bytes(0, data)
+memory_ptr = LibRNP::pgp_decrypt_buf(pgpio, data_buf, data_buf.size, seckeyring, pubkeyring, armored, sshkeys, passfp, numtries, nil)
+rd.close
+LibC::fclose(passfp)
+
+memory = LibRNP::PGPMemory.new(memory_ptr)
+if not memory.null?
+  $stdout.binmode
+  $stdout.puts memory[:buf].read_bytes(memory[:length])
+  LibRNP::pgp_memory_free(memory)
+  $stderr.puts 'Success'
+else
+  $stderr.puts 'Failed!'
+end
+

data/examples/lowlevel/encrypt_file.rb

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+require 'optparse'
+
+require_relative '../../lib/rnp'
+
+options = {armored: false, keys_armored: false}
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: #{$0} [options] <pubkey> <input-file> <output-file>"
+  opts.on('-k', '--keys-armored', 'Seckey is ASCII armored') do
+    options[:keys_armored] = true
+  end
+  opts.on('-a', '--armored', 'Output file will be ASCII armored') do
+    options[:armored] = true
+  end
+  opts.on('-h', '--help', 'Print this help') do
+    puts opts
+    exit
+  end
+end
+parser.parse!
+
+if ARGV.length != 3
+  parser.display
+  exit
+end
+
+pubkey_filename = ARGV.shift
+input_filename = ARGV.shift
+output_filename = ARGV.shift
+
+# Load keys/keyring
+keyring_mem = LibC::calloc(1, LibRNP::PGPKeyring.size)
+keyring = LibRNP::PGPKeyring.new(keyring_mem)
+if 1 != LibRNP::pgp_keyring_fileread(keyring, options[:keys_armored] ? 1 : 0, pubkey_filename)
+  puts 'Errors encountered while loading keyring.'
+  exit 1
+end
+# Find first pubkey
+keycount = LibRNP::dynarray_count(keyring, 'key')
+pubkey = nil
+(0..keycount - 1).each {|keyn|
+  key = LibRNP::dynarray_get_item(keyring, 'key', LibRNP::PGPKey, keyn)
+  pubkey = key if LibRNP::pgp_is_key_secret(key) == 0
+  break if pubkey != nil
+}
+if pubkey == nil
+  puts 'No pubkey found'
+  exit 1
+end
+
+pgpio = LibRNP::PGPIO.new
+stdout_fp = LibC::fdopen($stdout.to_i, 'w')
+stderr_fp = LibC::fdopen($stderr.to_i, 'w')
+pgpio[:outs] = stdout_fp
+pgpio[:errs] = stderr_fp
+pgpio[:res] = stdout_fp
+
+armored = options[:armored] ? 1 : 0
+overwrite = 1
+# see pgp_str_to_cipher
+cipher = 'cast5'
+ret = LibRNP::pgp_encrypt_file(pgpio, input_filename, output_filename, pubkey, armored, overwrite, cipher)
+if ret == 1
+  puts 'Success'
+else
+  puts 'Failed!'
+end
+

data/examples/lowlevel/encrypt_mem.rb

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+require 'optparse'
+
+require_relative '../../lib/rnp'
+
+options = {armored: false, keys_armored: false}
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: #{$0} [options] <pubkey>"
+  opts.on('-k', '--keys-armored', 'Seckey is ASCII armored') do
+    options[:keys_armored] = true
+  end
+  opts.on('-a', '--armored', 'Output will be ASCII armored') do
+    options[:armored] = true
+  end
+  opts.on('-h', '--help', 'Print this help') do
+    puts opts
+    exit
+  end
+end
+parser.parse!
+
+if ARGV.length != 1
+  parser.display
+  exit
+end
+
+pubkey_filename = ARGV.shift
+
+# Load keys/keyring
+keyring_mem = LibC::calloc(1, LibRNP::PGPKeyring.size)
+keyring = LibRNP::PGPKeyring.new(keyring_mem)
+if 1 != LibRNP::pgp_keyring_fileread(keyring, options[:keys_armored] ? 1 : 0, pubkey_filename)
+  puts 'Errors encountered while loading keyring.'
+  exit 1
+end
+# Find first pubkey
+keycount = LibRNP::dynarray_count(keyring, 'key')
+pubkey = nil
+(0..keycount - 1).each {|keyn|
+  key = LibRNP::dynarray_get_item(keyring, 'key', LibRNP::PGPKey, keyn)
+  pubkey = key if LibRNP::pgp_is_key_secret(key) == 0
+  break if pubkey != nil
+}
+if pubkey == nil
+  puts 'No pubkey found'
+  exit 1
+end
+
+pgpio = LibRNP::PGPIO.new
+stdout_fp = LibC::fdopen($stdout.to_i, 'w')
+stderr_fp = LibC::fdopen($stderr.to_i, 'w')
+pgpio[:outs] = stdout_fp
+pgpio[:errs] = stderr_fp
+pgpio[:res] = stdout_fp
+
+armored = options[:armored] ? 1 : 0
+# see pgp_str_to_cipher
+cipher = 'cast5'
+$stdin.binmode
+data = $stdin.read
+data_buf = FFI::MemoryPointer.new(:uint8, data.bytesize)
+data_buf.put_bytes(0, data)
+memory_ptr = LibRNP::pgp_encrypt_buf(pgpio, data_buf, data_buf.size, pubkey, armored, cipher)
+
+memory = LibRNP::PGPMemory.new(memory_ptr)
+$stdout.binmode
+$stdout.puts memory[:buf].read_bytes(memory[:length])
+LibRNP::pgp_memory_free(memory)
+
+if not memory.null?
+  $stderr.puts 'Success'
+else
+  $stderr.puts 'Failed!'
+end
+

data/examples/lowlevel/load_pubkey.rb

@@ -0,0 +1,118 @@
+#!/usr/bin/env ruby
+require_relative '../../lib/rnp'
+
+def bignum_byte_count(bn)
+  bn.to_s(16).length / 2
+end
+
+class PublicKey
+  attr_accessor :version,
+                :creation_time,
+                :expiration_time,
+                :public_key_algorithm,
+                :mpi,
+                :userids
+
+  def initialize
+    @version = nil
+    @creation_time = nil
+    @expiration_time = nil
+    @public_key_algorithm = nil
+    @mpi = {}
+
+    @userids = []
+  end
+  
+  def bitcount
+    case @public_key_algorithm
+    when :PGP_PKA_RSA, :PGP_PKA_RSA_ENCRYPT_ONLY, :PGP_PKA_RSA_SIGN_ONLY
+      return RNP::bignum_byte_count(@n) * 8
+    when :PGP_PKA_DSA
+      case RNP::bignum_byte_count(@q)
+      when 20
+        1024
+      when 28
+        2048
+      when 32
+        3072
+      end
+    when :PGP_PKA_ELGAMAL
+      RNP::bignum_byte_count(@y) * 8
+    end
+    0
+  end
+
+end
+
+PARSE_PUBLIC_KEY = Proc.new do |results, pkt, data|
+  case pkt[:tag]
+  when :PGP_PARSER_PTAG
+
+  when :PGP_PARSER_PACKET_END
+  when :PGP_PTAG_CT_PUBLIC_KEY, :PGP_PTAG_CT_PUBLIC_SUBKEY
+    pk = pkt[:u][:pubkey]
+    pubkey = PublicKey.new
+    case pk[:alg]
+    when :PGP_PKA_RSA, :PGP_PKA_RSA_ENCRYPT_ONLY, :PGP_PKA_RSA_SIGN_ONLY
+      rsa = pk[:key][:rsa]
+      pubkey.mpi[:n] = LibRNP::bn2hex(rsa[:n]).hex
+      pubkey.mpi[:e] = LibRNP::bn2hex(rsa[:e]).hex
+    when :PGP_PKA_DSA
+      dsa = pk[:key][:dsa]
+      pubkey.mpi[:p] = LibRNP::bn2hex(dsa[:p]).hex
+      pubkey.mpi[:q] = LibRNP::bn2hex(dsa[:q]).hex
+      pubkey.mpi[:g] = LibRNP::bn2hex(dsa[:g]).hex
+      pubkey.mpi[:y] = LibRNP::bn2hex(dsa[:y]).hex
+   when :PGP_PKA_ELGAMAL
+      elg = pk[:key][:elgamal]
+      pubkey.mpi[:p] = LibRNP::bn2hex(rsa[:p]).hex
+      pubkey.mpi[:g] = LibRNP::bn2hex(rsa[:g]).hex
+      pubkey.mpi[:y] = LibRNP::bn2hex(rsa[:y]).hex
+    else
+      next :PGP_RELEASE_MEMORY     
+    end
+    pubkey.version = pk[:version]
+    pubkey.creation_time = Time.at(pk[:birthtime])
+    pubkey.public_key_algorithm = pk[:alg]
+    results.push(pubkey)
+  when :PGP_PTAG_SS_KEY_EXPIRY
+    pubkey = results.last
+    pubkey.expiration_time = Time.at(results.last.creation_time.to_i + pkt[:u][:ss_time])
+  when :PGP_PTAG_CT_USER_ID
+    pubkey = results.last
+    pubkey.userids.push(pkt[:u][:userid].force_encoding('utf-8'))
+  end
+  next :PGP_RELEASE_MEMORY
+end
+
+def load_pubkey(data, armored=false, print_errors=true)
+  stream_mem = LibC::calloc(1, LibRNP::PGPStream.size)
+  # This will free the above memory (PGPStream is a ManagedStruct)
+  stream = LibRNP::PGPStream.new(stream_mem)
+  stream[:readinfo][:accumulate] = 1
+  LibRNP::pgp_parse_options(stream, :PGP_PTAG_SS_ALL, :PGP_PARSE_PARSED)
+
+  # This memory will be GC'd
+  mem = FFI::MemoryPointer.new(:uint8, data.bytesize)
+  mem.put_bytes(0, data)
+
+  LibRNP::pgp_reader_set_memory(stream, mem, mem.size)
+  results = []
+  callback = PARSE_PUBLIC_KEY.curry[results]
+  LibRNP::pgp_set_callback(stream, callback, nil)
+  LibRNP::pgp_reader_push_dearmour(stream) if armored
+  LibRNP::pgp_parse(stream, print_errors ? 1 : 0)
+  LibRNP::pgp_reader_pop_dearmour(stream) if armored
+  results[0]
+end
+
+def usage
+  puts "Usage: #{$0} <file>"
+  exit 1
+end
+
+usage if ARGV.length != 1
+armored = ARGV[0].downcase.end_with?('.asc')
+pubkey = load_pubkey(File.binread(ARGV[0]), armored)
+puts pubkey.inspect
+

data/examples/lowlevel/print_keyring_file.rb

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+require_relative '../../lib/rnp'
+
+def usage
+  puts "Usage: #{$0} <file>"
+  exit 1
+end
+
+def print_pubkey(pubkey, indent=0)
+    puts "#{' ' * indent}Version: #{pubkey[:version]}"
+    puts "#{' ' * indent}Creation Time: #{Time.at(pubkey[:birthtime])}"
+    puts "#{' ' * indent}Algorithm: #{pubkey[:alg]}"
+    case pubkey[:alg]
+    when :PGP_PKA_RSA
+      n = LibRNP::bn2hex(pubkey[:key][:rsa][:n])
+      e = LibRNP::bn2hex(pubkey[:key][:rsa][:e])
+      puts "#{' ' * indent}n: 0x#{n}"
+      puts "#{' ' * indent}e: 0x#{e}"
+    end
+end
+
+def print_seckey(seckey, indent=0)
+  puts "#{' ' * (indent+2)}[Public Key]"
+  print_pubkey(seckey[:pubkey], indent + 2)
+  puts "#{' ' * indent}string-to-key usage: #{seckey[:s2k_usage]}"
+  puts "#{' ' * indent}string-to-key specifier: #{seckey[:s2k_specifier]}"
+  puts "#{' ' * indent}Symmetric algorithm: #{seckey[:alg]}"
+  puts "#{' ' * indent}Hash algorithm: #{seckey[:hash_alg]}"
+end
+
+usage if ARGV.length != 1
+armored = ARGV[0].downcase.end_with?('.asc') ? 1 : 0
+
+keyring_mem = LibC::calloc(1, LibRNP::PGPKeyring.size)
+keyring = LibRNP::PGPKeyring.new(keyring_mem)
+if 1 != LibRNP::pgp_keyring_fileread(keyring, armored, ARGV[0])
+  puts 'Failed to load keyring'
+  exit 1
+end
+keycount = LibRNP::dynarray_count(keyring, 'key')
+puts "Loaded #{keycount} key(s)"
+
+(0..keycount - 1).each {|keyn|
+  key = LibRNP::dynarray_get_item(keyring, 'key', LibRNP::PGPKey, keyn)
+  puts "[Key ##{keyn}]"
+  uidcount = LibRNP::dynarray_count(key, 'uid')
+  print "User ids: "
+  puts LibRNP::dynarray_get_item(key, 'uid', :string, 0)
+  (1..uidcount - 1).each {|uidn|
+    print '          '
+    puts LibRNP::dynarray_get_item(key, 'uid', :string, uidn)
+  }
+  puts "Subpackets:  #{LibRNP::dynarray_count(key, 'packet')}"
+  puts "Subsigs:     #{LibRNP::dynarray_count(key, 'subsig')}"
+  puts "Revocations: #{LibRNP::dynarray_count(key, 'revoke')}"
+  case key[:type]
+  when :PGP_PTAG_CT_PUBLIC_KEY
+    puts '  [Public Key]'
+    pubkey = key[:key][:pubkey]
+    print_pubkey(pubkey, 2)
+  when :PGP_PTAG_CT_SECRET_KEY
+    puts '  [Secret Key]'
+    seckey = key[:key][:seckey]
+    print_seckey(seckey, 2)
+  end
+  puts ''
+}
+

data/examples/lowlevel/print_keyring_mem.rb

@@ -0,0 +1,96 @@
+#!/usr/bin/env ruby
+require 'optparse'
+
+require_relative '../../lib/rnp'
+
+options = {armored: false}
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: #{$0} [options]"
+  opts.on('-a', '--armored', 'Input file is ASCII armored') do
+    options[:armored] = true
+  end
+  opts.on('-h', '--help', 'Print this help') do
+    puts opts
+    exit
+  end
+end
+
+def print_pubkey(pubkey, indent=0)
+    puts "#{' ' * indent}Version: #{pubkey[:version]}"
+    puts "#{' ' * indent}Creation Time: #{Time.at(pubkey[:birthtime])}"
+    puts "#{' ' * indent}Algorithm: #{pubkey[:alg]}"
+    case pubkey[:alg]
+    when :PGP_PKA_RSA
+      n = LibRNP::bn2hex(pubkey[:key][:rsa][:n])
+      e = LibRNP::bn2hex(pubkey[:key][:rsa][:e])
+      puts "#{' ' * indent}n: 0x#{n}"
+      puts "#{' ' * indent}e: 0x#{e}"
+    end
+end
+
+def print_seckey(seckey, indent=0)
+  puts "#{' ' * (indent+2)}[Public Key]"
+  print_pubkey(seckey[:pubkey], indent + 2)
+  puts "#{' ' * indent}string-to-key usage: #{seckey[:s2k_usage]}"
+  puts "#{' ' * indent}string-to-key specifier: #{seckey[:s2k_specifier]}"
+  puts "#{' ' * indent}Symmetric algorithm: #{seckey[:alg]}"
+  puts "#{' ' * indent}Hash algorithm: #{seckey[:hash_alg]}"
+end
+
+parser.parse!
+armored = options[:armored] ? 1 : 0
+
+pgpio = LibRNP::PGPIO.new
+stdout_fp = LibC::fdopen($stdout.to_i, 'w')
+stderr_fp = LibC::fdopen($stderr.to_i, 'w')
+pgpio[:outs] = stdout_fp
+pgpio[:errs] = stderr_fp
+pgpio[:res] = stdout_fp
+
+mem_ptr = LibC::calloc(1, LibRNP::PGPMemory.size)
+mem = LibRNP::PGPMemory.new(mem_ptr)
+
+$stdin.binmode
+data = $stdin.read
+data_buf = FFI::MemoryPointer.new(:uint8, data.bytesize)
+data_buf.put_bytes(0, data)
+LibRNP::pgp_memory_add(mem, data_buf, data_buf.size)
+
+keyring_mem = LibC::calloc(1, LibRNP::PGPKeyring.size)
+keyring = LibRNP::PGPKeyring.new(keyring_mem)
+if 1 != LibRNP::pgp_keyring_read_from_mem(pgpio, keyring, armored, mem)
+  puts 'Failed to load keyring'
+  exit 1
+end
+keycount = LibRNP::dynarray_count(keyring, 'key')
+puts "Loaded #{keycount} key(s)"
+
+(0..keycount - 1).each {|keyn|
+  key = LibRNP::dynarray_get_item(keyring, 'key', LibRNP::PGPKey, keyn)
+  puts "[Key ##{keyn}]"
+  uidcount = LibRNP::dynarray_count(key, 'uid')
+  print "User ids: "
+  puts LibRNP::dynarray_get_item(key, 'uid', :string, 0)
+  (1..uidcount - 1).each {|uidn|
+    print '          '
+    puts LibRNP::dynarray_get_item(key, 'uid', :string, uidn)
+  }
+  puts "Subpackets:  #{LibRNP::dynarray_count(key, 'packet')}"
+  puts "Subsigs:     #{LibRNP::dynarray_count(key, 'subsig')}"
+  puts "Revocations: #{LibRNP::dynarray_count(key, 'revoke')}"
+  printf "Key Flags: 0x%02X\n", key[:key_flags]
+  case key[:type]
+  when :PGP_PTAG_CT_PUBLIC_KEY
+    puts '  [Public Key]'
+    pubkey = key[:key][:pubkey]
+    print_pubkey(pubkey, 2)
+  when :PGP_PTAG_CT_SECRET_KEY
+    puts '  [Secret Key]'
+    seckey = key[:key][:seckey]
+    print_seckey(seckey, 2)
+  end
+  puts ''
+}
+
+LibRNP::pgp_memory_free(mem)
+