clambytoo 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 522d95e9b100b7fa407904af1d747054b3977f8eab68193a207fc3f0196fa663
+  data.tar.gz: b5b98d1e4342a98632afeae44beb5f0499a999e8b1ac430ec621ad43034b96a1
+SHA512:
+  metadata.gz: 304daa2134c849ec2ee89aa4b0e0d9905d43d0ec877577d9e42f358c7c5690fef482dd66b1a5cdaf68d4a5d915bd656b3e10bdc60b74fc47c7d0ebb762cb6fb0
+  data.tar.gz: ebe2655c8dbd1e96d3d7d8374dfdf298bfdd43aae81e89ebffb6e63ffccf10adffd37c2b08764d0f83c6ae487e1a63068297669c3115cd5e9818f1d9457dde9d

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in clamby.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 kobaltz
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new
+
+task :default => :spec

data/clambytoo.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'clambytoo/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "clambytoo"
+  spec.version       = Clambytoo::VERSION
+  spec.authors       = ["kobaltz"]
+  spec.email         = ["dave@k-innovations.net"]
+  spec.summary       = "Scan file uploads with ClamAV"
+  spec.description   = "This is a temp fork for testing purposes only. Clamby allows users to scan files uploaded with Paperclip or Carrierwave. If a file has a virus, then you can delete this file and discard it without causing harm to other users."
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/clambytoo/command.rb

@@ -0,0 +1,121 @@
+module Clambytoo
+  # Interface with the system. Builds and runs the command.
+  class Command
+    EXECUTABLES = %w(clamscan clamdscan freshclam)
+
+    # Array containing the complete command line.
+    attr_accessor :command
+
+    # Returns the appropriate scan executable, based on clamd being used.
+    def self.scan_executable
+      return 'clamdscan' if Clambytoo.config[:daemonize]
+      return 'clamscan'
+    end
+
+    # Perform a ClamAV scan on the given path.
+    def self.scan(path)
+      return nil unless file_exists?(path)
+
+      args = [Shellwords.escape(path), '--no-summary']
+
+      if Clambytoo.config[:daemonize]
+        args << '--fdpass' if Clambytoo.config[:fdpass]
+        args << '--stream' if Clambytoo.config[:stream]
+      end
+
+      args << "-d #{Clambytoo.config[:datadir]}" if Clambytoo.config[:datadir]
+
+      new.run scan_executable, *args
+
+
+      # $CHILD_STATUS maybe nil if the execution itself (not the client process)
+      # fails
+      case $CHILD_STATUS && $CHILD_STATUS.exitstatus
+      when 0
+        return false
+      when nil, 2
+        # clamdscan returns 2 whenever error other than a detection happens
+        if Clambytoo.config[:error_clamscan_client_error] && Clambytoo.config[:daemonize]
+          raise Clambytoo::ClamscanClientError.new("Clamscan client error")
+        end
+
+        # returns true to maintain legacy behavior
+        return true
+      else
+        return true unless Clambytoo.config[:error_file_virus]
+
+        raise Clambytoo::VirusDetected.new("VIRUS DETECTED on #{Time.now}: #{path}")
+      end
+    end
+
+    # Update the virus definitions.
+    def self.freshclam
+      args = []
+      args << "--datadir=#{Clambytoo.config[:datadir]}" if Clambytoo.config[:datadir]
+      new.run 'freshclam', *args
+    end
+
+    # Show the ClamAV version. Also acts as a quick check if ClamAV functions.
+    def self.clamscan_version
+      new.run scan_executable, '--version'
+    end
+
+    # Run the given commands via a system call.
+    # The executable must be one of the permitted ClamAV executables.
+    # The arguments will be combined with default arguments if needed.
+    # The arguments are sorted alphabetically before being passed to the system.
+    #
+    # Examples:
+    #   run('clamscan', file, '--verbose')
+    #   run('clamscan', '-V')
+    def run(executable, *args)
+      executable_full = executable_path(executable)
+      self.command = args | default_args
+      self.command = command.sort.unshift(executable_full)
+      if caller_locations(1,1)[0].label == "clamscan_version"
+        Open3.popen3(self.command.join(' ')) do |stdin, stdout, stderr, wait_thr|
+          exit_status = wait_thr.value
+          return true if exit_status.success? && stderr.gets.nil?
+          return nil unless stderr.gets.nil?  #if we have any kind of error executing a command we should return nil
+        end
+      else
+        system(self.command.join(' '), system_options)
+      end
+    end
+
+    private
+
+    def default_args
+      args = []
+      args << "--config-file=#{Clambytoo.config[:config_file]}" if Clambytoo.config[:daemonize] && Clambytoo.config[:config_file]
+      args << '--quiet' if Clambytoo.config[:output_level] == 'low'
+      args << '--verbose' if Clambytoo.config[:output_level] == 'high'
+      args
+    end
+
+    # This applies to the `system` call itself; does not end up in the command.
+    def system_options
+      if Clambytoo.config[:output_level] == 'off'
+        { out: File::NULL }
+      else
+        {}
+      end
+    end
+
+    def executable_path(executable)
+      raise "`#{executable}` is not permitted" unless EXECUTABLES.include?(executable)
+      Clambytoo.config[:"executable_path_#{executable}"]
+    end
+
+    def self.file_exists?(path)
+      return true if File.file?(path)
+
+      if Clambytoo.config[:error_file_missing]
+        raise Clambytoo::FileNotFound.new("File not found: #{path}")
+      else
+        puts "FILE NOT FOUND on #{Time.now}: #{path}"
+        return false
+      end
+    end
+  end
+end

