rnp 0.2.0 → 1.0.0

data/examples/highlevel/decrypt_mem.rb

@@ -1,44 +0,0 @@
-#!/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

@@ -1,46 +0,0 @@
-#!/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

@@ -1,76 +0,0 @@
-#!/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

@@ -1,80 +0,0 @@
-#!/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

@@ -1,68 +0,0 @@
-#!/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

@@ -1,75 +0,0 @@
-#!/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

@@ -1,118 +0,0 @@
-#!/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
-