net-openvpn 0.3 → 0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 31c5a0e4bcf580d2b27834d191891a01215ac82d
-  data.tar.gz: dc9bcbea63aa3f265560fac744ab085115a1968f
+  metadata.gz: 160d6e02e9cd14fa4f008f6a606ec2108a29cc55
+  data.tar.gz: 6b170ccc82aec4b434f689e65774b45210f77817
 SHA512:
-  metadata.gz: 74270037b4c6b1bf017b85571609861321413f526e8b91677b42451e432ceca2bbc073ea63e196cc9ea04f5c59b9adeb80a59f1d4f5283b3f3644b9e65903185
-  data.tar.gz: 5c69397a66ae1086a7686074f3a19f495f10f366ca604b7059cee9807fdfa78550f277aeb8a3696f64e2e3383141df65d13495209c0f846556886943129858ff
+  metadata.gz: 103124d60d54401a50f90ee13960edaf26b64f416a81f6851d70f0c09736a1849b2bb279ebd92cb8523542e3501d6c491c0135481cf4a534f505e67b48f198ce
+  data.tar.gz: c8b78600a977150ecd8a5376f20d6e8bb32b0c8ba0314831f8403bc68698252f4a9a705ab05eb1d10c71998a32bff90b5ec44fdce56bb4502c0c20920013900c

data/.ruby-gemset

@@ -0,0 +1 @@
+net-openvpn

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.1.2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    net-openvpn (0.3)
+    net-openvpn (0.8)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -2,6 +2,21 @@
 
 Net-Openvpn is a gem for configuring a local OpenVPN installation.
 
+## Requirements
+
+* openvpn
+* easy-rsa
+
+You can install these on Debian based systems by running this command:
+
+```sh
+apt-get install openvpn easy-rsa
+```
+
+Sometimes `easy-rsa` is packaged with `openvpn` so if you can't find the `easy-rsa` package anywhere have a
+look in `/usr/share/doc/openvpn/examples` for the `easy-rsa` folder.  Then you can just globally override 
+the property for `:easy_rsa`  (see below).
+
 ## Usage
 
 ### Server configuration
