class NetPGP::Keyring

Attributes

keys[R]

Public Class Methods

load(data, armored=true, &passphrase_provider) click to toggle source
# File lib/netpgp/highlevel/keyring.rb, line 16
def self.load(data, armored=true, &passphrase_provider)
  kr = Keyring.new
  kr.add(data, armored, &passphrase_provider)
  kr
end
new() click to toggle source
# File lib/netpgp/highlevel/keyring.rb, line 12
def initialize
  @keys = []
end

Public Instance Methods

add(data, armored=true, &passphrase_provider) click to toggle source
# File lib/netpgp/highlevel/keyring.rb, line 22
def add(data, armored=true, &passphrase_provider)
  keys = NetPGP::load_keys(data, armored, &passphrase_provider)
  @keys.push(*keys)
  keys.size
end
export(key, armored=true) click to toggle source
# File lib/netpgp/highlevel/keyring.rb, line 32
def export(key, armored=true)
  raise if key.parent
  is_public = key.is_a?(PublicKey)
  if is_public
    seckey = secret_keys.find {|sk| sk.key_id == key.key_id}
  else
    seckey = key
  end
  return nil if not seckey
  output_ptr = FFI::MemoryPointer.new(:pointer)
  mem_ptr = FFI::MemoryPointer.new(:pointer)
  output = nil
  mem = nil
  decrypted_seckey = nil
  begin
    LibNetPGP::pgp_setup_memory_write(output_ptr, mem_ptr, 4096)
    output = LibNetPGP::PGPOutput.new(output_ptr.read_pointer)
    mem = LibNetPGP::PGPMemory.new(mem_ptr.read_pointer)
    native_ptr = LibC::calloc(1, LibNetPGP::PGPKey.size)
    native = LibNetPGP::PGPKey.new(native_ptr)
    native_auto = FFI::AutoPointer.new(native_ptr, LibNetPGP::PGPKey.method(:release))
    key.to_native_key(native)
    decrypted_seckey = seckey.decrypted_seckey
    return nil if not decrypted_seckey
    # this is necessary for signatures
    seckey = SecretKey.from_native(decrypted_seckey)
    seckey.to_native(native[:key][:seckey])
    native[:type] = :PGP_PTAG_CT_SECRET_KEY
    if is_public
      LibNetPGP::dynarray_clear(native, 'uid', :string)
      key.userids.each {|userid|
        LibNetPGP::pgp_add_selfsigned_userid(native, userid)
      }
    end
    # PGPKeyring is a ManagedStruct
    subkeysring_ptr = LibC::calloc(1, LibNetPGP::PGPKeyring.size)
    subkeysring = LibNetPGP::PGPKeyring.new(subkeysring_ptr)
    NetPGP::keys_to_native_keyring(key.subkeys, subkeysring)
    # add a binding signature to each subkey
    (0..LibNetPGP::dynarray_count(subkeysring, 'key') - 1).each {|n|
      subkey = LibNetPGP::dynarray_get_item(subkeysring, 'key', LibNetPGP::PGPKey, n)
      LibNetPGP::dynarray_clear(subkey, 'packet', LibNetPGP::PGPSubPacket)
      NetPGP::add_subkey_signature(native, subkey)
    }
    if is_public
      ret = LibNetPGP::pgp_write_xfer_pubkey(output, native, subkeysring, armored ? 1 : 0)
    else
      decrypted_key_ptr = LibC::calloc(1, LibNetPGP::PGPKey.size)
      decrypted_key = LibNetPGP::PGPKey.new(decrypted_key_ptr)
      decrypted_key_auto = FFI::AutoPointer.new(decrypted_key_ptr, LibNetPGP::PGPKey.method(:release))
      seckey.to_native_key(decrypted_key)
      key.userids.each {|userid|
        LibNetPGP::pgp_add_selfsigned_userid(decrypted_key, userid)
      }
      decrypted_key[:key][:seckey][:s2k_usage] = :PGP_S2KU_ENCRYPTED_AND_HASHED
      decrypted_key[:key][:seckey][:alg] = :PGP_SA_CAST5
      decrypted_key[:key][:seckey][:s2k_specifier] = :PGP_S2KS_SALTED
      (0..LibNetPGP::dynarray_count(subkeysring, 'key') - 1).each {|n|
        subkey = LibNetPGP::dynarray_get_item(subkeysring, 'key', LibNetPGP::PGPKey, n)
        subkey[:key][:seckey][:s2k_usage] = :PGP_S2KU_ENCRYPTED_AND_HASHED
        subkey[:key][:seckey][:alg] = :PGP_SA_CAST5
        subkey[:key][:seckey][:s2k_specifier] = :PGP_S2KS_SALTED
      }
      ret = LibNetPGP::pgp_write_xfer_seckey(output, decrypted_key, key.passphrase, key.passphrase.size, subkeysring, armored ? 1 : 0)
    end
    return nil if ret != 1
    data = mem[:buf].read_bytes(mem[:length])
    data
  ensure
    LibNetPGP::pgp_teardown_memory_write(output, mem) if mem
    LibNetPGP::pgp_seckey_free(decrypted_seckey) if decrypted_seckey
  end
end
public_keys() click to toggle source
# File lib/netpgp/highlevel/keyring.rb, line 106
def public_keys
  self.select {|key|
    key.is_a?(PublicKey)
  }
end
secret_keys() click to toggle source
# File lib/netpgp/highlevel/keyring.rb, line 112
def secret_keys
  self.select {|key|
    key.is_a?(SecretKey)
  }
end
to_native(native) click to toggle source
# File lib/netpgp/highlevel/keyring.rb, line 118
def to_native(native)
  keys_to_native_keyring(@keys, native)
end
verify(data, armored=true) click to toggle source
# File lib/netpgp/highlevel/keyring.rb, line 28
def verify(data, armored=true)
  NetPGP::verify(@keys, data, armored)
end