smart_proxy_openscap 0.7.5 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 00056a49674ba03472d6826481526c4ea1c46de925c815023bfcfd1332c57f78
-  data.tar.gz: 89ce04958b0e9cf5443d26ed135ec4f875d4be78d6c58b422c0ce52e3f96e108
+  metadata.gz: 385df2070cb04d103c5a01adaafe76ad62e2e11d45b0f9dd8cf9b8ee85a398b8
+  data.tar.gz: e715e8f29c68228523b9960a9940941a911cc6d917d9e422e745994c0976f7b6
 SHA512:
-  metadata.gz: cfdb8cbb7f73e95e419fdf6dd3e737242f42ebe9f81d86c3f97ec634a450715718a541ce95096c54b9d625d7bff24a8934fbaf6730c1010ea39926d8b5e79927
-  data.tar.gz: abe8e00cd38c8c422fe05c9c53c19821d9755614698f4741b96ff49d30bd236a3489f76ca55253dd4a5e5297aca9e3db35d22694e981b8e2162c5dc6934d5d5e
+  metadata.gz: 544dfb94c425239d852f31d4e32a840b4fc3bc1891cde91d78b24ca43ae8d17220e79dcd1eba96e1f8a147d368795b3f9da8062eac92c62a3a01608d4d0ce3d2
+  data.tar.gz: ad70eb12bc8f21f208de39af555efb0646fa2e56bd1e20bb193d4fae70be78d56b1862047de183322e63c12bd9a04edc86e4304f5c31257a9c431da59c701a26

data/Gemfile

@@ -4,6 +4,7 @@ gemspec
 group :development do
   gem 'test-unit'
   gem 'pry'
+  gem 'pry-byebug'
   gem 'rubocop'
   gem 'rack', '~> 1.6.8' if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.2')
   gem 'smart_proxy', :github => "theforeman/smart-proxy", :branch => 'develop'

data/lib/smart_proxy_openscap/arf_parser.rb

@@ -1,38 +1,95 @@
-require 'smart_proxy_openscap/shell_wrapper'
+require 'openscap_parser/test_result_file'
+require 'smart_proxy_openscap/openscap_exception'
 
 module Proxy
   module OpenSCAP
-    class ArfParser < ShellWrapper
+    class ArfParser
+      include Proxy::Log
 
       def initialize(cname, policy_id, date)
         @cname = cname
         @policy_id = policy_id
         @date = date
-        @script_name = 'smart-proxy-arf-json'
       end
 
       def as_json(arf_data)
-        execute_shell_command arf_data
-      end
+        begin
+          file = Tempfile.new
+          file.write(arf_data)
+          file.rewind
+          decompressed = `bunzip2 -dc #{file.path}`
+        rescue => e
+          logger.error e
+          raise Proxy::OpenSCAP::ReportDecompressError, "Failed to decompress received report bzip, cause: #{e.message}"
+        ensure
+          file.close
+          file.unlink
+        end
+        arf_file = ::OpenscapParser::TestResultFile.new(decompressed)
+        rules = arf_file.benchmark.rules.reduce({}) do |memo, rule|
+          memo[rule.id] = rule
+          memo
+        end
 
-      def in_filename
-        "#{super}-#{@cname}-#{@policy_id}-#{@date}-"
+        arf_digest = Digest::SHA256.hexdigest(arf_data)
+        report = parse_results(rules, arf_file.test_result, arf_digest)
+        report[:openscap_proxy_name] = Proxy::OpenSCAP::Plugin.settings.registered_proxy_name
+        report[:openscap_proxy_url] = Proxy::OpenSCAP::Plugin.settings.registered_proxy_url
+        report.to_json
       end
 
-      def out_filename
-        "#{in_filename}json-"
+      private
+
+      def parse_results(rules, test_result, arf_digest)
+        results = test_result.rule_results
+        set_values = test_result.set_values
+        report = {}
+        report[:logs] = []
+        passed = 0
+        failed = 0
+        othered = 0
+        results.each do |result|
+          next if result.result == 'notapplicable' || result.result == 'notselected'
+          # get rules and their results
+          rule_data = rules[result.id]
+          report[:logs] << populate_result_data(result.id, result.result, rule_data, set_values)
+          # create metrics for the results
+          case result.result
+            when 'pass', 'fixed'
+              passed += 1
+            when 'fail'
+              failed += 1
+            else
+              othered += 1
+          end
+        end
+        report[:digest]  = arf_digest
+        report[:metrics] = { :passed => passed, :failed => failed, :othered => othered }
+        report[:score] = test_result.score
+        report
       end
 