data/lib/clambytoo/error.rb

@@ -0,0 +1,8 @@
+module Clambytoo
+  class Error < StandardError; end
+
+  class VirusDetected < Error; end
+  class ClamscanMissing < Error; end
+  class ClamscanClientError < Error; end
+  class FileNotFound < Error; end
+end

data/lib/clambytoo/version.rb

@@ -0,0 +1,3 @@
+module Clambytoo
+  VERSION = "1.0.0"
+end

data/lib/clambytoo.rb

@@ -0,0 +1,67 @@
+require "English"
+require 'open3'
+require "clambytoo/command"
+require "clambytoo/error"
+require "clambytoo/version"
+
+module Clambytoo
+  DEFAULT_CONFIG = {
+    :check => true,
+    :daemonize => false,
+    :config_file => nil,
+    :error_clamscan_client_error => false,
+    :error_file_missing => true,
+    :error_file_virus => false,
+    :fdpass => false,
+    :stream => false,
+    :output_level => 'medium',
+    :datadir => nil,
+    :executable_path_clamscan => 'clamscan',
+    :executable_path_clamdscan => 'clamdscan',
+    :executable_path_freshclam => 'freshclam',
+  }.freeze
+
+  @config = DEFAULT_CONFIG.dup
+
+  @valid_config_keys = @config.keys
+
+  class << self
+    attr_reader :config
+    attr_reader :valid_config_keys
+  end
+
+  def self.configure(opts = {})
+    if opts.delete(:silence_output)
+      warn ':silence_output config is deprecated. Use :output_level => "off" instead.'
+      opts[:output_level] = 'off'
+    end
+
+    opts.each {|k,v| config[k.to_sym] = v if valid_config_keys.include? k.to_sym}
+  end
+
+  def self.safe?(path)
+    value = virus?(path)
+    return nil if value.nil?
+    ! value
+  end
+
+  def self.virus?(path)
+    return nil unless scanner_exists?
+    Command.scan path
+  end
+
+  def self.scanner_exists?
+    return true unless config[:check]
+    scanner = Command.clamscan_version
+
+    return scanner ? true : false
+  end
+
+  def self.update
+    Command.freshclam
+  end
+
+  def self.daemonize?
+    !! config[:daemonize]
+  end
+end

data/spec/clamby/command_spec.rb

