rnp 0.2.0 → 1.0.0

data/lib/rnp/op/sign.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+# (c) 2018 Ribose Inc.
+
+require 'ffi'
+
+require 'rnp/error'
+require 'rnp/ffi/librnp'
+require 'rnp/utils'
+
+class Rnp
+  # Signing operation
+  class Sign
+    # @api private
+    attr_reader :ptr
+
+    # @api private
+    def initialize(ptr)
+      raise Rnp::Error, 'NULL pointer' if ptr.null?
+      @ptr = FFI::AutoPointer.new(ptr, self.class.method(:destroy))
+    end
+
+    # @api private
+    def self.destroy(ptr)
+      LibRnp.rnp_op_sign_destroy(ptr)
+    end
+
+    def inspect
+      Rnp.inspect_ptr(self)
+    end
+
+    # Add a signer.
+    #
+    # @note The optional (per-signature) options here are not supported by RNP
+    #   internally at the time of this writing.
+    #
+    # @param signer [Key] the signer
+    # @param hash [String] (see #hash=)
+    # @param creation_time (see #creation_time=)
+    # @param expiration_time (see #expiration_time=)
+    # @return [self]
+    def add_signer(signer, hash: nil, creation_time: nil, expiration_time: nil)
+      pptr = FFI::MemoryPointer.new(:pointer)
+      Rnp.call_ffi(:rnp_op_sign_add_signature, @ptr, signer.ptr, pptr)
+      psig = pptr.read_pointer
+      self.class.set_signature_options(
+        psig,
+        hash: hash,
+        creation_time: creation_time,
+        expiration_time: expiration_time
+      )
+    end
+
+    # Set a group of options.
+    #
+    # @param armored see {#armored=}
+    # @param compression see {#compression=}
+    # @param hash see {#hash=}
+    # @param creation_time see {#creation_time=}
+    # @param expiration_time see {#expiration_time=}
+    def options=(armored: nil, compression: nil, hash: nil,
+                 creation_time: nil, expiration_time: nil)
+      self.armored = armored unless armored.nil?
+      self.compression = compression unless compression.nil?
+      self.hash = hash unless hash.nil?
+      self.creation_time = creation_time unless creation_time.nil?
+      self.expiration_time = expiration_time unless expiration_time.nil?
+    end
+
+    # Set whether the output will be ASCII-armored.
+    #
+    # @param armored [Boolean] true if the output should be
+    #        ASCII-armored, false otherwise.
+    def armored=(armored)
+      Rnp.call_ffi(:rnp_op_sign_set_armor, @ptr, armored)
+    end
+
+    # Set the compression algorithm and level.
+    #
+    # @param [Hash<Symbol>] compression
+    # @option compression [String] :algorithm the compression algorithm
+    #   (bzip2, etc)
+    # @option compression [Integer] :level the compression level. This should
+    #   generally be between 0 (no compression) and 9 (best compression).
+    def compression=(compression)
+      if !compression.is_a?(Hash) || Set.new(compression.keys) != Set.new(%i[algorithm level])
+        raise ArgumentError,
+              'Compression option must be of the form: {algorithm: \'zlib\', level: 5}'
+      end
+      Rnp.call_ffi(:rnp_op_sign_set_compression, @ptr, compression[:algorithm],
+                   compression[:level])
+    end
+
+    # Set the hash algorithm used for the signatures.
+    #
+    # @param hash [String] the hash algorithm name
+    def hash=(hash)
+      Rnp.call_ffi(:rnp_op_sign_set_hash, @ptr, hash)
+    end
+
+    # Set the creation time for signatures.
+    #
+    # @param creation_time [Time, Integer] the creation time to use for all
+    #   signatures. As an integer, this is the number of seconds since the
+    #   unix epoch.
+    def creation_time=(creation_time)
+      creation_time = creation_time.to_i if creation_time.is_a?(::Time)
+      Rnp.call_ffi(:rnp_op_sign_set_creation_time, @ptr, creation_time)
+    end
+
+    # Set the expiration time for signatures.
+    #
+    # @param expiration_time [Integer] the lifetime of the signature(s), as the
+    #   number of seconds. The actual expiration date/time is the creation time
+    #   plus this value. A value of 0 will create signatures that do not expire.
+    def expiration_time=(expiration_time)
+      Rnp.call_ffi(:rnp_op_sign_set_expiration_time, @ptr, expiration_time)
+    end
+
+    # Execute the operation.
+    #
+    # This should only be called once.
+    #
+    # @return [void]
+    def execute
+      Rnp.call_ffi(:rnp_op_sign_execute, @ptr)
+    end
+
+    # @api private
+    def self.set_signature_options(psig, hash:, creation_time:,
+                                   expiration_time:)
+      Rnp.call_ffi(:rnp_op_sign_signature_set_hash, psig, value) unless hash.nil?
+      creation_time = creation_time.to_i if creation_time.is_a?(::Time)
+      Rnp.call_ffi(:rnp_op_sign_signature_set_creation_time, psig, value) unless creation_time.nil?
+      Rnp.call_ffi(:rnp_op_sign_signature_set_expiration_time, psig, value) unless expiration_time.nil?
+    end
+  end # class
+end # class
+