-      def failure_message
-        "Failure when running script which parses reports"
+      def populate_result_data(result_id, rule_result, rule_data, set_values)
+        log               = {}
+        log[:source]      = result_id
+        log[:result]      = rule_result
+        log[:title]       = rule_data.title
+        log[:description] = rule_data.description
+        log[:rationale]   = rule_data.rationale
+        log[:references]  = rule_data.references.map { |ref| { :href => ref.href, :title => ref.label }}
+        log[:fixes]       = populate_fixes rule_data.fixes, set_values
+        log[:severity]    = rule_data.severity
+        log
       end
 
-      def command(in_file, out_file)
-        "#{script_location} " <<
-        "#{in_file.path} " <<
-        "#{out_file.path} " <<
-        "#{Proxy::OpenSCAP::Plugin.settings.registered_proxy_name} " <<
-        "#{Proxy::OpenSCAP::Plugin.settings.registered_proxy_url}"
+      def populate_fixes(fixes, set_values)
+        fixes.map do |fix|
+          {
+            :id => fix.id,
+            :system => fix.system,
+            :full_text => fix.full_text(set_values)
+          }
+        end
       end
     end
   end

data/lib/smart_proxy_openscap/content_parser.rb

@@ -1,30 +1,24 @@
-require 'smart_proxy_openscap/shell_wrapper'
+require 'openscap_parser/datastream_file'
+require 'openscap_parser/tailoring_file'
 
 module Proxy::OpenSCAP
-  class ContentParser < ShellWrapper
-    def initialize(type)
-      @type = type
-      @script_name = 'smart-proxy-scap-validation'
-    end
-
-    def validate(scap_file)
-      execute_shell_command scap_file
-    end
-
-    def out_filename
-      "#{in_filename}json-"
-    end
-
-    def in_filename
-      "#{super}-#{@type}-validate-"
-    end
-
-    def failure_message
-      "Failure when running script which validates scap files"
-    end
-
-    def command(in_file, out_file)
-      "#{script_location} #{in_file.path} #{out_file.path} #{@type}"
+  class ContentParser
+    def validate(file_type, scap_file)
+      msg = 'Invalid SCAP file type'
+      errors = []
+      file = nil
+      begin
+        case file_type
+        when 'scap_content'
+          file = ::OpenscapParser::DatastreamFile.new(scap_file)
+        when 'tailoring_file'
+          file = ::OpenscapParser::TailoringFile.new(scap_file)
+        end
+        errors << msg unless file.valid?
+      rescue Nokogiri::XML::SyntaxError => e
+        errors << msg
+      end
+      { errors: errors }
     end
   end
 end

data/lib/smart_proxy_openscap/openscap_api.rb

@@ -25,13 +25,6 @@ module Proxy::OpenSCAP
     include ::Proxy::Log
     helpers ::Proxy::Helpers
     authorize_with_ssl_client
-    CLIENT_PATHS = Regexp.compile(%r{^(/arf/\d+|/policies/\d+/content/|/policies/\d+/tailoring/)})
-
-    # authorize via trusted hosts but let client paths in without such authorization
-    before do
-      pass if request.path_info =~ CLIENT_PATHS
-      do_authorize_with_trusted_hosts
-    end
 
     post "/arf/:policy" do
       # first let's verify client's certificate
@@ -52,7 +45,7 @@ module Proxy::OpenSCAP
         logger.error "Failed to save Report in reports directory (#{Proxy::OpenSCAP::Plugin.settings.reportsdir}). Failed with: #{e.message}.
                       Saving file in #{Proxy::OpenSCAP::Plugin.settings.failed_dir}. Please copy manually to #{Proxy::OpenSCAP::Plugin.settings.reportsdir}"
         { :result => 'Storage failure on proxy, see proxy logs for details' }.to_json