@@ -0,0 +1,165 @@
+require 'spec_helper'
+require 'support/shared_context'
+
+describe Clambytoo::Command do
+  before { Clambytoo.configure(Clambytoo::DEFAULT_CONFIG.dup) }
+
+  describe 'ClamAV version' do
+    it 'returns true' do
+      command = described_class.clamscan_version
+      expect(command).to be true
+    end
+  end
+
+  describe 'scan' do
+    include_context 'paths'
+
+    let(:runner){ instance_double(described_class) }
+
+    describe 'exceptions' do
+      it "can be configured to raise exception when file is missing" do
+        Clambytoo.configure({:error_file_missing => true})
+
+        expect do
+          described_class.scan(bad_path)
+        end.to raise_exception(Clambytoo::FileNotFound)
+      end
+      it 'can be configured to return nil when file is missing' do
+        Clambytoo.configure({:error_file_missing => false})
+        command = described_class.scan(bad_path)
+
+        expect(command).to be(nil)
+      end
+    end
+
+    describe 'passing file descriptor' do
+      it 'does not include fdpass in the command by default' do
+        Clambytoo.configure
+        expect(runner).to receive(:run).with('clamscan', good_path, '--no-summary')
+        allow(described_class).to receive(:new).and_return(runner)
+
+        described_class.scan(good_path)
+      end
+
+      it 'omits the fdpass option when invoking clamscan if it is set, but daemonize isn\'t' do
+        Clambytoo.configure(fdpass: true)
+        expect(runner).to receive(:run).with('clamscan', good_path, '--no-summary')
+        allow(described_class).to receive(:new).and_return(runner)
+
+        described_class.scan(good_path)
+      end
+
+      it 'passes the fdpass option when invoking clamscan if it is set with daemonize' do
+        Clambytoo.configure(fdpass: true, daemonize: true)
+        expect(runner).to receive(:run).with('clamdscan', good_path, '--no-summary', '--fdpass')
+        allow(described_class).to receive(:new).and_return(runner)
+
+        described_class.scan(good_path)
+      end
+    end
+
+    describe 'streaming files to clamd' do
+      it 'does not include stream in the command by default' do
+        Clambytoo.configure
+        expect(runner).to receive(:run).with('clamscan', good_path, '--no-summary')
+        allow(described_class).to receive(:new).and_return(runner)
+
+        described_class.scan(good_path)
+      end
+
+      it 'omits the stream option when invoking clamscan if it is set, but daemonize isn\'t' do
+        Clambytoo.configure(stream: true)
+        expect(runner).to receive(:run).with('clamscan', good_path, '--no-summary')
+        allow(described_class).to receive(:new).and_return(runner)
+
+        described_class.scan(good_path)
+      end
+
+      it 'passes the stream option when invoking clamscan if it is set with daemonize' do
+        Clambytoo.configure(stream: true, daemonize: true)
+        expect(runner).to receive(:run).with('clamdscan', good_path, '--no-summary', '--stream')
+        allow(described_class).to receive(:new).and_return(runner)
+
+        described_class.scan(good_path)
+      end
+    end
+
+    describe 'specifying config-file' do
+      it 'does not include the parameter in the clamscan command by default' do
+        Clambytoo.configure
+
+        expect(described_class.new.send(:default_args)).not_to include(a_string_matching(/--config-file/))
+      end
+      it 'does not include the parameter in the clamdscan command by default' do
+        Clambytoo.configure(daemonize: true)
+
+        expect(described_class.new.send(:default_args)).not_to include(a_string_matching(/--config-file/))
+      end
+      it 'omits the parameter when invoking clamscan if it is set' do
+        Clambytoo.configure(daemonize: false, config_file: 'clamd.conf')
+
+        expect(described_class.new.send(:default_args)).not_to include('--config-file=clamd.conf')
+      end
+      it 'passes the parameter when invoking clamdscan if it is set' do
+        Clambytoo.configure(daemonize: true, config_file: 'clamd.conf')
+
+        expect(described_class.new.send(:default_args)).to include('--config-file=clamd.conf')
+      end
+    end
+
+    describe 'specifying custom executable paths' do
+      let(:runner) { described_class.new }
+      let(:custom_path) { '/custom/path' }
+
+      before do
+        Clambytoo.configure(
+          executable_path_clamscan: "#{custom_path}/clamscan",
+          executable_path_clamdscan: "#{custom_path}/clamdscan",
+          executable_path_freshclam: "#{custom_path}/freshclam",
+        )
+        allow(described_class).to receive(:new).and_return(runner)
+      end
+
+      it 'executes the freshclam executable from the custom path' do
+        expect(runner).to receive(:system).with(
+          "#{custom_path}/freshclam",
+          {}
+        ) { system("exit 0", out: File::NULL) }
+
+        described_class.freshclam
+      end
+
+      context 'when not set with daemonize' do
+        before { Clambytoo.configure(daemonize: false) }
+
+        it 'executes the clamscan executable from the custom path' do
+          expect(runner).to receive(:system).with(
+            "#{custom_path}/clamscan --no-summary #{good_path}",
+            {}
+          ) { system("exit 0", out: File::NULL) }
+
+          described_class.scan(good_path)
+        end
+      end
+
+      context 'when set with daemonize' do
+        before { Clambytoo.configure(daemonize: true) }
+
+        it 'executes the clamdscan executable from the custom path' do
+          expect(runner).to receive(:system).with(
+            "#{custom_path}/clamdscan --no-summary #{good_path}",
+            {}
+          ) { system("exit 0", out: File::NULL) }
+
+          described_class.scan(good_path)
+        end
+      end
+    end
+
+    describe 'special filenames' do
+      it 'does not fail' do
+        expect(described_class.scan(special_path)).to be(false)
+      end
+    end
+  end
+end

