memory_io 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 23fd90a4ba0906c5264a4149f8992c1ca22ed251
+  data.tar.gz: d6414406dac7f68362f6d1aafb0d31966f8e21b0
+SHA512:
+  metadata.gz: cc05ccbf5888b182138ff6112f8979e48875a8f3ab68730bf72e3cb5391e9205c32d7494e2d792196eda735eeac7e851e45fadcd54cdf51b9624d779b85e6492
+  data.tar.gz: b7ee99af0626e2486f8fab0da2b3c2bef47d877396a796118fc8ae8b4bfa456df609b0703d4da400b5a147e66a041ae557d69df2212b181f9d073353cf0e4bf6

data/README.md

@@ -0,0 +1,39 @@
+[![Build Status](https://travis-ci.org/david942j/memory_io.svg?branch=master)](https://travis-ci.org/david942j/memory_io)
+[![Gem Version](https://badge.fury.io/rb/memory_io.svg)](https://badge.fury.io/rb/memory_io)
+[![Maintainability](https://api.codeclimate.com/v1/badges/dc8da34c5a8ab0095530/maintainability)](https://codeclimate.com/github/david942j/memory_io/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/dc8da34c5a8ab0095530/test_coverage)](https://codeclimate.com/github/david942j/memory_io/test_coverage)
+[![Inline docs](https://inch-ci.org/github/david942j/memory_io.svg?branch=master)](https://inch-ci.org/github/david942j/memory_io)
+[![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](http://choosealicense.com/licenses/mit/)
+
+# Memory IO
+
+Read/Write complicated structures in memory easily.
+
+## Installation
+
+Available on RubyGems.org!
+
+```bash
+$ gem install memory_io
+```
+
+## Usage
+
+### Read Process's Memory
+```
+require 'memory_io'
+
+process = MemoryIO.attach(`pidof victim`.to_i)
+puts process.read('heap', 4, as: :u64).map { |c| '0x%016x' % c }
+# 0x0000000000000000
+# 0x0000000000000021
+# 0x00000000deadbeef
+# 0x0000000000000000
+#=> nil
+
+process.read('heap+0x10', 4, as: :u8).map { |c| '0x%x' % c }
+#=> ['0xef', '0xbe', '0xad', '0xde']
+
+process.read('libc', 4)
+#=> "\x7fELF"
+```

data/lib/memory_io/io.rb

@@ -0,0 +1,126 @@
+require 'memory_io/types/types'
+
+module MemoryIO
+  # Main class to use {MemoryIO}.
+  class IO
+    attr_reader :stream # @return [#pos=, #read, #write]
+
+    # Instantiate an {IO} object.
+    #
+    # @param [#pos=, #read, #write] stream
+    #   The file-like object to be read/written.
+    #   +file+ can be unwritable if you will not invoke any write-related method.
+    #
+    #   If +stream.read(*)+ returns empty string or +nil+, it would be seen as reaching EOF.
+    def initialize(stream)
+      @stream = stream
+    end
+
+    # Read and convert result into custom type/stucture.
+    #
+    # @param [Integer] num_elements
+    #   Number of elements to be read.
+    #   This parameter must be positive and larger than zero.
+    #
+    #   This parameter may effect the return type,
+    #   see documents of return value.
+    # @param [Integer?] from
+    #   Invoke +stream.pos = from+ before starting to read.
+    #   +nil+ for not changing current position of stream.
+    # @param [nil, Symbol, MemoryIO::Types, Proc] as
+    #   Decide the type/structure when reading.
+    #   See {MemoryIO::Types} for all supported types.
+    #
+    #   A +Proc+ is allowed, which should accept +stream+ as the first argument.
+    #   The return value of the proc would be the return objects of this method.
+    #
+    #   If +nil+ is given, this method returns a string and has same behavior as +::IO#read+.
+    # @param [Boolean] force_array
+    #   When +num_elements+ equals to 1, the read +Object+ would be returned.
+    #   Pass +true+ to this parameter to force this method returning an array.
+    #
+    # @return [String, Object, Array<Object>]
+    #   There're multiple possible return types,
+    #   which dependes on the value of parameter +num_elements+, +as+, and +force_array+.
+    #
+    #   See examples for clear usage. The rule of return type is listed as following:
+    #
+    #   * +as = nil+:
+    #     A +String+ with length +num_elements+ is returned.
+    #   * +as != nil+ and +num_elements = 1+ and +force_array = false+:
+    #     An +Object+ is returned. The type of +Object+ depends on parameter +as+.
+    #   * +as != nil+ and +num_elements = 1+ and +force_array = true+:
+    #     An array with one element is returned.
+    #   * +as != nil+ and +num_elements > 1+:
+    #     An array with length +num_elements+ is returned.
+    #
+    #   If EOF is occured, object(s) read will be returned.
+    #
+    # @example
+    #   stream = StringIO.new('A' * 8 + 'B' * 8)
+    #   io = MemoryIO.new(stream)
+    #   io.read(9)
+    #   #=> "AAAAAAAAB"
+    #   io.read(100)
+    #   #=> "BBBBBBB"
+    #
+    #   # read two unsigned 32-bit integers starts from posistion 4
+    #   io.read(2, from: 4, as: :u32)
+    #   #=> [1094795585, 1111638594] # [0x41414141, 0x42424242]
+    #
+    #   io.read(1, as: :u16)
+    #   #=> 16962 # 0x4242
+    #   io.read(1, as: :u16, force_array: true)
+    #   #=> [16962]
+    # @example
+    #   stream = StringIO.new("\xef\xbe\xad\xde")
+    #   io = MemoryIO.new(stream)
+    #   io.read(1, as: :u32)
+    #   #=> 3735928559
+    #   io.rewind
+    #   io.read(1, as: :s32)
+    #   #=> -559038737
+    # @example
+    #   stream = StringIO.new("123\x0045678\x00")
+    #   io = MemoryIO.new(stream)
+    #   io.read(2, as: :c_str)
+    #   #=> ["123", "45678"]
+    # @example
+    #   # pass lambda to `as`
+    #   stream = StringIO.new("\x03123\x044567")
+    #   io = MemoryIO.new(stream)
+    #   io.read(2, as: lambda { |stream| stream.read(stream.read(1).ord) })
+    #   #=> ["123", "4567"]
+    #
+    # @note
+    #   This method's arguments and return value are different with +::IO#read+.
+    #   Check documents and examples.
+    def read(num_elements, from: nil, as: nil, force_array: false)
+      stream.pos = from if from
+      return stream.read(num_elements) if as.nil?
+      conv = to_proc(as, :read)
+      # TODO: handle eof
+      ret = Array.new(num_elements) { conv.call(stream) }
+      ret = ret.first if num_elements == 1 && !force_array
+      ret
+    end
+
+    # Set +stream+ to the beginning.
+    # i.e. invoke +stream.pos = 0+.
+    #
+    # @return [0]
+    def rewind
+      stream.pos = 0
+    end
+
+    private
+
+    def to_proc(as, rw)
+      ret = as.respond_to?(:call) ? as : MemoryIO::Types.get_proc(as, rw)
+      raise ArgumentError, <<-EOERR.strip unless ret.respond_to?(:call)
+Invalid argument `as`: #{as.inspect}. It should be either a Proc or a supported type of MemoryIO::Types.
+      EOERR
+      ret
+    end
+  end
+end

data/lib/memory_io/process.rb

@@ -0,0 +1,113 @@
+module MemoryIO
+  # Records information of a process.
+  class Process
+    # @api private
+    # @return [#readable?, #writable?]
+    attr_reader :perm
+
+    # @api private
+    #
+    # Create process object from pid.
+    #
+    # @param [Integer] pid
+    #   Process id.
+    #
+    # @note
+    #   This class only supports procfs-based system. i.e. /proc is mounted and readable.
+    #
+    # @todo
+    #   Support MacOS
+    # @todo
+    #   Support Windows
+    def initialize(pid)
+      @pid = pid
+      @mem = "/proc/#{pid}/mem"
+      # check permission of '/proc/pid/mem'
+      @perm = MemoryIO::Util.file_permission(@mem)
+      # TODO: raise custom exception
+      raise Errno::ENOENT, @mem if perm.nil?
+      # FIXME: use logger
+      warn(<<-EOS.strip) unless perm.readable? || perm.writable?
+You have no permission to read/write this process.
+
+Check the setting of /proc/sys/kernel/yama/ptrace_scope, or try
+again as the root user.
+
+To enable attach another process, do:
+
+$ echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope
+      EOS
+    end
+
+    # Parse +/proc/[pid]/maps+ to get all bases.
+    #
+    # @return [{Symbol => Integer}]
+    #   Hash of bases.
+    #
+    # @example
+    #   process = Process.new(`pidof victim`.to_i)
+    #   puts process.bases.map { |key, val| format('%s: 0x%016x', key, val) }
+    #   # vsyscall: 0xffffffffff600000
+    #   # vdso: 0x00007ffd5b565000
+    #   # vvar: 0x00007ffd5b563000
+    #   # stack: 0x00007ffd5ad21000
+    #   # ld: 0x00007f339a69b000
+    #   # libc: 0x00007f33996f1000
+    #   # heap: 0x00005571994a1000
+    #   # victim: 0x0000557198bcb000
+    #   #=> nil
+    def bases
+      file = "/proc/#{@pid}/maps"
+      stat = MemoryIO::Util.file_permission(file)
+      return {} unless stat && stat.readable?
+      maps = ::IO.binread(file).split("\n").map do |line|
+        # 7f76515cf000-7f76515da000 r-xp 00000000 fd:01 29360257  /lib/x86_64-linux-gnu/libnss_files-2.24.so
+        addr, _perm, _offset, _dev, _inode, pathname = line.strip.split(' ', 6)
+        next nil if pathname.nil?
+        addr = addr.to_i(16)
+        pathname = pathname[1..-2] if pathname =~ /^\[.+\]$/
+        pathname = ::File.basename(pathname)
+        [MemoryIO::Util.trim_libname(pathname).to_sym, addr]
+      end
+      maps.compact.reverse.to_h
+    end
+
+    # Read from process's memory.
+    #
+    # This method has *almost* same arguements and return types as {IO#read}.
+    # The only difference is this method needs parameter +addr+ (which
+    # will be passed to paramter +from+ in {IO#reada}).
+    #
+    # @param [Integer, String] addr
+    #   The address start to read.
+    #   When String is given, it will be safe-evaluated.
+    #   You can use variables such as +'heap'/'stack'/'libc'+ in this parameter.
+    #   See examples.
+    # @param [Integer] num_elements
+    #   Number of elements to read. See {IO#read}.
+    #
+    # @return [String, Object, Array<Object>]
+    #   See {IO#read}.
+    #
+    # @example
+    #   process = MemoryIO.attach(`pidof victim`.to_i)
+    #   puts process.read('heap', 4, as: :u64).map { |c| '0x%016x' % c }
+    #   # 0x0000000000000000
+    #   # 0x0000000000000021
+    #   # 0x00000000deadbeef
+    #   # 0x0000000000000000
+    #   #=> nil
+    #   process.read('heap+0x10', 4, as: :u8).map { |c| '0x%x' % c }
+    #   #=> ['0xef', '0xbe', '0xad', '0xde']
+    #
+    #   process.read('libc', 4)
+    #   #=> "\x7fELF"
+    # @see IO#read
+    def read(addr, num_elements, **options)
+      addr = MemoryIO::Util.safe_eval(addr, bases)
+      File.open(@mem, 'rb') do |f|
+        MemoryIO::IO.new(f).read(num_elements, from: addr, **options)
+      end
+    end
+  end
+end

data/lib/memory_io/types/c_str.rb

@@ -0,0 +1,34 @@
+# encoding: ascii-8bit
+
+require 'memory_io/types/type'
+
+module MemoryIO
+  module Types
+    # Read a null-terminated string.
+    class CStr < Types::Type
+      # @api private
+      #
+      # @return [String]
+      #   String without null byte.
+      def self.read(stream)
+        ret = ''
+        loop do
+          c = stream.read(1)
+          break if c.nil? || c == '' || c == "\x00"
+          ret << c
+        end
+        ret
+      end
+
+      # @api private
+      #
+      # @param [String] val
+      #   A null byte would be appended if +val+ not ends with null byte.
+      def self.write(stream, val)
+        val = val.to_s
+        val << "\x00" unless val.end_with?("\x00")
+        stream.write(val)
+      end
+    end
+  end
+end

data/lib/memory_io/types/number.rb

@@ -0,0 +1,60 @@
+require 'memory_io/types/type'
+
+module MemoryIO
+  module Types
+    # @api private
+    # Register numbers to {Types}.
+    #
+    # All types registerd by this class are assumed as *little endian*.
+    class Number
+      # @param [Integer] bytes
+      #   Bytes.
+      # @param [Boolean] signed
+      #   Signed or unsigned.
+      # @param [String] pack_str
+      #   The indicator to be passed to +Array#pack+ and +String#unpack+.
+      def initialize(bytes, signed, pack_str)
+        @bytes = bytes
+        @signed = signed
+        @pack_str = pack_str
+      end
+
+      # @return [Integer]
+      def read(stream)
+        unpack(stream.read(@bytes))
+      end
+
+      # @param [Integer] val
+      def write(stream, val)
+        stream.write(pack(val))
+      end
+
+      private
+
+      def unpack(str)
+        val = str.unpack(@pack_str).first
+        val -= (2**@bytes) if @signed && val >= (2**(@bytes - 1))
+        val
+      end
+
+      def pack(val)
+        [val].pack(@pack_str)
+      end
+
+      # Register (un)signed n-bites integers.
+      {
+        8 => 'C',
+        16 => 'S',
+        32 => 'I',
+        64 => 'Q'
+      }.each do |t, c|
+        Type.register("s#{t}".to_sym, Number.new(t, true, c))
+        Type.register("u#{t}".to_sym, Number.new(t, false, c))
+      end
+
+      # Register floating numbers.
+      Type.register(:float, Number.new(4, false, 'F'))
+      Type.register(:double, Number.new(8, false, 'D'))
+    end
+  end
+end

data/lib/memory_io/types/type.rb

@@ -0,0 +1,37 @@
+module MemoryIO
+  module Types
+    # The base class, all descendents of this class would be consider as a valid 'type'.
+    class Type
+      class << self
+        # Find the subclass of {Type} by symbol.
+        #
+        # @param [Symbol] symbol
+        #   Symbol to be find.
+        #
+        # @return [#read, #write]
+        #   The object that registered in {.register}.
+        def find(symbol)
+          @map[symbol]
+        end
+
+        # @api private
+        #
+        # @param [Symbol] symbol
+        #   Symbol name that used for searching.
+        # @param [#read, #write] klass
+        #   Normally, +klass+ is a descendent of {Type}.
+        #
+        # @return [void]
+        def register(symbol, klass)
+          @map ||= {}
+          @map[symbol] = klass
+        end
+
+        # TO record descendants.
+        def inherited(klass)
+          register(MemoryIO::Util.underscore(klass.name).to_sym, klass)
+        end
+      end
+    end
+  end
+end

data/lib/memory_io/types/types.rb

@@ -0,0 +1,56 @@
+require 'memory_io/types/type'
+require 'memory_io/util'
+
+require 'memory_io/types/c_str'
+require 'memory_io/types/number'
+
+module MemoryIO
+  # Module that includes multiple types.
+  #
+  # Supported types are all descendants of {Types::Type}.
+  module Types
+    module_function
+
+    # @api private
+    #
+    # Returns the class whose name matches +name+.
+    #
+    # This method would search all descendants of {Types::Type}.
+    #
+    # @return [Symbol] name
+    #   Class name to be searched.
+    #
+    # @return [Class?]
+    #   The class.
+    #
+    # @example
+    #   Types.find(:u64)
+    #   #=> MemoryIO::Types::U64
+    #
+    #   Types.find(:c_str)
+    #   #=> MemoryIO::Types::CStr
+    def find(name)
+      Types::Type.find(Util.underscore(name.to_s).to_sym)
+    end
+
+    # Returns a callable object according to +name+.
+    #
+    # @param [Symbol] name
+    #   The name of type.
+    # @param [:read, :write] rw
+    #   Read or write?
+    #
+    # @return [Proc?]
+    #   The proc that accepts +stream+ as the first parameter.
+    #
+    # @example
+    #   Types.get_proc(:c_str, :write)
+    #   #=> #<Method: MemoryIO::Types::CStr.write>
+    #   Types.get_proc(:s32, :read)
+    #   #=> #<Method: MemoryIO::Types::Number#read>
+    def get_proc(name, rw)
+      klass = find(name)
+      klass && klass.method(rw)
+    end
+  end
+end

data/lib/memory_io/util.rb

@@ -0,0 +1,101 @@
+require 'ostruct'
+require 'dentaku'
+
+module MemoryIO
+  # Defines utility methods.
+  module Util
+    module_function
+
+    # Convert input into snake-case.
+    #
+    # This method also removes strings before +'::'+ in +str+.
+    #
+    # @param [String] str
+    #   String to be converted.
+    #
+    # @return [String]
+    #   Converted string.
+    #
+    # @example
+    #   Util.underscore('MemoryIO')
+    #   #=> 'memory_io'
+    #
+    #   Util.underscore('MyModule::MyClass')
+    #   #=> 'my_class'
+    def underscore(str)
+      return '' if str.empty?
+      str = str.split('::').last
+      str.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+      str.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+      str.downcase!
+      str
+    end
+
+    # @api private
+    #
+    # @param [String] file
+    #   File name.
+    #
+    # @return [#readable?, #writable?, nil]
+    #   Struct with two boolean method.
+    #   +nil+ for file not exists or is inaccessible.
+    def file_permission(file)
+      return nil unless File.file?(file)
+      stat = File.stat(file)
+      # we do a trick here because /proc/[pid]/mem might be marked as readable but fails at sysopen.
+      os = OpenStruct.new(readable?: stat.readable_real?, writable?: stat.writable_real?)
+      begin
+        os.readable? && File.open(file, 'rb').close
+      rescue Errno::EACCES
+        os[:readable?] = false
+      end
+      begin
+        os.writable? && File.open(file, 'wb').close
+      rescue Errno::EACCES
+        os[:writable?] = false
+      end
+      os
+    end
+
+    # Evaluate string safely.
+    #
+    # @param [String] str
+    #   String to be evaluated.
+    # @param [{Symbol => Integer}] vars
+    #   Predefined variables
+    #
+    # @return [Integer]
+    #   Result.
+    #
+    # @example
+    #   Util.safe_eval('heap + 0x10 * pp', heap: 0xde00, pp: 8)
+    #   #=> 56960 # 0xde80
+    def safe_eval(str, **vars)
+      return str if str.is_a?(Integer)
+      # dentaku 2 doesn't support hex
+      str = str.gsub(/0x[0-9a-zA-Z]+/) { |c| c.to_i(16) }
+      Dentaku::Calculator.new.store(vars).evaluate(str)
+    end
+
+    # Remove extension name (.so) and version in library name.
+    #
+    # @param [String] name
+    #   Original library filename.
+    #
+    # @return [String]
+    #   Name without version and '.so'.
+    #
+    # @example
+    #   Util.trim_libname('libc-2.24.so')
+    #   #=> 'libc'
+    #   Util.trim_libname('libcrypto.so.1.0.0')
+    #   #=> 'libcrypto'
+    #   Util.trim_libname('not_a_so')
+    #   #=> 'not_a_so'
+    def trim_libname(name)
+      type1 = '(-[\d.]+)?\.so$'
+      type2 = '\.so.\d+[\d.]+$'
+      name.sub(/#{type1}|#{type2}/, '')
+    end
+  end
+end

data/lib/memory_io/version.rb

@@ -0,0 +1,4 @@
+module MemoryIO
+  # Current gem version.
+  VERSION = '0.0.0'.freeze
+end

data/lib/memory_io.rb

@@ -0,0 +1,21 @@
+# MemoryIO - Read/Write structures in memory.
+#
+# @author david942j
+module MemoryIO
+  module_function
+
+  # Get a process by process id.
+  #
+  # @param [Integer] pid
+  #   Process Id in linux.
+  #
+  # @return [MemoryIO::Process]
+  #   A process object for further usage.
+  def attach(pid)
+    MemoryIO::Process.new(pid)
+  end
+end
+
+require 'memory_io/io'
+require 'memory_io/process'
+require 'memory_io/version'

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification
+name: memory_io
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- david942j
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dentaku
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.11
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.11
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.52'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.52'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.0
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: ''
+email:
+- david942j@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/memory_io.rb
+- lib/memory_io/io.rb
+- lib/memory_io/process.rb
+- lib/memory_io/types/c_str.rb
+- lib/memory_io/types/number.rb
+- lib/memory_io/types/type.rb
+- lib/memory_io/types/types.rb
+- lib/memory_io/util.rb
+- lib/memory_io/version.rb
+homepage: https://github.com/david942j/memory_io
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: memory_io
+test_files: []