-      rescue Proxy::OpenSCAP::OpenSCAPException => e
+      rescue Nokogiri::XML::SyntaxError => e
         error = "Failed to parse Arf Report, moving to #{Proxy::OpenSCAP::Plugin.settings.corrupted_dir}"
         logger.error error
         Proxy::OpenSCAP::StorageFS.new(Proxy::OpenSCAP::Plugin.settings.corrupted_dir, cn, policy, date).store_corrupted(request.body.string)
@@ -65,7 +58,7 @@ module Proxy::OpenSCAP
         { :result => msg }.to_json
       rescue Proxy::OpenSCAP::StoreSpoolError => e
         log_halt 500, e.message
-      rescue Proxy::OpenSCAP::ReportUploadError => e
+      rescue Proxy::OpenSCAP::ReportUploadError, Proxy::OpenSCAP::ReportDecompressError => e
         { :result => e.message }.to_json
       end
     end
@@ -133,7 +126,7 @@ module Proxy::OpenSCAP
 
     post "/scap_content/policies" do
       begin
-        Proxy::OpenSCAP::ProfilesParser.new('scap_content').profiles(request.body.string)
+        Proxy::OpenSCAP::ProfilesParser.new.profiles('scap_content', request.body.string)
       rescue *HTTP_ERRORS => e
         log_halt 500, e.message
       rescue StandardError => e
@@ -143,7 +136,7 @@ module Proxy::OpenSCAP
 
     post "/tailoring_file/profiles" do
       begin
-        Proxy::OpenSCAP::ProfilesParser.new('tailoring_file').profiles(request.body.string)
+        Proxy::OpenSCAP::ProfilesParser.new.profiles('tailoring_file', request.body.string)
       rescue *HTTP_ERRORS => e
         log_halt 500, e.message
       rescue StandardError => e
@@ -183,7 +176,7 @@ module Proxy::OpenSCAP
 
     def validate_scap_file(params)
       begin
-        Proxy::OpenSCAP::ContentParser.new(params[:type]).validate(request.body.string)
+        Proxy::OpenSCAP::ContentParser.new.validate(params[:type], request.body.string).to_json
       rescue *HTTP_ERRORS => e
         log_halt 500, e.message
       rescue StandardError => e

data/lib/smart_proxy_openscap/openscap_exception.rb

@@ -6,4 +6,5 @@ module Proxy::OpenSCAP
   class FileNotFound < StandardError; end
   class StoreCorruptedError < StandardError; end
   class ReportUploadError < StandardError; end
+  class ReportDecompressError < StandardError; end
 end

data/lib/smart_proxy_openscap/profiles_parser.rb

@@ -1,31 +1,30 @@
-require 'smart_proxy_openscap/shell_wrapper'
+require 'openscap_parser/datastream_file'
+require 'openscap_parser/tailoring_file'
 
 module Proxy
   module OpenSCAP
-    class ProfilesParser < ShellWrapper
-      def initialize(type)
-        @type = type
-        @script_name = 'smart-proxy-scap-profiles'
-      end
-
-      def profiles(scap_file)
-        execute_shell_command scap_file
-      end
-
-      def out_filename
-        "#{in_filename}json-"
-      end
-
-      def in_filename
-        "#{super}-#{@type}-profiles-"
-      end
+    class ProfilesParser
+      def profiles(file_type, scap_file)
+        profiles = []
+        error_msg = 'Failed to parse profiles'
+        begin
+          case file_type
+          when 'scap_content'
+            profiles = ::OpenscapParser::DatastreamFile.new(scap_file).benchmark.profiles
+          when 'tailoring_file'
+            profiles = ::OpenscapParser::TailoringFile.new(scap_file).tailoring.profiles
+          else
+            raise OpenSCAPException, "Unknown file type, expected 'scap_content' or 'tailoring_file'"
+          end
+        rescue Nokogiri::XML::SyntaxError
+          raise OpenSCAPException, error_msg
+        end
 
-      def failure_message
-        "Failure when running script which extracts profiles from scap file"
-      end
+        raise OpenSCAPException, error_msg if profiles.empty?
 