data/spec/clamby_spec.rb

@@ -0,0 +1,145 @@
+require 'spec_helper'
+require 'support/shared_context'
+
+describe Clambytoo do
+  include_context 'paths'
+
+  before { Clambytoo.configure(Clambytoo::DEFAULT_CONFIG.dup) }
+
+  it "should find clamscan" do
+    expect(Clambytoo.scanner_exists?).to be true
+  end
+
+  it "should scan file as safe" do
+    expect(Clambytoo.safe?(good_path)).to be true
+    expect(Clambytoo.virus?(good_path)).to be false
+  end
+
+  it "should scan file and return nil" do
+    Clambytoo.configure({:error_file_missing => false})
+    expect(Clambytoo.safe?(bad_path)).to be nil
+    expect(Clambytoo.virus?(bad_path)).to be nil
+  end
+
+  it "should scan file as dangerous" do
+    begin
+      file = download('https://secure.eicar.org/eicar.com')
+    rescue SocketError => error
+      pending("Skipped because reasons: #{error}")
+    end
+
+    dangerous = file.path
+    Clambytoo.configure({:error_file_virus => true})
+    expect{Clambytoo.safe?(dangerous)}.to raise_exception(Clambytoo::VirusDetected)
+    expect{Clambytoo.virus?(dangerous)}.to raise_exception(Clambytoo::VirusDetected)
+    Clambytoo.configure({:error_file_virus => false})
+    expect(Clambytoo.safe?(dangerous)).to be false
+    expect(Clambytoo.virus?(dangerous)).to be true
+    File.delete(dangerous)
+  end
+
+  # From the clamscan man page:
+  # Pass the file descriptor permissions to clamd. This is useful if clamd is
+  # running as a different user as it is faster than streaming the file to
+  # clamd. Only available if connected to clamd via local(unix) socket.
+  context 'fdpass option' do
+    it 'is false by default' do
+      expect(Clambytoo.config[:fdpass]).to eq false
+    end
+    it 'accepts an fdpass option in the config' do
+      Clambytoo.configure(fdpass: true)
+      expect(Clambytoo.config[:fdpass]).to eq true
+    end
+  end
+
+  # From the clamscan man page:
+  # Forces file streaming to clamd. This is generally not needed as clamdscan
+  # detects automatically if streaming is required. This option only exists for
+  # debugging and testing purposes, in all other cases --fdpass is preferred.
+  context 'stream option' do
+    it 'is false by default' do
+      expect(Clambytoo.config[:stream]).to eq false
+    end
+    it 'accepts an stream option in the config' do
+      Clambytoo.configure(stream: true)
+      expect(Clambytoo.config[:stream]).to eq true
+    end
+  end
+
+  context 'error_clamscan_client_error option' do
+    it 'is false by default' do
+      expect(Clambytoo.config[:error_clamscan_client_error]).to eq false
+    end
+    it 'accepts an error_clamscan_client_error option in the config' do
+      Clambytoo.configure(error_clamscan_client_error: true)
+      expect(Clambytoo.config[:error_clamscan_client_error]).to eq true
+    end
+
+    before {
+      Clambytoo.configure(check: false)
+      allow_any_instance_of(Process::Status).to receive(:exitstatus).and_return(2)
+      allow(Clambytoo).to receive(:system)
+    }
+
+    context 'when false' do
+      before { Clambytoo.configure(error_clamscan_client_error: false) }
+
+      it 'virus? returns true when the daemonized client exits with status 2' do
+        Clambytoo.configure(daemonize: true)
+        expect(Clambytoo.virus?(good_path)).to eq true
+      end
+      it 'returns true when the client exits with status 2' do
+        Clambytoo.configure(daemonize: false)
+        expect(Clambytoo.virus?(good_path)).to eq true
+      end
+    end
+
+    context 'when true' do
+      before { Clambytoo.configure(error_clamscan_client_error: true) }
+
+      it 'virus? raises when the daemonized client exits with status 2' do
+        Clambytoo.configure(daemonize: true)
+        expect { Clambytoo.virus?(good_path) }.to raise_error(Clambytoo::ClamscanClientError)
+      end
+      it 'returns true when the client exits with status 2' do
+        Clambytoo.configure(daemonize: false)
+        expect(Clambytoo.virus?(good_path)).to eq true
+      end
+    end
+  end
+
+  context 'executable paths' do
+    context 'executable_path_clamscan option' do
+      it 'is clamscan by default' do
+        expect(Clambytoo.config[:executable_path_clamscan]).to eq 'clamscan'
+      end
+      it 'accepts an executable_path_clamscan option in the config' do
+        path = '/custom/path/clamscan'
+        Clambytoo.configure(executable_path_clamscan: path)
+        expect(Clambytoo.config[:executable_path_clamscan]).to eq path
+      end
+    end
+
+    context 'executable_path_clamdscan option' do
+      it 'is clamdscan by default' do
+        expect(Clambytoo.config[:executable_path_clamdscan]).to eq 'clamdscan'
+      end
+      it 'accepts an executable_path_clamdscan option in the config' do
+        path = '/custom/path/clamdscan'
+        Clambytoo.configure(executable_path_clamdscan: path)
+        expect(Clambytoo.config[:executable_path_clamdscan]).to eq path
+      end
+    end
+
+    context 'executable_path_freshclam option' do
+      it 'is freshclam by default' do
+        expect(Clambytoo.config[:executable_path_freshclam]).to eq 'freshclam'
+      end
+      it 'accepts an executable_path_freshclam option in the config' do
+        path = '/custom/path/freshclam'
+        Clambytoo.configure(executable_path_freshclam: path)
+        expect(Clambytoo.config[:executable_path_freshclam]).to eq path
+      end
+    end
+  end
+end