@@ -52,6 +67,177 @@ host.ip       # what is the ip of this host
 host.network  # what is the network of this host
 ```
 
+## Generating certificates and keys
+
+**WARNING: This functionality is a little bit experimental at the moment, I am sure there are bugs present which would be found with more specs.**
+
+The goal is to build these generators into the Host (read: Client) and Server classes above so you can do something like `server.generate_keys!`.
+
+### Default key properties
+
+You will probably need to set key properties when generating keys.  There are some
+defaults already set and they can be seen by calling `Properties#default` (but are listed here for brevity):
+
+```ruby
+> Net::Openvpn::Generators::Keys::Properties.default
+{
+  :easy_rsa => "/usr/share/easy-rsa", 
+  :openssl => "openssl", 
+  :pkcs11tool => "pkcs11-tool", 
+  :grep => "grep", 
+  :key_dir => "/etc/openvpn/keys",
+  :key_dir_owner => "root",
+  :key_dir_group => "root",
+  :key_dir_permission => "700",
+  :pkcs11_module_path => "changeme", 
+  :pkcs11_pin => 1234, 
+  :key_size => 1024, 
+  :ca_expire => 3650, 
+  :key_expire => 3650, 
+  :key_country => "US", 
+  :key_province => "CA", 
+  :key_city => "SanFrancisco", 
+  :key_org => "Fort-Funston", 
+  :key_email => "me@myhost.mydomain", 
+  :key_cn => "changeme", 
+  :key_name => "changeme", 
+  :key_ou => "changeme", 
+  :key_config => "/usr/share/easy-rsa/openssl-1.0.0.cnf",
+  :key_index => "/etc/openvpn/keys/index.txt"
+}
+```
+
+### Overriding key properties globally
+
+Key properties can be overidden by creating the file: `/etc/openvpn/props.yml`
+
+In this way you can override the default `openssl.cnf` file, the location of your 
+`easy-rsa` folder, key size or any properties listed above!
+
+```yml
+---
+:easy_rsa: /usr/share/doc/openvpn/examples/easy-rsa/2.0
+:key_config: /path/to/openssl.cnf
+:key_dir: /path/to/generated/keys
+```
+
+Properties set in the YAML file will override the default ones.  You can see which properties are specified in the YAML file by checking the `Properties#yaml`.
+
+```ruby
+> Net::Openvpn::Generators::Keys::Properties.default
+{
+  :easy_rsa => "/usr/share/doc/openvpn/examples/easy-rsa/2.0",
+  :key_config => "/path/to/openssl.cnf",
+  :key_dir => "/path/to/generated/keys"
+}
+```
+
+But really you should use `Net::Openvpn#props` to get properties because that will merge the defaults with the properties from the YAML file, the latter overriding keys in the former.
+
+### Overriding key properties at generation time
+
+You can also provide key properties when you do the actual generation of the keys as
+described below.  These properties will override properties set in the YAML file.
+
+These properties can be supplied directly to the `Authority`, `Client`, `Server` and `Directory` classes in the `Generators::Keys` module as arguments to the `new` method:
+
+```ruby
+Net::Openvpn::Generators::Keys::Directory.new key_dir_permission: 0770
+
+Net::Openvpn::Generators::Keys::Authority.new key_size: 8192      # this will take hours lol
+
+Net::Openvpn::Generators::Keys::Client.new(
+  "fred",
+  key_country: "Switzerland",
+  key_province: "Romandy",
+  key_city: "Geneva",
+  key_email: "fred@example.com"
+)
+
+Net::Openvpn::Generators::Keys::Server.new(
+  "norvpn01",
+  key_country: "Norway",
+  key_province: "Ostlandet",
+  key_city: "Oslo",
+  key_email: "admin@example.com"
+)
+```
+
+### Key Directory
+
+To start with the first thing you will need to do is setup the key directory.  This can be done with the following line:
+
+```ruby
+# keys = Net::Openvpn.generator(:directory).new
+key_dir = Net::Openvpn::Generators::Keys::Directory.new 
+key_dir.generate
+key_dir.exist?  # check that it worked
+```
+
+This should generate the following files/folders:
+
+* /etc/openvpn/keys
+* /etc/openvpn/keys/index.txt
+* /etc/openvpn/keys/serial
+
+### Certificate Authority
+
+You will also need to generate the certificate authority and DH key like so.
+
+```ruby
+# keys = Net::Openvpn.generator(:authority).new
+ca = Net::Openvpn::Generators::Keys::Authority.new
+ca.generate
+ca.exist?
+```
+
+This should generate the following files/folders:
+
+* /etc/openvpn/keys
+* /etc/openvpn/keys/ca.crt
+* /etc/openvpn/keys/ca.key
+* /etc/openvpn/keys/dh1024.pem
+
+### Servers
+
+```ruby
+# keys = Net::Openvpn.generator(:server).new("swzvpn04")
+keys = Net::Openvpn::Generators::Keys::Server.new("swzvpn04")
+keys.generate
+keys.exist?  # returns true if the key files exist
+keys.valid?  # returns true if the keys are valid in the index
+```
+
+This should generate the following files/folders:
+
+* /etc/openvpn/keys
+* /etc/openvpn/keys/swzvpn04.key
+* /etc/openvpn/keys/swzvpn04.crt
+
+### Clients
+
+```ruby
+# keys = Net::Openvpn.generator(:client).new("fred")
+keys = Net::Openvpn::Generators::Keys::Client.new("fred")
+keys.generate
+keys.exist?  # returns true if the key files exist
+keys.valid?  # returns true if the keys are valid in the index
+```
+
+This should generate the following files/folders:
+
+* /etc/openvpn/keys
+* /etc/openvpn/keys/fred.key
+* /etc/openvpn/keys/fred.crt
+
+Revoke the keys like so (UNTESTED!):
+
+```ruby
+keys = Net::Openvpn::Generators::Keys::Client.new("fred")
+keys.revoke!
+keys.valid?  # returns false
+```
+
 ## Rails Permissions
 
 If you are running rails and you want to give the rails user access, you could do it like this:
@@ -64,4 +250,12 @@ chmod o-rwx /etc/openvpn -R
 cd /etc/openvpn
 chmod g-rwx easy-rsa *.key *.crt *.pem
 usermod -aG openvpn rails-app-user