-      def command(in_file, out_file)
-        "#{script_location} #{in_file.path} #{out_file.path} #{@type}"
+        result = profiles.reduce({}) do |memo, profile|
+          memo.tap { |acc| acc[profile.id] = profile.title }
+        end.to_json
       end
     end
   end

data/lib/smart_proxy_openscap/spool_forwarder.rb

@@ -55,7 +55,7 @@ module Proxy::OpenSCAP
       post_to_foreman = ForemanForwarder.new.post_arf_report(cname, policy_id, date, data, @loaded_settings.timeout)
       Proxy::OpenSCAP::StorageFS.new(@loaded_settings.reportsdir, cname, post_to_foreman['id'], date).store_archive(data)
       File.delete arf_file_path
-    rescue Proxy::OpenSCAP::OpenSCAPException => e
+    rescue Nokogiri::XML::SyntaxError, Proxy::OpenSCAP::ReportDecompressError => e
       logger.error "Failed to parse Arf Report at #{arf_file_path}, moving to #{@loaded_settings.corrupted_dir}"
 
       Proxy::OpenSCAP::StorageFS.new(@loaded_settings.corrupted_dir, cname, policy_id, date).

data/lib/smart_proxy_openscap/version.rb

@@ -10,6 +10,6 @@
 
 module Proxy
   module OpenSCAP
-    VERSION = '0.7.5'
+    VERSION = '0.8.0'
   end
 end

data/smart_proxy_openscap.gemspec

@@ -14,10 +14,13 @@ Gem::Specification.new do |s|
 
   s.files = `git ls-files`.split("\n") - ['.gitignore']
   s.executables = ['smart-proxy-openscap-send']
+  s.requirements = 'bzip2'
 
   s.add_development_dependency('rake')
   s.add_development_dependency('rack-test')
   s.add_development_dependency('mocha')
   s.add_development_dependency('webmock')
   s.add_dependency 'openscap', '~> 0.4.7'
+
+  s.add_dependency 'openscap_parser', '~> 1.0.1'
 end

data/test/scap_content_parser_api_test.rb

@@ -37,7 +37,7 @@ class ScapContentParserApiTest < Test::Unit::TestCase
 
   def test_invalid_scap_content_policies
     post '/scap_content/policies', '<xml>blah</xml>', 'CONTENT_TYPE' => 'text/xml'
-    assert(last_response.body.include?('Failure when running script which extracts profiles from scap file'))
+    assert(last_response.body.include?('Failed to parse profiles'))
   end
 
   def test_scap_content_validator

data/test/script_class_test.rb

@@ -1,10 +1,6 @@
 require 'test_helper'
 require 'smart_proxy_openscap/arf_html'
-require 'smart_proxy_openscap/arf_json'
 require 'smart_proxy_openscap/policy_guide'
-require 'smart_proxy_openscap/scap_profiles'
-require 'smart_proxy_openscap/arf_json'
-require 'smart_proxy_openscap/scap_validation'
 
 class ScriptClassTest < Test::Unit::TestCase
   def test_arf_generate_html
@@ -15,17 +11,6 @@ class ScriptClassTest < Test::Unit::TestCase
     end
   end
 
-  def test_arf_as_json
-    carry_out do |tmp|
-      Proxy::OpenSCAP::ArfJson.new.as_json("#{Dir.getwd}/test/data/arf_report", tmp.path, 'my-proxy', 'http://test-proxy.org')
-      json = read_json tmp
-      refute_empty json['logs']
-      refute_empty json['metrics']
-      refute_empty json['openscap_proxy_name']
-      refute_empty json['openscap_proxy_url']
-    end
-  end
-
   def test_policy_guide
     carry_out do |tmp|
       profile = "xccdf_org.ssgproject.content_profile_rht-ccp"
@@ -35,49 +20,6 @@ class ScriptClassTest < Test::Unit::TestCase
     end
   end
 