data/lib/rnp/op/verify.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+# (c) 2018 Ribose Inc.
+
+require 'ffi'
+
+require 'rnp/error'
+require 'rnp/ffi/librnp'
+require 'rnp/utils'
+
+class Rnp
+  # Verification operation
+  class Verify
+    # @api private
+    attr_reader :ptr
+
+    # @api private
+    def initialize(ptr)
+      raise Rnp::Error, 'NULL pointer' if ptr.null?
+      @ptr = FFI::AutoPointer.new(ptr, self.class.method(:destroy))
+      @signatures = nil
+    end
+
+    # @api private
+    def self.destroy(ptr)
+      LibRnp.rnp_op_verify_destroy(ptr)
+    end
+
+    def inspect
+      Rnp.inspect_ptr(self)
+    end
+
+    # Execute the operation.
+    #
+    # This should only be called once.
+    #
+    # @return [void]
+    # @raise [InvalidSignatureError, BadFormatError, ...] if the signature is
+    #        expired, not correctly formed, invalid, etc.
+    def execute
+      Rnp.call_ffi(:rnp_op_verify_execute, @ptr)
+    end
+
+    # Check if all signatures are good.
+    #
+    # @return [Boolean] true if all signatures are valid and not expired.
+    def good?
+      sigs = signatures
+      sigs.size && sigs.all?(&:good?)
+    end
+
+    # Get a list of the checked signatures.
+    #
+    # @return [Array<Signature>]
+    def signatures
+      return @signatures unless @signatures.nil?
+      @signatures = []
+      pptr = FFI::MemoryPointer.new(:pointer)
+      (0...signature_count).each do |i|
+        Rnp.call_ffi(:rnp_op_verify_get_signature_at, @ptr, i, pptr)
+        psig = pptr.read_pointer
+        @signatures << Signature.new(psig)
+      end
+      @signatures
+    end
+
+    # Class representing an individual signature.
+    class Signature
+      # @api private
+      attr_reader :status
+      # The hash algorithm used for the signature
+      # @return [String]
+      attr_reader :hash
+      # The key that created the signature
+      # @return [Key]
+      attr_reader :key
+      # The creation time of the signature
+      # @return [Time]
+      attr_reader :creation_time
+      # The expiration (as the number of seconds after {creation_time})
+      # @return [Integer]
+      attr_reader :expiration_time
+
+      # @api private
+      def initialize(ptr)
+        # status
+        @status = LibRnp.rnp_op_verify_signature_get_status(ptr)
+        pptr = FFI::MemoryPointer.new(:pointer)
+
+        # creation and expiration
+        pcreation_time = FFI::MemoryPointer.new(:uint32)
+        pexpiration_time = FFI::MemoryPointer.new(:uint32)
+        Rnp.call_ffi(:rnp_op_verify_signature_get_times, ptr, pcreation_time,
+                     pexpiration_time)
+        @creation_time = Time.at(pcreation_time.read(:uint32))
+        @expiration_time = pexpiration_time.read(:uint32)
+
+        # hash
+        Rnp.call_ffi(:rnp_op_verify_signature_get_hash, ptr, pptr)
+        begin
+          phash = pptr.read_pointer
+          @hash = phash.read_string unless phash.null?
+        ensure
+          LibRnp.rnp_buffer_destroy(phash)
+        end
+
+        # key
+        Rnp.call_ffi(:rnp_op_verify_signature_get_key, ptr, pptr)
+        pkey = pptr.read_pointer
+        @key = Key.new(pkey) unless pkey.null?
+      end
+
+      # Check if this signature is good.
+      #
+      # @return [Boolean] true if the signature is valid and not expired
+      def good?
+        @status == LibRnp::RNP_SUCCESS
+      end
+
+      # Check if this signature is valid.
+      #
+      # @note A valid signature may also be expired.
+      #
+      # @return [Boolean] true if the signature is valid
+      def valid?
+        @status == LibRnp::RNP_SUCCESS ||
+          @status == LibRnp::RNP_ERROR_SIGNATURE_EXPIRED
+      end
+
+      # Check if this signature is expired.
+      #
+      # @return [Boolean] true if the signature is expired
+      def expired?
+        @status == LibRnp::RNP_ERROR_SIGNATURE_EXPIRED
+      end
+    end
+
+    private
+
+    def signature_count
+      pcount = FFI::MemoryPointer.new(:size_t)
+      Rnp.call_ffi(:rnp_op_verify_get_signature_count, @ptr, pcount)
+      pcount.read(:size_t)
+    end
+  end # class
+end # class
+