data/spec/fixtures/safe (special).txt

@@ -0,0 +1,2 @@
+This is a virus-free file.
+It is used by automated tests.

data/spec/fixtures/safe.txt

@@ -0,0 +1,2 @@
+This is a virus-free file.
+It is used by automated tests.

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'open-uri'
+require 'tempfile'
+
+require 'clamby' # and any other gems you need
+
+RSpec.configure do |config|
+  config.mock_with :rspec do |mocks|
+    # so that Command can keep doing what it always does.
+    mocks.verify_partial_doubles = true
+  end
+
+  def download(url)
+    file = open(url)
+    file.is_a?(StringIO) ? to_tempfile(file) : file
+  end
+
+  # OpenURI returns either Tempfile or StringIO depending of the size of
+  # the response. We want to unify this and always return Tempfile.
+  def to_tempfile(io)
+    tempfile = Tempfile.new('tmp')
+    tempfile.binmode
+    ::OpenURI::Meta.init(tempfile, io)
+    tempfile << io.string
+    tempfile.rewind
+    tempfile
+  end
+end

data/spec/support/shared_context.rb

@@ -0,0 +1,5 @@
+RSpec.shared_context 'paths' do
+  let(:special_path) { File.expand_path('../../fixtures/safe (special).txt', __FILE__) }
+  let(:good_path) { File.expand_path('../../fixtures/safe.txt', __FILE__) }
+  let(:bad_path) { File.expand_path("not-here/#{rand 10e6}.txt", __FILE__) }
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: clambytoo
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- kobaltz
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-09-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This is a temp fork for testing purposes only. Clamby allows users to
+  scan files uploaded with Paperclip or Carrierwave. If a file has a virus, then you
+  can delete this file and discard it without causing harm to other users.
+email:
+- dave@k-innovations.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE.txt
+- Rakefile
+- clambytoo.gemspec
+- lib/clambytoo.rb
+- lib/clambytoo/command.rb
+- lib/clambytoo/error.rb
+- lib/clambytoo/version.rb
+- spec/.DS_Store
+- spec/clamby/command_spec.rb
+- spec/clamby_spec.rb
+- spec/fixtures/safe (special).txt
+- spec/fixtures/safe.txt
+- spec/spec_helper.rb
+- spec/support/shared_context.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.9
+signing_key:
+specification_version: 4
+summary: Scan file uploads with ClamAV
+test_files:
+- spec/.DS_Store
+- spec/clamby/command_spec.rb
+- spec/clamby_spec.rb
+- spec/fixtures/safe (special).txt
+- spec/fixtures/safe.txt
+- spec/spec_helper.rb
+- spec/support/shared_context.rb