-  def test_scap_file_profiles
-    carry_out do |tmp|
-      Proxy::OpenSCAP::ScapProfiles.new.profiles("#{Dir.getwd}/test/data/ssg-rhel7-ds.xml", tmp.path, 'scap_content')
-      profiles = read_json tmp
-      refute_empty profiles
-      assert profiles["xccdf_org.ssgproject.content_profile_standard"]
-    end
-  end
-
-  def test_tailoring_file_profiles
-    carry_out do |tmp|
-      Proxy::OpenSCAP::ScapProfiles.new.profiles("#{Dir.getwd}/test/data/tailoring.xml", tmp.path, 'tailoring_file')
-      profiles = read_json tmp
-      refute_empty profiles
-      assert profiles["xccdf_org.ssgproject.content_profile_stig-firefox-upstream_customized"]
-    end
-  end
-
-  def test_arf_json
-    carry_out do |tmp|
-      Proxy::OpenSCAP::ArfJson.new.as_json("#{Dir.getwd}/test/data/arf_report", tmp.path, 'my-proxy', 'http://test-proxy.org')
-      json = read_json tmp
-      refute_empty json['logs']
-      refute_empty json['metrics']
-    end
-  end
-
-  def test_scap_content_validation
-    carry_out do |tmp|
-      Proxy::OpenSCAP::ScapValidation.new.validate("#{Dir.getwd}/test/data/ssg-rhel7-ds.xml", tmp.path, 'scap_content')
-      res = read_json tmp
-      assert_empty res['errors']
-    end
-  end
-
-  def test_tailoring_file_validation
-    carry_out do |tmp|
-      Proxy::OpenSCAP::ScapValidation.new.validate("#{Dir.getwd}/test/data/tailoring.xml", tmp.path, 'tailoring_file')
-      res = read_json tmp
-      assert_empty res['errors']
-    end
-  end
-
   private
 
   def carry_out

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smart_proxy_openscap
 version: !ruby/object:Gem::Version
-  version: 0.7.5
+  version: 0.8.0
 platform: ruby
 authors:
 - Šimon Lukašík
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-04-22 00:00:00.000000000 Z
+date: 2021-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -82,6 +82,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.4.7
+- !ruby/object:Gem::Dependency
+  name: openscap_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.1
 description: |-
   A plug-in to the Foreman's smart-proxy which receives
     bzip2ed ARF files and forwards them to the Foreman.
@@ -99,18 +113,14 @@ files:
 - README.md
 - Rakefile
 - bin/smart-proxy-arf-html
-- bin/smart-proxy-arf-json
 - bin/smart-proxy-openscap-send
 - bin/smart-proxy-openscap-send-inner
 - bin/smart-proxy-policy-guide
-- bin/smart-proxy-scap-profiles
-- bin/smart-proxy-scap-validation
 - bundler.d/openscap.rb
 - extra/rubygem-smart_proxy_openscap.spec
 - extra/smart-proxy-openscap-send.cron
 - lib/smart_proxy_openscap.rb
 - lib/smart_proxy_openscap/arf_html.rb
-- lib/smart_proxy_openscap/arf_json.rb
 - lib/smart_proxy_openscap/arf_parser.rb
 - lib/smart_proxy_openscap/content_parser.rb
 - lib/smart_proxy_openscap/fetch_file.rb
@@ -127,8 +137,6 @@ files:
 - lib/smart_proxy_openscap/policy_guide.rb
 - lib/smart_proxy_openscap/policy_parser.rb
 - lib/smart_proxy_openscap/profiles_parser.rb
-- lib/smart_proxy_openscap/scap_profiles.rb
-- lib/smart_proxy_openscap/scap_validation.rb
 - lib/smart_proxy_openscap/shell_wrapper.rb
 - lib/smart_proxy_openscap/spool_forwarder.rb
 - lib/smart_proxy_openscap/storage.rb
@@ -172,7 +180,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-requirements: []
+requirements:
+- bzip2
 rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4

data/bin/smart-proxy-arf-json

@@ -1,7 +0,0 @@
-#!/usr/bin/env ruby
-path = File.join(File.dirname(File.expand_path(__FILE__)), '..', 'lib')
-$:.unshift(path) if File.exist? path
-
-require 'smart_proxy_openscap/arf_json'
-
-Proxy::OpenSCAP::ArfJson.new.as_json ARGV[0], ARGV[1], ARGV[2], ARGV[3]

