Class: OpenSSL::Config

Inherits:
Object
  • Object
show all
Includes:
Enumerable
Defined in:
lib/openssl/config.rb,
ext/openssl/ossl_config.c

Overview

OpenSSL::Config

Configuration for the openssl library.

Many system’s installation of openssl library will depend on your system configuration. See the value of OpenSSL::Config::DEFAULT_CONFIG_FILE for the location of the file for your host.

See also www.openssl.org/docs/apps/config.html

Constant Summary collapse

DEFAULT_CONFIG_FILE =

The default system configuration file for openssl

rb_str_new2(default_config_file)

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(filename = nil) ⇒ Config

Creates an instance of OpenSSL’s configuration class.

This can be used in contexts like OpenSSL::X509::ExtensionFactory.config=

If the optional filename parameter is provided, then it is read in and parsed via #parse_config.

This can raise IO exceptions based on the access, or availability of the file. A ConfigError exception may be raised depending on the validity of the data being configured.



264
265
266
267
268
269
270
271
272
273
 
# File 'lib/openssl/config.rb', line 264

def initialize(filename = nil)
  @data = {}
  if filename
    File.open(filename.to_s) do |file|
      Config.parse_config(file).each do |section, hash|
        set_section(section, hash)
      end
    end
  end
end

Class Method Details

.get_key_string(data, section, key) ⇒ Object

:nodoc:



61
62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/openssl/config.rb', line 61

def get_key_string(data, section, key) # :nodoc:
  if v = data[section] && data[section][key]
    return v
  elsif section == 'ENV'
    if v = ENV[key]
      return v
    end
  end
  if v = data['default'] && data['default'][key]
    return v
  end
end

.parse(string) ⇒ Object

Parses a given string as a blob that contains configuration for OpenSSL.

If the source of the IO is a file, then consider using #parse_config.



37
38
39
40
41
42
43
 
# File 'lib/openssl/config.rb', line 37

def parse(string)
  c = new()
  parse_config(StringIO.new(string)).each do |section, hash|
    c.set_section(section, hash)
  end
  c
end

.parse_config(io) ⇒ Object

Parses the configuration data read from io, see also #parse.

Raises a ConfigError on invalid configuration data.



53
54
55
56
57
58
59
 
# File 'lib/openssl/config.rb', line 53

def parse_config(io)
  begin
    parse_config_lines(io)
  rescue => error
    raise ConfigError, "error in line #{io.lineno}: " + error.message
  end
end

Instance Method Details

#[](section) ⇒ Object

Get a specific section from the current configuration

Given the following configurating file being loaded:

config = OpenSSL::Config.load('foo.cnf')
  #=> #<OpenSSL::Config sections=["default"]>
puts config.to_s
  #=> [ default ]
  #   foo=bar

You can get a hash of the specific section like so:

config['default']
  #=> {"foo"=>"bar"}



360
361
362
 
# File 'lib/openssl/config.rb', line 360

def [](section)
  @data[section] || {}
end

#[]=(section, pairs) ⇒ Object

*Deprecated in v2.2.0*. This method will be removed in a future release.

Sets a specific section name with a Hash pairs.

Given the following configuration being created:

config = OpenSSL::Config.new
  #=> #<OpenSSL::Config sections=[]>
config['default'] = {"foo"=>"bar","baz"=>"buz"}
  #=> {"foo"=>"bar", "baz"=>"buz"}
puts config.to_s
  #=> [ default ]
  #   foo=bar
  #   baz=buz

It’s important to note that this will essentially merge any of the keys in pairs with the existing section. For example:

config['default']
  #=> {"foo"=>"bar", "baz"=>"buz"}
config['default'] = {"foo" => "changed"}
  #=> {"foo"=>"changed"}
config['default']
  #=> {"foo"=>"changed", "baz"=>"buz"}



399
400
401
402
 
# File 'lib/openssl/config.rb', line 399

def []=(section, pairs)
  check_modify
  set_section(section, pairs)
end

#add_value(section, key, value) ⇒ Object

*Deprecated in v2.2.0*. This method will be removed in a future release.

Set the target key with a given value under a specific section.

Given the following configurating file being loaded:

