Class: OpenPGP::Engine::GnuPG

Inherits:
  • Object
show all
Defined in:
lib/openpgp/engine/gnupg.rb

Overview

GNU Privacy Guard (GnuPG) wrapper.

See Also:

Defined Under Namespace

Classes: Error

Constant Summary

OPTIONS =
{
  :batch                 => true,
  :quiet                 => true,
  :no_verbose            => true,
  :no_tty                => true,
  :no_permission_warning => true,
  :no_random_seed_file   => true,
}

Instance Attribute Summary (collapse)

Class Method Summary (collapse)

Instance Method Summary (collapse)

Methods inherited from

install!, install_extensions!, load!, use

Constructor Details

- (GnuPG) initialize(options = {})

A new instance of GnuPG

Parameters:

  • (Hash{Symbol => Object}) options (defaults to: {})


32
33
34
35
# File 'lib/openpgp/engine/gnupg.rb', line 32

def initialize(options = {})
  @where   = '/usr/bin/env gpg' # FIXME
  @options = OPTIONS.merge!(options)
end

Instance Attribute Details

- (Hash{Symbol => Object}) options

Returns:

  • (Hash{Symbol => Object})


28
29
30
# File 'lib/openpgp/engine/gnupg.rb', line 28

def options
  @options
end

- (String) where

Returns:

  • (String)


25
26
27
# File 'lib/openpgp/engine/gnupg.rb', line 25

def where
  @where
end

Class Method Details

+ (Boolean) available?

Returns:

  • (Boolean)


11
12
13
# File 'lib/openpgp/engine/gnupg.rb', line 11

def self.available?
  self.new.available?
end

Instance Method Details

- (Boolean) available?

Determines if GnuPG is available.

Returns:

  • (Boolean)


41
42
43
# File 'lib/openpgp/engine/gnupg.rb', line 41

def available?
  !!version
end

- (Object) clearsign

Makes a clear text OpenPGP signature.



161
162
163
# File 'lib/openpgp/engine/gnupg.rb', line 161

def clearsign()
  # TODO
end

- (String) cmdline(command, options = {}) (protected)

Constructs the GnuPG command-line for use with +exec+.

Parameters:

  • (String) command
  • (Hash{Symbol => Object}) options (defaults to: {})

Returns:

  • (String)


232
233
234
235
236
237
238
239
# File 'lib/openpgp/engine/gnupg.rb', line 232

def cmdline(command, options = {})
  command = [command].flatten
  cmdline = [where]
  cmdline += @options.merge(options).map { |k, v| !v ? nil : "#{option(k)} #{v == true ? '' : v.to_s}".rstrip }.compact
  cmdline << option(command.shift)
  cmdline += command
  cmdline.flatten.join(' ').strip
end

- (String) decrypt(ciphertext, options = {})

Decrypts the given ciphertext using the specified key ID.

Parameters:

  • (String) ciphertext
  • (Hash{Symbol => Object}) options (defaults to: {})

Returns:

  • (String)


141
142
143
# File 'lib/openpgp/engine/gnupg.rb', line 141

def decrypt(ciphertext, options = {})
  # TODO
end

- delete_secret_and_public_key(key_id)

This method returns an undefined value.

Parameters:

  • (String) key_id


100
101
102
103
# File 'lib/openpgp/engine/gnupg.rb', line 100

def delete_secret_and_public_key(key_id)
  opts = {:batch => true}
  OpenPGP::Message.parse(exec([:delete_secret_and_public_key, key_fingerprint(key_id)], opts ).read)
end

- (Object) detach_sign

Makes a detached OpenPGP signature.



167
168
169
# File 'lib/openpgp/engine/gnupg.rb', line 167

def detach_sign()
  # TODO
end

- (String) encrypt(plaintext, options = {})

Encrypts the given plaintext to the specified recipients.

Parameters:

  • (String) plaintext
  • (Hash{Symbol => Object}) options (defaults to: {})

Returns:

  • (String)


131
132
133
# File 'lib/openpgp/engine/gnupg.rb', line 131

def encrypt(plaintext, options = {})
  # TODO
end

- (IO) exec(command, options = {}, &block)

Executes a GnuPG command, yielding the standard input and returning the standard output.

Parameters:

  • (String) command
  • (Hash{Symbol => Object}) options (defaults to: {})

Returns:

  • (IO)


184
185
186
187
188
189
190
191
192
# File 'lib/openpgp/engine/gnupg.rb', line 184

def exec(command, options = {}, &block) #:yields: stdin
  exec4(command, options) do |pid, stdin, stdout, stderr|
    block.call(stdin) if block_given?
    stdin.close_write
    pid, status = Process.waitpid2(pid)
    raise Error, stderr.read.chomp if status.exitstatus.nonzero?
    stdout
  end
end

- (Array(IO, IO, IO)) exec3(command, options = {}, &block)

Executes a GnuPG command, yielding and returning the standard input, output and error.

Parameters:

  • (String) command
  • (Hash{Symbol => Object}) options (defaults to: {})

Returns:

  • (Array(IO, IO, IO))


201
202
203
204
205
206
207
208
209
# File 'lib/openpgp/engine/gnupg.rb', line 201