data/bin/smart-proxy-scap-profiles

@@ -1,7 +0,0 @@
-#!/usr/bin/env ruby
-path = File.join(File.dirname(File.expand_path(__FILE__)), '..', 'lib')
-$:.unshift(path) if File.exist? path
-
-require 'smart_proxy_openscap/scap_profiles'
-
-Proxy::OpenSCAP::ScapProfiles.new.profiles ARGV[0], ARGV[1], ARGV[2]

data/bin/smart-proxy-scap-validation

@@ -1,7 +0,0 @@
-#!/usr/bin/env ruby
-path = File.join(File.dirname(File.expand_path(__FILE__)), '..', 'lib')
-$:.unshift(path) if File.exist? path
-
-require 'smart_proxy_openscap/scap_validation'
-
-Proxy::OpenSCAP::ScapValidation.new.validate ARGV[0], ARGV[1], ARGV[2]

data/lib/smart_proxy_openscap/arf_json.rb

@@ -1,114 +0,0 @@
-# encoding=utf-8
-require 'openscap'
-require 'openscap/ds/arf'
-require 'openscap/xccdf/testresult'
-require 'openscap/xccdf/ruleresult'
-require 'openscap/xccdf/rule'
-require 'openscap/xccdf/fix'
-require 'openscap/xccdf/benchmark'
-require 'json'
-require 'digest'
-
-module Proxy
-  module OpenSCAP
-    class ArfJson
-      def as_json(file_in, file_out, proxy_name, proxy_url)
-        ::OpenSCAP.oscap_init
-        arf_digest   = Digest::SHA256.hexdigest(File.read(file_in))
-
-        arf          = ::OpenSCAP::DS::Arf.new(file_in)
-        test_result  = arf.test_result
-
-        results      = test_result.rr
-        sds          = arf.report_request
-        bench_source = sds.select_checklist!
-        benchmark    = ::OpenSCAP::Xccdf::Benchmark.new(bench_source)
-        items        = benchmark.items
-
-        report = parse_results(items, results, arf_digest)
-        report[:openscap_proxy_name] = proxy_name
-        report[:openscap_proxy_url] = proxy_url
-
-        File.write file_out, report.to_json
-      ensure
-        cleanup test_result, benchmark, sds, arf
-      end
-
-      private
-
-      def parse_results(items, results, arf_digest)
-        report       = {}
-        report[:logs] = []
-        passed        = 0
-        failed        = 0
-        othered         = 0
-        results.each do |rr_id, result|
-          next if result.result == 'notapplicable' || result.result == 'notselected'
-          # get rules and their results
-          rule_data = items[rr_id]
-          report[:logs] << populate_result_data(rr_id, result.result, rule_data)
-          # create metrics for the results
-          case result.result
-            when 'pass', 'fixed'
-              passed += 1
-            when 'fail'
-              failed += 1
-            else
-              othered += 1
-          end
-        end
-        report[:digest]  = arf_digest
-        report[:metrics] = { :passed => passed, :failed => failed, :othered => othered }
-        report
-      end
-
-      def populate_result_data(result_id, rule_result, rule_data)
-        log               = {}
-        log[:source]      = ascii8bit_to_utf8(result_id)
-        log[:result]      = ascii8bit_to_utf8(rule_result)
-        log[:title]       = ascii8bit_to_utf8(rule_data.title)
-        log[:description] = ascii8bit_to_utf8(rule_data.description)
-        log[:rationale]   = ascii8bit_to_utf8(rule_data.rationale)
-        log[:references]  = hash_a8b(rule_data.references.map(&:to_hash))
-        log[:fixes]       = hash_a8b(rule_data.fixes.map(&:to_hash))
-        log[:severity]    = ascii8bit_to_utf8(rule_data.severity)
-        log
-      end
-
-      def cleanup(*args)
-        args.compact.map(&:destroy)
-        ::OpenSCAP.oscap_cleanup
-      end
-
-      # Unfortunately openscap in ruby 1.9.3 outputs data in Ascii-8bit.
-      # We transform it to UTF-8 for easier json integration.
-
-      # :invalid ::
-      #   If the value is invalid, #encode replaces invalid byte sequences in
-      #   +str+ with the replacement character.  The default is to raise the
-      #   Encoding::InvalidByteSequenceError exception
-      # :undef ::
-      #   If the value is undefined, #encode replaces characters which are
-      #   undefined in the destination encoding with the replacement character.
-      #   The default is to raise the Encoding::UndefinedConversionError.
-      # :replace ::
-      #   Sets the replacement string to the given value. The default replacement
-      #   string is "\uFFFD" for Unicode encoding forms, and "?" otherwise.
-      def ascii8bit_to_utf8(string)
-        return ascii8bit_to_utf8_legacy(string) if RUBY_VERSION.start_with? '1.8'
-        string.to_s.encode('utf-8', :invalid => :replace, :undef => :replace, :replace => '_')
-      end
-
-      # String#encode appeared first in 1.9, so we need a workaround for 1.8
-      def ascii8bit_to_utf8_legacy(string)
-        Iconv.conv('UTF-8//IGNORE', 'UTF-8', string.to_s)
-      end
-
-      def hash_a8b(ary)
-        ary.map do |hash|
-          Hash[hash.map { |key, value| [ascii8bit_to_utf8(key), ascii8bit_to_utf8(value)] }]
-        end
-      end
-    end
-  end
-end

