diff --git a/lib/puppet/module_tool/applications/builder.rb b/lib/puppet/module_tool/applications/builder.rb
index 322020a8b..4fb9f26dc 100644
--- a/lib/puppet/module_tool/applications/builder.rb
+++ b/lib/puppet/module_tool/applications/builder.rb
@@ -1,91 +1,91 @@
 require 'fileutils'
 
 module Puppet::Module::Tool
   module Applications
     class Builder < Application
 
       def initialize(path, options = {})
         @path = File.expand_path(Puppet::Module::Tool.find_module_root(path))
         @pkg_path = File.join(@path, 'pkg')
         super(options)
       end
 
       def run
         load_modulefile!
         create_directory
         copy_contents
         add_metadata
         Puppet.notice "Building #{@path} for release"
         tar
         gzip
         relative = Pathname.new(File.join(@pkg_path, filename('tar.gz'))).relative_path_from(Pathname.new(Dir.pwd))
 
         # Return the Pathname object representing the path to the release
         # archive just created. This return value is used by the module_tool
         # face build action, and displayed to on the console using the to_s
         # method.
         #
         # Example return value:
         #
         #   <Pathname:puppetlabs-apache/pkg/puppetlabs-apache-0.0.1.tar.gz>
         #
         relative
       end
 
       private
 
       def filename(ext)
         ext.sub!(/^\./, '')
         "#{metadata.release_name}.#{ext}"
       end
 
       def tar
         tar_name = filename('tar')
         Dir.chdir(@pkg_path) do
           FileUtils.rm tar_name rescue nil
           unless system "tar -cf #{tar_name} #{metadata.release_name}"
             raise RuntimeError, "Could not create #{tar_name}"
           end
         end
       end
 
       def gzip
         Dir.chdir(@pkg_path) do
           FileUtils.rm filename('tar.gz') rescue nil
           unless system "gzip #{filename('tar')}"
             raise RuntimeError, "Could not compress #{filename('tar')}"
           end
         end
       end
 
       def create_directory
         FileUtils.mkdir(@pkg_path) rescue nil
         if File.directory?(build_path)
-          FileUtils.rm_rf(build_path)
+          FileUtils.rm_rf(build_path, :secure => true)
         end
         FileUtils.mkdir(build_path)
       end
 
       def copy_contents
         Dir[File.join(@path, '*')].each do |path|
           case File.basename(path)
           when *Puppet::Module::Tool::ARTIFACTS
             next
           else
             FileUtils.cp_r path, build_path
           end
         end
       end
 
       def add_metadata
         File.open(File.join(build_path, 'metadata.json'), 'w') do |f|
           f.write(PSON.pretty_generate(metadata))
         end
       end
 
       def build_path
         @build_path ||= File.join(@pkg_path, metadata.release_name)
       end
     end
   end
 end
diff --git a/lib/puppet/module_tool/applications/uninstaller.rb b/lib/puppet/module_tool/applications/uninstaller.rb
index 2ee9b9818..5ffaecd65 100644
--- a/lib/puppet/module_tool/applications/uninstaller.rb
+++ b/lib/puppet/module_tool/applications/uninstaller.rb
@@ -1,107 +1,107 @@
 module Puppet::Module::Tool
   module Applications
     class Uninstaller < Application
       include Puppet::Module::Tool::Errors
 
       def initialize(name, options)
         @name        = name
         @options     = options
         @errors      = Hash.new {|h, k| h[k] = {}}
         @unfiltered  = []
         @installed   = []
         @suggestions = []
         @environment = Puppet::Node::Environment.new(options[:environment])
       end
 
       def run
         results = {
           :module_name       => @name,
           :requested_version => @version,
         }
 
         begin
           find_installed_module
           validate_module