data/lib/rnp/output.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+# (c) 2018 Ribose Inc.
+
+require 'English'
+
+require 'ffi'
+
+require 'rnp/error'
+require 'rnp/ffi/librnp'
+require 'rnp/utils'
+
+class Rnp
+  # Class used to feed data out of RNP.
+  #
+  # @note When dealing with very large data, prefer {to_path} which should
+  #   be the most efficient. {to_io} is likely to have more overhead.
+  #
+  # @example output to a string
+  #   output = Rnp::Input.to_string('my data')
+  #   # ... after performing operations
+  #   output.string
+  #
+  # @example output to a file
+  #   Rnp::Input.to_path('/path/to/my/file')
+  #
+  # @example output to a Ruby IO object
+  #   Rnp::Input.to_io(File.open('/path/to/file', 'wb'))
+  class Output
+    # @api private
+    attr_reader :ptr
+
+    # @api private
+    def initialize(ptr, writer = nil)
+      raise Rnp::Error, 'NULL pointer' if ptr.null?
+      @ptr = FFI::AutoPointer.new(ptr, self.class.method(:destroy))
+      @writer = writer
+    end
+
+    # @api private
+    def self.destroy(ptr)
+      LibRnp.rnp_output_destroy(ptr)
+    end
+
+    def inspect
+      Rnp.inspect_ptr(self)
+    end
+
+    # Create an Output to write to a string.
+    #
+    # The resulting string can later be retrieved with {#string}.
+    #
+    # @param max_alloc [Integer] the maximum amount of memory to allocate,
+    #   or 0 for unlimited
+    # @return [Output]
+    def self.to_string(max_alloc = 0)
+      pptr = FFI::MemoryPointer.new(:pointer)
+      Rnp.call_ffi(:rnp_output_to_memory, pptr, max_alloc)
+      Output.new(pptr.read_pointer)
+    end
+
+    # Create an Output to write to a path.
+    #
+    # @param path [String] the path
+    # @return [Output]
+    def self.to_path(path)
+      pptr = FFI::MemoryPointer.new(:pointer)
+      Rnp.call_ffi(:rnp_output_to_path, pptr, path)
+      Output.new(pptr.read_pointer)
+    end
+
+    # Create an Output to discard all writes.
+    #
+    # @return [Output]
+    def self.to_null
+      pptr = FFI::MemoryPointer.new(:pointer)
+      Rnp.call_ffi(:rnp_output_to_null, pptr)
+      Output.new(pptr.read_pointer)
+    end
+
+    # Create an Output to write to an IO object.
+    #
+    # @param io [IO, #write] the IO object
+    # @return [Output]
+    def self.to_io(io)
+      to_callback(io.method(:write))
+    end
+
+    # Retrieve the data written. Only valid for #{to_string}.
+    #
+    # @return [String, nil]
+    def string
+      pptr = FFI::MemoryPointer.new(:pointer)
+      len = FFI::MemoryPointer.new(:size_t)
+      Rnp.call_ffi(:rnp_output_memory_get_buf, @ptr, pptr, len, false)
+      buf = pptr.read_pointer
+      buf.read_bytes(len.read(:size_t)) unless buf.null?
+    end
+
+    # @api private
+    WRITER = lambda do |writer, _ctx, buf, buf_len|
+      begin
+        data = buf.read_bytes(buf_len)
+        written = writer.call(data)
+        return written == data.bytesize
+      rescue
+        puts $ERROR_INFO
+        return false
+      end
+    end
+
+    # @api private
+    def self.to_callback(writer)
+      pptr = FFI::MemoryPointer.new(:pointer)
+      writercb = WRITER.curry[writer]
+      Rnp.call_ffi(:rnp_output_to_callback, pptr, writercb, nil, nil)
+      Output.new(pptr.read_pointer, writercb)
+    end
+  end # class
+end # class
+