config = OpenSSL::Config.load('foo.cnf')
  #=> #<OpenSSL::Config sections=["default"]>
puts config.to_s
  #=> [ default ]
  #   foo=bar

You can set the value of foo under the default section to a new value:

config.add_value('default', 'foo', 'buzz')
  #=> "buzz"
puts config.to_s
  #=> [ default ]
  #   foo=buzz



339
340
341
342
 
# File 'lib/openssl/config.rb', line 339

def add_value(section, key, value)
  check_modify
  (@data[section] ||= {})[key] = value
end

#each ⇒ Object

For a block.

Receive the section and its pairs for the current configuration.

config.each do |section, key, value|
  # ...
end



464
465
466
467
468
469
470
 
# File 'lib/openssl/config.rb', line 464

def each
  @data.each do |section, hash|
    hash.each do |key, value|
      yield [section, key, value]
    end
  end
end

#get_value(section, key) ⇒ Object

Gets the value of key from the given section

Given the following configurating file being loaded:

config = OpenSSL::Config.load('foo.cnf')
  #=> #<OpenSSL::Config sections=["default"]>
puts config.to_s
  #=> [ default ]
  #   foo=bar

You can get a specific value from the config if you know the section and key like so:

config.get_value('default','foo')
  #=> "bar"



292
293
294
295
296
297
298
 
# File 'lib/openssl/config.rb', line 292

def get_value(section, key)
  if section.nil?
    raise TypeError.new('nil not allowed')
  end
  section = 'default' if section.empty?
  get_key_string(section, key)
end

#inspect ⇒ Object

String representation of this configuration object, including the class name and its sections.



475
476
477
 
# File 'lib/openssl/config.rb', line 475

def inspect
  "#<#{self.class.name} sections=#{sections.inspect}>"
end

#section(name) ⇒ Object

Deprecated

Use #[] instead



368
369
370
371
 
# File 'lib/openssl/config.rb', line 368

def section(name) # :nodoc:
  warn('Config#section is deprecated; use Config#[]')
  @data[name] || {}
end

#sections ⇒ Object

Get the names of all sections in the current configuration



413
414
415
 
# File 'lib/openssl/config.rb', line 413

def sections
  @data.keys
end

#set_section(section, pairs) ⇒ Object

:nodoc:



404
405
406
407
408
409
 
# File 'lib/openssl/config.rb', line 404

def set_section(section, pairs) # :nodoc:
  hash = @data[section] ||= {}
  pairs.each do |key, value|
    hash[key] = value
  end
end

#to_s ⇒ Object

Get the parsable form of the current configuration

Given the following configuration being created:

config = OpenSSL::Config.new
  #=> #<OpenSSL::Config sections=[]>
config['default'] = {"foo"=>"bar","baz"=>"buz"}
  #=> {"foo"=>"bar", "baz"=>"buz"}
puts config.to_s
  #=> [ default ]
  #   foo=bar
  #   baz=buz

You can parse get the serialized configuration using #to_s and then parse it later:

serialized_config = config.to_s
# much later...
new_config = OpenSSL::Config.parse(serialized_config)
  #=> #<OpenSSL::Config sections=["default"]>
puts new_config
  #=> [ default ]
      foo=bar
      baz=buz



443
444
445
446
447
448
449
450
451
452
453
 
# File 'lib/openssl/config.rb', line 443

def to_s
  ary = []
  @data.keys.sort.each do |section|
    ary << "[ #{section} ]\n"
    @data[section].keys.each do |key|
      ary << "#{key}=#{@data[section][key]}\n"
    end
    ary << "\n"
  end
  ary.join
end

#value(arg1, arg2 = nil) ⇒ Object

Deprecated

Use #get_value instead



305
306
307
308
309
310
311
312
313
314
315
 
# File 'lib/openssl/config.rb', line 305

def value(arg1, arg2 = nil) # :nodoc:
  warn('Config#value is deprecated; use Config#get_value')
  if arg2.nil?
    section, key = 'default', arg1
  else
    section, key = arg1, arg2
  end
  section ||= 'default'
  section = 'default' if section.empty?
  get_key_string(section, key)
end