-          FileUtils.rm_rf(@installed.first.path)
+          FileUtils.rm_rf(@installed.first.path, :secure => true)
 
           results[:affected_modules] = @installed
           results[:result] = :success
         rescue ModuleToolError => err
           results[:error] = {
             :oneline   => err.message,
             :multiline => err.multiline,
           }
         rescue => e
           results[:error] = {
             :oneline => e.message,
             :multiline => e.respond_to?(:multiline) ? e.multiline : [e.to_s, e.backtrace].join("\n")
           }
         ensure
           results[:result] ||= :failure
         end
 
         results
       end
 
       private
 
       def find_installed_module
         @environment.modules_by_path.values.flatten.each do |mod|
           mod_name = (mod.forge_name || mod.name).gsub('/', '-')
           if mod_name == @name
             @unfiltered << {
               :name    => mod_name,
               :version => mod.version,
               :path    => mod.modulepath,
             }
             if @options[:version] && mod.version
               next unless SemVer[@options[:version]].include?(SemVer.new(mod.version))
             end
             @installed << mod
           elsif mod_name =~ /#{@name}/
             @suggestions << mod_name
           end
         end
 
         if @installed.length > 1
           raise MultipleInstalledError,
             :action            => :uninstall,
             :module_name       => @name,
             :installed_modules => @installed.sort_by { |mod| @environment.modulepath.index(mod.modulepath) }
         elsif @installed.empty?
           if @unfiltered.empty?
             raise NotInstalledError,
               :action      => :uninstall,
               :suggestions => @suggestions,
               :module_name => @name
           else
             raise NoVersionMatchesError,
               :installed_modules => @unfiltered.sort_by { |mod| @environment.modulepath.index(mod[:path]) },
               :version_range     => @options[:version],
               :module_name       => @name
           end
         end
       end
 
       def validate_module
         mod = @installed.first
 
         if !@options[:force] && mod.has_metadata? && mod.has_local_changes?
           raise LocalChangesError,
             :action            => :uninstall,
             :module_name       => (mod.forge_name || mod.name).gsub('/', '-'),
             :requested_version => @options[:version],
             :installed_version => mod.version
         end
 
         if !@options[:force] && !mod.required_by.empty?
           raise ModuleIsRequiredError,
             :module_name       => (mod.forge_name || mod.name).gsub('/', '-'),
             :required_by       => mod.required_by,
             :requested_version => @options[:version],
             :installed_version => mod.version
         end
       end
     end
   end
 end
diff --git a/lib/puppet/module_tool/applications/unpacker.rb b/lib/puppet/module_tool/applications/unpacker.rb
index f06c62d55..67a76fbcc 100644
--- a/lib/puppet/module_tool/applications/unpacker.rb
+++ b/lib/puppet/module_tool/applications/unpacker.rb
@@ -1,48 +1,48 @@
 require 'pathname'
 require 'tmpdir'
 
 module Puppet::Module::Tool
   module Applications
     class Unpacker < Application
 
       def initialize(filename, options = {})
         @filename = Pathname.new(filename)
         parsed = parse_filename(filename)
         super(options)
         @module_dir = Pathname.new(options[:target_dir]) + parsed[:dir_name]
       end
 
       def run
         extract_module_to_install_dir
 
         # Return the Pathname object representing the directory where the
         # module release archive was unpacked the to, and the module release
         # name.
         @module_dir
       end
 
       private
       def extract_module_to_install_dir
         delete_existing_installation_or_abort!
 
         build_dir = Puppet::Forge::Cache.base_path + "tmp-unpacker-#{Digest::SHA1.hexdigest(@filename.basename.to_s)}"
         build_dir.mkpath
         begin
           unless system "tar xzf #{@filename} -C #{build_dir}"
             raise RuntimeError, "Could not extract contents of module archive."
           end
           # grab the first directory
           extracted = build_dir.children.detect { |c| c.directory? }
           FileUtils.mv extracted, @module_dir
         ensure
           build_dir.rmtree
         end
       end
 
       def delete_existing_installation_or_abort!
         return unless @module_dir.exist?
-        FileUtils.rm_rf @module_dir
+        FileUtils.rm_rf(@module_dir, :secure => true)
       end
     end
   end
 end