+```
+
+Then override the following properties in your `/etc/openvpn/props.yml` file:
+
+```yaml
+---
+:key_dir_group: "openvpn"
+:key_dir_permission: 0700
 ```

data/lib/net/openvpn.rb

@@ -1,8 +1,18 @@
+require 'fileutils'
+
 require 'net/openvpn/server'
 require 'net/openvpn/host'
+require 'net/openvpn/errors'
 require 'net/openvpn/client_config'
 require 'net/openvpn/parser/server_config'
 
+require 'net/openvpn/generators/keys/base'
+require 'net/openvpn/generators/keys/directory'
+require 'net/openvpn/generators/keys/client'
+require 'net/openvpn/generators/keys/server'
+require 'net/openvpn/generators/keys/properties'
+require 'net/openvpn/generators/keys/authority'
+
 module Net
   module Openvpn
     class << self
@@ -25,6 +35,27 @@ module Net
         Net::Openvpn::Server.new(name)
       end
 
+      def generator(type)
+        case type
+        when :client
+          Net::Openvpn::Generators::Keys::Client
+        when :server
+          Net::Openvpn::Generators::Keys::Server
+        when :directory
+          Net::Openvpn::Generators::Keys::Directory
+        when :authority
+          Net::Openvpn::Generators::Keys::Authority
+        end
+      end
+
+      # Returns the default key properties merged with
+      # the properties stored in /etc/openvpn/props.yml
+      def props
+        props = Openvpn::Generators::Keys::Properties
+
+        props.default.merge props.yaml
+      end
+
     end
   end
-end
+end

data/lib/net/openvpn/errors.rb

@@ -0,0 +1,8 @@
+module Net
+  module Openvpn
+    module Errors
+      class KeyGeneration < StandardError; end
+      class CertificateRevocation < StandardError; end
+    end
+  end
+end

data/lib/net/openvpn/generators/keys/authority.rb

@@ -0,0 +1,39 @@
+module Net
+  module Openvpn
+    module Generators
+      module Keys
+        class Authority < Base
+
+          def initialize(**props)
+            super(nil, props)
+          end
+
+          def generate
+            @key_dir.exist? or raise Errors::KeyGeneration, "Key directory has not been generated yet"
+            !exist?         or raise Errors::KeyGeneration, "Authority already exists!"
+
+            FileUtils.cd(@props[:easy_rsa]) do
+              system "#{cli_prop_vars} ./pkitool --initca"
+              system "#{cli_prop_vars} ./build-dh"
+            end
+
+            true
+          end
+
+          def filepaths
+            [
+              "#{@props[:key_dir]}/ca.key",
+              "#{@props[:key_dir]}/ca.crt",
+              "#{@props[:key_dir]}/dh#{@props[:key_size]}.pem"
+            ]
+          end
+
+          def self.exist?
+            Authority.new.exist?
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/net/openvpn/generators/keys/base.rb

@@ -0,0 +1,87 @@
+module Net
+  module Openvpn
+    module Generators
+      module Keys
+        class Base
+          def initialize(name, props)
+            @name = name
+            @props = Openvpn.props.merge props
+            @props[:key_cn] = @name
+            @key_dir = Directory.new(@props)
+
+            Properties.validate! @props
+          end
+
+          def generate
+            raise NotImplementedError
+          end
+
+          # Returns true if all the generated keys exist or false if not
+          def exist?
+            filepaths.each do |file|
+              return false if !File.exist? file
+            end
+            true
+          end
+
+          # Returns true if the generated keys are valid by checking
+          # the key index and then checking the pemfile against the crt
+          # file.
+          def valid?
+            # read the index file
+            m = File.read(Openvpn.props[:key_index]).match /^V.*CN=#{@name}.*$/
+
+            return false if m.nil?
+
+            # get the pem number and build the paths
+            pem = m[0].split("\t")[3]
+            pem_path = "#{Openvpn.props[:key_dir]}/#{pem}.pem"
+            crt_path = "#{Openvpn.props[:key_dir]}/#{@name}.crt"
+
+            # Check the pem against the current cert for the name
+            File.read(pem_path) == File.read(crt_path)
+          end
+
+          # Revokes the keys
+          #
+          # Returns true if the keys were revoked or false if the keys do
+          # not exist or are not valid
+          #
+          # raises `Net::Openvpn::Errors::CertificateRevocation` if the key
+          # failed to be revoked
+          #
+          def revoke!
+            return false unless exist? and valid?
+
+            FileUtils.cd(Openvpn.props[:easy_rsa]) do
+              output = %x[#{cli_prop_vars} ./revoke-full #{@name}]
+              raise Errors::CertificateRevocation, "Revoke command failed" if !output.include? "error 23" # error 23 means key was revoked
+            end
+
+            !valid? or raise Errors::CertificateRevocation, "Certificates were still valid after being revoked"
+
+            true
+          end
+
+          private
+
+          # Generates the variable string of key properties
+          # to preceed easy-rsa script calls
+          #
+          # An example with just two properties:
+          #
+          #     EASY_RSA="/usr/share/easy-rsa" KEY_CN="fred" build-key ...
+          #
+          def cli_prop_vars
+            Properties.to_cli_vars(@props)
+          end
+
+          def filepaths
+            raise NotImplementedError
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/net/openvpn/generators/keys/client.rb

@@ -0,0 +1,45 @@
+module Net
+  module Openvpn
+    module Generators
+      module Keys
+        class Client < Base
+
+          def initialize(name, **props)
+            super(name, props)
+          end
+          
+          # Generates the certificates for a VPN client
+          #
+          # Raises `Net::Openvpn::Errors::KeyGeneration` if there were problems
+          #
+          # Returns true if the generation was successful
+          #
+          def generate
+            @key_dir.exist?  or raise Errors::KeyGeneration, "Key directory has not been generated yet"
+            Authority.exist? or raise Errors::KeyGeneration, "Certificate Authority has not been created"
+
+            revoke! if exist? and valid?
+
+            FileUtils.cd(@props[:easy_rsa]) do
+              system "#{cli_prop_vars} ./pkitool #{@name}"
+            end
+
+            exist? or raise Errors::KeyGeneration, "Keys do not exist"
+            valid? or raise Errors::KeyGeneration, "keys are not valid"
+
+            true
+          end
+
+          # Returns an array containing the paths to the generated keys
+          def filepaths
+            [
+              "#{@props[:key_dir]}/#{@name}.key",
+              "#{@props[:key_dir]}/#{@name}.crt"
+            ]
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/net/openvpn/generators/keys/directory.rb

@@ -0,0 +1,47 @@
+module Net
+  module Openvpn
+    module Generators
+      module Keys
+        class Directory
+
+          def initialize(**props)
+            @props = Openvpn.props.merge props
+          end
+
+          def exist?
+            File.directory?(@props[:key_dir]) and
+            File.exist?(@props[:key_index]) and
+            File.exist?("#{@props[:key_dir]}/serial")
+          end
+
+          # Sets up the directory where keys are to be generated.
+          # Also creates the serial and index.txt used by the pkitool
+          # that comes with easy-rsa
+          def generate
+
+            FileUtils.mkdir_p @props[:key_dir] unless
+              File.directory? @props[:key_dir]
+
+            FileUtils.cd(@props[:key_dir]) do
+              FileUtils.touch @props[:key_index]
+              File.open("serial", "w") {|f| f.write "01" }
+            end
+
+            FileUtils.chown_R(
+              @props[:key_dir_owner],
+              @props[:key_dir_group],
+              @props[:key_dir]
+            )
+
+            FileUtils.chmod_R(
+              @props[:key_dir_permission],
+              @props[:key_dir]
+            )
+
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/net/openvpn/generators/keys/properties.rb

@@ -0,0 +1,73 @@
+module Net
+  module Openvpn
+    module Generators
+      module Keys
+        module Properties
+          class << self
+
+            # Returns the properties loaded from a YAML file
+            # located in /etc/openvpn/props.yml
+            def yaml
+              return {} unless File.exist? Openvpn.basepath "props.yml"
+              YAML.load(File.read(Openvpn.basepath "props.yml"))
+            end
+
+            # Returns the default set of properties as per the easy-rsa
+            # 'vars' script
+            def default
+              props = {
+                easy_rsa: "/usr/share/easy-rsa",
+                openssl: "openssl",
+                pkcs11tool: "pkcs11-tool",
+                grep: "grep",
+                key_dir: "#{Openvpn.basepath}/keys",
+                key_dir_owner: "root",
+                key_dir_group: "root",
+                key_dir_permission: 0700,
+                pkcs11_module_path: "dummy",
+                pkcs11_pin: "dummy",
+                key_size: 1024,
+                ca_expire: 3650,
+                key_expire: 3650,
+                key_country: "US",
+                key_province: "CA",
+                key_city: "SanFrancisco",
+                key_org: "Fort-Funston",
+                key_email: "me@myhost.mydomain",
+                key_cn: "changeme",
+                key_name: "changeme",
+                key_ou: "changeme",
+                pkcs11_module_path: "changeme",
+                pkcs11_pin: 1234
+              }
+
+              props[:key_config] = "#{props[:easy_rsa]}/openssl-1.0.0.cnf"
+              props[:key_index]  = "#{props[:key_dir]}/index.txt"
+
+              props
+            end
+
+            alias_method :defaults, :default # POLS
+
+            # Ensures that all the required properties are available to
+            # stop the easy-rsa scripts having a cry
+            def validate!(props)
+
+            end
+
+            # Creates a list of variables to preceed a bash command
+            def to_cli_vars(props)
+              string = ""
+              props.each do |key, value|
+                prop = key.to_s.upcase
+                string+= "#{prop}=\"#{value}\" "
+              end
+              "export #{string}; "
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

data/lib/net/openvpn/generators/keys/server.rb

@@ -0,0 +1,37 @@
+module Net
+  module Openvpn
+    module Generators
+      module Keys
+        class Server < Base
+
+          def initialize(name, **props)
+            super(name, props)
+          end
+
+          def generate
+            @key_dir.exist?  or raise Errors::KeyGeneration, "Key directory has not been generated yet"
+            Authority.exist? or raise Errors::KeyGeneration, "Certificate Authority has not been created"
+            
+            revoke! if exist? and valid?
+
+            FileUtils.cd(@props[:easy_rsa]) do
+              system "#{cli_prop_vars} ./pkitool --server #{@name}"
+            end
+
+            exist? or raise Openvpn::Errors::KeyGeneration, "Keys do not exist"
+            valid? or raise Openvpn::Errors::KeyGeneration, "keys are not valid"
+
+          end
+
+          def filepaths
+            [
+              "#{@props[:key_dir]}/#{@name}.key",
+              "#{@props[:key_dir]}/#{@name}.crt"
+            ]
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/net/openvpn/version.rb

@@ -1,5 +1,5 @@
 module Net
   module Openvpn
-    VERSION = "0.3"
+    VERSION = "0.8"
   end
 end

data/spec/lib/net/openvpn/generators/keys/client_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe Net::Openvpn::Generators::Keys::Client do
+  subject(:client) { Net::Openvpn::Generators::Keys::Client.new(name, props) }
+  let(:directory)  { Net::Openvpn::Generators::Keys::Directory.new }
+  let(:authority)  { Net::Openvpn::Generators::Keys::Authority }
+  let(:name)       { "test" }
+  let(:props)      { {} }
+
+  before(:each) { setup_filesystem(:tmp) }
+  after(:each)  { destroy_filesystem(:tmp) }
+
+  context "when a client has not been generated" do
+    it "should not exist" do
+      expect(client).to_not exist
+    end 
+  end
+
+  context "when the key directory has not been generated" do
+
+    it "should raise an error" do
+      expect { client.generate }.to raise_error(
+        Net::Openvpn::Errors::KeyGeneration,
+        "Key directory has not been generated yet"
+      )
+    end
+
+  end
+
+  context "when the key directory has been generated" do
+    before(:each) { directory.generate }
+
+    context "and the authority has not been generated" do
+      before(:each) { expect(authority).to_not exist }
+
+      it "should raise an error" do
+        expect { client.generate }.to raise_error(
+          Net::Openvpn::Errors::KeyGeneration,
+          "Certificate Authority has not been created"
+        )
+      end
+    end
+
+    context "and the authority has been generated" do
+      before(:each) do
+        authority.new.generate
+        expect(authority).to exist
+      end
+
+      context "and the client has not been generated" do
+        it "should not exist" do
+          expect(client).to_not exist
+        end
+
+        it "should not be valid" do
+          expect(client).to_not be_valid
+        end
+      end
+
+      context "and the client has been generated" do
+        before(:each) do
+          client.generate
+        end
+
+        it "should exist" do
+          expect(client).to exist
+        end
+
+        it "should be valid" do
+          expect(client).to be_valid
+        end
+      end
+    end
+
+  end
+end

data/spec/lib/net/openvpn/generators/keys/directory_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Net::Openvpn::Generators::Keys::Directory, fakefs: true do
+  subject(:dir) { Net::Openvpn::Generators::Keys::Directory.new(props) }
+  let(:props)   { {} }
+
+  before(:each) { setup_filesystem(:fake) }
+
+  it "should exist after generation" do
+    dir.generate
+    expect(dir).to exist
+  end
+
+  it "should create the key dir folder" do
+    dir.generate
+    expect(File.exist? "/etc/openvpn/keys").to be_true
+  end
+
+  context "when the key dir property is changed" do
+    let(:props) { { key_dir: "/etc/openvpn/my_keys", key_index: "/etc/openvpn/my_keys/index.txt" } }
+    it "should create the key dir folder" do
+      dir.generate
+      expect(File.exist? "/etc/openvpn/my_keys").to be_true
+    end
+  end
+
+end

data/spec/lib/net/openvpn/generators/keys/properties_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Net::Openvpn::Generators::Keys::Properties, fakefs: true do
+  subject(:properties) { Net::Openvpn::Generators::Keys::Properties }
+  subject(:defaults)   { properties.defaults }
+  subject(:yaml)       { properties.yaml }
+
+  context "when there is no props.yml file" do
+    it "should have key size of 1024 from defaults" do
+      expect(defaults[:key_size]).to eq 1024
+    end
+
+    it "should have empty hash from yaml" do
+      expect(yaml).to be_empty
+    end
+  end
+
+  context "when there is a props.yml file" do
+    before(:each) { setup_filesystem(:fake) }
+
+    it "should have key size of 384 from yaml" do
+      expect(yaml[:key_size]).to eq 384
+    end
+
+    it "should have key size of 1024 from defaults" do
+      expect(defaults[:key_size]).to eq 1024
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,44 @@
 require 'net/openvpn'
 require 'fakefs/spec_helpers'
+require 'yaml'
 
 RSpec.configure do |config|
   config.include FakeFS::SpecHelpers, fakefs: true
+end
+
+def setup_overrides(path)
+
+  overrides = {
+    key_dir_owner: ENV["USER"],
+    key_dir_group: ENV["USER"],
+    key_permission: 0770,
+    key_size: 384 # tiny key to speed up the tests
+  }
+
+  File.open("#{path}/props.yml", "w") { |f| f.write overrides.to_yaml }
+
+end
+
+def stub_basepath
+  Net::Openvpn.stub(:basepath) do |path|
+    path = "/#{path}" unless path.nil?
+    "/tmp/openvpn#{path}"
+  end
+end
+
+def setup_filesystem(type)
+  case type
+  when :fake
+    FakeFS::FileSystem.clone "/usr/share/easy-rsa"
+    FileUtils.mkdir_p "/etc/openvpn"
+    setup_overrides "/etc/openvpn"
+  when :tmp
+    FileUtils.mkdir_p "/tmp/openvpn"
+    setup_overrides "/tmp/openvpn"
+    stub_basepath
+  end
+end
+
+def destroy_filesystem(type)
+  FileUtils.rm_rf "/tmp/openvpn"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: net-openvpn
 version: !ruby/object:Gem::Version
-  version: '0.3'
+  version: '0.8'
 platform: ruby
 authors:
 - Robert McLeod
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-22 00:00:00.000000000 Z
+date: 2014-06-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -88,17 +88,29 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
 - Gemfile
 - Gemfile.lock
 - README.md
 - Rakefile
 - lib/net/openvpn.rb
 - lib/net/openvpn/client_config.rb
+- lib/net/openvpn/errors.rb
+- lib/net/openvpn/generators/keys/authority.rb
+- lib/net/openvpn/generators/keys/base.rb
+- lib/net/openvpn/generators/keys/client.rb
+- lib/net/openvpn/generators/keys/directory.rb
+- lib/net/openvpn/generators/keys/properties.rb
+- lib/net/openvpn/generators/keys/server.rb
 - lib/net/openvpn/host.rb
 - lib/net/openvpn/parser/server_config.rb
 - lib/net/openvpn/server.rb
 - lib/net/openvpn/version.rb
 - net-openvpn.gemspec
+- spec/lib/net/openvpn/generators/keys/client_spec.rb
+- spec/lib/net/openvpn/generators/keys/directory_spec.rb
+- spec/lib/net/openvpn/generators/keys/properties_spec.rb
 - spec/lib/net/openvpn/host_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/penguinpowernz/net-openvpn