data/lib/rnp/rnp.rb

@@ -0,0 +1,595 @@
+# frozen_string_literal: true
+
+# (c) 2018 Ribose Inc.
+
+require 'English'
+require 'json'
+
+require 'ffi'
+
+require 'rnp/error'
+require 'rnp/ffi/librnp'
+require 'rnp/utils'
+require 'rnp/key'
+require 'rnp/op/sign'
+require 'rnp/op/verify'
+require 'rnp/op/encrypt'
+
+# Class used for interacting with RNP.
+class Rnp
+  # @api private
+  attr_reader :ptr
+
+  # Create a new interface to RNP.
+  #
+  # @param pubfmt [String] the public keyring format
+  # @param secfmt [String] the secret keyring format
+  def initialize(pubfmt = 'GPG', secfmt = 'GPG')
+    pptr = FFI::MemoryPointer.new(:pointer)
+    Rnp.call_ffi(:rnp_ffi_create, pptr, pubfmt, secfmt)
+    @ptr = FFI::AutoPointer.new(pptr.read_pointer, self.class.method(:destroy))
+    @key_provider = nil
+    @password_provider = nil
+  end
+
+  # @api private
+  def self.destroy(ptr)
+    LibRnp.rnp_ffi_destroy(ptr)
+  end
+
+  def inspect
+    Rnp.inspect_ptr(self)
+  end
+
+  # Set a logging destination.
+  #
+  # @param fd [Integer, IO] the file descriptor to log to. This will be closed
+  #   when this object is destroyed.
+  def log=(fd)
+    fd = fd.to_i if fd.is_a(::IO)
+    Rnp.call_ffi(:rnp_ffi_set_log_fd, @ptr, fd)
+  end
+
+  # Set a key provider.
+  #
+  # The key provider is useful if, for example, you have a database of keys and
+  # you do not want to load all of them, and you don't know which will be needed
+  # for a given operation.
+  #
+  # The key provider will be called to request that a key be loaded, and the
+  # key provider is responsible for loading the appropriate key (if available)
+  # using {#load_keys}.
+  #
+  # The provider may be called multiple times for the same key, but with
+  # different identifiers. For example, it may first be called with
+  # a fingerprint, then (if the key was not loaded), it may be called with a
+  # keyid.
+  #
+  # == Examples
+  # === examples/key_provider.rb
+  # {include:file:examples/key_provider.rb}
+  #
+  # @param provider [Proc, #call] a callable object
+  def key_provider=(provider)
+    @key_provider = provider
+    @key_provider = KEY_PROVIDER.curry[provider] if provider
+    Rnp.call_ffi(:rnp_ffi_set_key_provider, @ptr, @key_provider, nil)
+  end
+
+  # Set a password provider.
+  #
+  # The password provider is used for retrieving passwords for various
+  # operations, including:
+  # * Signing data
+  # * Decrypting data (public-key or symmetric)
+  # * Adding a userid to a key
+  # * Unlocking a key
+  # * Unprotecting a key
+  #
+  # == Examples
+  # === examples/password_provider.rb
+  # {include:file:examples/password_provider.rb}
+  #
+  # @param provider [Proc, #call, String] a callable object, or a password
+  def password_provider=(provider)
+    @password_provider = provider
+    @password_provider = PASS_PROVIDER.curry[provider] if provider
+    Rnp.call_ffi(:rnp_ffi_set_pass_provider, @ptr, @password_provider, nil)
+  end
+
+  # Generate a new key or pair of keys.
+  #
+  # @note The generated key(s) will be unprotected and unlocked.
+  #   The application should protect and lock the keys with
+  #   {Key#protect} and {Key#lock}.
+  #
+  # == Examples
+  # === examples/key_generation.rb
+  # {include:file:examples/key_generation.rb}
+  #
+  # @param description [String, Hash]
+  # @return [Hash<Symbol, Key>] a hash containing the generated key(s)
+  def generate_key(description)
+    description = JSON.generate(description) unless description.is_a?(String)
+    pptr = FFI::MemoryPointer.new(:pointer)
+    Rnp.call_ffi(:rnp_generate_key_json, @ptr, description, pptr)
+    begin
+      presults = pptr.read_pointer
+      return nil if presults.null?
+      results = JSON.parse(presults.read_string)
+      generated = {}
+      results.each do |k, v|
+        key = find_key(v.keys[0].to_sym => v.values[0])
+        generated[k.to_sym] = key
+      end
+      generated
+    ensure
+      LibRnp.rnp_buffer_destroy(presults)
+    end
+  end
+
+  # Load keys.
+  #
+  # @param format [String] the format of the keys to load (GPG, KBX, G10).
+  # @param input [Input] the input to read the keys from
+  # @param public_keys [Boolean] whether to load public keys
+  # @param secret_keys [Boolean] whether to load secret keys
+  # @return [void]
+  def load_keys(input:, format:, public_keys: true, secret_keys: true)
+    raise ArgumentError, 'At least one of public_keys or secret_keys must be true' if !public_keys && !secret_keys
+    flags = load_save_flags(public_keys: public_keys, secret_keys: secret_keys)
+    Rnp.call_ffi(:rnp_load_keys, @ptr, format, input.ptr, flags)
+  end
+
+  # Save keys.
+  #
+  # @param format [String] the format to save the keys in (GPG, KBX, G10).
+  # @param output [Output] the output to write the keys to
+  # @param public_keys [Boolean] whether to load public keys
+  # @param secret_keys [Boolean] whether to load secret keys
+  # @return [void]
+  def save_keys(output:, format:, public_keys: false, secret_keys: false)
+    raise ArgumentError, 'At least one of public_keys or secret_keys must be true' if !public_keys && !secret_keys
+    flags = load_save_flags(public_keys: public_keys, secret_keys: secret_keys)
+    Rnp.call_ffi(:rnp_save_keys, @ptr, format, output.ptr, flags)
+  end
+
+  # Find a key.
+  #
+  # @param criteria [Hash] the search criteria. Some examples would be:
+  #   * !{keyid: '2FCADF05FFA501BB'}
+  #   * !{'userid': 'user0'}
+  #   * !{fingerprint: 'BE1C4AB951F4C2F6B604'}
+  #   Only *one* criteria can be specified.
+  # @return [Key, nil]
+  def find_key(criteria)
+    raise Rnp::Error, 'Invalid search criteria' if !criteria.is_a?(::Hash) ||
+                                                   criteria.size != 1
+    pptr = FFI::MemoryPointer.new(:pointer)
+    Rnp.call_ffi(:rnp_locate_key, @ptr, criteria.keys[0].to_s,
+                 criteria.values[0], pptr)
+    pkey = pptr.read_pointer
+    Rnp::Key.new(pkey) unless pkey.null?
+  end
+
+  # @!method userids
+  # Get a list of all userids.
+  #
+  # @return [Array<String>]
+
+  # @!method each_userid(&block)
+  # Enumerate all userids.
+  #
+  # @return [self, Enumerator]
+
+  # @!method keyids
+  # Get a list of all keyids.
+  #
+  # @return [Array<String>]
+
+  # @!method each_keyid(&block)
+  # Enumerate all keyids.
+  #
+  # @return [self, Enumerator]
+
+  # @!method fingerprints
+  # Get a list of all fingerprints.
+  #
+  # @return [Array<String>]
+
+  # @!method each_fingerprint(&block)
+  # Enumerate all fingerprints.
+  #
+  # @return [self, Enumerator]
+
+  # @!method grips
+  # Get a list of all grips.
+  #
+  # @return [Array<String>]
+
+  # @!method each_grip(&block)
+  # Enumerate all grips.
+  #
+  # @return [self, Enumerator]
+
+  %w[userid keyid fingerprint grip].each do |identifier_type|
+    define_method("each_#{identifier_type}".to_sym) do |&block|
+      each_identifier(identifier_type, &block)
+    end
+
+    define_method("#{identifier_type}s".to_sym) do
+      each_identifier(identifier_type).to_a
+    end
+  end
+
+  def public_key_count
+    pcount = FFI::MemoryPointer.new(:size_t)
+    Rnp.call_ffi(:rnp_get_public_key_count, pcount)
+    pcount.read(:size_t)
+  end
+
+  def secret_key_count
+    pcount = FFI::MemoryPointer.new(:size_t)
+    Rnp.call_ffi(:rnp_get_secret_key_count, pcount)
+    pcount.read(:size_t)
+  end
+
+  # Create a signature.
+  #
+  # @param input [Input] the input to read the data to be signed
+  # @param output [Output] the output to write the signatures.
+  #   If nil, the result will be returned directly as a String.
+  # @param signers [Key, Array<Key>] the keys to sign with
+  # @param armored (see Sign#armored=)
+  # @param compression (see Sign#compression=)
+  # @param creation_time (see Sign#creation_time=)
+  # @param expiration_time (see Sign#expiration_time=)
+  # @param hash (see Sign#hash=)
+  # @return [nil, String]
+  def sign(input:, output: nil, signers:,
+           armored: nil,
+           compression: nil,
+           creation_time: nil,
+           expiration_time: nil,
+           hash: nil)
+    default_output(output) do |output_|
+      sign = start_sign(input: input, output: output_)
+      sign.options = {
+        armored: armored,
+        compression: compression,
+        creation_time: creation_time,
+        expiration_time: expiration_time,
+        hash: hash
+      }
+      simple_sign(sign, signers)
+    end
+  end
+
+  # Create a cleartext signature.
+  #
+  # @param input (see #sign)
+  # @param output (see #sign)
+  # @param signers [Key, Array<Key>] the keys to sign with
+  # @param compression (see Sign#compression=)
+  # @param creation_time (see Sign#creation_time=)
+  # @param expiration_time (see Sign#expiration_time=)
+  # @param hash (see Sign#hash=)
+  # @return [nil, String]
+  def cleartext_sign(input:, output: nil, signers:,
+                     compression: nil,
+                     creation_time: nil,
+                     expiration_time: nil,
+                     hash: nil)
+    default_output(output) do |output_|
+      sign = start_cleartext_sign(input: input, output: output_)
+      sign.options = {
+        compression: compression,
+        creation_time: creation_time,
+        expiration_time: expiration_time,
+        hash: hash
+      }
+      simple_sign(sign, signers)
+    end
+  end
+
+  # Create a detached signature.
+  #
+  # @param input (see #sign)
+  # @param output (see #sign)
+  # @param signers [Key, Array<Key>] the keys to sign with
+  # @param armored (see Sign#armored=)
+  # @param compression (see Sign#compression=)
+  # @param creation_time (see Sign#creation_time=)
+  # @param expiration_time (see Sign#expiration_time=)
+  # @param hash (see Sign#hash=)
+  # @return [nil, String]
+  def detached_sign(input:, output: nil, signers:,
+                    armored: nil,
+                    compression: nil,
+                    creation_time: nil,
+                    expiration_time: nil,
+                    hash: nil)
+    default_output(output) do |output_|
+      sign = start_detached_sign(input: input, output: output_)
+      sign.options = {
+        armored: armored,
+        compression: compression,
+        creation_time: creation_time,
+        expiration_time: expiration_time,
+        hash: hash
+      }
+      simple_sign(sign, signers)
+    end
+  end
+
+  # Verify a signature.
+  #
+  # @param input [Input] the input to read the signatures
+  # @param output [Output] the output (if any) to write the verified data
+  def verify(input:, output: nil)
+    verify = start_verify(input: input, output: output)
+    verify.execute
+  end
+
+  # Verify a detached signature.
+  #
+  # @param data [Input] the input to read the data
+  # @param signature [Input] the input to read the signatures
+  def detached_verify(data:, signature:)
+    verify = start_detached_verify(data: data, signature: signature)
+    verify.execute
+  end
+
+  # Encrypt data with a public key.
+  #
+  # @param input [Input] the input to read the plaintext
+  # @param output [Output] the output to write the encrypted data.
+  #   If nil, the result will be returned directly as a String.
+  # @param recipients [Key, Array<Key>] list of recipients keys
+  # @param armored (see Encrypt#armored=)
+  # @param compression (see Encrypt#compression=)
+  # @param cipher (see Encrypt#cipher=)
+  def encrypt(input:, output: nil, recipients:,
+              armored: nil,
+              compression: nil,
+              cipher: nil)
+    default_output(output) do |output_|
+      enc = start_encrypt(input: input, output: output_)
+      enc.options = {
+        armored: armored,
+        compression: compression,
+        cipher: cipher
+      }
+      simple_encrypt(enc, recipients: recipients)
+    end
+  end
+
+  # Encrypt and sign data with a public key.
+  #
+  # @param input (see #encrypt)
+  # @param output (see #encrypt)
+  # @param recipients (see #encrypt)
+  # @param signers [Key, Array<Key>] list of keys to sign with
+  # @param armored (see Encrypt#armored=)
+  # @param compression (see Encrypt#compression=)
+  # @param cipher (see Encrypt#cipher=)
+  # @param hash (see Encrypt#hash=)
+  # @param creation_time (see Encrypt#creation_time=)
+  # @param expiration_time (see Encrypt#expiration_time=)
+  def encrypt_and_sign(input:, output: nil, recipients:, signers:,
+                       armored: nil,
+                       compression: nil,
+                       cipher: nil,
+                       hash: nil,
+                       creation_time: nil,
+                       expiration_time: nil)
+    default_output(output) do |output_|
+      enc = start_encrypt(input: input, output: output_)
+      enc.options = {
+        armored: armored,
+        compression: compression,
+        cipher: cipher,
+        hash: hash,
+        creation_time: creation_time,
+        expiration_time: expiration_time
+      }
+      simple_encrypt(enc, recipients: recipients, signers: signers)
+    end
+  end
+
+  # Encrypt with a password only.
+  #
+  # @param input (see #encrypt)
+  # @param output (see #encrypt)
+  # @param passwords [String, Array<String>] list of passwords to encrypt with.
+  #        Any (single) one of the passwords can be used to decrypt.
+  # @param armored (see Encrypt#armored=)
+  # @param compression (see Encrypt#compression=)
+  # @param cipher (see Encrypt#cipher=)
+  # @param s2k_hash (see Encrypt#add_password)
+  # @param s2k_iterations (see Encrypt#add_password)
+  # @param s2k_cipher (see Encrypt#add_password)
+  # @return [void]
+  def symmetric_encrypt(input:, output: nil, passwords:,
+                        armored: nil,
+                        compression: nil,
+                        cipher: nil,
+                        s2k_hash: nil,
+                        s2k_iterations: 0,
+                        s2k_cipher: nil)
+    default_output(output) do |output_|
+      enc = start_encrypt(input: input, output: output_)
+      enc.options = {
+        armored: armored,
+        compression: compression,
+        cipher: cipher
+      }
+      passwords = [passwords] if passwords.is_a?(String)
+      passwords.each do |password|
+        enc.add_password(password,
+                         s2k_hash: s2k_hash,
+                         s2k_iterations: s2k_iterations,
+                         s2k_cipher: s2k_cipher)
+      end
+      enc.execute
+    end
+  end
+
+  # Decrypt encrypted data.
+  #
+  # @param input [Input] the input to read the encrypted data
+  # @param output [Output] the output to write the decrypted data.
+  #   If nil, the result will be returned directly as a String.
+  # @return [nil, String]
+  def decrypt(input:, output: nil)
+    default_output(output) do |output_|
+      Rnp.call_ffi(:rnp_decrypt, @ptr, input.ptr, output_.ptr)
+    end
+  end
+
+  # Create a {Sign} operation.
+  #
+  # @param input [Input] the input to read the data to be signed
+  # @param output [Output] the output to write the signatures
+  def start_sign(input:, output:)
+    _start_sign(:rnp_op_sign_create, input, output)
+  end
+
+  # Create a cleartext {Sign} operation.
+  #
+  # @param input (see #start_sign)
+  # @param output (see #start_sign)
+  def start_cleartext_sign(input:, output:)
+    _start_sign(:rnp_op_sign_cleartext_create, input, output)
+  end
+
+  # Create a detached {Sign} operation.
+  #
+  # @param input (see #start_sign)
+  # @param output (see #start_sign)
+  def start_detached_sign(input:, output:)
+    _start_sign(:rnp_op_sign_detached_create, input, output)
+  end
+
+  # Create a {Verify} operation.
+  #
+  # @param input [Input] the input to read the signatures
+  # @param output [Output] the output (if any) to write the verified data
+  def start_verify(input:, output: nil)
+    output = Output.to_null unless output
+    _start_verify(:rnp_op_verify_create, input, output)
+  end
+
+  # Create a detached {Verify} operation.
+  #
+  # @param data [Input] the input to read the signed data
+  # @param signature [Input] the input to read the signatures
+  def start_detached_verify(data:, signature:)
+    _start_verify(:rnp_op_verify_detached_create, data, signature)
+  end
+
+  # Create an {Encrypt} operation.
+  #
+  # @param input [Input] the input to read the plaintext
+  # @param output [Output] the output to write the encrypted data
+  def start_encrypt(input:, output:)
+    pptr = FFI::MemoryPointer.new(:pointer)
+    Rnp.call_ffi(:rnp_op_encrypt_create, pptr, @ptr, input.ptr, output.ptr)
+    pencrypt = pptr.read_pointer
+    Encrypt.new(pencrypt) unless pencrypt.null?
+  end
+
+  private
+
+  KEY_PROVIDER = lambda do |provider, _rnp, _ctx, identifier_type, identifier, secret|
+    provider.call(identifier_type, identifier, secret)
+  end
+
+  PASS_PROVIDER = lambda do |provider, _rnp, _ctx, pkey, reason, buf, buf_len|
+    begin
+      if provider.is_a?(String)
+        # we were provided a a literal password
+        password = provider
+      else
+        key = Key.new(pkey, false) unless pkey.null?
+        password = provider.call(key, reason)
+      end
+      return false unless password && password.size < buf_len
+      buf.write_string(password)
+      return true
+    rescue
+      puts $ERROR_INFO
+      return false
+    end
+  end
+
+  def simple_sign(sign, signers)
+    signers = [signers] if signers.is_a?(Key)
+    signers.each do |signer|
+      sign.add_signer(signer)
+    end
+    sign.execute
+  end
+
+  def _start_sign(func, input, output)
+    pptr = FFI::MemoryPointer.new(:pointer)
+    Rnp.call_ffi(func, pptr, @ptr, input.ptr, output.ptr)
+    psign = pptr.read_pointer
+    Rnp::Sign.new(psign) unless psign.null?
+  end
+
+  def _start_verify(func, io1, io2)
+    pptr = FFI::MemoryPointer.new(:pointer)
+    Rnp.call_ffi(func, pptr, @ptr, io1.ptr, io2.ptr)
+    pverify = pptr.read_pointer
+    Verify.new(pverify) unless pverify.null?
+  end
+
+  def simple_encrypt(enc, recipients: nil, signers: nil)
+    recipients = [recipients] if recipients.is_a?(Key)
+    recipients&.each do |recipient|
+      enc.add_recipient(recipient)
+    end
+    signers = [signers] if signers.is_a?(Key)
+    signers&.each do |signer|
+      enc.add_signer(signer)
+    end
+    enc.execute
+  end
+
+  def each_identifier(type, &block)
+    block or return enum_for(:identifier_iterator, type)
+    identifier_iterator(type, &block)
+    self
+  end
+
+  def identifier_iterator(identifier_type)
+    pptr = FFI::MemoryPointer.new(:pointer)
+    piterator = nil
+    Rnp.call_ffi(:rnp_identifier_iterator_create, @ptr, pptr, identifier_type)
+    piterator = pptr.read_pointer
+    loop do
+      Rnp.call_ffi(:rnp_identifier_iterator_next, piterator, pptr)
+      pidentifier = pptr.read_pointer
+      break if pidentifier.null?
+      yield pidentifier.read_string
+    end
+  ensure
+    LibRnp.rnp_identifier_iterator_destroy(piterator) if piterator
+  end
+
+  def load_save_flags(public_keys:, secret_keys:)
+    flags = 0
+    flags |= LibRnp::RNP_LOAD_SAVE_PUBLIC_KEYS if public_keys
+    flags |= LibRnp::RNP_LOAD_SAVE_SECRET_KEYS if secret_keys
+    flags
+  end
+
+  def default_output(output)
+    to_str = output.nil?
+    output = Output.to_string if to_str
+    yield output
+    output.string if to_str
+  end
+end # class
+