def exec3(command, options = {}, &block) #:yields: stdin, stdout, stderr
  exec4(command, options) do |pid, stdin, stdout, stderr|
    block.call(stdin, stdout, stderr) if block_given?
    stdin.close_write
    pid, status = Process.waitpid2(pid)
    raise Error, stderr.read.chomp if status.exitstatus.nonzero?
    [stdin, stdout, stderr]
  end
end

- exec4(command, options = {}, &block)

This method returns an undefined value.

Executes a GnuPG command, yielding the process identifier as well as the standard input, output and error.

Parameters:

  • (String) command
  • (Hash{Symbol => Object}) options (defaults to: {})


218
219
220
221
222
# File 'lib/openpgp/engine/gnupg.rb', line 218

def exec4(command, options = {}, &block) #:yields: pid, stdin, stdout, stderr
  require 'rubygems'
  require 'open4'
  block.call(*Open4.popen4(cmdline(command, options)))
end

- (Message) export(key_id = nil, opts = {})

Exports a specified key from the GnuPG keyring.

Parameters:

  • (String) key_id (defaults to: nil)
  • (Hash{Symbol => Object}) options

Returns:



85
86
87
# File 'lib/openpgp/engine/gnupg.rb', line 85

def export(key_id = nil, opts = {})
  OpenPGP::Message.parse(exec([:export, *[key_id].flatten], opts ).read)
end

- (Integer) gen_key(info = {})

Generates a new OpenPGP keypair and stores it GnuPG's keyring.

Parameters:

  • (Hash{Symbol => String}) info (defaults to: {})

Returns:

  • (Integer)


58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
# File 'lib/openpgp/engine/gnupg.rb', line 58

def gen_key(info = {})
  stdin, stdout, stderr = exec3(:gen_key) do |stdin, stdout, stderr|
    stdin.puts "Key-Type: #{info[:key_type]}"           if info[:key_type]
    stdin.puts "Key-Length: #{info[:key_length]}"       if info[:key_length]
    stdin.puts "Subkey-Type: #{info[:subkey_type]}"     if info[:subkey_type]
    stdin.puts "Subkey-Length: #{info[:subkey_length]}" if info[:subkey_length]
    stdin.puts "Name-Real: #{info[:name]}"              if info[:name]
    stdin.puts "Name-Comment: #{info[:comment]}"        if info[:comment]
    stdin.puts "Name-Email: #{info[:email]}"            if info[:email]
    stdin.puts "Expire-Date: #{info[:expire_date]}"     if info[:expire_date]
    stdin.puts "Passphrase: #{info[:passphrase]}"       if info[:passphrase]
    stdin.puts "%commit"
  end
  stderr.each_line do |line|
    if (line = line.chomp) =~ /^gpg: key ([0-9A-F]+) marked as ultimately trusted/
      return $1.to_i(16) # the key ID
    end
  end
  return nil
end

- import

This method returns an undefined value.

Imports a specified keyfile into the GnuPG keyring.



93
94
95
# File 'lib/openpgp/engine/gnupg.rb', line 93

def import()
  # TODO
end

- (String) key_fingerprint(key_id, opts = {})

Parameters:

  • (String) key_id
  • (Hash{Symbol => Object}) options

Returns:

  • (String)


109
110
111
112
113
114
115
# File 'lib/openpgp/engine/gnupg.rb', line 109

def key_fingerprint(key_id, opts = {})
  message = exec([:fingerprint, *[key_id].flatten], opts ).read
  if message =~ /Key fingerprint = (.*)\n/
    return $1.delete(" ")
  end
  nil
end

- (Array) list_keys

Returns an array of key IDs/titles of the keys in the public keyring.

Returns:

  • (Array)


121
122
123
# File 'lib/openpgp/engine/gnupg.rb', line 121

def list_keys()
  # TODO
end

- (String) option(option) (protected)

Translates Ruby symbols into GnuPG option arguments.

Parameters:

  • (String, #to_s) option

Returns:

  • (String)


246
247
248
# File 'lib/openpgp/engine/gnupg.rb', line 246

def option(option)
  "--" << option.to_s.gsub('_', '-')
end

- sign

This method returns an undefined value.

Makes an OpenPGP signature.



149
150
151
# File 'lib/openpgp/engine/gnupg.rb', line 149

def sign()
  # TODO
end

- (Object) sign_file(key_id, file, passphrase)

Makes an OpenPGP signature.



155
156
157
# File 'lib/openpgp/engine/gnupg.rb', line 155

def sign_file(key_id, file, passphrase)
  OpenPGP::Message.parse(exec([:sign, file],{ :local_user => key_id, :passphrase => passphrase}).read)
end

- (Object) verify(key_id, file)

Verifies an OpenPGP signature.



173
174
175
# File 'lib/openpgp/engine/gnupg.rb', line 173

def verify(key_id, file)
  OpenPGP::Message.parse(exec([:verify, file],{ :local_user => key_id}).read)
end

- (String) version

Returns the GnuPG version number.

Returns:

  • (String)


49
50
51
# File 'lib/openpgp/engine/gnupg.rb', line 49

def version
  exec(:version).readline =~ /^gpg \(GnuPG\) (.*)$/ ? $1 : nil
end