data/lib/smart_proxy_openscap/scap_profiles.rb

@@ -1,52 +0,0 @@
-require 'openscap'
-require 'openscap/ds/sds'
-require 'openscap/source'
-require 'openscap/xccdf/benchmark'
-require 'openscap/xccdf/tailoring'
-require 'json'
-
-module Proxy
-  module OpenSCAP
-    class ScapProfiles
-      def profiles(in_file, out_file, type)
-        ::OpenSCAP.oscap_init
-        source = ::OpenSCAP::Source.new(in_file)
-        json = type == 'scap_content' ? scap_content_profiles(source) : tailoring_profiles(source)
-        File.write out_file, json
-      ensure
-        source.destroy if source
-        ::OpenSCAP.oscap_cleanup
-      end
-
-      def scap_content_profiles(source)
-        bench = benchmark_profiles source
-        profiles = collect_profiles bench
-        profiles.to_json
-      ensure
-        bench.destroy if bench
-      end
-
-      def tailoring_profiles(source)
-        tailoring = ::OpenSCAP::Xccdf::Tailoring.new(source, nil)
-        profiles = collect_profiles tailoring
-        profiles.to_json
-      ensure
-        tailoring.destroy if tailoring
-      end
-
-      def collect_profiles(profile_source)
-        profile_source.profiles.inject({}) do |memo, (key, profile)|
-          memo.tap { |hash| hash[key] = profile.title.strip }
-        end
-      end
-
-      def benchmark_profiles(source)
-        sds          = ::OpenSCAP::DS::Sds.new(source)
-        bench_source = sds.select_checklist!
-        ::OpenSCAP::Xccdf::Benchmark.new(bench_source)
-      ensure
-        sds.destroy if sds
-      end
-    end
-  end
-end

data/lib/smart_proxy_openscap/scap_validation.rb

@@ -1,35 +0,0 @@
-require 'json'
-require 'openscap'
-require 'openscap/source'
-
-module Proxy
-  module OpenSCAP
-    class ScapValidation
-      def allowed_types
-        {
-          'tailoring_file' => 'XCCDF Tailoring',
-          'scap_content' => 'SCAP Source Datastream'
-        }
-      end
-
-      def validate(in_file, out_file, type)
-        errors = []
-        ::OpenSCAP.oscap_init
-        source = ::OpenSCAP::Source.new(in_file)
-        if source.type != allowed_types[type]
-          errors << "Uploaded file is #{source.type}, unexpected file type"
-        end
-
-        begin
-          source.validate!
-        rescue ::OpenSCAP::OpenSCAPError
-          errors << "Invalid SCAP file type"
-        end
-        File.write out_file, { :errors => errors }.to_json
-      ensure
-        source.destroy if source
-        ::OpenSCAP.oscap_cleanup
-      end
-    end
-  end
-end